orator 3.0.11 → 4.0.1

package/source/Orator.js

@@ -7,19 +7,19 @@
 * @module Orator Service
 */
 
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libDefaultOratorServiceServer = require('./Orator-Default-ServiceServer.js');
+
 const defaultOratorConfiguration = require('./Orator-Default-Configuration.js');
-const defaultOratorServiceServers = require('./Orator-Default-ServiceServers-Node.js');
 
-class Orator
+class Orator extends libFableServiceProviderBase
 {
-	constructor(pFable, pServiceProvider)
+	constructor(pFable, pOptions, pServiceHash)
 	{
-		// We were passed a fully operational fable -- use this
-		this.fable = pFable;
+        super(pFable, pOptions, pServiceHash);
 
-		// Carry core application requirements into the orator object for simplicity
-		this.settings = this.fable.settings;
-		this.log = this.fable.log;
+        this.serviceType = 'Orator';
 
 		// Create the empty, important logic containers
 		this.serviceServer = false;
@@ -31,42 +31,55 @@ class Orator
 		}
 
 		// Now check to see that the ServicePort is set (this used to be APIServerPort)
-		if (!this.settings.hasOwnProperty('ServicePort'))
+		if (!this.options.hasOwnProperty('ServicePort'))
 		{
-			if (this.settings.hasOwnProperty('APIServerPort'))
+			if (this.fable.settings.hasOwnProperty('APIServerPort'))
 			{
 				// Automatically migrate the legacy APIServerPort to ServicePort
-				this.settings.ServicePort = this.fable.settings.APIServerPort;
+				this.options.ServicePort = this.fable.settings.APIServerPort;
 			}
 			else
 			{
 				// Default to whatever the ... default is!
-				this.settings.ServicePort = defaultOratorConfiguration.ServicePort;
+				this.options.ServicePort = defaultOratorConfiguration.ServicePort;
 			}
 		}
 
 		// Now check to see that the Product name is set
-		if (!this.settings.hasOwnProperty('Product'))
+		if (!this.options.hasOwnProperty('Product'))
 		{
-			this.settings.Product = defaultOratorConfiguration.Product;
+			this.options.Product = defaultOratorConfiguration.Product;
 		}
 	}
 
-	initializeServiceServer(fNext)
+	onBeforeInitialize()
 	{
-		var tmpNext = (typeof(fNext) === 'function') ? fNext : ()=>{};
-
+		if (this.fable.settings.LogNoisiness > 3)
+		{
+			this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onBeforeInitialize:`);
+		}
+	}
+	onBeforeInitializeAsync(fNext)
+	{
+		this.onBeforeInitialize();
+		// Check to see if there is a service server active; if not instantiate one (and use IPC if none is registered with Fable as the default provider)
 		if (!this.serviceServer)
 		{
 			// If the developer hasn't set this to a service provider class of their own choosing, 
+			// TODO: Give the developer a chance to set a service provider instantiation address of their own choosing.
 			// use the built-in network-less one.
-			if (!this.serviceServerProvider)
+			if (!this.fable.OratorServiceServer)
 			{
-				this.serviceServerProvider = defaultOratorServiceServers.default;
+				// If there isn't a default Service Server setup, create one.
+				let tmpServiceServerOptions = (typeof(this.options.ServiceServerOptions) == 'undefined') ? {} : this.options.ServiceServerOptions;
+				if (!this.fable.serviceManager.servicesMap.hasOwnProperty('OratorServiceServer'))
+				{
+					// Only register IPC if there isn't one yet.
+					this.fable.serviceManager.addServiceType('OratorServiceServer', libDefaultOratorServiceServer);
+				}
+				this.fable.serviceManager.instantiateServiceProvider('OratorServiceServer', tmpServiceServerOptions, 'OratorServiceServer-AutoInit');
 			}
-
-			this.serviceServer = new this.serviceServerProvider(this);
-
+			this.serviceServer = this.fable.OratorServiceServer;
 			// For legacy reasons, we also will provide this under the "webServer" variable.
 			this.webServer = this.serviceServer;
 		}
@@ -74,58 +87,151 @@ class Orator
 		{
 			this.log.warn(`Orator attempting to initialize a service server after initialization has already completed.`)
 		}
+		fNext();
+	}
 
-		return tmpNext()
+	onInitialize()
+	{
+		if (this.fable.settings.LogNoisiness > 3)
+		{
+			this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onInitialize:`);
+		}
+	}
+	onInitializeAsync(fNext)
+	{
+		this.onInitialize();
+		return fNext();
+	}
+
+	onAfterInitialize()
+	{
+		if (this.fable.settings.LogNoisiness > 3)
+		{
+			this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} onAfterInitialize:`);
+		}
+	}
+	onAfterInitializeAsync(fNext)
+	{
+		this.onAfterInitialize();
+		return fNext();
 	}
 
-	_startServiceListener(fNext)
+	initialize(fCallback)
 	{
+		// I hate this -- is there a reason to not require a callback?
+		let tmpCallback = (typeof(fCallback) === 'function') ? fCallback : () => {};
+
+		if (!this.initializeTimestamp)
+		{
+			let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+			if (this.fable.LogNoisiness > 3)
+			{
+				this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} beginning initialization steps...`);
+			}
+
+			tmpAnticipate.anticipate(this.onBeforeInitializeAsync.bind(this));
+			tmpAnticipate.anticipate(this.onInitializeAsync.bind(this));
+			tmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));
+
+			tmpAnticipate.wait(
+				(pError) =>
+				{
+					this.initializeTimestamp = this.fable.log.getTimeStamp();
+					if (this.fable.LogNoisiness > 2)
+					{
+						this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} initialization steps complete.`);
+					}
+					return tmpCallback(pError);
+				});
+		}
+		else
+		{
+			this.log.warn(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} async initialize called but initialization is already completed.  Aborting.`);
+			// TODO: Should this be returning an error?
+			return tmpCallback();
+		}
+	}
+
+	onBeforeStartService(fNext)
+	{
+		return fNext();
+	}
+	onStartService(fNext)
+	{
+		this.onAfterInitialize();
 		return this.serviceServer.listen
 		(
-			this.settings.ServicePort,
+			this.options.ServicePort,
 			(pError)	=>
 			{
-				this.log.info(`${this.serviceServer.Name} listening at ${this.serviceServer.URL} port ${this.serviceServer.Port}`);
+				this.log.info(`${this.serviceServer.Name} listening on port ${this.options.ServicePort}`);
 				return fNext(pError);
 			}
 		);
 	}
+	onAfterStartService(fNext)
+	{
+		return fNext();
+	}
 
 	startService(fNext)
 	{
 		var tmpNext = (typeof(fNext) === 'function') ? fNext : ()=>{};
 
+		let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+		if (this.fable.LogNoisiness > 3)
+		{
+			this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} beginning startService steps...`);
+		}
+
+		// Auto initialize if there is no serviceServer
 		if (!this.serviceServer)
 		{
-			this.initializeServiceServer();
+			tmpAnticipate.anticipate(this.initialize.bind(this));
 		}
 
-		return this._startServiceListener(tmpNext);
+		tmpAnticipate.anticipate(this.onBeforeStartService.bind(this));
+		tmpAnticipate.anticipate(this.onStartService.bind(this));
+		tmpAnticipate.anticipate(this.onAfterStartService.bind(this));
+
+		tmpAnticipate.wait(
+			(pError) =>
+			{
+				this.startServiceTimestamp = this.fable.log.getTimeStamp();
+				if (this.fable.LogNoisiness > 2)
+				{
+					this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} startService steps complete.`);
+				}
+				return tmpNext(pError);
+			});
 	}
 
-	stopService(fNext)
+	stopService(fCallback)
 	{
-		var tmpNext = (typeof(fNext) === 'function') ? fNext : ()=>{};
+		var tmpCallback = (typeof(fCallback) === 'function') ? fCallback : ()=>{};
 
 		if (!this.serviceServer)
 		{
 			let tmpMessage = `Orator attempting to stop a service server but the service server has not been intialized yet.`;
 			this.log.warn(tmpMessage);
-			return tmpNext(tmpMessage);
+			return tmpCallback(tmpMessage);
 		}
 
 		if (!this.serviceServer.Active)
 		{
 			let tmpMessage = `Orator attempting to stop a service server but the service server is not actively running.`;
 			this.log.warn(tmpMessage);
-			return tmpNext(tmpMessage);
+			return tmpCallback(tmpMessage);
 		}
 
-		return this.serviceServer.close(tmpNext);
+		return this.serviceServer.close(tmpCallback);
 	}
 
 	invoke(pMethod, pRoute, pData, fCallback)
 	{
+		//this.log.trace(`Orator [${this.UUID}]::[${this.Hash}] ${this.options.Product} invoking ${pMethod} ${pRoute}`);
 		return this.serviceServer.invoke(pMethod, pRoute, pData, fCallback);
 	}
 
@@ -162,4 +268,5 @@ class Orator
 }
 
 module.exports = Orator;
-module.exports.ServiceServerBase = require('./Orator-ServiceServer-Base.js');
+module.exports.ServiceServerBase = require('orator-serviceserver-base');
+module.exports.ServiceServerIPC = require('./Orator-ServiceServer-IPC.js');

package/test/Orator_basic_tests.js

@@ -14,11 +14,12 @@ const Assert = Chai.assert;
 
 //const libSuperTest = require('supertest');
 const libFable = require('fable');
-const _Fable = new libFable(
+
+const defaultFableSettings = (
 	{
 		Product:'Orator-BasicTests-Backplane',
 		ProductVersion: '0.0.0',
-		APIServerPort: 8099
+		APIServerPort: 0
 	});
 
 suite
@@ -36,11 +37,13 @@ suite
 					'initialize should build a happy little object',
 					(fDone) =>
 					{
-						let tmpOrator = new libOrator(_Fable);
+						let tmpFable = new libFable(defaultFableSettings);
+						tmpFable.serviceManager.addServiceType('Orator', libOrator);
+						let tmpOrator = tmpFable.serviceManager.instantiateServiceProvider('Orator', {});
 						Expect(tmpOrator).to.be.an('object', 'Orator should initialize as an object directly from the require statement.');
 						Expect(tmpOrator.startService).to.be.an('function');
-						Expect(tmpOrator.settings).to.be.an('object');
-						tmpOrator.initializeServiceServer(
+						Expect(tmpOrator.options).to.be.an('object');
+						tmpOrator.initialize(
 							(pError)=>
 							{
 								Expect(tmpOrator.serviceServer.ServiceServerType).to.equal('IPC', 'The default service server provider should be IPC.');
@@ -51,14 +54,36 @@ suite
 
 				test
 				(
-					'orator should be able to initialize and start a service with no effort',
+					'orator should be able to initialize and start a service with discrete steps for init and start',
 					(fDone) =>
 					{
-						let tmpOrator = new libOrator(_Fable);
-						// Start the service server
-						tmpOrator.initializeServiceServer();
+						let tmpFable = new libFable(defaultFableSettings);
+						tmpFable.serviceManager.addServiceType('Orator', libOrator);
+						let tmpOrator = tmpFable.serviceManager.instantiateServiceProvider('Orator', {});
 						// Start the service
-						Expect(tmpOrator.serviceServer.Active).to.equal(false);
+						tmpOrator.initialize(
+							() =>
+							{
+								Expect(tmpOrator.serviceServer.Active).to.equal(false);
+								tmpOrator.startService(
+									()=>
+									{
+										Expect(tmpOrator.serviceServer.Active).to.equal(true);
+										fDone();
+									});
+							})
+					}
+				);
+
+				test
+				(
+					'orator should be able to initialize IPC and start a service with no effort',
+					(fDone) =>
+					{
+						let tmpFable = new libFable(defaultFableSettings);
+						tmpFable.serviceManager.addServiceType('Orator', libOrator);
+						let tmpOrator = tmpFable.serviceManager.instantiateServiceProvider('Orator', {});
+						// Start the service, which will implicitly call initialize
 						tmpOrator.startService(
 							()=>
 							{
@@ -73,12 +98,11 @@ suite
 					'ipc should be able to provide basic endpoint functionality',
 					(fDone) =>
 					{
-						let tmpOrator = new libOrator(_Fable);
-						// Initialize the service server
-						tmpOrator.initializeServiceServer();
+						let tmpFable = new libFable(defaultFableSettings);
+						tmpFable.serviceManager.addServiceType('Orator', libOrator);
+						let tmpOrator = tmpFable.serviceManager.instantiateServiceProvider('Orator', {});
 						// Start the service
 						tmpOrator.startService();
-
 						tmpOrator.serviceServer.get
 						(
 							'/test/:hash',
@@ -109,9 +133,10 @@ suite
 					'ipc should be able to process any number of handler additions with the use function',
 					(fDone) =>
 					{
-						let tmpOrator = new libOrator(_Fable);
-						// Initialize the service server
-						tmpOrator.initializeServiceServer();
+						let tmpFable = new libFable(defaultFableSettings);
+						tmpFable.serviceManager.addServiceType('Orator', libOrator);
+						let tmpOrator = tmpFable.serviceManager.instantiateServiceProvider('Orator', {});
+
 						// Start the service
 						tmpOrator.startService();
 
@@ -130,7 +155,7 @@ suite
 							}
 						);
 
-						_Fable.Utility.waterfall([
+						tmpFable.Utility.waterfall([
 								(fStageComplete) =>
 								{
 									let tmpURI = `/MagicEndpoint/BippityBoppityBoo`;

package/test_legacy/Orator_basic_tests.js

@@ -150,7 +150,7 @@ suite
 												.end(
 													function (pError, pResponse)
 													{
-														_Orator.settings.Profiling.TraceLog = true;
+														_Orator.options.Profiling.TraceLog = true;
 														Expect(pResponse.text)
 															.to.contain('50000px');
 														libSuperTest('http://localhost:8099/')

package/test_legacy/Orator_cluster_test.js.deferred

@@ -152,7 +152,7 @@ suite
 											.end(
 												function (pError, pResponse)
 												{
-													_Orator.settings.Profiling.TraceLog = true;
+													_Orator.options.Profiling.TraceLog = true;
 													Expect(pResponse.text)
 														.to.contain('50000px');
 													libSuperTest('http://localhost:8099/')

package/test_legacy/Orator_logging_tests.js

@@ -116,7 +116,7 @@ suite
 												.to.contain('dire');
 										}
 										// Next uncaught exception should be passed through without logging the stack trace
-										_Orator.settings.LogStackTraces = false;
+										_Orator.options.LogStackTraces = false;
 										fDone();
 									}
 								);

package/source/Orator-Default-ServiceServers-Node.js

@@ -1,21 +0,0 @@
-/**
-* Default Service Server Function
-*
-* @license MIT
-*
-* @author Steven Velozo <steven@velozo.com>
-*/
-
-// Return the servers that are available without extensions loaded
-getDefaultServiceServers = () =>
-{
-	let tmpDefaultServiceServers = {};
-
-	tmpDefaultServiceServers.ipc = require('./Orator-ServiceServer-IPC.js');
-
-	tmpDefaultServiceServers.default = tmpDefaultServiceServers.ipc;
-
-	return tmpDefaultServiceServers;
-}
-
-module.exports = getDefaultServiceServers();

package/source/Orator-Default-ServiceServers-Web.js

@@ -1,21 +0,0 @@
-/**
-* Default Service Server Function
-*
-* @license MIT
-*
-* @author Steven Velozo <steven@velozo.com>
-*/
-
-// Return the servers that are available without extensions loaded
-getDefaultServiceServers = () =>
-{
-	let tmpDefaultServiceServers = {};
-
-	tmpDefaultServiceServers.ipc = require('./Orator-ServiceServer-IPC.js');
-
-	tmpDefaultServiceServers.default = tmpDefaultServiceServers.ipc;
-
-	return tmpDefaultServiceServers;
-}
-
-module.exports = getDefaultServiceServers();

package/source/Orator-ServiceServer-Base.js

@@ -1,225 +0,0 @@
-class OratorServiceServerBase
-{
-	constructor(pOrator)
-	{
-		this.orator = pOrator;
-
-		this.log = pOrator.log;
-
-		this.ServiceServerType = 'Base';
-
-		this.Name = this.orator.settings.Product;
-		this.URL = 'BASE_SERVICE_SERVER';
-		this.Port = this.orator.settings.ServicePort;
-
-		this.Active = false;
-	}
-
-	/*
-	 * Service Lifecycle Functions
-	 *************************************************************************/
-	listen(pPort, fCallback)
-	{
-		// Sometimes, listen does not listen on network calls.
-		this.Active = true;
-
-		return fCallback();
-	}
-
-	close(fCallback)
-	{
-		this.Active = false;
-
-		return fCallback();
-	}
-	/*************************************************************************
-	 * End of Service Lifecycle Functions
-	 */
-
-	/*
-	 * Content parsing functions
-	 *************************************************************************/
-	bodyParser(pOptions)
-	{
-		return (pRequest, pResponse, fNext) => 
-			{
-				fNext();
-			};
-	}
-	/*************************************************************************
-	 * End of Service Lifecycle Functions
-	 */
-
-	/*
-	 * Service Route Creation Functions
-	 *
-	 * These base functions provide basic validation for the routes, but don't actually 
-	 * do anything with them.  The design intent here is to allow derived classes to call
-	 * these functions to validate that they conform to expected standards.
-	 *
-	 * Something like:
-
-		get (pRoute, ...fRouteProcessingFunctions)
-		{
-			if (!super.get(pRoute, ...fRouteProcessingFunctions))
-			{
-				this.log.error(`Restify provider failed to map route [${pRoute}]!`);
-				return false;
-			}
-
-			//...now we can do our actual get mapping function!....
-		}
-
-	 * This pattern and calling super is totally optional, obviously.
-	 *************************************************************************/
-	use(fHandlerFunction)
-	{
-		if (typeof(fHandlerFunction) != 'function')
-		{
-			this.log.error(`Orator USE global handler mapping failed -- parameter was expected to be a function with prototype function(Request, Response, Next) but type was ${typeof(fHandlerFunction)} instead of a string.`)
-			return false;
-		}
-
-		return true;
-	}
-
-	doGet(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	get(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator GET Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doGet(pRoute, ...fRouteProcessingFunctions);
-	}
-	getWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.get(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doPut(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	put(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator PUT Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doPut(pRoute, ...fRouteProcessingFunctions);
-	}
-	putWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.put(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doPost(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	post(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator POST Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doPost(pRoute, ...fRouteProcessingFunctions);
-	}
-	postWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.post(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doDel(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	del(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator DEL Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doDel(pRoute, ...fRouteProcessingFunctions);
-	}
-	delWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.del(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doPatch(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	patch(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator PATCH Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doPatch(pRoute, ...fRouteProcessingFunctions);
-	}
-	patchWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.patch(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doOpts(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	opts(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator OPTS Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doOpts(pRoute, ...fRouteProcessingFunctions);
-	}
-	optsWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.opts(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doHead(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	head(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator HEAD Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-
-		return true;
-	}
-	headWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.head(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-	/*************************************************************************
-	 * End of Service Route Creation Functions
-	 */
-
-	// Programmatically invoke a route
-	invoke(pMethod, pRoute, pData, fCallback)
-	{
-		// The base class version of this does nothing
-		this.log.debug(`Orator invoke called for route [${pRoute}] and landed on the base class; the service provider likely does not implement programmatic invoke capabilities.`, pData);
-		return false;
-	}
-}
-
-module.exports = OratorServiceServerBase;