@babblevoice/babble-drachtio-callmanager 3.3.3 → 3.3.5

package/lib/call.js

@@ -218,7 +218,8 @@ class call {
       "audio": undefined,
       "closed": {
         "audio": []
-      }
+      },
+      "count": 0
     }
 
     /**
@@ -1717,13 +1718,20 @@ class call {
       this.channels.closed.audio.push( e )
     }
 
-    this.channels.audio = false
-    if( this._state._onhangup ) {
-      this._cleanup()
-      return
-    }
+    this.channels.count--
+
+    if ( 0 === this.channels.count ) {
+      this.channels.audio = undefined
+
+      if( this._state._onhangup ) {
+        this._cleanup()
+        return
+      }
 
-    this.hangup() /* ? */
+      // This will handle _cleanup() later
+      // based on the above flag
+      this.hangup()
+    }
   }
 
   /**
@@ -2010,9 +2018,13 @@ class call {
     same as used elsewhere. If a bond has been attached to the call, we will
     try to reuse an existing channel.
     @param { object } [ channeldef ]
+    @param { object } [ newchannel ]
     @private
   */
-  async reinvite( channeldef ) {
+  async reinvite( channeldef, newchannel ) {
+
+    if ( newchannel )
+      this.channels.audio = newchannel
 
     if ( !channeldef )
       channeldef = await this.#createchannelremotedef()
@@ -2045,17 +2057,40 @@ class call {
       const channeldef = await othercall.#createchannelremotedef()
 
       const oldchannel = othercall.channels.audio
-      // eslint-disable-next-line require-atomic-updates
-      othercall.channels.audio = await this.channels.audio.openchannel( channeldef, othercall._handlechannelevents.bind( othercall ) )
+      const newchannel = await this.#openchannel( channeldef, othercall )
 
-      await othercall.bond( this ).reinvite( channeldef )
+      await othercall.bond( this ).reinvite( channeldef, newchannel )
 
-      await oldchannel.close()
+      await oldchannel.unmix()
+      oldchannel.close()
     }
 
     await this.channels.audio.mix( othercall.channels.audio )
   }
 
+  /**
+    Mix two calls. If the two calls are on a different node
+    the second call is bonded and reinvited.
+    @param { object } channeldef - our call object which is early
+    @param { call } [ bindcall ] - the call which will own the channel
+  */
+  async #openchannel( channeldef, bindcall ) {
+
+    if ( bindcall && bindcall.channels.audio ) {
+      const chan = await bindcall.channels.audio.openchannel(
+        channeldef, this._handlechannelevents.bind( this ) )
+
+      this.channels.count++
+      return chan
+    }
+    
+    const chan = await projectrtp.openchannel(
+      channeldef, this._handlechannelevents.bind( this ) )
+    this.channels.count++
+
+    return chan
+  }
+
   /**
    * 
    * @param { object } req 
@@ -2156,20 +2191,32 @@ class call {
     RTP stall timer will kick in first, but if a call is placed on hold followed
     by AWOL... */
     this._timers.seinterval = setInterval( async () => {
-      const opts = {
-        "method": "INVITE",
-        "body": this.sdp.local.toString()
-      }
 
-      const res = await dialog.request( opts )
-        .catch( ( e ) => {
-          console.trace( e )
-          this.hangup( hangupcodes.USER_GONE )
-        } )
+      try{
 
-      if( !this.destroyed && 200 != res.msg.status ) {
-        this.hangup( hangupcodes.USER_GONE )
-      }
+        if( this.destroyed ) {
+          /* this should be done - but we are still running */
+          clearInterval( this._timers.seinterval )
+          return
+        }
+
+        if( "function" != typeof dialog.request ) return
+
+        const opts = {
+          "method": "INVITE",
+          "body": this.sdp.local.toString()
+        }
+  
+        const res = await dialog.request( opts )
+          .catch( ( e ) => {
+            console.trace( e )
+            this.hangup( hangupcodes.USER_GONE )
+          } )
+  
+        if( !this.destroyed && 200 != res.msg.status ) {
+          this.hangup( hangupcodes.USER_GONE )
+        }
+      } catch( e ) { /* empty */ }
 
     }, callmanager.options.seexpire )
 
@@ -2567,7 +2614,6 @@ class call {
     @private
   */
   _cleanup() {
-
     if( this.state.cleaned ) return
     this.state.cleaned = true
 
@@ -2643,7 +2689,7 @@ class call {
     if( this.channels.audio ) {
       this.channels.audio.close()
       this._timers.cleanup = setTimeout( () => {
-        console.trace( "Timeout waiting for channel close, cleaning up anyway", this.uuid )
+        console.trace( this.uuid + " Timeout waiting for channel close, cleaning up anyway, chan uuid: " + this.channels.audio.uuid + ", channel count: " + this.channels.count )
         this._cleanup() 
       }, 60 * 1000 )
 
@@ -2890,24 +2936,24 @@ class call {
 
     if( this.channels.audio ) return
 
-    const relatedcall = this.other
+    const othercall = this.other
     /* TODO: this is a hack. projectrtp has become too complicated with both a listen and connect 
     mechanism. This is causing problems in code like this. There is no interface to 
     detect which mode the channel is in - but the channels property will exist on a connect
     style channel. projectrtp will getrelatives a rewrite to support only one. */
-    if( relatedcall && relatedcall.channels.audio && relatedcall.channels.audio.channels ) {
-      this.channels.audio = await this.other.channels.audio.openchannel( channeldef, this._handlechannelevents.bind( this ) )
+    if( othercall && othercall.channels.audio ) {
+      this.channels.audio = await this.#openchannel( channeldef, othercall )
       return
     }
 
     for( const other of this.relatives ) {
       if( other.channels && other.channels.audio ) {
-        this.channels.audio = await other.channels.audio.openchannel( channeldef, this._handlechannelevents.bind( this ) )
+        this.channels.audio = await this.#openchannel( channeldef, other )
         return
       }
     }
 
-    this.channels.audio = await projectrtp.openchannel( channeldef, this._handlechannelevents.bind( this ) )
+    this.channels.audio = await this.#openchannel( channeldef )
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/babble-drachtio-callmanager",
-  "version": "3.3.3",
+  "version": "3.3.5",
   "description": "Call processing to create a PBX",
   "main": "index.js",
   "scripts": {

package/test/interface/early.js

@@ -20,8 +20,7 @@ describe( "call early", function() {
     clearcallmanager()
   } )
 
-
-  it( "Create call and send 183 - early basic", async () => {
+  it( "Create call and send 183 - early basic prtp - listen mode", async () => {
 
     /*
     Phone                 BV                   Gateway
@@ -163,6 +162,148 @@ a=sendrecv`.replace(/(\r\n|\n|\r)/gm, "\r\n")
     rtpserver.destroy()
   } )
 
+
+  it( "Create call and send 183 - early basic prtp connect mode", async () => {
+
+    /*
+    Phone                 BV                   Gateway
+    |---------INVITE------>|                      |(1)
+    |                      |---------INVITE------>|(2)
+    |                      |<--------183 (w-sdp)--|(3)
+    |<--------183 (w-sdp)--|                      |(4)
+
+    Phone RTP: 192.168.0.200:18540
+    BV RTP: 192.168.0.141
+    Gateway RTP: 192.168.0.160:21000
+    */
+
+    /* Setup the mock RTP server */ 
+    const srfscenario = new srf.srfscenario()
+    const rtpserver = callmanager.projectrtp.proxy.addnode( { host: "127.0.0.1", port: 9002 } )
+
+    let connection
+    const mockrtp = net.createServer()
+    mockrtp.on( "connection", ( c ) => {
+      connection = c
+
+      connection.on( "data", ( data ) => {
+        projectrtpmessage.parsemessage( messagestate, data, ( msg ) => {
+          try{
+            channelmessages.push( msg )
+            if( "open" === msg.channel ) {
+              if( 0 == opencount ) {
+                setTimeout( () => 
+                  connection.write( 
+                    projectrtpmessage.createmessage( 
+                      {"local":{"port":10008,"dtls":
+                        {"fingerprint":"Some fingerprint","enabled":false},
+                      "address":"192.168.0.141"},
+                      "id": msg.id, 
+                      "uuid": uuidv4(),
+                      "action":"open",
+                      "status":{"channel":{"available":4995,"current":5},"workercount":12,"instance":"ca0ef6a9-9174-444d-bdeb-4c9eb54d4566"}
+                      } ) ), 2 )
+              } else {
+                setTimeout( () => 
+                  connection.write( 
+                    projectrtpmessage.createmessage( 
+                      {"local":{"port": 10010,"dtls":
+                        {"fingerprint":"Some fingerprint","enabled":false},
+                      "address":"192.168.0.141"},
+                      "id": msg.id, 
+                      "uuid": uuidv4(),
+                      "action":"open",
+                      "status":{"channel":{"available":4995,"current":5},"workercount":12,"instance":"ca0ef6a9-9174-444d-bdeb-4c9eb54d4566"}
+                      } ) ), 2 )
+              }
+              opencount++
+            } else if ( "close" === msg.channel ) {
+              connection.write( projectrtpmessage.createmessage( {"id": msg.id,"uuid":msg.uuid,"action":"close","reason":"requested","stats":{"in":{"mos":4.5,"count":586,"dropped":0,"skip":0},"out":{"count":303,"skip":0},"tick":{"meanus":124,"maxus":508,"count":597}}, "status":{"channel":{"available":4995,"current":5},"workercount":12,"instance":"ca0ef6a9-9174-444d-bdeb-4c9eb54d4566"}
+              } ) )
+            } else if ( "mix" === msg.channel ) {
+              mixing = true
+            }
+          } catch( e ) {
+            console.error( e )
+          }
+        } )
+      } )
+    } )
+
+    await new Promise( resolve => mockrtp.listen( 9002, resolve ) )
+
+    let mixing
+    const messagestate = projectrtpmessage.newstate()
+    const channelmessages = []
+    let opencount = 0
+
+    /* ensure we are connected */
+    await new Promise( ( resolve ) => setTimeout( () => resolve(), 100 ) )
+
+    srfscenario.oncreateUAC( async ( contact, options, callbacks ) => {
+
+      /* Step 3. This is the mocked gateway message back to our newcall. */
+      callbacks.cbProvisional( {
+        "status": 183,
+        "get": () => { return "INVITE, UPDATE, OPTIONS" },
+        "msg": {
+          "body": `v=0
+o=- 1608235282228 0 IN IP4 127.0.0.1
+s=
+c=IN IP4 192.168.0.160
+t=0 0
+m=audio 21000 RTP/AVP 0 101
+a=rtpmap:101 telephone-event/8000
+a=fmtp:101 0-16
+a=sendrecv`.replace(/(\r\n|\n|\r)/gm, "\r\n")
+        }
+      } )
+
+      await new Promise( ( resolve ) => setTimeout( () => resolve(), 100 ) )
+      throw { "status": 503 }
+    } )
+
+    /* Step 1. Phone sends INVITE */
+    const call = await new Promise( ( resolve ) => {
+      srfscenario.oncall( async ( call ) => { resolve( call ) } )
+      srfscenario.inbound()
+    } )
+
+    /* Step 4. BV sends 183 back to phone */
+    let msgsent, msginfo
+    srfscenario.res.onsend( ( c, i ) => {
+      msgsent = c
+      msginfo = i
+    } )
+
+
+    /* Step 2. New INVITE to the remote Gateway */
+    const newcall = await call.newuac( { "contact": "callto" } )
+    
+    await call._onhangup( "wire" )
+    expect( newcall.state.early ).to.be.true
+    expect( call.state.early ).to.be.true
+    expect( mixing ).to.be.true
+    expect( msgsent ).to.equal( 183 )
+
+    expect( channelmessages[ 0 ].channel ).to.equal( "open" )
+    expect( channelmessages[ 1 ].channel ).to.equal( "remote" )
+    expect( channelmessages[ 1 ].remote.port ).to.equal( 21000 )
+    expect( channelmessages[ 1 ].remote.address ).to.equal( "192.168.0.160" )
+    expect( channelmessages[ 2 ].channel ).to.equal( "open" )
+    expect( channelmessages[ 2 ].remote.port ).to.equal( 18540 )
+    expect( channelmessages[ 2 ].remote.address ).to.equal( "192.168.0.200" )
+    expect( channelmessages[ 3 ].channel ).to.equal( "mix" )
+    expect( channelmessages[ 4 ].channel ).to.equal( "close" )
+    expect( channelmessages[ 5 ].channel ).to.equal( "close" )
+
+    expect( msginfo.body ).to.include( "audio 10010 RTP/AVP" )
+
+    connection.destroy()
+    mockrtp.close()
+    rtpserver.destroy()
+  } )
+
   it( "Create call and send 183 - early - SAVPF", async () => {
 
     /*