ultravisor 1.0.0 → 1.0.2

package/source/services/tasks/stagingfiles/Ultravisor-Task-WriteText.cjs

@@ -0,0 +1,99 @@
+const libUltravisorTaskBase = require('../Ultravisor-Task-Base.cjs');
+
+const libFS = require('fs');
+const libPath = require('path');
+
+class UltravisorTaskWriteText extends libUltravisorTaskBase
+{
+	constructor(pFable)
+	{
+		super(pFable);
+	}
+
+	/**
+	 * Write text content to a file in the staging folder.
+	 *
+	 * Task definition fields:
+	 *   - File: relative file path inside the staging folder
+	 *   - Address (optional): dot-notation path into GlobalState to
+	 *       resolve the data to write (used instead of Data)
+	 *   - Data: the string to write
+	 *
+	 * Either Address or Data must be provided.  When Address is set,
+	 * the data is resolved from pContext.GlobalState (or NodeState).
+	 */
+	execute(pTaskDefinition, pContext, pManifestEntry, fCallback)
+	{
+		let tmpStagingPath = this.resolveStagingPath(pContext);
+		let tmpFilePath = this.resolveStagingFilePath(tmpStagingPath, pTaskDefinition.File);
+
+		if (!tmpFilePath)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`WriteText: missing or invalid File field.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		// Resolve data from Address or Data
+		let tmpData;
+
+		if (pTaskDefinition.Address && typeof(pTaskDefinition.Address) === 'string')
+		{
+			tmpData = this.resolveAddress(pTaskDefinition.Address, pContext);
+			pManifestEntry.Log.push(`WriteText: resolved data from Address "${pTaskDefinition.Address}".`);
+		}
+		else if (pTaskDefinition.hasOwnProperty('Data'))
+		{
+			tmpData = pTaskDefinition.Data;
+		}
+		else
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`WriteText: missing Data or Address field.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		if (tmpData === undefined)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`WriteText: resolved data is undefined.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		let tmpContent = (typeof(tmpData) === 'string')
+			? tmpData
+			: String(tmpData);
+
+		pManifestEntry.Log.push(`WriteText: writing to ${tmpFilePath}`);
+
+		try
+		{
+			let tmpDir = libPath.dirname(tmpFilePath);
+			if (!libFS.existsSync(tmpDir))
+			{
+				libFS.mkdirSync(tmpDir, { recursive: true });
+			}
+
+			libFS.writeFileSync(tmpFilePath, tmpContent, 'utf8');
+
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Complete';
+			pManifestEntry.Success = true;
+			pManifestEntry.Output = `${tmpContent.length} bytes written`;
+			pManifestEntry.Log.push(`WriteText: wrote ${tmpContent.length} bytes.`);
+		}
+		catch (pError)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`WriteText: ${pError.message}`);
+		}
+
+		return fCallback(null, pManifestEntry);
+	}
+}
+
+module.exports = UltravisorTaskWriteText;

package/source/services/tasks/stagingfiles/Ultravisor-Task-WriteXML.cjs

@@ -0,0 +1,102 @@
+const libUltravisorTaskBase = require('../Ultravisor-Task-Base.cjs');
+
+const libFS = require('fs');
+const libPath = require('path');
+
+class UltravisorTaskWriteXML extends libUltravisorTaskBase
+{
+	constructor(pFable)
+	{
+		super(pFable);
+	}
+
+	/**
+	 * Write XML content to a file in the staging folder.
+	 *
+	 * The Data field should be a string containing well-formed XML.
+	 * Creates intermediate directories automatically.
+	 *
+	 * Task definition fields:
+	 *   - File: relative file path inside the staging folder
+	 *   - Address (optional): dot-notation path into GlobalState to
+	 *       resolve the data to write (used instead of Data)
+	 *   - Data: XML string to write
+	 *
+	 * Either Address or Data must be provided.  When Address is set,
+	 * the data is resolved from pContext.GlobalState (or NodeState).
+	 */
+	execute(pTaskDefinition, pContext, pManifestEntry, fCallback)
+	{
+		let tmpStagingPath = this.resolveStagingPath(pContext);
+		let tmpFilePath = this.resolveStagingFilePath(tmpStagingPath, pTaskDefinition.File);
+
+		if (!tmpFilePath)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`WriteXML: missing or invalid File field.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		// Resolve data from Address or Data
+		let tmpData;
+
+		if (pTaskDefinition.Address && typeof(pTaskDefinition.Address) === 'string')
+		{
+			tmpData = this.resolveAddress(pTaskDefinition.Address, pContext);
+			pManifestEntry.Log.push(`WriteXML: resolved data from Address "${pTaskDefinition.Address}".`);
+		}
+		else if (pTaskDefinition.hasOwnProperty('Data'))
+		{
+			tmpData = pTaskDefinition.Data;
+		}
+		else
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`WriteXML: missing Data or Address field.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		if (tmpData === undefined)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`WriteXML: resolved data is undefined.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		let tmpContent = (typeof(tmpData) === 'string')
+			? tmpData
+			: String(tmpData);
+
+		pManifestEntry.Log.push(`WriteXML: writing to ${tmpFilePath}`);
+
+		try
+		{
+			let tmpDir = libPath.dirname(tmpFilePath);
+			if (!libFS.existsSync(tmpDir))
+			{
+				libFS.mkdirSync(tmpDir, { recursive: true });
+			}
+
+			libFS.writeFileSync(tmpFilePath, tmpContent, 'utf8');
+
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Complete';
+			pManifestEntry.Success = true;
+			pManifestEntry.Output = `${tmpContent.length} bytes written`;
+			pManifestEntry.Log.push(`WriteXML: wrote ${tmpContent.length} bytes.`);
+		}
+		catch (pError)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`WriteXML: ${pError.message}`);
+		}
+
+		return fCallback(null, pManifestEntry);
+	}
+}
+
+module.exports = UltravisorTaskWriteXML;

package/source/web_server/Ultravisor-API-Server.cjs

@@ -1,5 +1,6 @@
 const libPictService = require(`pict-serviceproviderbase`);
 
+const libPath = require('path');
 const libOrator = require('orator');
 const libOratorServiceServerRestify = require(`orator-serviceserver-restify`);
 
@@ -24,15 +25,440 @@ class UltravisorAPIServer extends libPictService
 			return fCallback(new Error(`Ultravisor API Server: Cannot wire endpoints; Orator service is not initialized.`));
 		}
 
+		// --- Package / Status ---
 		this._OratorServer.get
 			(
 				'/package',
-				(pRequest, pResponse, fNext) =>
+				function (pRequest, pResponse, fNext)
 				{
-					// Send back the request parameters
 					pResponse.send(this.pict.settings.Package);
 					return fNext();
-				}
+				}.bind(this)
+			);
+
+		this._OratorServer.get
+			(
+				'/status',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpHypervisor = this.fable['Ultravisor-Hypervisor'];
+					pResponse.send({
+						Status: 'Running',
+						ScheduleEntries: tmpHypervisor.getSchedule().length,
+						ScheduleRunning: tmpHypervisor._Running
+					});
+					return fNext();
+				}.bind(this)
+			);
+
+		this._OratorServer.get
+			(
+				'/stop',
+				function (pRequest, pResponse, fNext)
+				{
+					this.log.info(`Ultravisor API Server: Received stop request via API; stopping server.`);
+					let tmpHypervisor = this.fable['Ultravisor-Hypervisor'];
+					tmpHypervisor.stopSchedule();
+					pResponse.send({ "Status": "STOPPING" });
+					pResponse.end();
+					return this._Orator.stopService(fNext);
+				}.bind(this)
+			);
+
+		// --- Task CRUD ---
+		this._OratorServer.get
+			(
+				'/Task',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor-State'].getTaskList({},
+						function (pError, pTasks)
+						{
+							if (pError)
+							{
+								pResponse.send(500, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pTasks);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.get
+			(
+				'/Task/:GUIDTask',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor-State'].getTask(pRequest.params.GUIDTask,
+						function (pError, pTask)
+						{
+							if (pError)
+							{
+								pResponse.send(404, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pTask);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.post
+			(
+				'/Task',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor-State'].updateTask(pRequest.body,
+						function (pError, pTask)
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pTask);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.put
+			(
+				'/Task/:GUIDTask',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpTaskData = pRequest.body || {};
+					tmpTaskData.GUIDTask = pRequest.params.GUIDTask;
+					this.fable['Ultravisor-Hypervisor-State'].updateTask(tmpTaskData,
+						function (pError, pTask)
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pTask);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.del
+			(
+				'/Task/:GUIDTask',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpState = this.fable['Ultravisor-Hypervisor-State'];
+					if (tmpState._Tasks.hasOwnProperty(pRequest.params.GUIDTask))
+					{
+						delete tmpState._Tasks[pRequest.params.GUIDTask];
+						tmpState.persistState();
+						pResponse.send({ Status: 'Deleted', GUIDTask: pRequest.params.GUIDTask });
+					}
+					else
+					{
+						pResponse.send(404, { Error: `Task ${pRequest.params.GUIDTask} not found.` });
+					}
+					return fNext();
+				}.bind(this)
+			);
+
+		// --- Operation CRUD ---
+		this._OratorServer.get
+			(
+				'/Operation',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor-State'].getOperationList({},
+						function (pError, pOperations)
+						{
+							if (pError)
+							{
+								pResponse.send(500, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pOperations);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.get
+			(
+				'/Operation/:GUIDOperation',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor-State'].getOperation(pRequest.params.GUIDOperation,
+						function (pError, pOperation)
+						{
+							if (pError)
+							{
+								pResponse.send(404, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pOperation);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.post
+			(
+				'/Operation',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor-State'].updateOperation(pRequest.body,
+						function (pError, pOperation)
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pOperation);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.put
+			(
+				'/Operation/:GUIDOperation',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpOperationData = pRequest.body || {};
+					tmpOperationData.GUIDOperation = pRequest.params.GUIDOperation;
+					this.fable['Ultravisor-Hypervisor-State'].updateOperation(tmpOperationData,
+						function (pError, pOperation)
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pOperation);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.del
+			(
+				'/Operation/:GUIDOperation',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpState = this.fable['Ultravisor-Hypervisor-State'];
+					if (tmpState._Operations.hasOwnProperty(pRequest.params.GUIDOperation))
+					{
+						delete tmpState._Operations[pRequest.params.GUIDOperation];
+						tmpState.persistState();
+						pResponse.send({ Status: 'Deleted', GUIDOperation: pRequest.params.GUIDOperation });
+					}
+					else
+					{
+						pResponse.send(404, { Error: `Operation ${pRequest.params.GUIDOperation} not found.` });
+					}
+					return fNext();
+				}.bind(this)
+			);
+
+		// --- Task Execution ---
+		this._OratorServer.get
+			(
+				'/Task/:GUIDTask/Execute',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpState = this.fable['Ultravisor-Hypervisor-State'];
+					let tmpTaskService = this.fable['Ultravisor-Task'];
+
+					tmpState.getTask(pRequest.params.GUIDTask,
+						function (pError, pTask)
+						{
+							if (pError)
+							{
+								pResponse.send(404, { Error: pError.message });
+								return fNext();
+							}
+							tmpTaskService.executeTask(pTask, {},
+								function (pExecError, pManifestEntry)
+								{
+									if (pExecError)
+									{
+										pResponse.send(500, { Error: pExecError.message });
+										return fNext();
+									}
+									// Store the task result as a manifest so it appears in /Manifest
+									let tmpManifestService = this.fable['Ultravisor-Operation-Manifest'];
+									tmpManifestService.createTaskManifest(pManifestEntry);
+									pResponse.send(pManifestEntry);
+									return fNext();
+								}.bind(this));
+						}.bind(this));
+				}.bind(this)
+			);
+
+		// --- Operation Execution ---
+		this._OratorServer.get
+			(
+				'/Operation/:GUIDOperation/Execute',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpState = this.fable['Ultravisor-Hypervisor-State'];
+					let tmpOperationService = this.fable['Ultravisor-Operation'];
+
+					tmpState.getOperation(pRequest.params.GUIDOperation,
+						function (pError, pOperation)
+						{
+							if (pError)
+							{
+								pResponse.send(404, { Error: pError.message });
+								return fNext();
+							}
+							tmpOperationService.executeOperation(pOperation,
+								function (pExecError, pManifest)
+								{
+									if (pExecError)
+									{
+										pResponse.send(500, { Error: pExecError.message });
+										return fNext();
+									}
+									pResponse.send(pManifest);
+									return fNext();
+								});
+						});
+				}.bind(this)
+			);
+
+		// --- Schedule ---
+		this._OratorServer.get
+			(
+				'/Schedule',
+				function (pRequest, pResponse, fNext)
+				{
+					pResponse.send(this.fable['Ultravisor-Hypervisor'].getSchedule());
+					return fNext();
+				}.bind(this)
+			);
+
+		this._OratorServer.post
+			(
+				'/Schedule/Task',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpBody = pRequest.body || {};
+					let tmpHypervisor = this.fable['Ultravisor-Hypervisor'];
+
+					tmpHypervisor.scheduleTask(tmpBody.GUIDTask, tmpBody.ScheduleType, tmpBody.Parameters,
+						function (pError, pEntry)
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pEntry);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.post
+			(
+				'/Schedule/Operation',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpBody = pRequest.body || {};
+					let tmpHypervisor = this.fable['Ultravisor-Hypervisor'];
+
+					tmpHypervisor.scheduleOperation(tmpBody.GUIDOperation, tmpBody.ScheduleType, tmpBody.Parameters,
+						function (pError, pEntry)
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(pEntry);
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.del
+			(
+				'/Schedule/:GUID',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor'].removeScheduleEntry(pRequest.params.GUID,
+						function (pError, pResult)
+						{
+							if (pError)
+							{
+								pResponse.send(404, { Error: pError.message });
+								return fNext();
+							}
+							pResponse.send({ Status: 'Deleted', GUID: pRequest.params.GUID });
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.get
+			(
+				'/Schedule/Start',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor'].startSchedule(
+						function ()
+						{
+							pResponse.send({ Status: 'Schedule Started' });
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		this._OratorServer.get
+			(
+				'/Schedule/Stop',
+				function (pRequest, pResponse, fNext)
+				{
+					this.fable['Ultravisor-Hypervisor'].stopSchedule(
+						function ()
+						{
+							pResponse.send({ Status: 'Schedule Stopped' });
+							return fNext();
+						});
+				}.bind(this)
+			);
+
+		// --- Manifests ---
+		this._OratorServer.get
+			(
+				'/Manifest',
+				function (pRequest, pResponse, fNext)
+				{
+					pResponse.send(this.fable['Ultravisor-Operation-Manifest'].getManifestList());
+					return fNext();
+				}.bind(this)
+			);
+
+		this._OratorServer.get
+			(
+				'/Manifest/:GUIDRun',
+				function (pRequest, pResponse, fNext)
+				{
+					let tmpManifest = this.fable['Ultravisor-Operation-Manifest'].getManifest(pRequest.params.GUIDRun);
+					if (tmpManifest)
+					{
+						pResponse.send(tmpManifest);
+					}
+					else
+					{
+						pResponse.send(404, { Error: `Manifest ${pRequest.params.GUIDRun} not found.` });
+					}
+					return fNext();
+				}.bind(this)
 			);
 
 		return fCallback();
@@ -79,6 +505,14 @@ class UltravisorAPIServer extends libPictService
 					}.bind(this));
 			}.bind(this));
 
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				// Enable JSON body parsing for POST/PUT requests
+				this._OratorServer.server.use(this._OratorServer.bodyParser());
+				return fNext();
+			}.bind(this));
+
 		tmpAnticipate.anticipate(
 			function (fNext)
 			{
@@ -95,6 +529,32 @@ class UltravisorAPIServer extends libPictService
 					}.bind(this));
 			}.bind(this));
 
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				let tmpWebInterfacePath = this.fable?.ProgramConfiguration?.UltravisorWebInterfacePath;
+				if (tmpWebInterfacePath && (typeof tmpWebInterfacePath === 'string'))
+				{
+					// Resolve relative paths against the current working directory
+					let tmpResolvedPath = libPath.resolve(process.cwd(), tmpWebInterfacePath);
+					this.log.info(`Ultravisor: Serving web interface from [${tmpResolvedPath}]`);
+
+					// Workaround: Orator's addStaticRoute serves bare "/" with
+					// Content-Type application/octet-stream because serve-static
+					// overwrites the MIME header that Orator sets.  Add an
+					// explicit redirect so "/" always loads /index.html which is
+					// served with the correct text/html content type.
+					this._OratorServer.get('/',
+						function (pRequest, pResponse, fNext)
+						{
+							pResponse.redirect('/index.html', fNext);
+						});
+
+					this._Orator.addStaticRoute(tmpResolvedPath, 'index.html', '/*');
+				}
+				return fNext();
+			}.bind(this));
+
 		tmpAnticipate.anticipate(
 			function (fNext)
 			{