const Kernel = require('./kernel.js') const Scheduler = require('./scheduler.js') const DFSchecker = require('./dfsChecker.js') const CreationService = require('./creationService.js') const CREATION_ID = 0 module.exports = class Hypervisor { /** * The Hypervisor manages the container instances by instantiating them and * destorying them when possible. It also facilitates localating Containers * @param {Graph} dag an instance of [ipfs.dag](https://github.com/ipfs/interface-ipfs-core/tree/master/API/dag#dag-api) * @param {object} state - the starting state */ constructor (tree) { this.tree = tree this.scheduler = new Scheduler() this._containerTypes = {} this._nodesToCheck = new Set() this.creationService = new CreationService({ hypervisor: this }) this.scheduler.systemServices.set(CREATION_ID, this.creationService) this.pinnedIds = new Set() } /** * add a potaintail node in the state graph to check for garbage collection * @param {string} id */ addNodeToCheck (id) { this._nodesToCheck.add(id) } /** * given a port, this finds the corridsponeding endpoint port of the channel * @param {object} port * @returns {Promise} */ async getDestPort (port) { if (port.destPort) { return port.destPort } else { const instance = await this.scheduler.getInstance(port.destId) let containerState if (instance) { containerState = instance.state } else { containerState = await this.tree.get(port.destId, true) } return this.tree.graph.get(containerState, `ports/${port.destName}`) } } async send (port, message) { const id = port.destId if (id !== undefined) { const instance = await this.getInstance(id) return instance.queue(port, message) } else { // port is unbound port.destPort.messages.push(message) } } // loads an instance of a container from the state async _loadInstance (id, state) { if (!state) { state = await this.tree.get(id, true) } const container = this._containerTypes[state.type] // create a new kernel instance const kernel = new Kernel({ hypervisor: this, state: state, code: state.code, container: container, id: id }) // save the newly created instance this.scheduler.update(kernel) return kernel } /** * gets an existsing container instances * @param {string} id - the containers ID * @returns {Promise} */ async getInstance (id) { let instance = this.scheduler.getInstance(id) if (instance) { return instance } else { const resolve = this.scheduler.lock(id) const instance = await this._loadInstance(id) await instance.startup() resolve(instance) return instance } } createChannel () { const port1 = { messages: [] } const port2 = { messages: [], destPort: port1 } port1.destPort = port2 return [port1, port2] } /** * creates a state root starting from a given container and a given number of * ticks * @param {Number} ticks the number of ticks at which to create the state root * @returns {Promise} */ async createStateRoot (ticks) { await this.scheduler.wait(ticks) const unlinked = await DFSchecker(this.tree, this._nodesToCheck, (id) => { return this.pinnedIds.has(id) }) for (const id of unlinked) { await this.tree.delete(id) } return this.tree.flush() } /** * regirsters a container with the hypervisor * @param {Class} Constructor - a Class for instantiating the container * @param {*} args - any args that the contructor takes * @param {interger} typeId - the container's type identification ID */ registerContainer (Constructor, args, typeId = Constructor.typeId) { this._containerTypes[typeId] = { Constructor: Constructor, args: args } } pin (instance) { this.pinnedIds.add(instance.id) } }