@babblevoice/projectrtp 2.4.10 → 2.4.12

package/lib/server.js

@@ -12,6 +12,7 @@ const message = require( "./message" )
  * @typedef { object } nodehost
  * @property { number } port
  * @property { string } host
+ * @property { string } [ instance ]
  */
 
 const nodeconnectiontype = { "listen": 1, "connect": 2 }
@@ -221,7 +222,7 @@ class channel {
 
       newchannel.connection = {
         sock: net.createConnection( connecttonode.port, connecttonode.host ),
-        "instance": uuidv4(),
+        "instance": connecttonode.instance,
         "rejectconnections": false,
         "status": {},
         "type": nodeconnectiontype.connect
@@ -243,6 +244,11 @@ class channel {
             if ( receivedmsg.id === chnl.id ) chnl._on( receivedmsg )
           }
 
+          /* correct the instance id - i.e. in a proxy enviroment (docker swarm) instance may differ */
+          if( receivedmsg && receivedmsg.status && receivedmsg.status.instance ) {
+            newchannel.connection.instance = receivedmsg.status.instance
+          }
+
           if ( openresolve ) openresolve( newchannel )
         } )
       } )
@@ -271,7 +277,7 @@ class channel {
 
     options.channel = "open"
 
-    const resolvepromise = new Promise( ( res ) => {
+    const resolvepromise = new Promise( ( resolve ) => {
 
       const newchannel = new channel()
       if( cb ) newchannel.em.on( "all", cb )
@@ -279,7 +285,7 @@ class channel {
       newchannel.connection = this.connection
       newchannel.channels = this.channels
       newchannel.channels.push( newchannel )
-      newchannel.openresolve = res
+      newchannel.openresolve = resolve
       newchannel._write( options )
     } )
 
@@ -979,6 +985,8 @@ class serverinterface {
    */
   addnode( node ) {
     if ( !serverinterface._s ) serverinterface._s = new rtpserver()
+
+    node.instance = uuidv4()
     listeningnodes.push( node )
     return serverinterface._s
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/projectrtp",
-  "version": "2.4.10",
+  "version": "2.4.12",
   "description": "A scalable Node addon RTP server",
   "main": "index.js",
   "directories": {

package/test/interface/rtpproxymultinode.js

@@ -42,15 +42,13 @@ describe( "rtpproxy multi node", function() {
     const rtp1 = new mocknode()
     const rtp2 = new mocknode()
 
-    const listenport = 32443
-
     const rtpreceveivedmessages = []
     let ouruuid = 0
 
-    rtp1.setmessagehandler( "open", ( msg ) => {
+    rtp1.setmessagehandler( "open", ( msg, sendmessage ) => {
       msg.node = "rtp1"
       rtpreceveivedmessages.push ( msg )
-      rtp1.sendmessage( {
+      sendmessage( {
         "action": "open",
         "id": msg.id,
         "uuid": ""+ouruuid++,
@@ -67,10 +65,10 @@ describe( "rtpproxy multi node", function() {
       rtpreceveivedmessages.push ( msg )
     } )
 
-    rtp1.setmessagehandler( "unmix", ( msg ) => {
+    rtp1.setmessagehandler( "unmix", ( msg, sendmessage ) => {
       msg.node = "rtp1"
       rtpreceveivedmessages.push ( msg )
-      rtp1.sendmessage( {
+      sendmessage( {
         "action": "unmix",
         "id": msg.id,
         "uuid": msg.uuid,
@@ -87,20 +85,20 @@ describe( "rtpproxy multi node", function() {
       rtpreceveivedmessages.push ( msg )
     } )
 
-    rtp1.setmessagehandler( "close", ( msg ) => {
+    rtp1.setmessagehandler( "close", ( msg, sendmessage ) => {
       msg.node = "rtp1"
       rtpreceveivedmessages.push ( msg )
-      rtp1.sendmessage( {
+      sendmessage( {
         "action": "close",
         "id": msg.id,
         "uuid": msg.uuid,
       } )
     } )
 
-    rtp2.setmessagehandler( "open", ( msg ) => {
+    rtp2.setmessagehandler( "open", ( msg, sendmessage ) => {
       msg.node = "rtp2"
       rtpreceveivedmessages.push( msg )
-      rtp2.sendmessage( {
+      sendmessage( {
         "action": "open",
         "id": msg.id,
         "uuid": ""+ouruuid++,
@@ -117,10 +115,10 @@ describe( "rtpproxy multi node", function() {
       rtpreceveivedmessages.push( msg )
     } )
 
-    rtp2.setmessagehandler( "unmix", ( msg ) => {
+    rtp2.setmessagehandler( "unmix", ( msg, sendmessage ) => {
       msg.node = "rtp2"
       rtpreceveivedmessages.push( msg )
-      rtp2.sendmessage( {
+      sendmessage( {
         "action": "unmix",
         "id": msg.id,
         "uuid": msg.uuid,
@@ -137,17 +135,18 @@ describe( "rtpproxy multi node", function() {
       rtpreceveivedmessages.push( msg )
     } )
 
-    rtp2.setmessagehandler( "close", ( msg ) => {  
+    rtp2.setmessagehandler( "close", ( msg, sendmessage ) => {  
       msg.node = "rtp2"
       rtpreceveivedmessages.push( msg )
 
-      rtp2.sendmessage( {
+      sendmessage( {
         "action": "close",
         "uuid": msg.uuid,
         "id": msg.id
       } )
     } )
 
+    const listenport = 32443
     const p = await prtp.proxy.listen( undefined, "127.0.0.1", listenport )
     await rtp1.connect( listenport )
     await rtp2.connect( listenport )
@@ -168,10 +167,240 @@ describe( "rtpproxy multi node", function() {
     expect( actual ).to.deep.equal( { "mix": 2, "open": 4, "unmix": 4, "close": 4, "remote": 2 } )
 
     /* Clean up */
-    rtp1.destroy()
-    rtp2.destroy()
-    p.destroy()
+    await rtp1.destroy()
+    await rtp2.destroy()
+    await p.destroy()
+
+  } )
+
+  it( "2 node 2 channel simple mix rtp server listening on same node", async function() {
+    
+    /*
+      We need to check that the nodes are maintained when using the same rtp server.
+    */
+
+    const actual = { "mix": 0, "open": 0, "unmix": 0, "close": 0, "remote": 0 }
+
+    const rtp1 = new mocknode()
+    const rtp2 = new mocknode()
 
+    const rtpreceveivedmessages = []
+    let ouruuid = 0
+
+    rtp1.setmessagehandler( "open", ( msg, sendmessage ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+      sendmessage( {
+        "action": "open",
+        "id": msg.id,
+        "uuid": ""+ouruuid++,
+        "local": {
+          "port": 10002,
+          "address": "192.168.0.141"
+        },
+        "status": rtp1.ourstats
+      } )
+    } )
+
+    rtp1.setmessagehandler( "mix", ( msg ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+    } )
+
+    rtp1.setmessagehandler( "unmix", ( msg, sendmessage ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+      sendmessage( {
+        "action": "unmix",
+        "id": msg.id,
+        "uuid": msg.uuid,
+        "local": {
+          "port": 10002,
+          "address": "192.168.0.141"
+        },
+        "status": rtp1.ourstats
+      } )
+    } )
+
+    rtp1.setmessagehandler( "remote", ( msg ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+    } )
+
+    rtp1.setmessagehandler( "close", ( msg, sendmessage ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+      sendmessage( {
+        "action": "close",
+        "id": msg.id,
+        "uuid": msg.uuid,
+      } )
+    } )
+
+    rtp2.setmessagehandler( "open", ( msg, sendmessage ) => {
+      msg.node = "rtp2"
+      rtpreceveivedmessages.push( msg )
+      sendmessage( {
+        "action": "open",
+        "id": msg.id,
+        "uuid": ""+ouruuid++,
+        "local": {
+          "port": 10004,
+          "address": "192.168.0.141"
+        },
+        "status": rtp2.ourstats
+      } )
+    } )
+
+    rtp2.setmessagehandler( "mix", ( msg ) => {
+      msg.node = "rtp2"
+      rtpreceveivedmessages.push( msg )
+    } )
+
+    rtp2.setmessagehandler( "unmix", ( msg, sendmessage ) => {
+      msg.node = "rtp2"
+      rtpreceveivedmessages.push( msg )
+      sendmessage( {
+        "action": "unmix",
+        "id": msg.id,
+        "uuid": msg.uuid,
+        "local": {
+          "port": 10002,
+          "address": "192.168.0.141"
+        },
+        "status": rtp2.ourstats
+      } )
+    } )
+
+    rtp2.setmessagehandler( "remote", ( msg ) => {
+      msg.node = "rtp2"
+      rtpreceveivedmessages.push( msg )
+    } )
+
+    rtp2.setmessagehandler( "close", ( msg, sendmessage ) => {  
+      msg.node = "rtp2"
+      rtpreceveivedmessages.push( msg )
+
+      sendmessage( {
+        "action": "close",
+        "uuid": msg.uuid,
+        "id": msg.id
+      } )
+    } )
+
+    const listenport1 = await rtp1.listen( 0 )
+    const listenport2 = await rtp2.listen( 0 )
+    prtp.proxy.addnode( { "host": "127.0.0.1", "port": listenport1 } )
+    prtp.proxy.addnode( { "host": "127.0.0.1", "port": listenport2 } )
+
+    const channel1 = await prtp.openchannel()
+    const channel2 = await channel1.openchannel()
+    await channel1.mix( channel2 )
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1000 ) } )
+    channel1.unmix()
+    channel2.unmix()
+
+    channel1.close()
+    channel2.close()
+
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 10 ) } )
+
+    for ( const msg of rtpreceveivedmessages ) actual[ msg.channel ] += 1
+    expect( actual ).to.deep.equal( { "mix": 1, "open": 2, "unmix": 2, "close": 2, "remote": 0 } )
+
+    /* Clean up */
+    await rtp1.destroy()
+    await rtp2.destroy()
+
+    prtp.proxy.clearnodes()
+
+  } )
+
+  it( "2 node 2 channel connect to same rtp server not broken", async function() {
+
+    /*
+      We need to check that the nodes are maintained when using the same rtp server.
+    */
+
+    const actual = { "mix": 0, "open": 0, "unmix": 0, "close": 0, "remote": 0 }
+
+    const rtp1 = new mocknode()
+
+    const rtpreceveivedmessages = []
+    let ouruuid = 0
+
+    rtp1.setmessagehandler( "open", ( msg, sendmessage ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+      sendmessage( {
+        "action": "open",
+        "id": msg.id,
+        "uuid": ""+ouruuid++,
+        "local": {
+          "port": 10002,
+          "address": "192.168.0.141"
+        },
+        "status": rtp1.ourstats
+      } )
+    } )
+
+    rtp1.setmessagehandler( "mix", ( msg ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+    } )
+
+    rtp1.setmessagehandler( "unmix", ( msg, sendmessage ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+      sendmessage( {
+        "action": "unmix",
+        "id": msg.id,
+        "uuid": msg.uuid,
+        "local": {
+          "port": 10002,
+          "address": "192.168.0.141"
+        },
+        "status": rtp1.ourstats
+      } )
+    } )
+
+    rtp1.setmessagehandler( "remote", ( msg ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+    } )
+
+    rtp1.setmessagehandler( "close", ( msg, sendmessage ) => {
+      msg.node = "rtp1"
+      rtpreceveivedmessages.push ( msg )
+      sendmessage( {
+        "action": "close",
+        "id": msg.id,
+        "uuid": msg.uuid,
+      } )
+    } )
+
+    const listenport = await rtp1.listen( 0 )
+    prtp.proxy.addnode( { "host": "127.0.0.1", "port": listenport } )
+
+    const channel1 = await prtp.openchannel()
+    const channel2 = await prtp.openchannel()
+
+    await channel1.mix( channel2 )
+    await new Promise( ( resolve ) => { setTimeout( resolve, 1000 ) } )
+    channel1.unmix()
+    channel2.unmix()
+
+    channel1.close()
+    channel2.close()
+
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 10 ) } )
+
+    for ( const msg of rtpreceveivedmessages ) actual[ msg.channel ] += 1
+    expect( actual ).to.deep.equal( { "mix": 1, "open": 2, "unmix": 2, "close": 2, "remote": 0 } )
+
+    /* Clean up */
+    await rtp1.destroy()
+    prtp.proxy.clearnodes()
   } )
 
   it( "2 node 1 channel on one, 2 channels other", async function() {
@@ -352,10 +581,9 @@ describe( "rtpproxy multi node", function() {
     expect( actual ).to.deep.equal( { "mix": 3, "open": 5, "unmix": 5, "close": 5, "remote": 2 } )
 
     /* Clean up */
-    rtp1.destroy()
-    rtp2.destroy()
-    p.destroy()
-       
+    await rtp1.destroy()
+    await rtp2.destroy()
+    await p.destroy()
 
   } )
 
@@ -598,9 +826,9 @@ describe( "rtpproxy multi node", function() {
 
 
     /* Clean up */
-    rtp1.destroy()
-    rtp2.destroy()
-    p.destroy()
+    await rtp1.destroy()
+    await rtp2.destroy()
+    await p.destroy()
       
   } )
 } )

package/test/interface/rtpproxyserver.js

@@ -469,9 +469,9 @@ describe( "rtpproxy server", function() {
 
     await n.listen( ourport )
 
-    n.setmessagehandler( "open", ( msg ) => {
+    n.setmessagehandler( "open", ( msg, sendmessage ) => {
       openreceived = true
-      n.sendmessage( {
+      sendmessage( {
         "action": "open",
         "id": msg.id,
         "uuid": "7dfc35d9-eafe-4d8b-8880-c48f528ec152",
@@ -484,8 +484,8 @@ describe( "rtpproxy server", function() {
 
     let closeresolv
     const closepromise = new Promise( ( r ) => closeresolv = r )
-    n.setmessagehandler( "close", ( msg ) => {
-      n.sendmessage( {
+    n.setmessagehandler( "close", ( msg, sendmessage ) => {
+      sendmessage( {
         "action": "close",
         "uuid": msg.uuid,
         "id": msg.id
@@ -528,9 +528,9 @@ describe( "rtpproxy server", function() {
     await n.listen( n1port )
     await n2.listen( n2port )
 
-    n.setmessagehandler( "open", ( msg ) => {
+    n.setmessagehandler( "open", ( msg, sendmessage ) => {
       openreceived = true
-      n.sendmessage( {
+      sendmessage( {
         "action": "open",
         "id": msg.id,
         "uuid": ""+ouruuid++,
@@ -541,9 +541,9 @@ describe( "rtpproxy server", function() {
       } )
     } )
 
-    n2.setmessagehandler( "open", ( msg ) => {
+    n2.setmessagehandler( "open", ( msg, sendmessage ) => {
       openreceived = true
-      n2.sendmessage( {
+      sendmessage( {
         "action": "open",
         "id": msg.id,
         "uuid": ""+ouruuid++,
@@ -556,8 +556,8 @@ describe( "rtpproxy server", function() {
 
     let closeresolv
     const closepromise = new Promise( ( r ) => closeresolv = r )
-    n.setmessagehandler( "close", ( msg ) => {
-      n.sendmessage( {
+    n.setmessagehandler( "close", ( msg, sendmessage ) => {
+      sendmessage( {
         "action": "close",
         "uuid": msg.uuid,
         "id": msg.id
@@ -565,8 +565,8 @@ describe( "rtpproxy server", function() {
       closeresolv()
     } )
 
-    n2.setmessagehandler( "close", ( msg ) => {
-      n2.sendmessage( {
+    n2.setmessagehandler( "close", ( msg, sendmessage ) => {
+      sendmessage( {
         "action": "close",
         "uuid": msg.uuid,
         "id": msg.id

package/test/mock/mocknode.js

@@ -8,7 +8,6 @@ const { v4: uuidv4 } = require( "uuid" )
 class mocknode {
 
   constructor() {
-    this.mp = message.newstate()
     this.ourstats = prtp.stats()
     this.messagehandlers = {}
     this.recevievedmessagecount = 0
@@ -32,34 +31,74 @@ class mocknode {
    */
   async connect( port = 9002, address = "127.0.0.1" ) {
 
-    const connectpromise = new Promise( r => this._newconnectresolve = r )
-    this.connection = net.createConnection( port, address )
-    this.connection.on( "connect", this._onsocketconnect.bind( this ) )
-    this.connection.on( "data", this._onsocketdata.bind( this ) )
+    const connectpromise = new Promise( resolve => this._newconnectresolve = resolve )
+    const connection = net.createConnection( port, address, () => {
+
+      this.connection = connection
+      /* Pretend to be a node: our server will pass out new connections only after a
+      stats message has been sent and it must have an instance id */
+      const msg = {}
+      msg.status = this.ourstats
+      msg.status.instance = this.id
+      this.connection.write( message.createmessage( msg ) )
+
+      this._newconnectresolve()
+
+      const mp = message.newstate()
+      connection.on( "data", ( data ) => {
+        message.parsemessage( mp, data, ( receivedmsg ) => {
+          this.recevievedmessagecount++
+          expect( receivedmsg ).to.have.property( "channel" ).that.is.a( "string" )
+          expect( receivedmsg ).to.have.property( "id" ).that.is.a( "string" )
+          this.messagehandlers[ receivedmsg.channel ]( receivedmsg, ( senddata ) => {
+            senddata.status = this.ourstats
+            connection.write( message.createmessage( senddata ) )
+          } )
+        } )
+      } )
+    } )
 
     await connectpromise
   }
 
   /**
    * Listen for connections to this mock node.
-   * @param { number } [ port ] - default 9002
+   * @param { number } [ port ] - default 9002, if 0 binnd to random
    * @return { Promise } 
    */
-  listen( port = 9002, host = "127.0.0.1" ) {
+  async listen( port = 9002, host = "127.0.0.1" ) {
     let listenresolve
     const listenpromise = new Promise( ( r ) => listenresolve = r )
     this.port = port
     this.host = host
     this.server = net.createServer( ( connection ) => {
-      this.connection = connection
-      this.connection.setKeepAlive( true )
-      this.connection.on( "data", this._onsocketdata.bind( this ) )
+      connection.setKeepAlive( true )
+      const mp = message.newstate()
+      connection.on( "data", ( data ) => {
+        message.parsemessage( mp, data, ( receivedmsg ) => {
+          this.recevievedmessagecount++
+          expect( receivedmsg ).to.have.property( "channel" ).that.is.a( "string" )
+          expect( receivedmsg ).to.have.property( "id" ).that.is.a( "string" )
+          this.messagehandlers[ receivedmsg.channel ]( receivedmsg, ( senddata ) => {
+            senddata.status = this.ourstats
+            connection.write( message.createmessage( senddata ) )
+          } )
+        } )
+      } )
     } )
 
-    this.server.listen( port, host )
-    this.server.on( "listening", () => listenresolve() )
-    this.server.on( "close", () => {} )
-    return listenpromise
+    if( 0 == port ) {
+      this.server.listen( () => {
+        // Port does exist?
+        // @ts-ignore
+        this.port =  this.server.address().port
+        listenresolve( this.port )
+      } )
+    } else {
+      this.server.listen( port, host, listenresolve )
+    }
+    
+    return await listenpromise
   }
 
   /**
@@ -73,45 +112,31 @@ class mocknode {
   }
 
   /**
-   * @return { void }
+   * @return { Promise< void > }
    */
-  destroy() {
-    if( this.connection ) this.connection.destroy()
-    if( this.server ) this.server.close()
+  async destroy() {
+    if( this.connection ) {
+      const p = new Promise( resolve => {
+        this.connection.on( "close", resolve )
+      } )
+
+      this.connection.destroy()
+      await p
+    }
+
+    if( this.server ) {
+      const p = new Promise( resolve => {
+        this.server.on( "close", resolve )
+      } )
+      this.server.close()
+      await p
+    }
   }
 
   /**
-   * @private
-   * @return { void }
-   */
-  _onsocketconnect() {
-
-    /* Pretend to be a node: our server will pass out new connections only after a
-    stats message has been sent and it must have an instance id */
-    const msg = {}
-    msg.status = this.ourstats
-    msg.status.instance = this.id
-    this.connection.write( message.createmessage( msg ) )
-
-    this._newconnectresolve()
-  }
-
-  /**
-   * @private
-   * @param { Buffer } data
-   * @return { void }
-   */
-  _onsocketdata( data ) {
-    message.parsemessage( this.mp, data, ( receivedmsg ) => {
-      this.recevievedmessagecount++
-      expect( receivedmsg ).to.have.property( "channel" ).that.is.a( "string" )
-      expect( receivedmsg ).to.have.property( "id" ).that.is.a( "string" )
-      this.messagehandlers[ receivedmsg.channel ]( receivedmsg )
-    } )
-  }
-
-  /**
-   * 
+   * Will send a messag to the latst connection. If you expect multiple
+   * connections for a node then use the senddata function passed into the
+   * on data event.
    * @param { object } obj 
    * @return { void }
    */