SendAction Timeout in multiple instances

[mjcuadrado]

I have a application with multiple instances. When only I have one "SendAction" works perfectly but when I have two or more instances always obtain "Timeout". Example code:

OriginateAction oc = new OriginateAction();
oc.Context = llamada.contexto;
oc.Priority = "1";
oc.Channel = "SIP/" + llamada.hasta + "@" + llamada.proveedor;
oc.CallerId = (llamada.callerID != "" ? llamada.callerID : llamada.hasta); 
oc.Exten = llamada.origen;
oc.Timeout = 27000;
oc.Async = true;
oc.SetVariable("ID", llamada.hasta);
oc.ActionId = ObtenerActionId();

try
{
    originateResponse = _centralita.SendAction(oc,timeOutPeticiones);
}
catch (Exception ex)
{
    Console.WriteLine("Fallo al realizar la llamada");
}
return oc.ActionId;

Interestingly, the call is made but I do not receive the event with the assigned callerid.

Comment that not only happens when doing the Originate, for example also happens with QueueStatusAction so I understand that it is a problem of the "SendAction" function

Can We help me?

[mjcuadrado]

Paste my Asternet Abstraction Class

Click to view full code

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using System.Linq;
using AsterNET.Manager;
using AsterNET.Manager.Action;
using AsterNET.Manager.Event;
using AsterNET.Manager.Response;

namespace XXXXX.XXAsterisk
{
    public class ConexionAsterisk : Funciones, IConexionAsterisk
    {
        private int timeOutPeticiones = 15000;
        private Timer _temporizador;

        private  ManagerConnection _centralita;

       
        public int _IdEnvio { get; set; }
        public string _ColaMarcador { get; set; }
        public int getAgentesLibres { get; set; }

        public int getLlamadasEnCola { get; set; }

        public int getTiempoMedioEspera { get; set; }
        public int _Abandonadas { get; set; }

        public string _Proveedor { get; set; }



        public List<string> ActionIdsMarcador { get; set; }

        
        public event EventHandler AgentesLibres;

        public event EventHandler ResultadoLlamada;


        //public ConexionAsterisk(int idEnvio, string cola)
        //{
        //    ActionIdsMarcador = new List<string>();
        //   _IdEnvio = idEnvio;
        //    _Proveedor = "vozcom2";
        //    _ColaMarcador = cola;
        //    InicializarCentralita();
        //}


        public ConexionAsterisk()
        {
            ActionIdsMarcador = new List<string>();
            _Proveedor = "vozcom2";

        }

         public void InicializarCentralita(string cola)
        {
            //Task.Run(() => {
         
            _ColaMarcador = cola;
            _centralita = new ManagerConnection() ;
            _centralita.Username = "XXX";
            _centralita.Password = "XXXX";
            _centralita.Hostname = "192.168.XXX.XXX";
            _centralita.Port = 5038;
            _centralita.UseASyncEvents = true;
      

            _temporizador = new Timer();
            _temporizador.Elapsed += new ElapsedEventHandler(OnTimedEvent);
            _temporizador.Interval = 5000;
            _centralita.Login();
           if (_centralita.IsConnected())
            {
                _temporizador.Start();
            }


            _centralita.OriginateResponse += new EventHandler<OriginateResponseEvent>(OrginateEventsHandler);
            
            _centralita.QueueMember += new EventHandler<QueueMemberEvent>(QueueMemberHandler);
            _centralita.QueueStatusComplete += new EventHandler<QueueStatusCompleteEvent>(QueueCompleteHandler);
            _centralita.QueueParams += new EventHandler<QueueParamsEvent>(QueueParamsHandler);
            _centralita.QueueMemberStatus += new EventHandler<QueueMemberStatusEvent>(QueueStatusEventHandler);

            //});

        }

        private async void OnTimedEvent(object source, ElapsedEventArgs e)
        {

            if (EsDiaLaborable() && EsHorarioLaboral())
            {
         
         

                getAgentesLibres =  ComprobarAgentesLibres();

                if (getAgentesLibres>0)
                {
                    OnAgentesLibres(new EventArgs());
                }
                else
                {
                    Console.WriteLine(string.Format("{1} - {0} - > No hay agentes libres", _ColaMarcador, DateTime.Now));
                }
            }
            else
            {

            }

        }




        #region FuncionesCentralita
        object _lockAgentes = new object();
        private int ComprobarAgentesLibres()
        {
            
            //int agentes = 0;
            //if (!_centralita.IsConnected())
            //{
            //    Console.WriteLine("No estamos conectados");
            //    return 0;
            //}
            //agentes = await Task<int>.Factory.StartNew(() =>
            //{


            //    int members = 0;



                ////try
                ////{
                ////    QueueStatusAction acc = new QueueStatusAction();
                ////    acc.Queue = _ColaMarcador;
                ////    acc.ActionId = ObtenerActionId();
                ////    _centralita.SendAction(acc, timeOutPeticiones);
                ////}
                ////catch (Exception e)
                ////{

                ////}



                //QueueStatusAction acc = new QueueStatusAction();
                //acc.Queue = _ColaMarcador;
                //acc.ActionId = ObtenerActionId();

                //try
                //{
                //    //_manager.SendAction(acc);
                //    ResponseEvents aux = _centralita.SendEventGeneratingAction(acc, timeOutPeticiones);
                //    ResponseEvent e;
                //    for (int i = 0; i < aux.Events.Count; i++)
                //    {
                //        e = aux.Events[i];
                //        if (typeof(QueueMemberEvent) == e.GetType())
                //        {
                //            if ((((QueueMemberEvent)e).Status == 1) && !((QueueMemberEvent)e).Paused)
                //                members += 1;
                //        }
                //    }
                //}
                //catch (Exception ex)
                //{
                //    members = -1;
                //    //Reconectar(true);
                //    Console.WriteLine(ex.ToString());


                //}

                //return members;

            //    foreach (var agent in AgentesCola)
            //    {
            //        if(agent.status == 1)
            //        {
            //            members += 1;
            //        }
            //    }
            //    return members;
            //});

          lock (_lockAgentes)
            {
                int agentes = 0;
                foreach (var agent in AgentesCola)
                {
                    if (agent.status == 1 && !agent.pausado)
                    {
                        agentes += 1;
                    }
                }

                return agentes;

            }




        }

        private async void ComprobarLLamadasEnCurso()
        {

            await Task.Factory.StartNew(() => {
                try
                {
                    QueueStatusAction acc = new QueueStatusAction();
                    acc.Queue = _ColaMarcador;
                    acc.ActionId = ObtenerActionId();
                    _centralita.SendAction(acc, timeOutPeticiones);
                }
                catch (Exception ex)
                {

                }
            });


        }
        protected void OnAgentesLibres(EventArgs e)
        {
            AgentesLibres?.Invoke(this, e);
        }

        public struct Llamada
        {
            public string origen { get; set; }
            public string hasta { get; set; }
            public string contexto { get; set; }

            public string proveedor { get; set; }

            public string callerID { get; set; }
            public int timeOut { get; set; }


        }


        object _lockLlamadas = new object();
        public async Task<string> Llamar(Llamada llamada)
        {
            lock (_lockLlamadas)
            {
                if (EsDiaLaborable() && EsHorarioLaboral())
                {

                    if (llamada.origen == "" || llamada.origen == null)
                    {
                        llamada.origen = _ColaMarcador;
                    }

                    if (llamada.contexto == "" || llamada.contexto == null)
                    {
                        llamada.contexto = string.Format("marcador{0}", llamada.origen);
                    }


                    //string result = await Task.Run(() =>
                    //{
                    ManagerResponse originateResponse;
                    if (!Conectado())
                    {
                        Reconectar();
                    }

                    OriginateAction oc = new OriginateAction();

                  
                    oc.Context = llamada.contexto;
                    oc.Priority = "1";
                    oc.Channel = "SIP/" + llamada.hasta + "@" + llamada.proveedor;
                    oc.CallerId = (llamada.callerID != "" ? llamada.callerID : llamada.hasta); //+ "<" + hasta + ">";
                    oc.Exten = llamada.origen;
                    oc.Timeout = 27000;
                    oc.Async = true;
                    oc.SetVariable("ID", llamada.hasta);
                    oc.ActionId = ObtenerActionId();


                    try
                    {
                        //var reset = new System.Threading.AutoResetEvent(false);
                        //ResponseHandler response = new ResponseHandler(oc, reset);
                       // _centralita.SendAction(oc, response);

                        originateResponse = _centralita.SendAction(oc,timeOutPeticiones);

                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Fallo al realizar la llamada");

                    }
                    return oc.ActionId;
                    //});

                    //return result;
                }
                else
                {
                    return "";
                }

            }


        }

        public bool Conectado()
        {
            return _centralita.IsConnected();
        }


        public bool Reconectar(bool forzado=false)
        {
            bool result;
            if (!_centralita.IsConnected())
            {
                try
                {
                    _centralita.Login();
                    result = true;
                }
                catch (Exception ex)
                {
                    result = false;
                }
            }
            else
                result = true;

            return result;
        }

        #endregion

        #region "Manejadores eventos"

        private void QueueStatusEventHandler(object sender, QueueMemberStatusEvent e)
        {
            if (e.Queue == _ColaMarcador)
            {

                if (AgentesCola.Where(x => x.agente == e.Location).Count() == 0)
                {
                    var Agent = new Agente();
                    Agent.agente = e.Location;
                    Agent.pausado = e.Paused;
                    Agent.status = e.Status;
                    AgentesCola.Add(Agent);
                }
                else
                {
                    foreach (var agent in AgentesCola.Where(x => x.agente == e.Location))
                    {
                        agent.pausado = e.Paused;
                        agent.status = e.Status;
                    }
                }
            }
        }

        private void OrginateEventsHandler(Object sender, OriginateResponseEvent e)
        {
            if (ActionIdsMarcador.Contains(e.ActionId))
            {
                var resultado = new ResultadoLlamadaEventArgs();
                resultado.ActionID = e.ActionId;
                resultado.Resultado = e.Reason;
                ResultadoLlamada?.Invoke(sender, resultado);
            }
        
        }


        
        List<Agente> AgentesCola = new List<Agente>();
        private void QueueMemberHandler(Object sender, QueueMemberEvent e)
        {
            //Console.WriteLine(e.ToString());
            if (ActionIdsMarcador.Contains(e.ActionId))
            {
                
                if (e.Queue == _ColaMarcador)
                {
                   
                   if( AgentesCola.Where(x=> x.agente == e.Location).Count() == 0)
                    {
                        var Agent = new Agente();
                        Agent.agente = e.Location;
                        Agent.pausado = e.Paused;
                        Agent.status = e.Status;
                        AgentesCola.Add(Agent);
                    }
                    else
                    {
                        foreach(var agent in AgentesCola.Where(x => x.agente == e.Location))
                        {
                            agent.pausado = e.Paused;
                            agent.status = e.Status;
                        }
                    }

                    //agente Agent = new agente();
                    //Agent.location = e.Location;
                    //Agent.paused = e.Paused;
                }


            }

            //    if (ActionIdsMarcador.Contains(e.ActionId))
            //    {
            //    int agentesLibres = 0;
            //        if (!e.Paused && e.Status == 1)
            //        {
            //        agentesLibres += 1;
            //        }
            //    if (!_agentesCola[e.Queue].ContainsKey(e.Location))
            //    {
            //        //_agentesCola[e.Queue].Add(e.Location, (EstadoAgente)Enum.ToObject(typeof(InfoAgente.EstadoAgente), e.Status));
            //        InfoAgente aux = new InfoAgente();
            //        aux.pausado = e.Paused;
            //        aux.estado = (InfoAgente.EstadoAgente)Enum.ToObject(typeof(InfoAgente.EstadoAgente), e.Status);
            //        _agentesCola[e.Queue].Add(e.Location, aux);
            //    }
            //    else
            //    {
            //        //_agentesCola[e.Queue][e.Location] = (EstadoAgente)Enum.ToObject(typeof(EstadoAgente), e.Status);
            //        InfoAgente aux = new InfoAgente();
            //        aux.pausado = e.Paused;
            //        aux.estado = (InfoAgente.EstadoAgente)Enum.ToObject(typeof(InfoAgente.EstadoAgente), e.Status);
            //        _agentesCola[e.Queue][e.Location] = aux;
            //    }
            //}

        }



        private void QueueParamsHandler(Object sender, QueueParamsEvent e)
        {
            //Comprobar actionId
            getLlamadasEnCola= e.Calls;
            getTiempoMedioEspera = e.Holdtime;
            _Abandonadas = e.Abandoned;


        }


        private void QueueCompleteHandler(Object sender, QueueStatusCompleteEvent e)
        {
           
                    if (ActionIdsMarcador.Contains(e.ActionId))
                    {
                        //Console.WriteLine("mirame");
                    }
        }

        #endregion

        private object _lockActionID = new object();
        public string ObtenerActionId()
        {
            lock (_lockActionID)
            {
                string acc = string.Format("{0}_{1}", _ColaMarcador, DateTime.Now.Ticks.ToString());
                ActionIdsMarcador.Add(acc);
                return acc;
            }

        }

    }
}

[Deantwo]

First of all, stop using your two methods Conectado() and Reconectar(bool).
IsConnected() is unreliable because it just checks the status of the underlying TCP socket and AsterNET already attempts to reconnect on its own, you doing it on your own on top of it is just causing more issues than good.
See: #150

Instead you should just catch the SystemException thrown by SendAction when the connection is not op at the time of the action.

[mjcuadrado]

Thanks, Monday I'll try yours advices., but when I debug my app Asternet is connected.

Today I have been testing SendActionAsync (new version). When I have only one instance, OriginateAction take about 1 second and OriginateEvent fires ok. Then, when I have 2 or 3 instances actions take 60-70 seconds and OriginateEvents fires ok.

Any Idea?

Thanks again!

[mjcuadrado]

Hi All,

I found the problem.

If we have multiple instances with same credentials (and same Asterisk server) and we receive a Disconnected manager event, the DispatchEvent launch reconnect function and clear "responseHandlers" Lists in all instances. If we launch other action in other instance we have a timeout exception.

We disabled responseEventHandlers.Clear(), responseHandlers.Clear() and pingHandlers.Clear() and we are trying the solution at this moment.

Can you try this solution?

Thanks.

[Deantwo]

You mean you have multiple instances from the same computer to the server at the same time? Or from multiple computers with one instance each to the server?

And I am guessing you mean the dictionary.Clear() calls on ManagerConnection.cs#L1147?
They are private Dictionaries, so I don't see how those clearing would affect anything.
If you do have multiple instances from the same computer to the Asterisk server, then I guess the Asterisk server could possibly disconnect all the connections from that computer, but I am not sure that is what you mean.

[mjcuadrado]

I have multiple instances in same computer at the same time. Asterisk servers sends discconnect event to others instances and Asternet clear alls dictionarys and reconect all instances.

For example:

I have 3 instances: A, B, C

Instance A connect and I will send every second a Status Action.
Instance B connect, Instance A, when instance B connect, recive Disconnect event. Asternet reconnect instance A and pending Actions gets timeout because don't have in responseHandlers dictonary (Disconect event has clear dictionary of instance)
If I trying connect instance C, I'll recive disconnect event in the instance A and B.