@jambonz/mrf 0.1.1 → 0.1.3

package/lib/endpoint.js

@@ -46,12 +46,16 @@ class Endpoint extends EventEmitter {
       seekOffset = file.seekOffset;
       file = file.file;
     }
-    const urls = (Array.isArray(file) ? file : [file]).map(translatePlayUrl);
+    const files = Array.isArray(file) ? file : [file];
+    const urls = files.map(translatePlayUrl);
     const data = { urls };
     if (seekOffset > 0) data.seekOffset = parseInt(seekOffset, 10);
     const { playId } = await this._request('play.start', data);
     return new Promise((resolve, reject) => {
-      this._pendingPlays.set(playId, { resolve, reject });
+      // file (the caller's original, untranslated path) rides on the
+      // playback-start/stop events: FS parity — the say/play tasks match
+      // events to plays by evt.file when there is no tts playback id
+      this._pendingPlays.set(playId, { resolve, reject, file: files[0] });
     });
   }
 
@@ -457,9 +461,12 @@ class Endpoint extends EventEmitter {
       case 'dtmf':
         this.emit('dtmf', { dtmf: data.digit, duration: data.durationMs, source: data.source });
         break;
-      case 'play.start':
-        this.emit('playback-start', { playId: data.playId, ...ttsVars(data.tts) });
+      case 'play.start': {
+        const file = this._pendingPlays.get(data.playId)?.file;
+        this.emit('playback-start',
+          { playId: data.playId, ...(file && {file}), ...ttsVars(data.tts) });
         break;
+      }
       case 'play.done': {
         const p = this._pendingPlays.get(data.playId);
         if (p) {
@@ -475,7 +482,9 @@ class Endpoint extends EventEmitter {
             playbackLastOffsetPos: data.lastOffsetPos ?? 0
           });
         }
-        this.emit('playback-stop', { playId: data.playId, reason: data.reason, ...ttsVars(data.tts) });
+        this.emit('playback-stop',
+          { playId: data.playId, reason: data.reason, ...(p?.file && {file: p.file}),
+            ...ttsVars(data.tts) });
         break;
       }
       default: {

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.3",
   "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);
       });