@babblevoice/projectrtp 2.5.28 → 2.5.30

package/README.md

@@ -60,7 +60,7 @@ If you wish to build outsode of a Docker image, there are npm target scripts for
 
 ```bash
 docker buildx prune
-docker buildx build --platform linux/amd64,linux/arm64 -t tinpotnick/projectrtp:2.5.27 . --push
+docker buildx build --platform linux/amd64,linux/arm64 -t tinpotnick/projectrtp:2.5.29 . --push
 ```
 
 ## Example scripts

package/index.js

@@ -31,13 +31,13 @@ function gencerts() {
     const combined = keypath + "dtls-srtp.pem"
 
     const openssl = spawnSync( "openssl", [ "genrsa", "-out", serverkey, "4096" ] )
-    if( 0 !== openssl.status ) throw "Failed to genrsa: " + openssl.status
+    if( 0 !== openssl.status ) throw new Error( "Failed to genrsa: " + openssl.status )
 
     const request = spawnSync( "openssl", [ "req", "-new", "-key", serverkey , "-out", servercsr, "-subj", "/C=GB/CN=projectrtp" ] )
-    if( 0 !== request.status ) throw "Failed to generate csr: " + request.status
+    if( 0 !== request.status ) throw new Error( "Failed to generate csr: " + request.status )
 
     const sign = spawnSync( "openssl", [ "x509", "-req", "-in", servercsr, "-signkey", serverkey, "-out", servercert ] )
-    if( 0 !== sign.status ) throw "Failed to sign key: " + sign.status
+    if( 0 !== sign.status ) throw new Error( "Failed to sign key: " + sign.status )
 
     const serverkeydata = fs.readFileSync( serverkey )
     const servercertdata = fs.readFileSync( servercert )
@@ -407,9 +407,9 @@ class projectrtp {
   run( params ) {
 
     if( "win32" == process.platform && "x64" == process.arch ) {
-      throw "Platform not currently supported"
+      throw new Error( "Platform not currently supported" )
     } else if( "win32" == process.platform && "ia32" == process.arch ) {
-      throw "Platform not currently supported"
+      throw new Error( "Platform not currently supported" )
     }
 
     if( actualprojectrtp ) return
@@ -445,7 +445,6 @@ class projectrtp {
     if( !params.forcelocal && server.interface.get() ) {
       return server.interface.get().openchannel( params, cb )
     } else {
-      /* use local */
       const chan = actualprojectrtp.openchannel( params, ( d ) => {
         try{
           if( chan.em ) {
@@ -471,7 +470,7 @@ class projectrtp {
 
       /* ensure we are identicle to the node version of this object */
       chan.openchannel = this.openchannel.bind( this )
-      
+
       return chan
     }
   }

package/lib/message.js

@@ -75,7 +75,7 @@ function trimstateandcallback( state, cb ) {
         if( e instanceof SyntaxError ) {
           return
         }
-        throw e
+        throw new Error( e )
       }
     }
   }

package/lib/node.js

@@ -15,7 +15,12 @@ const channelmap = {
     }
   },
   "unmix": ( chan ) => chan.unmix(),
-  "dtmf": ( chan, msg ) => chan.dtmf( msg.digits ),
+  "dtmf": ( chan, msg ) => {
+    if( !msg.digits ) return
+    if( "string" !== typeof msg.digits ) return
+    if( 10 < msg.digits.length ) return
+    chan.dtmf( msg.digits )
+  },
   "echo": ( chan ) => chan.echo(),
   "play": ( chan, msg ) => chan.play( msg.soup ),
   "record": ( chan, msg ) => chan.record( msg.options ),
@@ -64,7 +69,7 @@ class rtpnodeconnection {
           this._processmessage( modifiedmsg )
         } )
       } catch( e ) {
-        console.error( "Unhandled exception in babble-rtp", e )
+        console.error( "Unhandled exception in projectrtp", e )
       }
     } )
   }
@@ -109,16 +114,48 @@ class rtpnodeconnection {
   /**
    * Send a message back to the main server, include stats to help with load balancing.
    * @param { object } msg
-   * @returns { void }
+   * @param { function } [ cb ]
+   * @returns { Promise | undefined }
    */
   send( msg, cb = undefined ) {
+
+    let retval
+    if( !cb ) retval = new Promise( ( r ) => cb = r )
     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)
+      if( this._destroying ) {
+        return
+      }
+      modifiedmsg.status = this.parent.prtp.stats()
+      modifiedmsg.status.instance = instance
+
+      delete modifiedmsg.forcelocal
+      delete modifiedmsg.em
+      delete modifiedmsg.openchannel
+      delete modifiedmsg.close
+      delete modifiedmsg.mix
+      delete modifiedmsg.unmix
+      delete modifiedmsg.echo
+      delete modifiedmsg.play
+      delete modifiedmsg.record
+      delete modifiedmsg.direction
+      delete modifiedmsg.dtmf
+      delete modifiedmsg.remote
+
+      this.connection.write( message.createmessage( modifiedmsg ), () => {
+        cb( modifiedmsg )
+      } )
     } )
+
+    return retval
+  }
+
+  #cleanup() {
+    this.connectionlength -= 1
+
+    if( 0 == this.connectionlength && "listen" == this.mode ) {
+      this.parent.connections.delete( this.connectionid )
+      this.connection.destroy()
+    }
   }
 
 
@@ -131,25 +168,61 @@ class rtpnodeconnection {
     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()
+    const timerid = setTimeout( () => {
+      console.trace( "Timeout opening channel", msg )
+      process.exit(1)
+    }, 4000 )
+
+    let chan
+    try {
+      chan = await this.parent.prtp.openchannel( msg, ( cookie ) => {
+
+        if( !chan ) {
+          console.error( "Error opening channel - message before open", msg, cookie )
+          return
+        }
+
+        // TODO: we might want to ensure the actual event has been written
+        // to the server before cleaning up the channel on our side?
+        const tosend = { ...{ "id": chan.id, "uuid": chan.uuid }, ...cookie }
+
+        this.send( tosend,
+          () => {
+            if ( "close" === cookie.action )  {
+              if( !chan ) {
+                const closebforeopen = { error: "unknown error opening channel", cookie, msg }
+                this.send( closebforeopen, () => {
+                  this.#cleanup()
+                } )
+                return
+              }
+              channels.delete( chan.uuid )
+              this.#cleanup()
             }
-          }
-        } )
-    } )
+          } )
+      } )
+    } catch( e ) {
+      console.error( "Error opening channel", e )
+      const opentosend = { error: "unknown error opening channel", msg }
+      await this.send( opentosend )
+      this.#cleanup()
+      return false
+    }
+
+    if( !chan ) {
+      console.trace( "Error opening channel", msg )
+      const opentosend = { error: "unknown error opening channel", msg }
+      await this.send( opentosend )
+      this.#cleanup()
+      return false
+    }
+
     channels.set( chan.uuid, chan )
-    this.send( { ...chan, ...{ "action": "open" } } )
 
+    clearTimeout( timerid )
+
+    const opentosend = { ...chan, ...{ "action": "open" } }
+    this.send( opentosend )
     return true
   }
 

package/lib/server.js

@@ -177,6 +177,8 @@ class channel {
    */
   _bridge
 
+  #connected = false
+
   /**
    * 
    */
@@ -262,12 +264,15 @@ class channel {
 
       newchannel.connection.sock.on( "connect", () => {
         newchannel._write( options )
+        newchannel.#connected = true
         if ( connectresolve ) connectresolve( newchannel )
       } )
 
       newchannel.opentimer = setTimeout( () => {
         if( newchannel.openreject ) {
-          newchannel.openreject()
+          let addmesg = ""
+          if( newchannel.#connected ) addmesg = " - post connect"
+          newchannel.openreject( new Error( "timed out waiting for open" + addmesg ) )
           delete newchannel.openresolve
           delete newchannel.openreject
           delete newchannel.opentimer
@@ -298,7 +303,7 @@ class channel {
         newchannel.channels.forEach( chnl => {
           channels.delete( chnl.id )
           if( chnl.openreject ) {
-            chnl.openreject()
+            chnl.openreject( new Error( "Connection closed whilst waiting for open" ) )
             clearTimeout( chnl.opentimer )
             delete chnl.openresolve
             delete chnl.openreject
@@ -325,11 +330,8 @@ class channel {
 
     const resolvepromise = new Promise( ( resolve, reject ) => {
 
-      if ( 0 < nodes.size ) {
-        const node = randomenode( options.nodeinstance )
-        const request = JSON.parse( JSON.stringify( options ) )
-        request.channel = "open"
-        channel._createforlisten( request, node, cb, resolve, reject )
+      if( !this.connection ) {
+        reject( new Error( "No connection" ) )
         return
       }
 
@@ -345,7 +347,7 @@ class channel {
 
       newchannel.opentimer = setTimeout( () => {
         if( newchannel.openreject ) {
-          newchannel.openreject()
+          newchannel.openreject( new Error( "timed out waiting for open" ) )
           delete newchannel.openresolve
           delete newchannel.openreject
           delete newchannel.opentimer
@@ -382,7 +384,7 @@ class channel {
 
     this.closetimer = setTimeout( () => {
       if( this.closereject ) {
-        this.closereject()
+        this.closereject( new Error( "timed out waiting for close" ) )
         delete this.closereject
         delete this.closeresolve
         delete this.closetimer
@@ -396,7 +398,7 @@ class channel {
     } )
 
     if( this.openreject ) {
-      this.openreject()
+      this.openreject( new Error( "Channel closed before open" ) )
       clearTimeout( this.opentimer )
       delete this.openresolve
       delete this.openreject
@@ -561,7 +563,8 @@ class channel {
    */
   _runclose( msg ) {
     if( this.openreject ) {
-      this.openreject()
+      console.error( "Received close before open", msg )
+      this.openreject( new Error( "Received close before open" ) )
       clearTimeout( this.opentimer )
       delete this.openresolve
       delete this.openreject
@@ -591,6 +594,21 @@ class channel {
     }
   }
 
+  #haserror( msg ) {
+    if( !msg.error ) return false
+    console.error( msg )
+
+    if( this.openreject ) {
+      this.openreject( new Error( msg.error ) )
+      clearTimeout( this.opentimer )
+      delete this.openresolve
+      delete this.openreject
+      delete this.opentimer
+    }
+
+    return true
+  }
+
   /**
    * Called by our socket to pass data back up the chain.
    * @ignore
@@ -600,6 +618,7 @@ class channel {
     msg.timestamp = ( new Date ).getTime()
     this.history.push( msg )
     if( this._runopen( msg ) ) return
+    if( this.#haserror( msg ) ) return
 
     this.em.emit( "all", msg )
     this.em.emit( msg.action, msg )
@@ -722,7 +741,7 @@ class rtpserver {
 
       if( 0 === nodes.size && 0 === listeningnodes.length ) {
         console.error( "No available RTP nodes" )
-        reject( "No available RTP nodes" )
+        reject( new Error( "No available RTP nodes" ) )
       }
 
       const request = JSON.parse( JSON.stringify( options ) )

package/package.json

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

package/src/projectrtpchannel.cpp

@@ -347,7 +347,8 @@ void projectrtpchannel::doopen( void ) {
       boost::asio::ip::udp::v4(), this->port ), ec );
 
   if( ec ) {
-    this->badsocketopen( "failed to bind rtp socket" );
+    auto err = std::string( "failed to bind rtp socket: " ) + std::to_string( this->port ) + std::string( ": " ) + ec.message();
+    this->badsocketopen( err.c_str() );
     return;
   }
 
@@ -362,7 +363,8 @@ void projectrtpchannel::doopen( void ) {
       boost::asio::ip::udp::v4(), this->port + 1 ), ec );
 
   if( ec ) {
-    this->badsocketopen( "failed to bind rtcp socket" );
+    auto err = std::string( "failed to bind rtcp socket: " ) + std::to_string( this->port + 1 ) + std::string( ": " ) + ec.message();
+    this->badsocketopen( err.c_str() );
     return;
   }
 
@@ -2366,10 +2368,12 @@ void getchannelstats( napi_env env, napi_value &result ) {
 void initrtpchannel( napi_env env, napi_value &result, int32_t startport, int32_t endport ) {
   napi_value ccreate;
 
+  AQUIRESPINLOCK( availableportslock );
   while(!availableports.empty()) availableports.pop();
   for( int i = (int) startport; i < (int) endport; i = i + 2 ) {
     availableports.push( i );
   }
+  RELEASESPINLOCK( availableportslock );
 
   if( napi_ok != napi_create_function( env, "exports", NAPI_AUTO_LENGTH, channelcreate, nullptr, &ccreate ) ) return;
   if( napi_ok != napi_set_named_property( env, result, "openchannel", ccreate ) ) return;

package/test/interface/projectrtprecord.js

@@ -312,8 +312,8 @@ describe( "record", function() {
 
       expect( channel.record( {
         "file": "/tmp/ourpowerrecording.wav",
-        "startabovepower": 250,
-        "finishbelowpower": 200,
+        "startabovepower": 40,
+        "finishbelowpower": 80,
         "minduration": 2000,
         "maxduration": 15000,
         "poweraveragepackets": 20
@@ -382,8 +382,8 @@ describe( "record", function() {
 
       expect( channel.record( {
         "file": "/tmp/ourtimeoutpowerrecording.wav",
-        "startabovepower": 250,
-        "finishbelowpower": 200,
+        "startabovepower": 40,
+        "finishbelowpower": 80,
         "minduration": 200,
         "maxduration": 500,
         "poweraveragepackets": 50
@@ -449,8 +449,8 @@ describe( "record", function() {
 
       expect( channel.record( {
         "file": "/tmp/dualrecordingpower.wav",
-        "startabovepower": 200,
-        "finishbelowpower": 180,
+        "startabovepower": 40,
+        "finishbelowpower": 200,
         "minduration": 200,
         "maxduration": 3500,
         "poweraveragepackets": 10 /* faster response */
@@ -470,7 +470,7 @@ describe( "record", function() {
     server.close()
 
     let stats = fs.statSync( "/tmp/dualrecordingpower.wav" )
-    expect( stats.size ).to.be.within( 40000, 52000 )
+    expect( stats.size ).to.be.within( 30000 , 40000 )
 
     stats = fs.statSync( "/tmp/dualrecording.wav" )
     expect( stats.size ).to.be.within( 110000, 190000 )

package/test/interface/projectrtptonegen.js

@@ -4,9 +4,76 @@
 const expect = require( "chai" ).expect
 const projectrtp = require( "../../index.js" ).projectrtp
 
+const fs = require( "node:fs" ).promises
+const dgram = require( "dgram" )
+const rtp = require( "../util/rtp" )
+
 describe( "tonegen", function() {
+
+  const silentfilename = "/tmp/silent.wav"
+
+  this.afterEach( async () => {
+    try{
+      await fs.unlink( silentfilename )
+    } catch( e ) { /* silent */ }
+    
+  } )
+
   it( "tone.generate exists", async function() {
     expect( projectrtp.tone.generate ).to.be.an( "function" )
   } )
+
+  it( "generate silence and ensure looped is silent", async function() {
+
+    this.timeout( 4000 )
+    this.slow( 3000 )
+
+    /* Trying to replicate a bug where we use the silence in a tone file to send silence */
+    projectrtp.tone.generate( "350+440*0.5:1000", silentfilename )
+    projectrtp.tone.generate( "400+450*0.5/0/400+450*0.5/0:400/200/400/2000", silentfilename )
+    projectrtp.tone.generate( "697+1209*0.5/0/697+1336*0.5/0/697+1477*0.5/0/697+1633*0.5/0:400/100", silentfilename )
+
+    const server = dgram.createSocket( "udp4" )
+
+    let done
+    const complete = new Promise( resolve => done = resolve )
+    let recvcount = 0
+    let allaregood = true
+    server.on( "message", function( dgm ) {
+      // check
+      const parsed = rtp.parsepk( dgm )
+
+      recvcount++
+
+      allaregood &&= Array.from( parsed.payload ).every( val => 255 === val )
+
+      if( 100 < recvcount ) channel.close()
+    } )
+
+    server.bind()
+    await new Promise( resolve => server.on( "listening", resolve() ) )
+
+    const ourport = server.address().port
+
+    const chandef = { "remote": { "address": "localhost", "port": ourport, "codec": 0 } }
+    const channel = await projectrtp.openchannel( chandef, function( d ) {
+      if( "close" === d.action ) {
+        server.close()
+        done()
+      }
+    } )
+
+    const prompt = { "wav": silentfilename, "start": 2100, "stop": 3100, "loop": 3 } //silent
+    const soup = { 
+      "files": [ prompt ], "interupt": true 
+    }
+
+    channel.play( soup )
+
+    await complete
+
+    expect( allaregood ).to.be.true
+
+  } )
 } )