orator-conversion 1.0.2 → 1.0.4

package/source/Orator-File-Translation.js

@@ -6,8 +6,14 @@ const libFS = require('fs');
 const libPath = require('path');
 const libOS = require('os');
 
+const libBeaconService = require('ultravisor-beacon');
+const libOratorConversionBeaconProvider = require('./Orator-Conversion-BeaconProvider.js');
+
 const libEndpointImageJpgToPng = require('./endpoints/Endpoint-Image-JpgToPng.js');
 const libEndpointImagePngToJpg = require('./endpoints/Endpoint-Image-PngToJpg.js');
+const libEndpointImageResize = require('./endpoints/Endpoint-Image-Resize.js');
+const libEndpointImageRotate = require('./endpoints/Endpoint-Image-Rotate.js');
+const libEndpointImageConvert = require('./endpoints/Endpoint-Image-Convert.js');
 const libEndpointPdfPageToPng = require('./endpoints/Endpoint-Pdf-PageToPng.js');
 const libEndpointPdfPageToJpg = require('./endpoints/Endpoint-Pdf-PageToJpg.js');
 const libEndpointPdfPageToPngSized = require('./endpoints/Endpoint-Pdf-PageToPng-Sized.js');
@@ -75,6 +81,9 @@ class OratorFileTranslation extends libFableServiceProviderBase
 		// Array of instantiated endpoint services
 		this._endpointServices = [];
 
+		// Beacon service reference (created on connectBeacon)
+		this._BeaconService = null;
+
 		// Initialize the built-in converters
 		this.initializeDefaultConverters();
 	}
@@ -89,6 +98,9 @@ class OratorFileTranslation extends libFableServiceProviderBase
 		// Register endpoint service types with fable
 		this.fable.addServiceTypeIfNotExists('OratorFileTranslationEndpoint-ImageJpgToPng', libEndpointImageJpgToPng);
 		this.fable.addServiceTypeIfNotExists('OratorFileTranslationEndpoint-ImagePngToJpg', libEndpointImagePngToJpg);
+		this.fable.addServiceTypeIfNotExists('OratorFileTranslationEndpoint-ImageResize', libEndpointImageResize);
+		this.fable.addServiceTypeIfNotExists('OratorFileTranslationEndpoint-ImageRotate', libEndpointImageRotate);
+		this.fable.addServiceTypeIfNotExists('OratorFileTranslationEndpoint-ImageConvert', libEndpointImageConvert);
 		this.fable.addServiceTypeIfNotExists('OratorFileTranslationEndpoint-PdfPageToPng', libEndpointPdfPageToPng);
 		this.fable.addServiceTypeIfNotExists('OratorFileTranslationEndpoint-PdfPageToJpg', libEndpointPdfPageToJpg);
 		this.fable.addServiceTypeIfNotExists('OratorFileTranslationEndpoint-PdfPageToPngSized', libEndpointPdfPageToPngSized);
@@ -100,6 +112,9 @@ class OratorFileTranslation extends libFableServiceProviderBase
 			[
 				'OratorFileTranslationEndpoint-ImageJpgToPng',
 				'OratorFileTranslationEndpoint-ImagePngToJpg',
+				'OratorFileTranslationEndpoint-ImageResize',
+				'OratorFileTranslationEndpoint-ImageRotate',
+				'OratorFileTranslationEndpoint-ImageConvert',
 				'OratorFileTranslationEndpoint-PdfPageToPng',
 				'OratorFileTranslationEndpoint-PdfPageToJpg',
 				'OratorFileTranslationEndpoint-PdfPageToPngSized',
@@ -499,6 +514,145 @@ class OratorFileTranslation extends libFableServiceProviderBase
 
 		return true;
 	}
+
+	/**
+	 * Connect to an Ultravisor coordinator as a beacon, exposing the same
+	 * MediaConversion capabilities available through the HTTP endpoints.
+	 *
+	 * This makes the running orator-conversion server discoverable by
+	 * Ultravisor and allows it to receive work items from the mesh.
+	 *
+	 * @param {object} pBeaconConfig Beacon configuration:
+	 *   - ServerURL {string} Ultravisor server URL (required)
+	 *   - Name {string} Beacon name (default: 'orator-conversion')
+	 *   - Password {string} Auth password (default: '')
+	 *   - MaxConcurrent {number} Max concurrent work items (default: 2)
+	 *   - StagingPath {string} Local staging directory (default: cwd)
+	 *   - Tags {object} Beacon tags (default: {})
+	 * @param {Function} fCallback Called with (pError, pBeaconInfo)
+	 */
+	connectBeacon(pBeaconConfig, fCallback)
+	{
+		if (!pBeaconConfig || !pBeaconConfig.ServerURL)
+		{
+			return fCallback(new Error('connectBeacon requires a ServerURL in the config.'));
+		}
+
+		if (this._BeaconService && this._BeaconService.isEnabled())
+		{
+			this.log.warn('OratorFileTranslation: beacon already connected.');
+			return fCallback(null);
+		}
+
+		// Register the beacon service type with fable if not already present
+		this.fable.addServiceTypeIfNotExists('UltravisorBeacon', libBeaconService);
+
+		// Default staging path to dist/orator-conversion-staging
+		let tmpStagingPath = pBeaconConfig.StagingPath || require('path').resolve(__dirname, '..', 'dist', 'orator-conversion-staging');
+
+		// Ensure staging directory exists
+		try
+		{
+			require('fs').mkdirSync(tmpStagingPath, { recursive: true });
+		}
+		catch (pMkdirError)
+		{
+			// Already exists — fine
+		}
+
+		// Instantiate the beacon service with the provided config
+		this._BeaconService = this.fable.instantiateServiceProviderWithoutRegistration('UltravisorBeacon',
+			{
+				ServerURL: pBeaconConfig.ServerURL,
+				Name: pBeaconConfig.Name || 'orator-conversion',
+				Password: pBeaconConfig.Password || '',
+				MaxConcurrent: pBeaconConfig.MaxConcurrent || 2,
+				StagingPath: tmpStagingPath,
+				Tags: pBeaconConfig.Tags || {},
+				BindAddresses: pBeaconConfig.BindAddresses || []
+			});
+
+		// Create the MediaConversion capability provider and register it
+		let tmpProvider = new libOratorConversionBeaconProvider(
+			{
+				PdftkPath: this.PdftkPath,
+				PdftoppmPath: this.PdftoppmPath,
+				FfmpegPath: pBeaconConfig.FfmpegPath || 'ffmpeg',
+				FfprobePath: pBeaconConfig.FfprobePath || 'ffprobe',
+				MaxFileSizeBytes: this.MaxFileSize,
+				LogLevel: this.LogLevel
+			});
+
+		// Initialize the provider (checks tool availability), then register and enable
+		tmpProvider.initialize(
+			(pInitError) =>
+			{
+				if (pInitError)
+				{
+					this.log.error(`OratorFileTranslation: beacon provider init failed: ${pInitError.message}`);
+					this._BeaconService = null;
+					return fCallback(pInitError);
+				}
+
+				// Register the capability with the beacon service
+				this._BeaconService.registerCapability(
+					{
+						Capability: tmpProvider.Capability,
+						Name: tmpProvider.Name,
+						actions: tmpProvider.actions,
+						execute: tmpProvider.execute.bind(tmpProvider),
+						initialize: (fCb) => { return fCb(null); },  // Already initialized above
+						shutdown: (fCb) => { return fCb(null); }
+					});
+
+				// Enable the beacon — authenticate, register, begin polling
+				this._BeaconService.enable(
+					(pEnableError, pBeaconInfo) =>
+					{
+						if (pEnableError)
+						{
+							this.log.error(`OratorFileTranslation: beacon enable failed: ${pEnableError.message}`);
+							this._BeaconService = null;
+							return fCallback(pEnableError);
+						}
+
+						this.log.info(`OratorFileTranslation: beacon connected as ${pBeaconInfo.BeaconID}`);
+						return fCallback(null, pBeaconInfo);
+					});
+			});
+	}
+
+	/**
+	 * Disconnect the beacon from the Ultravisor coordinator.
+	 *
+	 * @param {Function} fCallback Called with (pError)
+	 */
+	disconnectBeacon(fCallback)
+	{
+		if (!this._BeaconService || !this._BeaconService.isEnabled())
+		{
+			if (this.log)
+			{
+				this.log.info('OratorFileTranslation: beacon not connected, nothing to disconnect.');
+			}
+			return fCallback(null);
+		}
+
+		this._BeaconService.disable(
+			(pError) =>
+			{
+				if (pError)
+				{
+					this.log.warn(`OratorFileTranslation: beacon disconnect warning: ${pError.message}`);
+				}
+				else
+				{
+					this.log.info('OratorFileTranslation: beacon disconnected.');
+				}
+				this._BeaconService = null;
+				return fCallback(pError || null);
+			});
+	}
 }
 
 module.exports = OratorFileTranslation;

package/source/endpoints/Endpoint-Image-Convert.js

@@ -0,0 +1,33 @@
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libConversionCore = require('../Conversion-Core.js');
+
+class EndpointImageConvert extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'OratorFileTranslationEndpoint-ImageConvert';
+
+		this.converterPath = 'image/convert/:Format';
+	}
+
+	convert(pInputBuffer, pRequest, fCallback)
+	{
+		let tmpParams = pRequest.params || {};
+		let tmpQuery = pRequest.query || {};
+
+		let tmpCore = new libConversionCore();
+
+		let tmpOptions =
+		{
+			Format: tmpParams.Format,
+			Quality: tmpQuery.Quality ? parseInt(tmpQuery.Quality, 10) : undefined
+		};
+
+		tmpCore.imageConvert(pInputBuffer, tmpOptions, fCallback);
+	}
+}
+
+module.exports = EndpointImageConvert;

package/source/endpoints/Endpoint-Image-Resize.js

@@ -0,0 +1,49 @@
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+const libURL = require('url');
+
+const libConversionCore = require('../Conversion-Core.js');
+
+class EndpointImageResize extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'OratorFileTranslationEndpoint-ImageResize';
+
+		this.converterPath = 'image/resize';
+	}
+
+	convert(pInputBuffer, pRequest, fCallback)
+	{
+		let tmpFileTranslation = this.options.FileTranslation;
+
+		let tmpCore = new libConversionCore({
+			MaxFileSize: tmpFileTranslation ? tmpFileTranslation.MaxFileSize : undefined
+		});
+
+		let tmpParams = pRequest.params || {};
+		// Parse query string from the URL if pRequest.query is not available
+		let tmpQuery = pRequest.query || {};
+		if (Object.keys(tmpQuery).length === 0 && pRequest.url)
+		{
+			let tmpParsed = libURL.parse(pRequest.url, true);
+			tmpQuery = tmpParsed.query || {};
+		}
+
+		let tmpOptions =
+		{
+			Width: tmpQuery.Width || tmpParams.Width,
+			Height: tmpQuery.Height || tmpParams.Height,
+			Format: tmpQuery.Format || tmpParams.Format,
+			Quality: tmpQuery.Quality || tmpParams.Quality,
+			Fit: tmpQuery.Fit || tmpParams.Fit,
+			Position: tmpQuery.Position || tmpParams.Position,
+			AutoOrient: tmpQuery.AutoOrient !== 'false'
+		};
+
+		tmpCore.imageResize(pInputBuffer, tmpOptions, fCallback);
+	}
+}
+
+module.exports = EndpointImageResize;

package/source/endpoints/Endpoint-Image-Rotate.js

@@ -0,0 +1,34 @@
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libConversionCore = require('../Conversion-Core.js');
+
+class EndpointImageRotate extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'OratorFileTranslationEndpoint-ImageRotate';
+
+		this.converterPath = 'image/rotate/:Angle';
+	}
+
+	convert(pInputBuffer, pRequest, fCallback)
+	{
+		let tmpCore = new libConversionCore();
+
+		let tmpParams = pRequest.params || {};
+		let tmpQuery = pRequest.query || {};
+
+		let tmpOptions =
+		{
+			Angle: tmpParams.Angle,
+			Flip: (tmpQuery.Flip === 'true' || tmpQuery.Flip === '1'),
+			Flop: (tmpQuery.Flop === 'true' || tmpQuery.Flop === '1')
+		};
+
+		tmpCore.imageRotate(pInputBuffer, tmpOptions, fCallback);
+	}
+}
+
+module.exports = EndpointImageRotate;