@babblevoice/projectrtp 2.3.7 → 2.4.0

package/.github/workflows/buildimage.yaml

@@ -0,0 +1,65 @@
+name: Build
+
+# Controls when the workflow will run
+on: 
+  workflow_dispatch:
+  push:
+    branches:
+      - 'main'
+      - 'dev'
+    tags:
+      - 'v*.*.*'
+  pull_request:
+    branches:
+      - 'main'
+      - 'dev'
+
+#GH
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    # Get the repository's code
+      - name: Checkout
+        uses: actions/checkout@v3
+      # https://github.com/docker/setup-qemu-action
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      # https://github.com/docker/setup-buildx-action
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Docker meta
+        id: ourdockertags
+        uses: docker/metadata-action@v3
+        with:
+          # list of Docker images to use as base name for tags
+          images: |
+            docker.io/tinpotnick/projectrtp
+          # Docker tags based on the following events/attributes
+          tags: |
+            type=schedule
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=sha
+    
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.ourdockertags.outputs.tags }}
+          labels: ${{ steps.ourdockertags.outputs.labels }}

package/lib/node.js

@@ -78,7 +78,8 @@ class rtpnode {
       const con = {
         connectionid: uuidv4(),
         connection,
-        "connectionlength": 0
+        "connectionlength": 0,
+        "mode": "connect"
       }
       this.connections[ con.connectionid ] = con
       this.connection.on( "data", this._onsocketdata.bind( this, con ) )
@@ -97,7 +98,8 @@ class rtpnode {
       const con = {
         connectionid: uuidv4(),
         connection,
-        "connectionlength": 0
+        "connectionlength": 0,
+        "mode": "listen"
       }
       this.connections[ con.connectionid ] = con
       connection.setKeepAlive( true )
@@ -163,12 +165,13 @@ class rtpnode {
    * @param { object } connection
    * @returns { void }
    */
-  send( msg, connection ) {
+  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)
     } )
   }
 
@@ -195,7 +198,9 @@ class rtpnode {
    * @returns { Promise< Boolean > }
    */
   async _processmessage( msg, con ) {
-    return ( await this._openchannel( msg, con ) || this._updatechannel( msg, con ) )
+    if( "open" == msg.channel ) return await this._openchannel( msg, con )
+
+    return this._updatechannel( msg, con )
   }
 
   /**
@@ -285,21 +290,25 @@ class rtpnode {
    * @returns { Promise< Boolean > }
    */
   async _openchannel( msg, con ) {
-    if( "open" !== msg.channel ) return false
     con.connectionlength += 1
     msg.forcelocal = true
 
-    const chan = await this.prtp.openchannel( msg, ( x ) => {
-      this.send( { ...{ "id": chan.id, "uuid": chan.uuid }, ...x }, con.connection )
-      if( "close" === x.action )  {
-        con.connectionlength -= 1
-        channels.delete( chan.uuid )
-
-        if( 0 == con.connectionlength ) {
-          this.connections.delete( con.instance )
-          con.connection.destroy()
-        }
-      }
+    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 )

package/lib/server.js

@@ -260,20 +260,27 @@ class channel {
   /**
    * This method forces an open channel on the same remote node.
    * @param { object } options
+   * @param { channelcallback } cb
    * @returns { Promise< channel > }
    */
-  openchannel( options = {} ) {
+  openchannel( options = undefined, cb = undefined ) {
+    if( "function" == typeof options ) {
+      cb = options
+      options = {}
+    }
 
     options.channel = "open"
 
     const resolvepromise = new Promise( ( res ) => {
 
       const newchannel = new channel()
+      if( cb ) newchannel.em.on( "all", cb )
+
       newchannel.connection = this.connection
       newchannel.channels = this.channels
       newchannel.channels.push( newchannel )
+      newchannel.openresolve = res
       newchannel._write( options )
-      res( newchannel )
     } )
 
     return resolvepromise
@@ -597,8 +604,6 @@ class channel {
    * @private
    */
   _runclose( msg ) {
-    if( "close" !== msg.action ) return
-    
     if( undefined !== this.openresolve ) {
       this.openresolve()
       delete this.openresolve
@@ -612,10 +617,6 @@ class channel {
       if( 0 === this.channels.length && this.connection.sock ) this.connection.sock.destroy()
     }
 
-    if( this.connection && this.connection.sock && !this.channels ) {
-      this.connection.sock.destroy()
-      delete this.connection.sock
-    }
 
     channels.delete( this.id )
   }
@@ -633,7 +634,7 @@ class channel {
     this.em.emit( "all", msg )
     this.em.emit( msg.action, msg )
 
-    this._runclose( msg )
+    if( "close" == msg.action ) this._runclose( msg )
   }
 
   /**

package/package.json

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

package/stress/utils.js

@@ -20,9 +20,18 @@ module.exports.logclosechannel = ( message, d, mstimeout ) => {
   channelcount--
   totalcount++
   module.exports.log( message )
-  module.exports.log( ` Expected number of packets: ${Math.round(mstimeout / 20)}, Received: ${d.stats.in["count"]},` +
-  ` Score: ${(d.stats.in["count"] / mstimeout * 20).toFixed(2)}` )
-  module.exports.log( `Channel closed - current count now ${channelcount} total channels this session ${totalcount}` )
+
+  const score = ( d.stats.in["count"] / mstimeout * 20 ).toFixed( 2 )
+  let scoremsg = ` Score: ${ score }`
+
+  // Colour based on score: red, yellow, green
+  if( 0.25 >= score ) scoremsg = "\x1B[31m" + scoremsg
+  else if( 0.7 >= score ) scoremsg = "\x1B[33m" + scoremsg
+  else scoremsg = "\x1B[32m" + scoremsg
+  scoremsg += "\x1B[37m"
+
+  module.exports.log( `Expected number of packets: ${ Math.round( mstimeout / 20 ) }, Received: ${ d.stats.in[ "count" ] },` + scoremsg )
+  module.exports.log( `Channel closed - current count now ${ channelcount } total channels this session ${ totalcount }` )
 }
 
 module.exports.totalchannelcount = () => {

package/test/interface/rtpproxyserver.js

@@ -673,4 +673,21 @@ describe( "rtpproxy server", function() {
     
 
   } )
+  it( "Ensure connection stays open with 0 channel in listen mode", async () => {
+
+    const ourport = getnextport()
+    prtp.server.clearnodes()
+    const p = await prtp.proxy.listen( undefined, "127.0.0.1", ourport )
+    const ournode = await prtp.node.connect( ourport, "127.0.0.1" )
+
+
+    const chnl = await prtp.openchannel()
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 100 ) } )
+    await chnl.close()
+    const chnl2 = await prtp.openchannel()
+    await chnl2.close()
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 100 ) } )
+    ournode.destroy()
+    p.destroy()
+  } )
 } )