Async issues with API calls about esl

[grEvenX]

Tested out the lastest in master-branch utilizing Q/promises which has a similar issue. In this case however the correct callback is called in time, just with the wrong result in one of the cases.

In this case the result of the operation is

Callback1: 1325376000
Callback2: 1325376000

The code I used following the example in the Readme.md is:

(function () {
   'use strict';

    var esl = require('./esl/lib/esl');

    esl.client( function (eslResponse) {
        console.log("...Connected to FS");

        eslResponse.sequence([
            function () {
                this.api('strepoch 2013-01-01').then(function(apiResponse) {
                    console.log("Callback1: " + apiResponse.body);
                    return Q(true);
                });
            }, function () {
                return this.api('strepoch 2012-01-01').then(function(apiResponse2) {
                    console.log("Callback2: " + apiResponse2.body);
                    return Q(true);
                });
            }
        ]);
    }).connect(8021, '127.0.0.1');
}());

The full output when running this is:

27 Jun 07:17:05 - { when: 'connection listener emit freeswitch_connect',
  call: 
   { socket: 
      { _events: [Object],
        _connecting: false,
        _handle: [Object],
        _readableState: [Object],
        readable: true,
        domain: null,
        _maxListeners: 10,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: false,
        onend: null,
        destroyed: false,
        errorEmitted: false,
        bytesRead: 0,
        _bytesDispatched: 0,
        _pendingData: null,
        _pendingEncoding: '',
        pipe: [Function],
        addListener: [Function],
        on: [Function],
        pause: [Function],
        resume: [Function],
        read: [Function],
        _consuming: true } } }
27 Jun 07:17:05 - { headers: { 'Content-Type': 'auth/request' }, body: undefined }
27 Jun 07:17:05 - { when: 'connection listener socket.emit',
  event: 'freeswitch_auth_request',
  call: 
   { socket: 
      { _events: [Object],
        _connecting: false,
        _handle: [Object],
        _readableState: [Object],
        readable: true,
        domain: null,
        _maxListeners: 10,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: false,
        onend: null,
        destroyed: false,
        errorEmitted: false,
        bytesRead: 28,
        _bytesDispatched: 0,
        _pendingData: null,
        _pendingEncoding: '',
        pipe: [Function],
        addListener: [Function],
        on: [Function],
        pause: [Function],
        resume: [Function],
        read: [Function],
        _consuming: true },
     headers: { 'Content-Type': 'auth/request' },
     body: undefined } }
27 Jun 07:17:05 - { when: 'Challenged for authentication' }
27 Jun 07:17:05 - { headers: 
   { 'Content-Type': 'command/reply',
     'Reply-Text': '+OK accepted' },
  body: undefined }
27 Jun 07:17:05 - { when: 'connection listener socket.emit',
  event: 'freeswitch_command_reply',
  call: 
   { socket: 
      { _events: [Object],
        _connecting: false,
        _handle: [Object],
        _readableState: [Object],
        readable: true,
        domain: null,
        _maxListeners: 10,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: false,
        onend: null,
        destroyed: false,
        errorEmitted: false,
        bytesRead: 82,
        _bytesDispatched: 14,
        _pendingData: null,
        _pendingEncoding: '',
        pipe: [Function],
        addListener: [Function],
        on: [Function],
        pause: [Function],
        resume: [Function],
        read: [Function],
        _consuming: true },
     headers: 
      { 'Content-Type': 'command/reply',
        'Reply-Text': '+OK accepted' },
     body: undefined } }
27 Jun 07:17:05 - { when: 'Authentication sent',
  call: 
   { socket: 
      { _events: [Object],
        _connecting: false,
        _handle: [Object],
        _readableState: [Object],
        readable: true,
        domain: null,
        _maxListeners: 10,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: false,
        onend: null,
        destroyed: false,
        errorEmitted: false,
        bytesRead: 82,
        _bytesDispatched: 14,
        _pendingData: null,
        _pendingEncoding: '',
        pipe: [Function],
        addListener: [Function],
        on: [Function],
        pause: [Function],
        resume: [Function],
        read: [Function],
        _consuming: true },
     headers: 
      { 'Content-Type': 'command/reply',
        'Reply-Text': '+OK accepted' },
     body: undefined } }
...Connected to FS
27 Jun 07:17:05 - { headers: { 'Content-Type': 'api/response', 'Content-Length': '10' },
  body: '1356998400' }
27 Jun 07:17:05 - { when: 'connection listener socket.emit',
  event: 'freeswitch_api_response',
  call: 
   { socket: 
      { _events: [Object],
        _connecting: false,
        _handle: [Object],
        _readableState: [Object],
        readable: true,
        domain: null,
        _maxListeners: 10,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: false,
        onend: null,
        destroyed: false,
        errorEmitted: false,
        bytesRead: 196,
        _bytesDispatched: 64,
        _pendingData: null,
        _pendingEncoding: '',
        pipe: [Function],
        addListener: [Function],
        on: [Function],
        pause: [Function],
        resume: [Function],
        read: [Function],
        _consuming: true },
     headers: { 'Content-Type': 'api/response', 'Content-Length': '10' },
     body: '1356998400' } }
27 Jun 07:17:05 - { headers: { 'Content-Type': 'api/response', 'Content-Length': '10' },
  body: '1325376000' }
27 Jun 07:17:05 - { when: 'connection listener socket.emit',
  event: 'freeswitch_api_response',
  call: 
   { socket: 
      { _events: [Object],
        _connecting: false,
        _handle: [Object],
        _readableState: [Object],
        readable: true,
        domain: null,
        _maxListeners: 10,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: false,
        onend: null,
        destroyed: false,
        errorEmitted: false,
        bytesRead: 196,
        _bytesDispatched: 64,
        _pendingData: null,
        _pendingEncoding: '',
        pipe: [Function],
        addListener: [Function],
        on: [Function],
        pause: [Function],
        resume: [Function],
        read: [Function],
        _consuming: true },
     headers: { 'Content-Type': 'api/response', 'Content-Length': '10' },
     body: '1325376000' } }
Callback1: 1325376000
Callback2: 1325376000

[shimaore]

(Sorry for the delay, just came back from vacation.)

In the 0.3.2 test you would have to send the request sequentially by calling eslResponse.api('conference list'..) from within the callback of the first call to eslResponse.api.

In the 1.0 version .sequence should do it for you, but I suspect it gets confused by return Q(true). I think return (or simply omitting the return statement) should do the trick. Edit: it doesn't, see below for the solution.

[shimaore]

In 1.0 the proper way to do it is:

(function () {
    var esl = require('./esl/lib/esl');

    esl.client( function (eslResponse) {
        console.log("...Connected to FS");

        eslResponse.sequence([
            function () {
                return this.api('strepoch 2013-01-01');
            }
          , function() {
                console.log("Callback1: " + this.body);
            }
          , function () {
                return this.api('strepoch 2012-01-01');
            }
          , function() {
                console.log("Callback2: " + this.body);
            }
        ]);
    }).connect(8021, '127.0.0.1');
}());

[shimaore]

Obsoleted in 2.x. The proper way to do it would now look like:

    @api 'sofia status'
    .then (res) ->
      console.log res.body
      @api 'conference list'
    .then (res) ->
      console.log res.body