@ti-engine/core 1.1.9 → 1.2.0

package/components/exchange/message-memory-cache.js

@@ -20,6 +20,7 @@ const redis = require( "#redis-integration" );
 class MessageMemoryCache {
 
     #redisClient = null;
+    #isShuttingDown = false;
 
     /**
      * @constructor
@@ -60,6 +61,7 @@ class MessageMemoryCache {
      * @public
      */
     shutDown( timeoutMs ) {
+        this.#isShuttingDown = true;
         return this.#redisClient.shutDown( timeoutMs );
     }
 
@@ -85,13 +87,17 @@ class MessageMemoryCache {
      */
     sendMessage( message, queue ) {
         return new Promise( ( resolve, reject ) => {
-            let command = [ redis.cacheCommands.LIST_PUSH, queue, tools.stringifyJSON( message ) ];
-            this.#redisClient.executeCommands( [ command ] ).then( ( results ) => {
-                results = results[ 0 ];
-                resolve( ( results && results.length > 1 ) ? results[ 1 ] : undefined );
-            } ).catch( ( error ) => {
-                reject( exceptions.raise( error ) );
-            } );
+            if ( this.#isShuttingDown === true ) {
+                reject( exceptions.raise( exceptions.exceptionCode.E_COM_MESSAGE_SENDER_UNAVAILABLE ) );
+            } else {
+                let command = [ redis.cacheCommands.LIST_PUSH, queue, tools.stringifyJSON( message ) ];
+                this.#redisClient.executeCommands( [ command ] ).then( ( results ) => {
+                    results = results[ 0 ];
+                    resolve( ( results && results.length > 1 ) ? results[ 1 ] : undefined );
+                } ).catch( ( error ) => {
+                    reject( exceptions.raise( error ) );
+                } );
+            }
         } );
     }
 
@@ -134,7 +140,11 @@ class MessageMemoryCache {
                 results = ( results && results.length > 1 ) ? results[ 1 ] : undefined;
                 resolve( tools.parseJSON( results ) );
             } ).catch( ( error ) => {
-                reject( exceptions.raise( error ) );
+                if ( this.#isShuttingDown === true ) {
+                    reject( exceptions.raise( exceptions.exceptionCode.E_COM_MESSAGE_RECEIVER_UNAVAILABLE ) );
+                } else {
+                    reject( exceptions.raise( error ) );
+                }
             } );
         } );
     }

package/components/exchange/message-receiver.js

@@ -1,6 +1,6 @@
 /*
  * The ti-engine is an open source, free to use—both for personal and commercial projects—framework for the creation of microservice-based solutions using node.js.
- * Copyright © 2021-2023 Boris Kostadinov <kostadinov.boris@gmail.com>
+ * Copyright © 2021-2025 Boris Kostadinov <kostadinov.boris@gmail.com>
  * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
@@ -22,6 +22,7 @@ const config = require( "#config" );
 class MessageReceiver extends MessageHandler {
 
     #receiveQueue;
+    #isReceiving = false;
 
     /**
      * @constructor
@@ -48,7 +49,31 @@ class MessageReceiver extends MessageHandler {
      * @returns {string}
      * @public
      */
-    get receiveQueue() { return this.#receiveQueue; }
+    get receiveQueue() {
+        return this.#receiveQueue;
+    }
+
+    /**
+     * Indicates whether the receiver is currently receiving messages.
+     *
+     * @property
+     * @returns {boolean}
+     * @public
+     */
+    get isReceiving() {
+        return this.#isReceiving;
+    }
+
+    /**
+     * Used to set the value of the {@link MessageReceiver#isReceiving} property.
+     *
+     * @property
+     * @param {boolean} value
+     * @public
+     */
+    set isReceiving( value ) {
+        this.#isReceiving = value;
+    }
 
     /**
      * Used to initialize and enable the communication capabilities of the handler.
@@ -81,21 +106,26 @@ class MessageReceiver extends MessageHandler {
     /**
      * Used to receive messages.
      * <br/>
-     * NOTE: This method will start a recursion of subsequent receives that will continue even if an individual message fetch fails.
+     * NOTE: This method will start a recursion of subsequent receive calls that will continue even if an individual message fetch fails.
      *
      * @method
+     * @recursion
      * @public
      */
     receive() {
-        this.onReceive().then( ( message ) => {
-            return this.#postReceive( message );
-        } ).then( ( message ) => {
-            this.onMessage( message );
-        } ).catch( ( error ) => {
-            logger.log( `Error while trying to receive the next pending message from memory cache in receiver '${ this.connectionIdentifier }'! Resuming operation...`, logger.logSeverity.ERROR, error );
-        } ).finally( () => {
-            this.receive();
-        } );
+        if ( this.isReceiving === true ) {
+            this.onReceive().then( ( message ) => {
+                return this.#postReceive( message );
+            } ).then( ( message ) => {
+                this.onMessage( message );
+            } ).catch( ( error ) => {
+                if ( error.code !== exceptions.exceptionCode.E_COM_MESSAGE_RECEIVER_UNAVAILABLE ) {
+                    logger.log( `Error while trying to receive the next pending message from memory cache in receiver '${ this.connectionIdentifier }'! Resuming operation...`, logger.logSeverity.ERROR, error );
+                }
+            } ).finally( () => {
+                this.receive();
+            } );
+        }
     }
 
     /**
@@ -147,4 +177,4 @@ class MessageReceiver extends MessageHandler {
 
 }
 
-module.exports = MessageReceiver;
+module.exports = MessageReceiver;

package/components/exchange/message-tracer.js

@@ -117,7 +117,12 @@ class MessageTracer {
             cache.instance.setJSON( config.getSetting( config.setting.MESSAGE_EXCHANGE_TRACE_REPOSITORY ), traceRoot, "$", 1 ).then( () => {
                 resolve();
             } ).catch( ( error ) => {
-                reject( exceptions.raise( error ) );
+                // If JSON is unsupported in Redis server, the trace will use a Set later, so we can resolve the promise:
+                if ( error.code === exceptions.exceptionCode.E_GEN_FEATURE_UNSUPPORTED ) {
+                    resolve();
+                } else {
+                    reject( exceptions.raise( error ) );
+                }
             } );
         } );
     }
@@ -125,7 +130,7 @@ class MessageTracer {
     /**
      * Used to create a trace entry for the provided {@link Message} and parameters.
      * <br/>
-     * NOTE: By default all trace events are stored in the memory cache for further processing and analysis. The
+     * NOTE: By default, all trace events are stored in the memory cache for further processing and analysis. The
      * location is configured in the MESSAGE_EXCHANGE_TRACE_REPOSITORY setting.
      * <br/>
      * NOTE: Trace events are logged with severity level NOTICE or ERROR for failed dispatches. They still might be
@@ -139,7 +144,7 @@ class MessageTracer {
      * @public
      */
     recordTraceEntry( message, messageType, dispatchEvent, messageState ) {
-        // Depending on whether the message comes as request or response, the from and to addresses will be opposite:
+        // Depending on whether the message comes as a request or response, the from and to addresses will be opposite:
         let source = message.source.route + "." + message.source.instanceID;
         let destination = message.destination.route + ( ( message.destination.instanceID != null ) ? "." + message.destination.instanceID : "" );
         let messageSnapshot = MessageTracer.#obscureSensitiveData( message );

package/components/service-executor.js

@@ -58,8 +58,6 @@ class ServiceExecutor extends MessageObserver {
     #serviceInterface = {};
     /** @type VerifyAccessMethod */
     #verifyAccess;
-    #registrationTasks = {};
-    #registrationRetryInterval = 500;
 
     /**
      * @constructor
@@ -67,7 +65,7 @@ class ServiceExecutor extends MessageObserver {
     constructor() {
         super();
 
-        // Setup a default empty verify access method:
+        // Set up a default empty verify access method:
         this.#verifyAccess = () => {
             return Promise.resolve();
         };
@@ -127,17 +125,6 @@ class ServiceExecutor extends MessageObserver {
      */
     onConnectionRecovered( identifier ) {
         super.onConnectionRecovered( identifier );
-
-        if ( identifier !== cache.instance.connectionIdentifier ) {
-            let serviceCatalog = config.getSetting( config.setting.SERVICE_REGISTRY_ADDRESS ) + ServiceInstance.serviceDomainName;
-            _.forOwn( this.#serviceInterface, ( versions, serviceAlias ) => {
-                if ( !this.#registrationTasks[ serviceAlias ] ) {
-                    this.#registrationTasks[ serviceAlias ] = setInterval( () => {
-                        this.#registerServiceToCatalog( serviceCatalog, serviceAlias );
-                    }, this.#registrationRetryInterval );
-                }
-            } );
-        }
     }
 
     /**
@@ -164,16 +151,26 @@ class ServiceExecutor extends MessageObserver {
      * @param {ServiceHandlerMethod} serviceHandler
      * @param {ServiceDefinition} serviceDefinition
      * @param {ServiceInstance} serviceInstance This will be used as context to bind all business services.
+     * @returns {Promise}
      * @public
      */
     addServiceHandler( serviceHandler, serviceDefinition, serviceInstance ) {
-        if ( !this.#serviceInterface[ serviceDefinition.serviceAlias ] ) {
-            this.#serviceInterface[ serviceDefinition.serviceAlias ] = {};
-        }
-        if ( this.#serviceInterface[ serviceDefinition.serviceAlias ][ serviceDefinition.serviceVersion ] ) {
-            logger.log( `Service handler for '${ serviceDefinition.serviceAlias }' version '${ serviceDefinition.serviceVersion }' already existed and will be overridden.`, logger.logSeverity.WARNING );
-        }
-        this.#serviceInterface[ serviceDefinition.serviceAlias ][ serviceDefinition.serviceVersion ] = serviceHandler.bind( serviceInstance, _.cloneDeep( serviceDefinition ) );
+        return new Promise( ( resolve, reject ) => {
+            this.#registerServiceToCatalog( serviceDefinition.serviceAlias ).then( () => {
+                // Bind the service handler to the service alias and version:
+                if ( !this.#serviceInterface[ serviceDefinition.serviceAlias ] ) {
+                    this.#serviceInterface[ serviceDefinition.serviceAlias ] = {};
+                }
+                if ( this.#serviceInterface[ serviceDefinition.serviceAlias ][ serviceDefinition.serviceVersion ] ) {
+                    logger.log( `Service handler for '${ serviceDefinition.serviceAlias }' version '${ serviceDefinition.serviceVersion }' already existed and will be overridden.`, logger.logSeverity.WARNING );
+                }
+                this.#serviceInterface[ serviceDefinition.serviceAlias ][ serviceDefinition.serviceVersion ] = serviceHandler.bind( serviceInstance, _.cloneDeep( serviceDefinition ) );
+
+                resolve();
+            } ).catch( ( error ) => {
+                reject( exceptions.raise( error ) );
+            } );
+        } );
     }
 
     /* Private interface */
@@ -207,19 +204,20 @@ class ServiceExecutor extends MessageObserver {
      * Used to register a service in the service registry.
      *
      * @method
-     * @param {string} serviceCatalog
      * @param {string} serviceAlias
+     * @returns {Promise}
      * @private
      */
-    #registerServiceToCatalog( serviceCatalog, serviceAlias ) {
-        if ( cache.instance.isOperational ) {
+    #registerServiceToCatalog( serviceAlias ) {
+        return new Promise( ( resolve, reject ) => {
+            let serviceCatalog = config.getSetting( config.setting.SERVICE_REGISTRY_ADDRESS ) + ServiceInstance.serviceDomainName;
             cache.instance.addToSet( serviceCatalog, serviceAlias ).then( () => {
-                clearTimeout( this.#registrationTasks[ serviceAlias ] );
-                delete this.#registrationTasks[ serviceAlias ];
+                resolve();
             } ).catch( ( error ) => {
-                logger.log( `Record for service '${ serviceAlias }' could not be added to the service registry. Will retry in '${ this.#registrationRetryInterval }' milliseconds.`, logger.logSeverity.ERROR, error );
+                logger.log( `Record for service '${ serviceAlias }' could not be added to the service registry. Service will not be visible to Service Consumers!`, logger.logSeverity.ERROR, error );
+                reject( exceptions.raise( error ) );
             } );
-        }
+        } );
     }
 
     /**

package/components/service-instance.js

@@ -56,7 +56,7 @@ class ServiceInstance {
             } );
         }
 
-        // Ensure uniform 'ti-' prefix even if env is missing or custom starter script is used:
+        // Ensure a uniform 'ti-' prefix even if env is missing or a custom starter script is used:
         const envID = process.env.TI_INSTANCE_ID;
         ServiceInstance.#instanceID = ( envID && String( envID ).startsWith( "ti-" ) ) ? envID : ( "ti-" + ( envID || tools.getUUID() ) );
 
@@ -217,7 +217,7 @@ class ServiceInstance {
      * Used to report health status of the service instance for external monitoring.
      * This is a scheduled job that will be executed at SERVICE_HEALTH_CHECK_INTERVAL time.
      * <br/>
-     * NOTE: By default this method will update a Redis key with an expiration timer. You can override this
+     * NOTE: By default, this method will update a Redis key with an expiration timer. You can override this
      * functionality with something custom like calling an HTTP endpoint.
      *
      * @method

package/components/service-provider.js

@@ -140,10 +140,10 @@ class ServiceProvider extends ServiceConsumer {
     /**
      * Used to register a single service to the service provider's API. One service can have multiple versions accessible at the same time.
      * <br/>
-     * NOTE: This will actually bind the serviceDefinition as first parameter of the service handler function. When creating default service handlers,
+     * NOTE: This will actually bind the serviceDefinition as the first parameter of the service handler function. When creating default service handlers,
      * keep in mind that your first param must always be the 'serviceDefinition' and the second one will be the general 'serviceParams' object.
      * <br/>
-     * NOTE: Additionally, if you intend to call another service inside the service handler, then you have to use normal function for the handler and not
+     * NOTE: Additionally, if you intend to call another service inside the service handler, then you have to use a normal function for the handler and not
      * an arrow function! Arrow functions cannot bind the scope of the parent class to themselves, and you won't have access to it and its methods.
      *
      * @method
@@ -171,12 +171,15 @@ class ServiceProvider extends ServiceConsumer {
                 }
             }
 
-            // if we have a valid service handler proceed with the registration:
+            // if we have a valid service handler, proceed with the registration:
             if ( typeof ( serviceHandler ) === "function" ) {
                 // make sure we have a version and parent service provider specified:
                 serviceDefinition.serviceVersion = serviceDefinition.serviceVersion || 1;
-                this.#serviceExecutor.addServiceHandler( serviceHandler, serviceDefinition, this );
-                resolve();
+                this.#serviceExecutor.addServiceHandler( serviceHandler, serviceDefinition, this ).then( () => {
+                    resolve();
+                } ).catch( ( error ) => {
+                    reject( exceptions.raise( error ) );
+                } );
             } else {
                 reject( exceptions.raise( exceptions.exceptionCode.E_GEN_BAD_SERVICE_HANDLER ) );
             }
@@ -201,7 +204,7 @@ class ServiceProvider extends ServiceConsumer {
                 _.forEach( serviceDefinitions, ( serviceDefinition ) => {
                     // NOTE: we are not going to interrupt the service interface loading if one of the services fails to load or is not found!
                     // If this happens, a corresponding log entry will be created but the loading process will continue. Therefore, the following
-                    // promise will always resolve (unless a programming error occurs in it of course).
+                    // promise will always resolve (unless a programming error occurs in it, of course).
                     let registrationPromise = ( serviceDefinition, defaultServiceHandler ) => {
                         return new Promise( ( resolve ) => {
                             this.registerService( serviceDefinition, defaultServiceHandler ).then( () => {