@babblevoice/babble-drachtio-callmanager 3.3.4 → 3.3.6

package/lib/call.js

@@ -1150,17 +1150,7 @@ class call {
     /* maintain privacy */
     other.options.privacy = this.options.privacy
 
-    if( mix ) {
-      this.channels.audio.mix( other.channels.audio )
-
-      this._em.emit( "call.mix", this )
-      callmanager.options.em.emit( "call.mix", this )
-      other._em.emit( "call.mix", other )
-      callmanager.options.em.emit( "call.mix", other )
-
-      this.epochs.mix = Math.floor( +new Date() / 1000 )
-      other.epochs.mix = Math.floor( +new Date() / 1000 )
-    }
+    if( mix ) this.mix( other )
     return this
   }
 
@@ -1721,7 +1711,7 @@ class call {
     this.channels.count--
 
     if ( 0 === this.channels.count ) {
-      this.channels.audio = false
+      this.channels.audio = undefined
 
       if( this._state._onhangup ) {
         this._cleanup()
@@ -2045,7 +2035,7 @@ class call {
 
   /**
     Mix two calls. If the two calls are on a different node
-    the second call is bonded and reinvited.
+    the other call is bonded and reinvited.
     @param { call } othercall - our call object which is early
     @private
   */
@@ -2057,8 +2047,7 @@ class call {
       const channeldef = await othercall.#createchannelremotedef()
 
       const oldchannel = othercall.channels.audio
-      const newchannel = await this.#openchannel( channeldef, othercall )
-
+      const newchannel = await this.#openchannel( channeldef, this )
       await othercall.bond( this ).reinvite( channeldef, newchannel )
 
       await oldchannel.unmix()
@@ -2066,30 +2055,35 @@ class call {
     }
 
     await this.channels.audio.mix( othercall.channels.audio )
+
+    this._em.emit( "call.mix", this )
+    callmanager.options.em.emit( "call.mix", this )
+    othercall._em.emit( "call.mix", othercall )
+    callmanager.options.em.emit( "call.mix", othercall )
+
+    this.epochs.mix = Math.floor( +new Date() / 1000 )
+    othercall.epochs.mix = Math.floor( +new Date() / 1000 )
   }
 
   /**
     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
+    @param { call } [ bindcall ] - the call which will own the channel
   */
   async #openchannel( channeldef, bindcall ) {
 
-    let chan = undefined
-
-    if ( !bindcall || !this.channels.audio ) {
-      chan = await projectrtp.openchannel(
+    if ( bindcall && bindcall.channels.audio ) {
+      const chan = await bindcall.channels.audio.openchannel(
         channeldef, this._handlechannelevents.bind( this ) )
-    } else {
-      chan = await this.channels.audio.openchannel(
-        channeldef, bindcall._handlechannelevents.bind( bindcall ) )
-    }
 
-    if ( bindcall )
-      bindcall.channels.count++
-    else
       this.channels.count++
+      return chan
+    }
+
+    const chan = await projectrtp.openchannel(
+      channeldef, this._handlechannelevents.bind( this ) )
+    this.channels.count++
 
     return chan
   }
@@ -2939,19 +2933,19 @@ 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.#openchannel( channeldef, 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.#openchannel( channeldef, this )
+        this.channels.audio = await this.#openchannel( channeldef, other )
         return
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/babble-drachtio-callmanager",
-  "version": "3.3.4",
+  "version": "3.3.6",
   "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 () => {
 
     /*