elasticio-sailor-nodejs 3.0.0-sailor-proxy-dev1 → 3.0.0-sailor-proxy-dev2

package/lib/proxy-client.js

@@ -12,7 +12,8 @@ const {
     HTTP2_HEADER_PATH,
     HTTP2_HEADER_METHOD,
     HTTP2_HEADER_AUTHORIZATION,
-    HTTP2_HEADER_STATUS
+    HTTP2_HEADER_STATUS,
+    NGHTTP2_NO_ERROR
 } = http2.constants;
 
 const HEADER_ROUTING_KEY = 'x-eio-routing-key';
@@ -29,10 +30,12 @@ class ProxyClient {
         this.settings = settings;
         this._encryptor = new Encryptor(this.settings.MESSAGE_CRYPTO_PASSWORD, this.settings.MESSAGE_CRYPTO_IV);
         this.closed = true;
+        this.listeningForMessages = true;
         this.clientSession = null;
         this.reconnecting = false;
         this.reconnectAttempts = 0;
         this.reconnectTimer = null;
+        this.getMessageStreams = new Set();
 
         const username = settings.API_USERNAME;
         const password = settings.API_KEY;
@@ -100,24 +103,27 @@ class ProxyClient {
 
         // Handle connection close
         this.clientSession.on('close', () => {
-            log.warn({ closed: this.closed, reconnecting: this.reconnecting }, 'HTTP2 session closed');
+            log.debug({ closed: this.closed, reconnecting: this.reconnecting }, 'HTTP2 session closed');
             if (!this.closed && !this.reconnecting) {
+                log.warn('HTTP2 session closed unexpectedly, initiating reconnection');
                 this._handleDisconnection('close');
             }
         });
 
         // Handle GOAWAY frames (server-initiated shutdown)
         this.clientSession.on('goaway', (errorCode, lastStreamID, opaqueData) => {
-            log.warn({ errorCode, lastStreamID, closed: this.closed }, 'Received GOAWAY from server');
+            log.debug({ errorCode, lastStreamID, closed: this.closed }, 'Received GOAWAY from server');
             if (!this.closed) {
+                log.warn('Received GOAWAY frame from server, initiating reconnection');
                 this._handleDisconnection('goaway', { errorCode, lastStreamID });
             }
         });
 
         // Handle timeout
         this.clientSession.on('timeout', () => {
-            log.warn({ closed: this.closed }, 'HTTP2 session timeout');
+            log.debug({ closed: this.closed }, 'HTTP2 session timeout');
             if (!this.closed) {
+                log.warn('HTTP2 session timeout, initiating reconnection');
                 this._handleDisconnection('timeout');
             }
         });
@@ -192,11 +198,13 @@ class ProxyClient {
 
         // Clear any pending reconnection timers
         if (this.reconnectTimer) {
+            log.debug('Clearing pending reconnection timer');
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
         }
 
         return new Promise((resolve) => {
+            log.debug('Disconnecting from Sailor Proxy');
             if (!this.clientSession || this.clientSession.destroyed) {
                 log.debug('Session already destroyed');
                 return resolve();
@@ -391,23 +399,27 @@ class ProxyClient {
     }
 
     async listenForMessages(messageHandler) {
-        while (!this.closed) {
+        while (this.listeningForMessages) {
             try {
+                log.debug('Starting to listen for messages from proxy');
                 await this._ensureConnection();
 
                 const stepId = this.settings.STEP_ID;
                 const prefetch = this.settings.PROXY_PREFETCH_SAILOR;
+                // TODO: When prefetch > 1, what if one message takes a long time to process - do we want to wait for it before requesting the next one?
                 await Promise.all(new Array(prefetch).fill().map(async () => {
                     const queryParams = new URLSearchParams({
                         stepId,
                         prefetch
                     }).toString();
                     log.info({ stepId, prefetch }, 'Requesting message from proxy');
+                    // TODO: what timeout is here? e.g. when flow is realtime - we might need to wait a long time...
                     const getMessageStream = this.clientSession.request({
                         [HTTP2_HEADER_PATH]: `/message?${queryParams}`,
                         [HTTP2_HEADER_METHOD]: 'GET',
                         [HTTP2_HEADER_AUTHORIZATION]: this.authHeader
                     });
+                    this.getMessageStreams.add(getMessageStream);
 
                     const { headers, body } = await new Promise((resolve, reject) => {
                         getMessageStream.on('response', (headers, flags) => {
@@ -459,10 +471,30 @@ class ProxyClient {
                     log.debug('Currently reconnecting, will retry listening for messages after reconnection');
                 }
                 await new Promise(resolve => setTimeout(resolve, 1000));
+            } finally {
+                log.debug('Cleaning up message streams');
+                this.getMessageStreams.clear();
             }
         }
     }
 
+    async stopListeningForMessages() {
+        log.info('Stopping listening for messages');
+        await Promise.all(Array.from(this.getMessageStreams).map(stream => {
+            if (stream.closed || stream.destroyed) {
+                log.debug({ closed: stream.closed, destroyed: stream.destroyed  }, 'Message stream is already closed or destroyed');
+                return Promise.resolve();
+            }
+            return new Promise((resolve) => {
+                stream.close(NGHTTP2_NO_ERROR, () => {
+                    log.debug('Closed message stream');
+                    resolve();
+                });
+            });
+        }));
+        this.listeningForMessages = false;
+    }
+
     async sendMessage({
         incomingMessageId,
         type,

package/lib/sailor.js

@@ -80,7 +80,6 @@ class Sailor {
     }
 
     async disconnect() {
-        // TODO: delete if not needed (currently used only in old tests)
         log.debug('Disconnecting, %s messages in processing', this.messagesCount);
         return this.proxyClient.disconnect();
     }
@@ -171,10 +170,13 @@ class Sailor {
 
     async processMessageAndMaybeShutdownCallback(headers, body) {
         try {
-            return await this.processMessage(headers, body);
+            await this.processMessage(headers, body);
         } catch (e) {
             log.error(e, 'Something very bad happened during message processing');
         } finally {
+            log.debug({
+                messagesCount: this.messagesCount
+            }, 'Finished processing message, checking if shutdownCallback should be called');
             if (this.shutdownCallback) {
                 if (this.messagesCount === 0) {
                     // there is no another processMessage invocation, so it's time to call shutdownCallback
@@ -195,7 +197,7 @@ class Sailor {
             return new Promise(resolve => this.shutdownCallback = resolve);
         }
 
-        await this.proxyClient.disconnect();
+        await this.proxyClient.stopListeningForMessages();
         if (this.messagesCount === 0) {
             // there is no unfinished processMessage invocation, let's just resolve scheduleShutdown now
             log.debug('scheduleShutdown – about to shutdown immediately');
@@ -443,7 +445,7 @@ class Sailor {
                 }
             }
 
-            function onEnd() {
+            async function onEnd() {
                 if (endWasEmitted) {
                     logger.warn({
                         messagesCount: that.messagesCount,
@@ -455,7 +457,7 @@ class Sailor {
 
                 endWasEmitted = true;
 
-                that.proxyClient.finishProcessing(
+                await that.proxyClient.finishProcessing(
                     incomingMessageHeaders,
                     taskExec.errorCount > 0
                         ? MESSAGE_PROCESSING_STATUS.ERROR

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elasticio-sailor-nodejs",
   "description": "The official elastic.io library for bootstrapping and executing for Node.js connectors",
-  "version": "3.0.0-sailor-proxy-dev1",
+  "version": "3.0.0-sailor-proxy-dev2",
   "main": "run.js",
   "scripts": {
     "build": "tsc",

package/run.js

@@ -74,8 +74,10 @@ async function gracefulShutdown() {
     logger.trace('Waited an init before graceful shutdown');
 
     try {
-        logger.info('Disconnecting...');
+        logger.info('Scheduling shutdown...');
         await sailor.scheduleShutdown();
+        logger.info('Finished shutdown. Disconnecting...');
+        await sailor.disconnect();
         logger.info('Successfully disconnected');
         process.exit();
     } catch (err) {
@@ -88,7 +90,6 @@ async function run(settings, ipc) {
     prepareSandbox();
     try {
         await putOutToSea(settings, ipc);
-        logger.info('Fully initialized and waiting for messages');
     } catch (e) {
         if (sailor && !sailor.isConnected()) {
             await sailor.reportError(e);
@@ -97,6 +98,21 @@ async function run(settings, ipc) {
     }
 }
 
+function addProcessListeners() {
+    process.on('SIGTERM', function onSigterm() {
+        logger.info('Received SIGTERM');
+        gracefulShutdown();
+    });
+
+    process.on('SIGINT', function onSigint() {
+        logger.info('Received SIGINT');
+        gracefulShutdown();
+    });
+
+    process.on('uncaughtException', logger.criticalErrorAndExit.bind(logger, 'process.uncaughtException'));
+    process.on('unhandledRejection', (err) => logger.error(err, 'process.unhandledRejection'));
+}
+
 exports.__test__ = {
     disconnectOnly: function disconnectOnly() {
         if (!disconnectRequired) {
@@ -110,22 +126,10 @@ exports.__test__ = {
 };
 exports.run = run;
 exports.putOutToSea = putOutToSea;
+exports.addProcessListeners = addProcessListeners;
 
 if (require.main === module || process.mainModule.filename === __filename) {
-    process.on('SIGTERM', function onSigterm() {
-        logger.info('Received SIGTERM');
-        gracefulShutdown();
-    });
-
-    process.on('SIGINT', function onSigint() {
-        logger.info('Received SIGINT');
-        gracefulShutdown();
-    });
-
-    process.on('uncaughtException', logger.criticalErrorAndExit.bind(logger, 'process.uncaughtException'));
-    process.on('unhandledRejection', (err) => logger.error(err, 'process.unhandledRejection'));
-
+    addProcessListeners();
     const ipc = new IPC();
-
     run(settings.readFrom(process.env), ipc);
 }

package/run.local.js

@@ -8,7 +8,9 @@ function setEnvVars() {
 setEnvVars();
 
 const { IPC } = require('./lib/ipc');
-const { run } = require('./run');
+const { addProcessListeners, run } = require('./run');
 const settings = require('./lib/settings.js');
 const ipc = new IPC();
+
+addProcessListeners();
 run(settings.readFrom(process.env), ipc);

package/mise.toml

@@ -1,2 +0,0 @@
-[tools]
-node = "18.16.1"