ultravisor 1.0.2 → 1.0.4

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

@@ -9,19 +9,26 @@ class UltravisorCommandSingleOperationRun extends libCommandLineCommand
 		this.options.CommandKeyword = 'singleoperation';
 		this.options.Description = 'Execute a single ultravisor operation immediately, no matter what.';
 
-		this.options.CommandArguments.push({ Name: '<operation>', Description: 'The operation(s) to run.' });
-		this.options.CommandOptions.push({ Name: '-d, --dry_run', Description: 'Dry run the task.', Default: false });
+		this.options.CommandArguments.push({ Name: '<operation>', Description: 'The operation hash to run.' });
+		this.options.CommandOptions.push({ Name: '-d, --dry_run', Description: 'Dry run the operation.', Default: false });
 
 		this.options.Aliases.push('operation');
 
 		this.addCommand();
 	}
 
+	_getService(pTypeName)
+	{
+		return this.fable.servicesMap[pTypeName]
+			? Object.values(this.fable.servicesMap[pTypeName])[0]
+			: null;
+	}
+
 	onRunAsync(fCallback)
 	{
-		let tmpOperationGUID = this.ArgumentString;
+		let tmpOperationHash = this.ArgumentString;
 
-		if (!tmpOperationGUID)
+		if (!tmpOperationHash)
 		{
 			console.log(`Error: operation argument is required.`);
 			return fCallback();
@@ -31,16 +38,16 @@ class UltravisorCommandSingleOperationRun extends libCommandLineCommand
 
 		if (tmpDryRun)
 		{
-			console.log(`[DRY RUN] Would execute operation: ${tmpOperationGUID}`);
+			console.log(`[DRY RUN] Would execute operation: ${tmpOperationHash}`);
 			return fCallback();
 		}
 
-		console.log(`Executing operation: ${tmpOperationGUID}`);
+		console.log(`Executing operation: ${tmpOperationHash}`);
 
-		let tmpStateService = this.fable['Ultravisor-Hypervisor-State'];
-		let tmpOperationService = this.fable['Ultravisor-Operation'];
+		let tmpStateService = this._getService('UltravisorHypervisorState');
+		let tmpEngine = this._getService('UltravisorExecutionEngine');
 
-		tmpStateService.getOperation(tmpOperationGUID,
+		tmpStateService.getOperation(tmpOperationHash,
 			function (pError, pOperation)
 			{
 				if (pError)
@@ -49,8 +56,8 @@ class UltravisorCommandSingleOperationRun extends libCommandLineCommand
 					return fCallback();
 				}
 
-				tmpOperationService.executeOperation(pOperation,
-					function (pExecError, pManifest)
+				tmpEngine.executeOperation(pOperation,
+					function (pExecError, pContext)
 					{
 						if (pExecError)
 						{
@@ -59,16 +66,20 @@ class UltravisorCommandSingleOperationRun extends libCommandLineCommand
 						}
 
 						console.log(`\nOperation Result:`);
-						console.log(`  Status: ${pManifest.Status}`);
-						console.log(`  Success: ${pManifest.Success}`);
-						console.log(`  Start: ${pManifest.StartTime}`);
-						console.log(`  Stop: ${pManifest.StopTime}`);
-						console.log(`  Tasks Executed: ${pManifest.TaskResults.length}`);
-						console.log(`  Summary: ${pManifest.Summary}`);
+						console.log(`  Status: ${pContext.Status}`);
+						console.log(`  Start: ${pContext.StartTime}`);
+						console.log(`  Stop: ${pContext.StopTime}`);
+						console.log(`  Elapsed: ${pContext.ElapsedMs}ms`);
+						let tmpTaskCount = pContext.TaskManifests ? Object.keys(pContext.TaskManifests).length : 0;
+						console.log(`  Tasks Executed: ${tmpTaskCount}`);
+						if (pContext.Errors && pContext.Errors.length > 0)
+						{
+							console.log(`  Errors: ${pContext.Errors.length}`);
+						}
 						return fCallback();
 					});
 			});
 	}
 }
 
-module.exports = UltravisorCommandSingleOperationRun;
+module.exports = UltravisorCommandSingleOperationRun;

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

@@ -9,8 +9,7 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 		this.options.CommandKeyword = 'singletask';
 		this.options.Description = 'Execute a single ultravisor task immediately, no matter what.';
 
-		this.options.CommandArguments.push({ Name: '<task>', Description: 'The task(s) to run.' });
-		this.options.CommandOptions.push({ Name: '-o, --operation [operation]', Description: 'The operation to scope the task(s) to.', Default: 'Default' });
+		this.options.CommandArguments.push({ Name: '<task>', Description: 'The task hash to run.' });
 		this.options.CommandOptions.push({ Name: '-d, --dry_run', Description: 'Dry run the task.', Default: false });
 
 		this.options.Aliases.push('task');
@@ -18,11 +17,18 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 		this.addCommand();
 	}
 
+	_getService(pTypeName)
+	{
+		return this.fable.servicesMap[pTypeName]
+			? Object.values(this.fable.servicesMap[pTypeName])[0]
+			: null;
+	}
+
 	onRunAsync(fCallback)
 	{
-		let tmpTaskGUID = this.ArgumentString;
+		let tmpTaskHash = this.ArgumentString;
 
-		if (!tmpTaskGUID)
+		if (!tmpTaskHash)
 		{
 			console.log(`Error: task argument is required.`);
 			return fCallback();
@@ -32,17 +38,17 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 
 		if (tmpDryRun)
 		{
-			console.log(`[DRY RUN] Would execute task: ${tmpTaskGUID}`);
+			console.log(`[DRY RUN] Would execute task: ${tmpTaskHash}`);
 			return fCallback();
 		}
 
-		console.log(`Executing task: ${tmpTaskGUID}`);
+		console.log(`Executing task: ${tmpTaskHash}`);
 
-		let tmpStateService = this.fable['Ultravisor-Hypervisor-State'];
-		let tmpTaskService = this.fable['Ultravisor-Task'];
+		let tmpStateService = this._getService('UltravisorHypervisorState');
+		let tmpEngine = this._getService('UltravisorExecutionEngine');
 
-		tmpStateService.getTask(tmpTaskGUID,
-			function (pError, pTask)
+		tmpStateService.getTaskDefinition(tmpTaskHash,
+			function (pError, pTaskDef)
 			{
 				if (pError)
 				{
@@ -50,8 +56,41 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 					return fCallback();
 				}
 
-				tmpTaskService.executeTask(pTask, {},
-					function (pExecError, pResult)
+				// Wrap single task in a minimal operation graph and execute
+				let tmpAdHocOperation = {
+					Hash: `ADHOC-${pTaskDef.Hash}`,
+					Name: `Ad-hoc: ${pTaskDef.Name || pTaskDef.Hash}`,
+					Graph:
+					{
+						Nodes:
+						[
+							{ Hash: 'start-node', Type: 'start', X: 0, Y: 100 },
+							{ Hash: pTaskDef.Hash, Type: pTaskDef.Type, DefinitionHash: pTaskDef.Type, Settings: pTaskDef.Settings || {}, X: 200, Y: 100 },
+							{ Hash: 'end-node', Type: 'end', X: 400, Y: 100 }
+						],
+						Connections:
+						[
+							{
+								SourceNodeHash: 'start-node',
+								SourcePortHash: 'start-node-eo-Start',
+								TargetNodeHash: pTaskDef.Hash,
+								TargetPortHash: pTaskDef.Hash + '-ei-Execute',
+								ConnectionType: 'Event'
+							},
+							{
+								SourceNodeHash: pTaskDef.Hash,
+								SourcePortHash: pTaskDef.Hash + '-eo-Complete',
+								TargetNodeHash: 'end-node',
+								TargetPortHash: 'end-node-ei-Finish',
+								ConnectionType: 'Event'
+							}
+						],
+						ViewState: {}
+					}
+				};
+
+				tmpEngine.executeOperation(tmpAdHocOperation,
+					function (pExecError, pContext)
 					{
 						if (pExecError)
 						{
@@ -60,13 +99,17 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 						}
 
 						console.log(`\nTask Result:`);
-						console.log(`  Status: ${pResult.Status}`);
-						console.log(`  Success: ${pResult.Success}`);
-						console.log(`  Start: ${pResult.StartTime}`);
-						console.log(`  Stop: ${pResult.StopTime}`);
-						if (pResult.Output)
+						console.log(`  Status: ${pContext.Status}`);
+						console.log(`  Start: ${pContext.StartTime}`);
+						console.log(`  Stop: ${pContext.StopTime}`);
+						console.log(`  Elapsed: ${pContext.ElapsedMs}ms`);
+						if (pContext.TaskOutputs && pContext.TaskOutputs[pTaskDef.Hash])
+						{
+							console.log(`  Output: ${JSON.stringify(pContext.TaskOutputs[pTaskDef.Hash]).substring(0, 1000)}`);
+						}
+						if (pContext.Errors && pContext.Errors.length > 0)
 						{
-							console.log(`  Output: ${pResult.Output.substring(0, 1000)}`);
+							console.log(`  Errors: ${pContext.Errors.length}`);
 						}
 						return fCallback();
 					});
@@ -74,4 +117,4 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 	}
 }
 
-module.exports = UltravisorCommandSingleTaskRun;
+module.exports = UltravisorCommandSingleTaskRun;

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

@@ -10,20 +10,25 @@ class UltravisorCommandAddTask extends libCommandLineCommand
 		super(pFable, pManifest, pServiceHash);
 
 		this.options.CommandKeyword = 'updatetask';
-		this.options.Description = 'Update (or add) a task to the available tasks.';
+		this.options.Description = 'Update (or add) a task definition.';
 
 		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:'-h, --hash [task_hash]', Description:'The hash for the task definition.', 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.options.CommandOptions.push({ Name:'-t, --type [task_type]', Description:'The type of task (e.g. read-file, write-file, set-values).', Default:false });
 
 		this.addCommand();
 	}
 
+	_getService(pTypeName)
+	{
+		return this.fable.servicesMap[pTypeName]
+			? Object.values(this.fable.servicesMap[pTypeName])[0]
+			: null;
+	}
+
 	onRunAsync(fCallback)
 	{
 		const tmpOperationState = {};
@@ -64,28 +69,35 @@ class UltravisorCommandAddTask extends libCommandLineCommand
 
 		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;
+		if (this.CommandOptions.hash)
+		{
+			tmpOperationState.TaskDefinition_Parameterized.Hash = this.CommandOptions.hash;
+		}
+		if (this.CommandOptions.name)
+		{
+			tmpOperationState.TaskDefinition_Parameterized.Name = this.CommandOptions.name;
+		}
+		if (this.CommandOptions.type)
+		{
+			tmpOperationState.TaskDefinition_Parameterized.Type = this.CommandOptions.type;
+		}
 
 		tmpOperationState.TaskDefinition = Object.assign({}, tmpOperationState.TaskDefinition_Parameterized, tmpOperationState.JSONFile);
 
-		this.fable['Ultravisor-Hypervisor-State'].updateTask(tmpOperationState.TaskDefinition,
+		let tmpStateService = this._getService('UltravisorHypervisorState');
+		tmpStateService.updateTaskDefinition(tmpOperationState.TaskDefinition,
 			function (pError, pUpdatedTask)
 			{
 				if (pError)
 				{
-					return fCallback(new Error(`Could not update task: ${pError.message}`));
+					return fCallback(new Error(`Could not update task definition: ${pError.message}`));
 				}
 
-				console.log(`Task with GUID ${pUpdatedTask.GUIDTask} updated successfully.`);
+				console.log(`Task definition ${pUpdatedTask.Hash} updated successfully.`);
 
 				return fCallback();
 			}.bind(this));
 	}
 }
 
-module.exports = UltravisorCommandAddTask;
+module.exports = UltravisorCommandAddTask;

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

@@ -1,10 +1,12 @@
+let _ModuleRoot = require('path').resolve(__dirname, '..', '..');
+
 module.exports = (
 	{
 		"UltravisorAPIServerPort": 54321,
-		"UltravisorFileStorePath": `${process.cwd()}/dist/ultravisor_datastore`,
-		"UltravisorStagingRoot": `${process.cwd()}/dist/ultravisor_staging`,
+		"UltravisorFileStorePath": `${_ModuleRoot}/dist/ultravisor_datastore`,
+		"UltravisorStagingRoot": `${_ModuleRoot}/dist/ultravisor_staging`,
 		"UltravisorTickIntervalMilliseconds": 60000,
 		"UltravisorCommandTimeoutMilliseconds": 300000,
 		"UltravisorCommandMaxBufferBytes": 10485760,
-		"UltravisorWebInterfacePath": false
+		"UltravisorWebInterfacePath": `${_ModuleRoot}/webinterface/dist`
 	});