@ti-engine/core 1.1.8 → 1.1.9

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 This document will contain the list of changes made to the framework. The format is based on the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.
 
+## Version 1.1.9
+* feat(redis integration)!: change the way the `redis` client is initialized. Instead of happening automatically on class instantiation, it is now initialized on demand using the `initialize` method.
+* feat(cache): change the way the main cache instance is initialized in compliance with the new redis integration
+* feat(message memory cache)!: change the way the message memory cache is initialized in compliance with the new redis integration. The `initialize` method needs to be called explicitly to initialize the cache instance before it can be used.
+* fix(message dispatcher): fix the way the `messageExchange` is initialized in the `MessageDispatcher` class (was not returning a promise)
+
 ## Version 1.1.8
 * feat(auditing): change export of the singleton class in an `instance` variable for consistency and clarity
 * feat(message dispatcher): change export of the singleton class in an `instance` variable for consistency and clarity

package/components/exchange/message-dispatcher.js

@@ -54,7 +54,7 @@ class MessageDispatcher {
 
             // Initialize the message tracer before enabling the message exchange:
             messageTracer.instance.initialize().then( () => {
-                this.#messageExchange.enableMessaging( configureInbound, configureOutbound );
+                return this.#messageExchange.enableMessaging( configureInbound, configureOutbound );
             } ).then( () => {
                 resolve();
             } ).catch( ( error ) => {

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

@@ -24,8 +24,22 @@ class MessageMemoryCache {
     /**
      * @constructor
      * @param {string} identifier The connection identifier for the Redis connection.
+     * @returns {MessageMemoryCache}
      */
     constructor( identifier ) {
+        this.#redisClient = redis.createRedisClient( identifier );
+    }
+
+    /* Public interface */
+
+    /**
+     * Used to initialize the cache service.
+     *
+     * @method
+     * @returns {Promise}
+     * @public
+     */
+    initialize() {
         let host = config.getSetting( config.setting.MEMORY_CACHE_REDIS_HOST );
         let port = config.getSetting( config.setting.MEMORY_CACHE_REDIS_PORT );
         let db = config.getSetting( config.setting.MEMORY_CACHE_REDIS_DB );
@@ -33,17 +47,16 @@ class MessageMemoryCache {
         let user = config.getSetting( config.setting.MEMORY_CACHE_USER );
         let retryMaxAttempts = config.getSetting( config.setting.MEMORY_CACHE_RETRY_MAX_ATTEMPTS );
         let retryMaxInterval = config.getSetting( config.setting.MEMORY_CACHE_RETRY_MAX_INTERVAL );
-        this.#redisClient = redis.createRedisClient( identifier, host, port, authKey, user, db, retryMaxInterval, retryMaxAttempts );
-    }
 
-    /* Public interface */
+        return this.#redisClient.initialize( host, port, authKey, user, db, retryMaxInterval, retryMaxAttempts );
+    }
 
     /**
      * Used to gracefully shut down the cache service.
      *
      * @method
      * @param {number} [timeoutMs]
-     * @return {Promise}
+     * @returns {Promise}
      * @public
      */
     shutDown( timeoutMs ) {

package/components/service-instance.js

@@ -150,13 +150,16 @@ class ServiceInstance {
      */
     onStart() {
         return new Promise( ( resolve, reject ) => {
-            const DefaultMessageExchange = require( "#default-message-exchange" );
-            const ServiceProvider = require( "#service-provider" );
-            const ServiceConsumer = require( "#service-consumer" );
+            cache.instance.initialize().then( () => {
+                const DefaultMessageExchange = require( "#default-message-exchange" );
+                const ServiceProvider = require( "#service-provider" );
+                const ServiceConsumer = require( "#service-consumer" );
 
-            let configureInbound = ( this instanceof ServiceProvider );
-            let configureOutbound = ( this instanceof ServiceConsumer );
-            messageDispatcher.instance.initialize( new DefaultMessageExchange( ServiceInstance.instanceID, ServiceInstance.serviceDomainName ), configureInbound, configureOutbound ).then( () => {
+                let configureInbound = ( this instanceof ServiceProvider );
+                let configureOutbound = ( this instanceof ServiceConsumer );
+
+                return messageDispatcher.instance.initialize( new DefaultMessageExchange( ServiceInstance.instanceID, ServiceInstance.serviceDomainName ), configureInbound, configureOutbound );
+            } ).then( () => {
                 resolve();
             } ).catch( ( error ) => {
                 reject( exceptions.raise( error ) );

package/integrations/redis-integration.js

@@ -87,99 +87,10 @@ class RedisClient {
     /**
      * @constructor
      * @param {string} identifier
-     * @param {string} host
-     * @param {number} port
-     * @param {string} authKey
-     * @param {string} user
-     * @param {number} defaultDB
-     * @param {number} [retryMaxIntervalMs=1000] Optional max backoff interval.
-     * @param {number|undefined} [retryMaxAttempts=undefined] Optional max (re)connection attempts before abort.
+     * @returns {RedisClient}
      */
-    constructor( identifier, host, port, authKey, user, defaultDB, retryMaxIntervalMs = 1000, retryMaxAttempts = undefined ) {
+    constructor( identifier ) {
         this.#clientIdentifier = identifier || "redis-client-" + tools.getUUID();
-        this.#retryMaxInterval = retryMaxIntervalMs;
-        this.#retryMaxAttempts = retryMaxAttempts;
-
-        let retryStrategy = ( attempt ) => {
-            let result = Math.min( attempt * 50, this.#retryMaxInterval );
-
-            if ( this.#retryMaxAttempts != null && attempt > this.#retryMaxAttempts ) {
-                logger.log( "In Redis retry strategy: reached max attempts for command retry. Aborting...", logger.logSeverity.WARNING, { attempts: attempt } );
-                result = exceptions.raise( exceptions.exceptionCode.E_COM_RETRY_ATTEMPTS_EXCEEDED );
-            }
-
-            return result;
-        };
-
-        let reconnectOnError = ( error ) => {
-            logger.log( `In Redis reconnect on error strategy: ${ error.message }`, logger.logSeverity.ERROR, error );
-            return !!error.message.includes( "READONLY" );
-        };
-
-        let options = {
-            port: port,
-            host: host,
-            username: user,
-            password: authKey,
-            db: defaultDB,
-            autoResendUnfulfilledCommands: true,
-            maxRetriesPerRequest: null,
-            retryStrategy: retryStrategy,
-            reconnectOnError: reconnectOnError
-        };
-
-        /** @type Redis */
-        this.#redisClient = new Redis( options );
-
-        this.#redisClient.on( "ready", () => {
-            logger.log( `Connection to Redis server ${ host }:${ port } (re)established by client '${ this.identifier }' and is ready to be used.`, logger.logSeverity.INFO );
-
-            // notify all connection observers about this event:
-            _.forEach( this.#connectionObservers, ( connectionObservers ) => {
-                connectionObservers.onConnectionRecovered( this.#clientIdentifier );
-            } );
-
-            // fetch the server information and store it:
-            this.#redisClient.info().then( ( result ) => {
-                this.#serverInfo = {};
-                if ( _.isString( result ) ) {
-                    let rawData = _.split( result, "\r\n" );
-                    _.forEach( rawData, ( entry ) => {
-                        let details = _.split( entry, ":" );
-                        if ( !_.startsWith( details[ 0 ], "#" ) && details[ 0 ] !== "" && details[ 0 ] ) {
-                            if ( _.isNaN( _.toNumber( details[ 1 ] ) ) ) {
-                                this.#serverInfo[ details[ 0 ] ] = details[ 1 ];
-                            } else {
-                                this.#serverInfo[ details[ 0 ] ] = _.toNumber( details[ 1 ] );
-                            }
-                        }
-                    } );
-                }
-                return this.#redisClient.module( "LIST" );
-            } ).then( ( result ) => {
-                this.#serverFeatures = {};
-                if ( _.isArray( result ) ) {
-                    _.forEach( result, ( entry ) => {
-                        this.#serverFeatures[ entry[ 1 ] ] = entry[ 3 ];
-                    } );
-                }
-            } ).catch( ( error ) => {
-                logger.log( `Failed to fetch server information by client '${ this.identifier }'!`, logger.logSeverity.WARNING, error );
-            } );
-        } );
-        this.#redisClient.on( "error", ( error ) => {
-            logger.log( `Error received in Redis client '${ this.identifier }'.`, logger.logSeverity.ERROR, error );
-
-            // notify all connection observers about this event:
-            _.forEach( this.#connectionObservers, ( connectionObservers ) => {
-                connectionObservers.onConnectionDisrupted( this.#clientIdentifier );
-            } );
-        } );
-        this.#redisClient.on( "reconnecting", ( info ) => {
-            if ( info.attempt > 1 ) {
-                logger.log( `Client '${ this.identifier }' reconnecting to Redis server after ${ info.delay } ms. This is attempt ${ info.attempt }.`, logger.logSeverity.DEBUG );
-            }
-        } );
     }
 
     /* Public interface */
@@ -188,7 +99,7 @@ class RedisClient {
      * Used to return the Redis client identifier.
      *
      * @property
-     * @return {string}
+     * @returns {string}
      * @public
      */
     get identifier() {
@@ -199,7 +110,7 @@ class RedisClient {
      * Used to return the Redis server version.
      *
      * @property
-     * @return {number}
+     * @returns {number}
      * @public
      */
     get serverVersion() {
@@ -218,6 +129,92 @@ class RedisClient {
         return !_.isNil( this.#serverFeatures[ "ReJSON" ] ) || !_.isNil( this.#serverFeatures[ "ReJSON2" ] );
     }
 
+    /**
+     * Used to initialize the Redis client.
+     *
+     * @method
+     * @param {string} host
+     * @param {number} port
+     * @param {string} authKey
+     * @param {string} user
+     * @param {number} defaultDB
+     * @param {number} [retryMaxIntervalMs=1000] Optional max backoff interval.
+     * @param {number|undefined} [retryMaxAttempts=undefined] Optional max (re)connection attempts before abort.
+     * @public
+     */
+    initialize( host, port, authKey, user, defaultDB, retryMaxIntervalMs = 1000, retryMaxAttempts = undefined ) {
+        return new Promise( ( resolve, reject ) => {
+            if ( this.#redisClient ) {
+                resolve();
+            } else {
+                try {
+                    this.#retryMaxInterval = retryMaxIntervalMs;
+                    this.#retryMaxAttempts = retryMaxAttempts;
+
+                    let retryStrategy = ( attempt ) => {
+                        let result = Math.min( attempt * 50, this.#retryMaxInterval );
+
+                        if ( this.#retryMaxAttempts != null && attempt > this.#retryMaxAttempts ) {
+                            logger.log( "In Redis retry strategy: reached max attempts for command retry. Aborting...", logger.logSeverity.WARNING, { attempts: attempt } );
+                            result = exceptions.raise( exceptions.exceptionCode.E_COM_RETRY_ATTEMPTS_EXCEEDED );
+                        }
+
+                        return result;
+                    };
+
+                    let reconnectOnError = ( error ) => {
+                        logger.log( `In Redis reconnect on error strategy: ${ error.message }`, logger.logSeverity.ERROR, error );
+                        return !!error.message.includes( "READONLY" );
+                    };
+
+                    let options = {
+                        port: port,
+                        host: host,
+                        username: user,
+                        password: authKey,
+                        db: defaultDB,
+                        autoResendUnfulfilledCommands: true,
+                        maxRetriesPerRequest: null,
+                        retryStrategy: retryStrategy,
+                        reconnectOnError: reconnectOnError
+                    };
+
+                    /** @type Redis */
+                    this.#redisClient = new Redis( options );
+
+                    this.#redisClient.on( "ready", () => {
+                        logger.log( `Connection to Redis server ${ host }:${ port } (re)established by client '${ this.identifier }' and is ready to be used.`, logger.logSeverity.INFO );
+
+                        // Notify all connection observers about this event:
+                        _.forEach( this.#connectionObservers, ( connectionObservers ) => {
+                            connectionObservers.onConnectionRecovered( this.#clientIdentifier );
+                        } );
+
+                        // Fetch the server information and store it:
+                        this.#fetchServerInfo();
+
+                        resolve();
+                    } );
+                    this.#redisClient.on( "error", ( error ) => {
+                        logger.log( `Error received in Redis client '${ this.identifier }'.`, logger.logSeverity.ERROR, error );
+
+                        // Notify all connection observers about this event:
+                        _.forEach( this.#connectionObservers, ( connectionObservers ) => {
+                            connectionObservers.onConnectionDisrupted( this.#clientIdentifier );
+                        } );
+                    } );
+                    this.#redisClient.on( "reconnecting", ( info ) => {
+                        if ( info.attempt > 1 ) {
+                            logger.log( `Client '${ this.identifier }' reconnecting to Redis server after ${ info.delay } ms. This is attempt ${ info.attempt }.`, logger.logSeverity.DEBUG );
+                        }
+                    } );
+                } catch ( error ) {
+                    reject( exceptions.raise( error ) );
+                }
+            }
+        } );
+    }
+
     /**
      * Used to register a new {@link ConnectionObserver} for events related to the Redis connection state.
      *
@@ -238,7 +235,7 @@ class RedisClient {
      *
      * @method
      * @param {Array[]} commands
-     * @return {Promise<*>}
+     * @returns {Promise<*>}
      * @public
      */
     executeCommands( commands ) {
@@ -259,7 +256,7 @@ class RedisClient {
      * @method
      * @param {string} command
      * @param {Array} commandArguments
-     * @return {Promise<*>}
+     * @returns {Promise<*>}
      * @public
      */
     blockingCommand( command, commandArguments ) {
@@ -278,7 +275,7 @@ class RedisClient {
      * @method
      * @param {string} channel
      * @param {(Object|string)} message
-     * @return {Promise<number>}
+     * @returns {Promise<number>}
      * @public
      */
     publishCommand( channel, message ) {
@@ -299,7 +296,7 @@ class RedisClient {
      * @method
      * @param {string} channel Unique identifier of the channel to subscribe to.
      * @param {function( Object )} messageHandler Will execute this handler every time a new message is received.
-     * @return {Promise}
+     * @returns {Promise}
      * @public
      */
     subscribeCommand( channel, messageHandler ) {
@@ -343,7 +340,7 @@ class RedisClient {
      *
      * @method
      * @param {string} channel Unique identifier of the channel to unsubscribe from.
-     * @return {Promise}
+     * @returns {Promise}
      * @public
      */
     unsubscribeCommand( channel ) {
@@ -424,6 +421,43 @@ class RedisClient {
         } );
     }
 
+    /* Private interface */
+
+    /**
+     * Used to fetch and store Redis server information.
+     *
+     * @method
+     * @private
+     */
+    #fetchServerInfo() {
+        this.#redisClient.info().then( ( result ) => {
+            this.#serverInfo = {};
+            if ( _.isString( result ) ) {
+                let rawData = _.split( result, "\r\n" );
+                _.forEach( rawData, ( entry ) => {
+                    let details = _.split( entry, ":" );
+                    if ( !_.startsWith( details[ 0 ], "#" ) && details[ 0 ] !== "" && details[ 0 ] ) {
+                        if ( _.isNaN( _.toNumber( details[ 1 ] ) ) ) {
+                            this.#serverInfo[ details[ 0 ] ] = details[ 1 ];
+                        } else {
+                            this.#serverInfo[ details[ 0 ] ] = _.toNumber( details[ 1 ] );
+                        }
+                    }
+                } );
+            }
+            return this.#redisClient.module( "LIST" );
+        } ).then( ( result ) => {
+            this.#serverFeatures = {};
+            if ( _.isArray( result ) ) {
+                _.forEach( result, ( entry ) => {
+                    this.#serverFeatures[ entry[ 1 ] ] = entry[ 3 ];
+                } );
+            }
+        } ).catch( ( error ) => {
+            logger.log( `Failed to fetch server information by client '${ this.identifier }'!`, logger.logSeverity.WARNING, error );
+        } );
+    }
+
 }
 
 /**
@@ -431,16 +465,9 @@ class RedisClient {
  *
  * @method
  * @param {string} identifier
- * @param {string} host
- * @param {number} [port=6379]
- * @param {string} [authKey=undefined]
- * @param {string} [user="default"]
- * @param {number} [defaultDB=0]
- * @param {number} [retryMaxIntervalMs=1000]
- * @param {number|undefined} [retryMaxAttempts=undefined]
  * @return {RedisClient}
  * @public
  */
-module.exports.createRedisClient = ( identifier, host, port = 6379, authKey = undefined, user = "default", defaultDB = 0, retryMaxIntervalMs = 1000, retryMaxAttempts = undefined ) => {
-    return Object.freeze( new RedisClient( identifier, host, port, authKey, user, defaultDB, retryMaxIntervalMs, retryMaxAttempts ) );
+module.exports.createRedisClient = ( identifier ) => {
+    return Object.freeze( new RedisClient( identifier ) );
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ti-engine/core",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "description": "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.",
   "author": "Boris Kostadinov <kostadinov.boris@gmail.com>",
   "license": "GPL-3.0-or-later",

package/testRedis.js

@@ -0,0 +1,22 @@
+import Redis from "ioredis";
+
+const redisClient = new Redis( {
+    port: 17467,
+    host: "redis-17467.c300.eu-central-1-1.ec2.redns.redis-cloud.com",
+    username: "default",
+    password: "o49Iyj2JYnmD7NSFWa32x2iYqulWkIM1",
+    db: 0,
+    autoResendUnfulfilledCommands: true,
+    maxRetriesPerRequest: null,
+    retryStrategy: ( attempt ) => {
+        let result = Math.min( attempt * 50, 1000 );
+    }
+});
+
+redisClient.on('error', err => console.log('Redis Client Error', err));
+
+//await redisClient.connect();
+
+await redisClient.set('foo', 'bar');
+const result = await redisClient.get('foo');
+console.log(result);

package/utils/cache.js

@@ -36,13 +36,6 @@ class CommonMemoryCache extends ConnectionObserver {
         super();
 
         if ( !CommonMemoryCache.#instance ) {
-            let host = config.getSetting( config.setting.MEMORY_CACHE_REDIS_HOST );
-            let port = config.getSetting( config.setting.MEMORY_CACHE_REDIS_PORT );
-            let db = config.getSetting( config.setting.MEMORY_CACHE_REDIS_DB );
-            let authKey = config.getSetting( config.setting.MEMORY_CACHE_AUTH_KEY );
-            let user = config.getSetting( config.setting.MEMORY_CACHE_USER );
-            this.#redisClient = redis.createRedisClient( this.#connectionIdentifier, host, port, authKey, user, db );
-            this.#redisClient.addConnectionObserver( this );
             CommonMemoryCache.#instance = this;
         }
         return CommonMemoryCache.#instance;
@@ -72,6 +65,26 @@ class CommonMemoryCache extends ConnectionObserver {
         return this.#connectionIdentifier;
     }
 
+    /**
+     * Used to initialize the cache service.
+     *
+     * @method
+     * @returns {Promise}
+     * @public
+     */
+    initialize() {
+        let host = config.getSetting( config.setting.MEMORY_CACHE_REDIS_HOST );
+        let port = config.getSetting( config.setting.MEMORY_CACHE_REDIS_PORT );
+        let db = config.getSetting( config.setting.MEMORY_CACHE_REDIS_DB );
+        let authKey = config.getSetting( config.setting.MEMORY_CACHE_AUTH_KEY );
+        let user = config.getSetting( config.setting.MEMORY_CACHE_USER );
+
+        this.#redisClient = redis.createRedisClient( this.#connectionIdentifier );
+        this.#redisClient.addConnectionObserver( this );
+
+        return this.#redisClient.initialize( host, port, authKey, user, db );
+    }
+
     /**
      * Used to gracefully shut down the cache service.
      *