Beispiel #1
0
        private void MonitorClient()
        {
            long lastRun = DateTime.UtcNow.Ticks;

            while (_bKeepRunning)
            {
                try
                {
                    TimeSpan ts = new TimeSpan(DateTime.UtcNow.Ticks - lastRun);
                    if (ts.TotalMilliseconds > 30000)
                    {
                        lastRun = DateTime.UtcNow.Ticks;

                        string sonda = GerarSonda();

                        List <int> toDelete = new List <int>();
                        foreach (ClientHandlerState state in dctClientes.Values)
                        {
                            try
                            {
                                logger.Info("Enviando sonda para cliente " + state.ClientNumber + "[" + state.ClientSocket.RemoteEndPoint.ToString() + "]");
                                SocketPackage.SendData(sonda, state.ClientSocket);
                                state.TentativasSonda = 0;
                            }
                            catch (Exception ex)
                            {
                                logger.Error("Erro ao enviar sonda para [" + state.ClientNumber + "]");
                                state.TentativasSonda++;

                                if (state.TentativasSonda > 5)
                                {
                                    logger.Error("Erro ao enviar sonda para [" + state.ClientNumber + "] removendo cliente");
                                    toDelete.Add(state.ClientNumber);
                                }
                            }
                        }

                        if (toDelete.Count > 0)
                        {
                            foreach (int clientNumber in toDelete)
                            {
                                dctClientes.Remove(clientNumber);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    logger.Error("MonitorClient(): " + ex.Message, ex);
                }

                Thread.Sleep(100);
            }
        }
        protected override void queueProcessor()
        {
            logger.Info("Iniciando thread para otimizar eventos");

            thOtimizadorEventos      = new Thread(new ThreadStart(otimizadorEventos));
            thOtimizadorEventos.Name = "thOtimizadorEventos-";
            thOtimizadorEventos.Start();

            logger.Info("Iniciando processamento da fila de envio streamer de LOA");
            long lastLogTicks = 0;

            while (bKeepRunning)
            {
                try
                {
                    string msglof = null;
                    lock (objLockSnapshot)
                    {
                        if (queueToStreamer.TryDequeue(out msglof))
                        {
                            if (!String.IsNullOrEmpty(msglof))
                            {
                                SocketPackage.SendData(msglof, ClientSocket);
                            }

                            if (MDSUtils.shouldLog(lastLogTicks))
                            {
                                lastLogTicks = DateTime.UtcNow.Ticks;
                                logger.Info("Mensagens na fila: " + queueToStreamer.Count);
                            }
                            continue;
                        }
                    }

                    lock (syncQueueToStreamer)
                    {
                        Monitor.Wait(syncQueueToStreamer, 50);
                    }
                }
                catch (Exception ex)
                {
                    logger.Error("queueProcessor(): " + ex.Message, ex);
                }
            }

            logger.Info("Finalizando processamento da fila de envio streamer de LOA");
        }
        //protected override EPStatement createStatement(string tipo, string instrumento)
        //{
        //    try
        //    {
        //        string consultaEsper = "";

        //        consultaEsper = "select * from EventoHttpNegocio where instrumento='" + instrumento + "'";

        //        consultaEsper += " output all every 1 msec";

        //        EPStatement comandoEsper = NesperManager.Instance.epService.EPAdministrator.CreateEPL(consultaEsper);
        //        comandoEsper.Events += new UpdateEventHandler(eventUpdateHandler);

        //        logger.Debug("Consulta [" + consultaEsper + "] cadastrada no ESPER!");

        //        return comandoEsper;
        //    }
        //    catch (EPException epex)
        //    {
        //        logger.Error("Exception in createEPL - " + epex.Message, epex);
        //    }
        //    catch (Exception ex)
        //    {
        //        logger.Error("Error in CreateStatement() " + ex.Message, ex);
        //    }

        //    return null;
        //}


        protected override void queueProcessor()
        {
            logger.Info("Iniciando processamento da fila de envio streamer de Negocios");
            long lastLogTicks = 0;

            while (bKeepRunning)
            {
                try
                {
                    string msgneg = null;

                    if (queueToStreamer.TryDequeue(out msgneg))
                    {
                        if (!String.IsNullOrEmpty(msgneg))
                        {
                            SocketPackage.SendData(msgneg, ClientSocket);
                        }

                        if (MDSUtils.shouldLog(lastLogTicks))
                        {
                            lastLogTicks = DateTime.UtcNow.Ticks;
                            logger.Info("Mensagens na fila: " + queueToStreamer.Count);
                        }

                        continue;
                    }

                    lock (syncQueueToStreamer)
                    {
                        Monitor.Wait(syncQueueToStreamer, 50);
                    }
                }
                catch (Exception ex)
                {
                    logger.Error("queueProcessor(): " + ex.Message, ex);
                }
            }

            logger.Info("Finalizando processamento da fila de envio streamer de Negocios");
        }
        protected void queueProcessor()
        {
            logger.Info("Iniciando processamento da fila de envio Analise Grafica");
            long lastLogTicks = 0;

            while (bKeepRunning)
            {
                try
                {
                    string msgNEG = null;
                    if (queueToAnaliseGrafica.TryDequeue(out msgNEG))
                    {
                        SocketPackage.SendData(msgNEG, ClientSocket);

                        if (MDSUtils.shouldLog(lastLogTicks))
                        {
                            lastLogTicks = DateTime.UtcNow.Ticks;
                            logger.Info("Fila de eventos : " + queueToAnaliseGrafica.Count);
                        }
                        logger.DebugFormat("Mensagem [{0}]", msgNEG);

                        continue;
                    }

                    lock (syncQueueToAnaliseGrafica)
                    {
                        Monitor.Wait(syncQueueToAnaliseGrafica, 50);
                    }
                }
                catch (Exception ex)
                {
                    logger.Error("queueProcessor(): " + ex.Message, ex);
                }
            }

            logger.Info("Finalizando processamento da fila de envio home broker de Negocios");
        }
Beispiel #5
0
        protected void queueProcessor()
        {
            logger.Info("Iniciando processamento da fila de envio home broker de livro de ofertas agregado");
            long lastLogTicks = 0;

            while (bKeepRunning)
            {
                try
                {
                    string msgLOA = null;
                    if (queueToHomeBroker.TryDequeue(out msgLOA))
                    {
                        SocketPackage.SendData(msgLOA, ClientSocket);

                        if (MDSUtils.shouldLog(lastLogTicks))
                        {
                            lastLogTicks = DateTime.UtcNow.Ticks;
                            logger.Info("Fila de eventos : " + queueToHomeBroker.Count);
                        }

                        continue;
                    }

                    lock (syncObj)
                    {
                        Monitor.Wait(syncObj, 50);
                    }
                }
                catch (Exception ex)
                {
                    logger.Error("queueProcessor(): " + ex.Message, ex);
                }
            }

            logger.Info("Finalizando processamento da fila de envio home broker de livro de ofertas");
        }