@babblevoice/babble-drachtio-callmanager 3.8.0 → 3.9.0

package/lib/call.js

@@ -293,6 +293,12 @@ class call {
     */
     this.parent = undefined
 
+    /**
+    * @summary Lifecycle callbacks supplied to newuac for this (outbound) call.
+    * @type { newuaccallbacks }
+    */
+    this.callbacks = {}
+
     /** @summary Other channels which we might need - for things like opening a channel on the same node. */
     this.relatives = new Set()
 
@@ -1472,6 +1478,15 @@ class call {
     this.epochs.mix = Math.floor( +new Date() / 1000 )
     if( this.parent ) this.parent.epochs.mix = Math.floor( +new Date() / 1000 )
 
+    /* Now we are bridged/mixed with our parent, notify any onconnect handler. */
+    if( this.callbacks.onconnect ) {
+      try {
+        await this.callbacks.onconnect( this )
+      } catch( e ) {
+        console.trace( e )
+      }
+    }
+
     return this
   }
 
@@ -1973,6 +1988,16 @@ class call {
 
     if( options.early ) {
       this.state.early = true
+
+      /* The call is now progressing with early media. Cancel the ring (uac)
+         timeout: a far end that delivers early media (e.g. a carrier sending
+         183 Session Progress) and answers only after the ring timeout would
+         otherwise be torn down with a REQUEST_TIMEOUT (487) just before it
+         answers. Once the dialog is established the non-early answer path
+         clears this timer via #setdialog. */
+      clearTimeout( this._timers.newuac )
+      delete this._timers.newuac
+
       this._em.emit( "call.early", this )
       callmanager.options.em.emit( "call.early", this )
     } else {
@@ -3798,6 +3823,8 @@ class call {
       return this
     }
 
+    this.callbacks = callbacks
+
     if( this.parent ) {
       const hangups = []
       for( const child of this.parent.children ) {
@@ -4052,11 +4079,18 @@ class call {
    * @param { call } call - our call object which is early
    */
 
+  /**
+   * @callback onconnectcallback
+   * @async
+   * @param { call } call - the (outbound) call which has just connected and been bridged with its parent
+   */
+
   /**
    * @typedef { object } newuaccallbacks
    * @property { earlycallback } [ early ] - callback to provide a call object with early call (pre dialog)
    * @property { confirmcallback } [ confirm ] - called when a dialog is confirmed but before it is bridged with a parent - this provides an opportunity for another call to adopt this call
    * @property { failcallback } [ fail ] - Called when child is terminated
+   * @property { onconnectcallback } [ onconnect ] - called after this call has connected and been bridged/mixed with its parent
    */
 
   /**
@@ -4112,10 +4146,12 @@ class call {
     newcall.#confignetwork( options )
 
     let newdialog, earlypromise
+    let settlewatchdog
     try {
       await newcall.#openchannelsfornewuac()
 
-      newdialog = await callmanager.options.srf.createUAC(
+      const settlems = newcall.options.uactimeout || callmanager.options.uactimeout
+      const createuacpromise = callmanager.options.srf.createUAC(
         options.contact + newcall.options.contactparams,
         {
           ...newcall.options,
@@ -4172,6 +4208,18 @@ class call {
             }
           }
         } )
+
+      const settlewatchdogpromise = new Promise( ( resolve, reject ) => {
+        settlewatchdog = setTimeout( async () => {
+          try {
+            await newcall.hangup( hangupcodes.REQUEST_TIMEOUT )
+          } catch ( e ) { /* silent */ }
+
+          reject( Object.assign( new Error( "newuac settle timeout" ), { status: 408 } ) )
+        }, settlems )
+      } )
+
+      newdialog = await Promise.race( [ createuacpromise, settlewatchdogpromise ] )
     } catch ( err ) {
       newcall.#onnewuaccatch( err )
       try{
@@ -4194,6 +4242,8 @@ class call {
           }
         }
       } catch( e ) { console.error( e ) }
+    } finally {
+      if( settlewatchdog ) clearTimeout( settlewatchdog )
     }
 
     if( earlypromise ) await earlypromise

package/package.json

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

package/test/interface/call.js

@@ -177,6 +177,54 @@ describe( "call object", function() {
 
   } )
 
+  it( "uas.newuac - onconnect callback is called after bridge with valid audio", async function() {
+
+    const srfscenario = new srf.srfscenario()
+
+    const call = await new Promise( ( resolve ) => {
+      srfscenario.oncall( async ( call ) => { resolve( call ) } )
+      srfscenario.inbound()
+    } )
+
+    let onconnectcount = 0
+    let connectedcall
+    let audioatconnect
+    let mixepochatconnect
+
+    const child = await call.newuac( { "contact": "1000@dummy" }, {
+      "onconnect": ( c ) => {
+        onconnectcount++
+        connectedcall = c
+        audioatconnect = c.channels.audio
+        mixepochatconnect = c.epochs.mix
+      }
+    } )
+
+    /* the handler ran exactly once, during newuac */
+    expect( onconnectcount ).to.equal( 1 )
+
+    /* it received the connected (child) call */
+    expect( connectedcall ).to.equal( child )
+
+    /* the audio channel was a valid object inside the handler - it must not
+       go undefined/false (the regression this callback originally exposed) */
+    expect( audioatconnect ).to.be.an( "object" )
+    expect( child.channels.audio ).to.equal( audioatconnect )
+
+    /* it fired AFTER the mix, i.e. once genuinely connected/bridged */
+    expect( mixepochatconnect ).to.be.a( "number" ).that.is.above( 0 )
+
+    await child.hangup()
+    await call.hangup()
+
+    expect( await callstore.stats() ).to.deep.include( {
+      "storebycallid": 0,
+      "storebyuuid": 0,
+      "storebyentity": 0
+    } )
+
+  } )
+
   it( "uas.newuac - create uac by entity no registrar", async function() {
     const srfscenario = new srf.srfscenario()
 
@@ -469,6 +517,47 @@ describe( "call object", function() {
     expect( child.state.cleaned ).to.be.true
   } )
 
+  it( "uas.newuac - createUAC never settles - watchdog forces return", async function() {
+
+    const srfscenario = new srf.srfscenario()
+    /* simulate a far end that never sends a final response and never honours
+       CANCEL: createUAC never resolves or rejects. Without the settle watchdog
+       newuac would hang here forever (and this test would hit the mocha timeout). */
+    srfscenario.oncreateUAC( () => new Promise( () => {} ) )
+
+    const call = await new Promise( ( resolve ) => {
+      srfscenario.oncall( async ( call ) => { resolve( call ) } )
+      srfscenario.inbound()
+    } )
+
+    const start = Date.now()
+    const child = await call.newuac( { "contact": "1000@dummy", "uactimeout": 50 } )
+    const elapsed = Date.now() - start
+
+    /* the watchdog must make newuac return promptly (~uactimeout) rather than
+       block on the never-settling createUAC */
+    expect( elapsed ).to.be.below( 1000 )
+
+    expect( child.destroyed ).to.be.true
+    expect( child.hangup_cause.sip ).to.equal( 408 )
+    expect( child.hangup_cause.reason ).to.equal( "REQUEST_TIMEOUT" )
+    expect( child.hangup_cause.src ).to.equal( "us" )
+
+    /* clean up runs on the event loop */
+    await new Promise( resolve => setTimeout( resolve, 100 ) )
+
+    await call.hangup()
+
+    expect( await callstore.stats() ).to.deep.include( {
+      "storebycallid": 0,
+      "storebyuuid": 0,
+      "storebyentity": 0
+    } )
+
+    expect( call.state.cleaned ).to.be.true
+    expect( child.state.cleaned ).to.be.true
+  } )
+
   it( "uas.newuac - child remote hangup", async function() {
 
     const srfscenario = new srf.srfscenario()