public Servico RegistrarServico(ServicoInfo servicoInfo, object instancia)
{
try
{
// Cria servico
Servico servico = new Servico();
servico.ServicoInfo = servicoInfo;
servico.Instancia = instancia;
// Seta o id do servico
if (servico.ServicoInfo.ID != null)
{
((IServicoID)instancia).SetarID(servico.ServicoInfo.ID);
}
// Adiciona
string id = servico.ServicoInfo.ID == null ? "" : servico.ServicoInfo.ID;
string nomeServico = servico.ServicoInfo.NomeInterface.Split(',')[0];
this.Servicos.Add(
nomeServico + "-" + id, servico);
// Ativa o servico
servico.Ativar();
// Retorna
return(servico);
}
catch (Exception ex)
{
Log.EfetuarLog(ex, null, "OMS.Library.Servicos");
throw ex;
}
}
void IServicoLocalizador.Registrar(ServicoInfo servico)
{
try
{
lock (_servicos)
{
string nomeServico = servico.NomeInterface.Split(',')[0];
string id = servico.ID == null ? "" : servico.ID;
if (!_servicos.ContainsKey(nomeServico))
{
_servicos.Add(nomeServico, new Dictionary <string, ServicoInfo>());
}
if (_servicos[nomeServico].ContainsKey(id))
{
_servicos[nomeServico][id] = servico;
}
else
{
_servicos[nomeServico].Add(id, servico);
}
// Faz o log do registro
Log.EfetuarLog("Serviço registrado: " + Serializador.TransformarEmString(servico), LogTipoEnum.Passagem, "OMS.Library.Servicos");
}
}
catch (Exception ex)
{
Log.EfetuarLog(ex, null, "OMS.Library.Servicos");
throw ex;
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="servicoinfo"></param>
/// <returns></returns>
private static string _findEndpointForInterface <T>(ServicoInfo servicoinfo)
{
string ret = null;
// Efetua 2 buscas, se nao achar o protocolo preferencial, retorna
// o primeiro endpoint disponivel
if (LocalizadorCliente.PreferedBinding != null && LocalizadorCliente.PreferedBinding.Length > 0)
{
foreach (ServicoEndPointInfo endpoint in servicoinfo.EndPoints)
{
if (endpoint.Endereco.Contains(typeof(T).ToString()) &&
endpoint.Endereco.StartsWith(LocalizadorCliente.PreferedBinding))
{
ret = endpoint.Endereco;
}
}
}
if (ret == null)
{
foreach (ServicoEndPointInfo endpoint in servicoinfo.EndPoints)
{
if (endpoint.Endereco.Contains(typeof(T).ToString()))
{
ret = endpoint.Endereco;
}
}
}
return(ret);
}
/// <summary>
/// Busca ServicoInfo correspondente a um nome de interface
/// </summary>
/// <param name="interfaceName"></param>
/// <param name="listaservico"></param>
/// <returns>objeto ServicoInfo ou nulo, se nao encontrado</returns>
private static ServicoInfo _findServicoInfo(string interfaceName, List <ServicoInfo> listaservico)
{
ServicoInfo servicoInfo = null;
foreach (ServicoInfo info in listaservico)
{
bool bFound = false;
foreach (string Interface in info.NomeInterface)
{
if (Interface.StartsWith(interfaceName))
{
servicoInfo = info;
break;
}
}
if (bFound)
{
break;
}
}
return(servicoInfo);
}
public Servico RegistrarServico(ServicoInfo servicoInfo)
{
try
{
return(RegistrarServico(servicoInfo, null));
}
catch (Exception ex)
{
logger.Error("Erro em RegistrarServico(" + servicoInfo.NomeInterface + "): ", ex);
throw ex;
}
}
public static void Registrar(ServicoInfo servico)
{
try
{
LocalizadorCliente.ServicoLocalizador.Registrar(servico);
}
catch (Exception ex)
{
Log.EfetuarLog(ex, null, "OMS.Library.Servicos");
throw ex;
}
}
public Servico RegistrarServico(ServicoInfo servicoInfo)
{
try
{
return(RegistrarServico(servicoInfo, null));
}
catch (Exception ex)
{
Log.EfetuarLog(ex, null, "OMS.Library.Servicos");
throw ex;
}
}
/// <summary>
/// Registra um servico.
/// </summary>
/// <param name="servico">objeto ServicoInfo</param>
private void _registrar(ServicoInfo servico)
{
try
{
// Dump do servico
logger.Info("Registrando Servico: " + servico.NomeInstancia);
foreach (string Interface in servico.NomeInterface)
{
logger.Info(" Interface: " + Interface);
}
foreach (ServicoEndPointInfo einfo in servico.EndPoints)
{
logger.Info(" Endpoint: " + einfo.Endereco);
}
lock (_servicos)
{
foreach (string Interface in servico.NomeInterface)
{
string nomeServico = Interface.Split(',')[0];
string id = servico.ID == null ? "" : servico.ID;
if (!_servicos.ContainsKey(nomeServico))
{
_servicos.Add(nomeServico, new Dictionary <string, ServicoInfo>());
}
if (_servicos[nomeServico].ContainsKey(id))
{
_servicos[nomeServico][id] = servico;
}
else
{
_servicos[nomeServico].Add(id, servico);
}
// Faz o log do registro
logger.Info("Serviço registrado. Interface [" + Interface + "] Instancia =>" + servico.NomeInstancia);
}
}
}
catch (Exception ex)
{
logger.Error("Erro em ServicoLocalizador.Registrar():", ex);
throw ex;
}
}
public static void Registrar(ServicoInfo servico)
{
try
{
string servername = System.Environment.MachineName;
LocalizadorCliente.ServicoLocalizador.Registrar(servico);
Desconectar();
}
catch (Exception ex)
{
logger.Error("Erro em LocalizadorCliente.Registrar()", ex);
_canal.Abort();
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);
}
}
/// <summary>
/// Registra um servico
/// </summary>
/// <param name="servico">objeto ServicoInfo</param>
public void ReplicarRegistro(ServicoInfo servico)
{
foreach (ReplicadorConn replicador in replicadores)
{
try
{
if (!replicador.Conectado)
{
replicador.Conectar();
}
replicador.Servico.ReplicarRegistro(servico);
}
catch (Exception ex)
{
logger.Error("Erro em Registrar(): " + ex.Message, ex);
replicador.Desconectar();
}
}
}
public static ServicoInfo Consultar(Type servicoInterface)
{
ServicoInfo info = null;
try
{
LocalizadorCliente.MutexLocalizador.WaitOne();
info = LocalizadorCliente.ServicoLocalizador.Consultar(servicoInterface.FullName);
LocalizadorCliente.MutexLocalizador.ReleaseMutex();
Desconectar();
}
catch (Exception ex)
{
logger.Error("Erro em LocalizadorCliente.Consultar()", ex);
_canal.Abort();
throw ex;
}
return(info);
}
public Servico RegistrarServico(ServicoInfo servicoInfo, object instancia)
{
try
{
// Cria servico
Servico servico = new Servico();
servico.ServicoInfo = servicoInfo;
servico.Instancia = instancia;
// Seta o id do servico
if (servico.ServicoInfo.ID != null)
{
((IServicoID)instancia).SetarID(servico.ServicoInfo.ID);
}
// Adiciona
string id = servico.ServicoInfo.ID == null ? "" : servico.ServicoInfo.ID;
foreach (string Interface in servico.ServicoInfo.NomeInterface)
{
string nomeServico = Interface.Split(',')[0];
string key = nomeServico + "-" + id;
lock (this.Servicos)
{
if (this.Servicos.ContainsKey(key))
{
this.Servicos[key] = servico;
}
else
{
this.Servicos.Add(key, servico);
}
}
}
// Ativa o servico
logger.Info("Ativando servico: " + servico.ServicoInfo.NomeInstancia);
// Acrescenta os enderecos de enpoint da base mais os declarados para o servico
if (_baseAddress.Count > 0)
{
servico.BaseAddress.AddRange(_baseAddress);
}
if (servicoInfo.WCFBaseAddress.Count > 0)
{
servico.BaseAddress.AddRange(servicoInfo.WCFBaseAddress);
}
servico.MexBaseAddress = _mexBaseAddress;
// Efetua a ativacao do servico
servico.Ativar();
// Verifica se é servico controlavel
IServicoControlavel controlavel = servico.Instancia as IServicoControlavel;
if (controlavel != null)
{
logger.Info("Servico " + servicoInfo.NomeInstancia + " é controlavel.");
if (!_srvsControlaveis.ContainsKey(servicoInfo.NomeInstancia))
{
_srvsControlaveis.Add(servicoInfo.NomeInstancia, controlavel);
}
}
// Retorna
return(servico);
}
catch (Exception ex)
{
logger.Error("Erro em RegistrarServico(" + servicoInfo.NomeInterface + "): ", ex);
throw ex;
}
}
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;
}
}
/// <summary>
/// Recebe um servico para ser registrado via processo de replicacao
/// </summary>
/// <param name="servico">objeto ServicoInfo</param>
public void ReplicarRegistro(ServicoInfo servico)
{
_registrar(servico);
}
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;
}
}
