@weave-js/redis-transport 0.13.0 → 0.15.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [0.14.0](https://github.com/weave-microservices/weave/compare/@weave-js/redis-transport@0.12.1...@weave-js/redis-transport@0.14.0) (2023-05-04)
+
+
+* Release Version 0.14.0 (#279) ([12a003c](https://github.com/weave-microservices/weave/commit/12a003c05b2960b20810fbbad496258b5d4b0606)), closes [#279](https://github.com/weave-microservices/weave/issues/279) [#276](https://github.com/weave-microservices/weave/issues/276) [#278](https://github.com/weave-microservices/weave/issues/278)
+
+
+### BREAKING CHANGES
+
+* Removed http error codes from errors and added correct codes
+
+* chore: published 0.13.0
+
+
+
+
+
 # [0.13.0](https://github.com/weave-microservices/weave/compare/@weave-js/redis-transport@0.12.1...@weave-js/redis-transport@0.13.0) (2022-08-16)
 
 **Note:** Version bump only for package @weave-js/redis-transport

package/lib/index.js

@@ -3,102 +3,139 @@
  * -----
  * Copyright 2021 Fachwerk
  */
-
-const redis = require('redis');
-const { defaultsDeep, promiseDelay } = require('@weave-js/utils');
-const { TransportAdapters } = require('@weave-js/core');
+const redis = require('redis')
+const { defaultsDeep } = require('@weave-js/utils')
+const { TransportAdapters } = require('@weave-js/core')
 
 const defaultOptions = {
   port: 6379,
   host: '127.0.0.1'
-};
+}
 
 const RedisTransportAdapter = (adapterOptions) => {
-  let clientSub;
-  let clientPub;
+  let clientSub
+  let clientPub
 
-  // Merge options with default options.
-  adapterOptions = defaultsDeep(adapterOptions, defaultOptions);
+  adapterOptions = defaultsDeep(adapterOptions, defaultOptions)
 
   return Object.assign(TransportAdapters.BaseAdapter(adapterOptions), {
     name: 'REDIS',
+
     connect () {
-      return new Promise((resolve, reject) => {
-        clientSub = redis.createClient(adapterOptions);
-
-        clientSub.on('connect', () => {
-          clientPub = redis.createClient(adapterOptions);
-
-          this.log.info('Redis SUB client connected.');
-
-          clientPub.on('connect', () => {
-            if (this.interruptionCount > 0 && !this.isConnected) {
-              this.bus.emit('adapter.connected', true);
-            }
-            this.log.info('Redis PUB client connected.');
-            this.isConnected = true;
-            resolve();
-          });
-
-          clientPub.on('error', error => {
-            this.log.error('Redis PUB error:', error.message);
-            this.isConnected = false;
-            reject(error);
-          });
-
-          clientPub.on('close', () => {
-            if (this.isConnected) {
-              this.isConnected = false;
-              this.interruptionCount++;
-              this.log.warn('Redis PUB disconnected.');
-              this.disconnected();
-            }
-          });
-        });
-
-        clientSub.on('error', error => {
-          this.log.error('Redis PUB error:', error.message);
-          reject(error);
-        });
-
-        clientSub.on('message', (topic, message) => {
-          const type = topic.split('.')[1];
-          this.incomingMessage(type, message);
-        });
-
-        clientSub.on('close', () => {
-          this.log.warn('Redis SUB disconnected.');
-        });
+      if (clientSub || clientPub) {
+        return Promise.reject(new Error('Adapter already connected.'))
+      }
+
+      // Ohne explizite Strategie gibt v3 je nach Fehlerbild auf,
+      // dann bleibt 'reconnecting' aus. Solange eine Zahl kommt, wird retried.
+      const retryStrategy = ({ attempt }) => Math.min(attempt * 100, 3000)
+
+      clientPub = redis.createClient({ ...adapterOptions, retry_strategy: retryStrategy })
+      clientSub = redis.createClient({
+        ...adapterOptions,
+        retry_strategy: retryStrategy,
+        return_buffers: true          // binärsichere Payload + korrekte Byte-Statistik
       })
+
+      const isUp = () =>
+        Boolean(clientSub && clientSub.ready && clientPub && clientPub.ready)
+
+      const syncState = () => {
+        const up = isUp()
+        if (up === this.isConnected) return
+
+        this.isConnected = up
+
+        if (up) {
+          const attempts = this.repeatAttemptCounter
+          this.repeatAttemptCounter = 0
+          this.log.info(`Redis reconnected${attempts ? ` after ${attempts} attempts` : ''}.`)
+          this.connected({ wasReconnect: true })
+        } else {
+          this.interruptCounter++
+          this.log.warn(`Redis disconnected (SUB: ${clientSub.ready}, PUB: ${clientPub.ready}).`)
+          this.disconnected()
+        }
+      }
+
+      const waitForReady = (client) => new Promise((resolve, reject) => {
+        const onReady = () => { client.removeListener('error', onError); resolve() }
+        const onError = (error) => { client.removeListener('ready', onReady); reject(error) }
+        client.once('ready', onReady)
+        client.once('error', onError)
+      })
+
+      return Promise.all([waitForReady(clientPub), waitForReady(clientSub)])
         .then(() => {
-          this.connected();
-        });
+          this.isConnected = true
+
+          for (const [client, label] of [[clientSub, 'SUB'], [clientPub, 'PUB']]) {
+            client.on('ready', syncState)
+            client.on('end', syncState)
+
+            client.on('reconnecting', () => {
+              this.repeatAttemptCounter++
+              this.log.debug(`Redis ${label} reconnecting (attempt ${this.repeatAttemptCounter}).`)
+              syncState()
+            })
+
+            // Dauerhaft nötig: EventEmitter ohne error-Listener wirft.
+            client.on('error', (error) => {
+              const detail = !error
+                ? '(no error object)'
+                : error.message || error.code || error.constructor.name
+              this.log.error(`Redis ${label} error: ${detail}`)
+              syncState()
+            })
+          }
+
+          clientSub.on('message', (topic, message) => {
+            const type = topic.toString().split('.')[1]
+            this.incomingMessage(type, message)
+          })
+
+          this.log.info('Redis SUB and PUB clients connected.')
+          this.connected()
+        })
+        .catch((error) => {
+          if (clientSub) clientSub.end(true)
+          if (clientPub) clientPub.end(true)
+          clientSub = clientPub = null
+          throw error
+        })
     },
+
     subscribe (type, nodeId) {
-      return new Promise(resolve => {
-        const topic = this.getTopic(type, nodeId);
-        clientSub.subscribe(topic, () => {
-          return resolve();
-        });
-      });
+      return new Promise((resolve, reject) => {
+        const topic = this.getTopic(type, nodeId)
+        clientSub.subscribe(topic, (error) => error ? reject(error) : resolve())
+      })
     },
+
     send (message) {
-      const data = this.serialize(message);
-      if (this.isConnected) {
-        this.updateStatisticSent(data.length);
-        const topic = this.getTopic(message.type, message.targetNodeId);
-        clientPub.publish(topic, data);
+      if (!this.isConnected) {
+        this.log.debug('Message dropped, adapter not connected.', { type: message.type })
+        return Promise.resolve()
       }
-      return Promise.resolve();
+
+      const data = this.serialize(message)
+      if (!data) return Promise.resolve()
+
+      this.updateStatisticSent(data.length)
+      clientPub.publish(this.getTopic(message.type, message.targetNodeId), data)
+
+      return Promise.resolve()
     },
+
     close () {
-      if (clientPub && clientSub) {
-        clientPub.quit();
-        clientSub.quit();
-      }
-      return promiseDelay(Promise.resolve(), 500);
+      const quit = (client) => client
+        ? new Promise((resolve) => client.quit(() => resolve()))
+        : Promise.resolve()
+
+      return Promise.all([quit(clientPub), quit(clientSub)])
+        .then(() => { clientSub = clientPub = null })
     }
-  });
-};
+  })
+}
 
-module.exports = RedisTransportAdapter;
+module.exports = RedisTransportAdapter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-js/redis-transport",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "weave redis transport adapter module",
   "main": "lib/index.js",
   "scripts": {
@@ -20,10 +20,10 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@weave-js/core": ">=0.9.0"
+    "@weave-js/core": "0.16.0"
   },
   "devDependencies": {
-    "@weave-js/core": "^0.13.0"
+    "@weave-js/core": "^0.16.0"
   },
   "jest": {
     "testEnvironment": "node",
@@ -33,8 +33,8 @@
     ]
   },
   "dependencies": {
-    "@weave-js/utils": "^0.12.0",
+    "@weave-js/utils": "^0.13.0",
     "redis": "^3.1.2"
   },
-  "gitHead": "6772c8bfb00be1da32c17cff621a8abcd98a08fc"
+  "gitHead": "84fd5e4af3af96e8c004bcfba40bb3cb35f23fa7"
 }

package/test/adapter.test.js

@@ -1,19 +1,43 @@
 const { Weave } = require('@weave-js/core');
 const REDISTransport = require('../lib/index');
 
+const waitUntil = (predicate, timeout = 5000, interval = 25) =>
+  new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+
+    const check = () => {
+      if (predicate()) {
+        return resolve();
+      }
+
+      if (Date.now() - startedAt > timeout) {
+        return reject(new Error('Timeout while waiting for condition'));
+      }
+
+      setTimeout(check, interval);
+    };
+
+    check();
+  });
+
 describe('REDIS transport adapter', () => {
-  let broker1;
-  let broker2;
+  const namespace = `redis-test-${process.pid}-${Date.now()}`;
   const startedHook1 = jest.fn();
   const startedHook2 = jest.fn();
+  const eventHandler = jest.fn();
+  const broadcastHandler1 = jest.fn();
+  const broadcastHandler2 = jest.fn();
 
-  beforeEach(() => {
+  let broker1;
+  let broker2;
+
+  beforeAll(async () => {
     broker1 = Weave({
       nodeId: 'node1',
       logger: {
         enabled: false
       },
-      namespace: 'redis-test',
+      namespace,
       transport: {
         adapter: REDISTransport()
       },
@@ -25,7 +49,13 @@ describe('REDIS transport adapter', () => {
       actions: {
         hello (context) {
           return 'Hello from ' + context.nodeId;
+        },
+        greet (context) {
+          return `Hello ${context.data.name}!`;
         }
+      },
+      events: {
+        'user.broadcasted': broadcastHandler1
       }
     });
 
@@ -34,7 +64,7 @@ describe('REDIS transport adapter', () => {
       logger: {
         enabled: false
       },
-      namespace: 'redis-test',
+      namespace,
       transport: {
         adapter: REDISTransport()
       },
@@ -46,34 +76,123 @@ describe('REDIS transport adapter', () => {
       actions: {
         hello () {
           return 'Hello from ' + this.broker.nodeId;
+        },
+        echo (context) {
+          return context.data;
+        },
+        fail () {
+          throw new Error('Expected failure');
         }
+      },
+      events: {
+        'user.created': eventHandler,
+        'user.broadcasted': broadcastHandler2
       }
     });
 
-    return Promise.all([
-      broker1.start(),
-      broker2.start()
+    await Promise.all([broker1.start(), broker2.start()]);
+
+    await Promise.all([
+      broker1.waitForServices(['testService2']),
+      broker2.waitForServices(['testService1'])
     ]);
   });
 
-  afterEach(() => {
+  afterAll(() => {
     return Promise.all([broker1.stop(), broker2.stop()]);
   });
 
-  it('should connect', () => {
+  it('should connect and call the started hooks exactly once', () => {
     expect(startedHook1).toBeCalledTimes(1);
     expect(startedHook2).toBeCalledTimes(1);
   });
 
-  it('should get node info', (done) => {
-    broker1
-      .waitForServices(['testService2'])
-      .then(() => {
-        return broker1.call('testService2.hello');
-      })
-      .then(result => {
-        expect(result).toBe('Hello from node2');
-        done();
-      });
+  it('should discover the remote node', () => {
+    const node = broker1.runtime.registry.nodeCollection.get('node2');
+    expect(node).toBeDefined();
+    expect(node.isAvailable).toBe(true);
+  });
+
+  it('should call a remote action (node1 -> node2)', async () => {
+    const result = await broker1.call('testService2.hello');
+    expect(result).toBe('Hello from node2');
+  });
+
+  it('should call a remote action (node2 -> node1)', async () => {
+    const result = await broker2.call('testService1.hello');
+    expect(result).toBe('Hello from node1');
+  });
+
+  it('should pass parameters to a remote action', async () => {
+    const result = await broker2.call('testService1.greet', { name: 'Weave' });
+    expect(result).toBe('Hello Weave!');
+  });
+
+  it('should transfer complex payloads without losing data', async () => {
+    const payload = {
+      text: 'Hänsel & Grätel äöüß',
+      number: 42.5,
+      flag: true,
+      nothing: null,
+      nested: { list: [1, 2, 3], deep: { key: 'value' } }
+    };
+
+    const result = await broker1.call('testService2.echo', payload);
+    expect(result).toEqual(payload);
+  });
+
+  it('should propagate errors of remote actions to the caller', async () => {
+    await expect(broker1.call('testService2.fail'))
+      .rejects
+      .toThrow('Expected failure');
+  });
+
+  it('should reject calls to unknown actions', async () => {
+    await expect(broker1.call('testService2.unknownAction')).rejects.toThrow();
+  });
+
+  it('should deliver emitted events to the remote node', async () => {
+    eventHandler.mockClear();
+
+    broker1.emit('user.created', { id: 1 });
+
+    await waitUntil(() => eventHandler.mock.calls.length === 1);
+
+    const context = eventHandler.mock.calls[0][0];
+    expect(context.data).toEqual({ id: 1 });
+    expect(context.callerNodeId).toBe('node1');
+  });
+
+  it('should deliver broadcast events to all nodes', async () => {
+    broadcastHandler1.mockClear();
+    broadcastHandler2.mockClear();
+
+    broker1.broadcast('user.broadcasted', { id: 2 });
+
+    await waitUntil(() =>
+      broadcastHandler1.mock.calls.length === 1 &&
+      broadcastHandler2.mock.calls.length === 1
+    );
+
+    const remoteContext = broadcastHandler2.mock.calls[0][0];
+    expect(remoteContext.data).toEqual({ id: 2 });
+  });
+
+  it('should handle multiple parallel remote calls', async () => {
+    const results = await Promise.all(
+      Array.from({ length: 25 }, (_, index) =>
+        broker1.call('testService2.echo', { index })
+      )
+    );
+
+    results.forEach((result, index) => {
+      expect(result).toEqual({ index });
+    });
+  });
+
+  it('should respond to ping messages of remote nodes', async () => {
+    const result = await broker1.ping('node2');
+    expect(result.nodeId).toBe('node2');
+    expect(typeof result.elapsedTime).toBe('number');
   });
 });

package/test/unit.test.js

@@ -0,0 +1,203 @@
+const RedisTransportAdapter = require('../lib/index');
+
+const createMockLog = () => ({
+  info: jest.fn(),
+  debug: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn()
+});
+
+const createMockRuntime = ({ namespace, nodeId = 'unit-node' } = {}) => {
+  const log = createMockLog();
+
+  const broker = {
+    nodeId,
+    options: { namespace },
+    handleError (error) {
+      throw error;
+    }
+  };
+
+  const transport = {
+    log,
+    statistics: {
+      sent: { packages: 0 },
+      received: { packages: 0 }
+    }
+  };
+
+  return { broker, transport, log };
+};
+
+const initAdapter = async (adapter, runtimeOptions) => {
+  const runtime = createMockRuntime(runtimeOptions);
+  await adapter.init(runtime.broker, runtime.transport, () => {});
+  return runtime;
+};
+
+const waitForBusEvent = (adapter, eventName, timeout = 5000) =>
+  new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`Timeout waiting for bus event "${eventName}"`)),
+      timeout
+    );
+
+    adapter.bus.once(eventName, (...args) => {
+      clearTimeout(timer);
+      resolve(args);
+    });
+  });
+
+// The connect() promise of the adapter is resolved through the
+// "$adapter.connected" bus event, so we wait for the event instead.
+const connectAdapter = (adapter) => {
+  const connected = waitForBusEvent(adapter, '$adapter.connected');
+  adapter.connect();
+  return connected;
+};
+
+describe('REDIS adapter (unit)', () => {
+  let adapter;
+
+  afterEach(async () => {
+    if (adapter) {
+      await adapter.close();
+      adapter = null;
+    }
+  });
+
+  it('should expose the adapter name "REDIS"', () => {
+    adapter = RedisTransportAdapter();
+    expect(adapter.name).toBe('REDIS');
+  });
+
+  it('should not be connected initially', () => {
+    adapter = RedisTransportAdapter();
+    expect(adapter.isConnected).toBe(false);
+    expect(adapter.interruptCounter).toBe(0);
+    expect(adapter.repeatAttemptCounter).toBe(0);
+  });
+
+  it('should build topics with the namespace prefix', async () => {
+    adapter = RedisTransportAdapter();
+    await initAdapter(adapter, { namespace: 'unit-ns' });
+
+    expect(adapter.getTopic('INFO', 'node1')).toBe('weave-unit-ns.INFO.node1');
+    expect(adapter.getTopic('DISCOVERY')).toBe('weave-unit-ns.DISCOVERY');
+  });
+
+  it('should build topics without a namespace', async () => {
+    adapter = RedisTransportAdapter();
+    await initAdapter(adapter, {});
+
+    expect(adapter.getTopic('INFO', 'node1')).toBe('weave.INFO.node1');
+  });
+
+  it('should resolve and drop the message when sending while disconnected', async () => {
+    adapter = RedisTransportAdapter();
+    const { log } = await initAdapter(adapter, { namespace: 'unit-send-disconnected' });
+
+    await adapter.send({ type: 'INFO', targetNodeId: 'node2', payload: {} });
+
+    expect(log.debug).toBeCalledTimes(1);
+    expect(log.debug).toBeCalledWith(
+      'Message dropped, adapter is not connected',
+      { type: 'INFO' }
+    );
+  });
+
+  it('should resolve close() even if the adapter was never connected', async () => {
+    adapter = RedisTransportAdapter();
+    await initAdapter(adapter, { namespace: 'unit-close' });
+    await adapter.close();
+    adapter = null;
+  });
+
+  it('should connect to a running redis server and emit "$adapter.connected"', async () => {
+    adapter = RedisTransportAdapter();
+    await initAdapter(adapter, { namespace: 'unit-connect' });
+
+    await connectAdapter(adapter);
+
+    expect(adapter.isConnected).toBe(true);
+  });
+
+  it('should merge the adapter options with the default options', async () => {
+    // Explicit options matching the defaults must work the same way.
+    adapter = RedisTransportAdapter({ port: 6379, host: '127.0.0.1' });
+    await initAdapter(adapter, { namespace: 'unit-options' });
+
+    await connectAdapter(adapter);
+
+    expect(adapter.isConnected).toBe(true);
+  });
+
+  it('should deliver published messages to subscribers of the topic', async () => {
+    adapter = RedisTransportAdapter();
+    const { broker } = await initAdapter(adapter, { namespace: `unit-roundtrip-${Date.now()}` });
+
+    await connectAdapter(adapter);
+    await adapter.subscribe('EVENT', 'node2');
+
+    const incoming = waitForBusEvent(adapter, '$adapter.message');
+    await adapter.send({
+      type: 'EVENT',
+      targetNodeId: 'node2',
+      payload: { eventName: 'user.created' }
+    });
+
+    const [messageType, data] = await incoming;
+
+    expect(messageType).toBe('EVENT');
+    expect(data.payload.eventName).toBe('user.created');
+    expect(data.payload.sender).toBe(broker.nodeId);
+  });
+
+  it('should update the sent and received statistics', async () => {
+    adapter = RedisTransportAdapter();
+    const { transport } = await initAdapter(adapter, { namespace: `unit-stats-${Date.now()}` });
+
+    await connectAdapter(adapter);
+    await adapter.subscribe('HEARTBEAT');
+
+    const incoming = waitForBusEvent(adapter, '$adapter.message');
+    await adapter.send({ type: 'HEARTBEAT', payload: {} });
+    await incoming;
+
+    expect(transport.statistics.sent.packages).toBeGreaterThan(0);
+    expect(transport.statistics.received.packages).toBeGreaterThan(0);
+  });
+
+  it('should not deliver messages of topics without a subscription', async () => {
+    adapter = RedisTransportAdapter();
+    await initAdapter(adapter, { namespace: `unit-no-sub-${Date.now()}` });
+
+    await connectAdapter(adapter);
+    await adapter.subscribe('INFO');
+
+    const received = [];
+    adapter.bus.on('$adapter.message', (type) => received.push(type));
+
+    await adapter.send({ type: 'HEARTBEAT', payload: {} });
+
+    const incoming = waitForBusEvent(adapter, '$adapter.message');
+    await adapter.send({ type: 'INFO', payload: {} });
+    await incoming;
+
+    expect(received).toEqual(['INFO']);
+  });
+
+  it('should not receive its own messages after close()', async () => {
+    adapter = RedisTransportAdapter();
+    await initAdapter(adapter, { namespace: `unit-closed-${Date.now()}` });
+
+    await connectAdapter(adapter);
+    await adapter.subscribe('INFO');
+    await adapter.close();
+
+    // After close the clients are gone; sending must still resolve without throwing.
+    adapter.isConnected = false;
+    await adapter.send({ type: 'INFO', payload: {} });
+    adapter = null;
+  });
+});

package/.vscode/launch.json

@@ -1,35 +0,0 @@
-{
-    // Verwendet IntelliSense zum Ermitteln möglicher Attribute.
-    // Zeigen Sie auf vorhandene Attribute, um die zugehörigen Beschreibungen anzuzeigen.
-    // Weitere Informationen finden Sie unter https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Jest All",
-            "program": "${workspaceFolder}/node_modules/.bin/jest",
-            "args": ["--runInBand"],
-            "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen",
-            "disableOptimisticBPs": true,
-            "windows": {
-                "program": "${workspaceFolder}/node_modules/jest/bin/jest",
-        }
-        },
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Jest Current File",
-            "program": "${workspaceFolder}/node_modules/.bin/jest",
-            "args": ["${relativeFile}"],
-            "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen",
-            "disableOptimisticBPs": true,
-            "windows": {
-                "program": "${workspaceFolder}/node_modules/jest/bin/jest",
-            }
-        }
-    ]
-}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2020 Fachwerk Software
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.