ultravisor 1.0.0 → 1.0.2

package/source/cli/commands/Ultravisor-Command-UpdateTask.cjs

@@ -0,0 +1,91 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+const libFS = require('fs');
+const libPath = require('path');
+
+class UltravisorCommandAddTask extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'updatetask';
+		this.options.Description = 'Update (or add) a task to the available tasks.';
+
+		this.options.CommandOptions.push({ Name:'-f, --file [json_filepath]', Description:'JSON Task definition file path.', Default:false });
+
+		this.options.CommandOptions.push({ Name:'-g, --guid [task_guid]', Description:'The guid for the task.', Default:false });
+		this.options.CommandOptions.push({ Name:'-c, --code [task_code]', Description:'The code for the task.', Default:false });
+		this.options.CommandOptions.push({ Name:'-n, --name [task_name]', Description:'The name of the task.', Default:false });
+
+		this.options.CommandOptions.push({ Name:'-t, --type [task_type]', Description:'The type of task.', Default:'CRON' });
+		this.options.CommandOptions.push({ Name:'-p, --parameters [task_parameters]', Description:'The parameters of the task.', Default:'0 0 * * * *' });
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		const tmpOperationState = {};
+
+		tmpOperationState.JSONFile = false;
+
+		if (this.CommandOptions.json_filepath)
+		{
+			tmpOperationState.TaskDefinition_JSONFilePathRaw = this.CommandOptions.json_filepath;
+			tmpOperationState.TaskDefinition_JSONFilePath = libPath.resolve(tmpOperationState.TaskDefinition_JSONFilePathRaw);
+
+			if (!libFS.existsSync(tmpOperationState.TaskDefinition_JSONFilePath))
+			{
+				tmpOperationState.TaskDefinition_JSONFilePath = libPath.resolve(process.cwd(), tmpOperationState.TaskDefinition_JSONFilePathRaw);
+
+				if (!libFS.existsSync(tmpOperationState.TaskDefinition_JSONFilePath))
+				{
+					return fCallback(new Error(`The specified task definition JSON file could not be found at either path: ${tmpOperationState.TaskDefinition_JSONFilePathRaw} or ${tmpOperationState.TaskDefinition_JSONFilePath}`));
+				}
+			}
+			if (tmpOperationState.TaskDefinition_JSONFilePath && (tmpOperationState.TaskDefinition_JSONFilePath.length > 0))
+			{
+				try
+				{
+					const tmpFileContents = libFS.readFileSync(tmpOperationState.TaskDefinition_JSONFilePath, 'utf8');
+					tmpOperationState.JSONFile = JSON.parse(tmpFileContents);
+				}
+				catch(pError)
+				{
+					return fCallback(new Error(`The specified task definition JSON file could not be read or parsed: ${pError.message}`));
+				}
+			}
+		}
+		else
+		{
+			tmpOperationState.JSONFile = {};
+		}
+
+		tmpOperationState.TaskDefinition_Parameterized = {};
+
+		tmpOperationState.TaskDefinition_Parameterized.GUIDTask = this.CommandOptions.guid;
+		tmpOperationState.TaskDefinition_Parameterized.Code = this.CommandOptions.code;
+		tmpOperationState.TaskDefinition_Parameterized.Name = this.CommandOptions.name;
+
+		tmpOperationState.TaskDefinition_Parameterized.Type = this.CommandOptions.type;
+		tmpOperationState.TaskDefinition_Parameterized.Parameters = this.CommandOptions.parameters;
+
+		tmpOperationState.TaskDefinition = Object.assign({}, tmpOperationState.TaskDefinition_Parameterized, tmpOperationState.JSONFile);
+
+		this.fable['Ultravisor-Hypervisor-State'].updateTask(tmpOperationState.TaskDefinition,
+			function (pError, pUpdatedTask)
+			{
+				if (pError)
+				{
+					return fCallback(new Error(`Could not update task: ${pError.message}`));
+				}
+
+				console.log(`Task with GUID ${pUpdatedTask.GUIDTask} updated successfully.`);
+
+				return fCallback();
+			}.bind(this));
+	}
+}
+
+module.exports = UltravisorCommandAddTask;

package/source/config/Ultravisor-Default-Command-Configuration.cjs

@@ -1,5 +1,10 @@
 module.exports = (
 	{
 		"UltravisorAPIServerPort": 54321,
-		"UltravisorFileStorePath": `${process.cwd()}/dist/ultravisor_datastore`
+		"UltravisorFileStorePath": `${process.cwd()}/dist/ultravisor_datastore`,
+		"UltravisorStagingRoot": `${process.cwd()}/dist/ultravisor_staging`,
+		"UltravisorTickIntervalMilliseconds": 60000,
+		"UltravisorCommandTimeoutMilliseconds": 300000,
+		"UltravisorCommandMaxBufferBytes": 10485760,
+		"UltravisorWebInterfacePath": false
 	});

package/source/services/Ultravisor-Hypervisor-Event-Base.cjs

@@ -5,7 +5,24 @@ class UltravisorEventBase extends libPictService
 	constructor(pPict, pOptions, pServiceHash)
 	{
 		super(pPict, pOptions, pServiceHash);
+
+		this._Active = false;
+	}
+
+	start(pScheduleEntry, fOnTick)
+	{
+		this._Active = true;
+	}
+
+	stop()
+	{
+		this._Active = false;
+	}
+
+	get active()
+	{
+		return this._Active;
 	}
 }
 
-module.exports = UltravisorEventBase;
+module.exports = UltravisorEventBase;

package/source/services/Ultravisor-Hypervisor-State.cjs

@@ -0,0 +1,213 @@
+const libPictService = require(`pict-serviceproviderbase`);
+
+const libFS = require('fs');
+const libPath = require('path');
+
+class UltravisorHypervisorState extends libPictService
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+
+		this._Tasks = {};
+		this._Operations = {};
+
+		this._ConfigurationOutcome = this.fable.gatherProgramConfiguration(false);
+
+		// Load tasks and operations from the gathered configuration
+		let tmpConfig = this.fable.ProgramConfiguration || {};
+
+		if (tmpConfig.Tasks && typeof(tmpConfig.Tasks) === 'object')
+		{
+			let tmpTaskKeys = Object.keys(tmpConfig.Tasks);
+			for (let i = 0; i < tmpTaskKeys.length; i++)
+			{
+				this._Tasks[tmpTaskKeys[i]] = tmpConfig.Tasks[tmpTaskKeys[i]];
+			}
+		}
+
+		if (tmpConfig.Operations && typeof(tmpConfig.Operations) === 'object')
+		{
+			let tmpOperationKeys = Object.keys(tmpConfig.Operations);
+			for (let i = 0; i < tmpOperationKeys.length; i++)
+			{
+				this._Operations[tmpOperationKeys[i]] = tmpConfig.Operations[tmpOperationKeys[i]];
+			}
+		}
+	}
+
+	persistState()
+	{
+		// Check the _ConfigurationOutcome to see where we should be persisting state
+		let tmpFinalGatherPhasePath = false;
+		for (let i = 0; i < this._ConfigurationOutcome.GatherPhases.length; i++)
+		{
+			let tmpGatherPhase = this._ConfigurationOutcome.GatherPhases[i];
+			if ((tmpGatherPhase.Phase != 'Default Program Configuration') && (tmpGatherPhase.Path))
+			{
+				tmpFinalGatherPhasePath = tmpGatherPhase.Path;
+			}
+		}
+
+		if (!tmpFinalGatherPhasePath && this.fable.settings.ProgramConfigurationFileName)
+		{
+			tmpFinalGatherPhasePath = libPath.resolve(process.cwd(), this.fable.settings.ProgramConfigurationFileName);
+			this.pict.log.warn(`Ultravisor Hypervisor State: persistState could not determine a valid configuration path to persist state to;.`);
+		}
+		else if (!tmpFinalGatherPhasePath)
+		{
+			this.pict.log.error(`Ultravisor Hypervisor State: persistState could not determine a valid configuration path to persist state to; state will not be saved.`);
+			return;
+		}
+
+		// Now merge all the data
+		const tmpStateToPersist = this._ConfigurationOutcome.ConfigurationOutcome;
+
+		// Merge in Tasks
+		if (!tmpStateToPersist.hasOwnProperty('Tasks'))
+		{
+			tmpStateToPersist.Tasks = {};
+		}
+		const tmpTaskKeys = Object.keys(this._Tasks);
+		for (let i=0; i<tmpTaskKeys.length; i++)
+		{
+			if (tmpStateToPersist.Tasks.hasOwnProperty(tmpTaskKeys[i]))
+			{
+				tmpStateToPersist.Tasks[tmpTaskKeys[i]] = Object.assign({}, tmpStateToPersist.Tasks[tmpTaskKeys[i]], this._Tasks[tmpTaskKeys[i]]);
+			}
+			else
+			{
+				tmpStateToPersist.Tasks[tmpTaskKeys[i]] = this._Tasks[tmpTaskKeys[i]];
+			}
+		}
+
+		if (!tmpStateToPersist.hasOwnProperty('Operations'))
+		{
+			tmpStateToPersist.Operations = {};
+		}
+		const tmpOperationKeys = Object.keys(this._Operations);
+		for (let i=0; i<tmpOperationKeys.length; i++)
+		{
+			if (tmpStateToPersist.Operations.hasOwnProperty(tmpOperationKeys[i]))
+			{
+				tmpStateToPersist.Operations[tmpOperationKeys[i]] = Object.assign({}, tmpStateToPersist.Operations[tmpOperationKeys[i]], this._Operations[tmpOperationKeys[i]]);
+			}
+			else
+			{
+				tmpStateToPersist.Operations[tmpOperationKeys[i]] = this._Operations[tmpOperationKeys[i]];
+			}
+		}
+
+		this.fable.log.info(`Ultravisor Hypervisor State: persisting hypervisor state to ${tmpFinalGatherPhasePath}.`);
+
+		try
+		{
+			libFS.writeFileSync(tmpFinalGatherPhasePath, JSON.stringify(tmpStateToPersist, null, 4), 'utf8');
+		}
+		catch(pError)
+		{
+			this.fable.log.error(`Ultravisor Hypervisor State: an error occurred while attempting to persist hypervisor state to ${tmpFinalGatherPhasePath}: ${pError.message}`);
+			return false;
+		}
+
+		return true
+	}
+
+
+	updateOperation(pOperation, fCallback)
+	{
+		if (typeof(pOperation) !== 'object' || pOperation === null)
+		{
+			return fCallback(new Error(`Ultravisor Hypervisor State: updateOperation requires a valid operation object.`));
+		}
+		if (!pOperation.hasOwnProperty('GUIDOperation') || typeof(pOperation.GUIDOperation) !== 'string' || pOperation.GUIDOperation.length === 0)
+		{
+			return fCallback(new Error(`Ultravisor Hypervisor State: updateOperation requires the operation object to have a GUIDOperation property.`));
+		}
+
+		if (this._Operations.hasOwnProperty(pOperation.GUIDOperation))
+		{
+			// Update the existing operation
+			this._Operations[pOperation.GUIDOperation] = Object.assign(this._Operations[pOperation.GUIDOperation], pOperation);
+		}
+		else
+		{
+			// Add a new operation
+			this._Operations[pOperation.GUIDOperation] = pOperation;
+		}
+
+		this.persistState();
+
+		return fCallback(null, this._Operations[pOperation.GUIDOperation]);
+	}
+
+	getOperationList(pFilters, fCallback)
+	{
+		const tmpOperationKeys = Object.keys(this._Operations);
+		const tmpOperations = [];
+		for (let i=0; i<tmpOperationKeys.length; i++)
+		{
+			tmpOperations.push(this._Operations[tmpOperationKeys[i]]);
+		}
+		return fCallback(null, tmpOperations);
+	}
+
+	getOperation(pGUIDOperation, fCallback)
+	{
+		if (!this._Operations.hasOwnProperty(pGUIDOperation))
+		{
+			return fCallback(new Error(`Ultravisor Hypervisor State: getOperation could not find operation with GUID ${pGUIDOperation}.`));
+		}
+		return fCallback(null, this._Operations[pGUIDOperation]);
+	}
+
+
+	updateTask(pTask, fCallback)
+	{
+		if (typeof(pTask) !== 'object' || pTask === null)
+		{
+			return fCallback(new Error(`Ultravisor Hypervisor State: updateTask requires a valid task object.`));
+		}
+		if (!pTask.hasOwnProperty('GUIDTask') || typeof(pTask.GUIDTask) !== 'string' || pTask.GUIDTask.length === 0)
+		{
+			return fCallback(new Error(`Ultravisor Hypervisor State: updateTask requires the task object to have a GUIDTask property.`));
+		}
+
+		if (this._Tasks.hasOwnProperty(pTask.GUIDTask))
+		{
+			// Update the existing task
+			this._Tasks[pTask.GUIDTask] = Object.assign(this._Tasks[pTask.GUIDTask], pTask);
+		}
+		else
+		{
+			// Add a new task
+			this._Tasks[pTask.GUIDTask] = pTask;
+		}
+
+		this.persistState();
+
+		return fCallback(null, this._Tasks[pTask.GUIDTask]);
+	}
+
+	getTaskList(pFilters, fCallback)
+	{
+		const tmpTaskKeys = Object.keys(this._Tasks);
+		const tmpTasks = [];
+		for (let i=0; i<tmpTaskKeys.length; i++)
+		{
+			tmpTasks.push(this._Tasks[tmpTaskKeys[i]]);
+		}
+		return fCallback(null, tmpTasks);
+	}
+
+	getTask(pGUIDTask, fCallback)
+	{
+		if (!this._Tasks.hasOwnProperty(pGUIDTask))
+		{
+			return fCallback(new Error(`Ultravisor Hypervisor State: getTask could not find task with GUID ${pGUIDTask}.`));
+		}
+		return fCallback(null, this._Tasks[pGUIDTask]);
+	}
+}
+
+module.exports = UltravisorHypervisorState;

package/source/services/Ultravisor-Hypervisor.cjs

@@ -1,11 +1,235 @@
 const libPictService = require(`pict-serviceproviderbase`);
 
+const libCron = require('cron');
+
 class UltravisorHypervisor extends libPictService
 {
 	constructor(pPict, pOptions, pServiceHash)
 	{
 		super(pPict, pOptions, pServiceHash);
+
+		this.CronJob = libCron.CronJob;
+
+		this._Schedule = [];
+		this._Running = false;
+	}
+
+	get schedule()
+	{
+		return this.getSchedule();
+	}
+
+	getSchedule()
+	{
+		return this._Schedule;
+	}
+
+	/**
+	 * Add a task to the schedule.
+	 *
+	 * @param {string} pTaskGUID - The task GUID to schedule.
+	 * @param {string} pType - Schedule type (cron, daily, hourly).
+	 * @param {string} pParameters - Schedule parameters (e.g. cron expression).
+	 * @param {function} fCallback - Callback.
+	 */
+	scheduleTask(pTaskGUID, pType, pParameters, fCallback)
+	{
+		let tmpScheduleEntry = {
+			GUID: `sched-task-${pTaskGUID}-${Date.now()}`,
+			TargetType: 'Task',
+			TargetGUID: pTaskGUID,
+			ScheduleType: pType || 'cron',
+			Parameters: pParameters || '0 * * * *',
+			CronExpression: this._resolveScheduleExpression(pType, pParameters),
+			Active: false,
+			CreatedAt: new Date().toISOString()
+		};
+
+		this._Schedule.push(tmpScheduleEntry);
+		this.log.info(`Ultravisor Hypervisor: scheduled task ${pTaskGUID} as ${tmpScheduleEntry.ScheduleType} (${tmpScheduleEntry.CronExpression})`);
+
+		return fCallback(null, tmpScheduleEntry);
+	}
+
+	/**
+	 * Add an operation to the schedule.
+	 *
+	 * @param {string} pOperationGUID - The operation GUID to schedule.
+	 * @param {string} pType - Schedule type (cron, daily, hourly).
+	 * @param {string} pParameters - Schedule parameters.
+	 * @param {function} fCallback - Callback.
+	 */
+	scheduleOperation(pOperationGUID, pType, pParameters, fCallback)
+	{
+		let tmpScheduleEntry = {
+			GUID: `sched-op-${pOperationGUID}-${Date.now()}`,
+			TargetType: 'Operation',
+			TargetGUID: pOperationGUID,
+			ScheduleType: pType || 'cron',
+			Parameters: pParameters || '0 * * * *',
+			CronExpression: this._resolveScheduleExpression(pType, pParameters),
+			Active: false,
+			CreatedAt: new Date().toISOString()
+		};
+
+		this._Schedule.push(tmpScheduleEntry);
+		this.log.info(`Ultravisor Hypervisor: scheduled operation ${pOperationGUID} as ${tmpScheduleEntry.ScheduleType} (${tmpScheduleEntry.CronExpression})`);
+
+		return fCallback(null, tmpScheduleEntry);
+	}
+
+	/**
+	 * Resolve a schedule type and parameters into a cron expression.
+	 */
+	_resolveScheduleExpression(pType, pParameters)
+	{
+		let tmpType = (pType || 'cron').toLowerCase();
+
+		switch (tmpType)
+		{
+			case 'daily':
+				// Default to midnight, or use the parameters as a time
+				return pParameters || '0 0 * * *';
+			case 'hourly':
+				return pParameters || '0 * * * *';
+			case 'cron':
+			default:
+				return pParameters || '0 * * * *';
+		}
+	}
+
+	/**
+	 * Start all scheduled jobs via the cron event service.
+	 */
+	startSchedule(fCallback)
+	{
+		let tmpCronService = this.fable['Ultravisor-Hypervisor-Event-Cron'];
+		let tmpTaskService = this.fable['Ultravisor-Task'];
+		let tmpOperationService = this.fable['Ultravisor-Operation'];
+		let tmpStateService = this.fable['Ultravisor-Hypervisor-State'];
+
+		this._Running = true;
+
+		for (let i = 0; i < this._Schedule.length; i++)
+		{
+			let tmpEntry = this._Schedule[i];
+
+			if (tmpEntry.Active)
+			{
+				continue;
+			}
+
+			tmpEntry.Active = true;
+
+			tmpCronService.start(tmpEntry,
+				(pScheduleEntry) =>
+				{
+					// On tick, execute the target
+					if (pScheduleEntry.TargetType === 'Task')
+					{
+						tmpStateService.getTask(pScheduleEntry.TargetGUID,
+							(pError, pTask) =>
+							{
+								if (pError)
+								{
+									this.log.error(`Ultravisor Hypervisor: scheduled task ${pScheduleEntry.TargetGUID} not found: ${pError.message}`);
+									return;
+								}
+								tmpTaskService.executeTask(pTask, {},
+									(pTaskError, pResult) =>
+									{
+										if (pTaskError)
+										{
+											this.log.error(`Ultravisor Hypervisor: scheduled task execution error: ${pTaskError.message}`);
+										}
+										else
+										{
+											this.log.info(`Ultravisor Hypervisor: scheduled task ${pScheduleEntry.TargetGUID} completed: ${pResult.Status}`);
+										}
+									});
+							});
+					}
+					else if (pScheduleEntry.TargetType === 'Operation')
+					{
+						tmpStateService.getOperation(pScheduleEntry.TargetGUID,
+							(pError, pOperation) =>
+							{
+								if (pError)
+								{
+									this.log.error(`Ultravisor Hypervisor: scheduled operation ${pScheduleEntry.TargetGUID} not found: ${pError.message}`);
+									return;
+								}
+								tmpOperationService.executeOperation(pOperation,
+									(pOpError, pManifest) =>
+									{
+										if (pOpError)
+										{
+											this.log.error(`Ultravisor Hypervisor: scheduled operation execution error: ${pOpError.message}`);
+										}
+										else
+										{
+											this.log.info(`Ultravisor Hypervisor: scheduled operation ${pScheduleEntry.TargetGUID} completed: ${pManifest.Status}`);
+										}
+									});
+							});
+					}
+				});
+		}
+
+		this.log.info(`Ultravisor Hypervisor: schedule started with ${this._Schedule.length} entries.`);
+
+		if (typeof(fCallback) === 'function')
+		{
+			return fCallback();
+		}
+	}
+
+	/**
+	 * Stop all scheduled jobs.
+	 */
+	stopSchedule(fCallback)
+	{
+		let tmpCronService = this.fable['Ultravisor-Hypervisor-Event-Cron'];
+
+		tmpCronService.stop();
+		this._Running = false;
+
+		for (let i = 0; i < this._Schedule.length; i++)
+		{
+			this._Schedule[i].Active = false;
+		}
+
+		this.log.info(`Ultravisor Hypervisor: schedule stopped.`);
+
+		if (typeof(fCallback) === 'function')
+		{
+			return fCallback();
+		}
+	}
+
+	/**
+	 * Remove a schedule entry by GUID.
+	 */
+	removeScheduleEntry(pGUID, fCallback)
+	{
+		let tmpCronService = this.fable['Ultravisor-Hypervisor-Event-Cron'];
+
+		for (let i = 0; i < this._Schedule.length; i++)
+		{
+			if (this._Schedule[i].GUID === pGUID)
+			{
+				if (this._Schedule[i].Active)
+				{
+					tmpCronService.stopJob(pGUID);
+				}
+				this._Schedule.splice(i, 1);
+				this.log.info(`Ultravisor Hypervisor: removed schedule entry ${pGUID}`);
+				return fCallback(null, true);
+			}
+		}
+
+		return fCallback(new Error(`Schedule entry ${pGUID} not found.`));
 	}
 }
 
-module.exports = UltravisorHypervisor;
+module.exports = UltravisorHypervisor;