@babblevoice/projectrtp 2.5.26 → 2.5.29

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.23_beta4 . --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

@@ -64,7 +64,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 +109,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 +163,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

@@ -4,9 +4,10 @@ const net = require( "net" )
 const { v4: uuidv4 } = require( "uuid" )
 
 const EventEmitter = require( "events" )
-
 const message = require( "./message" )
 
+const opentimeout = 5000
+
 /**
  * Node host address and port object
  * @typedef { object } nodehost
@@ -105,12 +106,36 @@ class channel {
    */
   openresolve
 
+  /** 
+   * @private
+   * @type { function } 
+   */
+  closeresolve
+
   /** 
    * @private
    * @type { function } 
    */
   openreject
 
+  /** 
+   * @private
+   * @type { function } 
+   */
+  closereject
+
+  /** 
+   * @private
+   * @type { NodeJS.Timeout }
+   */
+  opentimer
+
+  /** 
+   * @private
+   * @type { NodeJS.Timeout }
+   */
+  closetimer
+
   /** 
    * Array of messages sent to and from the remote end.
    * @type { Array< any > } 
@@ -152,6 +177,8 @@ class channel {
    */
   _bridge
 
+  #connected = false
+
   /**
    * 
    */
@@ -206,14 +233,15 @@ class channel {
   }
 
   /**
-   * Creates a new channel which connects to a remote rtp node.
+   * Connects to a RTP server then creates channel
    * @param { object } options
    * @param { channelcallback } cb
    * @param { function } openresolve
+   * @param { function } openreject
    * @returns { Promise< channel > } - resolves when the connection is connected
    * @internal
    */
-  static _createforconnect( options, cb, openresolve /* openreject do something with me */ ) {
+  static _createforconnect( options, cb, openresolve, openreject ) {
 
     const newchannel = new channel( options.id )
     if( cb ) newchannel.em.on( "all", cb )
@@ -228,14 +256,29 @@ class channel {
         "type": nodeconnectiontype.connect
       }
 
+      newchannel.openresolve = openresolve
+      newchannel.openreject = openreject
+
       newchannel.connection.sock.setKeepAlive( true )
       newchannel.channels = [ newchannel ]
 
       newchannel.connection.sock.on( "connect", () => {
         newchannel._write( options )
+        newchannel.#connected = true
         if ( connectresolve ) connectresolve( newchannel )
       } )
 
+      newchannel.opentimer = setTimeout( () => {
+        if( 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
+        }
+      }, opentimeout )
+
       const state = message.newstate()
       newchannel.connection.sock.on( "data", ( data ) => {
         message.parsemessage( state, data, ( /** @type { object } */ receivedmsg ) => {
@@ -248,8 +291,6 @@ class channel {
           if( receivedmsg && receivedmsg.status && receivedmsg.status.instance ) {
             newchannel.connection.instance = receivedmsg.status.instance
           }
-
-          if ( openresolve ) openresolve( newchannel )
         } )
       } )
 
@@ -259,6 +300,16 @@ class channel {
       } )
 
       newchannel.connection.sock.on( "close", () => {
+        newchannel.channels.forEach( chnl => {
+          channels.delete( chnl.id )
+          if( chnl.openreject ) {
+            chnl.openreject( new Error( "Connection closed whilst waiting for open" ) )
+            clearTimeout( chnl.opentimer )
+            delete chnl.openresolve
+            delete chnl.openreject
+            delete chnl.opentimer
+          }
+        } )
       } )
     } )
   }
@@ -279,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
       }
 
@@ -294,7 +342,17 @@ class channel {
       newchannel.channels = this.channels
       newchannel.channels.push( newchannel )
       newchannel.openresolve = resolve
+      newchannel.openreject = reject
       newchannel._write( options )
+
+      newchannel.opentimer = setTimeout( () => {
+        if( newchannel.openreject ) {
+          newchannel.openreject( new Error( "timed out waiting for open" ) )
+          delete newchannel.openresolve
+          delete newchannel.openreject
+          delete newchannel.opentimer
+        }
+      }, opentimeout )
     } )
 
     return resolvepromise
@@ -314,12 +372,24 @@ class channel {
   }
 
   /**
-   * @summary Close the channel
+   * Closes the channel. It might throw a timeout error if the channel is not closed within 5 seconds.
+   * @param { object } [ options ]
+   * @param { number } [ options.timeout ] - different timeout to wait
+   * @returns { Promise< object > }
    */
-  close() {
+  close( options ) {
 
-    /* any outstanding to remove where unmix was not called first? */
-    //this._removebridge()
+    let timeout = opentimeout
+    if( options && options.timeout ) timeout = options.timeout
+
+    this.closetimer = setTimeout( () => {
+      if( this.closereject ) {
+        this.closereject( new Error( "timed out waiting for close" ) )
+        delete this.closereject
+        delete this.closeresolve
+        delete this.closetimer
+      }
+    }, timeout )
     
     /* close us */
     this._write( {
@@ -327,11 +397,18 @@ class channel {
       "uuid": this.uuid
     } )
 
-    if( this.openresolve ) {
-      this.openresolve()
+    if( this.openreject ) {
+      this.openreject( new Error( "Channel closed before open" ) )
+      clearTimeout( this.opentimer )
       delete this.openresolve
       delete this.openreject
+      delete this.opentimer
     }
+
+    return new Promise( ( resolve, reject ) => {
+      this.closeresolve = resolve
+      this.closereject = reject
+    } )
   }
 
   /**
@@ -354,142 +431,6 @@ class channel {
     return true
   }
 
-  /**
-   * Add _bridge object to both channel
-   * @param { object } other - other channel
-   * @returns { void }
-   */
-  _createbridges( other ) {
-
-    if( !this._bridge && !other._bridge ) {
-      this._bridge = other._bridge = {
-        "bridges": [],
-        "main": this.connection.instance
-      }
-    }
-
-    if( !this._bridge && other._bridge ) this._bridge = other._bridge
-    if( this._bridge && !other._bridge ) other._bridge = this._bridge
-
-    if( this._bridge !== other._bridge )
-      throw new Error( "some complex mixing occured and this function needs finishing" )
-  }
-
-  /**
-   * Any channels which have been mixed we create an
-   * object common to both channels so we can keep track of channels which 
-   * require tidyin up. We try to maintain a star shaped network.
-   * In the example diagram, the out mix method mixes between phone1 and this
-   * and phone2 and other. 
-   * Markdown (mermaid)
-      graph TD
-        this -->|rtp - our created bridge to link the 2 remote channels| other
-        other --> this
-
-        phone1 --> this
-        this --> phone1
-
-        phone2 --> other
-        other --> phone2
-   * @private
-   * @param { object } other - other channel
-   * @returns { Promise< boolean > }
-   */
-  async _addbridge( other ) {
-
-    let leftid = this.connection.instance
-    const rightid = other.connection.instance
-
-    this._createbridges( other )
-
-    /* nothing more to do if we are on the same node */
-    if( rightid === leftid ) return false
-
-    /* It might have changed now we have linked them up */
-    leftid = this._bridge.main
-
-    let found = false
-    for( const bridge of this._bridge.bridges ) {
-      if( ( bridge.left.connection.instance === leftid || bridge.right.connection.instance === leftid ) &&
-          ( bridge.left.connection.instance === rightid || bridge.right.connection.instance === rightid ) ) {
-        found = true
-        bridge.channels.add( this )
-        bridge.channels.add( other )
-
-        this.mix( bridge.left )
-        other.mix( bridge.right )
-      }
-    }
-
-    if( found ) return
-
-    const bridge = {
-      /* TODO: this will need reworking with to support reverse connection types */
-      "left": await serverinterface.get().openchannel( { "nodeinstance": leftid } ),
-      "right": await serverinterface.get().openchannel( { "nodeinstance": rightid } ),
-      "channels": new Set( [ this, other ] )
-    }
-
-    const addressleft = bridge.left.local.privateaddress || bridge.left.local.address
-    const addressright = bridge.right.local.privateaddress || bridge.right.local.address
-    const g722 = 9
-
-    bridge.left.remote( { "address": addressright, "port": bridge.right.local.port, "codec": g722 } )
-    bridge.right.remote( { "address": addressleft, "port": bridge.left.local.port, "codec": g722 } )
-
-    this._bridge.bridges.push( bridge )
-
-    this._write( {
-      "channel": "mix",
-      "other": {
-        "id": bridge.left.id,
-        "uuid": bridge.left.uuid
-      }
-    } )
-
-    other._write( {
-      "channel": "mix",
-      "other": {
-        "id": bridge.right.id,
-        "uuid": bridge.right.uuid
-      }
-    } )
-
-    return true
-  }
-
-  /**
-   * We check if we are a remote node (i.e.. not the centre of the star)
-   * then we close down the link between the two.
-   * @private
-   * @returns { boolean }
-   */
-  _removebridge() {
-
-    /* no remote bridges have been created */
-    if( !this._bridge || !this._bridge.main ) return
-
-    const usid = this.connection.instance
-
-    /* The centre of star cannot remove from the network until last man standing */
-    if( usid == this._bridge.main ) return
-
-    this._bridge.bridges = this._bridge.bridges.filter( ( bridge ) => {
-      bridge.channels.delete( this )
-
-      if( 2 > bridge.channels.size ) {
-
-        bridge.left._write( { "channel": "unmix" } )
-        bridge.left._write( { "channel": "unmix" } )
-
-        bridge.left.close()
-        bridge.right.close()
-        return false /* remove */
-      }
-      return true /* keep */
-    } )
-  }
-
   /**
   @summary Removes us from an existing mix
   @returns { boolean }
@@ -592,6 +533,7 @@ class channel {
   }
 
   /**
+   * We have received teh open confirm message so we should action it
    * @private
    * @param { object } msg
    * @returns { boolean } - is further processing required
@@ -605,33 +547,66 @@ class channel {
 
     if( !this.openresolve ) return true
     this.openresolve( this )
+    clearTimeout( this.opentimer )
     delete this.openresolve
     delete this.openreject
+    delete this.opentimer
 
     return true
   }
 
   /**
-   * 
+   * We have received a close message so we should action it
+   * @param { object } msg
    * @returns { void }
    * @private
    */
-  _runclose() {
-    if( undefined !== this.openresolve ) {
-      this.openresolve()
+  _runclose( msg ) {
+    if( 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
+      delete this.opentimer
+    }
+
+    if( this.closeresolve ) {
+      this.closeresolve( msg )
+      clearTimeout( this.closetimer )
+      delete this.closeresolve
+      delete this.closereject
+      delete this.closetimer
     }
 
+    this.#cleanupsharedchannels()
+    channels.delete( this.id )
+  }
+
+  #cleanupsharedchannels() {
     if( this.channels ) { 
       // adjust with filter
       const index = this.channels.indexOf( this )
       if( -1 < index ) this.channels.splice( index, 1 )
-      if( 0 === this.channels.length && this.connection.sock ) this.connection.sock.destroy()
+      if( 0 === this.channels.length && this.connection.sock ) {
+        this.connection.sock.destroy()
+      }
     }
+  }
 
+  #haserror( msg ) {
+    if( !msg.error ) return false
+    console.error( msg )
 
-    channels.delete( this.id )
+    if( this.openreject ) {
+      this.openreject( new Error( msg.error ) )
+      clearTimeout( this.opentimer )
+      delete this.openresolve
+      delete this.openreject
+      delete this.opentimer
+    }
+
+    return true
   }
 
   /**
@@ -643,11 +618,12 @@ 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 )
 
-    if( "close" == msg.action ) this._runclose()
+    if( "close" == msg.action ) this._runclose( msg )
   }
 
   /**
@@ -765,16 +741,16 @@ 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 ) )
       request.channel = "open"
   
       const node = randomenode( options.nodeinstance )
-  
+
       if ( 0 < nodes.size ) channel._createforlisten( request, node, callback, resolve, reject )
-      else channel._createforconnect( request, callback, resolve )
+      else channel._createforconnect( request, callback, resolve, reject )
 
     } )
   }

package/package.json

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