Exemple #1
0
        /// <summary>
        /// Aborta um canal
        /// </summary>
        /// <param name="canal"></param>
        private void _resetCanal(CanalInfo canal)
        {
            try
            {
                Ativador.AbortChannel(canal.roteador);
                Ativador.AbortChannel(canal.assinatura);
            }
            catch (Exception ex)
            {
                logger.Error("_resetCanal():" + ex.Message, ex);
            }

            canal.Conectado = false;

            try
            {
                logger.Info("Canal: " + canal.Exchange + "-" + canal.ChannelID);

                canal.roteador    = RoteadorCanalComunic.GetChannel <IRoteadorOrdens>(canal.RoteadorAddress, null);
                canal.assinatura  = RoteadorCanalComunic.GetChannel <IAssinaturasRoteadorOrdensCallback>(canal.AssinaturaAddress, this);
                canal.roteadorAdm = RoteadorCanalComunic.GetChannel <IRoteadorOrdensAdmin>(canal.RoteadorAdmAddress, null);

                logger.Info("Canal: " + canal.Exchange + "-" + canal.ChannelID + " assinando eventos de status");
                canal.assinatura.AssinarExecucaoOrdens(new AssinarExecucaoOrdemRequest());
                canal.assinatura.AssinarStatusConexaoBolsa(new AssinarStatusConexaoBolsaRequest());
            }
            catch (Exception ex)
            {
                logger.Error("_resetCanal():" + ex.Message, ex);
            }
        }
Exemple #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="report"></param>
        public void OrdemAlterada(OrdemInfo report)
        {
            // Envia o report para os assinantes
            logger.Debug("On OrdemAlterada(): recebeu report ");

            TradutorFix.DumpOrdemInfo(report);

            lock (_executionsReportsSubscribers)
            {
                if (_executionsReportsSubscribers.Count > 0)
                {
                    _sendExecutionReport(report);
                }
                else
                {
                    _enqueueExecutionReport(report);
                }
            }


            // Reseta o contador do heartbeat
            lock (_canais)
            {
                if (_canais.ContainsKey(report.Exchange + report.ChannelID))
                {
                    CanalInfo canal = (CanalInfo)_canais[report.Exchange + report.ChannelID];
                    canal.Conectado     = true;
                    canal.LastHeartbeat = _getSecsFromTicks(DateTime.Now.Ticks);
                }
            }
        }
Exemple #3
0
        /// <summary>
        /// Envia um pedido de execucao de ordem para o canal correspondente
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public ExecutarOrdemResponse ExecutarOrdem(ExecutarOrdemRequest request)
        {
            ExecutarOrdemResponse response = new ExecutarOrdemResponse();
            CanalInfo             _canal   = null;
            StatusRoteamentoEnum  status   = StatusRoteamentoEnum.Sucesso;
            string msg = "Ordem Enviada";

            logger.Debug("*** ExecutarOrdem()");

            TradutorFix.DumpOrdemInfo(request.info);

            try
            {
                _canal = (CanalInfo)_canais[request.info.Exchange + request.info.ChannelID];

                if (_canal == null)
                {
                    msg    = "Nao ha canal configurado para " + request.info.Exchange + "-" + request.info.ChannelID;
                    status = StatusRoteamentoEnum.Erro;
                    logger.Info(msg);
                    response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaEO(msg, status);
                }
                else
                {
                    if (_canal.roteador == null || _canal.Conectado == false)
                    {
                        status = StatusRoteamentoEnum.Erro;
                        msg    = "Nao ha canal ativo e conectado para " + request.info.Exchange + "-" + request.info.ChannelID;
                        logger.Info(msg);
                        response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaEO(msg, status);
                    }
                    else
                    {
                        _criaReportStore(request.info.ClOrdID);

                        _notificaEnvioParaCanal(request.info);

                        response = _canal.roteador.ExecutarOrdem(request);
                    }
                }
            }
            catch (Exception ex)
            {
                msg    = "Error ExecutarOrdem(): " + ex.Message;
                status = StatusRoteamentoEnum.Erro;
                logger.Error(msg + "-" + ex.StackTrace);
                response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaEO(msg, status);

                if (_canal != null)
                {
                    _resetCanal(_canal);
                }
            }

            logger.Debug("*** End of ExecutarOrdem()");

            return(response);
        }
Exemple #4
0
        private void _carregarCanais()
        {
            // Carrega a tabela de canais
            foreach (CanalConfig canal in _config.Canais)
            {
                logger.Info("Carregando informação do canal: " + canal.Exchange);
                logger.Info("Porta ........................: " + canal.ChannelID);
                logger.Info("EndPointRoteader .............: " + canal.EndPointRoteador);
                logger.Info("EndPointAssinatura ...........: " + canal.EndPointAssinatura);
                logger.Info("EndPointRoteadorAdm ..........: " + canal.EndPointRoteadorAdm);

                CanalInfo info = new CanalInfo();

                info.ChannelID          = canal.ChannelID;
                info.Exchange           = canal.Exchange;
                info.RoteadorAddress    = canal.EndPointRoteador;
                info.AssinaturaAddress  = canal.EndPointAssinatura;
                info.RoteadorAdmAddress = canal.EndPointRoteadorAdm;

                info.assinatura  = null;
                info.roteador    = null;
                info.roteadorAdm = null;

                _canais.Add(info.Exchange + info.ChannelID, info);
            }

            logger.Info("Obtendo instancias de assinatura e envio de ordens");

            // Assina cada um dos eventos dos canais
            foreach (CanalInfo canal in _canais.Values)
            {
                try
                {
                    canal.roteador    = RoteadorCanalComunic.GetChannel <IRoteadorOrdens>(canal.RoteadorAddress, null);
                    canal.assinatura  = RoteadorCanalComunic.GetChannel <IAssinaturasRoteadorOrdensCallback>(canal.AssinaturaAddress, this);
                    canal.roteadorAdm = RoteadorCanalComunic.GetChannel <IRoteadorOrdensAdmin>(canal.RoteadorAdmAddress, null);

                    canal.assinatura.AssinarExecucaoOrdens(new AssinarExecucaoOrdemRequest());
                }
                catch (EndpointNotFoundException enfex)
                {
                    logger.Error("Nao pode conectar no canal" + canal.Exchange + "-" + canal.ChannelID + " [" + enfex.Message + "]");
                    canal.Conectado = false;
                }
            }

            logger.Info(_canais.Count + " canais carregados");
        }
Exemple #5
0
        private void ProcessadorCancelamentos()
        {
            logger.Info("Inicio da thread de processamento de cancelamentos");

            while (_bKeepRunning)
            {
                ExecutarCancelamentoOrdemRequest request;
                if (queueCancelamento.TryDequeue(out request))
                {
                    CanalInfo _canal = (CanalInfo)_canais[request.info.Exchange + request.info.ChannelID];

                    _canal.roteador.CancelarOrdem(request);

                    continue;
                }

                Thread.Sleep(100);
            }

            logger.Info("Final da thread de processamento de cancelamentos");
        }
Exemple #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="status"></param>
        public void StatusConexaoAlterada(StatusConexaoBolsaInfo status)
        {
            logger.Debug("On StatusConexaoAlterada(): recebeu status ");

            logger.Debug("Bolsa ..: " + status.Bolsa);
            logger.Debug("Operador ..: " + status.Operador);
            logger.Debug("Conectado .: " + status.Conectado.ToString());

            lock (_canais)
            {
                if (_canais.ContainsKey(status.Bolsa + status.Operador))
                {
                    CanalInfo canal = (CanalInfo)_canais[status.Bolsa + status.Operador];

                    canal.LastHeartbeat = _getSecsFromTicks(DateTime.Now.Ticks);
                    canal.Conectado     = status.Conectado;
                    canal.roteador.Ping(new PingRequest());
                }
            }

            _sendConnectionStatus(status);
        }
Exemple #7
0
        /// <summary>
        /// Envia um pedido de cancelamento de ordem para o canal correspondente
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public ExecutarCancelamentoOrdemResponse CancelarOrdem(ExecutarCancelamentoOrdemRequest request)
        {
            ExecutarCancelamentoOrdemResponse response = new ExecutarCancelamentoOrdemResponse();
            CanalInfo            _canal = null;
            StatusRoteamentoEnum status = StatusRoteamentoEnum.Sucesso;
            string msg = "Cancelamento Enviado";

            logger.Debug("Request de Cancelamento Recebido:");
            logger.Debug("Cliente ......: " + request.info.Account);
            logger.Debug("Bolsa ........: " + request.info.Exchange);
            logger.Debug("Canal ........: " + request.info.ChannelID);
            logger.Debug("Order ID .....: " + request.info.OrderID);
            logger.Debug("OrigClOrdID ..: " + request.info.OrigClOrdID);
            logger.Debug("ClOrdID ......: " + request.info.ClOrdID);


            try
            {
                _canal = (CanalInfo)_canais[request.info.Exchange + request.info.ChannelID];

                if (!_bKeepRunning)
                {
                    msg    = "Servico esta em finalizacao";
                    status = StatusRoteamentoEnum.Erro;
                    logger.Info(msg);
                    response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);
                    return(response);
                }

                if (_canal == null)
                {
                    msg    = "Nao ha canal configurado para " + request.info.Exchange + "-" + request.info.ChannelID;
                    status = StatusRoteamentoEnum.Erro;
                    logger.Info(msg);
                    response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);
                }
                else
                {
                    if (_canal.roteador == null || _canal.Conectado == false)
                    {
                        status = StatusRoteamentoEnum.Erro;
                        msg    = "Nao ha canal ativo e conectado para " + request.info.Exchange + "-" + request.info.ChannelID;
                        logger.Info(msg);
                        response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);
                    }
                    else
                    {
                        response = EnfileirarCancelamento(request);
                    }
                }
            }
            catch (Exception ex)
            {
                msg    = "CancelarOrdem(): " + ex.Message;
                status = StatusRoteamentoEnum.Erro;
                logger.Error(msg + "-" + ex.StackTrace);
                response.DadosRetorno = RoteadorOrdensUtil.FormatarRespostaCancelamento(msg, status);

                if (_canal != null)
                {
                    _resetCanal(_canal);
                }
            }

            logger.Info(msg);

            logger.Debug("Request de Cancelamento Recebido:");

            return(response);
        }
Exemple #8
0
        public FixResendResponse ExecutarFixResend(FixResendRequest request)
        {
            FixResendResponse    response = new FixResendResponse();
            CanalInfo            _canal   = null;
            StatusRoteamentoEnum status   = StatusRoteamentoEnum.Sucesso;
            string msg = "Ordem Enviada";

            logger.Debug("*** ExecutarFixResend()");

            try
            {
                _canal = (CanalInfo)_canais[request.Bolsa + request.Canal];

                if (_canal == null)
                {
                    msg    = "Nao ha canal configurado para " + request.Bolsa + "-" + request.Canal;
                    status = StatusRoteamentoEnum.Erro;
                    logger.Info(msg);
                    response.DadosRetorno = new DadosAdmRetornoBase();
                    response.DadosRetorno.DataResposta = DateTime.Now;
                    response.DadosRetorno.Erro         = true;
                    response.DadosRetorno.Ocorrencias.Add(msg);
                }
                else
                {
                    if (_canal.roteador == null || _canal.Conectado == false)
                    {
                        status = StatusRoteamentoEnum.Erro;
                        msg    = "Nao ha canal conectado para " + request.Bolsa + "-" + request.Canal;
                        logger.Info(msg);
                        response.DadosRetorno = new DadosAdmRetornoBase();
                        response.DadosRetorno.DataResposta = DateTime.Now;
                        response.DadosRetorno.Erro         = true;
                        response.DadosRetorno.Ocorrencias.Add(msg);
                    }
                    else
                    {
                        response = _canal.roteadorAdm.ExecutarFixResend(request);
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error("Error ExecutarFixResend():" + ex.Message, ex);

                msg    = "Error ExecutarFixResend(): " + ex.Message;
                status = StatusRoteamentoEnum.Erro;
                response.DadosRetorno = new DadosAdmRetornoBase();
                response.DadosRetorno.DataResposta = DateTime.Now;
                response.DadosRetorno.Erro         = true;
                response.DadosRetorno.Ocorrencias.Add(msg);


                if (_canal != null)
                {
                    _resetCanal(_canal);
                }
            }

            logger.Debug("*** End of ExecutarOrdem()");

            return(response);
        }