@audc/rtpengine-client 0.5.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Dave Horton
+
+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.
+

package/README.md

@@ -0,0 +1,108 @@
+# rtpengine-client [![Build Status](https://travis-ci.org/davehorton/rtpengine-client.svg?branch=master)](http://travis-ci.org/davehorton/rtpengine-client) [![NPM version](https://badge.fury.io/js/rtpengine-client.svg)](http://badge.fury.io/js/rtpengine-client) [![Coverage Status](https://coveralls.io/repos/github/davehorton/rtpengine-client/badge.svg?branch=master)](https://coveralls.io/github/davehorton/rtpengine-client?branch=master)
+
+A Promises-based nodejs client for accessing rtpengine via ng protocol
+
+## Usage
+
+```js
+const Client = require('rtpengine-client').Client;
+const client = new Client();
+
+client.ping(22222, '39.194.250.246')
+  .then((res) => {
+    console.log(`received ${JSON.stringify(res)}`); // {result: 'pong'}
+  })
+  .catch((err) => {
+    console.log(`Error: ${err}`);
+  });
+```
+
+## Constructing a client
+```js
+client = new Client();  // listen on any port and default address
+// or..
+client = new Client(9055);    // listen on a specific port
+// or..
+client = new Client(9055, '192.168.1.10'); // listen on a specific port and address
+// or..
+client = new Client({port: 9055, host: '192.168.1.10'}); // listen on a specific port and address
+// or..
+client = new Client({timeout: 1500}); // wait a max of 1500 ms for each command reply, throw error on timeout
+// or..
+client = new Client({rejectOnFailure: true});
+// reject promise on any command if response from rtpengine has error
+// default behavior is to resolve with any response from rtpengine, even errors
+```
+
+## Websocket support
+
+```js
+const client = new Client('ws://<IP>:8080');
+
+client.on('listening', () => {
+  client.statistics()
+    .then((res) => {
+      console.log('received data', res);
+    })
+    .catch((err) => {
+      console.log(`Error: ${err}`);
+    });
+});
+```
+
+## Making requests
+The ng request verbs (`ping`, `offer`, `answer`, `delete`, `query`, `start recording`, `stop recording`, `block DTMF`, `unblock DTMF`, `block media`, `unblock media`) are available as methods on the `client` object.  The sytax for each is the same:
++ the destination of the request comes first, either as `port, host` or `{port, host}`
++ following that, if any options are required for the request, those come next in an object.
+
+The function call returns a promise that is resolved when the response is received.
+
+Function names are as follows:
+
+| ng verb          | function name    |
+|------------------|------------------|
+|ping              | ping             |
+|offer             | offer            |
+|answer            | answer           |
+|delete            | delete           |
+|query             | query            |
+|start recording   | startRecording   |
+|stop recording    | stopRecording    |
+|block DTMF        | blockDTMF        |
+|unblock DTMF      | unblockDTMF      |
+|play DTMF         | playDTMF         |
+|block media       | blockMedia       |
+|unblock media     | unblockMedia     |
+|silence media     | silenceMedia     |
+|unsilence media   | unsilenceMedia   |
+|start forwarding  | startForwarding  |
+|stop forwarding   | stopForwarding   |
+|play media        | playMedia        |
+|stop media        | stopMedia        |
+|statistics        | statistics       |
+|publish           | publish          |
+|subscribe request | subscribeRequest |
+|subscribe answer  | subscribeAnswer  |
+|unsubscribe       | unsubscribe      |
+
+For instance
+```
+client.offer(22222, '35.195.250.243', {
+  'sdp': ..
+  'call-id': ..
+  'from-tag': ..
+})
+  .then((res) => {
+    console.log(res); // { "result": "ok", "sdp": "v=0\r\no=..." }
+  })
+  .catch((err) => {
+
+  });
+
+// or..
+client.offer({port: 22222, host: '35.195.250.243}, {
+  'sdp': ..
+  'call-id': ..
+  'from-tag': ..
+}) // ...etc
+```

package/index.js

@@ -0,0 +1,6 @@
+const Client = require('./lib/Client');
+const WsClient = require('./lib/WsClient');
+const TcpClient = require('./lib/TcpClient');
+const RtpEngineError = require('./lib/error');
+
+module.exports = { Client, RtpEngineError, WsClient, TcpClient };

package/lib/BaseClient.js

@@ -0,0 +1,199 @@
+const bencode = require('bencode');
+const v4 = require('uuid-random');
+const Emitter = require('events').EventEmitter;
+const RtpEngineError = require('./error');
+const { getRtpEngineNameForCommand } = require('./constants');
+const debug = require('debug')('rtpengine:baseClient');
+
+class BaseClient extends Emitter {
+
+  constructor(opts) {
+    super();
+    this.type = opts.type;
+    this.connected = false;
+    this.timers = new Map();
+    this.timeout = opts.timeout || 0;
+
+    this.messages = new Map();
+    this.incomingMsgs = [];
+    if (this.timeout) {
+      this.timers = new Map();
+    }
+  }
+
+  get connectionBased() {
+    return ['tcp', 'websocket'].includes(this.type);
+  }
+
+  send_internal(name, opts, callback) {
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
+    }
+    opts = {
+      ...opts,
+      command: getRtpEngineNameForCommand(name)
+    };
+
+    debug(`RtpEngine: ${name} ${JSON.stringify(opts)}, callback: ${typeof callback}}`);
+
+    const __x = (opts, callback) => {
+      const cookie = v4();
+      const message = BaseClient.encodeMessage(cookie, opts);
+      this.messages.set(cookie, callback);
+
+      debug(`RtpEngine: sending command: ${cookie}: ${JSON.stringify(opts)}`);
+
+      if (this.timeout) {
+        debug(`setting timeout: ${this.timeout}ms`);
+        this.timers.set(cookie, setTimeout(this._onMessageTimeout.bind(this, cookie), this.timeout));
+      }
+
+      if (this.type === 'udp') {
+        this.socket.send(message, this.remotePort, this.remoteHost, (err) => {
+          if (err) {
+            console.error(`error sending command to rtpengine over ws at ${this.remoteHost}:${this.remotePort}`);
+            this.messages.delete(cookie);
+            return callback(err);
+          }
+        });
+      } else if (this.type === 'websocket') {
+        this.socket.send(message, (err) => {
+          if (err) {
+            console.error(`error sending command to rtpengine at ${this.url}`);
+            this.messages.delete(cookie);
+            return callback(err);
+          }
+        });
+      }
+      else if (this.type === 'tcp') {
+        if (!this.connected) return callback('socket to rtpengine is not connected');
+        this.socket.write(message, (err) => {
+          if (err) {
+            console.error(`error sending command to rtpengine over tcp at ${this.hostport}`);
+            this.messages.delete(cookie);
+            return callback(err);
+          }
+        });
+      }
+    };
+
+    if (callback) {
+      __x(opts, callback) ;
+      return this ;
+    }
+
+    return new Promise((resolve, reject) => {
+      __x(opts, (err, data) => {
+        if (err) return reject(err);
+        resolve(data);
+      });
+    });
+  }
+
+  _handleIncomingMessages() {
+    while (this.incomingMsgs.length) {
+      const msg = this.incomingMsgs.shift();
+      try {
+        const obj = BaseClient.decodeMessage(msg);
+        this._onParsedMessage(obj);
+      } catch (err) {
+        console.error({err}, 'error decoding message from rtpengine');
+        this.emit('error', new RtpEngineError(`malformed/unexpected message format ${msg}`));
+      }
+    }
+  }
+
+  _onMessage(msg) {
+    this.incomingMsgs.push(msg);
+    setImmediate(this._handleIncomingMessages.bind(this));
+  }
+
+  _onParsedMessage(obj) {
+    if (!this.messages.has(obj.id)) {
+      console.error({data: obj.data}, `received a response from rtpengine with unknown msg id: '${obj.id}'`);
+      this.emit('error', new RtpEngineError(
+        `received a response that can not be correlated to a request: ${obj.id}: ${obj.data}`));
+      return;
+    }
+
+    const callback = this.messages.get(obj.id);
+    if (this.timers) {
+      const timer = this.timers.get(obj.id);
+      clearTimeout(timer);
+      this.timers.delete(obj.id);
+    }
+
+    this.messages.delete(obj.id);
+    if (this.rejectOnError && obj.data.result === 'error') {
+      return callback(obj.data['error-reason']);
+    }
+    setImmediate(callback.bind(null, null, obj.data));
+  }
+
+  _onMessageTimeout(id) {
+    this.timers.delete(id);
+    const callback = this.messages.get(id);
+    if (!callback) {
+      this.emit('error', new RtpEngineError(
+        `received a timeout that can not be correlated to a request: ${id}`));
+      return;
+    }
+    this.messages.delete(id);
+
+    let connDetails = '';
+    if (this.type === 'udp') {
+      connDetails = `host:${this.remoteHost} port:${this.remotePort}`;
+    } else if (this.type === 'websocket') {
+      connDetails = `url:${this.url}`;
+    }  else if (this.type === 'tcp') {
+      connDetails = `hostport:${this.hostport}`;
+    }
+
+    callback(new RtpEngineError(`rtpengine timeout ${connDetails}`));
+  }
+
+  _onError(err) {
+    console.error(`RtpEngine#_onError: ${JSON.stringify(err)}`);
+    this.emit('error', err);
+  }
+
+  _onListening() {
+    this.emit('listening');
+    if (this.connectionBased) this.connected = true;
+  }
+
+  _onEnd() {
+    this.emit('end');
+    if (this.connectionBased) this.connected = false;
+  }
+
+  close() {
+    if ('tcp' === this.type) this.socket.destroy();
+    else this.socket.close();
+    if (this.connectionBased) this.connected = false;
+  }
+}
+
+
+BaseClient.decodeMessage = function(msg) {
+  const idx = msg.indexOf(' ');
+  if (idx === 36) {
+    const buf1 = msg.subarray(0, idx);
+    const buf2 = msg.subarray(idx + 1);
+    const data = bencode.decode(buf2, 'utf8');
+    const obj = { id: buf1.toString(), data };
+    return obj;
+  }
+  console.error(`no data returned from parsing ${msg}`);
+  throw new Error('Error parsing message');
+};
+
+BaseClient.encodeMessage = function(id, data) {
+  const message = new Buffer.from(
+    [id, bencode.encode(data)].join(' ')
+  );
+  return message;
+};
+
+module.exports = BaseClient;

package/lib/Client.js

@@ -0,0 +1,107 @@
+const dgram = require('dgram');
+const assert = require('assert');
+const BaseClient = require('./BaseClient');
+const RtpEngineError = require('./error');
+const { COMMANDS } = require('./constants');
+const debug = require('debug')('rtpengine:Client');
+
+class Client extends BaseClient {
+
+  constructor(...args) {
+    super({type: 'udp', ...args});
+
+    this.socket = dgram.createSocket('udp4');
+    if (typeof args[args.length - 1] === 'function') {
+      this.addListener('listening', args.pop());
+    }
+
+    this.socket.on('message', this._onMessage.bind(this));
+    this.socket.on('error', this._onError.bind(this));
+    this.socket.on('listening', this._onListening.bind(this));
+
+    if (typeof args[0] === 'object') {
+      const localPort = args[0].localPort || 0;
+      if (!args[0].localAddress) {
+        this.socket.bind(localPort);
+      }
+      else {
+        this.socket.bind(localPort, args[0].localAddress);
+      }
+      if (args[0].timeout) this.timeout = args[0].timeout;
+      this.rejectOnError = args[0].rejectOnError;
+    }
+    else {
+      switch (args.length) {
+        case 0 :
+          this.socket.bind();
+          break;
+        case 1:
+          this.socket.bind(args[0]);
+          break;
+        case 2:
+          this.socket.bind(args[0], args[1]);
+          break;
+        default:
+          throw new RtpEngineError('invalid number of arguments to rtpengine-client constructor');
+      }
+    }
+
+    this.messages = new Map();
+    if (this.timeout) {
+      this.timers = new Map();
+    }
+  }
+
+  _onListening() {
+    const r = process.env.UDP_RECV_BUFSIZE || process.env.UDP_BUFSIZE;
+    const s = process.env.UDP_SEND_BUFSIZE || process.env.UDP_BUFSIZE;
+
+    try {
+      if (r) {
+        const recvBufSize = parseInt(r, 10);
+        if (recvBufSize > 0) {
+          this.socket.setRecvBufferSize(recvBufSize);
+        }
+      }
+      if (s) {
+        const sendBufSize = parseInt(s, 10);
+        if (sendBufSize > 0) {
+          this.socket.setSendBufferSize(sendBufSize);
+        }
+      }
+    } catch (err) {
+      console.log({err, r, s}, 'rtpengine-client: error setting udp buffer size');
+    }
+    super._onListening();
+  }
+}
+
+// add commands
+COMMANDS.forEach((method) => {
+  Client.prototype[method] = function(...args) {
+    assert.ok(args.length, `must supply destination port and address in call to Client#${method}`);
+
+    debug(args);
+    let idx = 1;
+    if (typeof args[0] === 'object') {
+      assert(typeof args[0].port === 'number', `must supply 'port' in call to Client#${method}`);
+      assert(typeof args[0].host === 'string', `must supply 'host' in call to Client#${method}`);
+      this.remotePort = args[0].port;
+      this.remoteHost = args[0].host;
+
+    }
+    else {
+      assert(typeof args[0] === 'number', `must supply port in call to Client#${method}`);
+      assert(typeof args[1] === 'string', `must supply host in call to Client#${method}`);
+      this.remotePort = args[0];
+      this.remoteHost = args[1];
+      idx = 2;
+    }
+
+    const a = [method].concat(args.slice(idx));
+    debug(a);
+    return this.send_internal(...[method].concat(args.slice(idx)));
+  };
+});
+
+module.exports = Client;

package/lib/TcpClient.js

@@ -0,0 +1,71 @@
+const BaseClient = require('./BaseClient');
+const net = require('net');
+const RtpEngineError = require('./error');
+const { COMMANDS } = require('./constants');
+const debug = require('debug')('rtpengine:baseClient');
+
+
+const MAX_BUFLEN = 16384;
+
+class TcpClient extends BaseClient {
+
+  constructor(...args) {
+    super({type: 'tcp', ...args});
+
+    if (typeof args[0] === 'object') {
+      if (args[0].timeout) this.timeout = args[0].timeout;
+      this.hostport = args[0].hostport;
+    }
+    else {
+      this.hostport = args[0];
+    }
+
+    const arr = /^(.*):(\d+)$/.exec(this.hostport);
+    if (!arr) throw new RtpEngineError(`rtpengine-client: invalid hostport for tcp connection: ${this.hostport}`);
+
+    this.host = arr[1];
+    this.port = arr[2];
+
+    const socket = this.socket = new net.Socket();
+    socket.setKeepAlive(true) ;
+
+    socket.on('connect', () => {
+      this.connected = true;
+      this.emit('connect');
+    });
+    socket.on('data', this._onData.bind(this));
+    socket.on('end', this._onEnd.bind(this));
+    socket.on('ready', this._onListening.bind(this));
+    socket.on('error', this._onError.bind(this));
+
+    debug(`connecting tcp client to ${this.host}:${this.port}`);
+    socket.connect(this.port, this.host);
+  }
+
+  _onData(msg) {
+    let res;
+    this.buffer = !this.buffer ? msg : Buffer.concat([this.buffer, msg]);
+    if (this.buffer.length > MAX_BUFLEN) {
+      this.emit('error', new RtpEngineError(`malformed/unexpected message format ${this.buffer.slice(0, 64)}...`));
+      this.buffer = null;
+      return;
+    }
+    try {
+      console.log(`received ${msg.length} bytes`);
+      res = BaseClient.decodeMessage(this.buffer);
+    } catch {
+      return;
+    }
+    this._onParsedMessage(res);
+    this.buffer = null;
+  }
+}
+
+// add commands
+COMMANDS.forEach((method) => {
+  TcpClient.prototype[method] = function(...args) {
+    return this.send_internal(...[method].concat(args));
+  };
+});
+
+module.exports = TcpClient;

package/lib/WsClient.js

@@ -0,0 +1,47 @@
+const WebSocket = require('ws');
+const BaseClient = require('./BaseClient');
+const { COMMANDS } = require('./constants');
+
+class WsClient extends BaseClient {
+
+  constructor(...args) {
+    super({type: 'websocket', ...args});
+    this.connectionCount = 0;
+
+    if (typeof args[0] === 'object') {
+      if (args[0].timeout) this.timeout = args[0].timeout;
+      this.url = args[0].url;
+    }
+    else {
+      this.url = args[0];
+    }
+    this._connect(this.url, 'ng.rtpengine.com');
+  }
+
+  _connect(opts, protocol) {
+    this.socket =  new WebSocket(opts, protocol);
+    this._attachHandlers(this.socket, opts, protocol);
+  }
+
+  _attachHandlers(socket, opts, protocol) {
+    socket.on('message', this._onMessage.bind(this));
+    socket.on('error', this._onError.bind(this));
+    socket.on('open', () => {
+      if (this.connectionCount++ === 0) this._onListening();
+      else this.emit('reconnected');
+    });
+    socket.on('close', () => {
+      this.emit('close');
+      setTimeout(this._connect.bind(this, opts, protocol), 2000);
+    });
+  }
+}
+
+// add commands
+COMMANDS.forEach((method) => {
+  WsClient.prototype[method] = function(...args) {
+    return this.send_internal(...[method].concat(args));
+  };
+});
+
+module.exports = WsClient;

package/lib/constants.js

@@ -0,0 +1,35 @@
+const _commands = {
+  'answer': 'answer',
+  'delete': 'delete',
+  'list': 'list',
+  'offer': 'offer',
+  'ping': 'ping',
+  'query': 'query',
+  'startRecording': 'start recording',
+  'stopRecording': 'stop recording',
+  'blockDTMF': 'block DTMF',
+  'unblockDTMF': 'unblock DTMF',
+  'playDTMF': 'play DTMF',
+  'blockMedia': 'block media',
+  'unblockMedia': 'unblock media',
+  'silenceMedia': 'silence media',
+  'unsilenceMedia': 'unsilence media',
+  'startForwarding': 'start forwarding',
+  'stopForwarding': 'stop forwarding',
+  'playMedia': 'play media',
+  'stopMedia': 'stop media',
+  'statistics': 'statistics',
+  'publish': 'publish',
+  'subscribeRequest': 'subscribe request',
+  'subscribeAnswer': 'subscribe answer',
+  'unsubscribe': 'unsubscribe'
+};
+
+const COMMANDS = Object.keys(_commands);
+
+const getRtpEngineNameForCommand = (name) => _commands[name];
+
+module.exports = {
+  COMMANDS,
+  getRtpEngineNameForCommand
+};

package/lib/error.js

@@ -0,0 +1,8 @@
+class RtpEngineError extends Error {
+  constructor(...args) {
+    super(...args);
+    Error.captureStackTrace(this, RtpEngineError);
+  }
+}
+
+module.exports = RtpEngineError;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@audc/rtpengine-client",
+  "version": "0.5.0",
+  "description": "node client for rtpengine daemon",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test/",
+    "coverage": "c8 --reporter html npm run test",
+    "lint": "eslint"
+  },
+  "author": "Dave Horton",
+  "license": "MIT",
+  "files": [
+    "index.js",
+    "lib/"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.18.0",
+    "@types/bencode": "^2.0.4",
+    "@types/tape": "^5.8.1",
+    "c8": "^10.1.3",
+    "debug": "^4.4.0",
+    "eslint": "^9.18.0",
+    "eslint-plugin-promise": "^7.2.1",
+    "globals": "^15.14.0",
+    "sinon": "^19.0.2",
+    "tape": "^5.9.0"
+  },
+  "dependencies": {
+    "bencode": "^2.0.3",
+    "uuid-random": "^1.3.2",
+    "ws": "^8.18.0"
+  },
+  "keywords": [
+    "rtpengine"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/davehorton/rtpengine-client"
+  }
+}