public void IniciarServico()
{
try
{
log4net.Config.XmlConfigurator.Configure();
gLogger.Info("Iniciando serviço ServicoGerenciadorGradualPremium");
ThreadPool.RegisterWaitForSingleObject(gThreadEvent, new WaitOrTimerCallback(RemoverCustodiaCliente), null, this.gTemporizadorIntervaloVerificacao, false);
ThreadPool.RegisterWaitForSingleObject(gThreadEvent, new WaitOrTimerCallback(ReativarCustodiaCliente), null, this.gTemporizadorIntervaloVerificacao, false);
//ThreadPool.RegisterWaitForSingleObject(gThreadEvent, new WaitOrTimerCallback(ReativarCorretagemCliente), null, this.gTemporizadorIntervaloVerificacao, false);
//ThreadPool.RegisterWaitForSingleObject(gThreadEvent, new WaitOrTimerCallback(InativarCorretagemCliente), null, this.gTemporizadorIntervaloVerificacao, false);
ThreadPool.RegisterWaitForSingleObject(gThreadEvent, new WaitOrTimerCallback(GerarArquivoEstornoCustodia), null, this.gTemporizadorIntervaloVerificacao, false);
gServicoStatus = ServicoStatus.EmExecucao;
}
catch (Exception ex)
{
gLogger.ErrorFormat("Erro ao iniciar o serviço de ServicoGerenciadorGradualPremium - {0} - StackTrace - {1}", ex.Message, ex.StackTrace);
}
}
/// <summary>
/// Inicia o serviço de monitor de lucro prejuízo chamando o método StartMonitor
/// Esse é um método padrão da Gradual.OMS.Library e é acionado sempre que o
/// serviço inicializa
/// </summary>
public void IniciarServico()
{
try
{
logger.Info("Iniciando o servico de Monitoramento de Compliance");
logger.Info("Inicia Thread responsavel por armazenar o monitor em memoria.");
ThreadResetLoadSuitability = new WaitOrTimerCallback(StartLoadSuitability);
ThreadPool.RegisterWaitForSingleObject(lThreadEvent, ThreadResetLoadSuitability, null, this.TemporizadorIntervaloVerificacao, false);
//ThreadResetPosicao = new WaitOrTimerCallback(StartMonitorComplianceEvent);
//ThreadPool.RegisterWaitForSingleObject(lThreadEvent, ThreadResetPosicao, null, this.TemporizadorIntervaloVerificacao, false);
ThreadResetLoadChurning = new WaitOrTimerCallback(StartLoadComplianceChurning);
ThreadPool.RegisterWaitForSingleObject(lThreadEvent, ThreadResetLoadChurning, null, this.TemporizadorIntervaloVerificacao, false);
//ThreadPool.QueueUserWorkItem(new WaitCallback(CarregarMonitoresMemoria), null);
thThreadCarregarMonitorMemoria = new Thread(new ThreadStart(ThreadCarregarMonitorMemoria));
thThreadCarregarMonitorMemoria.Name = "ThreadCarregarMonitorMemoria";
thThreadCarregarMonitorMemoria.Start();
_ServicoStatus = ServicoStatus.EmExecucao;
logger.Info("Processo inicializado com sucesso.");
}
catch (Exception ex)
{
logger.Error("Ocorreu um erro ao Iniciar o Servico de Compliance.", ex);
}
}
public void IniciarServico()
{
try
{
_bKeepRunning = true;
_thrMonitorRoteador = new Thread(new ThreadStart(RunMonitor));
_thrMonitorRoteador.Start();
_status = ServicoStatus.EmExecucao;
logger.Info("SERVICO INICIALIZADO COM SUCESSO.");
logger.Info("INICIALIZA CALLBACK");
OrderCallback = new NewOrderCallback();
OrderCallback.StartRouterCallBack();
logger.Info("Servico NEW ORDER CALLBACK iniciado com sucesso.");
logger.Info("NEW CALLBACK INICIALIZADO .");
}
catch (Exception ex)
{
logger.Error("OCORREU UM ERRO AO INICIAR O SERVICO DE ORDENS.", ex);
}
}
public void PararServico()
{
clistm.Stop();
processadormsgs.Stop();
_status = ServicoStatus.Parado;
}
public void IniciarServico()
{
try
{
log4net.Config.XmlConfigurator.Configure();
//_gThreadAtivacaoCliente = new WaitOrTimerCallback(VerificaPosicaoClienteSinacor);
//_gThreadAtivacaoClienteDirect = new WaitOrTimerCallback(VerificaPosicaoClienteAssessorDirect);
_gThreadGeracaoArquivo = new WaitOrTimerCallback(GerarArquivoPeriodico);
logger.Info("Iniciando a Thread de Ativação de Planos do cliente (Integração com o Solicitações - Sinacor)");
ThreadPool.RegisterWaitForSingleObject(lThreadEvent, _gThreadAtivacaoCliente, null, this.TemporizadorIntervaloVerificacao, false);
ThreadPool.RegisterWaitForSingleObject(lThreadEvent, _gThreadAtivacaoClienteDirect, null, this.TemporizadorIntervaloVerificacao, false);
ThreadPool.RegisterWaitForSingleObject(lThreadEvent, _gThreadGeracaoArquivo, null, this.TemporizadorGeradorArquivo, false);
lThreadEvent.Set();
_ServicoStatus = ServicoStatus.EmExecucao;
}
catch (Exception ex)
{
logger.ErrorFormat("Erro ao iniciar o serviço de AtivacaoPlanoCliente - {0} - StackTrace - {1}", ex.Message, ex.StackTrace);
}
}
public void IniciarServico()
{
replclient = new ReplicacaoLocalizadorClient();
Dictionary <string, Dictionary <string, ServicoInfo> > servicos;
replclient.Conectar();
if (replclient.QtdeReplicadores > 0)
{
servicos = replclient.ObterListaServicos();
if (servicos != null && servicos.Count > 0)
{
foreach (KeyValuePair <string, Dictionary <string, ServicoInfo> > item1 in servicos)
{
logger.Info("Replicando: [" + item1.Key + "]");
if (!_servicos.ContainsKey(item1.Key))
{
_servicos.Add(item1.Key, item1.Value);
}
else
{
_servicos[item1.Key] = item1.Value;
}
}
}
}
_status = ServicoStatus.EmExecucao;
}
//private ServidorConexaoTCPReplay servidorTcpReplay = null;
public void IniciarServico()
{
try
{
_monitorConfig = new MonitorConfig();
logger.Info("*** Iniciando Servico TCPReplay");
logger.Info("Carregando configuracao dos canais");
_umdfconfig = GerenciadorConfig.ReceberConfig <UMDFConfig>();
// Carrega configuracao e ativa as threads das sessoes FIX
foreach (TCPReplayConfig tcpReplayConfig in _umdfconfig.TCPReplay)
{
if (tcpReplayConfig.ConnectionType.Equals(QUICKFIX_CONNECTION_TYPE_ACCEPTOR))
{
logger.Info("Iniciando ACCEPTOR SenderCompID[" + tcpReplayConfig.SenderCompID +
"] TargetCompID[" + tcpReplayConfig.TargetCompID +
"] Aguardando na porta [" + tcpReplayConfig.SocketAcceptPort + "]");
tcpReplayConfig.ChannelID = QUICKFIX_CONNECTION_TYPE_ACCEPTOR.ToUpper();
fixServerAcceptor = new FixServerAcceptor(
tcpReplayConfig, _dctSessionsFixClients, _dctSessionsFixChannels);
}
else
{
string channelsID = tcpReplayConfig.ChannelID;
if (tcpReplayConfig.IsPuma)
{
tcpReplayConfig.ChannelID = ConstantesUMDF.UMDF_CHANNEL_ID_PUMA_1_6;
}
else if (tcpReplayConfig.IsPuma20)
{
tcpReplayConfig.ChannelID = ConstantesUMDF.UMDF_CHANNEL_ID_PUMA_2_0;
}
logger.Info("Iniciando thread ChannelID[" + tcpReplayConfig.ChannelID +
"]: SenderCompID[" + tcpReplayConfig.SenderCompID +
"] TargetCompID[" + tcpReplayConfig.TargetCompID +
"] Host[" + tcpReplayConfig.SocketConnectHost +
"] Port[" + tcpReplayConfig.SocketConnectPort +
"] TemplateFile[" + tcpReplayConfig.TemplateFile + "]");
FixServerInitiator fixServerInitiator = new FixServerInitiator(
channelsID, tcpReplayConfig, _dctSessionsFixClients, _dctSessionsFixChannels);
_dctFixServerInitiator.Add(tcpReplayConfig.ChannelID, fixServerInitiator);
}
}
_serviceStatus = ServicoStatus.EmExecucao;
logger.Info("Servico TcpReplay iniciado");
}
catch (Exception ex)
{
logger.Error("IniciarServico(): " + ex.Message, ex);
}
}
public void IniciarServico()
{
_me = this;
_config = GerenciadorConfig.ReceberConfig <GeracaoBaseConfig>();
if (_config != null)
{
foreach (BaseParam parametro in _config.Parametros)
{
logger.Info("Carregando parametros da funcao [" + parametro.FunctionName + "]");
dctParametros.Add(parametro.FunctionName, parametro);
}
}
if (ConfigurationManager.AppSettings["PortaHttp"] != null)
{
portaHttp = Convert.ToInt32(ConfigurationManager.AppSettings["PortaHttp"].ToString());
}
httpServer = new MyHttpServer(portaHttp, _config);
thHttp = new Thread(new ThreadStart(httpServer.listen));
thHttp.Start();
_cron = new CronStyleScheduler();
_cron.Start();
_status = ServicoStatus.EmExecucao;
}
public virtual void PararServico()
{
logger.Info("Finalizando canal Bovespa");
finalizarSinalizado = true;
try
{
// Para o socket
if (_config.Initiator)
{
_socketInitiator.stop();
_socketInitiator.Dispose();
_socketInitiator = null;
}
else
{
_socketAcceptor.stop();
_socketAcceptor.Dispose();
_socketAcceptor = null;
}
}
catch (Exception ex)
{
logger.Error("Erro em PararServico():" + ex.Message, ex);
}
finally
{
_status = ServicoStatus.Parado;
}
logger.Info("*** Canal Bovespa finalizado ***");
}
public void IniciarServico()
{
_me = this;
logger.Info("Iniciando ServicoAutomacaoOrdensTeste");
_bKeepRunning = true;
logger.Info("Carregando configuracao e parametros de teste");
_config = Gradual.OMS.Library.GerenciadorConfig.ReceberConfig <ParametrosTesteConfig>();
thMonitorRoteador = new Thread(new ThreadStart(MonitorRoteador));
thMonitorRoteador.Start();
thProcCallback = new Thread(new ThreadStart(ProcessadorCallback));
thProcCallback.Start();
logger.Info("Iniciando scheduler");
_cron = new CronStyleScheduler();
_cron.Start();
_status = ServicoStatus.EmExecucao;
}
public void PararServico()
{
this.gTimer.Enabled = false;
this.ServicoStatus = OMS.Library.Servicos.ServicoStatus.Parado;
gLogger.Info(string.Format("Seriço parado às: {0}", DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")));
}
/// <summary>
///
/// </summary>
public void IniciarServico()
{
logger.Info("Iniciando ServicoA4S");
_config = GerenciadorConfig.ReceberConfig <A4SConfig>();
_bKeepRunning = true;
sckServer = new SocketPackage();
sckServer.OnClientConnected += new ClientConnectedHandler(sckServer_OnClientConnected);
sckServer.OnRequestReceived += new MessageReceivedHandler(sckServer_OnMessageReceived);
_thOrdemProcessor = new Thread(new ThreadStart(OrdemProcessor));
_thOrdemProcessor.Start();
_thStatusProcessor = new Thread(new ThreadStart(StatusProcessor));
_thStatusProcessor.Start();
sckServer.StartListen(_config.ListenPort);
_servicoStatus = ServicoStatus.EmExecucao;
logger.Info("ServicoA4S Iniciado");
}
public void IniciarServico()
{
try
{
logger.Info("**********************************************************************");
logger.Info("**********************************************************************");
logger.Info("*** IniciarServico(): DropCopyServer....");
// Carrega configurações a partir do banco de dados
DbDropCopy dbDropCopy = new DbDropCopy();
string strExecFile = Process.GetCurrentProcess().MainModule.FileName;
strExecFile = strExecFile.Substring(strExecFile.LastIndexOf(Path.DirectorySeparatorChar) + 1);
logger.Info("ExecFile: " + strExecFile);
_lstCfg = dbDropCopy.BuscarSessoesFIXServer(strExecFile);
List <FixSessionItem> lstDropCopyInit = new List <FixSessionItem>();
//logger.Info("Iniciando Gerenciador de Limites");
//LimiteManager.GetInstance().Start();
string strServerName = System.Net.Dns.GetHostName() + "." + System.Net.NetworkInformation.IPGlobalProperties.GetIPGlobalProperties().DomainName;
logger.Info("Atualizando 'server names' das sessoes fix");
foreach (FixSessionItem item in _lstCfg)
{
if (item.ConnectionType.ToLower().Equals(FixConnectionType.DROPCOPY_INITIATOR))
{
lstDropCopyInit.Add(item);
}
// Atualizar o nome do servidor para definir a "origem" das sessoes
dbDropCopy.AtualizarServerName(item.IdSessaoFix, strServerName);
}
//Inicia Thread de tratamento de callbacks
DropCopyCallbackManager.Instance.Start();
if (lstDropCopyInit.Count == 0)
{
logger.Info("Configurações de FixDropCopy Initiator não encontradas. Não criará o SocketInitator DropCopy");
}
else
{
foreach (FixSessionItem item in lstDropCopyInit)
{
FixInitiatorDropCopy aux = new FixInitiatorDropCopy(item);
_lstfixInitiatorDC.Add(aux);
logger.Info("IniciarServico(): iniciando SocketInitiator DropCopy");
aux.Start();
}
}
logger.Info("*** IniciarServico(): DropCopyServer inicializado...");
dbDropCopy = null;
_status = ServicoStatus.EmExecucao;
}
catch (Exception ex)
{
logger.Error("Problemas na inicializacao do servico: " + ex.Message, ex);
_status = ServicoStatus.Erro;
throw ex;
}
}
public void PararServico()
{
logger.Info("Recebida requisição de parada");
bKeepRunning = false;
_status = ServicoStatus.Parado;
}
public void IniciarServico()
{
_thrMonitorRoteador = new Thread(new ThreadStart(RunMonitor));
_thrMonitorRoteador.Start();
_bKeepRunning = true;
_status = ServicoStatus.EmExecucao;
}
public void PararServico()
{
logger.Info("Tentando parar o servico");
// _Monitor.LoopControler = false;
_Monitor = null;
GC.Collect();
_ServiceStatus = ServicoStatus.Parado;
logger.Info("Servico Parado com sucesso.");
}
public void PararServico()
{
logger.Info("Finalizando ServicoRecalculoFinanceiroBRP");
_scheduler.Stop();
_status = ServicoStatus.Parado;
logger.Info("ServicoRecalculoFinanceiroBRP finalizado");
}
public FixServer()
{
_status = ServicoStatus.Indefinido;
_fixAcceptor = null;
//_fixDropCopy = null;
_lstfixInitiator = new List <FixInitiator>();
//_lstfixDropCopy = new List<FixDropCopy>();
_tasks = GeneralTasks.GetInstance();
_cron = new Gradual.Core.OMS.FixServerLowLatency.Util.CronStyleScheduler();
}
public void IniciarServico()
{
gTimer.Interval = this.GetIntervaloExecucao;
gTimer.Enabled = true;
gTimer.Start();
this.ServicoStatus = OMS.Library.Servicos.ServicoStatus.EmExecucao;
gLogger.Info(string.Format("Seriço iniciado às: {0}", DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")));
}
public void IniciarServico()
{
logger.Info("Iniciando Servico Automacao de Ordens");
parametros = GerenciadorConfig.ReceberConfig <AutomacaoConfig>();
dadosGlobais = new DadosGlobais();
dadosGlobais.Parametros = parametros;
dadosGlobais.KeepRunning = true;
Configuration esperConfig = new Configuration();
//ATP: toda essa parte aqui tem que carregar dinamicamente
// e ficar parametrizada
//ATP: Start f*****g unparametrized section
// Tipar o evento no nesper
esperConfig.AddEventType <EventoBovespa>();
esperConfig.AddEventType <EventoBMF>();
startEsper(esperConfig);
// Carrega livros de ofertas
PersistenciaMarketData persistencia = new PersistenciaMarketData(dadosGlobais);
if (File.Exists(parametros.DiretorioDB + "\\LofBov.dat"))
{
persistencia.LoadLOFBovespa();
}
// O monitor faz o registro do evento na engine, associando a um listener
AutomacaoMonitorBase monitor = new BovespaLivroOfertasMonitor(dadosGlobais);
monitor.Start();
// O monitor faz o registro do evento na engine, associando a um listener
AutomacaoMonitorBase monitorLOFBMF = new BMFLivroOfertasMonitor(dadosGlobais);
monitorLOFBMF.Start();
// Inicia o adapter. O adapter deve sempre ser iniciado apos o
// evento ser conhecido e registrado no nesper
//gerador = new GeradorEventosBovespa(dadosGlobais);
gerador = new GeradorEventosDump2Bovespa(dadosGlobais);
gerador.Start();
retransmissorBMF = new RetransmissorBMF(dadosGlobais);
retransmissorBMF.Start();
//ATP: End of f*****g unparametrized section
_status = ServicoStatus.EmExecucao;
logger.Info("Servico Automacao de Ordens iniciado");
}
public void PararServico()
{
try
{
gServicoStatus = ServicoStatus.Parado;
}
catch (Exception ex)
{
gLogger.ErrorFormat("Erro ao Parar o serviço de ServicoGerenciadorGradualPremium - {0} - StackTrace - {1}", ex.Message, ex.StackTrace);
}
}
public void PararServico()
{
_bKeepRunning = false;
while (thMonitorRoteador != null && thMonitorRoteador.IsAlive)
{
Thread.Sleep(250);
}
_status = ServicoStatus.Parado;
}
public Servico(int id, string descricao, string tipoOrdem, ServicoStatus status, DateTime dataRegistro, DateTime dataFinalizada, Usuario usuario, int usuarioId)
{
Id = id;
Descricao = descricao;
TipoOrdem = tipoOrdem;
Status = status;
DataRegistro = dataRegistro;
DataFinalizada = dataFinalizada;
Usuario = usuario;
UsuarioId = usuarioId;
}
/// <summary>
/// Invocado pelo framework ao parar o servico
/// </summary>
public void PararServico()
{
logger.Info("*** Finalizando Gravador de Negocios ***");
while (_threadCotacao.IsAlive)
{
Thread.Sleep(250);
}
_srvstatus = ServicoStatus.Parado;
}
public void IniciarServico()
{
logger.Info("Iniciando ServicoRecalculoFinanceiroBRP");
_status = ServicoStatus.EmExecucao;
_scheduler = new CronStyleScheduler();
_scheduler.Start();
logger.Info("ServicoRecalculoFinanceiroBRP iniciado");
}
private void CarregarServico()
{
TimerCallback callBack = AlimentarConsultaDNDelegate;
if (null == _timer)
{
_timer = new Timer(callBack, _autoResetEvent, 15000, GetTemporizador);
}
_status = ServicoStatus.EmExecucao;
_logger.Debug(string.Concat("Timer iniciado: ", _timer.ToString()));
}
public void PararServico()
{
try
{
logger.Info("Tentando parar o servico");
_ServicoStatus = ServicoStatus.Parado;
logger.Info("Servico parado com sucesso");
}
catch (Exception ex)
{
logger.Info("Ocorreu um erro ao Iniciar o servico: " + ex.Message);
}
}
/// <summary>
/// Invocado pelo framework ao parar o servico
/// </summary>
public void PararServico()
{
logger.Info("*** Finalizando Processador de Cotacao ***");
_bKeepRunning = false;
while (_threadCotacao.IsAlive)
{
Thread.Sleep(250);
}
_srvstatus = ServicoStatus.Parado;
}
public void PararServico()
{
try
{
_ServicoStatus = ServicoStatus.Parado;
logger.InfoFormat("Parando o serviço de AtivacaoPlanoCliente");
}
catch (Exception ex)
{
logger.ErrorFormat("Parando o serviço de AtivacaoPlanoCliente - {0} - StackTrace - {1}", ex.Message, ex.StackTrace);
}
}
public void PararServico()
{
_timer.Dispose();
if (_thread.IsAlive)
{
_thread.Abort();
}
_status = ServicoStatus.Parado;
_logger.Debug("Serviço forçado a parar pelo cliente.");
}
