/// <summary> /// Interrogates the app.config file to get a list of WCF client end points that implement the ISIPMonitorPublisher contract. /// This is to allow this class to connect to multiple notification servers if needed. /// </summary> private List <string> GetClientEndPointNames() { List <string> clientEndPointNames = new List <string>(); //ServiceModelSectionGroup serviceModelSectionGroup = (ServiceModelSectionGroup)ConfigurationManager.GetSection("system.serviceModel"); ServiceModelSectionGroup serviceModelSectionGroup = null; try { serviceModelSectionGroup = ServiceModelSectionGroup.GetSectionGroup(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); } catch { serviceModelSectionGroup = ServiceModelSectionGroup.GetSectionGroup(WebConfigurationManager.OpenWebConfiguration("~")); } foreach (ChannelEndpointElement client in serviceModelSectionGroup.Client.Endpoints) { if (client.Contract == CLIENT_CONTRACT && !clientEndPointNames.Contains(client.Name)) { logger.Debug("MonitorProxyManager found client endpoint for ISIPMonitorPublisher, name=" + client.Name + "."); clientEndPointNames.Add(client.Name); } } return(clientEndPointNames); }
/// <summary> /// The main entry point for the application. /// </summary> static void Main() { WebAPIBuilder.BuildWebAPI(ServiceConfiguration.WebAPIUrl); WCFHost wcfHost = new WCFHost(); if (Environment.UserInteractive && Debugger.IsAttached) { Console.WriteLine("WCFHost running on console mode."); Configuration configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); ServiceModelSectionGroup serviceModel = ServiceModelSectionGroup.GetSectionGroup(configuration); ServicesSection servicesSection = serviceModel.Services; foreach (ServiceEndpointElement endpoint in servicesSection.Services.Cast <ServiceElement>().Select(s => s.Endpoints).SelectMany(ss => ss.OfType <ServiceEndpointElement>())) { Console.WriteLine("Address: {0}", endpoint.Address); } wcfHost.Start(); Console.WriteLine("Press any key to stop program..."); Console.ReadKey(); wcfHost.Stop(); } else { ServiceBase.Run(wcfHost); } }
public override List <string> GetBaseAddresses(EndpointConfig config) { List <string> ret = new List <string>(); Configuration svcconfig = GetConfiguration(true); ServiceModelSectionGroup sg = ServiceModelSectionGroup.GetSectionGroup(svcconfig); ServiceElementCollection serviceColl = sg.Services.Services; ServiceElement serviceElement = null; // Find serviceElement foreach (ServiceElement el in serviceColl) { if (config.MatchServiceType(el.Name)) { serviceElement = el; break; } } if (null == serviceElement) { return(ret); } foreach (BaseAddressElement element in serviceElement.Host.BaseAddresses) { ret.Add(element.BaseAddress); } return(ret); }
/// <summary> /// Adds the given endpoint unless its already configured in app.config /// </summary> /// <param name="contractType"></param> /// <param name="binding"></param> /// <param name="address"></param> public void AddDefaultEndpoint(Type contractType, Binding binding, string address) { var serviceModel = ServiceModelSectionGroup.GetSectionGroup(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); if (serviceModel == null) { throw new InvalidOperationException("No service model section found in config"); } bool endpointAlreadyConfigured = false; foreach (ServiceElement se in serviceModel.Services.Services) { if (se.Name == Description.ConfigurationName) { foreach (ServiceEndpointElement endpoint in se.Endpoints) { if (endpoint.Contract == contractType.FullName && endpoint.Address.OriginalString == address) { endpointAlreadyConfigured = true; } } } } if (!endpointAlreadyConfigured) { logger.Debug("Endpoint for contract: " + contractType.Name + " is not found in configuration, going to add it programatically"); AddServiceEndpoint(contractType, binding, address); } }
public IHttpActionResult GetBindings([FromUri] string bindingType) { var serviceModel = ServiceModelSectionGroup.GetSectionGroup(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); IList <string> result = serviceModel.Bindings[bindingType].ConfiguredBindings.Select(x => x.Name).ToList(); return(Ok(result)); }
private static string ReadServiceName() { string _ServiceName = string.Empty; var serviceModel = ServiceModelSectionGroup.GetSectionGroup(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); var endpoints = serviceModel.Services.Services; foreach (ServiceElement e in endpoints) { if (e.Name == "WcfServiceLibrary.ObservableService") { foreach (ServiceEndpointElement item in e.Endpoints) { if (item.Name == "PeerEndpoint") { _ServiceName = $"{e.Host.BaseAddresses[0].BaseAddress.ToString()}"; var test = new Uri(_ServiceName); _ServiceName = $"{test.Host}:{test.Port}"; break; } } break; } } return(_ServiceName); }
void Connect() { var group = ServiceModelSectionGroup.GetSectionGroup( ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); //create duplex channel factory var serviceFactory = new DuplexChannelFactory <IBoardService>( this, group.Client.Endpoints[0].Name); //create a communication channel and register for its events this.serviceProxy = serviceFactory.CreateChannel(); var channel = (IClientChannel)this.serviceProxy; channel.Open(); channel.Closed += this.OnChannelClosed; channel.Faulted += this.OnChannelClosed; this.board.Creatures.Clear(); foreach (var creature in this.serviceProxy.GetCreatures()) { this.board.Creatures.Add(creature); } }
private void StartHost() { var group = ServiceModelSectionGroup.GetSectionGroup( ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); if (group != null) { //take the first service and endpoint definition var service = group.Services.Services[0]; var baseAddress = service.Endpoints[0].Address.AbsoluteUri.Replace(service.Endpoints[0].Address.AbsolutePath, String.Empty); //create service var productService = new ProductService(this); //create host var host = new ServiceHost(productService, new[] { new Uri(baseAddress) }); host.AddServiceEndpoint(typeof(IProductService), new NetNamedPipeBinding(), service.Endpoints[0].Address.AbsolutePath); try { //open host host.Open(); } catch (CommunicationObjectFaultedException cofe) { //log exception } catch (TimeoutException te) { //log exception } } }
public static void EnumerateAvailableServiceEndpoints(string serviceConfigFile) { var fileMap = new ExeConfigurationFileMap { ExeConfigFilename = serviceConfigFile }; var appConfig = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); var serviceModel = ServiceModelSectionGroup.GetSectionGroup(appConfig); if (serviceModel == null) { return; } Trace.WriteLine("Service Name: Configuration Name : Address : Binding : Contract"); foreach (ServiceElement service in serviceModel.Services.Services) { foreach (ServiceEndpointElement endpoint in service.Endpoints) { Trace.WriteLine(String.Format("{0} : {1} : {2} : {3} : {4}", service.Name, endpoint.Name, endpoint.Address, endpoint.Binding, endpoint.Contract)); } } }
/// <summary> /// LookupEndpoint /// </summary> /// <param name="endpointName"></param> /// <returns></returns> private string LookupEndpoint(string endpointName) { if (string.IsNullOrWhiteSpace(endpointName)) { return("*"); } Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); ClientSection clientSection = ServiceModelSectionGroup.GetSectionGroup(config).Client; ChannelEndpointElement endpointElement = null; foreach (ChannelEndpointElement element in clientSection.Endpoints) { if (element.Name.EndsWith("_" + endpointName, StringComparison.OrdinalIgnoreCase) && element.Contract == typeof(TChannel).FullName) { endpointElement = element; break; } } if (endpointElement == null) { return("*"); } return(endpointElement.Name); }
public static void EnumerateAvailableClientEndpoints() { Configuration appConfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); ServiceModelSectionGroup serviceModel = ServiceModelSectionGroup.GetSectionGroup(appConfig); if (serviceModel == null) { return; } if (100 > Console.WindowWidth) { Console.WindowWidth = 100; } Console.WriteLine("Configuration Name : Address : Binding : Contract"); foreach (ChannelEndpointElement endpoint in serviceModel.Client.Endpoints) { Console.WriteLine("{0} : {1} : {2} : {3}", endpoint.Name, endpoint.Address, endpoint.Binding, endpoint.Contract); } }
private ChannelEndpointElementCollection ReadClientServices() { var serviceModel = ServiceModelSectionGroup.GetSectionGroup(_configFile); var endpoints = serviceModel.Client.Endpoints; return(endpoints); }
private void Connect() { //get endpoint configuration from app.config. var group = ServiceModelSectionGroup.GetSectionGroup( ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); if (group != null) { //create duplex channel factory pipeFactory = new DuplexChannelFactory <IProductService>(this, group.Client.Endpoints[0].Name); //create a communication channel and register for its events pipeProxy = pipeFactory.CreateChannel(); ((IClientChannel)pipeProxy).Faulted += PipeProxyFaulted; ((IClientChannel)pipeProxy).Opened += PipeProxyOpened; try { //try to open the connection ((IClientChannel)pipeProxy).Open(); this.checkConnectionTimer.Stop(); //register for added products pipeProxy.RegisterForAddedProducts(); } catch { //for example show status text or log; } } }
static ServiceModelSectionGroup GetSection() { var appConfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); var config = ServiceModelSectionGroup.GetSectionGroup(appConfig); return(config); }
private bool UseConfig() { try { string uri = Assembly.GetExecutingAssembly().CodeBase; string file = new Uri(uri).LocalPath; string bin = Path.GetDirectoryName(file); DirectoryInfo root = new DirectoryInfo(bin).Parent; Configuration config = WebConfigurationManager.OpenWebConfiguration("/"); ServiceModelSectionGroup sectionGrp = ServiceModelSectionGroup.GetSectionGroup(config); ChannelEndpointElementCollection endpoints = sectionGrp.Client.Endpoints; foreach (ChannelEndpointElement endpoint in endpoints) { if (endpoint.Name == AppConfig.EndpointConfig) { Log.Write(TraceEventType.Information, "CompareService: service.model section found"); return(true); } } } catch (Exception ex) { Log.Write(TraceEventType.Error, "{0}", ex); } Log.Write(TraceEventType.Information, "CompareService: service.model section not found"); return(false); }
public static System.ServiceModel.Description.ServiceEndpoint GetServiceEndpoint <T>() where T : IClientChannel { var configFullName = Assembly.GetExecutingAssembly().Location + ".config"; var configuration = ConfigurationManager.OpenMappedExeConfiguration(new ExeConfigurationFileMap { ExeConfigFilename = configFullName }, ConfigurationUserLevel.None); var channelType = typeof(T); var contractType = channelType.GetInterfaces().First(i => i.Namespace == channelType.Namespace); var contractAttribute = contractType.GetCustomAttributes(typeof(ServiceContractAttribute), false).First() as ServiceContractAttribute; var serviceModelSectionGroup = ServiceModelSectionGroup.GetSectionGroup(configuration); var channelEndpointElement = serviceModelSectionGroup?.Client.Endpoints.OfType <ChannelEndpointElement>().First(e => e.Contract == contractAttribute?.ConfigurationName); var channelFactory = new ConfigurationChannelFactory <T>(channelEndpointElement.Name, configuration, null); //var binding = channelFactory.Endpoint.Binding as BasicHttpBinding; //binding.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly; //binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic; //binding.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.None; //binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic; //binding.Security.Message.ClientCredentialType = BasicHttpMessageCredentialType.UserName; //binding.Security.Message.AlgorithmSuite = SecurityAlgorithmSuite.Default; //channelFactory.Credentials.UserName.UserName = "******"; //channelFactory.Credentials.UserName.Password = ""; return(channelFactory.Endpoint); }
public List <string> GetServiceNamesFromConfigFile() { List <string> ServiceNames = null; Configuration appConfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); ServiceModelSectionGroup serviceModel = ServiceModelSectionGroup.GetSectionGroup(appConfig); ServicesSection services = serviceModel.Services; ServiceElementCollection sec = services.Services; if (sec.Count > 0) { ServiceNames = new List <string>(); m_serviceTypes = new Dictionary <string, Type>(); foreach (ServiceElement se in sec) { ServiceNames.Add(se.Name); Type t = Type.GetType(se.Name); if (t == null) { string[] sa = se.Name.Split('.'); System.Reflection.Assembly a = System.Reflection.Assembly.LoadFrom(sa[0] + ".dll"); t = a.GetType(se.Name); } m_serviceTypes.Add(se.Name, t); } } return(ServiceNames); }
private static StandardBindingElement GetBindingElement(string bindingName, string sBindingType, out Type oBindingType) { oBindingType = null; StandardBindingElement bindingElement = null; var serviceModel = ServiceModelSectionGroup.GetSectionGroup(_config); foreach (var bindingCollection in serviceModel.Bindings.BindingCollections) { if (bindingCollection.BindingName == sBindingType) { foreach (var bindingElem in bindingCollection.ConfiguredBindings) { if (bindingElem.Name == bindingName) { bindingElement = (StandardBindingElement)bindingElem; oBindingType = bindingCollection.BindingType; break; } } } if (bindingElement != null) { break; } } return(bindingElement); }
/// <summary> /// The get services. /// </summary> /// <returns> /// The <see cref="System.ServiceModel.Configuration.ServiceElementCollection"/>. /// </returns> public static ServiceElementCollection GetServices() { string baseDirectory = AppDomain.CurrentDomain.BaseDirectory; Configuration config; try { config = WebConfigurationManager.OpenWebConfiguration(baseDirectory); } catch (Exception ex1) { try { config = WebConfigurationManager.OpenWebConfiguration("~"); } catch (Exception ex2) { if (Log.isLogging(LoggingConstants.ERROR)) { Log.log(LoggingConstants.ERROR, "Unable to load web.config for WCF services inspection. If you run WebORB using ASP.NET Development Server, make sure to start Visual Studio 'as Administrator'"); Log.log(LoggingConstants.ERROR, ex1); Log.log(LoggingConstants.ERROR, ex2); } return(null); } } Log.log(LoggingConstants.INFO, "CONFIG PATH - " + config.FilePath); return(ServiceModelSectionGroup.GetSectionGroup(config).With(x => x.Services).Services); }
public IHttpActionResult GetBindingTypes() { var serviceModel = ServiceModelSectionGroup.GetSectionGroup(ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); var types = serviceModel.Bindings.BindingCollections.Select(x => x.BindingName); return(Ok(types)); }
protected override void ApplyConfiguration() { ExeConfigurationFileMap filemap = new ExeConfigurationFileMap(); filemap.ExeConfigFilename = _configurationPath; Configuration config = ConfigurationManager.OpenMappedExeConfiguration(filemap, ConfigurationUserLevel.None); ServiceModelSectionGroup serviceModel = ServiceModelSectionGroup.GetSectionGroup(config); bool loaded = false; foreach (ServiceElement se in serviceModel.Services.Services) { if (!loaded && se.Name == this.Description.ConfigurationName) { base.LoadConfigurationSection(se); loaded = true; } } if (!loaded) { throw new ArgumentException(string.Format("ServiceElement doesn't exist in the configuration file: {0}", _configurationPath)); } }
private static ChannelEndpointElement GetEndPointElement(string configurationName) { var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); var sectionGroup = ServiceModelSectionGroup.GetSectionGroup(config); if (sectionGroup == null) { throw new ConfigurationErrorsException(Resources.GroupExpectedErrorMessage); } var client = sectionGroup.Client; var contractType = typeof(TService); var endPoint = client.Endpoints.OfType <ChannelEndpointElement>() .FirstOrDefault(ep => (ep.Name == configurationName) || (ep.Contract == contractType.Name) || (ep.Contract == contractType.AssemblyQualifiedName) || (ep.Contract == contractType.FullName)); if (endPoint != null) { return(endPoint); } var errorMessage = string.Format(Resources.EndPointMissingErrorMessage, contractType.AssemblyQualifiedName); throw new ConfigurationErrorsException(errorMessage); }
static EndpointAddress GetAddressFromClientConfig(Type type, string endpointName = null) { Debug.Assert(type.IsInterface); Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); ServiceModelSectionGroup sectionGroup = ServiceModelSectionGroup.GetSectionGroup(config); EndpointAddress address = null; foreach (ChannelEndpointElement endpointElement in sectionGroup.Client.Endpoints) { if ((String.IsNullOrEmpty(endpointName)) && (endpointElement.Contract == type.ToString())) { address = new EndpointAddress(endpointElement.Address); break; } else { if (endpointElement.Name == endpointName) { address = new EndpointAddress(endpointElement.Address); break; } } } return(address); }
protected void EnsureComMetaDataExchangeBehaviorAdded(Configuration config) { ServiceModelSectionGroup sg = ServiceModelSectionGroup.GetSectionGroup(config); if (!sg.Behaviors.ServiceBehaviors.ContainsKey(comServiceBehavior)) { ServiceBehaviorElement behavior = new ServiceBehaviorElement(comServiceBehavior); sg.Behaviors.ServiceBehaviors.Add(behavior); ServiceMetadataPublishingElement metadataPublishing = new ServiceMetadataPublishingElement(); if (Tool.Options.Hosting == Hosting.Complus || Tool.Options.Hosting == Hosting.NotSpecified) { metadataPublishing.HttpGetEnabled = false; } else { metadataPublishing.HttpGetEnabled = true; } behavior.Add(metadataPublishing); ServiceDebugElement serviceDebug = new ServiceDebugElement(); serviceDebug.IncludeExceptionDetailInFaults = false; behavior.Add(serviceDebug); } }
public List <string> GetClientNamesFromConfigFile() { List <string> ClientNames = null; string name; Configuration appConfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); ServiceModelSectionGroup serviceModel = ServiceModelSectionGroup.GetSectionGroup(appConfig); ClientSection clients = serviceModel.Client; ChannelEndpointElementCollection cepec = clients.Endpoints; if (cepec.Count > 0) { ClientNames = new List <string>(); m_ClientEndPoints = new List <EndPoint>(); foreach (ChannelEndpointElement cepe in cepec) { string[] sa = cepe.Contract.ToString().Split('.'); name = sa[0] + "(" + cepe.Binding + ")"; m_ClientEndPoints.Add(new EndPoint(cepe.Name, sa[0])); ClientNames.Add(name); } } return(ClientNames); }
private static void HostServices() { EnsureQueueExists(); List <ServiceHost> lHosts = new List <ServiceHost>(); try { Configuration lAppConfig = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); ServiceModelSectionGroup lServiceModel = ServiceModelSectionGroup.GetSectionGroup(lAppConfig); System.ServiceModel.Configuration.ServicesSection lServices = lServiceModel.Services; foreach (ServiceElement lServiceElement in lServices.Services) { ServiceHost lHost = new ServiceHost(Type.GetType(GetAssemblyQualifiedServiceName(lServiceElement.Name))); lHost.Open(); lHosts.Add(lHost); } Console.WriteLine("VideoStore Service Started, press Q key to quit"); while (Console.ReadKey().Key != ConsoleKey.Q) { ; } } finally { foreach (ServiceHost lHost in lHosts) { lHost.Close(); } } }
private void LoadFromFile(string configFilePath) { var filemap = new ExeConfigurationFileMap() { ExeConfigFilename = configFilePath }; var config = ConfigurationManager.OpenMappedExeConfiguration(filemap, ConfigurationUserLevel.None); var serviceModel = ServiceModelSectionGroup.GetSectionGroup(config); bool loaded = false; foreach (ServiceElement se in serviceModel.Services.Services) { if (!loaded) { if (se.Name == this.Description.ConfigurationName) { base.LoadConfigurationSection(se); loaded = true; } } } if (!loaded) { throw new ArgumentException("ServiceElement doesn't exist"); } }
/// <summary> /// Retourne l'uri associé au point d'accès principal de l'application. /// /// Pour les applications, l'uri est de la forme : /// - MACHINE_NAME;http[s]://logical_name:port/[path]/. /// </summary> /// <returns>Uri du point d'accès principal de l'application.</returns> private static string GetEndPointUri() { if (HttpContext.Current != null) { return(Environment.MachineName); } else { try { System.Configuration.Configuration configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); ServiceModelSectionGroup serviceModelSection = ServiceModelSectionGroup.GetSectionGroup(configuration); if (serviceModelSection != null) { foreach (ServiceElement service in serviceModelSection.Services.Services) { foreach (ServiceEndpointElement sep in service.Endpoints) { if (sep.Address != null) { return(sep.Address.ToString()); } } } } } catch (ArgumentException) { return(Environment.MachineName); } return(Environment.MachineName); } }
int NumEndpointsForClsid(Configuration config, Guid clsid, Guid appId) { ServiceModelSectionGroup sg = ServiceModelSectionGroup.GetSectionGroup(config); ServiceElementCollection serviceColl = sg.Services.Services; foreach (ServiceElement se in serviceColl) { string[] serviceParams = se.Name.Split(','); if (serviceParams.Length != 2) { continue; } Guid serviceAppId; Guid serviceClsid; try { serviceAppId = new Guid(serviceParams[0]); serviceClsid = new Guid(serviceParams[1]); } catch (FormatException) { // Only Guid serviceTypes are of interest to us - those are the ones our listener picks up continue; } if (serviceClsid == clsid && serviceAppId == appId) { return(se.Endpoints.Count); } } return(0); }
protected ServiceModelSectionGroup GetServiceModelSectionGroup() { var group = ServiceModelSectionGroup.GetSectionGroup( ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); return(@group); }