ultravisor 1.0.0 → 1.0.2

package/source/services/tasks/rest/Ultravisor-Task-GetBinary.cjs

@@ -0,0 +1,127 @@
+const libUltravisorTaskBase = require('../Ultravisor-Task-Base.cjs');
+
+const libHTTP = require('http');
+const libHTTPS = require('https');
+
+class UltravisorTaskGetBinary extends libUltravisorTaskBase
+{
+	constructor(pFable)
+	{
+		super(pFable);
+	}
+
+	/**
+	 * Download a binary file from an HTTP/HTTPS URL.
+	 *
+	 * Task definition fields:
+	 *   - URL: the endpoint to download from
+	 *   - Headers (optional): object of request headers
+	 *   - Destination (optional): manyfest address in GlobalState
+	 *       where the binary data is stored as base64 (defaults to "Output")
+	 *   - Persist (optional): where to store the downloaded content
+	 *       string  -- manyfest address into GlobalState (stores base64)
+	 *       { Address: "..." } -- same as string form
+	 *       { File: "..." }   -- writes the raw binary to a staging file
+	 */
+	execute(pTaskDefinition, pContext, pManifestEntry, fCallback)
+	{
+		let tmpURL = pTaskDefinition.URL || pTaskDefinition.Parameters || '';
+
+		if (!tmpURL || tmpURL.length === 0)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetBinary: missing URL.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		pManifestEntry.Log.push(`GetBinary: GET ${tmpURL}`);
+
+		let tmpHeaders = Object.assign({}, pTaskDefinition.Headers || {});
+
+		let tmpParsedURL;
+		try
+		{
+			tmpParsedURL = new URL(tmpURL);
+		}
+		catch (pParseError)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetBinary: invalid URL: ${pParseError.message}`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		let tmpTransport = (tmpParsedURL.protocol === 'https:') ? libHTTPS : libHTTP;
+		let tmpTimeout = (this.fable?.ProgramConfiguration?.UltravisorCommandTimeoutMilliseconds) || 300000;
+
+		let tmpRequestOptions = {
+			method: 'GET',
+			headers: tmpHeaders,
+			timeout: tmpTimeout
+		};
+
+		let tmpRequest = tmpTransport.request(tmpURL, tmpRequestOptions,
+			(pResponse) =>
+			{
+				let tmpChunks = [];
+
+				pResponse.on('data', (pChunk) => { tmpChunks.push(pChunk); });
+
+				pResponse.on('end', () =>
+				{
+					let tmpBuffer = Buffer.concat(tmpChunks);
+
+					pManifestEntry.StopTime = new Date().toISOString();
+					pManifestEntry.Log.push(`GetBinary: received ${tmpBuffer.length} bytes, status ${pResponse.statusCode}.`);
+
+					pManifestEntry.Output = `${tmpBuffer.length} bytes downloaded`;
+					pManifestEntry.Status = 'Complete';
+					pManifestEntry.Success = true;
+					pManifestEntry.Log.push(`GetBinary: download completed successfully.`);
+
+					this.storeDestination(pTaskDefinition, pContext, pManifestEntry, tmpBuffer.toString('base64'));
+
+					// Persist the result
+					if (pTaskDefinition.Persist)
+					{
+						let tmpPersist = pTaskDefinition.Persist;
+						let tmpIsAddressPersist = (typeof(tmpPersist) === 'string') ||
+							(typeof(tmpPersist) === 'object' && tmpPersist !== null && tmpPersist.Address);
+
+						if (tmpIsAddressPersist)
+						{
+							this.storeResult(pTaskDefinition, pContext, pManifestEntry, tmpBuffer.toString('base64'));
+						}
+						else
+						{
+							this.storeResult(pTaskDefinition, pContext, pManifestEntry, tmpBuffer);
+						}
+					}
+
+					return fCallback(null, pManifestEntry);
+				});
+			});
+
+		tmpRequest.on('error', (pError) =>
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetBinary: request error: ${pError.message}`);
+			return fCallback(null, pManifestEntry);
+		});
+
+		tmpRequest.on('timeout', () =>
+		{
+			tmpRequest.destroy();
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetBinary: request timed out after ${tmpTimeout}ms.`);
+			return fCallback(null, pManifestEntry);
+		});
+
+		tmpRequest.end();
+	}
+}
+
+module.exports = UltravisorTaskGetBinary;

package/source/services/tasks/rest/Ultravisor-Task-GetJSON.cjs

@@ -0,0 +1,119 @@
+const libUltravisorTaskBase = require('../Ultravisor-Task-Base.cjs');
+
+const libHTTP = require('http');
+const libHTTPS = require('https');
+
+class UltravisorTaskGetJSON extends libUltravisorTaskBase
+{
+	constructor(pFable)
+	{
+		super(pFable);
+	}
+
+	/**
+	 * Perform an HTTP/HTTPS GET and parse the response as JSON.
+	 *
+	 * Task definition fields:
+	 *   - URL: the endpoint to request
+	 *   - Headers (optional): object of request headers
+	 *   - Destination (optional): manyfest address in GlobalState
+	 *       where the parsed object is stored (defaults to "Output")
+	 *   - Persist (optional): where to store the parsed response
+	 *       string  -- manyfest address into GlobalState
+	 *       { Address: "..." } -- same as string form
+	 *       { File: "..." }   -- writes JSON to a staging file
+	 */
+	execute(pTaskDefinition, pContext, pManifestEntry, fCallback)
+	{
+		let tmpURL = pTaskDefinition.URL || pTaskDefinition.Parameters || '';
+
+		if (!tmpURL || tmpURL.length === 0)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetJSON: missing URL.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		pManifestEntry.Log.push(`GetJSON: GET ${tmpURL}`);
+
+		let tmpHeaders = Object.assign({ 'Accept': 'application/json' }, pTaskDefinition.Headers || {});
+
+		let tmpParsedURL;
+		try
+		{
+			tmpParsedURL = new URL(tmpURL);
+		}
+		catch (pParseError)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetJSON: invalid URL: ${pParseError.message}`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		let tmpTransport = (tmpParsedURL.protocol === 'https:') ? libHTTPS : libHTTP;
+		let tmpTimeout = (this.fable?.ProgramConfiguration?.UltravisorCommandTimeoutMilliseconds) || 300000;
+
+		let tmpRequestOptions = {
+			method: 'GET',
+			headers: tmpHeaders,
+			timeout: tmpTimeout
+		};
+
+		let tmpRequest = tmpTransport.request(tmpURL, tmpRequestOptions,
+			(pResponse) =>
+			{
+				let tmpData = '';
+
+				pResponse.on('data', (pChunk) => { tmpData += pChunk; });
+
+				pResponse.on('end', () =>
+				{
+					pManifestEntry.StopTime = new Date().toISOString();
+					pManifestEntry.Log.push(`GetJSON: received ${tmpData.length} bytes, status ${pResponse.statusCode}.`);
+
+					try
+					{
+						let tmpParsed = JSON.parse(tmpData);
+						pManifestEntry.Output = JSON.stringify(tmpParsed);
+						pManifestEntry.Status = 'Complete';
+						pManifestEntry.Success = true;
+						pManifestEntry.Log.push(`GetJSON: parsed JSON successfully.`);
+
+						this.storeDestination(pTaskDefinition, pContext, pManifestEntry, tmpParsed);
+						this.storeResult(pTaskDefinition, pContext, pManifestEntry, tmpParsed);
+					}
+					catch (pJsonError)
+					{
+						pManifestEntry.Output = tmpData.substring(0, 2000);
+						pManifestEntry.Status = 'Error';
+						pManifestEntry.Log.push(`GetJSON: failed to parse response as JSON: ${pJsonError.message}`);
+					}
+
+					return fCallback(null, pManifestEntry);
+				});
+			});
+
+		tmpRequest.on('error', (pError) =>
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetJSON: request error: ${pError.message}`);
+			return fCallback(null, pManifestEntry);
+		});
+
+		tmpRequest.on('timeout', () =>
+		{
+			tmpRequest.destroy();
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetJSON: request timed out after ${tmpTimeout}ms.`);
+			return fCallback(null, pManifestEntry);
+		});
+
+		tmpRequest.end();
+	}
+}
+
+module.exports = UltravisorTaskGetJSON;

package/source/services/tasks/rest/Ultravisor-Task-GetText.cjs

@@ -0,0 +1,109 @@
+const libUltravisorTaskBase = require('../Ultravisor-Task-Base.cjs');
+
+const libHTTP = require('http');
+const libHTTPS = require('https');
+
+class UltravisorTaskGetText extends libUltravisorTaskBase
+{
+	constructor(pFable)
+	{
+		super(pFable);
+	}
+
+	/**
+	 * Perform an HTTP/HTTPS GET and return the response as plain text.
+	 *
+	 * Task definition fields:
+	 *   - URL: the endpoint to request
+	 *   - Headers (optional): object of request headers
+	 *   - Destination (optional): manyfest address in GlobalState
+	 *       where the response text is stored (defaults to "Output")
+	 *   - Persist (optional): where to store the response text
+	 *       string  -- manyfest address into GlobalState
+	 *       { Address: "..." } -- same as string form
+	 *       { File: "..." }   -- writes the text to a staging file
+	 */
+	execute(pTaskDefinition, pContext, pManifestEntry, fCallback)
+	{
+		let tmpURL = pTaskDefinition.URL || pTaskDefinition.Parameters || '';
+
+		if (!tmpURL || tmpURL.length === 0)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetText: missing URL.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		pManifestEntry.Log.push(`GetText: GET ${tmpURL}`);
+
+		let tmpHeaders = Object.assign({ 'Accept': 'text/plain' }, pTaskDefinition.Headers || {});
+
+		let tmpParsedURL;
+		try
+		{
+			tmpParsedURL = new URL(tmpURL);
+		}
+		catch (pParseError)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetText: invalid URL: ${pParseError.message}`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		let tmpTransport = (tmpParsedURL.protocol === 'https:') ? libHTTPS : libHTTP;
+		let tmpTimeout = (this.fable?.ProgramConfiguration?.UltravisorCommandTimeoutMilliseconds) || 300000;
+
+		let tmpRequestOptions = {
+			method: 'GET',
+			headers: tmpHeaders,
+			timeout: tmpTimeout
+		};
+
+		let tmpRequest = tmpTransport.request(tmpURL, tmpRequestOptions,
+			(pResponse) =>
+			{
+				let tmpData = '';
+
+				pResponse.on('data', (pChunk) => { tmpData += pChunk; });
+
+				pResponse.on('end', () =>
+				{
+					pManifestEntry.StopTime = new Date().toISOString();
+					pManifestEntry.Log.push(`GetText: received ${tmpData.length} bytes, status ${pResponse.statusCode}.`);
+
+					pManifestEntry.Output = tmpData;
+					pManifestEntry.Status = 'Complete';
+					pManifestEntry.Success = true;
+					pManifestEntry.Log.push(`GetText: response received successfully.`);
+
+					this.storeDestination(pTaskDefinition, pContext, pManifestEntry, tmpData);
+					this.storeResult(pTaskDefinition, pContext, pManifestEntry, tmpData);
+
+					return fCallback(null, pManifestEntry);
+				});
+			});
+
+		tmpRequest.on('error', (pError) =>
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetText: request error: ${pError.message}`);
+			return fCallback(null, pManifestEntry);
+		});
+
+		tmpRequest.on('timeout', () =>
+		{
+			tmpRequest.destroy();
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetText: request timed out after ${tmpTimeout}ms.`);
+			return fCallback(null, pManifestEntry);
+		});
+
+		tmpRequest.end();
+	}
+}
+
+module.exports = UltravisorTaskGetText;

package/source/services/tasks/rest/Ultravisor-Task-GetXML.cjs

@@ -0,0 +1,112 @@
+const libUltravisorTaskBase = require('../Ultravisor-Task-Base.cjs');
+
+const libHTTP = require('http');
+const libHTTPS = require('https');
+
+class UltravisorTaskGetXML extends libUltravisorTaskBase
+{
+	constructor(pFable)
+	{
+		super(pFable);
+	}
+
+	/**
+	 * Perform an HTTP/HTTPS GET and return the response as XML text.
+	 *
+	 * The raw XML string is returned in Output. No parsing is performed
+	 * -- the caller is responsible for interpreting the XML structure.
+	 *
+	 * Task definition fields:
+	 *   - URL: the endpoint to request
+	 *   - Headers (optional): object of request headers
+	 *   - Destination (optional): manyfest address in GlobalState
+	 *       where the XML response is stored (defaults to "Output")
+	 *   - Persist (optional): where to store the XML response
+	 *       string  -- manyfest address into GlobalState
+	 *       { Address: "..." } -- same as string form
+	 *       { File: "..." }   -- writes the XML to a staging file
+	 */
+	execute(pTaskDefinition, pContext, pManifestEntry, fCallback)
+	{
+		let tmpURL = pTaskDefinition.URL || pTaskDefinition.Parameters || '';
+
+		if (!tmpURL || tmpURL.length === 0)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetXML: missing URL.`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		pManifestEntry.Log.push(`GetXML: GET ${tmpURL}`);
+
+		let tmpHeaders = Object.assign({ 'Accept': 'application/xml, text/xml' }, pTaskDefinition.Headers || {});
+
+		let tmpParsedURL;
+		try
+		{
+			tmpParsedURL = new URL(tmpURL);
+		}
+		catch (pParseError)
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetXML: invalid URL: ${pParseError.message}`);
+			return fCallback(null, pManifestEntry);
+		}
+
+		let tmpTransport = (tmpParsedURL.protocol === 'https:') ? libHTTPS : libHTTP;
+		let tmpTimeout = (this.fable?.ProgramConfiguration?.UltravisorCommandTimeoutMilliseconds) || 300000;
+
+		let tmpRequestOptions = {
+			method: 'GET',
+			headers: tmpHeaders,
+			timeout: tmpTimeout
+		};
+
+		let tmpRequest = tmpTransport.request(tmpURL, tmpRequestOptions,
+			(pResponse) =>
+			{
+				let tmpData = '';
+
+				pResponse.on('data', (pChunk) => { tmpData += pChunk; });
+
+				pResponse.on('end', () =>
+				{
+					pManifestEntry.StopTime = new Date().toISOString();
+					pManifestEntry.Log.push(`GetXML: received ${tmpData.length} bytes, status ${pResponse.statusCode}.`);
+
+					pManifestEntry.Output = tmpData;
+					pManifestEntry.Status = 'Complete';
+					pManifestEntry.Success = true;
+					pManifestEntry.Log.push(`GetXML: response received successfully.`);
+
+					this.storeDestination(pTaskDefinition, pContext, pManifestEntry, tmpData);
+					this.storeResult(pTaskDefinition, pContext, pManifestEntry, tmpData);
+
+					return fCallback(null, pManifestEntry);
+				});
+			});
+
+		tmpRequest.on('error', (pError) =>
+		{
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetXML: request error: ${pError.message}`);
+			return fCallback(null, pManifestEntry);
+		});
+
+		tmpRequest.on('timeout', () =>
+		{
+			tmpRequest.destroy();
+			pManifestEntry.StopTime = new Date().toISOString();
+			pManifestEntry.Status = 'Error';
+			pManifestEntry.Log.push(`GetXML: request timed out after ${tmpTimeout}ms.`);
+			return fCallback(null, pManifestEntry);
+		});
+
+		tmpRequest.end();
+	}
+}
+
+module.exports = UltravisorTaskGetXML;