public static MemoriaCotacaoDelay GetInstance()
{
if (_me == null)
{
_me = new MemoriaCotacaoDelay();
}
return(_me);
}
public override void PararServico()
{
logger.Info("Finalizando servico");
bKeepRunning = false;
MemoriaCotacaoDelay.GetInstance().StopProcessamento();
if (thrMonitorConexao != null)
{
while (thrMonitorConexao.IsAlive)
{
logger.Info("Aguardando finalizacao do monitor de conexao com MDS");
Thread.Sleep(250);
}
}
logger.Info("Servico cotacao finalizado");
this.Status = ServicoStatus.Parado;
}
public virtual void IniciarServico()
{
//composicaoIndice = new ComposicaoIndice();
indiceGradual = new IndiceGradual();
lIndiceGradualQuantidadeTeorica = new IndiceGradualQuantidadeTeorica();
// Verifica se deve ser ativado o tratamento de delay da cotação
MemoriaCotacaoDelay.GetInstance().DelayTickerOn = false;
if (ConfigurationManager.AppSettings["DelayTicker"] != null &&
ConfigurationManager.AppSettings["DelayTicker"].ToString().ToUpper().Equals("TRUE"))
{
MemoriaCotacaoDelay.GetInstance().DelayTickerOn = true;
// Obtem o valor do Delay do sinal de cotação, em minutos
MemoriaCotacaoDelay.GetInstance().DelayTickerAmount = 15 * 60 * 1000;
if (ConfigurationManager.AppSettings["DelayTickerAmount"] != null)
{
int delayAmount = Convert.ToInt32(ConfigurationManager.AppSettings["DelayTickerAmount"].ToString());
MemoriaCotacaoDelay.GetInstance().DelayTickerAmount = delayAmount * 60 * 1000;
}
MemoriaCotacaoDelay.GetInstance().StartProcessamento();
}
if (ConfigurationManager.AppSettings["FiltraIndiceCheio"] != null &&
ConfigurationManager.AppSettings["FiltraIndiceCheio"].ToString().ToUpper().Equals("TRUE"))
{
_filtraIndiceCheio = true;
}
QueueManager.Instance.Start();
//QueueManager.Instance.ComposicaoIndice = composicaoIndice;
QueueManager.Instance.IndiceGradual = indiceGradual;
logger.Info("MDS modelo tradicional");
lSocket = new MDSPackageSocket();
lSocket.FiltraIndiceCheio = _filtraIndiceCheio;
lSocket.IpAddr = ConfigurationManager.AppSettings["ASConnMDSIp"].ToString();
lSocket.Port = ConfigurationManager.AppSettings["ASConnMDSPort"].ToString();
//lSocket.setComposicaoIndice(composicaoIndice);
lSocket.setIndiceGradual(indiceGradual);
lSocket.OpenConnection();
_sendMDSLoginMSG(lSocket);
thrMonitorConexao = new Thread(new ThreadStart(MonitorConexaoMDS));
thrMonitorConexao.Start();
gTimer = new Timer(new TimerCallback(IniciarThread), null, 0, 5000);
// Obtem o parametro de maxima diferenca de horario da ultima mensagem com a bolsa
// para envio de alertas
MaxDifHorarioBolsa = 75;
if (ConfigurationManager.AppSettings["MaxDifHorarioBolsa"] != null)
{
MaxDifHorarioBolsa = Convert.ToDouble(ConfigurationManager.AppSettings["MaxDifHorarioBolsa"].ToString());
}
MaxDifHorarioBolsa *= 1000;
// Obtem o timeout de mensagem com o MDS, em segundos
TimeoutMDS = 300;
if (ConfigurationManager.AppSettings["TimeoutMDS"] != null)
{
TimeoutMDS = Convert.ToDouble(ConfigurationManager.AppSettings["TimeoutMDS"].ToString());
}
TimeoutMDS *= 1000;
logger.Info("Servico cotacao iniciado");
this.Status = ServicoStatus.EmExecucao;
}
/// <summary>
/// Obtém informação de ticker de cotação a partir dos containers de sinal com atraso.
/// </summary>
/// <param name="instrumento">Nome do instrumento para o qual se solicita o ticker</param>
/// <returns>string contendo o ticker com atraso</returns>
private string _TickerCotacaoComAtraso(string instrumento)
{
string ret = "";
List <string> Cotacoes = null;
lock (MemoriaCotacaoDelay.GetInstance().hstCotacoes)
{
Cotacoes = (List <string>)(MemoriaCotacaoDelay.GetInstance().hstCotacoes[instrumento]);
}
if (Cotacoes != null)
{
int ItemsVetor = Cotacoes.Count - 1;
string Cotacao = Cotacoes[ItemsVetor].ToString();
string Compra = "C000000000000000000,00000000000000";
string Venda = "V000000000000000000,00000000000000";
string LivroOferta = Compra + Venda;
string livroferta;
if (MemoriaCotacao.hstLivroOferta.TryGetValue(instrumento, out livroferta))
{
LivroOferta = livroferta.Remove(0, 41);
}
else
{
logger.Info("Nao existe dados de LOF para [" + instrumento + "]");
}
int index = 0;
if (LivroOferta.IndexOf("C") >= 0)
{
Compra = LivroOferta.Substring(0, 34);
}
if (LivroOferta.IndexOf('V') >= 0)
{
index = LivroOferta.IndexOf('V');
Venda = LivroOferta.Remove(0, index).Substring(0, 34);
}
string vAbertFech = "0000000000.000000000000.00";
lock (MemoriaCotacaoDelay.GetInstance().hstDadosPapel)
{
if (MemoriaCotacaoDelay.GetInstance().hstDadosPapel.ContainsKey(instrumento))
{
string cot = MemoriaCotacaoDelay.GetInstance().hstDadosPapel[instrumento].ToString();
if (cot != null && cot.Length > 0)
{
vAbertFech = cot;
}
}
else
{
logger.Error("Nao encontrou dados de abertura e fechamento do papel: [" + instrumento + "]");
}
}
// X - Indicador de opcao
// 00000.000000000000 - preco de exercicio
// DDDDMMYY - data de exercicio
string dadosopcao = "X000000.00000000000000000000";
if (MemoriaCotacao.hstDadosOpcoes.ContainsKey(instrumento))
{
MemoriaCotacao.hstDadosOpcoes.TryGetValue(instrumento, out dadosopcao);
}
ret = string.Format("{0}{1}{2}{3}{4}", Cotacao, vAbertFech, Compra, Venda, dadosopcao);
}
return(ret);
}
public override void IniciarServico()
{
logger.Info("Iniciando servico Cotacao com UMDF");
//composicaoIndice = new ComposicaoIndice();
_umdfconfig = Gradual.OMS.Library.GerenciadorConfig.ReceberConfig <UMDFConfig>();
// Verifica se deve ser ativado o tratamento de delay da cotação
MemoriaCotacaoDelay.GetInstance().DelayTickerOn = false;
if (ConfigurationManager.AppSettings["DelayTicker"] != null &&
ConfigurationManager.AppSettings["DelayTicker"].ToString().ToUpper().Equals("TRUE"))
{
MemoriaCotacaoDelay.GetInstance().DelayTickerOn = true;
// Obtem o valor do Delay do sinal de cotação, em minutos
MemoriaCotacaoDelay.GetInstance().DelayTickerAmount = 15 * 60 * 1000;
if (ConfigurationManager.AppSettings["DelayTickerAmount"] != null)
{
int delayAmount = Convert.ToInt32(ConfigurationManager.AppSettings["DelayTickerAmount"].ToString());
MemoriaCotacaoDelay.GetInstance().DelayTickerAmount = delayAmount * 60 * 1000;
}
MemoriaCotacaoDelay.GetInstance().StartProcessamento();
}
if (ConfigurationManager.AppSettings["FiltraIndiceCheio"] != null &&
ConfigurationManager.AppSettings["FiltraIndiceCheio"].ToString().ToUpper().Equals("TRUE"))
{
_filtraIndiceCheio = true;
}
if (_umdfconfig == null)
{
logger.Fatal("Erro ao carregar configuracoes do UMDF");
return;
}
umdfSockets = new MDSPackageSocket[_umdfconfig.Portas.Count];
int i = 0;
foreach (string host in _umdfconfig.Portas)
{
string[] hostporta = host.Split(':');
umdfSockets[i] = new MDSPackageSocket();
umdfSockets[i].FiltraIndiceCheio = _filtraIndiceCheio;
umdfSockets[i].IpAddr = hostporta[0];
umdfSockets[i].Port = hostporta[1];
//umdfSockets[i].setComposicaoIndice(composicaoIndice);
umdfSockets[i].OpenConnection();
_sendMDSLoginMSG(umdfSockets[i]);
i++;
}
thrMonitorConexao = new Thread(new ThreadStart(MonitorConexaoMDS));
thrMonitorConexao.Start();
gTimer = new Timer(new TimerCallback(IniciarThread), null, 0, 5000);
// Obtem o parametro de maxima diferenca de horario da ultima mensagem com a bolsa
// para envio de alertas
MaxDifHorarioBolsa = 75;
if (ConfigurationManager.AppSettings["MaxDifHorarioBolsa"] != null)
{
MaxDifHorarioBolsa = Convert.ToDouble(ConfigurationManager.AppSettings["MaxDifHorarioBolsa"].ToString());
}
MaxDifHorarioBolsa *= 1000;
// Obtem o timeout de mensagem com o MDS, em segundos
TimeoutMDS = 300;
if (ConfigurationManager.AppSettings["TimeoutMDS"] != null)
{
TimeoutMDS = Convert.ToDouble(ConfigurationManager.AppSettings["TimeoutMDS"].ToString());
}
TimeoutMDS *= 1000;
logger.Info("Servico cotacao iniciado");
this.Status = ServicoStatus.EmExecucao;
}
private void MessageBroker(string Instrumento, string Mensagem)
{
try
{
logger.Debug("[" + Instrumento + "] [" + Mensagem + "]");
if (_filtraIndiceCheio)
{
if (Mensagem.Substring(2, 2).Equals("BF") &&
!Instrumento.Substring(0, 1).Equals("W"))
{
return;
}
}
switch (Mensagem.ToString().Substring(0, 2))
{
case ConstantesMDS.Negocio:
MemoriaCotacao.LastNegocioPacket = DateTime.Now;
MemoriaCotacao.LastNegocioMsg = Mensagem;
//MemoriaCotacao.AdicionarLivroNegocios(Instrumento, Mensagem);
MemoriaCotacao.AdicionarNegocio(Instrumento, Mensagem);
MemoriaCotacao.AdicionarNegocioIndiceGradual(Instrumento, Mensagem);
MemoriaCotacao.ProcessaSonda(Instrumento, Mensagem);
//ComposicaoIndice.RecalcularIndice(Instrumento, Mensagem);
if (Instrumento.Equals(IndiceGradual.INDICE_IBOV))
{
IndiceGradual.AtualizarIndiceGradual(Instrumento, Mensagem);
}
if (MemoriaCotacaoDelay.GetInstance().DelayTickerOn)
{
MemoriaCotacaoDelay.GetInstance().AdicionarFilaLivroNegocios(Instrumento, Mensagem);
}
break;
case ConstantesMDS.LivroNegocio:
MemoriaCotacao.LastLofPacket = DateTime.Now;
MemoriaCotacao.LastLofMsg = Mensagem;
MemoriaCotacao.AdicionarLivroNegocios(Instrumento, Mensagem);
break;
case ConstantesMDS.LivroOferta:
MemoriaCotacao.LastLofPacket = DateTime.Now;
MemoriaCotacao.LastLofMsg = Mensagem;
MemoriaCotacao.AdicionarTikerLivroOferta(Instrumento, Mensagem);
break;
case ConstantesMDS.Destaques:
MemoriaCotacao.LastDestaquePacket = DateTime.Now;
MemoriaCotacao.LastDestaqueMsg = Mensagem;
MemoriaCotacao.AdicionarTikerDestaques(Mensagem);
break;
case ConstantesMDS.RankCorretora:
MemoriaCotacao.LastRankingPacket = DateTime.Now;
MemoriaCotacao.LastRankingMsg = Mensagem;
MemoriaCotacao.AdicionarTickerRankCorretora(Instrumento, Mensagem);
break;
case ConstantesMDS.Sonda:
logger.Info("Recebeu Sonda: [" + Mensagem + "]");
MemoriaCotacao.LastSondaMsg = Mensagem;
MemoriaCotacao.ProcessaSonda(Instrumento, Mensagem);
break;
case ConstantesMDS.LIVRO_AGREGADO:
MemoriaCotacao.LastAgregadoPacket = DateTime.Now;
MemoriaCotacao.LastAgregadoMsg = Mensagem;
MemoriaCotacao.AdicionarTikerLivroAgregado(Instrumento, Mensagem);
break;
}
}
catch (Exception ex)
{
logger.Error("MessageBroker(): " + ex.Message, ex);
if (!String.IsNullOrEmpty(Instrumento))
{
logger.Error("Instrumento [" + Instrumento + "]");
}
if (!String.IsNullOrEmpty(Mensagem))
{
logger.Error("Mensagem [" + Mensagem + "]");
}
}
}
