@jambonz/mrf 0.1.1 → 0.1.2

package/lib/mediaserver.js

@@ -1,5 +1,14 @@
 const { EventEmitter } = require('events');
 const Endpoint = require('./endpoint');
+const Connection = require('./connection');
+
+const RECONNECT_DELAY_MS = 500;
+const RECONNECT_DELAY_MAX_MS = 5000;
+
+function clientInfo() {
+  const { name, version } = require('../package.json');
+  return `${name}/${version}`;
+}
 
 /**
  * MediaServer represents one connection to a mediajam server, exposing the
@@ -28,25 +37,69 @@ class MediaServer extends EventEmitter {
     // fsmrf compatibility: feature-server listens on ms.conn for esl events
     this.conn = new EventEmitter();
 
+    this._wireConnection(connection);
+  }
+
+  _wireConnection(connection) {
+    this._connection = connection;
     connection.on('evt', (frame) => this._onEvent(frame));
     connection.on('stats', (data) => this._onStats(data));
-    connection.on('close', () => {
-      this.connected = false;
-      // fsmrf parity: a self-initiated destroy()/disconnect() tears down
-      // quietly; esl::end and endpoint destroy events are reserved for an
-      // unexpected loss of the media server
-      if (this._selfDestroyed) {
-        this._endpoints.clear();
+    connection.on('close', () => this._onConnectionClose());
+    connection.on('error', (err) => this.emit('error', err));
+  }
+
+  /* An unexpected loss of the media server ends its endpoints (the
+   * server died with them) but NOT this MediaServer: mediajam restarts
+   * (deploys) must not take the feature-server down with them, so we
+   * quietly redial with backoff and re-emit esl::ready on recovery —
+   * mirroring the ESL auto-reconnect of the freeswitch world. esl::end
+   * is never emitted for a transient loss because the feature-server
+   * treats it as fatal (it tears down drachtio when its last media
+   * server is gone). A self-initiated destroy()/disconnect() tears down
+   * quietly with no reconnect. */
+  _onConnectionClose() {
+    this.connected = false;
+    if (this._selfDestroyed) {
+      this._endpoints.clear();
+      return;
+    }
+    for (const [, ep] of this._endpoints) {
+      ep._onEvent('endpoint.destroyed', { reason: 'connectionLost' });
+    }
+    this._endpoints.clear();
+    this.emit('disconnect');
+    this._reconnect();
+  }
+
+  async _reconnect() {
+    if (this._reconnecting) return;
+    this._reconnecting = true;
+    this.logger?.info(`mediajam at ${this.address}:${this.port} lost; reconnecting`);
+    let delay = RECONNECT_DELAY_MS;
+    let attempts = 0;
+    while (!this._selfDestroyed) {
+      // unref: a pending reconnect must not hold the process open
+      await new Promise((r) => setTimeout(r, delay).unref());
+      try {
+        const connection = new Connection(this.logger);
+        const helloData = await connection.connect(
+          { address: this.address, port: this.port }, clientInfo());
+        this._wireConnection(connection);
+        this._reconnecting = false;
+        this._onHello(helloData);
+        this.logger?.info(`reconnected to mediajam at ${this.address}:${this.port}` +
+          ` after ${attempts + 1} attempt(s)`);
         return;
+      } catch (err) {
+        attempts++;
+        if (attempts % 10 === 0) {
+          this.logger?.info(`still unable to reach mediajam at ${this.address}:${this.port}` +
+            ` (${attempts} attempts): ${err.message}`);
+        }
+        delay = Math.min(delay * 2, RECONNECT_DELAY_MAX_MS);
       }
-      for (const [, ep] of this._endpoints) {
-        ep._onEvent('endpoint.destroyed', { reason: 'connectionLost' });
-      }
-      this._endpoints.clear();
-      this.conn.emit('esl::end');
-      this.emit('disconnect');
-    });
-    connection.on('error', (err) => this.emit('error', err));
+    }
+    this._reconnecting = false;
   }
 
   _onHello(helloData) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/mrf",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "main": "index.js",
   "scripts": {
     "test": "node --test",

package/test/client.test.js

@@ -174,19 +174,28 @@ test('stats update mediaserver gauges', async(t) => {
   assert.equal(ms.cpuIdle, 88);
 });
 
-test('connection loss destroys endpoints with connectionLost', async() => {
+test('connection loss destroys endpoints and reconnects', async() => {
   const mock = new MockMediajam();
   const port = await mock.listen();
   const mrf = new Mrf();
   const ms = await mrf.connect({ address: '127.0.0.1', port });
   const ep = await ms.createEndpoint({});
   const destroyed = new Promise((resolve) => ep.once('destroy', resolve));
-  const ended = new Promise((resolve) => ms.conn.once('esl::end', resolve));
+  const disconnected = new Promise((resolve) => ms.once('disconnect', resolve));
+  const ready = new Promise((resolve) => ms.conn.once('esl::ready', resolve));
   mock.close();
   for (const socket of mock.sockets) socket.destroy();
   const evt = await destroyed;
-  await ended;
+  await disconnected;
   assert.equal(evt.reason, 'connectionLost');
+  // esl::end must NOT fire on transient loss (it is fatal to the
+  // feature-server); the wrapper redials and re-emits esl::ready
+  ms.conn.once('esl::end', () => assert.fail('esl::end fired on transient loss'));
+  await mock.listen(port);
+  await ready;
+  assert.equal(ms.connected, true);
+  ms.destroy();
+  mock.close();
 });
 
 test('setLogLevel changes and queries server log level', async(t) => {

package/test/support/mock-server.js

@@ -14,10 +14,10 @@ class MockMediajam {
     this.requests = []; // every req frame received, for assertions
   }
 
-  listen() {
+  listen(port = 0) {
     return new Promise((resolve) => {
       this.server = net.createServer((socket) => this._onConnection(socket));
-      this.server.listen(0, '127.0.0.1', () => {
+      this.server.listen(port, '127.0.0.1', () => {
         this.port = this.server.address().port;
         resolve(this.port);
       });