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;
}
//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 CarregarConfig(string id)
{
try
{
// Pára serviços que possam estar carregados
this.PararServicos();
// Limpa coleção de serviços
_servicos.Clear();
// Carrega os serviços do config
this.IdConfigCarregado = id;
ServicoHostConfig config =
GerenciadorConfig.ReceberConfig <ServicoHostConfig>(id);
if (config != null)
{
foreach (ServicoInfo servicoInfo in config.Servicos)
{
if (servicoInfo.Habilitado)
{
this.RegistrarServico(servicoInfo);
}
}
}
}
catch (Exception ex)
{
Log.EfetuarLog(ex, null, "OMS.Library.Servicos");
throw ex;
}
}
/// <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");
}
/// <summary>
/// Construtor default. Faz a carga do(s) arquivo(s) binários de persistência.
/// </summary>
public PersistenciaArquivo()
{
// Pega config do arquivo de configuracoes
_config = GerenciadorConfig.ReceberConfig <PersistenciaArquivoConfig>();
// Inicializa
inicializar();
}
public ReplicacaoLocalizadorClient()
{
_config = GerenciadorConfig.ReceberConfig <ReplicacaoLocalizadorConfig>();
if (_config == null)
{
logger.Warn("Erro ao obter configuracao da replicacao dos localizadores. Verifique a secao <ReplicacaoLocalizadorConfig>");
}
}
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");
}
protected override void OnStart(string[] args)
{
// Pega o config
WindowsServiceHostConfig config = GerenciadorConfig.ReceberConfig <WindowsServiceHostConfig>();
if (config == null)
{
config = new WindowsServiceHostConfig();
}
// Carrega servicos do config
ServicoHostColecao.Default.CarregarConfig(config.ServicoHostId);
ServicoHostColecao.Default.IniciarServicos();
}
/// <summary>
/// Invocado pelo framework ao iniciar o serviço
/// </summary>
public void IniciarServico()
{
logger.Info("*** Iniciando Gravador de Negocios ***");
_config = GerenciadorConfig.ReceberConfig <ProcessadorCotacaoConfig>();
_diretorioLogs = _config.DiretorioLogs;
_nomeLogPadrao = _config.NomeLogPadrao;
_db = new ANGPersistenciaDB();
_threadCotacao = new Thread(new ThreadStart(Run));
_threadCotacao.Start();
_srvstatus = ServicoStatus.EmExecucao;
}
/// <summary>
/// Invocado pelo framework ao iniciar o serviço
/// </summary>
public void IniciarServico()
{
logger.Info("*** Iniciando Capturador de Negocios ***");
_bKeepRunning = true;
_config = GerenciadorConfig.ReceberConfig <ProcessadorNegociosConfig>();
_db = new ANGPersistenciaDB();
_threadNegocios = new Thread(new ThreadStart(Run));
_threadNegocios.Start();
_srvstatus = ServicoStatus.EmExecucao;
}
/// <summary>
/// Invocado pelo framework ao iniciar o serviço
/// </summary>
public virtual void IniciarServico()
{
logger.Info("*** Iniciando Processador de Cotacao ***");
_bKeepRunning = true;
_config = GerenciadorConfig.ReceberConfig <ProcessadorCotacaoConfig>();
_db = new ANGPersistenciaDB();
_threadCotacao = new Thread(new ThreadStart(Run));
_threadCotacao.Start();
_srvstatus = ServicoStatus.EmExecucao;
}
public static void Conectar()
{
try
{
// Inicializa
bool local = true;
// Verifica como o servico deve ser criado
if (_config == null)
{
_config = GerenciadorConfig.ReceberConfig <LocalizadorClienteConfig>();
}
if (_config != null && _config.AtivacaoTipo == ServicoAtivacaoTipo.WCF)
{
local = false;
}
// Cria o servico
if (local)
{
// Cria local
_servicoLocalizador =
(IServicoLocalizador)
ServicoHostColecao.Default.ReceberServico <IServicoLocalizador>();
}
else
{
// Cria via wcf
Binding binding =
(Binding)
typeof(BasicHttpBinding).Assembly.CreateInstance(
_config.EndPoint.NomeBindingType);
_canal = new ChannelFactory <IServicoLocalizador>(binding);
_servicoLocalizador =
_canal.CreateChannel(
new EndpointAddress(
_config.EndPoint.Endereco));
}
}
catch (Exception ex)
{
Log.EfetuarLog(ex, null, "OMS.Library.Servicos");
throw ex;
}
}
/// <summary>
/// Efetua a carga das configuracoes definidas na secao [Gradual.OMS.Library.Servicos.ServicoHostConfig-xxxx]
/// onde xxxx é o id da secao a ser carregada (normalmente "Default");
/// </summary>
/// <param name="id">id da secao a ser carregada (normalmente "Default")</param>
public void CarregarConfig(string id)
{
String lNomeServico;
try
{
logger.Debug("CarregarConfig(): Carregando configuracoes para (" + id + ")");
// Pára serviços que possam estar carregados
this.PararServicos();
// Limpa coleção de serviços
_servicos.Clear();
// Carrega os serviços do config
this.IdConfigCarregado = id;
ServicoHostConfig config =
GerenciadorConfig.ReceberConfig <ServicoHostConfig>(id);
if (config != null)
{
_baseAddress = config.BaseAddress;
_mexBaseAddress = config.MexBaseAddress;
logger.Info("WCF Base Address: " + _baseAddress);
logger.Info("MEX Base Address: " + _mexBaseAddress);
foreach (ServicoInfo servicoInfo in config.Servicos)
{
if (servicoInfo.Habilitado)
{
lNomeServico = servicoInfo.NomeInstancia;
logger.Info("Registrando servico: [" + servicoInfo.NomeInstancia + "]");
this.RegistrarServico(servicoInfo);
}
}
}
}
catch (Exception ex)
{
logger.Error("Erro em CarregarConfig(): ", ex);
throw ex;
}
}
/// <summary>
/// Registra um servico e replica para os demais localizadores
/// </summary>
/// <param name="servico">objeto ServicoInfo</param>
public void Registrar(ServicoInfo servico)
{
OperationContext context = OperationContext.Current;
LocalizadorConfig config = GerenciadorConfig.ReceberConfig <LocalizadorConfig>();
//context.RequestContext.//
MessageProperties messageProperties = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpointProperty = messageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
if (endpointProperty != null)
{
foreach (string instancia in servico.NomeInterface)
{
logger.Debug("[" + endpointProperty.Address + ":" +
endpointProperty.Port +
"] Requisicao de registro do servico [" + servico.NomeInterface[0] + "]");
}
if (config != null && config.AllowedHosts.AllowedHost.Contains(endpointProperty.Address) == false)
{
string msg = "Host [" + endpointProperty.Address + "] nao tem permissao para registrar servicos neste Localizador!!!";
logger.Fatal(msg);
Thread.Sleep(250);
throw new Exception(msg);
}
}
//foreach (KeyValuePair<string, object> entry in messageProperties)
//{
// logger.Debug("messageProperties[" + entry.Key + "]=" + entry.Value.GetType().ToString());
//}
_registrar(servico);
if (this.replclient != null)
{
replclient.ReplicarRegistro(servico);
}
}
public void IniciarServico()
{
try
{
logger.Info("**********************************************************************");
logger.Info("**********************************************************************");
logger.Info("BrokerageProcessor v." + typeof(BrokerageProcessorSrv).Assembly.GetName().Version);
logger.Info("*** IniciarServico(): BrokerageProcessor....");
_config = GerenciadorConfig.ReceberConfig <FileWatcherConfig>();
logger.Info("Config Count: " + _config.Watchers.Count);
_lstFileManager = new List <FileWatcherManager>();
foreach (FileWatcherConfigItem aux in _config.Watchers)
{
FileWatcherManager item = new FileWatcherManager();
item.Config = aux;
item.CreatePaths();
item.Start();
_lstFileManager.Add(item);
}
// Iniciando PdfManager
PdfManager.Instance.Start();
// Iniciando TxtManager
TxtManager.Instance.Start();
// Iniciando EmailManager
EmailManager.Instance.Start();
//Iniciando cron scheduler
scheduler.Start();
_status = ServicoStatus.EmExecucao;
}
catch (Exception ex)
{
logger.Error("Problemas no start do servico: " + ex.Message, ex);
_status = ServicoStatus.Erro;
throw ex;
}
}
public override void IniciarServico()
{
logger.Info("*** Iniciando Processador de Cotacao ***");
_bKeepRunning = true;
_config = GerenciadorConfig.ReceberConfig <ProcessadorCotacaoConfig>();
UMDFConfig _umdfconfig = GerenciadorConfig.ReceberConfig <UMDFConfig>();
_umdfSockets = new MDSPackageSocket[_umdfconfig.Portas.Count];
int i = 0;
foreach (int porta in _umdfconfig.Portas)
{
_umdfSockets[i] = new MDSPackageSocket();
_umdfSockets[i].IpAddr = _config.MDSAddress;
_umdfSockets[i].Port = porta;
_umdfSockets[i].OnFastQuoteReceived += new MDSMessageReceivedHandler(OnCotacao);
_umdfSockets[i].OnSerieHistoricaReceived += new MDSMessageReceivedHandler(OnSerieHistorica);
i++;
}
_db = new ANGPersistenciaDB();
_db.ConnectionString = _config.ConnectionString;
_db.MDSConnectionString = _config.MDSConnectionString;
_threadCotacao = new Thread(new ThreadStart(Run));
_threadCotacao.Start();
_threadSerieHistorica = new Thread(new ThreadStart(SerieHistoricaRun));
_threadSerieHistorica.Start();
_srvstatus = ServicoStatus.EmExecucao;
}
/// <summary>
///
/// </summary>
public void IniciarServico()
{
logger.Info("Iniciando Servico Roteador de Ordens.....");
_bKeepRunning = true;
_config = GerenciadorConfig.ReceberConfig <RoteadorOrdensConfig>();
if (_config == null)
{
throw new Exception("Erro ao carregar configuracoes");
}
// Carrega fila
_orderReportInfo.PersistenceFile = _config.PathFilaOrdens;
logger.Info("Carregando reports enfileirados em [" + _orderReportInfo.PersistenceFile + "]");
_orderReportInfo.LoadQueue();
logger.Info("Iniciando thread de tratamento da fila de cancelamentos");
thCancelProcessor = new Thread(new ThreadStart(ProcessadorCancelamentos));
thCancelProcessor.Name = "procCancelamentos";
thCancelProcessor.Start();
logger.Info("Iniciando canais.....");
_carregarCanais();
// Iniciando thread de monitoracao dos canais
_bKeepRunning = true;
_thrMonitorCanais = new Thread(new ThreadStart(RunMonitor));
_thrMonitorCanais.Priority = ThreadPriority.BelowNormal;
_thrMonitorCanais.Start();
this._thrSendReport = new Thread(new ThreadStart(RunInfoDispacher));
_thrSendReport.Start();
_status = ServicoStatus.EmExecucao;
logger.Info("Servico Roteador de Ordens iniciado");
}
public ServicoAnaliseGrafica()
{
_config = GerenciadorConfig.ReceberConfig <AnaliseGraficaConfig>();
}
public WSTradeInterface()
: base()
{
log4net.Config.XmlConfigurator.Configure();
_config = GerenciadorConfig.ReceberConfig <OpenBlotterConfig>();
}
public void Start()
{
try
{
logger.Info("FixDropCopy Start(): Iniciando ThreadedSocketAcceptor....");
_running = true;
// Buscar Application Path para compor diretorios de dicionario e afins(Substring(6) para retirar 'file:\')
string path = Path.GetDirectoryName(Assembly.GetAssembly(typeof(FixAcceptor)).CodeBase).Substring(6);
logger.Info("Application Path: " + path);
_config = GerenciadorConfig.ReceberConfig <FixDropCopyConfig>();
// Cria dicionario da configuracao
Dictionary mainDic = new Dictionary();
if (_config.SocketAcceptPort > 0)
{
mainDic.SetLong("SocketAcceptPort", _config.SocketAcceptPort);
}
mainDic.SetLong("HeartBtInt", _config.HeartBtInt);
mainDic.SetLong("ReconnectInterval", _config.ReconnectInterval);
mainDic.SetString("FileStorePath", _config.FileStorePath);
logger.Debug("FileLogPath: " + _config.FileLogPath);
mainDic.SetString("FileLogPath", _config.FileLogPath);
logger.Debug("DebugFileLogPath: " + _config.FileLogPath);
mainDic.SetString("DebugFileLogPath", _config.DebugFileLogPath);
mainDic.SetString("StartTime", _config.StartTime);
mainDic.SetString("EndTime", _config.EndTime);
mainDic.SetString("ConnectionType", "acceptor");
// Configure the session settings
SessionSettings settings = new SessionSettings();
settings.Set(mainDic);
foreach (FixSessionItem info in _sessionsDropCopy)
{
Dictionary sessDic = new Dictionary();
string strdictionary = path + Path.DirectorySeparatorChar + info.DataDictionary;
sessDic.SetString("DataDictionary", strdictionary);
sessDic.SetBool("UseDataDictionary", info.UseDataDictionary);
sessDic.SetBool("ResetOnLogon", info.ResetSeqNum);
sessDic.SetBool("PersistMessages", info.PersistMessages);
logger.InfoFormat("Criando sessao DROPCOPY S:[{0}] T:[{1}] UseDic:[{2}] Dic:[{3}] Rst:[{4}] Pers:[{5}] Begstr:[{6}] FinancialLimit:[{7}] Port:[{8}] IdClient[{9}]",
info.SenderCompID,
info.TargetCompID,
info.UseDataDictionary,
strdictionary,
info.ResetSeqNum,
info.PersistMessages,
info.BeginString,
info.FinancialLimit,
info.Operador,
info.IdCliente
);
// Adicionar no dicionario para validacao de logon
// Atribui respectivo Initiator para cada sessao
SessionDropCopy ssDrop = new SessionDropCopy();
//FixInitiator aux = null;
//foreach (FixInitiator init in _lstInitiator)
//{
// if (init.Canal == info.Operador)
// {
// aux = init;
// break;
// }
//}
ssDrop.Config = info;
//ssDrop.Initiator = aux;
//ssDrop.CalcularLimite = info.FinancialLimit;
/*
*/
SessionID session = new SessionID(info.BeginString, info.TargetCompID, info.SenderCompID);
ssDrop.Sessao = session;
ssDrop.Start();
//_dicSessionsDropCopy.Add(session, ssDrop);
List <SessionDropCopy> lstDC = null;
if (_dicSessionsDropCopy.TryGetValue(info.Operador, out lstDC))
{
lstDC.Add(ssDrop);
}
else
{
List <SessionDropCopy> lst = new List <SessionDropCopy>();
lst.Add(ssDrop);
_dicSessionsDropCopy.Add(info.Operador, lst);
}
// Adicionar a sessao no initiator, para conseguir "referencia cruzada"
// Verificar se nao ocorre erros
//if (null != aux)
//{
// ssAcceptor.Initiator.AddSessionAcceptor(session, ssAcceptor);
//}
settings.Set(session, sessDic);
}
//FileStoreFactory store = new FileStoreFactory(settings);
MemoryStoreFactory store = new MemoryStoreFactory();
FileLogFactory logs = new FileLogFactory(settings);
IMessageFactory msgs = new DefaultMessageFactory();
logger.Info("Iniciando ThreadedSocketAcceptor ...");
_socketDropCopy = new ThreadedSocketAcceptor(this, store, settings, logs, msgs);
_socketDropCopy.Start();
logger.Info("Start(): ThreadedSocketAcceptor em execucao....");
logger.Info("Start(): Iniciando thread de mensagens....");
// Thread para receber as mensagens de acceptors
_thDropCopy = new Thread(new ThreadStart(this.SendToDropCopy));
_thDropCopy.Priority = ThreadPriority.Normal;
_thDropCopy.Start();
logger.Info("Start(): thread de mensagens iniciada....");
logger.Info("FixDropCopy Start(): Fim de Inicializacao do ThreadedSocketAcceptor....");
}
catch (Exception ex)
{
logger.Error("Problemas no start da sessao FixDropCopy: " + ex.Message, ex);
throw ex;
}
}
public void IniciarServico()
{
logger.Info("IniciarServico(): iniciando Servidor FIX...");
// Carrega configurações
_config = GerenciadorConfig.ReceberConfig <ServidorFixConfig>();
// Cria dicionario da configuracao
Dictionary mainDic = new Dictionary();
if (_config.SocketAcceptPort > 0)
{
mainDic.SetLong("SocketAcceptPort", _config.SocketAcceptPort);
}
//mainDic.SetLong("SocketConnectPort", _config.SocketConnectPort);
mainDic.SetLong("HeartBtInt", _config.HeartBtInt);
mainDic.SetLong("ReconnectInterval", _config.ReconnectInterval);
//mainDic.SetBool("ResetOnLogon", _config.ResetSeqNum);
//mainDic.SetBool("PersistMessages", _config.PersistMessages);
// Ver
// ret.setString("ConnectionType", ConnectionType.ToLower());
//mainDic.SetString("SocketConnectHost", _config.Host);
mainDic.SetString("FileStorePath", _config.FileStorePath);
logger.Debug("FileLogPath: " + _config.FileLogPath);
mainDic.SetString("FileLogPath", _config.FileLogPath);
logger.Debug("DebugFileLogPath: " + _config.FileLogPath);
mainDic.SetString("DebugFileLogPath", _config.DebugFileLogPath);
mainDic.SetString("StartTime", _config.StartTime);
mainDic.SetString("EndTime", _config.EndTime);
mainDic.SetString("ConnectionType", "acceptor");
CamadaDeDados db = new CamadaDeDados();
List <SessionFixInfo> sessions = db.BuscarSessoesFIX();
// Configure the session settings
SessionSettings settings = new SessionSettings();
settings.Set(mainDic);
foreach (SessionFixInfo info in sessions)
{
Dictionary sessDic = new Dictionary();
//sessDic.SetString("BeginString", _config.BeginString);
//sessDic.SetString("SenderCompID", _config.SenderCompID);
//sessDic.SetString("TargetCompID", _config.TargetCompID);
string dataDictionary;
switch (info.FixVersion)
{
case "5.0": dataDictionary = _config.DataDictionary50; break;
case "4.4": dataDictionary = _config.DataDictionary44; break;
case "4.2":
default:
dataDictionary = _config.DataDictionary42; break;
}
sessDic.SetString("DataDictionary", dataDictionary);
sessDic.SetBool("UseDataDictionary", true);
sessDic.SetBool("ResetOnLogon", info.ResetSeqNum != 0?true:false);
sessDic.SetBool("PersistMessages", info.PersistMessages != 0 ? true : false);
logger.InfoFormat("Criando sessao S:[{0}] T:[{1}] Ver:[{2}] Dic:[{3}] Rst:[{4}] Pers:[{5}] Begstr:[{6}]",
info.SenderCompID,
info.TargetCompID,
info.FixVersion,
dataDictionary,
info.ResetSeqNum,
info.PersistMessages,
info.BeginString
);
// Cria sessao que será usada para mandar as mensagens
_session =
new SessionID(info.BeginString,
info.SenderCompID,
info.TargetCompID);
settings.Set(_session, sessDic);
}
logger.Info("Iniciando gerenciador de limites...");
LimiteManager.GetInstance().Start();
logger.Info("Iniciando cron scheduler...");
_cron = new CronStyleScheduler();
_cron.Start();
logger.Info("Iniciando Executor FIX...");
_executorApp = Executor.GetInstance();
_executorApp.Start();
FileStoreFactory store = new FileStoreFactory(settings);
LogFactory logs = new FileLogFactory(settings);
IMessageFactory msgs = new DefaultMessageFactory();
logger.Info("Iniciando ThreadedSocketAcceptor...");
_socketAcceptor = new ThreadedSocketAcceptor(_executorApp, store, settings, logs, msgs);
_socketAcceptor.Start();
_status = ServicoStatus.EmExecucao;
logger.Info("IniciarServico(): ServidorFIX em execucao....");
}
public static T Get <T>(ICallbackEvento callback, object parametros)
{
try
{
logger.Info("Ativador.Get<" + typeof(T).ToString() + ">()");
// Pega config
if (_config == null)
{
_config = GerenciadorConfig.ReceberConfig <AtivadorConfig>();
}
// Pega config do host, caso exista
if (_configServicoHost == null)
{
if (ServicoHostColecao.Default.IdConfigCarregado != null)
{
_configServicoHost = GerenciadorConfig.ReceberConfig <ServicoHostConfig>(
ServicoHostColecao.Default.IdConfigCarregado);
}
}
// Inicializa
T servico = default(T);
Type tipo = typeof(T);
ServicoInfo servicoInfo = null;
// Verifica se tem no cache
bool adicionarNoCache = false;
lock (_cache)
{
if (_cache.ContainsKey(typeof(T)))
{
servicoInfo = _cache[typeof(T)];
}
else
{
adicionarNoCache = true;
}
}
// Verifica se tem na lista interna
if (servicoInfo == null && _config != null)
{
logger.Info("Buscando informacoes do servico " + tipo.FullName + " na lista interna");
servicoInfo = _findServicoInfo(tipo.FullName, _config.Servicos);
}
// Verifica se tem na lista de servicos do host
if (servicoInfo == null && _configServicoHost != null)
{
logger.Info("Buscando informacoes do servico " + tipo.FullName + " na lista de servicos do host");
servicoInfo = _findServicoInfo(tipo.FullName, _configServicoHost.Servicos);
}
// Se ainda não achou, pega serviço info no localizador
if (servicoInfo == null)
{
logger.Info("Buscando informacoes do servico " + tipo.FullName + " no localizador");
servicoInfo = LocalizadorCliente.Consultar(typeof(T));
}
// Se até este ponto não achou o serviçoInfo, dispara erro
if (servicoInfo == null)
{
logger.Error("Não foi possível conseguir informações para a ativação do serviço " + tipo.FullName);
throw new Exception("Não foi possível conseguir informações para a ativação do serviço " + tipo.FullName + ".");
}
// Verifica se deve adicionar no cache
if (adicionarNoCache && servicoInfo != null)
{
lock (_cache)
{
if (!_cache.ContainsKey(typeof(T)))
{
logger.Info("Armazenando informacoes do servico " + tipo.FullName + " no cache");
_cache.Add(typeof(T), servicoInfo);
}
}
}
// Primeira tentativa deve ser criação local?
if (servicoInfo.AtivacaoDefaultTipo == ServicoAtivacaoTipo.Local)
{
logger.Debug("Ativando " + tipo.FullName + " localmente");
// Cria o serviço
servico = ServicoHostColecao.Default.ReceberServico <T>();
// Caso seja servico com callback, faz a chamada do registro
IServicoComCallback servicoComCallback = servico as IServicoComCallback;
if (servicoComCallback != null && callback != null)
{
servicoComCallback.Registrar(parametros, callback);
}
}
if (servico == null && servicoInfo.EndPoints.Count > 0)
{
ContractDescription cd;
logger.Debug("Ativando " + tipo.FullName + " como WCF");
string epaddress = _findEndpointForInterface <T>(servicoInfo);
logger.Debug("Criando Binding para Endpoint: " + epaddress);
// Cria via wcf
Binding binding = Utilities.GetBinding(epaddress);
//(Binding)
// typeof(BasicHttpBinding).Assembly.CreateInstance(
// servicoInfo.EndPoints[0].NomeBindingType);
binding.ReceiveTimeout = new TimeSpan(0, 2, 0);
binding.SendTimeout = new TimeSpan(0, 1, 0);
binding.OpenTimeout = new TimeSpan(0, 0, 30);
binding.CloseTimeout = new TimeSpan(0, 0, 30);
if (servicoInfo.EndPoints[0].NomeBindingType.Equals("System.ServiceModel.NetTcpBinding"))
{
((NetTcpBinding)binding).MaxReceivedMessageSize = 8000000;
((NetTcpBinding)binding).ReaderQuotas = System.Xml.XmlDictionaryReaderQuotas.Max;
//((NetTcpBinding)binding).Security.Mode = SecurityMode.None;
}
if (servicoInfo.EndPoints[0].NomeBindingType.Equals("System.ServiceModel.BasicHttpBinding"))
{
logger.Debug("Binding setado BasicHttpBinding , verificando por callback");
((BasicHttpBinding)binding).MaxReceivedMessageSize = int.MaxValue;
((BasicHttpBinding)binding).ReaderQuotas = System.Xml.XmlDictionaryReaderQuotas.Max;
//((NetTcpBinding)binding).Security.Mode = SecurityMode.None;
}
logger.Debug("Binding criado, verificando por callback");
// Verifica se tem callback
// Mesmo que não tenha informado, tem que ver se tem contrato especificado na interface
bool temCallback = callback != null;
if (!temCallback)
{
object[] attrs = typeof(T).GetCustomAttributes(typeof(ServiceContractAttribute), true);
if (attrs.Length == 1)
{
if (((ServiceContractAttribute)attrs[0]).CallbackContract != null)
{
temCallback = true;
}
}
}
// Cria dependendo se tem contrato ou não
if (!temCallback)
{
logger.Debug("Servico " + tipo.FullName + " nao tem callback, criando channel ");
IChannelFactory <T> canal = new ChannelFactory <T>(binding);
canal.Faulted += new EventHandler(_channelFaulted);
string uri = _findEndpointForInterface <T>(servicoInfo);
if (uri == null)
{
string msg = "Servico [" + tipo.FullName + "] nao pôde ser ativado.\n";
msg += "Verifique se existe <ServicoEndPointInfo> nas configuracoes locais,\n";
msg += "ou se um endpoint foi criado para o mesmo e registrado no ServicoLocalizador.";
logger.Error("ERRO: NENHUM ENDERECO DE ENDPOINT PARA SERVICO [" + tipo.FullName + "]!");
throw new Exception(msg);
}
servico = canal.CreateChannel(new EndpointAddress(uri));
cd = ((ChannelFactory)canal).Endpoint.Contract;
}
else
{
logger.Debug("Servico " + tipo.FullName + " tem callback, criando channel duplex");
DuplexChannelFactory <T> canal = null;
canal.Faulted += new EventHandler(_channelFaulted);
if (callback == null)
{
logger.Error("Contratos que recebem callbacks tem necessariamente que receber um objeto de callback.");
throw new Exception("Contratos que recebem callbacks tem necessariamente que receber um objeto de callback.");
}
canal = new DuplexChannelFactory <T>(new InstanceContext(callback), binding);
string uri = _findEndpointForInterface <T>(servicoInfo);
if (uri == null)
{
string msg = "Servico [" + tipo.FullName + "] nao pôde ser ativado.\n";
msg += "Verifique se existe <ServicoEndPointInfo> nas configuracoes locais,\n";
msg += "ou se um endpoint foi criado para o mesmo e registrado no ServicoLocalizador.";
logger.Error("ERRO: NENHUM ENDERECO DE ENDPOINT PARA SERVICO [" + tipo.FullName + "]!");
throw new Exception(msg);
}
servico = canal.CreateChannel(new EndpointAddress(uri));
cd = canal.Endpoint.Contract;
IServicoComCallback servicoComCallback = servico as IServicoComCallback;
if (servicoComCallback != null)
{
servicoComCallback.Registrar(parametros);
}
}
if (cd != null)
{
foreach (OperationDescription od in cd.Operations)
{
DataContractSerializerOperationBehavior serializerBh = od.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (serializerBh == null)
{
logger.Info("Adicionando DataContractSerializerOperationBehavior");
serializerBh = new DataContractSerializerOperationBehavior(od);
od.Behaviors.Add(serializerBh);
}
logger.Info("Setando MaxItemsInObjectGraph para operacao: " + od.Name);
serializerBh.MaxItemsInObjectGraph = 8000000;
}
}
((IContextChannel)servico).OperationTimeout = new TimeSpan(0, 10, 0);
}
if (servico == null)
{
string msg = "Servico [" + tipo.FullName + "] nao pôde ser ativado.\n";
msg += "Verifique se existe <servicoinfo> nas configuracoes locais,\n";
msg += "ou se o mesmo foi registrado no ServicoLocalizador e seu hoster esta ativo.";
logger.Error("ERRO: SERVICO [" + tipo.FullName + "] NAO FOI ATIVADO!!!");
throw new Exception(msg);
}
// Retorna
return(servico);
}
catch (Exception ex)
{
logger.Error("Erro em Ativador.Get(" + typeof(T).FullName + ")", ex);
throw ex;
}
}
private void frmMonitorServicos_Load(object sender, EventArgs e)
{
_config = GerenciadorConfig.ReceberConfig <MonitorConfig>();
}
public static T Get <T>(ICallbackEvento callback, object parametros)
{
try
{
// Pega config
if (_config == null)
{
_config = GerenciadorConfig.ReceberConfig <AtivadorConfig>();
}
// Pega config do host, caso exista
if (_configServicoHost == null)
{
if (ServicoHostColecao.Default.IdConfigCarregado != null)
{
_configServicoHost = GerenciadorConfig.ReceberConfig <ServicoHostConfig>(
ServicoHostColecao.Default.IdConfigCarregado);
}
}
// Inicializa
T servico = default(T);
Type tipo = typeof(T);
ServicoInfo servicoInfo = null;
// Verifica se tem no cache
bool adicionarNoCache = false;
if (_cache.ContainsKey(typeof(T)))
{
servicoInfo = _cache[typeof(T)];
}
else
{
adicionarNoCache = true;
}
// Verifica se tem na lista interna
if (servicoInfo == null && _config != null)
{
servicoInfo = (from s in _config.Servicos
where s.NomeInterface.StartsWith(tipo.FullName)
select s).FirstOrDefault();
}
// Verifica se tem na lista de servicos do host
if (servicoInfo == null && _configServicoHost != null)
{
servicoInfo = (from s in _configServicoHost.Servicos
where s.NomeInterface.StartsWith(tipo.FullName)
select s).FirstOrDefault();
}
// Se ainda não achou, pega serviço info no localizador
if (servicoInfo == null)
{
servicoInfo = LocalizadorCliente.Consultar(typeof(T));
}
// Se até este ponto não achou o serviçoInfo, dispara erro
if (servicoInfo == null)
{
throw new Exception("Não foi possível conseguir informações para a ativação do serviço " + tipo.FullName + ".");
}
// Verifica se deve adicionar no cache
if (adicionarNoCache && servicoInfo != null)
{
_cache.Add(typeof(T), servicoInfo);
}
// Primeira tentativa deve ser criação local?
if (servicoInfo.AtivacaoDefaultTipo == ServicoAtivacaoTipo.Local)
{
// Cria o serviço
servico = ServicoHostColecao.Default.ReceberServico <T>();
// Caso seja servico com callback, faz a chamada do registro
IServicoComCallback servicoComCallback = servico as IServicoComCallback;
if (servicoComCallback != null && callback != null)
{
servicoComCallback.Registrar(parametros, callback);
}
}
if (servico == null && servicoInfo.EndPoints.Count > 0)
{
// Cria via wcf
Binding binding =
(Binding)
typeof(BasicHttpBinding).Assembly.CreateInstance(
servicoInfo.EndPoints[0].NomeBindingType);
binding.ReceiveTimeout = new TimeSpan(0, 2, 0);
binding.SendTimeout = new TimeSpan(0, 1, 0);
binding.OpenTimeout = new TimeSpan(0, 0, 30);
binding.CloseTimeout = new TimeSpan(0, 0, 30);
((NetTcpBinding)binding).MaxReceivedMessageSize = 8000000;
// ATP: nao eh "tem contrato", e sim "tem callback"
// ATP: considerar isso em todo o trecho abaixo.
// Verifica se tem contrato
// Mesmo que não tenha informado, tem que ver se tem contrato especificado na interface
bool temContrato = callback != null;
if (!temContrato)
{
object[] attrs = typeof(T).GetCustomAttributes(typeof(ServiceContractAttribute), true);
if (attrs.Length == 1)
{
if (((ServiceContractAttribute)attrs[0]).CallbackContract != null)
{
temContrato = true;
}
}
}
// Cria dependendo se tem contrato ou não
if (!temContrato)
{
IChannelFactory <T> canal = new ChannelFactory <T>(binding);
servico =
canal.CreateChannel(
new EndpointAddress(
servicoInfo.EndPoints[0].Endereco));
}
else
{
DuplexChannelFactory <T> canal = null;
if (callback != null)
{
canal = new DuplexChannelFactory <T>(new InstanceContext(callback), binding);
}
else
{
throw new Exception("Contratos que recebem callbacks tem necessariamente que receber um objeto de callback.");
}
servico =
canal.CreateChannel(
new EndpointAddress(
servicoInfo.EndPoints[0].Endereco));
IServicoComCallback servicoComCallback = servico as IServicoComCallback;
if (servicoComCallback != null)
{
servicoComCallback.Registrar(parametros);
}
}
((IContextChannel)servico).OperationTimeout = new TimeSpan(0, 10, 0);
}
// Retorna
return(servico);
}
catch (Exception ex)
{
Log.EfetuarLog(ex, "typeof(T): " + typeof(T).FullName, "OMS.Library.Servicos");
throw ex;
}
}
public virtual void IniciarServico()
{
logger.Info("IniciarServico(): iniciando canal Bovespa ....");
// Carrega configurações
_config = GerenciadorConfig.ReceberConfig <CanalNegociacaoConfig>();
// Cria sessao que será usada para mandar as mensagens
_session =
new SessionID(
new BeginString(_config.BeginString),
new SenderCompID(_config.SenderCompID),
new TargetCompID(_config.TargetCompID));
// Cria dicionario da configuracao
Dictionary mainDic = new Dictionary();
if (_config.SocketAcceptPort > 0)
{
mainDic.setLong("SocketAcceptPort", _config.SocketAcceptPort);
}
mainDic.setLong("SocketConnectPort", _config.SocketConnectPort);
mainDic.setLong("HeartBtInt", _config.HeartBtInt);
mainDic.setLong("ReconnectInterval", _config.ReconnectInterval);
mainDic.setBool("ResetOnLogon", _config.ResetSeqNum);
mainDic.setBool("PersistMessages", _config.PersistMessages);
// Ver
// ret.setString("ConnectionType", ConnectionType.ToLower());
mainDic.setString("SocketConnectHost", _config.Host);
mainDic.setString("FileStorePath", _config.FileStorePath);
logger.Debug("FileLogPath: " + _config.FileLogPath);
mainDic.setString("FileLogPath", _config.FileLogPath);
mainDic.setString("StartTime", _config.StartTime);
mainDic.setString("EndTime", _config.EndTime);
if (_config.Initiator)
{
mainDic.setString("ConnectionType", "initiator");
}
else
{
mainDic.setString("ConnectionType", "acceptor");
}
Dictionary sessDic = new Dictionary();
sessDic.setString("BeginString", _config.BeginString);
sessDic.setString("SenderCompID", _config.SenderCompID);
sessDic.setString("TargetCompID", _config.TargetCompID);
sessDic.setString("DataDictionary", _config.DataDictionary);
sessDic.setBool("UseDataDictionary", true);
// Configure the session settings
SessionSettings settings = new SessionSettings();
settings.set(mainDic);
settings.set(_session, sessDic);
FileStoreFactory store = new FileStoreFactory(settings);
FileLogFactory logs = new FileLogFactory(settings);
QuickFix.MessageFactory msgs = new DefaultMessageFactory();
// Cria o socket
if (_config.Initiator)
{
_socketInitiator = new SocketInitiator(this, store, settings, logs, msgs);
_socketInitiator.start();
}
else
{
_socketAcceptor = new SocketAcceptor(this, store, settings, logs, msgs);
_socketAcceptor.start();
}
_status = ServicoStatus.EmExecucao;
logger.Info("IniciarServico(): canal Bovespa em execucao....");
}
public TradeProcessor()
{
_config = GerenciadorConfig.ReceberConfig <OpenBlotterConfig>();
}
public WSIndiceGradualInterface()
: base()
{
log4net.Config.XmlConfigurator.Configure();
_config = GerenciadorConfig.ReceberConfig <IndiceGradualConfig>();
}
public static void Conectar()
{
try
{
// Inicializa
bool local = true;
// Verifica como o servico deve ser criado
if (_config == null)
{
_config = GerenciadorConfig.ReceberConfig <LocalizadorClienteConfig>();
}
if (_config != null && _config.AtivacaoTipo == ServicoAtivacaoTipo.WCF)
{
local = false;
}
// Cria o servico
if (local)
{
// Cria local
_servicoLocalizador =
(IServicoLocalizador)
ServicoHostColecao.Default.ReceberServico <IServicoLocalizador>();
}
else
{
// Cria via wcf
string bindingType = _getBindingType(_config.EndPoint.Endereco);
Binding binding =
(Binding)
typeof(BasicHttpBinding).Assembly.CreateInstance(bindingType);
binding.ReceiveTimeout = new TimeSpan(0, 2, 0);
binding.SendTimeout = new TimeSpan(0, 1, 0);
binding.OpenTimeout = new TimeSpan(0, 0, 30);
binding.CloseTimeout = new TimeSpan(0, 0, 30);
if (_config.EndPoint.Endereco.StartsWith("https://"))
{
System.Net.ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(
delegate(object sender,
System.Security.Cryptography.X509Certificates.X509Certificate certificate,
System.Security.Cryptography.X509Certificates.X509Chain chain,
System.Net.Security.SslPolicyErrors sslPolicyErrors) { return(true); });
((BasicHttpBinding)binding).Security.Mode = BasicHttpSecurityMode.Transport;
((BasicHttpBinding)binding).Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
}
_canal = new ChannelFactory <IServicoLocalizador>(binding);
_servicoLocalizador =
_canal.CreateChannel(
new EndpointAddress(
_config.EndPoint.Endereco));
_canal.Faulted += new EventHandler(_channelFaulted);
_lastRequest = DateTime.Now.Ticks;
((IContextChannel)_servicoLocalizador).OperationTimeout = new TimeSpan(0, 10, 0);
}
}
catch (Exception ex)
{
logger.Error("Erro em Conectar(): ", ex);
throw ex;
}
}
private void readCrontab()
{
ScheduleConfig _config = GerenciadorConfig.ReceberConfig <ScheduleConfig>();
try
{
foreach (ScheduleItem item in _config.ScheduleItem)
{
_cronlines.Add(item.value.Trim());
logger.Debug("Adding ScheduleItem [" + item.value.Trim() + "]");
}
String line;
foreach (string linha in _cronlines)
{
ArrayList minutes, hours, mDays, months, wDays;
line = linha;
if (line.Length == 0 || line.StartsWith("#"))
{
continue;
}
// re-escape space- and backslash-escapes in a cheap fashion
line = line.Replace("\\\\", "<BACKSLASH>");
line = line.Replace("\\ ", "<SPACE>");
// split string on whitespace
String[] cols = line.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < cols.Length; i++)
{
cols[i] = cols[i].Replace("<BACKSLASH>", "\\");
cols[i] = cols[i].Replace("<SPACE>", " ");
}
if (cols.Length < 6)
{
reportError("Parse error in crontab (line too short).");
crontab = new ArrayList();
}
minutes = parseTimes(cols[0], 0, 59);
hours = parseTimes(cols[1], 0, 23);
months = parseTimes(cols[3], 1, 12);
if (!cols[2].Equals("*") && cols[3].Equals("*"))
{
// every n monthdays, disregarding weekdays
mDays = parseTimes(cols[2], 1, 31);
wDays = new ArrayList();
wDays.Add(-1); // empty value
}
else if (cols[2].Equals("*") && !cols[3].Equals("*"))
{
// every n weekdays, disregarding monthdays
mDays = new ArrayList();
mDays.Add(-1); // empty value
wDays = parseTimes(cols[4], 1, 7); // 60 * 24 * 7
}
else
{
// every n weekdays, every m monthdays
mDays = parseTimes(cols[2], 1, 31);
wDays = parseTimes(cols[4], 1, 7); // 60 * 24 * 7
}
String args = "";
for (int i = 6; i < cols.Length; i++)
{
args += cols[i].Trim() + " ";
}
args = args.Trim();
// Prestar atencao aqui....inicializa com 6
ArrayList entry = new ArrayList(6);
entry.Add(months);
entry.Add(mDays);
entry.Add(wDays);
entry.Add(hours);
entry.Add(minutes);
entry.Add(cols[5]);
entry.Add(args);
crontab.Add(entry);
logger.Info("Command [" + cols[5] + "] scheduled to run");
}
}
catch (Exception e)
{
reportError(e.ToString());
}
}
/// <summary>
///
/// </summary>
public void IniciarServico()
{
try
{
_monitorConfig = new MonitorConfig();
logger.Info("Iniciando servidor MDS");
logger.Info("Inicializando NEsper");
//NesperManager.Instance.Configure();
logger.Info("Inicializando gerenciador de filas de eventos");
EventQueueManager.Instance.Start();
logger.Info("Carregando configuracao dos canais UMDF");
_umdfconfig = GerenciadorConfig.ReceberConfig <UMDFConfig>();
logger.Info("Criando instancias dos canais UMDF");
foreach (ChannelUMDFConfig cfgcanal in _umdfconfig.CanaisUMDF)
{
cfgcanal.Segment = cfgcanal.Segment.ToUpperInvariant();
cfgcanal.TCPConfig = _umdfconfig.TCPConfig;
ChannelUDMF canal = new ChannelUDMF(cfgcanal, _monitorConfig);
canal.startup = cfgcanal.Startup;
logger.Info("Configurado ChannelID[" + cfgcanal.ChannelID +
"]: SecurityList[" + cfgcanal.SecurityListHost + ":" + cfgcanal.SecurityListPorta +
"] Snapshot[" + cfgcanal.MDRecoveryHost + ":" + cfgcanal.MDRecoveryPorta +
"] Incremental[" + cfgcanal.MDIncrementalHost + ":" + cfgcanal.MDIncrementalPorta + "]");
_dctCanais.Add(cfgcanal.ChannelID, canal);
_monitorConfig.AddChannel(cfgcanal.ChannelID, cfgcanal.Startup);
}
logger.Info("Iniciando canais TCPConflated");
_conflatedConfig = GerenciadorConfig.ReceberConfig <TCPConflatedConfig>();
if (_conflatedConfig != null)
{
ChannelTcpConflated tcpConflated = new ChannelTcpConflated(_conflatedConfig);
_dctConflated.Add(_conflatedConfig.SenderCompID, tcpConflated);
}
if (ConfigurationManager.AppSettings["AnaliseGraficaListenPort"] != null)
{
string portaANG = ConfigurationManager.AppSettings["AnaliseGraficaListenPort"].ToString();
logger.Info("Iniciando servidor sinal AnaliseGrafica na porta [" + portaANG + "]");
servidorANG = new ServidorConexaoANG();
servidorANG.ListenPortNumber = Int32.Parse(portaANG);
servidorANG.Start();
}
logger.Info("Iniciando threads de tratamento dos sinais");
ContainerManager.Instance.Start(_dctCanais);
logger.Info("Iniciando threads dos Canais UMDF");
foreach (ChannelUDMF canal in _dctCanais.Values)
{
if (canal.startup)
{
canal.Start();
logger.Info("Ativado ChannelID[" + canal.channelConfig.ChannelID + "]");
}
}
Parallel.Invoke(() => {
Thread.Sleep(15000);
if (ConfigurationManager.AppSettings["StreamerListenPort"] != null)
{
string portaStreamer = ConfigurationManager.AppSettings["StreamerListenPort"].ToString();
logger.Info("Iniciando servidor Streaming na porta [" + portaStreamer + "]");
servidorStreamer = new ServidorConexaoStreamer();
servidorStreamer.ListenPortNumber = Int32.Parse(portaStreamer);
servidorStreamer.Start();
}
},
() => {
Thread.Sleep(15000);
if (ConfigurationManager.AppSettings["CotacaoListenPort"] != null)
{
string portaCotacao = ConfigurationManager.AppSettings["CotacaoListenPort"].ToString();
logger.Info("Iniciando servidor cotacoes HB na porta [" + portaCotacao + "]");
servidorCotacao = new ServidorConexaoHB();
servidorCotacao.ListenPortNumber = Int32.Parse(portaCotacao);
servidorCotacao.Start();
}
}
);
_serviceStatus = ServicoStatus.EmExecucao;
logger.Info("Servidor MDS iniciado");
}
catch (Exception ex)
{
logger.Error("IniciarServico(): " + ex.Message, ex);
}
}
