fable 3.0.116 → 3.0.118

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.116",
+    "version": "3.0.118",
     "description": "Anentity behavior management and API bundling library.",
     "main": "source/Fable.js",
     "scripts": {

package/source/services/Fable-Service-Operation-DefaultSettings.js

@@ -1,25 +1,20 @@
 module.exports = (
-    {
-        "Metadata": {
-            "UUID": false,
-            "Hash": false,
+	{
+		"Metadata": {
+			"UUID": false,
+			"Hash": false,
 
-            "Name": "",
-            "Summary": "",
+			"Name": "",
+			"Summary": "",
 
-            "Version": 0
-        },
-        "Status": {
-            "Completed": false,
-
-            "CompletionProgress": 0,
-            "CompletionTimeElapsed": 0,
-
-            "TimeStart": 0,
-            "TimeEnd": 0
-        },
-        "Steps": [],
-        "Errors": [],
-        "Log": []
-    }
+			"Version": 0
+		},
+		"Status": {
+			"Completed": false,
+			"StepCount": 0
+		},
+		"Steps": [],
+		"Errors": [],
+		"Log": []
+	}
 );

package/source/services/Fable-Service-Operation.js

@@ -1,3 +1,4 @@
+const { PE } = require('big.js');
 const libFableServiceBase = require('fable-serviceproviderbase');
 
 const _OperationStatePrototypeString = JSON.stringify(require('./Fable-Service-Operation-DefaultSettings.js'));
@@ -12,9 +13,6 @@ class FableOperation extends libFableServiceBase
 		// Timestamps will just be the long ints
 		this.timeStamps = {};
 
-		// ProgressTrackers have an object format of: {Hash:'SomeHash',EndTime:UINT,CurrentTime:UINT,TotalCount:INT,CurrentCount:INT}
-		this.progressTrackers = {};
-
         this.serviceType = 'PhasedOperation';
 
 		this.state = JSON.parse(_OperationStatePrototypeString);
@@ -29,113 +27,136 @@ class FableOperation extends libFableServiceBase
 		this.state.Metadata.Name = (typeof(this.options.Name) == 'string') ? this.options.Name : `Unnamed Operation ${this.state.Metadata.UUID}`;
 		this.name = this.state.Metadata.Name;
 
+		this.progressTrackers = this.fable.instantiateServiceProviderWithoutRegistration('ProgressTracker');
+
+		this.state.OverallProgressTracker = this.progressTrackers.createProgressTracker(`Overall-${this.state.Metadata.UUID}`);
+
+		// This is here to use the pass-through logging functions in the operation itself.
 		this.log = this;
 	}
 
 	execute(fExecutionCompleteCallback)
 	{
 		// TODO: Should the same operation be allowed to execute more than one time?
-		if (this.state.Status.TimeStart)
+		if (this.state.OverallProgressTracker.StartTimeStamp > 0)
 		{
 			return fExecutionCompleteCallback(new Error(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} has already been executed!`));
 		}
 
-		this.state.Status.TimeStart = +new Date();
-
 		let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+		
+		this.progressTrackers.setProgressTrackerTotalOperations(this.state.OverallProgressTracker.Hash, this.state.Status.StepCount);
+		this.progressTrackers.startProgressTracker(this.state.OverallProgressTracker.Hash);
+		this.info(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} starting...`);
 
-		for (let i = 0; i < this.state.Steps; i++)
+		for (let i = 0; i < this.state.Steps.length; i++)
 		{
-			tmpAnticipate.anticipate(this.stepFunctions[this.state.Steps[i].GUIDStep].bind(this));
+			tmpAnticipate.anticipate(
+				function(fNext)
+				{
+					this.fable.log.info(`Step #${i} [${this.state.Steps[i].GUIDStep}] ${this.state.Steps[i].Name} starting...`);
+					this.progressTrackers.startProgressTracker(this.state.Steps[i].ProgressTracker.Hash);
+					return fNext();
+				}.bind(this));
+			// Steps are executed in a custom context with 
+			tmpAnticipate.anticipate(this.stepFunctions[this.state.Steps[i].GUIDStep].bind(
+				{
+					log:this,
+					fable:this.fable,
+					options:this.state.Steps[i].Metadata,
+					metadata:this.state.Steps[i].Metadata,
+					ProgressTracker:this.progressTrackers.getProgressTracker(this.state.Steps[i].ProgressTracker.Hash),
+					updateProgressTracker: function(pProgressAmount)
+						{
+							return this.progressTrackers.updateProgressTracker(this.state.Steps[i].ProgressTracker.Hash, pProgressAmount);
+						}.bind(this),
+					incrementProgressTracker: function(pProgressIncrementAmount)
+						{
+							return this.progressTrackers.incrementProgressTracker(this.state.Steps[i].ProgressTracker.Hash, pProgressIncrementAmount);
+						}.bind(this),
+					setProgressTrackerTotalOperations: function(pTotalOperationCount)
+						{
+							return this.progressTrackers.setProgressTrackerTotalOperations(this.state.Steps[i].ProgressTracker.Hash, pTotalOperationCount);
+						}.bind(this),
+					getProgressTrackerStatusString: function() 
+						{
+							return this.progressTrackers.getProgressTrackerStatusString(this.state.Steps[i].ProgressTracker.Hash);
+						}.bind(this),
+					logProgressTrackerStatus: function() 
+						{
+							return this.log.info(`Step #${i} [${this.state.Steps[i].GUIDStep}]: ${this.progressTrackers.getProgressTrackerStatusString(this.state.Steps[i].ProgressTracker.Hash)}`);
+						}.bind(this),
+					OperationState:this.state,
+					StepState:this.state.Steps[i]
+				}));
+			tmpAnticipate.anticipate(
+				function(fNext)
+				{
+					this.progressTrackers.endProgressTracker(this.state.Steps[i].ProgressTracker.Hash);
+					let tmpStepTimingMessage = this.progressTrackers.getProgressTrackerStatusString(this.state.Steps[i].ProgressTracker.Hash);
+					this.fable.log.info(`Step #${i} [${this.state.Steps[i].GUIDStep}] ${this.state.Steps[i].Name} complete.`);
+					this.fable.log.info(`Step #${i} [${this.state.Steps[i].GUIDStep}] ${this.state.Steps[i].Name} ${tmpStepTimingMessage}.`);
+			
+					this.progressTrackers.incrementProgressTracker(this.state.OverallProgressTracker.Hash, 1);
+					let tmpOperationTimingMessage = this.progressTrackers.getProgressTrackerStatusString(this.state.OverallProgressTracker.Hash);
+					this.fable.log.info(`Operation [${this.state.Metadata.UUID}] ${tmpOperationTimingMessage}.`);
+					return fNext();
+				}.bind(this));
 		}
 
 		// Wait for the anticipation to complete
 		tmpAnticipate.wait(
 			(pError) =>
 			{
-				this.state.Status.TimeEnd = +new Date();
+				if (pError)
+				{
+					this.fable.log.error(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} had an error: ${pError}`, pError);
+					return fExecutionCompleteCallback(pError);
+				}
+				this.info(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} complete.`);
+				let tmpOperationTimingMessage = this.progressTrackers.getProgressTrackerStatusString(this.state.OverallProgressTracker.Hash);
+				this.progressTrackers.endProgressTracker(this.state.OverallProgressTracker.Hash);
+				this.fable.log.info(`Operation [${this.state.Metadata.UUID}] ${tmpOperationTimingMessage}.`);
 				return fExecutionCompleteCallback();
 			});
 	}
 
-/*
-	TODO: I've gone back and forth on whether this should be an object, JSON 
-	object prototype, or set of functions here.  Discuss with colleagues!
-*/
-	addStep(fStepFunction, pStepName, pStepDescription, pStepMetadata, pGUIDStep)
+	addStep(fStepFunction, pStepMetadata, pStepName, pStepDescription, pGUIDStep)
 	{
 		let tmpStep = {};
 
 		// GUID is optional
 		tmpStep.GUIDStep = (typeof(pGUIDStep) !== 'undefined') ? pGUIDStep : `STEP-${this.state.Steps.length}-${this.fable.DataGeneration.randomNumericString()}`;
 
+
 		// Name is optional
 		tmpStep.Name = (typeof(pStepName) !== 'undefined') ? pStepName : `Step [${tmpStep.GUIDStep}]`;
 		tmpStep.Description = (typeof(pStepDescription) !== 'undefined') ? pStepDescription : `Step execution of ${tmpStep.Name}.`;
 
-		tmpStep.Metadata = (typeof(pStepMetadata) === 'object') ? pStepMetadata : {};
+		tmpStep.ProgressTracker = this.progressTrackers.createProgressTracker(tmpStep.GUIDStep);
 
-		tmpStep.TimeStart = false;
-		tmpStep.TimeEnd = false;
+		tmpStep.Metadata = (typeof(pStepMetadata) === 'object') ? pStepMetadata : {};
 
 		// There is an array of steps, in the Operation State itself ... push a step there
 		this.state.Steps.push(tmpStep);
 
-		this.stepFunctions[tmpStep.GUIDStep] = fStepFunction;;
+		this.stepMap[tmpStep.GUIDStep] = tmpStep;
 
-		this.stepMap[tmpStep.GUIDStep];
+		this.stepFunctions[tmpStep.GUIDStep] = typeof(fStepFunction) == 'function' ? fStepFunction : function (fDone) { return fDone(); };
 
 		this.state.Status.StepCount++;
 
 		return tmpStep;
 	}
 
-	/**
-	 * Retrieves a step from the step map based on the provided GUID.
-	 * @param {string} pGUIDStep - The GUID of the step to retrieve.
-	 * @returns {object|boolean} - The step object if found, otherwise false.
-	 */
-	getStep(pGUIDStep)
+	setStepTotalOperations(pGUIDStep, pTotalOperationCount)
 	{
-		if (this.stepMap.hasOwnProperty(pGUIDStep))
+		if (!this.stepMap.hasOwnProperty(pGUIDStep))
 		{
-			return this.stepMap[pGUIDStep];
+			return new Error(`Step [${pGUIDStep}] does not exist in operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} when attempting to set total operations to ${pTotalOperationCount}.`);
 		}
 
-		return false;
-	}
-
-	/**
-	 * Begins a step in the Fable service operation.
-	 * @param {string} pGUIDStep - The GUID of the step to begin.
-	 * @returns {object|boolean} - The step object if found, or `false` if not found.
-	 */
-	beginStep(pGUIDStep)
-	{
-		let tmpStep = this.getStep(pGUIDStep);
-
-		if (tmpStep === false)
-		{
-			return false;
-		}
-
-		tmpStep.TimeStart = +new Date();
-
-		return tmpStep;
-	}
-
-	endStep(pGUIDStep)
-	{
-		let tmpStep = this.getStep(pGUIDStep);
-
-		if (tmpStep === false)
-		{
-			return false;
-		}
-
-		tmpStep.TimeEnd = +new Date();
-
-		return tmpStep;
+		this.progressTrackers.setProgressTrackerTotalOperations(this.stepMap[pGUIDStep].ProgressTracker.Hash, pTotalOperationCount);
 	}
 
 	writeOperationLog(pLogLevel, pLogText, pLogObject)

package/source/services/Fable-Service-ProgressTime.js

@@ -15,6 +15,11 @@ class FableServiceProgressTime extends libFableServiceBase
 	{
 		let tmpTimeDuration = typeof(pTimeDurationInMilliseconds) == 'number' ? pTimeDurationInMilliseconds : 0;
 
+		if (pTimeDurationInMilliseconds < 0)
+		{
+			return 'unknown';
+		}
+
 		let tmpTimeDurationString = '';
 		if (tmpTimeDuration > 3600000)
 		{

package/source/services/Fable-Service-ProgressTracker.js

@@ -23,7 +23,7 @@ class FableServiceProgressTracker extends libFableServiceBase
 
 		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
 		{
-			this.fable.log.warn(`Progress Tracker ${tmpProgressTrackerHash} does not exist!  Creating a new tracker...`);
+			this.fable.log.warn(`ProgressTracker ${tmpProgressTrackerHash} does not exist!  Creating a new tracker...`);
 			this.createProgressTracker(tmpProgressTrackerHash, 100);
 		}
 
@@ -46,6 +46,8 @@ class FableServiceProgressTracker extends libFableServiceBase
 				EndTimeStamp: -1,
 
 				PercentComplete: -1,
+				// If this is set to true, PercentComplete will be calculated as CurrentCount / TotalCount even if it goes over 100%
+				AllowTruePercentComplete: false,
 
 				ElapsedTime: -1,
 				AverageOperationTime: -1,
@@ -58,7 +60,7 @@ class FableServiceProgressTracker extends libFableServiceBase
 
 		if (this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
 		{
-			this.fable.log.warn(`Progress Tracker ${tmpProgressTrackerHash} already exists!  Overwriting with a new tracker...`);
+			this.fable.log.warn(`ProgressTracker ${tmpProgressTrackerHash} already exists!  Overwriting with a new tracker...`);
 			this.progressTimes.removeTimeStamp(tmpProgressTracker.StartTimeHash);
 			this.progressTimes.removeTimeStamp(tmpProgressTracker.EndTimeHash);
 		}
@@ -68,11 +70,27 @@ class FableServiceProgressTracker extends libFableServiceBase
 		return tmpProgressTracker;
 	}
 
+	setProgressTrackerTotalOperations(pProgressTrackerHash, pTotalOperations)
+	{
+		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'Default';
+		let tmpTotalOperations = (typeof(pTotalOperations) == 'number') ? pTotalOperations : 100;
+
+		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
+		{
+			this.fable.log.warn(`Attempted to set the total operations of ProgressTracker ${tmpProgressTrackerHash} but it does not exist!  Creating a new tracker...`);
+			this.createProgressTracker(tmpProgressTrackerHash, tmpTotalOperations);
+		}
+
+		this.progressTrackers[tmpProgressTrackerHash].TotalCount = tmpTotalOperations;
+
+		return this.progressTrackers[tmpProgressTrackerHash];
+	}
+
 	startProgressTracker(pProgressTrackerHash)
 	{
 		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'Default';
 
-		// This is the only method to lazily create Progress Trackers now
+		// This is the only method to lazily create ProgressTrackers now
 		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
 		{
 			this.createProgressTracker(tmpProgressTrackerHash, 100);
@@ -82,6 +100,10 @@ class FableServiceProgressTracker extends libFableServiceBase
 
 		this.progressTimes.createTimeStamp(this.progressTrackers[tmpProgressTrackerHash].StartTimeHash);
 		tmpProgressTracker.StartTimeStamp = this.progressTimes.getTimeStampValue(this.progressTrackers[tmpProgressTrackerHash].StartTimeHash);
+		if (tmpProgressTracker.CurrentCount < 0)
+		{
+			tmpProgressTracker.CurrentCount = 0;
+		}
 
 		return this.solveProgressTrackerStatus(tmpProgressTrackerHash);
 	}
@@ -92,10 +114,12 @@ class FableServiceProgressTracker extends libFableServiceBase
 
 		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
 		{
-			this.fable.log.error(`Attempted to end Progress Tracker ${tmpProgressTrackerHash} that does not exist!`);
+			this.fable.log.error(`Attempted to end ProgressTracker ${tmpProgressTrackerHash} that does not exist!`);
 			return false;
 		}
 
+		let tmpProgressTracker = this.progressTrackers[tmpProgressTrackerHash];
+
 		this.progressTimes.createTimeStamp(this.progressTrackers[tmpProgressTrackerHash].EndTimeHash);
 		tmpProgressTracker.EndTimeStamp = this.progressTimes.getTimeStampValue(this.progressTrackers[tmpProgressTrackerHash].EndTimeHash);
 
@@ -108,7 +132,7 @@ class FableServiceProgressTracker extends libFableServiceBase
 
 		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
 		{
-			this.fable.log.error(`Attempted to solve Progress Tracker ${tmpProgressTrackerHash} that does not exist!`);
+			this.fable.log.error(`Attempted to solve ProgressTracker ${tmpProgressTrackerHash} that does not exist!`);
 			return false;
 		}
 
@@ -116,7 +140,7 @@ class FableServiceProgressTracker extends libFableServiceBase
 
 		if ((tmpProgressTracker.TotalCount < 1) || isNaN(tmpProgressTracker.TotalCount))
 		{
-			this.fable.log.error(`Progress Tracker ${tmpProgressTracker.Hash} has an invalid total count of operations (${tmpProgressTracker.TotalCount}!  Setting it to the default of 100...`);
+			this.fable.log.error(`ProgressTracker ${tmpProgressTracker.Hash} has an invalid total count of operations (${tmpProgressTracker.TotalCount}!  Setting it to the default of 100...`);
 			tmpProgressTracker.TotalCount = 100;
 		}
 
@@ -124,18 +148,27 @@ class FableServiceProgressTracker extends libFableServiceBase
 		if (tmpProgressTracker.CurrentCount < 1)
 		{
 			tmpProgressTracker.PercentComplete = 0;
-			return tmpProgressTracker;
 		}
 		else
 		{
 			tmpProgressTracker.PercentComplete = (tmpProgressTracker.CurrentCount / tmpProgressTracker.TotalCount) * 100.0;
 		}
 
+		if (!tmpProgressTracker.AllowTruePercentComplete && (tmpProgressTracker.PercentComplete > 100))
+		{
+			tmpProgressTracker.PercentComplete = 100;
+		}
+
 		// Compute the average time per operation
 		this.progressTimes.updateTimeStampValue('CurrentTime');
 		tmpProgressTracker.CurrentTimeStamp = this.progressTimes.getTimeStampValue('CurrentTime');
 		tmpProgressTracker.ElapsedTime = tmpProgressTracker.CurrentTimeStamp - tmpProgressTracker.StartTimeStamp;
 
+		if (tmpProgressTracker.EndTimeStamp > 0)
+		{
+			tmpProgressTracker.ElapsedTime = tmpProgressTracker.EndTimeStamp - tmpProgressTracker.StartTimeStamp;
+		}
+
 		if (tmpProgressTracker.CurrentCount > 0)
 		{
 			tmpProgressTracker.AverageOperationTime = (tmpProgressTracker.CurrentTimeStamp-tmpProgressTracker.StartTimeStamp) / tmpProgressTracker.CurrentCount;
@@ -165,7 +198,7 @@ class FableServiceProgressTracker extends libFableServiceBase
 
 		if (isNaN(tmpCurrentOperations))
 		{
-			this.fable.log.warn(`Attempted to update Progress Tracker ${tmpProgressTrackerHash} with an invalid number of operations!`)
+			this.fable.log.warn(`Attempted to update ProgressTracker ${tmpProgressTrackerHash} with an invalid number of operations!`)
 			return false;
 		}
 
@@ -191,13 +224,13 @@ class FableServiceProgressTracker extends libFableServiceBase
 
 		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
 		{
-			this.fable.log.warn(`Attempted to increment Progress Tracker ${tmpProgressTrackerHash} but it did not exist.`);
+			this.fable.log.warn(`Attempted to increment ProgressTracker ${tmpProgressTrackerHash} but it did not exist.`);
 			return false;
 		}
 
 		if (this.progressTrackers[tmpProgressTrackerHash].StartTimeStamp < 1)
 		{
-			this.fable.log.warn(`Attempted to increment Progress Tracker ${tmpProgressTrackerHash} but it was not started.. starting now.`);
+			this.fable.log.warn(`Attempted to increment ProgressTracker ${tmpProgressTrackerHash} but it was not started.. starting now.`);
 			this.startProgressTracker(tmpProgressTrackerHash);
 		}
 
@@ -206,32 +239,113 @@ class FableServiceProgressTracker extends libFableServiceBase
 		return this.solveProgressTrackerStatus(tmpProgressTrackerHash);
 	}
 
-	logProgressTrackerStatus(pProgressTrackerHash)
+	getProgressTrackerCompletedOperationCountString(pProgressTrackerHash)
+	{
+		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'Default';
+
+		// This call here can mean if we add operations and then immediately get the string, this function runs twice.
+		const tmpProgressTracker = this.progressTrackers[tmpProgressTrackerHash];
+
+		// The states of a progress tracker:
+		if (tmpProgressTracker.CurrentCount < 0)
+		{
+			return `none`;
+		}
+		else if (tmpProgressTracker.CurrentCount < 1)
+		{
+			return `0`;
+		}
+		else
+		{
+			return `${tmpProgressTracker.CurrentCount}`;
+		}
+	}
+
+	getProgressTrackerPercentCompleteString(pProgressTrackerHash)
 	{
 		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'Default';
 
+		// This call here can mean if we add operations and then immediately get the string, this function runs twice.
+		// TODO: Is there a pattern to avoid this double call that's worth putting in?
+		this.solveProgressTrackerStatus(tmpProgressTrackerHash);
+
 		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
 		{
-			this.fable.log.info(`>> Progress Tracker ${tmpProgressTrackerHash} does not exist!  No stats to display.`);
+			return `ProgressTracker ${tmpProgressTrackerHash} does not exist!  No stats to display.`;
 		}
 		else
 		{
 			const tmpProgressTracker = this.progressTrackers[tmpProgressTrackerHash];
 
+			// The states of a progress tracker:
+			// 1. Not started
+			if (tmpProgressTracker.StartTimeStamp < 1)
+			{
+				return `0%`;
+			}
+			// 2. Started, but no operations completed
+
 			if (tmpProgressTracker.CurrentCount < 1)
 			{
-				this.fable.log.info(`>> Progress Tracker ${tmpProgressTracker.Hash} has no completed operations.  ${tmpProgressTracker.CurrentTime}ms have elapsed since it was started.`);
+				return `0%`;
 			}
+			// 3. Started, some operations completed
 			else if (tmpProgressTracker.EndTimeStamp < 1)
 			{
-				this.fable.log.info(`>> Progress Tracker ${tmpProgressTracker.Hash} is ${tmpProgressTracker.PercentComplete.toFixed(3)}% completed - ${tmpProgressTracker.CurrentCount} / ${tmpProgressTracker.TotalCount} operations over ${this.progressTimes.formatTimeDuration(tmpProgressTracker.ElapsedTime)} (median ${this.progressTimes.formatTimeDuration(tmpProgressTracker.AverageOperationTime)} per).  Estimated completion in ${this.progressTimes.formatTimeDuration(tmpProgressTracker.EstimatedCompletionTime)}`)
+				return `${tmpProgressTracker.PercentComplete.toFixed(3)}%`;
+			}
+			// 4. Done
+			else
+			{
+				return `${tmpProgressTracker.PercentComplete.toFixed(3)}%`;
+			}
+		}
+	}
+
+	getProgressTrackerStatusString(pProgressTrackerHash)
+	{
+		let tmpProgressTrackerHash = (typeof(pProgressTrackerHash) == 'string') ? pProgressTrackerHash : 'Default';
+
+		// This call here can mean if we add operations and then immediately get the string, this function runs twice.
+		// TODO: Is there a pattern to avoid this double call that's worth putting in?
+		this.solveProgressTrackerStatus(tmpProgressTrackerHash);
+
+		if (!this.progressTrackers.hasOwnProperty(tmpProgressTrackerHash))
+		{
+			return `ProgressTracker ${tmpProgressTrackerHash} does not exist!  No stats to display.`;
+		}
+		else
+		{
+			const tmpProgressTracker = this.progressTrackers[tmpProgressTrackerHash];
+
+			// The states of a progress tracker:
+			// 1. Not started
+			if (tmpProgressTracker.StartTimeStamp < 1)
+			{
+				return `ProgressTracker ${tmpProgressTracker.Hash} has not been started yet.`;
 			}
+			// 2. Started, but no operations completed
+
+			if ((tmpProgressTracker.CurrentCount < 1) && (tmpProgressTracker.EndTimeStamp < 1))
+			{
+				return `ProgressTracker ${tmpProgressTracker.Hash} has no completed operations.  ${this.progressTimes.formatTimeDuration(tmpProgressTracker.ElapsedTime)} have elapsed since it was started.`;
+			}
+			// 3. Started, some operations completed
+			else if (tmpProgressTracker.EndTimeStamp < 1)
+			{
+				return `ProgressTracker ${tmpProgressTracker.Hash} is ${tmpProgressTracker.PercentComplete.toFixed(3)}% completed - ${tmpProgressTracker.CurrentCount} / ${tmpProgressTracker.TotalCount} operations over ${this.progressTimes.formatTimeDuration(tmpProgressTracker.ElapsedTime)} (median ${this.progressTimes.formatTimeDuration(tmpProgressTracker.AverageOperationTime)} per).  Estimated completion: ${this.progressTimes.formatTimeDuration(tmpProgressTracker.EstimatedCompletionTime)}`;			}
+			// 4. Done
 			else
 			{
-				this.fable.log.info(`>> Progress Tracker ${tmpProgressTracker.Hash} is done and completed ${tmpProgressTracker.CurrentCount} / ${tmpProgressTracker.TotalCount} operations in ${tmpProgressTracker.EndTime}ms.`)
+				return `ProgressTracker ${tmpProgressTracker.Hash} is done. It completed ${tmpProgressTracker.CurrentCount} / ${tmpProgressTracker.TotalCount} operations in ${this.progressTimes.formatTimeDuration(tmpProgressTracker.ElapsedTime)} (median ${this.progressTimes.formatTimeDuration(tmpProgressTracker.AverageOperationTime)} per).`;
 			}
 		}
 	}
+
+	logProgressTrackerStatus(pProgressTrackerHash)
+	{
+		this.fable.log.info(this.getProgressTrackerStatusString(pProgressTrackerHash));
+	}
 }
 
 module.exports = FableServiceProgressTracker;

package/test/FableOperation_tests.js

@@ -86,26 +86,76 @@ suite
 					function(fDone)
 					{
 						let testFable = new libFable();
-						let tmpOperation = testFable.instantiateServiceProvider('Operation', {Name:'The last operation in town.'});
+						let tmpOperation = testFable.instantiateServiceProvider('Operation', {Name:'MTO - The Mega Test Operation'});
 						Expect(tmpOperation).to.be.an('object');
 						Expect(testFable.servicesMap.Operation.hasOwnProperty(tmpOperation.Hash)).to.equal(true);
 						Expect(tmpOperation.state.Log.length).to.equal(0);
-						let tmpText = `Operation ${tmpOperation.Hash} starting up...`;
+
+						let tmpText = `Created operation ${tmpOperation.Hash}; ready to add a step and start execution...`;
 						tmpOperation.log.info(tmpText);
 						Expect(tmpOperation.state.Log.length).to.equal(1);
 						Expect(tmpOperation.state.Log[0]).to.contain(tmpText);
 
-						tmpOperation.addStep('001-Login',
-							(fStepComplete) =>
+						let tmpOperationCount = 10;
+
+						tmpOperation.addStep(
+							function (fStepComplete)
 							{
-								setTimeout(
-									() =>
-									{
-										tmpOperation.log.trace('Login thingy complete!');
-										return fStepComplete();
-									}, 150);
-							}, 'Example step 1!');
+								this.logProgressTrackerStatus();
+
+								let tmpAnticipate = testFable.newAnticipate();
+
+								for (let i = 1; i <= tmpOperationCount; i++)
+								{
+									tmpAnticipate.anticipate((fWorkComplete)=>
+										{
+											let tmpDelay = Math.floor(Math.random() * 100) + 100;
+											this.log.info(`Doing some big work for ${tmpDelay}ms on iteration ${i}...`);
+											setTimeout(
+												() =>
+												{
+													this.log.info(`Work done for iteration ${i}.`);
+													this.incrementProgressTracker(1);
+													this.logProgressTrackerStatus();
+													return fWorkComplete();
+												}, tmpDelay);
+										});
+								}
+
+								tmpAnticipate.wait(fStepComplete);
+							}, {}, 'Example Step 1', 'This is the first step of the mega test.', 'STEP1');
+						tmpOperation.setStepTotalOperations('STEP1', tmpOperationCount);
+
+						tmpOperation.addStep(
+							function (fStepComplete)
+							{
+								let tmpShortOperationCount = 300;
+
+								this.setProgressTrackerTotalOperations(tmpShortOperationCount);
+								this.logProgressTrackerStatus();
+
+								let tmpAnticipate = testFable.newAnticipate();
+
+								for (let i = 1; i <= tmpShortOperationCount; i++)
+								{
+									tmpAnticipate.anticipate((fWorkComplete)=>
+										{
+											let tmpDelay = Math.floor(Math.random() * 3) + 3;
+											this.log.info(`Doing a little work for ${tmpDelay}ms on iteration ${i}...`);
+											setTimeout(
+												() =>
+												{
+													this.log.info(`Leetle work done for iteration ${i}.`);
+													this.incrementProgressTracker(1);
+													this.logProgressTrackerStatus();
+													return fWorkComplete();
+												}, tmpDelay);
+										});
+								}
 
+								tmpAnticipate.wait(fStepComplete);
+							}, {}, 'Example Step 2', 'This is the second step of the mega test.', 'STEP2');
+						
 						tmpOperation.execute(fDone);
 					}
 				);