@babblevoice/projectrtp 2.4.5 → 2.4.8

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.5",
+  "version": "2.4.8",
   "description": "A scalable Node addon RTP server",
   "main": "index.js",
   "directories": {

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()

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 )
+  } )
+
+} )