0.7.2 version

* JAMBONES_NETWORK_CIDR not needed for K8S

* fix bug setting fsUUID in K8S scenario

* bugfix: dial music was not stopped when a dial verb times out (#56)

.github/workflows/docker-publish.yml

@@ -0,0 +1,51 @@
+name: Docker
+
+on:
+  push:
+    # Publish `main` as Docker `latest` image.
+    branches:
+      - main
+
+    # Publish `v1.2.3` tags as releases.
+    tags:
+      - v*
+
+env:
+  IMAGE_NAME: feature-server
+
+jobs:
+  push:
+
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push'
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Build image
+        run: docker build . --file Dockerfile --tag $IMAGE_NAME
+
+      - name: Log into registry
+        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
+
+      - name: Push image
+        run: |
+          IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME
+
+          # Change all uppercase to lowercase
+          IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]')
+
+          # Strip git ref prefix from version
+          VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,')
+
+          # Strip "v" prefix from tag name
+          [[ "${{ github.ref }}" == "refs/tags/"* ]] && VERSION=$(echo $VERSION | sed -e 's/^v//')
+
+          # Use Docker `latest` tag convention
+          [ "$VERSION" == "main" ] && VERSION=latest
+
+          echo IMAGE_ID=$IMAGE_ID
+          echo VERSION=$VERSION
+
+          docker tag $IMAGE_NAME $IMAGE_ID:$VERSION
+          docker push $IMAGE_ID:$VERSION

Dockerfile

@@ -1,16 +1,10 @@
-FROM node:alpine as builder
-RUN apk update && apk add --no-cache python make g++
+FROM node:17.4-slim
 WORKDIR /opt/app/
 COPY package.json ./
 RUN npm install
 RUN npm prune
-
-FROM node:alpine as app
-WORKDIR /opt/app
 COPY . /opt/app
-COPY --from=builder /opt/app/node_modules ./node_modules
-
 ARG NODE_ENV
 ENV NODE_ENV $NODE_ENV
 
-CMD [ "npm", "start" ]
+CMD [ "npm", "start" ]

app.js

@@ -7,7 +7,7 @@ assert.ok(process.env.DRACHTIO_PORT || process.env.DRACHTIO_HOST, 'missing DRACH
 assert.ok(process.env.DRACHTIO_SECRET, 'missing DRACHTIO_SECRET env var');
 assert.ok(process.env.JAMBONES_FREESWITCH, 'missing JAMBONES_FREESWITCH env var');
 assert.ok(process.env.JAMBONES_REDIS_HOST, 'missing JAMBONES_REDIS_HOST env var');
-assert.ok(process.env.JAMBONES_NETWORK_CIDR, 'missing JAMBONES_SUBNET env var');
+assert.ok(process.env.JAMBONES_NETWORK_CIDR || process.env.K8S, 'missing JAMBONES_SUBNET env var');
 
 const Srf = require('drachtio-srf');
 const srf = new Srf();
@@ -17,7 +17,7 @@ const opts = {
   level: process.env.JAMBONES_LOGLEVEL || 'info'
 };
 const logger = require('pino')(opts);
-const {LifeCycleEvents} = require('./lib/utils/constants');
+const {LifeCycleEvents, FS_UUID_SET_NAME} = require('./lib/utils/constants');
 const installSrfLocals = require('./lib/utils/install-srf-locals');
 installSrfLocals(srf, logger);
 
@@ -92,6 +92,10 @@ sessionTracker.on('idle', () => {
   }
 });
 
+const getCount = () => sessionTracker.count;
+const healthCheck = require('@jambonz/http-health-check');
+healthCheck({app, logger, path: '/', fn: getCount});
+
 setInterval(() => {
   srf.locals.stats.gauge('fs.sip.calls.count', sessionTracker.count);
 }, 5000);
@@ -105,4 +109,16 @@ const disconnect = () => {
   });
 };
 
+process.on('SIGUSR2', handle);
+process.on('SIGTERM', handle);
+
+function handle(signal) {
+  const {removeFromSet} = srf.locals.dbHelpers;
+  const setName = `${(process.env.JAMBONES_CLUSTER_ID || 'default')}:active-fs`;
+  logger.info(`got signal ${signal}, removing ${srf.locals.localSipAddress} from set ${setName}`);
+  removeFromSet(setName, srf.locals.localSipAddress);
+  removeFromSet(FS_UUID_SET_NAME, srf.locals.fsUUID);
+  srf.locals.disabled = true;
+}
+
 module.exports = {srf, logger, disconnect};

bin/k8s-pre-stop-hook.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+const bent = require('bent');
+const getJSON = bent('json');
+const PORT = process.env.HTTP_PORT || 3000;
+
+const sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+(async function() {
+
+  try {
+    do {
+      const obj = await getJSON(`http://127.0.0.1:${PORT}/`);
+      const {calls} = obj;
+      if (calls === 0) {
+        console.log('no calls on the system, we can exit');
+        process.exit(0);
+      }
+      else {
+        console.log(`waiting for ${calls} to exit..`);
+      }
+      await sleep(10000);
+    } while (1);
+  } catch (err) {
+    console.error(err, 'Error querying health endpoint');
+    process.exit(-1);
+  }
+})();

lib/http-routes/api/index.js

@@ -9,8 +9,4 @@ api.use('/enqueue', require('./enqueue'));
 api.use('/messaging', require('./messaging'));            // inbound SMS
 api.use('/createMessage', require('./create-message'));   // outbound SMS (REST)
 
-// health checks
-api.get('/', (req, res) => res.sendStatus(200));
-api.get('/health', (req, res) => res.sendStatus(200));
-
 module.exports = api;

lib/http-routes/index.js

@@ -1,16 +1,23 @@
 const express = require('express');
 const api = require('./api');
 const routes = express.Router();
+const sessionTracker = require('../session/session-tracker');
+
+const readiness = (req, res) => {
+  const logger = req.app.locals.logger;
+  const {count} = sessionTracker;
+  const {srf} = require('../..');
+  const {getFreeswitch} = srf.locals;
+  if (getFreeswitch()) {
+    return res.status(200).json({calls: count});
+  }
+  logger.info('responding to /health check with failure as freeswitch is not up');
+  res.sendStatus(480);
+};
 
 routes.use('/v1', api);
 
-// health checks
-routes.get('/', (req, res) => {
-  res.sendStatus(200);
-});
-
-routes.get('/health', (req, res) => {
-  res.sendStatus(200);
-});
+// health check
+routes.get('/health', readiness);
 
 module.exports = routes;

lib/middleware.js

@@ -8,7 +8,13 @@ const normalizeJambones = require('./utils/normalize-jambones');
 const dbUtils = require('./utils/db-utils');
 
 module.exports = function(srf, logger) {
-  const {lookupAppByPhoneNumber, lookupAppBySid, lookupAppByRealm, lookupAppByTeamsTenant}  = srf.locals.dbHelpers;
+  const {
+    lookupAppByPhoneNumber,
+    lookupAppByRegex,
+    lookupAppBySid,
+    lookupAppByRealm,
+    lookupAppByTeamsTenant
+  }  = srf.locals.dbHelpers;
   const {lookupAccountDetails} = dbUtils(logger, srf);
   function initLocals(req, res, next) {
     const callSid = req.has('X-Retain-Call-Sid') ? req.get('X-Retain-Call-Sid') : uuidv4();
@@ -112,7 +118,15 @@ module.exports = function(srf, logger) {
             logger.error(err, `Error retrieving transferred call app for ${arr[1]}`);
           }
         }
-        else app = await lookupAppByPhoneNumber(req.locals.calledNumber);
+        else {
+          const voip_carrier_sid = req.get('X-Voip-Carrier-Sid');
+          app = await lookupAppByPhoneNumber(req.locals.calledNumber, voip_carrier_sid);
+
+          if (!app) {
+            /* lookup by call_routes.regex */
+            app = await lookupAppByRegex(req.locals.calledNumber, account_sid);
+          }
+        }
       }
 
       if (!app || !app.call_hook || !app.call_hook.url) {
@@ -137,7 +151,9 @@ module.exports = function(srf, logger) {
       const obj = Object.assign({}, app);
       delete obj.requestor;
       delete obj.notifier;
-      logger.info({app: obj}, `retrieved application for incoming call to ${req.locals.calledNumber}`);
+      // eslint-disable-next-line no-unused-vars
+      const {call_hook, call_status_hook, ...appInfo} = obj;  // mask sensitive data like user/pass on webhook
+      logger.info({app: appInfo}, `retrieved application for incoming call to ${req.locals.calledNumber}`);
       req.locals.callInfo = new CallInfo({req, app, direction: CallDirection.Inbound});
       next();
     } catch (err) {

lib/session/call-session.js

@@ -257,6 +257,19 @@ class CallSession extends Emitter {
             region: process.env.AWS_REGION || credential.aws_region
           };
         }
+        else if ('microsoft' === vendor) {
+          return {
+            speech_credential_sid: credential.speech_credential_sid,
+            api_key: credential.api_key,
+            region: credential.region
+          };
+        }
+        else if ('wellsaid' === vendor) {
+          return {
+            speech_credential_sid: credential.speech_credential_sid,
+            api_key: credential.api_key
+          };
+        }
       }
       else {
         writeAlerts({
@@ -625,7 +638,7 @@ class CallSession extends Emitter {
     try {
       if (!this.ms) this.ms = this.getMS();
       const ep = await this.ms.createEndpoint({remoteSdp: this.req.body});
-      ep.cs = this;
+      //ep.cs = this;
       this.ep = ep;
       ep.set({
         hangup_after_bridge: false,
@@ -709,14 +722,12 @@ class CallSession extends Emitter {
   /**
    * Hang up the call and free the media endpoint
    */
-  async _clearResources() {
+  _clearResources() {
     for (const resource of [this.dlg, this.ep]) {
-      try {
-        if (resource && resource.connected) await resource.destroy();
-      } catch (err) {
-        this.logger.error(err, 'CallSession:_clearResources error');
-      }
+      if (resource && resource.connected) resource.destroy();
     }
+    this.dlg = null;
+    this.ep = null;
 
     // remove any temporary tts files that were created (audio is still cached in redis)
     for (const path of this.tmpFiles) {
@@ -775,9 +786,19 @@ class CallSession extends Emitter {
 
   async _onReinvite(req, res) {
     try {
-      const newSdp = await this.ep.modify(req.body);
-      res.send(200, {body: newSdp});
-      this.logger.info({offer: req.body, answer: newSdp}, 'handling reINVITE');
+      if (this.ep) {
+        const newSdp = await this.ep.modify(req.body);
+        res.send(200, {body: newSdp});
+        this.logger.info({offer: req.body, answer: newSdp}, 'handling reINVITE');
+      }
+      else if (this.currentTask && this.currentTask.name === TaskName.Dial) {
+        this.logger.info('handling reINVITE after media has been released');
+        await this.currentTask.handleReinviteAfterMediaReleased(req, res);
+      }
+      else {
+        this.logger.info('got reINVITE but no endpoint and media has not been released');
+        res.send(488);
+      }
     } catch (err) {
       this.logger.error(err, 'Error handling reinvite');
     }
@@ -948,6 +969,13 @@ class CallSession extends Emitter {
     });
   }
 
+  async handleReinviteAfterMediaReleased(req, res) {
+    assert(this.dlg && this.dlg.connected && !this.ep);
+    const sdp = await this.dlg.modify(req.body);
+    this.logger.info({sdp}, 'CallSession:handleReinviteAfterMediaReleased - reinvite to A leg returned sdp');
+    res.send(200, {body: sdp});
+  }
+
   /**
    * Called any time call status changes.  This method both invokes the
    * call_status_hook callback as well as updates the realtime database

lib/session/inbound-call-session.js

@@ -21,15 +21,17 @@ class InboundCallSession extends CallSession {
     this.req = req;
     this.res = res;
 
-    req.on('cancel', () => {
-      this._notifyCallStatusChange({callStatus: CallStatus.NoAnswer, sipStatus: 487});
-      this._callReleased();
-    });
+    req.once('cancel', this._onCancel.bind(this));
 
     this.on('callStatusChange', this._notifyCallStatusChange.bind(this));
     this._notifyCallStatusChange({callStatus: CallStatus.Trying, sipStatus: 100});
   }
 
+  _onCancel() {
+    this._notifyCallStatusChange({callStatus: CallStatus.NoAnswer, sipStatus: 487});
+    this._callReleased();
+  }
+
   _onTasksDone() {
     if (!this.res.finalResponseSent) {
       if (this._mediaServerFailure) {
@@ -45,6 +47,7 @@ class InboundCallSession extends CallSession {
         this.res.send(603);
       }
     }
+    this.req.removeAllListeners('cancel');
   }
 
   /**
@@ -56,6 +59,7 @@ class InboundCallSession extends CallSession {
     this.emit('callStatusChange', {callStatus: CallStatus.Completed, duration});
     this.logger.debug('InboundCallSession: caller hung up');
     this._callReleased();
+    this.req.removeAllListeners('cancel');
   }
 }
 

lib/tasks/cognigy.js

@@ -0,0 +1,248 @@
+const Task = require('./task');
+const {TaskName, TaskPreconditions} = require('../utils/constants');
+const makeTask = require('./make_task');
+const { SocketClient } = require('@cognigy/socket-client');
+
+const parseGallery = (obj = {}) => {
+  const {_default} = obj;
+  if (_default) {
+    const {_gallery} = _default;
+    if (_gallery) return _gallery.fallbackText;
+  }
+};
+
+const parseQuickReplies = (obj) => {
+  const {_default} = obj;
+  if (_default) {
+    const {_quickReplies} = _default;
+    if (_quickReplies) return _quickReplies.text || _quickReplies.fallbackText;
+  }
+};
+
+const parseBotText = (evt) => {
+  const {text, data} = evt;
+  if (text) return text;
+
+  switch (data?.type) {
+    case 'quickReplies':
+      return parseQuickReplies(data?._cognigy);
+    case 'gallery':
+      return parseGallery(data?._cognigy);
+    default:
+      break;
+  }
+};
+
+class Cognigy extends Task {
+  constructor(logger, opts) {
+    super(logger, opts);
+    this.preconditions = TaskPreconditions.Endpoint;
+
+    this.url = this.data.url;
+    this.token = this.data.token;
+    this.prompt = this.data.prompt;
+    this.eventHook = this.data?.eventHook;
+    this.actionHook = this.data?.actionHook;
+    this.data = this.data.data || {};
+    this.prompts = [];
+  }
+
+  get name() { return TaskName.Cognigy; }
+
+  get hasReportedFinalAction() {
+    return this.reportedFinalAction || this.isReplacingApplication;
+  }
+
+  async exec(cs, ep) {
+    await super.exec(cs);
+
+    this.ep = ep;
+    try {
+      /* set event handlers and start transcribing */
+      this.on('transcription', this._onTranscription.bind(this, cs, ep));
+      this.on('error', this._onError.bind(this, cs, ep));
+
+      this.transcribeTask = this._makeTranscribeTask();
+      this.transcribeTask.exec(cs, ep, this)
+        .catch((err) => {
+          this.logger.info({err}, 'Cognigy transcribe task returned error');
+          this.notifyTaskDone();
+        });
+      if (this.prompt) {
+        this.sayTask = this._makeSayTask(this.prompt);
+        this.sayTask.exec(cs, ep, this)
+          .catch((err) => {
+            this.logger.info({err}, 'Cognigy say task returned error');
+            this.notifyTaskDone();
+          });
+      }
+
+      /* connect to the bot and send initial data */
+      this.client = new SocketClient(
+        this.url,
+        this.token,
+        {
+          sessionId: cs.callSid,
+          channel: 'jambonz',
+          forceWebsockets: true,
+          reconnection: true,
+          settings: {
+            enableTypingIndicator: false
+          }
+        }
+      );
+      this.client.on('output', this._onBotUtterance.bind(this, cs, ep));
+      this.client.on('typingStatus', this._onBotTypingStatus.bind(this, cs, ep));
+      this.client.on('error', this._onBotError.bind(this, cs, ep));
+      this.client.on('finalPing', this._onBotFinalPing.bind(this, cs, ep));
+      await this.client.connect();
+      this.client.sendMessage('', {...this.data, ...cs.callInfo});
+
+      await this.awaitTaskDone();
+    } catch (err) {
+      this.logger.error({err}, 'Cognigy error');
+      throw err;
+    }
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+    this.logger.debug('Cognigy:kill');
+
+    this.removeAllListeners();
+    this.transcribeTask && this.transcribeTask.kill();
+
+    this.client.removeAllListeners();
+    if (this.client && this.client.connected) this.client.disconnect();
+
+    if (!this.hasReportedFinalAction) {
+      this.reportedFinalAction = true;
+      this.performAction({cognigyResult: 'caller hungup'})
+        .catch((err) => this.logger.info({err}, 'cognigy - error w/ action webook'));
+    }
+
+    if (this.ep.connected) {
+      await this.ep.api('uuid_break', this.ep.uuid).catch((err) => this.logger.info(err, 'Error killing audio'));
+    }
+    this.notifyTaskDone();
+  }
+
+  _makeTranscribeTask() {
+    const opts = {
+      recognizer: this.data.recognizer || {
+        vendor: 'default',
+        language: 'default',
+        outputFormat: 'detailed'
+      }
+    };
+    this.logger.debug({opts}, 'constructing a nested transcribe object');
+    const transcribe = makeTask(this.logger, {transcribe: opts}, this);
+    return transcribe;
+  }
+
+  _makeSayTask(text) {
+    const opts = {
+      text,
+      synthesizer: this.data.synthesizer ||
+      {
+        vendor: 'default',
+        language: 'default',
+        voice: 'default'
+      }
+    };
+    this.logger.debug({opts}, 'constructing a nested say object');
+    const say = makeTask(this.logger, {say: opts}, this);
+    return say;
+  }
+
+  async _onBotError(cs, ep, evt) {
+    this.logger.info({evt}, 'Cognigy:_onBotError');
+    this.performAction({cognigyResult: 'botError', message: evt.message });
+    this.reportedFinalAction = true;
+    this.notifyTaskDone();
+  }
+
+  async _onBotTypingStatus(cs, ep, evt) {
+    this.logger.info({evt}, 'Cognigy:_onBotTypingStatus');
+  }
+  async _onBotFinalPing(cs, ep) {
+    this.logger.info('Cognigy:_onBotFinalPing');
+    if (this.prompts.length) {
+      const text = this.prompts.join('.');
+      this.prompts = [];
+      if (text && !this.killed) {
+        this.sayTask = this._makeSayTask(text);
+        this.sayTask.exec(cs, ep, this)
+          .catch((err) => {
+            this.logger.info({err}, 'Cognigy say task returned error');
+            this.notifyTaskDone();
+          });
+      }
+    }
+  }
+
+  async _onBotUtterance(cs, ep, evt) {
+    this.logger.debug({evt}, 'Cognigy:_onBotUtterance');
+
+    if (this.eventHook) {
+      this.performHook(cs, this.eventHook, {event: 'botMessage', message: evt})
+        .then((redirected) => {
+          if (redirected) {
+            this.logger.info('Cognigy_onTranscription: event handler for bot message redirected us to new webhook');
+            this.reportedFinalAction = true;
+            this.performAction({cognigyResult: 'redirect'}, false);
+          }
+          return;
+        })
+        .catch(({err}) => {
+          this.logger.info({err}, 'Cognigy_onTranscription: error sending event hook');
+        });
+    }
+    const text = parseBotText(evt);
+    this.prompts.push(text);
+  }
+
+  async _onTranscription(cs, ep, evt) {
+    this.logger.debug({evt}, `Cognigy: got transcription for callSid ${cs.callSid}`);
+    const utterance = evt.alternatives[0].transcript;
+
+    if (this.eventHook) {
+      this.performHook(cs, this.eventHook, {event: 'userMessage', message: utterance})
+        .then((redirected) => {
+          if (redirected) {
+            this.logger.info('Cognigy_onTranscription: event handler for user message redirected us to new webhook');
+            this.reportedFinalAction = true;
+            this.performAction({cognigyResult: 'redirect'}, false);
+            if (this.transcribeTask) this.transcribeTask.kill(cs);
+          }
+          return;
+        })
+        .catch(({err}) => {
+          this.logger.info({err}, 'Cognigy_onTranscription: error sending event hook');
+        });
+    }
+
+    /* send the user utterance to the bot */
+    try {
+      if (this.client && this.client.connected) {
+        this.client.sendMessage(utterance);
+      }
+      else {
+        this.logger.info('Cognigy_onTranscription - not sending user utterance as bot is disconnected');
+      }
+    } catch (err) {
+      this.logger.error({err}, 'Cognigy_onTranscription: Error sending user utterance to Cognigy - ending task');
+      this.performAction({cognigyResult: 'socketError'});
+      this.reportedFinalAction = true;
+      this.notifyTaskDone();
+    }
+  }
+  _onError(cs, ep, err) {
+    this.logger.debug({err}, 'Cognigy: got error');
+    if (!this.hasReportedFinalAction) this.performAction({cognigyResult: 'error', err});
+    this.reportedFinalAction = true;
+    this.notifyTaskDone();
+  }
+}
+
+module.exports = Cognigy;

lib/tasks/conference.js

@@ -10,6 +10,7 @@ const WAIT = 'wait';
 const JOIN = 'join';
 const START = 'start';
 
+
 function confNoMatch(str) {
   return str.match(/^No active conferences/) || str.match(/Conference.*not found/);
 }
@@ -49,7 +50,7 @@ class Conference extends Task {
       'beep', 'startConferenceOnEnter', 'endConferenceOnExit', 'joinMuted',
       'maxParticipants', 'waitHook', 'statusHook', 'endHook', 'enterHook'
     ].forEach((attr) => this[attr] = this.data[attr]);
-
+    this.record = this.data.record || {};
     this.statusEvents = [];
     if (this.statusHook) {
       ['start', 'end', 'join', 'leave', 'start-talking', 'stop-talking'].forEach((e) => {
@@ -68,6 +69,9 @@ class Conference extends Task {
 
   get name() { return TaskName.Conference; }
 
+  get shouldRecord() { return this.record.path; }
+  get isRecording() { return this.recordingInProgress; }
+
   async exec(cs, ep) {
     await super.exec(cs);
     this.ep = ep;
@@ -346,6 +350,16 @@ class Conference extends Task {
       if (response.body && /\d+/.test(response.body)) this.participantCount = parseInt(response.body);
       this._notifyConferenceEvent(cs, 'join');
 
+      // start recording if requested and we just started the conference
+      if (startConf && this.shouldRecord) {
+        this.logger.info(`recording conference to ${this.record.path}`);
+        try {
+          await this.ep.api(`conference ${this.confName} record ${this.record.path}`);
+        } catch (err) {
+          this.logger.info({err}, 'Conference:_joinConference - failed to start recording');
+        }
+      }
+
       // listen for conference events
       this.ep.filter('Conference-Unique-ID', this.confUuid);
       this.ep.conn.on('esl::event::CUSTOM::*', this.__onConferenceEvent.bind(this, cs)) ;

lib/tasks/dial.js

@@ -12,6 +12,7 @@ const assert = require('assert');
 const placeCall = require('../utils/place-outdial');
 const sessionTracker = require('../session/session-tracker');
 const DtmfCollector = require('../utils/dtmf-collector');
+const dbUtils = require('../utils/db-utils');
 const debug = require('debug')('jambonz:feature-server');
 
 function parseDtmfOptions(logger, dtmfCapture) {
@@ -160,7 +161,19 @@ class TaskDial extends Task {
 
   async kill(cs, reason) {
     super.kill(cs);
+    if (this.dialMusic && this.epOther) {
+      this.epOther.api('uuid_break', this.epOther.uuid)
+        .catch((err) => this.logger.info(err, 'Error killing dialMusic'));
+    }
     this.killReason = reason || KillReason.Hangup;
+    if (this.timerMaxCallDuration) {
+      clearTimeout(this.timerMaxCallDuration);
+      this.timerMaxCallDuration = null;
+    }
+    if (this.timerRing) {
+      clearTimeout(this.timerRing);
+      this.timerRing = null;
+    }
     this._removeDtmfDetection(cs.dlg);
     this._removeDtmfDetection(this.dlg);
     this._killOutdials();
@@ -171,7 +184,6 @@ class TaskDial extends Task {
     if (this.callSid) sessionTracker.remove(this.callSid);
     if (this.listenTask) await this.listenTask.kill(cs);
     if (this.transcribeTask) await this.transcribeTask.kill(cs);
-    if (this.timerMaxCallDuration) clearTimeout(this.timerMaxCallDuration);
     this.notifyTaskDone();
   }
 
@@ -227,10 +239,19 @@ class TaskDial extends Task {
     }
   }
 
+  _removeHandlers(sd) {
+    sd.removeAllListeners('accept');
+    sd.removeAllListeners('decline');
+    sd.removeAllListeners('adulting');
+    sd.removeAllListeners('callStatusChange');
+    sd.removeAllListeners('callCreateFail');
+  }
+
   _killOutdials() {
     for (const [callSid, sd] of Array.from(this.dials)) {
       this.logger.debug(`Dial:_killOutdials killing callSid ${callSid}`);
       sd.kill().catch((err) => this.logger.info(err, `Dial:_killOutdials Error killing ${callSid}`));
+      this._removeHandlers(sd);
     }
     this.dials.clear();
   }
@@ -291,6 +312,7 @@ class TaskDial extends Task {
     const {req, srf} = cs;
     const {getSBC} = srf.locals;
     const {lookupTeamsByAccount, lookupAccountBySid} = srf.locals.dbHelpers;
+    const {lookupCarrier} = dbUtils(this.logger, cs.srf);
     const sbcAddress = this.proxy || getSBC();
     const teamsInfo = {};
     let fqdn;
@@ -314,8 +336,9 @@ class TaskDial extends Task {
     }
 
     const ms = await cs.getMS();
-    const timerRing = setTimeout(() => {
+    this.timerRing = setTimeout(() => {
       this.logger.info(`Dial:_attemptCall: ring no answer timer ${this.timeout}s exceeded`);
+      this.timerRing = null;
       this._killOutdials();
     }, this.timeout * 1000);
 
@@ -336,6 +359,13 @@ class TaskDial extends Task {
             this.logger.error({err}, 'Error looking up account by sid');
           }
         }
+        if (t.type === 'phone' && t.trunk) {
+          const voip_carrier_sid = await lookupCarrier(cs.accountSid, t.trunk);
+          this.logger.info(`Dial:_attemptCalls: selected ${voip_carrier_sid} for requested carrier: ${t.trunk})`);
+          if (voip_carrier_sid) {
+            opts.headers['X-Requested-Carrier-Sid'] = voip_carrier_sid;
+          }
+        }
         const sd = placeCall({
           logger: this.logger,
           application: cs.application,
@@ -375,7 +405,8 @@ class TaskDial extends Task {
                 break;
               case CallStatus.InProgress:
                 this.logger.debug('Dial:_attemptCall -- call was answered');
-                clearTimeout(timerRing);
+                clearTimeout(this.timerRing);
+                this.timerRing = null;
                 break;
               case CallStatus.Failed:
               case CallStatus.Busy:
@@ -383,7 +414,8 @@ class TaskDial extends Task {
                 this.dials.delete(sd.callSid);
                 if (this.dials.size === 0 && !this.sd) {
                   this.logger.debug('Dial:_attemptCalls - all calls failed after call failure, ending task');
-                  clearTimeout(timerRing);
+                  clearTimeout(this.timerRing);
+                  this.timerRing = null;
                   this.kill(cs);
                 }
                 break;
@@ -405,6 +437,13 @@ class TaskDial extends Task {
               this.kill(cs);
             }
           })
+          .on('reinvite', (req, res) => {
+            try {
+              cs.handleReinviteAfterMediaReleased(req, res);
+            } catch (err) {
+              this.logger.error(err, 'Error in dial einvite from B leg');
+            }
+          })
           .once('adulting', () => {
             /* child call just adulted and got its own session */
             this.logger.info('Dial:on_adulting: detaching child call leg');
@@ -436,6 +475,12 @@ class TaskDial extends Task {
     this._killOutdials();       // NB: order is important
   }
 
+  _onMaxCallDuration(cs) {
+    this.logger.info(`Dial:_onMaxCallDuration tearing down call as it has reached ${this.timeLimit}s`);
+    this.ep && this.ep.unbridge();
+    this.kill(cs);
+  }
+
   /**
    * We now have a call leg produced by the Dial action, so
    * - hangup any simrings in progress
@@ -456,11 +501,7 @@ class TaskDial extends Task {
       await cs.propagateAnswer();
     }
     if (this.timeLimit) {
-      this.timerMaxCallDuration = setTimeout(() => {
-        this.logger.info(`Dial:_selectSingleDial tearing down call as it has reached ${this.timeLimit}s`);
-        this.ep.unbridge();
-        this.kill(cs);
-      }, this.timeLimit * 1000);
+      this.timerMaxCallDuration = setTimeout(this._onMaxCallDuration.bind(this, cs), this.timeLimit * 1000);
     }
     sessionTracker.add(this.callSid, cs);
     this.dlg.on('destroy', () => {
@@ -468,7 +509,10 @@ class TaskDial extends Task {
       if (this.dlg) {
         this.logger.debug('Dial:_selectSingleDial called party hungup, ending dial operation');
         sessionTracker.remove(this.callSid);
-        if (this.timerMaxCallDuration) clearTimeout(this.timerMaxCallDuration);
+        if (this.timerMaxCallDuration) {
+          clearTimeout(this.timerMaxCallDuration);
+          this.timerMaxCallDuration = null;
+        }
         this.ep && this.ep.unbridge();
         this.kill(cs);
       }
@@ -508,10 +552,9 @@ class TaskDial extends Task {
     assert(cs.ep && sd.ep);
 
     try {
-      this.logger.info('Dial:_releaseMedia - releasing media from freewitch');
       const aLegSdp = cs.ep.remote.sdp;
-      const bLegSdp = sd.ep.remote.sdp;
-      await Promise.all[sd.releaseMediaToSBC(aLegSdp), cs.releaseMediaToSBC(bLegSdp)];
+      const bLegSdp = sd.dlg.remote.sdp;
+      await Promise.all[sd.releaseMediaToSBC(aLegSdp, cs.ep.local.sdp), cs.releaseMediaToSBC(bLegSdp)];
       this.epOther = null;
       this.logger.info('Dial:_releaseMedia - successfully released media from freewitch');
     } catch (err) {
@@ -526,6 +569,12 @@ class TaskDial extends Task {
     await Promise.all([sd.reAnchorMedia(), cs.reAnchorMedia()]);
     this.epOther = cs.ep;
   }
+
+  async handleReinviteAfterMediaReleased(req, res) {
+    const sdp = await this.dlg.modify(req.body);
+    this.logger.info({sdp}, 'Dial:handleReinviteAfterMediaReleased - sent reinvite to B leg');
+    res.send(200, {body: sdp});
+  }
 }
 
 module.exports = TaskDial;

lib/tasks/dialogflow/index.js

@@ -452,8 +452,8 @@ class Dialogflow extends Task {
     this.noinputTimer = setTimeout(this._onNoInput.bind(this, ep, cs), this.noInputTimeout);
   }
 
-  async _performHook(cs, hook, results) {
-    const json = await this.cs.requestor.request(hook, results);
+  async _performHook(cs, hook, results = {}) {
+    const json = await this.cs.requestor.request(hook, {...results, ...cs.callInfo.toJSON()});
     if (json && Array.isArray(json)) {
       const makeTask = require('../make_task');
       const tasks = normalizeJambones(this.logger, json).map((tdata) => makeTask(this.logger, tdata));

lib/tasks/enqueue.js

@@ -337,7 +337,7 @@ class TaskEnqueue extends Task {
       }
       tasksToRun.push(o);
     }
-
+    const cloneTasks = [...tasksToRun];
     if (this.killed) return [];
     else if (tasksToRun.length > 0) {
       this._playSession = new ConfirmCallSession({
@@ -356,7 +356,7 @@ class TaskEnqueue extends Task {
       this.state = QueueResults.Leave;
       this.kill(cs);
     }
-    return tasksToRun;
+    return cloneTasks;
   }
 }
 

lib/tasks/gather.js

@@ -3,7 +3,8 @@ const {
   TaskName,
   TaskPreconditions,
   GoogleTranscriptionEvents,
-  AwsTranscriptionEvents
+  AwsTranscriptionEvents,
+  AzureTranscriptionEvents
 } = require('../utils/constants');
 
 const makeTask = require('./make_task');
@@ -33,6 +34,12 @@ class TaskGather extends Task {
       this.vocabularyName = recognizer.vocabularyName;
       this.vocabularyFilterName = recognizer.vocabularyFilterName;
       this.filterMethod = recognizer.filterMethod;
+
+      /* microsoft options */
+      this.outputFormat = recognizer.outputFormat || 'simple';
+      this.profanityOption = recognizer.profanityOption || 'raw';
+      this.requestSnr = recognizer.requestSnr || false;
+      this.initialSpeechTimeoutMs = recognizer.initialSpeechTimeoutMs || 0;
     }
 
     this.digitBuffer = '';
@@ -46,6 +53,8 @@ class TaskGather extends Task {
 
   get name() { return TaskName.Gather; }
 
+  get needsStt() { return this.input.includes('speech'); }
+
   get earlyMedia() {
     return (this.sayTask && this.sayTask.earlyMedia) ||
       (this.playTask && this.playTask.earlyMedia);
@@ -59,9 +68,9 @@ class TaskGather extends Task {
     if ('default' === this.vendor || !this.vendor) this.vendor = cs.speechRecognizerVendor;
     if ('default' === this.language || !this.language) this.language = cs.speechRecognizerLanguage;
     this.sttCredentials = cs.getSpeechCredentials(this.vendor, 'stt');
-    if (!this.sttCredentials) {
+    if (this.needsStt && !this.sttCredentials) {
       const {writeAlerts, AlertType} = cs.srf.locals;
-      this.logger.info(`TaskGather:exec - ERROR stt using ${this.vendor} requested but not creds supplied`);
+      this.logger.info(`TaskGather:exec - ERROR stt using ${this.vendor} requested but creds not supplied`);
       writeAlerts({
         account_sid: cs.accountSid,
         alert_type: AlertType.STT_NOT_PROVISIONED,
@@ -104,6 +113,8 @@ class TaskGather extends Task {
     ep.removeCustomEventListener(GoogleTranscriptionEvents.Transcription);
     ep.removeCustomEventListener(GoogleTranscriptionEvents.EndOfUtterance);
     ep.removeCustomEventListener(AwsTranscriptionEvents.Transcription);
+    ep.removeCustomEventListener(AzureTranscriptionEvents.Transcription);
+    ep.removeCustomEventListener(AzureTranscriptionEvents.NoSpeechDetected);
   }
 
   kill(cs) {
@@ -133,7 +144,9 @@ class TaskGather extends Task {
         GOOGLE_SPEECH_SINGLE_UTTERANCE: true,
         GOOGLE_SPEECH_MODEL: 'command_and_search'
       });
-      if (this.hints && this.hints.length > 1) opts.GOOGLE_SPEECH_HINTS = this.hints.join(',');
+      if (this.hints && this.hints.length > 1) {
+        opts.GOOGLE_SPEECH_HINTS = this.hints.map((h) => h.trim()).join(',');
+      }
       if (this.altLanguages && this.altLanguages.length > 1) {
         opts.GOOGLE_SPEECH_ALTERNATIVE_LANGUAGE_CODES = this.altLanguages.join(',');
       }
@@ -143,22 +156,41 @@ class TaskGather extends Task {
       ep.addCustomEventListener(GoogleTranscriptionEvents.Transcription, this._onTranscription.bind(this, cs, ep));
       ep.addCustomEventListener(GoogleTranscriptionEvents.EndOfUtterance, this._onEndOfUtterance.bind(this, cs, ep));
     }
-    else {
+    else if (['aws', 'polly'].includes(this.vendor)) {
       if (this.vocabularyName) opts.AWS_VOCABULARY_NAME = this.vocabularyName;
       if (this.vocabularyFilterName) {
         opts.AWS_VOCABULARY_NAME = this.vocabularyFilterName;
         opts.AWS_VOCABULARY_FILTER_METHOD = this.filterMethod || 'mask';
       }
-      Object.assign(opts, {
-        AWS_ACCESS_KEY_ID: this.sttCredentials.accessKeyId,
-        AWS_SECRET_ACCESS_KEY: this.sttCredentials.secretAccessKey,
-        AWS_REGION: this.sttCredentials.region
-      });
+      if (this.sttCredentials) {
+        Object.assign(opts, {
+          AWS_ACCESS_KEY_ID: this.sttCredentials.accessKeyId,
+          AWS_SECRET_ACCESS_KEY: this.sttCredentials.secretAccessKey,
+          AWS_REGION: this.sttCredentials.region
+        });
+      }
       ep.addCustomEventListener(AwsTranscriptionEvents.Transcription, this._onTranscription.bind(this, cs, ep));
     }
+    else if ('microsoft' === this.vendor) {
+      if (this.sttCredentials) {
+        Object.assign(opts, {
+          'AZURE_SUBSCRIPTION_KEY': this.sttCredentials.api_key,
+          'AZURE_REGION': this.sttCredentials.region
+        });
+      }
+      if (this.hints && this.hints.length > 1) {
+        opts.AZURE_SPEECH_HINTS = this.hints.map((h) => h.trim()).join(',');
+      }
+      //if (this.requestSnr) opts.AZURE_REQUEST_SNR = 1;
+      //if (this.profanityOption !== 'raw') opts.AZURE_PROFANITY_OPTION = this.profanityOption;
+      if (this.initialSpeechTimeoutMs > 0) opts.AZURE_INITIAL_SPEECH_TIMEOUT_MS = this.initialSpeechTimeoutMs;
+      opts.AZURE_USE_OUTPUT_FORMAT_DETAILED = 1;
+
+      ep.addCustomEventListener(AzureTranscriptionEvents.Transcription, this._onTranscription.bind(this, cs, ep));
+      ep.addCustomEventListener(AzureTranscriptionEvents.NoSpeechDetected, this._onNoSpeechDetected.bind(this, cs, ep));
+    }
     await ep.set(opts)
       .catch((err) => this.logger.info(err, 'Error setting channel variables'));
-
   }
 
   _startTranscribing(ep) {
@@ -206,11 +238,21 @@ class TaskGather extends Task {
 
   _onTranscription(cs, ep, evt) {
     if ('aws' === this.vendor && Array.isArray(evt) && evt.length > 0) evt = evt[0];
-    this.logger.debug(evt, 'TaskGather:_onTranscription');
-    const final = evt.is_final;
-    if (final) {
-      this._resolve('speech', evt);
+    if ('microsoft' === this.vendor) {
+      const nbest = evt.NBest;
+      const newEvent = {
+        is_final: evt.RecognitionStatus === 'Success',
+        alternatives: [
+          {
+            confidence: nbest[0].Confidence,
+            transcript: nbest[0].Display
+          }
+        ]
+      };
+      evt = newEvent;
     }
+    this.logger.debug(evt, 'TaskGather:_onTranscription');
+    if (evt.is_final) this._resolve('speech', evt);
     else if (this.partialResultHook) {
       this.cs.requestor.request(this.partialResultHook,  Object.assign({speech: evt}, this.cs.callInfo))
         .catch((err) => this.logger.info(err, 'GatherTask:_onTranscription error'));
@@ -223,6 +265,10 @@ class TaskGather extends Task {
     }
   }
 
+  _onNoSpeechDetected(cs, ep) {
+    this._resolve('timeout');
+  }
+
   async _resolve(reason, evt) {
     if (this.resolved) return;
     this.resolved = true;

lib/tasks/listen.js

@@ -64,6 +64,7 @@ class TaskListen extends Task {
       this.results.dialCallDuration = duration;
     }
     if (this.transcribeTask) await this.transcribeTask.kill(cs);
+    this.ep && this._removeListeners(this.ep);
     this.notifyTaskDone();
   }
 
@@ -136,6 +137,10 @@ class TaskListen extends Task {
     if (this.finishOnKey || this.passDtmf) {
       ep.removeListener('dtmf', this._dtmfHandler);
     }
+    ep.removeCustomEventListener(ListenEvents.PlayAudio);
+    ep.removeCustomEventListener(ListenEvents.KillAudio);
+    ep.removeCustomEventListener(ListenEvents.Disconnect);
+
   }
 
   _onDtmf(evt) {

lib/tasks/make_task.js

@@ -17,8 +17,13 @@ function makeTask(logger, obj, parent) {
     case TaskName.SipDecline:
       const TaskSipDecline = require('./sip_decline');
       return new TaskSipDecline(logger, data, parent);
+    case TaskName.SipRefer:
+      const TaskSipRefer = require('./sip_refer');
+      return new TaskSipRefer(logger, data, parent);
+    case TaskName.Cognigy:
+      const TaskCognigy = require('./cognigy');
+      return new TaskCognigy(logger, data, parent);
     case TaskName.Conference:
-      logger.debug({data}, 'Conference verb');
       const TaskConference = require('./conference');
       return new TaskConference(logger, data, parent);
     case TaskName.Dial:

lib/tasks/message.js

@@ -42,7 +42,7 @@ class TaskMessage extends Task {
       }
       if (gw) {
         this.logger.info({gw, accountSid}, 'Message:exec - using smpp to send message');
-        url = getSmpp();
+        url = process.env.K8S ? 'http://smpp' : getSmpp();
         relativeUrl = '/sms';
         payload = {
           ...payload,

lib/tasks/say.js

@@ -21,19 +21,15 @@ class TaskSay extends Task {
     const {updateSpeechCredentialLastUsed} = require('../utils/db-utils')(this.logger, srf);
     const {writeAlerts, AlertType, stats} = srf.locals;
     const {synthAudio} = srf.locals.dbHelpers;
-    const vendor = ('default' === this.synthesizer.vendor  || !this.synthesizer.vendor) ?
-      cs.speechSynthesisVendor :
-      this.synthesizer.vendor;
-    const language = ('default' === this.synthesizer.language  || !this.synthesizer.language) ?
-      cs.speechSynthesisLanguage :
-      this.synthesizer.language;
-    const voice = ('default' === this.synthesizer.voice  || !this.synthesizer.voice) ?
-      cs.speechSynthesisVoice :
-      this.synthesizer.voice;
+    const hasVerbLevelTts = this.synthesizer.vendor && this.synthesizer.vendor !== 'default';
+    const vendor = hasVerbLevelTts ? this.synthesizer.vendor : cs.speechSynthesisVendor ;
+    const language = hasVerbLevelTts ? this.synthesizer.language : cs.speechSynthesisLanguage ;
+    const voice = hasVerbLevelTts ? this.synthesizer.voice : cs.speechSynthesisVoice ;
+    const engine = this.synthesizer.engine || 'standard';
     const salt = cs.callSid;
     const credentials = cs.getSpeechCredentials(vendor, 'tts');
 
-    this.logger.info({vendor, credentials}, 'Task:say - using vendor');
+    this.logger.info({language, voice}, `Task:say - using vendor: ${vendor}`);
     this.ep = ep;
     try {
       if (!credentials) {
@@ -52,6 +48,7 @@ class TaskSay extends Task {
           vendor,
           language,
           voice,
+          engine,
           salt,
           credentials
         }).catch((err) => {

lib/tasks/sip_refer.js

@@ -0,0 +1,101 @@
+const Task = require('./task');
+const {TaskName, TaskPreconditions} = require('../utils/constants');
+const {parseUri} = require('drachtio-srf');
+
+/**
+ * sends a sip REFER to transfer the existing call
+ */
+class TaskSipRefer extends Task {
+  constructor(logger, opts) {
+    super(logger, opts);
+    this.preconditions = TaskPreconditions.StableCall;
+
+    this.referTo = this.data.referTo;
+    this.referredBy = this.data.referredBy;
+    this.headers = this.data.headers || {};
+    this.eventHook = this.data.eventHook;
+  }
+
+  get name() { return TaskName.SipRefer; }
+
+  async exec(cs) {
+    super.exec(cs);
+    const {dlg} = cs;
+    const {referTo, referredBy} = this._normalizeReferHeaders(cs, dlg);
+
+    try {
+      this.notifyHandler = this._handleNotify.bind(this, cs, dlg);
+      dlg.on('notify', this.notifyHandler);
+      const response = await dlg.request({
+        method: 'REFER',
+        headers: {
+          ...this.headers,
+          'Refer-To': referTo,
+          'Referred-By': referredBy
+        }
+      });
+      this.referStatus = response.status;
+      this.logger.info(`TaskSipRefer:exec - received ${this.referStatus} to REFER`);
+
+      /* if we fail, fall through to next verb.  If success, we should get BYE from far end */
+      if (this.referStatus === 202) {
+        await this.awaitTaskDone();
+      }
+      else await this.performAction({refer_status: this.referStatus});
+    } catch (err) {
+      this.logger.info({err}, 'TaskSipRefer:exec - error sending REFER');
+    }
+  }
+
+  async kill(cs) {
+    super.kill(cs);
+    const {dlg} = cs;
+    dlg.off('notify', this.notifyHandler);
+  }
+
+  async _handleNotify(cs, dlg, req, res) {
+    res.send(200);
+
+    const contentType = req.get('Content-Type');
+    this.logger.debug({body: req.body}, `TaskSipRefer:_handleNotify got ${contentType}`);
+
+    if (contentType === 'message/sipfrag') {
+      const arr = /SIP\/2\.0\s+(\d+)/.exec(req.body);
+      if (arr) {
+        const status = arr[1];
+        this.logger.debug(`TaskSipRefer:_handleNotify: call got status ${status}`);
+        if (this.eventHook) {
+          await cs.requestor.request(this.eventHook, {event: 'transfer-status', call_status: status});
+        }
+        if (status >= 200) {
+          await this.performAction({refer_status: 202, final_referred_call_status: status});
+          this.notifyTaskDone();
+        }
+      }
+    }
+  }
+
+  _normalizeReferHeaders(cs, dlg) {
+    let {referTo, referredBy} = this;
+
+    /* get IP address of the SBC to use as hostname if needed */
+    const {host} = parseUri(dlg.remote.uri);
+
+    if (!referTo.startsWith('<') && !referTo.startsWith('sip') && !referTo.startsWith('"')) {
+      /* they may have only provided a phone number/user */
+      referTo = `sip:${referTo}@${host}`;
+    }
+    if (!referredBy) {
+      /* default */
+      referredBy = cs.req?.callingNumber || dlg.local.uri;
+      this.logger.info({referredBy}, 'setting referredby');
+    }
+    if (!referredBy.startsWith('<') && !referredBy.startsWith('sip') && !referredBy.startsWith('"')) {
+      /* they may have only provided a phone number/user */
+      referredBy = `sip:${referredBy}@${host}`;
+    }
+    return {referTo, referredBy};
+  }
+}
+
+module.exports = TaskSipRefer;

lib/tasks/specs.json

@@ -9,6 +9,34 @@
       "status"
     ]
   },
+  "sip:refer": {
+    "properties": {
+      "referTo": "string",
+      "referredBy": "string",
+      "headers": "object",
+      "actionHook": "object|string",
+      "eventHook": "object|string"
+    },
+    "required": [
+      "referTo"
+    ]
+  },
+  "cognigy": {
+    "properties": {
+      "url": "string",
+      "token": "string",
+      "recognizer": "#recognizer",
+      "tts": "#synthesizer",
+      "prompt": "string",
+      "actionHook": "object|string",
+      "eventHook": "object|string",
+      "data": "object"
+    },
+    "required": [
+      "url",
+      "token"
+    ]
+  },
   "dequeue": {
     "properties": {
       "name": "string",
@@ -92,7 +120,8 @@
       "waitHook": "object|string",
       "statusEvents": "array",
       "statusHook": "object|string",
-      "enterHook": "object|string"
+      "enterHook": "object|string",
+      "record": "#record"
     },
     "required": [
       "name"
@@ -241,6 +270,14 @@
       "url"
     ]
   },
+  "record": {
+    "properties": {
+      "path": "string"
+    },
+    "required": [
+      "path"
+    ]
+  },
   "redirect": {
     "properties": {
       "actionHook": "object|string"
@@ -287,7 +324,6 @@
       "earlyMedia": "boolean"
     },
     "required": [
-      "transcriptionHook",
       "recognizer"
     ]
   },
@@ -307,7 +343,9 @@
       "sipUri": "string",
       "auth": "#auth",
       "vmail": "boolean",
-      "tenant": "string"
+      "tenant": "string",
+      "trunk": "string",
+      "overrideTo": "string"
     },
     "required": [
       "type"
@@ -327,10 +365,14 @@
     "properties": {
       "vendor": {
         "type": "string",
-        "enum": ["google", "aws", "polly", "default"]
+        "enum": ["google", "aws", "polly", "microsoft", "default"]
       },
       "language": "string",
       "voice": "string",
+      "engine": {
+        "type": "string",
+        "enum": ["standard", "neural"]
+      },
       "gender": {
         "type": "string",
         "enum": ["MALE", "FEMALE", "NEUTRAL"]
@@ -344,7 +386,7 @@
     "properties": {
       "vendor": {
         "type": "string",
-        "enum": ["google", "aws", "default"]
+        "enum": ["google", "aws", "microsoft", "default"]
       },
       "language": "string",
       "hints": "array",
@@ -384,7 +426,24 @@
           "mask",
           "tag"
         ]
-      }
+      },
+      "outputFormat": {
+        "type": "string",
+        "enum": [
+          "simple",
+          "detailed"
+        ]
+      },
+      "profanityOption": {
+        "type": "string",
+        "enum": [
+          "masked",
+          "removed",
+          "raw"
+        ]
+      },
+      "requestSnr": "boolean",
+      "initialSpeechTimeoutMs": "number"
     },
     "required": [
       "vendor"

lib/tasks/transcribe.js

@@ -3,6 +3,7 @@ const {
   TaskName,
   TaskPreconditions,
   GoogleTranscriptionEvents,
+  AzureTranscriptionEvents,
   AwsTranscriptionEvents
 } = require('../utils/constants');
 
@@ -10,6 +11,7 @@ class TaskTranscribe extends Task {
   constructor(logger, opts, parentTask) {
     super(logger, opts);
     this.preconditions = TaskPreconditions.Endpoint;
+    this.parentTask = parentTask;
 
     this.transcriptionHook = this.data.transcriptionHook;
     this.earlyMedia = this.data.earlyMedia === true || (parentTask && parentTask.earlyMedia);
@@ -38,6 +40,12 @@ class TaskTranscribe extends Task {
     this.vocabularyName = recognizer.vocabularyName;
     this.vocabularyFilterName = recognizer.vocabularyFilterName;
     this.filterMethod = recognizer.filterMethod;
+
+    /* microsoft options */
+    this.outputFormat = recognizer.outputFormat || 'simple';
+    this.profanityOption = recognizer.profanityOption || 'raw';
+    this.requestSnr = recognizer.requestSnr || false;
+    this.initialSpeechTimeoutMs = recognizer.initialSpeechTimeoutMs || 0;
   }
 
   get name() { return TaskName.Transcribe; }
@@ -53,7 +61,13 @@ class TaskTranscribe extends Task {
 
     try {
       if (!this.sttCredentials) {
-        // TODO: generate alert (actually should be done by cs.getSpeechCredentials)
+        const {writeAlerts, AlertType} = cs.srf.locals;
+        this.logger.info(`TaskTranscribe:exec - ERROR stt using ${this.vendor} requested but creds not supplied`);
+        writeAlerts({
+          account_sid: cs.accountSid,
+          alert_type: AlertType.STT_NOT_PROVISIONED,
+          vendor: this.vendor
+        }).catch((err) => this.logger.info({err}, 'Error generating alert for no stt'));
         throw new Error('no provisioned speech credentials for TTS');
       }
       await this._startTranscribing(cs, ep);
@@ -63,6 +77,7 @@ class TaskTranscribe extends Task {
       await this.awaitTaskDone();
     } catch (err) {
       this.logger.info(err, 'TaskTranscribe:exec - error');
+      this.parentTask && this.parentTask.emit('error', err);
     }
     ep.removeCustomEventListener(GoogleTranscriptionEvents.Transcription);
     ep.removeCustomEventListener(GoogleTranscriptionEvents.NoAudioDetected);
@@ -70,6 +85,8 @@ class TaskTranscribe extends Task {
     ep.removeCustomEventListener(AwsTranscriptionEvents.Transcription);
     ep.removeCustomEventListener(AwsTranscriptionEvents.NoAudioDetected);
     ep.removeCustomEventListener(AwsTranscriptionEvents.MaxDurationExceeded);
+    ep.removeCustomEventListener(AzureTranscriptionEvents.Transcription);
+    ep.removeCustomEventListener(AzureTranscriptionEvents.NoSpeechDetected);
   }
 
   async kill(cs) {
@@ -96,6 +113,8 @@ class TaskTranscribe extends Task {
     ep.addCustomEventListener(AwsTranscriptionEvents.NoAudioDetected, this._onNoAudio.bind(this, cs, ep));
     ep.addCustomEventListener(AwsTranscriptionEvents.MaxDurationExceeded,
       this._onMaxDurationExceeded.bind(this, cs, ep));
+    ep.addCustomEventListener(AzureTranscriptionEvents.Transcription, this._onTranscription.bind(this, cs, ep));
+    ep.addCustomEventListener(AzureTranscriptionEvents.NoSpeechDetected, this._onNoAudio.bind(this, cs, ep));
 
     if (this.vendor === 'google') {
       if (this.sttCredentials) opts.GOOGLE_APPLICATION_CREDENTIALS = JSON.stringify(this.sttCredentials.credentials);
@@ -164,6 +183,22 @@ class TaskTranscribe extends Task {
       await ep.set(opts)
         .catch((err) => this.logger.info(err, 'TaskTranscribe:_startTranscribing with aws'));
     }
+    else if (this.vendor === 'microsoft') {
+      Object.assign(opts, {
+        'AZURE_SUBSCRIPTION_KEY': this.sttCredentials.api_key,
+        'AZURE_REGION': this.sttCredentials.region
+      });
+      if (this.hints && this.hints.length > 1) {
+        opts.AZURE_SPEECH_HINTS = this.hints.map((h) => h.trim()).join(',');
+      }
+      if (this.requestSnr) opts.AZURE_REQUEST_SNR = 1;
+      if (this.profanityOption !== 'raw') opts.AZURE_PROFANITY_OPTION = this.profanityOption;
+      if (this.initialSpeechTimeoutMs > 0) opts.AZURE_INITIAL_SPEECH_TIMEOUT_MS = this.initialSpeechTimeoutMs;
+      if (this.outputFormat !== 'simple') opts.AZURE_USE_OUTPUT_FORMAT_DETAILED = 1;
+
+      await ep.set(opts)
+        .catch((err) => this.logger.info(err, 'TaskTranscribe:_startTranscribing with azure'));
+    }
     await this._transcribe(ep);
   }
 
@@ -177,11 +212,36 @@ class TaskTranscribe extends Task {
   }
 
   _onTranscription(cs, ep, evt) {
-    if ('aws' === this.vendor && Array.isArray(evt) && evt.length > 0) evt = evt[0];
     this.logger.debug(evt, 'TaskTranscribe:_onTranscription');
+    if ('aws' === this.vendor && Array.isArray(evt) && evt.length > 0) evt = evt[0];
+    if ('microsoft' === this.vendor) {
+      const nbest = evt.NBest;
+      const alternatives = nbest ? nbest.map((n) => {
+        return {
+          confidence: n.Confidence,
+          transcript: n.Display
+        };
+      }) :
+        [
+          {
+            transcript: evt.DisplayText
+          }
+        ];
 
-    this.cs.requestor.request(this.transcriptionHook, Object.assign({speech: evt}, this.cs.callInfo))
-      .catch((err) => this.logger.info(err, 'TranscribeTask:_onTranscription error'));
+      const newEvent = {
+        is_final: evt.RecognitionStatus === 'Success',
+        alternatives
+      };
+      evt = newEvent;
+    }
+
+    if (this.transcriptionHook) {
+      this.cs.requestor.request(this.transcriptionHook, Object.assign({speech: evt}, this.cs.callInfo))
+        .catch((err) => this.logger.info(err, 'TranscribeTask:_onTranscription error'));
+    }
+    if (this.parentTask) {
+      this.parentTask.emit('transcription', evt);
+    }
     if (this.killed) {
       this.logger.debug('TaskTranscribe:_onTranscription exiting after receiving final transcription');
       this._clearTimer();

lib/utils/constants.json

@@ -1,5 +1,6 @@
 {
   "TaskName": {
+    "Cognigy": "cognigy",
     "Conference": "conference",
     "Dequeue": "dequeue",
     "Dial": "dial",
@@ -18,6 +19,7 @@
     "Redirect": "redirect",
     "RestDial": "rest:dial",
     "SipDecline": "sip:decline",
+    "SipRefer": "sip:refer",
     "SipNotify": "sip:notify",
     "SipRedirect": "sip:redirect",
     "Say": "say",
@@ -64,6 +66,12 @@
     "NoAudioDetected": "aws_transcribe::no_audio_detected",
     "MaxDurationExceeded": "aws_transcribe::max_duration_exceeded"
   },
+  "AzureTranscriptionEvents": {
+    "Transcription": "azure_transcribe::transcription",
+    "StartOfUtterance": "azure_transcribe::start_of_utterance",
+    "EndOfUtterance": "azure_transcribe::end_of_utterance",
+    "NoSpeechDetected": "azure_transcribe::no_speech_detected"
+  },
   "ListenEvents": {
     "Connect": "mod_audio_fork::connect",
     "ConnectFailure": "mod_audio_fork::connect_failed",
@@ -98,5 +106,6 @@
     "Replaced": "replaced"
   },
   "MAX_SIMRINGS": 10,
-  "BONG_TONE": "tone_stream://v=-7;%(100,0,941.0,1477.0);v=-7;>=2;+=.1;%(1400,0,350,440)"
+  "BONG_TONE": "tone_stream://v=-7;%(100,0,941.0,1477.0);v=-7;>=2;+=.1;%(1400,0,350,440)",
+  "FS_UUID_SET_NAME": "fsUUIDs"
 }

lib/utils/db-utils.js

@@ -10,6 +10,16 @@ const sqlSpeechCredentialsForSP = `SELECT *
 FROM speech_credentials 
 WHERE service_provider_sid =  
 (SELECT service_provider_sid from accounts where account_sid = ?)`;
+const sqlQueryAccountCarrierByName = `SELECT voip_carrier_sid  
+FROM voip_carriers vc 
+WHERE vc.account_sid = ? 
+AND vc.name = ?`;
+const sqlQuerySPCarrierByName = `SELECT voip_carrier_sid  
+FROM voip_carriers vc 
+WHERE vc.account_sid IS NULL 
+AND vc.service_provider_sid = 
+(SELECT service_provider_sid from accounts where account_sid = ?) 
+AND vc.name = ?`;
 
 const speechMapper = (cred) => {
   const {credential, ...obj} = cred;
@@ -21,6 +31,15 @@ const speechMapper = (cred) => {
     obj.access_key_id = o.access_key_id;
     obj.secret_access_key = o.secret_access_key;
   }
+  else if ('microsoft' === obj.vendor) {
+    const o = JSON.parse(decrypt(credential));
+    obj.api_key = o.api_key;
+    obj.region = o.region;
+  }
+  else if ('wellsaid' === obj.vendor) {
+    const o = JSON.parse(decrypt(credential));
+    obj.api_key = o.api_key;
+  }
   return obj;
 };
 
@@ -37,7 +56,9 @@ module.exports = (logger, srf) => {
     /* search at the service provider level if we don't find it at the account level */
     const haveGoogle = speech.find((s) => s.vendor === 'google');
     const haveAws = speech.find((s) => s.vendor === 'aws');
-    if (!haveGoogle || !haveAws) {
+    const haveMicrosoft = speech.find((s) => s.vendor === 'microsoft');
+    const haveWellsaid = speech.find((s) => s.vendor === 'wellsaid');
+    if (!haveGoogle || !haveAws || !haveMicrosoft) {
       const [r3] = await pp.query(sqlSpeechCredentialsForSP, account_sid);
       if (r3.length) {
         if (!haveGoogle) {
@@ -48,6 +69,14 @@ module.exports = (logger, srf) => {
           const aws = r3.find((s) => s.vendor === 'aws');
           if (aws) speech.push(speechMapper(aws));
         }
+        if (!haveMicrosoft) {
+          const ms = r3.find((s) => s.vendor === 'microsoft');
+          if (ms) speech.push(speechMapper(ms));
+        }
+        if (!haveWellsaid) {
+          const wellsaid = r3.find((s) => s.vendor === 'wellsaid');
+          if (wellsaid) speech.push(speechMapper(wellsaid));
+        }
       }
     }
 
@@ -67,8 +96,21 @@ module.exports = (logger, srf) => {
     }
   };
 
+  const lookupCarrier = async(account_sid, carrierName) => {
+    const pp = pool.promise();
+    try {
+      const [r] = await pp.query(sqlQueryAccountCarrierByName, [account_sid, carrierName]);
+      if (r.length) return r[0].voip_carrier_sid;
+      const [r2] = await pp.query(sqlQuerySPCarrierByName, [account_sid, carrierName]);
+      if (r2.length) return r2[0].voip_carrier_sid;
+    } catch (err) {
+      logger.error({err}, `lookupCarrier: Error ${account_sid}:${carrierName}`);
+    }
+  };
+
   return {
     lookupAccountDetails,
-    updateSpeechCredentialLastUsed
+    updateSpeechCredentialLastUsed,
+    lookupCarrier
   };
 };

lib/utils/encrypt-decrypt.js

@@ -1,5 +1,5 @@
 const crypto = require('crypto');
-const algorithm = 'aes-256-ctr';
+const algorithm = process.env.LEGACY_CRYPTO ? 'aes-256-ctr' : 'aes-256-cbc';
 const iv = crypto.randomBytes(16);
 const secretKey = crypto.createHash('sha256')
   .update(String(process.env.JWT_SECRET))

lib/utils/install-srf-locals.js

@@ -20,6 +20,13 @@ function initMS(logger, wrapper, ms) {
       wrapper.connects = 1;
       wrapper.active = true;
     });
+
+  ms.on('channel::open', (evt) => {
+    logger.debug({evt}, `mediaserver ${ms.address} added endpoint`);
+  });
+  ms.on('channel::close', (evt) => {
+    logger.debug({evt}, `mediaserver ${ms.address} removed endpoint`);
+  });
 }
 
 function installSrfLocals(srf, logger) {
@@ -105,6 +112,7 @@ function installSrfLocals(srf, logger) {
   const {
     pool,
     lookupAppByPhoneNumber,
+    lookupAppByRegex,
     lookupAppBySid,
     lookupAppByRealm,
     lookupAppByTeamsTenant,
@@ -159,6 +167,7 @@ function installSrfLocals(srf, logger) {
       client,
       pool,
       lookupAppByPhoneNumber,
+      lookupAppByRegex,
       lookupAppBySid,
       lookupAppByRealm,
       lookupAppByTeamsTenant,

lib/utils/place-outdial.js

@@ -5,15 +5,10 @@ const {TaskPreconditions, CallDirection} = require('../utils/constants');
 const CallInfo = require('../session/call-info');
 const assert = require('assert');
 const ConfirmCallSession = require('../session/confirm-call-session');
-const selectSbc = require('./select-sbc');
-const Registrar = require('@jambonz/mw-registrar');
 const AdultingCallSession = require('../session/adulting-call-session');
-const registrar = new Registrar({
-  host: process.env.JAMBONES_REDIS_HOST,
-  port: process.env.JAMBONES_REDIS_PORT || 6379
-});
 const deepcopy = require('deepcopy');
 const moment = require('moment');
+const stripCodecs = require('./strip-ancillary-codecs');
 const { v4: uuidv4 } = require('uuid');
 
 class SingleDialer extends Emitter {
@@ -63,7 +58,12 @@ class SingleDialer extends Emitter {
   async exec(srf, ms, opts) {
     opts = opts || {};
     opts.headers = opts.headers || {};
-    opts.headers = {...opts.headers, 'X-Call-Sid': this.callSid};
+    opts.headers = {
+      ...opts.headers,
+      'X-Jambonz-Routing': this.target.type,
+      'X-Jambonz-FS-UUID': srf.locals.fsUUID,
+      'X-Call-Sid': this.callSid
+    };
     this.ms = ms;
     let uri, to;
     try {
@@ -84,7 +84,6 @@ class SingleDialer extends Emitter {
           break;
         case 'user':
           assert(this.target.name);
-          const aor = this.target.name;
           uri = `sip:${this.target.name}`;
           to = this.target.name;
 
@@ -93,16 +92,6 @@ class SingleDialer extends Emitter {
               'X-Override-To': this.target.overrideTo
             });
           }
-
-          // need to send to the SBC registered on
-          const reg = await registrar.query(aor);
-          if (reg) {
-            const sbc = selectSbc(reg.sbcAddress);
-            if (sbc) {
-              this.logger.debug(`SingleDialer:exec retrieved registration details for ${aor}, using sbc at ${sbc}`);
-              this.sbcAddress = sbc;
-            }
-          }
           break;
         case 'sip':
           assert(this.target.sipUri);
@@ -209,9 +198,15 @@ class SingleDialer extends Emitter {
         .on('refresh', () => this.logger.info('SingleDialer:exec - dialog refreshed by uas'))
         .on('modify', async(req, res) => {
           try {
-            const newSdp = await this.ep.modify(req.body);
-            res.send(200, {body: newSdp});
-            this.logger.info({offer: req.body, answer: newSdp}, 'SingleDialer:exec: handling reINVITE');
+            if (this.ep) {
+              const newSdp = await this.ep.modify(req.body);
+              res.send(200, {body: newSdp});
+              this.logger.info({offer: req.body, answer: newSdp}, 'SingleDialer:exec: handling reINVITE');
+            }
+            else {
+              this.logger.info('SingleDialer:exec: handling reINVITE with released media, emit event');
+              this.emit('reinvite', req, res);
+            }
           } catch (err) {
             this.logger.error(err, 'Error handling reinvite');
           }
@@ -322,9 +317,10 @@ class SingleDialer extends Emitter {
     return cs;
   }
 
-  async releaseMediaToSBC(remoteSdp) {
+  async releaseMediaToSBC(remoteSdp, localSdp) {
     assert(this.dlg && this.dlg.connected && this.ep && typeof remoteSdp === 'string');
-    await this.dlg.modify(remoteSdp, {
+    const sdp = stripCodecs(this.logger, remoteSdp, localSdp) || remoteSdp;
+    await this.dlg.modify(sdp, {
       headers: {
         'X-Reason': 'release-media'
       }

lib/utils/requestor.js

@@ -100,15 +100,15 @@ class Requestor {
 
     assert.ok(url, 'Requestor:request url was not provided');
     assert.ok, (['GET', 'POST'].includes(method), `Requestor:request method must be 'GET' or 'POST' not ${method}`);
-
-    this.logger.debug({hook, payload}, `Requestor:request ${method} ${url}`);
+    const {url: urlInfo = hook, method: methodInfo = 'POST'} = hook;  // mask user/pass
+    this.logger.debug({url: urlInfo, method: methodInfo, payload}, `Requestor:request ${method} ${url}`);
     const startAt = process.hrtime();
 
     let buf;
     try {
       const sigHeader = generateSigHeader(payload, this.secret);
       const headers = {...sigHeader, ...this.authHeader};
-      this.logger.info({url, headers}, 'send webhook');
+      //this.logger.info({url, headers}, 'send webhook');
       buf = isRelativeUrl(url) ?
         await this.post(url, payload, headers) :
         await bent(method, 'buffer', 200, 201, 202)(url, payload, headers);

lib/utils/sbc-pinger.js

@@ -1,8 +1,9 @@
 const assert = require('assert');
-const noopLogger = {info: () => {}, error: () => {}};
-const {LifeCycleEvents} = require('./constants');
+const { v4: uuidv4 } = require('uuid');
+const {LifeCycleEvents, FS_UUID_SET_NAME} = require('./constants');
 const Emitter = require('events');
 const debug = require('debug')('jambonz:feature-server');
+const noopLogger = {info: () => {}, error: () => {}};
 
 module.exports = (logger) => {
   logger = logger || noopLogger;
@@ -67,7 +68,6 @@ module.exports = (logger) => {
     })();
   }
 
-  // send OPTIONS pings to SBCs
   async function pingProxies(srf) {
     if (process.env.NODE_ENV === 'test') return;
 
@@ -90,29 +90,40 @@ module.exports = (logger) => {
       }
     }
   }
+  if (process.env.K8S) {
+    setImmediate(() => {
+      logger.info('disabling OPTIONS pings since we are running as a kubernetes service');
+      const {srf} = require('../..');
+      const {addToSet} = srf.locals.dbHelpers;
+      const uuid = srf.locals.fsUUID = uuidv4();
+      addToSet(FS_UUID_SET_NAME, uuid)
+        .catch((err) => logger.info({err}, `Error adding ${uuid} to set ${FS_UUID_SET_NAME}`));
+    });
+  }
+  else {
+    // OPTIONS ping the SBCs from each feature server every 60 seconds
+    setInterval(() => {
+      const {srf} = require('../..');
+      pingProxies(srf);
+    }, process.env.OPTIONS_PING_INTERVAL || 30000);
 
-  // OPTIONS ping the SBCs from each feature server every 60 seconds
-  setInterval(() => {
-    const {srf} = require('../..');
-    pingProxies(srf);
-  }, 20000);
+    // initial ping once we are up
+    setTimeout(async() => {
 
-  // initial ping once we are up
-  setTimeout(async() => {
-    const {srf} = require('../..');
+      // if SBCs are auto-scaling, monitor them as they come and go
+      const {srf} = require('../..');
+      if (!process.env.JAMBONES_SBCS) {
+        const {monitorSet} = srf.locals.dbHelpers;
+        const setName = `${(process.env.JAMBONES_CLUSTER_ID || 'default')}:active-sip`;
+        await monitorSet(setName, 10, (members) => {
+          sbcs = members;
+          logger.info(`sbc-pinger: SBC roster has changed, list of active SBCs is now ${sbcs}`);
+        });
+      }
 
-    // if SBCs are auto-scaling, monitor them as they come and go
-    if (!process.env.JAMBONES_SBCS) {
-      const {monitorSet} = srf.locals.dbHelpers;
-      const setName = `${(process.env.JAMBONES_CLUSTER_ID || 'default')}:active-sip`;
-      await monitorSet(setName, 10, (members) => {
-        sbcs = members;
-        logger.info(`sbc-pinger: SBC roster has changed, list of active SBCs is now ${sbcs}`);
-      });
-    }
-
-    pingProxies(srf);
-  }, 1000);
+      pingProxies(srf);
+    }, 1000);
+  }
 
   return {
     lifecycleEmitter,

lib/utils/select-sbc.js

@@ -1,13 +0,0 @@
-const CIDRMatcher = require('cidr-matcher');
-const matcher = new CIDRMatcher([process.env.JAMBONES_NETWORK_CIDR]);
-
-module.exports = (sbcList) => {
-  const obj = sbcList
-    .split(',')
-    .map((str) => {
-      const arr = /^(.*)\/(.*):(\d+)$/.exec(str);
-      return {protocol: arr[1], host: arr[2], port: arr[3]};
-    })
-    .find((obj) => 'udp' == obj.protocol && matcher.contains(obj.host));
-  if (obj) return `${obj.host}:${obj.port}`;
-};

lib/utils/strip-ancillary-codecs.js

@@ -0,0 +1,30 @@
+const sdpTransform = require('sdp-transform');
+
+const stripCodecs = (logger, remoteSdp, localSdp) => {
+  try {
+    const sdp = sdpTransform.parse(remoteSdp);
+    const local = sdpTransform.parse(localSdp);
+    const m = local.media
+      .find((m) => 'audio' === m.type);
+    const pt = m.rtp[0].payload;
+
+    /* manipulate on the audio section */
+    const audio = sdp.media.find((m) => 'audio' === m.type);
+
+    /* discard all of the codecs except the first in our 200 OK, and telephony-events */
+    const ptSaves = audio.rtp
+      .filter((r) => r.codec === 'telephone-event' || r.payload === pt)
+      .map((r) => r.payload);
+    const rtp = audio.rtp.filter((r) => ptSaves.includes(r.payload));
+
+    /* reattach the new rtp sections and  stripped payload list */
+    audio.rtp = rtp;
+    audio.payloads = rtp.map((r) => r.payload).join(' ');
+    return sdpTransform.write(sdp);
+  } catch (err) {
+    logger.error({err, remoteSdp, localSdp}, 'strip-ancillary-codecs error');
+  }
+};
+
+module.exports = stripCodecs;
+

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jambonz-feature-server",
-  "version": "0.6.7-rc5",
+  "version": "v0.7.2",
   "main": "app.js",
   "engines": {
     "node": ">= 10.16.0"
@@ -26,23 +26,25 @@
     "jslint": "eslint app.js lib"
   },
   "dependencies": {
-    "@jambonz/db-helpers": "^0.6.13",
+    "@cognigy/socket-client": "^4.5.5",
+    "@jambonz/db-helpers": "^0.6.16",
+    "@jambonz/http-health-check": "^0.0.1",
     "@jambonz/mw-registrar": "^0.2.1",
-    "@jambonz/realtimedb-helpers": "^0.4.8",
-    "@jambonz/stats-collector": "^0.1.5",
+    "@jambonz/realtimedb-helpers": "^0.4.19",
+    "@jambonz/stats-collector": "^0.1.6",
     "@jambonz/time-series": "^0.1.5",
-    "aws-sdk": "^2.846.0",
+    "aws-sdk": "^2.1060.0",
     "bent": "^7.3.12",
     "cidr-matcher": "^2.1.1",
-    "debug": "^4.3.1",
+    "debug": "^4.3.2",
     "deepcopy": "^2.1.0",
-    "drachtio-fsmrf": "^2.0.7",
+    "drachtio-fsmrf": "^2.0.13",
     "drachtio-srf": "^4.4.55",
     "express": "^4.17.1",
     "ip": "^1.1.5",
     "moment": "^2.29.1",
-    "parse-url": "^5.0.2",
-    "pino": "^6.11.2",
+    "parse-url": "^5.0.7",
+    "pino": "^6.13.2",
     "to-snake-case": "^1.0.0",
     "uuid": "^8.3.2",
     "verify-aws-sns-signature": "^0.0.6",

test/db/create-and-populate-schema.sql

@@ -587,7 +587,8 @@ DROP TABLE IF EXISTS `speech_credentials`;
 /*!50503 SET character_set_client = utf8mb4 */;
 CREATE TABLE `speech_credentials` (
   `speech_credential_sid` char(36) NOT NULL,
-  `account_sid` char(36) NOT NULL,
+ `service_provider_sid` CHAR(36),
+ `account_sid` char(36) NOT NULL,
   `vendor` varchar(255) NOT NULL,
   `credential` VARCHAR(8192) NOT NULL,
   `use_for_tts` tinyint(1) DEFAULT '1',
@@ -611,7 +612,7 @@ CREATE TABLE `speech_credentials` (
 
 LOCK TABLES `speech_credentials` WRITE;
 /*!40000 ALTER TABLE `speech_credentials` DISABLE KEYS */;
-INSERT INTO `speech_credentials` VALUES ('2add163c-34f2-45c6-a016-f955d218ffb6','bb845d4b-83a9-4cde-a6e9-50f3743bab3f','google','credential-goes-here',1,1,NULL,'2021-04-03 15:42:10',1,1),('84154212-5c99-4c94-8993-bc2a46288daa','bb845d4b-83a9-4cde-a6e9-50f3743bab3f','aws','credential-goes-here',0,0,NULL,NULL,NULL,NULL);
+INSERT INTO `speech_credentials` VALUES ('2add163c-34f2-45c6-a016-f955d218ffb6',NULL,'bb845d4b-83a9-4cde-a6e9-50f3743bab3f','google','credential-goes-here',1,1,NULL,'2021-04-03 15:42:10',1,1),('84154212-5c99-4c94-8993-bc2a46288daa',NULL,'bb845d4b-83a9-4cde-a6e9-50f3743bab3f','aws','credential-goes-here',0,0,NULL,NULL,NULL,NULL);
 /*!40000 ALTER TABLE `speech_credentials` ENABLE KEYS */;
 UNLOCK TABLES;
 

test/db/jambones-sql.sql

@@ -20,12 +20,16 @@ DROP TABLE IF EXISTS lcr_routes;
 
 DROP TABLE IF EXISTS predefined_sip_gateways;
 
+DROP TABLE IF EXISTS predefined_smpp_gateways;
+
 DROP TABLE IF EXISTS predefined_carriers;
 
 DROP TABLE IF EXISTS account_offers;
 
 DROP TABLE IF EXISTS products;
 
+DROP TABLE IF EXISTS schema_version;
+
 DROP TABLE IF EXISTS api_keys;
 
 DROP TABLE IF EXISTS sbc_addresses;
@@ -148,6 +152,20 @@ predefined_carrier_sid CHAR(36) NOT NULL,
 PRIMARY KEY (predefined_sip_gateway_sid)
 );
 
+CREATE TABLE predefined_smpp_gateways
+(
+predefined_smpp_gateway_sid CHAR(36) NOT NULL UNIQUE ,
+ipv4 VARCHAR(128) NOT NULL COMMENT 'ip address or DNS name of the gateway. ',
+port INTEGER NOT NULL DEFAULT 2775 COMMENT 'smpp signaling port',
+inbound BOOLEAN NOT NULL COMMENT 'if true, whitelist this IP to allow inbound SMS from the gateway',
+outbound BOOLEAN NOT NULL COMMENT 'i',
+netmask INTEGER NOT NULL DEFAULT 32,
+is_primary BOOLEAN NOT NULL DEFAULT 1,
+use_tls BOOLEAN DEFAULT 0,
+predefined_carrier_sid CHAR(36) NOT NULL,
+PRIMARY KEY (predefined_smpp_gateway_sid)
+);
+
 CREATE TABLE products
 (
 product_sid CHAR(36) NOT NULL UNIQUE ,
@@ -174,6 +192,11 @@ stripe_product_id VARCHAR(56) NOT NULL,
 PRIMARY KEY (account_offer_sid)
 );
 
+CREATE TABLE schema_version
+(
+version VARCHAR(16)
+);
+
 CREATE TABLE api_keys
 (
 api_key_sid CHAR(36) NOT NULL UNIQUE ,
@@ -420,6 +443,10 @@ CREATE INDEX predefined_sip_gateway_sid_idx ON predefined_sip_gateways (predefin
 CREATE INDEX predefined_carrier_sid_idx ON predefined_sip_gateways (predefined_carrier_sid);
 ALTER TABLE predefined_sip_gateways ADD FOREIGN KEY predefined_carrier_sid_idxfk (predefined_carrier_sid) REFERENCES predefined_carriers (predefined_carrier_sid);
 
+CREATE INDEX predefined_smpp_gateway_sid_idx ON predefined_smpp_gateways (predefined_smpp_gateway_sid);
+CREATE INDEX predefined_carrier_sid_idx ON predefined_smpp_gateways (predefined_carrier_sid);
+ALTER TABLE predefined_smpp_gateways ADD FOREIGN KEY predefined_carrier_sid_idxfk_1 (predefined_carrier_sid) REFERENCES predefined_carriers (predefined_carrier_sid);
+
 CREATE INDEX product_sid_idx ON products (product_sid);
 CREATE INDEX account_product_sid_idx ON account_products (account_product_sid);
 CREATE INDEX account_subscription_sid_idx ON account_products (account_subscription_sid);
@@ -545,4 +572,4 @@ ALTER TABLE accounts ADD FOREIGN KEY queue_event_hook_sid_idxfk (queue_event_hoo
 
 ALTER TABLE accounts ADD FOREIGN KEY device_calling_application_sid_idxfk (device_calling_application_sid) REFERENCES applications (application_sid);
 
-SET FOREIGN_KEY_CHECKS=1;
+SET FOREIGN_KEY_CHECKS=0;

test/docker-compose-testbed.yaml

@@ -9,6 +9,7 @@ networks:
 services:
   mysql:
     image: mysql:5.7
+    platform: linux/x86_64
     ports:
       - "3360:3306"
     environment: 
@@ -123,7 +124,7 @@ services:
         ipv4_address: 172.38.0.63
 
   influxdb:
-    image: influxdb:1.8-alpine
+    image: influxdb:1.8
     ports:
       - "8086:8086"
     networks: