Esempio n. 1
0
        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;
            }
        }
Esempio n. 2
0
        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;
            }
        }