@babblevoice/projectrtp 2.4.3 → 2.4.8

package/README.md

@@ -1,5 +1,7 @@
 # ProjectRTP
 
+[![Build](https://github.com/babblevoice/projectrtp/actions/workflows/buildimage.yaml/badge.svg)](https://github.com/babblevoice/projectrtp/actions/workflows/buildimage.yaml)
+
 An RTP node addon which offers functionality to process RTP data streams and mix it. All performance tasks are implemented in C++ and use boost::asio for IO completion ports for high concurrency.
 
 ProjectRTP is designed to scale to multiple servers serving other signalling servers. RTP and signalling should be kept separate, and this architecture allows that. It is provided with a proxy server and client to allow for remote nodes.
@@ -30,21 +32,9 @@ Given a version number MAJOR.MINOR.PATCH, increment the:
 
 As part of this, we maintain jsdoc documentation to document our public interface to this programme.
 
-Only when we release version 1.0.0 will the public API be settled.
-
 ## Release process
 
-1. Update package.json to the new version number (see Version numbers above)
-2. Update Dockerfile with the new version number
-3. npm test && stress testing
-4. git commit && push
-5. npm publish
-6. docker buildx prune
-7. docker buildx build --platform linux/amd64,linux/arm64 -t tinpotnick/projectrtp:<version> . --push
-8. Git release
-9. Github tag <version> 
-
-<version> should simply the semantic version number. For late stage test builds this could be <version>betax.
+Releases are managed on GitHub actions. It builds and tests any version.
 
 ## Docker
 
@@ -102,27 +92,6 @@ has a submodule so (although this is handled inteh Dockerfile if you are buildin
 git submodule update --init --recursive
 ```
 
-### Fedora
-
-After installing standard build tools - including g++.
-
-```
-dnf install ilbc-devel spandsp-devel boost gnutls libsrtp libsrtp-devel g++
-```
-
-### Ubuntu
-
-Build ilbc from the sub module plus install other dependancies.
-
-```bash
-
-apt install libboost-dev libboost-system-dev libspandsp-dev gnutls-dev libsrtp2-dev cmake ccache
-
-cd libilbc
-cmake . -DCMAKE_INSTALL_LIBDIR=/lib -DCMAKE_INSTALL_INCLUDEDIR=/usr/include; cmake --build .; cmake --install .
-cd ..
-```
-
 ## Docker/Podman
 
 Podman has some shortfalls. Remove and install docker.

package/lib/node.js

@@ -22,6 +22,198 @@ const channelmap = {
   "direction": ( chan, msg ) => chan.direction( msg.options )
 }
 
+/**
+ * One for each connection spawned by rtpnode.
+ */
+class rtpnodeconnection {
+  constructor( parent, connection ) {
+    this.connectionid = uuidv4()
+    this.connection = connection
+    this.connectionlength = 0
+    this.mode = "listen"
+    this.parent = parent
+    this.messagestate = message.newstate()
+    this._reconnecttime = 500 /* mS */
+    this._destroying = false
+
+    // spawned from listen
+    if( connection ) {
+      connection.setKeepAlive( true )
+      connection.on( "data", this._onsocketdata.bind( this ) )
+    }
+  }
+
+  static create( parent, connection ) {
+    return new rtpnodeconnection( parent, connection )
+  }
+
+  destroy() {
+    this._destroying = true
+    if( this._reconnecttimerid ) {
+      clearTimeout( this._reconnecttimerid )
+      delete this._reconnecttimerid
+    }
+
+    this.connection.destroy()
+  }
+
+  _onsocketdata( data ) {
+    message.parsemessage( this.messagestate, data, ( msg ) => {
+      try {
+        this.parent._pre( msg, ( modifiedmsg ) => {
+          this._processmessage( modifiedmsg )
+        } )
+      } catch( e ) {
+        console.error( "Unhandled exception in babble-rtp", e )
+      }
+    } )
+  }
+
+  /**
+   * @private
+   * @param { object } msg
+   * @returns boolean
+   */
+  _updatechannel( msg ) {
+
+    if( undefined === msg.channel ) return false
+    if( undefined === msg.uuid ) return false
+
+    const chan = channels.get( msg.uuid )
+    if( undefined == chan ) return false
+
+    if( msg.channel in channelmap ) {
+      channelmap[ msg.channel ]( chan, msg )
+    } else {
+      const channelidentifiers = {
+        "id": msg.id,
+        "uuid": msg.uuid
+      }
+      this.send( { ...{ "error": "Unknown method" }, ...channelidentifiers } )
+    }
+
+    return true
+  }
+
+  /**
+   * 
+   * @param { object } msg 
+   * @returns { Promise< Boolean > }
+   */
+  async _processmessage( msg ) {
+    if( "open" == msg.channel ) return await this._openchannel( msg )
+
+    return this._updatechannel( msg )
+  }
+
+  /**
+   * Send a message back to the main server, include stats to help with load balancing.
+   * @param { object } msg
+   * @returns { void }
+   */
+  send( msg, cb = undefined ) {
+    this.parent._post( msg, ( modifiedmsg ) => {
+      if( this._destroying ) return
+      msg.status = this.parent.prtp.stats()
+      msg.status.instance = instance
+      this.connection.write( message.createmessage( modifiedmsg ) )
+      if (cb !== undefined) cb(msg)
+    } )
+  }
+
+
+  /**
+   * @private
+   * @param { object } msg
+   * @returns { Promise< Boolean > }
+   */
+  async _openchannel( msg ) {
+    this.connectionlength += 1
+    msg.forcelocal = true
+
+    const chan = await this.parent.prtp.openchannel( msg, ( cookie ) => {
+      // TODO: we might want to ensure the actual event has been written
+      // to the server before cleaning up the channel on our side?
+      this.send( { ...{ "id": chan.id, "uuid": chan.uuid }, ...cookie },
+        ( cookie ) => {
+          if ( "close" === cookie.action )  {
+            this.connectionlength -= 1
+            channels.delete( chan.uuid )
+
+            if( 0 == this.connectionlength && "listen" == this.mode ) {
+              this.parent.connections.delete( this.connectionid )
+              this.connection.destroy()
+            }
+          }
+        } )
+    } )
+    channels.set( chan.uuid, chan )
+    this.send( { ...chan, ...{ "action": "open" } } )
+
+    return true
+  }
+
+
+  /**
+   * @summary Connect to a server.
+   * @param {string} host
+   * @param {number} port
+   * @return {Promise} - Promise which resolves to an rtpnode
+  */
+  connect( host, port ) {
+    this.host = host
+    this.port = port
+    this.mode = "connect"
+
+    return new Promise( resolve => {
+
+      this.connection = net.createConnection( this.port, this.host )
+      this.connection.on( "data", this._onsocketdata.bind( this ) )
+
+      this.connection.setKeepAlive( true )
+
+      this.connection.on( "connect", () => {
+        this.send( {} )
+        resolve()
+        this._reconnecttime = 500 /* mS */
+      } )
+      
+      this.connection.on( "error", () => {
+        if( this._destroying ) return
+        this._runreconnect()
+      } )
+      this.connection.on( "close", () => {
+        if( this._destroying ) return
+        this._runreconnect()
+      } )
+    } )
+  }
+
+  /**
+   * @private
+   * @returns { void }
+   */
+  _reconnect() {
+    delete this._reconnecttimerid
+    this.connect( this.host, this.port )
+  }
+  
+  /**
+   * @private
+   * @returns { void }
+   */
+  _runreconnect() {
+    if( this._reconnecttimerid ) return
+    console.log( "Disconnected - trying to reconnect to " + this.host + ":" + this.port )
+
+    this._reconnecttimerid = setTimeout( this._reconnect.bind( this ), this._reconnecttime )
+
+    this._reconnecttime = this._reconnecttime * 2
+    if( this._reconnecttime > ( 1000 * 2 ) ) this._reconnecttime = this._reconnecttime / 2
+  }
+
+}
+
 /**
  * @summary An RTP node. We are a remote RTP node which waits for intruction from our server.
  */
@@ -38,7 +230,6 @@ class rtpnode {
     this.port = port
     this.instance = uuidv4()
     this.connections = new Map()
-    this.messagestate = message.newstate()
 
     /* pre callbacks are called when we receive an instruction from
     our server and we want to check if there is anything to do such as
@@ -50,42 +241,19 @@ class rtpnode {
     to our server - this is to, for example, upload a recording to a remote storage
     facility. */
     this._post = this._defaulthandler.bind( this )
-
-    /**
-     * @type { NodeJS.Timeout }
-     */
-    this._reconnecttimerid
   }
 
   /**
    * @summary Connect to a server.
-   * @param {number} port
    * @param {string} host
+   * @param {number} port
    * @return {Promise<rtpnode>} - Promise which resolves to an rtpnode
   */
-  connect( port, host ) {
-    this.host = host
-    this.port = port
-    this._destroying = false
-    this._reconnecttime = 500 /* mS */
-
-    return new Promise( resolve => {
-      this._onsocketreadypromiseresolve = resolve
-      const connection = net.createConnection( this.port, this.host )
-      this.connection = connection
-      this.connection.setKeepAlive( true )
-      this.connection.on( "connect", this._onsocketconnect.bind( this ) )
-      const con = {
-        connectionid: uuidv4(),
-        connection,
-        "connectionlength": 0,
-        "mode": "connect"
-      }
-      this.connections[ con.connectionid ] = con
-      this.connection.on( "data", this._onsocketdata.bind( this, con ) )
-      this.connection.on( "error", this._onsocketerror.bind( this ) )
-      this.connection.on( "close", this._onsocketclose.bind( this ) )
-    } )
+  async connect( host, port ) {
+    const con = rtpnodeconnection.create( this )
+    await con.connect( host, port )
+    this.connections.set( con.connectionid, con )
+    return this
   }
 
   /**
@@ -95,15 +263,12 @@ class rtpnode {
     let listenresolve
     const listenpromise = new Promise( ( r ) => listenresolve = r )
     this.server = net.createServer( ( connection ) => {
-      const con = {
-        connectionid: uuidv4(),
-        connection,
-        "connectionlength": 0,
-        "mode": "listen"
+      try {
+        const con = rtpnodeconnection.create( this, connection )
+        this.connections.set( con.connectionid, con )
+      } catch( e ) {
+        console.error( "Uncaught exception in node listen", e )
       }
-      this.connections[ con.connectionid ] = con
-      connection.setKeepAlive( true )
-      connection.on( "data", this._onsocketdata.bind( this, con ) )
     } )
 
     this.server.listen( this.port, this.address )
@@ -112,17 +277,6 @@ class rtpnode {
     return listenpromise
   }
 
-  /**
-   * @private
-   * @returns { void }
-   */
-  _onsocketconnect( /* sock */ ) {
-    //console.log( "Connected to " + this.host + ":" + this.port )
-    this.send( {}, this.connection )
-    this._onsocketreadypromiseresolve( this )
-    this._reconnecttime = 500 /* mS */
-  }
-
   /**
   * This callback is displayed as a global member.
   * @callback requestComplete
@@ -159,22 +313,6 @@ class rtpnode {
     this._post = cb
   }
 
-  /**
-   * Send a message back to the main server, include stats to help with load balancing.
-   * @param { object } msg
-   * @param { object } connection
-   * @returns { void }
-   */
-  send( msg, connection, cb = undefined ) {
-    this._post( msg, ( modifiedmsg ) => {
-      if( this._destroying ) return
-      msg.status = this.prtp.stats()
-      msg.status.instance = instance
-      connection.write( message.createmessage( modifiedmsg ) )
-      if (cb !== undefined) cb(msg)
-    } )
-  }
-
   /**
    * @summary Destroy this node
    * @returns { void }
@@ -183,24 +321,10 @@ class rtpnode {
     this._destroying = true
     nodeinterface.clean()
 
-    if( this._reconnecttimerid ) clearTimeout( this._reconnecttimerid )
-    if( this.connection ) this.connection.destroy()
-    this.connections.forEach( ( connection ) => {
-      connection.destroy()
-    } )
-    if ( this.server ) this.server.close()
-  }
-
-  /**
-   * 
-   * @param { object } msg 
-   * @param { object } con
-   * @returns { Promise< Boolean > }
-   */
-  async _processmessage( msg, con ) {
-    if( "open" == msg.channel ) return await this._openchannel( msg, con )
+    this.connections.forEach( ( con ) => con.destroy() )
+    this.connections.clear()
 
-    return this._updatechannel( msg, con )
+    if ( this.server ) this.server.close()
   }
 
   /**
@@ -211,137 +335,6 @@ class rtpnode {
   _defaulthandler( msg, cb ) {
     cb( msg )
   }
-
-  /**
-   * @private
-   * @returns { void }
-   */
-  _reconnect() {
-
-    delete this._reconnecttimerid
-    this.connection = net.createConnection( this.port, this.host )
-      .on( "error", () => {
-        this._runreconnect()
-      } )
-
-    this.connection.setKeepAlive( true )
-
-    this.connection.on( "connect", this._onsocketconnect.bind( this ) )
-    this.connection.on( "data", this._onsocketdata.bind( this ) )
-    this.connection.on( "error", this._onsocketerror.bind( this ) )
-    this.connection.on( "close", this._onsocketclose.bind( this ) )
-  }
-
-  /**
-   * @private
-   * @returns { void }
-   */
-  _runreconnect() {
-    if( this._reconnecttimerid ) return
-    console.log( "Disconnected - trying to reconnect to " + this.host + ":" + this.port )
-
-    this._reconnecttimerid = setTimeout( this._reconnect.bind( this ), this._reconnecttime )
-
-    this._reconnecttime = this._reconnecttime * 2
-    if( this._reconnecttime > ( 1000 * 2 ) ) this._reconnecttime = this._reconnecttime / 2
-  }
-
-  /**
-   * @private
-   * @returns { void }
-   */
-  _onsocketclose() {
-    if( this._destroying ) return
-    this._runreconnect()
-  }
-
-  /**
-   * Reconnect on failure.
-   * @private
-   * @returns { void }
-   */
-  _onsocketerror() {
-    if( this._destroying ) return
-    this._runreconnect()
-  }
-
-  /**
-   * @privateopenchannel
-   * @param { Buffer } data
-   * @param { object } con 
-   * @returns { void }
-   */
-  _onsocketdata( con, data ) {
-    message.parsemessage( this.messagestate, data, ( msg ) => {
-      try {
-        this._pre( msg, ( modifiedmsg ) => {
-          this._processmessage( modifiedmsg, con )
-        } )
-      } catch( e ) {
-        console.error( "Unhandled exception in babble-rtp", e )
-      }
-    } )
-  }
-
-  /**
-   * @private
-   * @param { object } msg
-   * @param { object } con
-   * @returns { Promise< Boolean > }
-   */
-  async _openchannel( msg, con ) {
-    con.connectionlength += 1
-    msg.forcelocal = true
-
-    const chan = await this.prtp.openchannel( msg, ( cookie ) => {
-      // TODO: we might want to ensure the actual event has been written
-      // to the server before cleaning up the channel on our side?
-      this.send( { ...{ "id": chan.id, "uuid": chan.uuid }, ...cookie },
-        con.connection,
-        ( cookie ) => {
-          if ( "close" === cookie.action )  {
-            con.connectionlength -= 1
-            channels.delete( chan.uuid )
-
-            if( 0 == con.connectionlength && "listen" == con.mode ) {
-              this.connections.delete( con.instance )
-              con.connection.destroy()
-            }
-          }
-        } )
-    } )
-    channels.set( chan.uuid, chan )
-    this.send( { ...chan, ...{ "action": "open" } }, con.connection )
-
-    return true
-  }
-
-  /**
-   * @private
-   * @param { object } msg
-   * @param { object } con 
-   * @returns boolean
-   */
-  _updatechannel( msg, con ) {
-
-    if( undefined === msg.channel ) return false
-    if( undefined === msg.uuid ) return false
-
-    const chan = channels.get( msg.uuid )
-    if( undefined == chan ) return false
-
-    if( msg.channel in channelmap ) {
-      channelmap[ msg.channel ]( chan, msg )
-    } else {
-      const channelidentifiers = {
-        "id": msg.id,
-        "uuid": msg.uuid
-      }
-      this.send( { ...{ "error": "Unknown method" }, ...channelidentifiers }, con.connection )
-    }
-
-    return true
-  }
 }
 
 /**
@@ -386,7 +379,7 @@ class nodeinterface {
     if( nodeinterface._n ) return new Promise( r => r( nodeinterface._n ) )
 
     nodeinterface._n = new rtpnode( this.prtp )
-    return nodeinterface._n.connect( port, host )
+    return nodeinterface._n.connect( host, port )
   }
 
   /**

package/lib/server.js

@@ -5,7 +5,7 @@ const { v4: uuidv4 } = require( "uuid" )
 
 const EventEmitter = require( "events" )
 
-const message = require( "./message.js" )
+const message = require( "./message" )
 
 /**
  * Node host address and port object
@@ -599,11 +599,10 @@ class channel {
 
   /**
    * 
-   * @param { object } msg 
    * @returns { void }
    * @private
    */
-  _runclose( msg ) {
+  _runclose() {
     if( undefined !== this.openresolve ) {
       this.openresolve()
       delete this.openresolve
@@ -634,7 +633,7 @@ class channel {
     this.em.emit( "all", msg )
     this.em.emit( msg.action, msg )
 
-    if( "close" == msg.action ) this._runclose( msg )
+    if( "close" == msg.action ) this._runclose()
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/projectrtp",
-  "version": "2.4.3",
+  "version": "2.4.8",
   "description": "A scalable Node addon RTP server",
   "main": "index.js",
   "directories": {
@@ -10,7 +10,7 @@
   },
   "scripts": {
     "test": "./node_modules/mocha/bin/_mocha test/**/*.js --check-leaks",
-    "github:check": "node test/basictests.js; npm update; npm test",
+    "github:check": "node test/basictests.js; npm update; ./node_modules/mocha/bin/_mocha test/**/*.js --check-leaks --exit",
     "check": "tsc --checkJs --noEmit --target es6 --module commonjs --skipLibCheck *.js test/**/*.js; ./node_modules/eslint/bin/eslint.js ./",
     "docs": "jsdoc -c jsdoc.conf.json ./README.md",
     "stress": "node stress/index.js",
@@ -25,14 +25,14 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tinpotnick/projectrtp.git"
+    "url": "git+https://github.com/babblevoice/projectrtp.git"
   },
   "author": "Nick Knight",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/tinpotnick/projectrtp/issues"
+    "url": "https://github.com/babblevoice/projectrtp/issues"
   },
-  "homepage": "https://github.com/tinpotnick/projectrtp#readme",
+  "homepage": "https://github.com/babblevoice/projectrtp#readme",
   "dependencies": {
     "uuid": "^9.0.0"
   },

package/test/basictests.js

@@ -23,8 +23,23 @@ async function testopen() {
   }
 }
 
+let retval = 0
+console.log( "Running project RTP" )
 prtp.projectrtp.run()
-testopen()
+
+console.log( "Test open channel" )
+
+try{
+  testopen()
+} catch( e ) {
+  console.log( e )
+  retval = 1
+}
+
+console.log( "Shutting down projectrtp" )
 prtp.projectrtp.shutdown()
+console.log( "Shutdown - good to proceed" )
+
+process.exit( retval )
 
 

package/test/interface/projectrtpchannel.js

@@ -96,7 +96,7 @@ describe( "rtpchannel", function() {
     await finished
   } )
 
-  it( "call create channel and check the structure of the returned object ( server as listener )", async function() {
+  it( "call create channel and check the structure of the returned object - server as listener", async function() {
 
     const ourport = 45433
     await projectrtp.server.listen( ourport, "127.0.0.1" )
@@ -119,7 +119,7 @@ describe( "rtpchannel", function() {
     await server.destroy()
   } )
 
-  it( "call create channel and check the structure of the returned object ( node as listener )", async function() {
+  it( "call create channel and check the structure of the returned object - node as listener", async function() {
 
     const ourport = 45432
     projectrtp.server.clearnodes()
@@ -437,7 +437,7 @@ describe( "rtpchannel", function() {
     expect( closedstats.stats.in.count ).to.equal( 300 )
     expect( closedstats.stats.out.count ).to.be.within( 180, 190 )
     expect( totalsndiff ).to.equal( 0 ) // received should be reordered
-    expect( totaltsdiff ).to.equal( 18400 )
+    expect( totaltsdiff ).to.be.within( 18240, 18400 ) // Allow some loss in test
     expect( lastsn - firstsn ).to.be.within( 180, 192 )
   } )
 

package/test/interface/projectrtpdtls.js

@@ -432,7 +432,7 @@ describe( "dtls", function() {
     await finished
 
     expect( clientcclose.stats.in.count ).to.be.above( 10 )
-    expect( clientcclose.stats.in.skip ).to.equal( 0 )
+    expect( clientcclose.stats.in.skip ).to.be.below( 2 ) // allow a little loss in test
 
   } )
 } )

package/test/interface/projectrtpdtmf.js

@@ -338,7 +338,7 @@ describe( "dtmf", function() {
   } )
 
 
-  it( "Send multiple 2833 DTMF and check event", function( done ) {
+  it( "Send multiple 2833 DTMF and check event", async function() {
 
     /* create our RTP/UDP endpoint */
     const server = dgram.createSocket( "udp4" )
@@ -348,53 +348,58 @@ describe( "dtmf", function() {
     this.slow( 2500 )
 
     server.bind()
-    server.on( "listening", async function() {
+    await new Promise( ( resolve ) => { server.on( "listening", () => resolve() ) } )
 
-      const ourport = server.address().port
+    const ourport = server.address().port
 
-      let expectedmessagecount = 0
-      const expectedmessages = [
-        { action: "telephone-event", event: "4" },
-        { action: "telephone-event", event: "5" },
-        { action: "close" }
-      ]
+    const receivedmessages = []
+    const channel = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": ourport, "codec": 0 } }, function( d ) {
+      receivedmessages.push( d )
+      if( "close" === d.action ) {
+        server.close()
+      }
+    } )
 
-      const channel = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": ourport, "codec": 0 } }, function( d ) {
-        expect( d ).to.deep.include( expectedmessages[ expectedmessagecount ] )
-        expectedmessagecount++
+    expect( channel.echo() ).to.be.true
 
-        if( "close" === d.action ) {
-          server.close()
-          done()
-        }
-      } )
+    /* send a packet every 20mS x 50 */
+    for( let i = 0;  13 > i; i ++ ) {
+      sendpk( i, i*160, i*20, channel.local.port, server )
+    }
 
-      expect( channel.echo() ).to.be.true
+    /* DTMF every 50mS */
+    senddtmf( 13, 12*160, 13*20, channel.local.port, server, false, "4" )
+    sendpk( 14, 13*160, 13*20, channel.local.port, server )
+    sendpk( 15, 14*160, 14*20, channel.local.port, server )
+    senddtmf( 16, 14*160, (13*20)+50, channel.local.port, server, false, "4" )
+    // Packet loss
+    // senddtmf( 15, 12 * 160, 15*20, channel.port, server, true, "4" )
 
-      /* send a packet every 20mS x 50 */
-      for( let i = 0;  13 > i; i ++ ) {
-        sendpk( i, i*160, i*20, channel.local.port, server )
-      }
+    for( let i = 17;  30 > i; i ++ ) {
+      sendpk( i, (i-2)*160, (i-2)*20, channel.local.port, server )
+    }
 
-      senddtmf( 13, 12 * 160, 13*20, channel.local.port, server, false, "4" )
-      senddtmf( 14, 12 * 160, 14*20, channel.local.port, server, false, "4" )
-      // Packet loss
-      // senddtmf( 15, 12 * 160, 15*20, channel.port, server, true, "4" )
+    senddtmf( 31, 29*160, 29*20, channel.local.port, server, false, "5" )
+    sendpk( 32, 29*160, 29*20, channel.local.port, server )
+    sendpk( 33, 30*160, 30*20, channel.local.port, server )
+    senddtmf( 34, 30*160, (29*20)+50, channel.local.port, server, false, "5" )
+    sendpk( 35, 31*160, 31*20, channel.local.port, server )
+    sendpk( 36, 32*160, 32*20, channel.local.port, server )
+    senddtmf( 37, 32*160, (29*20)+100, channel.local.port, server, true, "5" )
 
-      for( let i = 16;  23 > i; i ++ ) {
-        sendpk( i, i*160, (i-3)*20, channel.local.port, server )
-      }
+    for( let i = 37; 45 > i; i ++ ) {
+      sendpk( i, i*160, (i-6)*20, channel.local.port, server )
+    }
 
-      senddtmf( 23, 22 * 160, 23*20, channel.local.port, server, false, "5" )
-      senddtmf( 24, 22 * 160, 24*20, channel.local.port, server, false, "5" )
-      senddtmf( 25, 22 * 160, 25*20, channel.local.port, server, true, "5" )
+    setTimeout( () => channel.close(), 1100 )
+    await new Promise( resolve => { server.on( "close", resolve ) } )
 
-      for( let i = 26;  33 > i; i ++ ) {
-        sendpk( i, i*160, (i-6)*20, channel.local.port, server )
-      }
+    expect( receivedmessages[ 0 ].action ).to.equal( "telephone-event" )
+    expect( receivedmessages[ 0 ].event ).to.equal( "4" )
+    expect( receivedmessages[ 1 ].action ).to.equal( "telephone-event" )
+    expect( receivedmessages[ 1 ].event ).to.equal( "5" )
+    expect( receivedmessages[ 2 ].action ).to.equal( "close" )
 
-      setTimeout( () => channel.close(), 1000 )
-    } )
   } )
 
   it( "Lose end packet", async function() {
@@ -686,9 +691,6 @@ describe( "dtmf", function() {
 
     const receveiedmessages = []
 
-    let done
-    const finished = new Promise( ( r ) => { done = r } )
-
     const channela = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointa.address().port, "codec": 0 } }, function( d ) {
       receveiedmessages.push( d )
 
@@ -702,7 +704,11 @@ describe( "dtmf", function() {
 
     const channelc = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointc.address().port, "codec": 97 } }, function( d ) {
       expect( d.action).to.not.equal( "telephone-event" )
-      if( "close" === d.action ) done()
+      if( "close" === d.action ) {
+        endpointa.close()
+        endpointb.close()
+        endpointc.close()
+      }
     } )
 
     /* mix */
@@ -735,32 +741,32 @@ describe( "dtmf", function() {
     senddtmf( 13, 13*160, 13*20, channela.local.port, endpointa, false, "4" )
     sendpk( 14, 13*160, 13*20, channela.local.port, endpointa, 0 )
     sendpk( 15, 14*160, 14*20, channela.local.port, endpointa, 0 )
-    senddtmf( 16, (16*160), (13*20)+50, channela.local.port, endpointa, false, "4" )
-    sendpk( 17, 15*160, 15*20, channela.local.port, endpointa, 0 )
+    sendpk( 16, 15*160, 15*20, channela.local.port, endpointa, 0 )
+    senddtmf( 17, (15*160), (13*20)+50, channela.local.port, endpointa, false, "4" )
     sendpk( 18, 16*160, 16*20, channela.local.port, endpointa, 0 )
-    senddtmf( 19, (19*160), (13*20)+100, channela.local.port, endpointa, true, "4" )
-    sendpk( 20, 17*160, 17*20, channela.local.port, endpointa, 0 )
+    sendpk( 19, 17*160, 17*20, channela.local.port, endpointa, 0 )
+    senddtmf( 20, (17*160), (13*20)+100, channela.local.port, endpointa, true, "4" )
     sendpk( 21, 18*160, 18*20, channela.local.port, endpointa, 0 )
-    senddtmf( 22, (22*160)+20, (13*20)+150, channela.local.port, endpointa, true, "4" )
-    sendpk( 23, 19*160, 19*20, channela.local.port, endpointa, 0 )
+    sendpk( 22, 19*160, 19*20, channela.local.port, endpointa, 0 )
+    sendpk( 23, 20*160, 20*20, channela.local.port, endpointa, 0 )
+    senddtmf( 24, (20*160), (13*20)+150, channela.local.port, endpointa, true, "4" )
+    sendpk( 25, 21*160, 21*20, channela.local.port, endpointa, 0 )
+    sendpk( 26, 22*160, 22*20, channela.local.port, endpointa, 0 )
+    sendpk( 27, 23*160, 23*20, channela.local.port, endpointa, 0 )
+    sendpk( 28, 24*160, 24*20, channela.local.port, endpointa, 0 )
+    sendpk( 29, 25*160, 25*20, channela.local.port, endpointa, 0 )
 
-    senddtmf( 24, 20*160, 20*20, channela.local.port, endpointa, false, "5" )
-    sendpk( 25, 20*160, 20*20, channela.local.port, endpointa, 0 )
-    sendpk( 26, 21*160, 21*20, channela.local.port, endpointa, 0 )
-    senddtmf( 27, (27*160), (20*20)+50, channela.local.port, endpointa, false, "5" )
-    sendpk( 28, 22*160, 22*20, channela.local.port, endpointa, 0 )
-    sendpk( 29, 23*160, 23*20, channela.local.port, endpointa, 0 )
-    senddtmf( 30, (30*160), (20*20)+100, channela.local.port, endpointa, true, "5" )
-    sendpk( 31, 24*160, 24*20, channela.local.port, endpointa, 0 )
-    sendpk( 32, 25*160, 25*20, channela.local.port, endpointa, 0 )
-    senddtmf( 33, (33*160), (20*20)+150, channela.local.port, endpointa, true, "5" )
-    sendpk( 34, 26*160, 26*20, channela.local.port, endpointa, 0 )
-    sendpk( 35, 27*160, 27*20, channela.local.port, endpointa, 0 )
-    sendpk( 36, 28*160, 28*20, channela.local.port, endpointa, 0 )
-    sendpk( 37, 29*160, 29*20, channela.local.port, endpointa, 0 )
-    sendpk( 38, 30*160, 30*20, channela.local.port, endpointa, 0 )
-    sendpk( 39, 31*160, 31*20, channela.local.port, endpointa, 0 )
-    sendpk( 40, 32*160, 32*20, channela.local.port, endpointa, 0 )
+    senddtmf( 30, 25*160, 25*20, channela.local.port, endpointa, false, "5" )
+    sendpk( 31, 26*160, 26*20, channela.local.port, endpointa, 0 )
+    sendpk( 32, 27*160, 27*20, channela.local.port, endpointa, 0 )
+    senddtmf( 33, (27*160), (25*20)+50, channela.local.port, endpointa, false, "5" )
+    sendpk( 34, 28*160, 28*20, channela.local.port, endpointa, 0 )
+    sendpk( 35, 29*160, 29*20, channela.local.port, endpointa, 0 )
+    senddtmf( 36, (29*160), (25*20)+100, channela.local.port, endpointa, true, "5" )
+    sendpk( 37, 30*160, 30*20, channela.local.port, endpointa, 0 )
+    sendpk( 38, 31*160, 31*20, channela.local.port, endpointa, 0 )
+    sendpk( 39, 32*160, 32*20, channela.local.port, endpointa, 0 )
+    senddtmf( 40, (32*160), (25*20)+150, channela.local.port, endpointa, true, "5" )
     sendpk( 41, 33*160, 33*20, channela.local.port, endpointa, 0 )
     sendpk( 42, 34*160, 34*20, channela.local.port, endpointa, 0 )
     sendpk( 43, 35*160, 35*20, channela.local.port, endpointa, 0 )
@@ -774,15 +780,22 @@ describe( "dtmf", function() {
     sendpk( 51, 43*160, 43*20, channela.local.port, endpointa, 0 )
     sendpk( 52, 44*160, 44*20, channela.local.port, endpointa, 0 )
     sendpk( 53, 45*160, 45*20, channela.local.port, endpointa, 0 )
+    sendpk( 54, 46*160, 46*20, channela.local.port, endpointa, 0 )
+    sendpk( 55, 47*160, 47*20, channela.local.port, endpointa, 0 )
+    sendpk( 56, 48*160, 48*20, channela.local.port, endpointa, 0 )
+    sendpk( 57, 49*160, 49*20, channela.local.port, endpointa, 0 )
+    sendpk( 58, 50*160, 50*20, channela.local.port, endpointa, 0 )
+    sendpk( 59, 52*160, 51*20, channela.local.port, endpointa, 0 )
 
     await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1200 ) } )
 
     channela.close()
-    endpointa.close()
-    endpointb.close()
-    endpointc.close()
 
-    await finished
+    await Promise.all( [
+      new Promise( resolve => { endpointa.on( "close", resolve ) } ),
+      new Promise( resolve => { endpointb.on( "close", resolve ) } ),
+      new Promise( resolve => { endpointc.on( "close", resolve ) } )
+    ] )
 
     expect( endpointapkcount ).to.be.within( 59, 70 )
     expect( endpointbpkcount ).to.be.within( 59, 70 )

package/test/interface/projectrtpfullserver.js

@@ -0,0 +1,83 @@
+
+const prtp = require( "../../index" )
+const node = require( "../../lib/node" )
+const expect = require( "chai" ).expect
+
+/**
+ * Test file to run tests acting as a remote note. Starts a babble-rtp node in the background
+ * before any tests begin then runs tests to open, play, polly etc.
+ */
+describe( "server connect interface", () => {
+
+  before( async () => {
+    const host = "127.0.0.1"
+    const port = 9002
+    await prtp.projectrtp.node.listen( host, port )
+    prtp.projectrtp.server.addnode( { host, port} )
+    
+  } )
+
+  after( () => {
+
+    prtp.projectrtp.server.clearnodes()
+    node.interface.destroy()
+  } )
+
+  it( "server connect and open channel", async function () {
+    this.timeout( 6000 )
+    this.slow( 3000 )
+
+    const totalotherchannelcount = 100
+    let chanclosecount = 0
+    let allchannelsclosedresolve
+    const allchannelsclosed = new Promise( resolve => allchannelsclosedresolve = resolve )
+    const onclose = ( e ) => {
+      if( "close" == e.action ) chanclosecount++
+      if( totalotherchannelcount == chanclosecount ) allchannelsclosedresolve()
+    }
+
+    // A very short wav file
+    prtp.projectrtp.tone.generate( "350+440*0.5:100", "/tmp/serverconnecttestwav.wav" )
+    prtp.projectrtp.tone.generate( "350+440*0.5:100", "/tmp/otherserverconnecttestwav.wav" )
+
+    const channels = []
+    for( let i = 0; totalotherchannelcount > i; i++ ) {
+      channels.push( await prtp.projectrtp.openchannel( onclose ) )
+    }
+
+    for( let i = 0; 3 > i; i++ ) {
+      let done
+      const finished = new Promise( resolve => done = resolve )
+  
+      const receivedmessages = []
+      const chan = await prtp.projectrtp.openchannel( ( e ) => {
+        receivedmessages.push( e )
+        if( "play" == e.action && "end" == e.event ) chan.close()
+        if( "close" == e.action ) done()
+      } )
+  
+      chan.play( { "interupt":true, "files": [ { "wav": "/tmp/serverconnecttestwav.wav" }, { "wav": "/tmp/otherserverconnecttestwav.wav" } ] } )
+  
+      await finished
+
+      //console.log(receivedmessages)
+      expect( receivedmessages.length ).to.equal( 3 )
+      expect( receivedmessages[ 0 ].action ).to.equal( "play" )
+      expect( receivedmessages[ 0 ].event ).to.equal( "start" )
+      expect( receivedmessages[ 0 ].reason ).to.equal( "new" )
+      expect( receivedmessages[ 1 ].action ).to.equal( "play" )
+      expect( receivedmessages[ 1 ].event ).to.equal( "end" )
+      expect( receivedmessages[ 1 ].reason ).to.equal( "completed" )
+      expect( receivedmessages[ 2 ].action ).to.equal( "close" )
+      expect( receivedmessages[ 2 ].reason ).to.equal( "requested" )
+    }
+
+    for( const chan of channels ) {
+      chan.close()
+    }
+
+    await allchannelsclosed
+    expect( chanclosecount ).to.equal( totalotherchannelcount )
+  } )
+
+} )