public static void Main() { Uri baseAddress = new Uri("http://localhost:8000/" + Guid.NewGuid().ToString()); ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress); try { // Add an endpoint to the service ServiceEndpoint discoverableCalculatorEndpoint = serviceHost.AddServiceEndpoint( typeof(ICalculatorService), new WSHttpBinding(), "/DiscoverableEndpoint"); // Add a Scope to the endpoint EndpointDiscoveryBehavior discoverableEndpointBehavior = new EndpointDiscoveryBehavior(); discoverableEndpointBehavior.Scopes.Add(new Uri("ldap:///ou=engineering,o=exampleorg,c=us")); discoverableCalculatorEndpoint.Behaviors.Add(discoverableEndpointBehavior); // Add an endpoint to the service ServiceEndpoint nonDiscoverableCalculatorEndpoint = serviceHost.AddServiceEndpoint (typeof(ICalculatorService), new WSHttpBinding(), "/NonDiscoverableEndpoint"); // Disable discoverability of the endpoint EndpointDiscoveryBehavior nonDiscoverableEndpointBehavior = new EndpointDiscoveryBehavior(); nonDiscoverableEndpointBehavior.Scopes.Add(new Uri("ldap:///ou=engineering,o=exampleorg,c=us")); nonDiscoverableEndpointBehavior.Enabled = false; nonDiscoverableCalculatorEndpoint.Behaviors.Add(nonDiscoverableEndpointBehavior); // Make the service discoverable over UDP multicast serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); serviceHost.Open(); Console.WriteLine("Calculator Service started at {0}", baseAddress); Console.WriteLine(); Console.WriteLine("Press <ENTER> to terminate the service."); Console.WriteLine(); Console.ReadLine(); serviceHost.Close(); } catch (CommunicationException e) { Console.WriteLine(e.Message); } catch (TimeoutException e) { Console.WriteLine(e.Message); } if (serviceHost.State != CommunicationState.Closed) { Console.WriteLine("Aborting the service..."); serviceHost.Abort(); } }
public void Open() { try { m_endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); if (m_MetadataList != null) { foreach (DiscoveryMetadata metadata in m_MetadataList) { XElement endpointMetadata = new XElement("Root", new XElement(metadata.Name, metadata.Value)); m_endpointDiscoveryBehavior.Extensions.Add(endpointMetadata); } m_NetEndpoint.Behaviors.Add(m_endpointDiscoveryBehavior); } m_ServiceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); m_ServiceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); m_ServiceHost.Open(); IsRunning = true; } catch (CommunicationException ex) { m_ServiceHost.Abort(); // customize this exception to be more specific throw ex; } }
public void Open() { try { if (HostMetadata != null) { EndpointDiscoveryBehavior behavior = new EndpointDiscoveryBehavior(); foreach (DiscoveryMetadata metadata in HostMetadata) { XElement element = new XElement("Root", new XElement(metadata.Name, metadata.Value)); behavior.Extensions.Add(element); } HostEndpoint.Behaviors.Add(behavior); } HostService.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); HostService.AddServiceEndpoint(new UdpDiscoveryEndpoint()); HostService.Open(); Debug.Assert(IsRunning); } catch (Exception ex) { try { Close(); } catch { } Debug.WriteLine(ex.ToString()); Debug.Assert(!IsRunning); throw ex; } }
protected internal override object CreateBehavior() { EndpointDiscoveryBehavior behavior = new EndpointDiscoveryBehavior(); behavior.Enabled = Enabled; if ((Scopes != null) && (Scopes.Count > 0)) { foreach (ScopeElement scopeElement in Scopes) { behavior.Scopes.Add(scopeElement.Scope); } } if (ContractTypeNames != null) { foreach (ContractTypeNameElement contractTypeNameElement in ContractTypeNames) { behavior.ContractTypeNames.Add( new XmlQualifiedName(contractTypeNameElement.Name, contractTypeNameElement.Namespace)); } } if ((Extensions != null) && (Extensions.Count > 0)) { foreach (XmlElementElement xmlElement in Extensions) { behavior.Extensions.Add(XElement.Parse(xmlElement.XmlElement.OuterXml)); } } return(behavior); }
public static IHost MakeDiscoverable(this IHost me, DiscoveryMetadataElement metadata = DiscoveryMetadataElement.NetBiosName | DiscoveryMetadataElement.IpV4Addresses, Action <EndpointDiscoveryBehavior> configureEndpointBehavior = null) { var edb = new EndpointDiscoveryBehavior(); if (metadata.HasFlag(DiscoveryMetadataElement.NetBiosName)) { edb.Extensions.Add(new XElement("NetBiosName", Environment.MachineName)); } var dns = Dns.GetHostEntry(Dns.GetHostName()); foreach (var ip in dns.AddressList) { if (metadata.HasFlag(DiscoveryMetadataElement.IpV4Addresses) && ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) { edb.Extensions.Add(new XElement("IpV4Address", ip.ToString())); } if (metadata.HasFlag(DiscoveryMetadataElement.IpV6Addresses) && ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6) { edb.Extensions.Add(new XElement("IpV6Address", ip.ToString())); } } configureEndpointBehavior?.Invoke(edb); (me as _Host).ServiceHost.Description.Endpoints.First().EndpointBehaviors.Add(edb); (me as _Host).ServiceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); (me as _Host).ServiceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); return(me); }
private static void AddAdditionalMetadata(ServiceHost serviceHost, EndpointDiscoveryBehavior discovery) { var meatadata = serviceHost.Extensions.FindAll <IWcfMetadataProvider>(); discovery.Scopes.AddAll(meatadata.SelectMany(meta => meta.Scopes)); discovery.Extensions.AddAll(meatadata.SelectMany(meta => meta.Extensions)); }
public void MetadataUpdate(DiscoveryMetadata metadata) { if (!String.IsNullOrWhiteSpace(metadata.Value)) { if (HostMetadata != null) { if (HostMetadata.Contains(metadata)) { try { Predicate <DiscoveryMetadata> finder = (DiscoveryMetadata m) => { return(m.Name == metadata.Name); }; DiscoveryMetadata data = HostMetadata.Find(finder); data.Value = metadata.Value; EndpointDiscoveryBehavior behavior = HostEndpoint.Behaviors.Find <EndpointDiscoveryBehavior>(); foreach (XElement element in behavior.Extensions.Elements <XElement>()) { if (element.Name.Equals(metadata.Name.ToString())) { element.SetValue(metadata.Value); } } } catch (Exception ex) { Debug.WriteLine(ex.ToString()); throw ex; } } } } }
static void Main(string[] args) { IPHostEntry entry = Dns.GetHostEntry(""); string addr = "localhost"; for (int i = 0; i < entry.AddressList.Length; i++) { if (entry.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) { addr = entry.AddressList[i].ToString(); break; } } Uri baseAddress = new Uri("http://" + addr + ":8084/319D0A4D-2253-47DC-AC4A-C1951FF6667D"); ServiceHost serviceHost = new ServiceHost(typeof(ServiceHelloWCF), baseAddress); try { ServiceEndpoint wsEndpoint = serviceHost.AddServiceEndpoint(typeof(IServiceHelloWCF), new WSHttpBinding(SecurityMode.None), string.Empty); EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); // Add the discovery behavior to the endpoint. wsEndpoint.Behaviors.Add(endpointDiscoveryBehavior); // Make the service discoverable over UDP multicast serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscovery11)); ServiceMetadataBehavior smb = new ServiceMetadataBehavior(); smb.HttpGetEnabled = true; smb.HttpGetUrl = baseAddress; serviceHost.Description.Behaviors.Add(smb); serviceHost.Open(); Console.WriteLine("Hello World WCF Service started at {0}", baseAddress); Console.WriteLine(); Console.WriteLine("Press <ENTER> to terminate the service."); Console.WriteLine(); Console.ReadLine(); serviceHost.Close(); } catch (CommunicationException e) { Console.WriteLine(e.Message); } catch (TimeoutException e) { Console.WriteLine(e.Message); } if (serviceHost.State != CommunicationState.Closed) { Console.WriteLine("Aborting service..."); serviceHost.Abort(); } }
/// <summary> /// Start new broadcast service /// </summary> /// <param name="type">Type of discovery</param> /// <param name="nameToBroadcast">The name of the service that needs to be broadcasted</param> /// <param name="physicalLocation">The physical location of the service that needs to be broadcasted</param> /// <param name="code">code to be broadcasted (e.g. device id)</param> /// <param name="addressToBroadcast">The address of the service that needs to be broadcasted</param> public void Start(DiscoveryType type, string nameToBroadcast, string physicalLocation, string code, Uri addressToBroadcast) { DiscoveryType = type; switch (DiscoveryType) { case DiscoveryType.WsDiscovery: { Ip = Net.GetIp(IpType.All); Port = 7985; Address = "http://" + Ip + ":" + Port + "/"; _discoveryHost = new ServiceHost(new DiscoveyService()); var serviceEndpoint = _discoveryHost.AddServiceEndpoint(typeof(IDiscovery), new WebHttpBinding(), Net.GetUrl(Ip, Port, "")); serviceEndpoint.Behaviors.Add(new WebHttpBehavior()); var broadcaster = new EndpointDiscoveryBehavior(); broadcaster.Extensions.Add(nameToBroadcast.ToXElement <string>()); broadcaster.Extensions.Add(physicalLocation.ToXElement <string>()); broadcaster.Extensions.Add(addressToBroadcast.ToString().ToXElement <string>()); broadcaster.Extensions.Add(code.ToXElement <string>()); serviceEndpoint.Behaviors.Add(broadcaster); _discoveryHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); _discoveryHost.Description.Endpoints.Add(new UdpDiscoveryEndpoint()); _discoveryHost.Open(); IsRunning = true; Debug.WriteLine(DiscoveryType.ToString() + " is started"); } break; case DiscoveryType.Zeroconf: { _service = new RegisterService { Name = nameToBroadcast, RegType = "_am._tcp", ReplyDomain = "local", Port = 3689 }; // TxtRecords are optional var txtRecord = new TxtRecord { { "name", nameToBroadcast }, { "addr", addressToBroadcast.ToString() }, { "loc", physicalLocation }, { "code", code } }; _service.TxtRecord = txtRecord; _service.Response += service_Response; _service.Register(); Debug.WriteLine(DiscoveryType.ToString() + " is started"); } break; } }
public void Open(string announcementConnectionUri, int announcementTimerSec, bool enableAnnouncement) { try { ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior(); EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); XElement endpointMetadata = new XElement("Root", new XElement(_metaDataElement, _metaDataElementValue)); XElement aliasMetadata = new XElement("Root", new XElement(_metaDataAlias, _metaDataAliasValue)); XElement LoginMetadata = new XElement("Root", new XElement(_metaDataLogIn, _metaDataLogInValue)); endpointDiscoveryBehavior.Extensions.Add(endpointMetadata); endpointDiscoveryBehavior.Extensions.Add(aliasMetadata); endpointDiscoveryBehavior.Extensions.Add(LoginMetadata); _netTcpEndpoint.Behaviors.Add(endpointDiscoveryBehavior); _serviceHost.Description.Behaviors.Add(serviceDiscoveryBehavior); _serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); _serviceHost.Open(); if (enableAnnouncement) { Uri announcementEndpointUri = new Uri(announcementConnectionUri); EndpointAddress announcementEndpointAddress = new EndpointAddress(announcementEndpointUri); NetTcpBinding binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; _announcementEndpoint = new AnnouncementEndpoint(binding, announcementEndpointAddress); _announcementClient = new AnnouncementClient(_announcementEndpoint); _endpointDiscoveryMetadata = EndpointDiscoveryMetadata.FromServiceEndpoint(_netTcpEndpoint); //Start a timer that send announcement message _announcementTimer = new Timer(announcementTimerSec * 1000); _announcementTimer.AutoReset = true; _announcementTimer.Elapsed += new ElapsedEventHandler(_announcementTimer_Elapsed); _announcementTimer.Start(); _announcementClient.Open(); } IsRunning = true; } catch (EndpointNotFoundException ex) { //this error occurs when announcement endpoint is not on the network } catch (CommunicationException ex) { _serviceHost.Abort(); // customize this exception to be more specific throw; } }
void EnableServiceBusDiscovery(Uri scope, bool enableMEX, Uri[] baseAddresses) { Debug.Assert(baseAddresses.Any(address => address.Scheme == "sb")); if (Description.Endpoints.Count == 0) { this.AddServiceBusDefaultEndpoints(baseAddresses); } AddServiceEndpoint(new UdpDiscoveryEndpoint()); ServiceDiscoveryBehavior discovery = new ServiceDiscoveryBehavior(); discovery.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint()); Description.Behaviors.Add(discovery); if (enableMEX == true) { Description.Behaviors.Add(new ServiceMetadataBehavior()); foreach (Uri baseAddress in baseAddresses) { if (baseAddress.Scheme == "sb") { string address = baseAddress.AbsoluteUri; if (address.EndsWith("/") == false) { address += "/"; } address += "MEX"; AddServiceEndpoint(typeof(IMetadataExchange), new NetTcpRelayBinding(), address); break; } } if (scope != null) { EndpointDiscoveryBehavior behavior = new EndpointDiscoveryBehavior(); behavior.Scopes.Add(scope); foreach (ServiceEndpoint endpoint in Description.Endpoints) { if (endpoint.IsSystemEndpoint || endpoint is DiscoveryEndpoint || endpoint is AnnouncementEndpoint || endpoint is ServiceMetadataEndpoint) { continue; } endpoint.Behaviors.Add(behavior); } } } }
public static void Main() { Uri baseAddress = new Uri("net.tcp://localhost:8000/" + Guid.NewGuid().ToString()); ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress); try { ServiceEndpoint netTcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new NetTcpBinding(), string.Empty); EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); // Create XML metadata to add to the service endpoint XElement endpointMetadata = new XElement( "Root", new XElement("Information", "This endpoint is for a service of type: ICalculatorService."), new XElement("Time", System.DateTime.Now.ToString("MM/dd/yyyy HH:mm"))); // Add the XML metadata to the endpoint discovery behavior. endpointDiscoveryBehavior.Extensions.Add(endpointMetadata); // Add the discovery behavior to the endpoint. netTcpEndpoint.Behaviors.Add(endpointDiscoveryBehavior); // Make the service discoverable over UDP multicast serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); serviceHost.Open(); Console.WriteLine("Calculator Service started at {0}", baseAddress); Console.WriteLine(); Console.WriteLine("Added the following metadata to the endpoint: \n{0}", endpointMetadata); Console.WriteLine("Press <ENTER> to terminate the service."); Console.WriteLine(); Console.ReadLine(); serviceHost.Close(); } catch (CommunicationException e) { Console.WriteLine(e.Message); } catch (TimeoutException e) { Console.WriteLine(e.Message); } if (serviceHost.State != CommunicationState.Closed) { Console.WriteLine("Aborting service..."); serviceHost.Abort(); } }
public void Use2() { // This time with ServiceDiscoveryBehavior. var b = new EndpointDiscoveryBehavior(); IEndpointBehavior eb = b; var host = new ServiceHost(typeof(TestService)); var se = host.AddServiceEndpoint(typeof(ITestService), new BasicHttpBinding(), new Uri("http://localhost:37564")); var sdb = new ServiceDiscoveryBehavior(); sdb.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint()); IServiceBehavior sb = sdb; se.Behaviors.Add(b); var bc = new BindingParameterCollection(); sb.AddBindingParameters(host.Description, host, host.Description.Endpoints, bc); eb.AddBindingParameters(se, bc); Assert.AreEqual(0, bc.Count, "#1"); Assert.AreEqual(0, host.Extensions.Count, "#1-2"); sb.Validate(host.Description, host); eb.Validate(se); // ... should "validate" not "apply dispatch behavior" do "add host extension" job? I doubt that. Assert.AreEqual(1, host.Extensions.Count, "#2-2"); var dse = host.Extensions.Find <DiscoveryServiceExtension> (); Assert.IsNotNull(dse, "#2-3"); Assert.AreEqual(0, dse.PublishedEndpoints.Count, "#2-4"); Assert.AreEqual(2, se.Behaviors.Count, "#2-5"); // EndpointDiscoveryBehavior + discovery initializer. Assert.AreEqual(0, host.ChannelDispatchers.Count, "#3-1"); Assert.AreEqual(1, host.Description.Endpoints.Count, "#3-2"); Assert.AreEqual(0, dse.PublishedEndpoints.Count, "#3-4"); // The IEndpointBehavior from EndpointDiscoveryBehavior, when ApplyDispatchBehavior() is invoked, publishes an endpoint. sb.ApplyDispatchBehavior(host.Description, host); Assert.AreEqual(0, dse.PublishedEndpoints.Count, "#3-5"); // not yet published eb.ApplyDispatchBehavior(se, new EndpointDispatcher(new EndpointAddress("http://localhost:37564"), "ITestService", "http://tempuri.org/")); Assert.AreEqual(2, host.ChannelDispatchers.Count, "#3-6-1"); // for online and offline announcements Assert.AreEqual(0, dse.PublishedEndpoints.Count, "#3-6-2"); // still not published. host.Open(); try { Assert.AreEqual(3, host.ChannelDispatchers.Count, "#4-1"); // for online and offline announcements Assert.AreEqual(1, dse.PublishedEndpoints.Count, "#4-2"); // The endpoint is published again. (Not sure if it's worthy of testing.) } finally { host.Close(); } }
private void btnListen_Click(object sender, EventArgs e) { if (_serviceHost == null) { _serviceHost = new ServiceHost(typeof(SampleService), _baseAddress); { // Add an endpoint to the service ServiceEndpoint discoverableEndpoint = _serviceHost.AddServiceEndpoint( typeof(ISampleService), new BasicHttpBinding(), "/DiscoverableEndpoint"); // Add Scopes to the endpoint EndpointDiscoveryBehavior discoverableEndpointBehavior = new EndpointDiscoveryBehavior(); foreach (ListViewItem item in lvTypes.CheckedItems) { XmlQualifiedName type = new XmlQualifiedName(item.SubItems[0].Text, item.SubItems[1].Text); discoverableEndpointBehavior.ContractTypeNames.Add(type); } foreach (ListViewItem item in lvScopes.CheckedItems) { discoverableEndpointBehavior.Scopes.Add(new Uri(item.SubItems[0].Text)); } discoverableEndpointBehavior.Enabled = true; discoverableEndpoint.Behaviors.Add(discoverableEndpointBehavior); } // without this fragment, Probe does not work { ServiceDiscoveryBehavior sdb = new ServiceDiscoveryBehavior(); _serviceHost.Description.Behaviors.Add(sdb); UdpDiscoveryEndpoint discoveryEndpoint = new UdpDiscoveryEndpoint(SelectedVersion); discoveryEndpoint.TransportSettings.TimeToLive = 5; _serviceHost.AddServiceEndpoint(discoveryEndpoint); //discoveryEndpoint.Address = new EndpointAddress(new Uri("urn:uuid" + _guid.ToString())); } _serviceHost.Open(); btnListen.Text = "Stop"; } else { _serviceHost.Close(); _serviceHost = null; btnListen.Text = "Listen"; } }
private async Task CreateService() { await TaskManager.StartNew(() => { var host = new ServiceHost(typeof(FactoryService)); var cert = new X509Certificate2(Properties.Resources.Fuxion, "fuxion"); host.Credentials.ServiceCertificate.Certificate = cert; host.Credentials.UserNameAuthentication.UserNamePasswordValidationMode = UserNamePasswordValidationMode.Custom; host.Credentials.UserNameAuthentication.CustomUserNamePasswordValidator = new ServiceValidator((_, __) => { }); var bin = new NetTcpBinding(SecurityMode.Message) { MaxReceivedMessageSize = int.MaxValue, MaxBufferSize = int.MaxValue }; bin.Security.Message.ClientCredentialType = MessageCredentialType.UserName; bin.ReceiveTimeout = TimeSpan.MaxValue; bin.SendTimeout = TimeSpan.MaxValue; var cusBin = new CustomBinding(bin); var security = cusBin.Elements.Find <SecurityBindingElement>(); if (security != null) { security.LocalServiceSettings.MaxClockSkew = TimeSpan.FromDays(1); security.LocalClientSettings.MaxClockSkew = TimeSpan.FromDays(1); } var se = new ServiceEndpoint( ContractDescription.GetContract(typeof(IFactoryService)), cusBin, new EndpointAddress( new Uri("net.tcp://localhost:6666/FactoryService") )); host.AddServiceEndpoint(se); var edb = new EndpointDiscoveryBehavior(); edb.Extensions.Add(new XElement("NetBiosName", Environment.MachineName)); var dns = Dns.GetHostEntry(Dns.GetHostName()); foreach (var ip in dns.AddressList) { if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) { edb.Extensions.Add(new XElement("IpAddress", ip.ToString())); } } se.Behaviors.Add(edb); host.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); host.AddServiceEndpoint(new UdpDiscoveryEndpoint()); host.Open(); }); }
public static void Main() { Uri baseAddress = new Uri("net.tcp://localhost:8000/CalculatorSvc/"); Uri redmondScope = new Uri("net.tcp://Microsoft.Samples.Discovery/RedmondLocation"); ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress); try { ServiceEndpoint tcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new NetTcpBinding(), "TCPEndpoint"); // Add a scope EndpointDiscoveryBehavior tcpEndpointBehavior = new EndpointDiscoveryBehavior(); tcpEndpointBehavior.Scopes.Add(redmondScope); tcpEndpoint.Behaviors.Add(tcpEndpointBehavior); // Make the service discoverable serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); // Listen for discovery messages over UDP multicast serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); // Hook up a custom discovery service implementation through extensions serviceHost.Extensions.Add(new CustomDiscoveryExtension()); serviceHost.Open(); Console.WriteLine("Calculator Service started at: \n {0}", baseAddress); Console.WriteLine("Endpoint is decorated with the following scope: \n {0}", redmondScope); Console.WriteLine(); Console.WriteLine("Press <ENTER> to terminate the service."); Console.WriteLine(); Console.ReadLine(); serviceHost.Close(); } catch (CommunicationException e) { Console.WriteLine(e.Message); } catch (TimeoutException e) { Console.WriteLine(e.Message); } if (serviceHost.State != CommunicationState.Closed) { Console.WriteLine("Aborting the service..."); serviceHost.Abort(); } }
public static Uri[] LookupScopes(ServiceEndpoint endpoint) { Uri[] scopes = new Uri[] {}; EndpointDiscoveryBehavior behavior = endpoint.Behaviors.Find <EndpointDiscoveryBehavior>(); if (behavior != null) { if (behavior.Scopes.Count > 0) { scopes = behavior.Scopes.ToArray(); } } return(scopes); }
/// <summary> /// Causes a communication object to transition from the created state into the opened state. /// </summary> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="ObjectDisposedException"></exception> /// <exception cref="CommunicationObjectFaultedException"></exception> /// <exception cref="TimeoutException"></exception> /// <param name="timeout"></param> /// <param name="contract"></param> /// <returns></returns> public string CustomOpen(string contract, TimeSpan timeout) { string serviceId = Guid.NewGuid().ToString(); var id = new XElement("Id", serviceId); var contractElem = new XElement("Contract", contract); var behavior = new EndpointDiscoveryBehavior(); behavior.Extensions.Add(id); behavior.Extensions.Add(contractElem); Description.Endpoints.First(x => x.Name == "CombateSvcEndpoint").EndpointBehaviors.Add(behavior); base.Open(timeout); return(serviceId); }
public static void AddDiscovery(ServiceHost host, Type serviceType) { // Add a ServiceDiscoveryBehavior host.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); // Add a UdpDiscoveryEndpoint var udpDiscoveryEndpoint = new UdpDiscoveryEndpoint(); host.AddServiceEndpoint(udpDiscoveryEndpoint); // Add a discovery behavior for Meta Extensions EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); endpointDiscoveryBehavior.Extensions.Add(GetLocalAddresses()); host.Description.Endpoints[0].Behaviors.Add(endpointDiscoveryBehavior); }
public void UpdateIPAddressList(String ipAddressRange) { if (!String.IsNullOrWhiteSpace(ipAddressRange)) { _metaDataElementValue = ipAddressRange; EndpointDiscoveryBehavior endpointDiscoveryBehavior = _netTcpEndpoint.Behaviors.Find <EndpointDiscoveryBehavior>(); foreach (XElement endpointMetadata in endpointDiscoveryBehavior.Extensions.Elements <XElement>()) { if (_metaDataElement.Equals(endpointMetadata.Name.ToString())) { endpointMetadata.SetValue(_metaDataElementValue); } } } }
/// <summary> /// 向服务终结点中添加服务发现行为 /// </summary> /// <param name="endpoint">被添加服务发现行为的终结点</param> /// <param name="contractType">被添加终结点的服务契约类型</param> public static void AddDiscoveryBehaviorToServiceEndpoint(ServiceEndpoint endpoint, Type contractType) { if (endpoint == null) { throw new ArgumentNullException("endpoint"); } EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); endpointDiscoveryBehavior.Extensions.Add( new XElement( "root", new XElement("SpecifiedName", string.Format(CultureInfo.InvariantCulture, @"{0}#{1}", contractType.FullName, endpoint.ListenUri.Host)))); endpoint.Behaviors.Add(endpointDiscoveryBehavior); Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "Add discovery behavior to {0}.", endpoint.Address.Uri)); }
public void UpdateMetadata(DiscoveryMetadata metadata) { if (!String.IsNullOrWhiteSpace(metadata.Value) && m_MetadataList.Contains(metadata)) { Predicate <DiscoveryMetadata> NameFinder = (DiscoveryMetadata m) => { return(m.Name == metadata.Name); }; DiscoveryMetadata data = m_MetadataList.Find(NameFinder); data.Value = metadata.Value; EndpointDiscoveryBehavior endpointDiscoveryBehavior = m_NetEndpoint.Behaviors.Find <EndpointDiscoveryBehavior>(); foreach (XElement endpointMetadata in endpointDiscoveryBehavior.Extensions.Elements <XElement>()) { if (endpointMetadata.Name.Equals(metadata.Name.ToString())) { endpointMetadata.SetValue(metadata.Value); } } } }
public static void Main() { Uri baseAddress = new Uri("net.tcp://localhost:5555/CalculatorService/" + Guid.NewGuid().ToString()); ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress); try { ServiceEndpoint netTcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new NetTcpBinding(), string.Empty); // Add a scope to the endpoint EndpointDiscoveryBehavior netTcpEndpointBehavior = new EndpointDiscoveryBehavior(); netTcpEndpointBehavior.Scopes.Add(new Uri("ldap:///ou=engineering,o=exampleorg,c=us")); netTcpEndpoint.Behaviors.Add(netTcpEndpointBehavior); // Service discovery is enabled through configuration serviceHost.Open(); Console.WriteLine("Calculator Service started at: \n {0}", baseAddress); Console.WriteLine(); Console.WriteLine("Press <ENTER> to terminate the service."); Console.WriteLine(); Console.ReadLine(); serviceHost.Close(); } catch (CommunicationException e) { Console.WriteLine(e.Message); } catch (TimeoutException e) { Console.WriteLine(e.Message); } if (serviceHost.State != CommunicationState.Closed) { Console.WriteLine("Aborting the service..."); serviceHost.Abort(); } }
public static ServiceHost <S> CreateHost <S>() where S : DiscoveryPublishService <T>, T { Uri baseAddress = DiscoveryHelper.AvailableTcpBaseAddress; ServiceHost <S> host = new ServiceHost <S>(baseAddress); //Add the events endpoint EndpointAddress address = new EndpointAddress(baseAddress.AbsoluteUri + Guid.NewGuid()); ServiceEndpoint endpoint = host.AddServiceEndpoint(typeof(T), Binding, address.Uri.AbsoluteUri); EndpointDiscoveryBehavior discoveryBehavior = new EndpointDiscoveryBehavior(); discoveryBehavior.Scopes.Add(Scope); endpoint.Behaviors.Add(discoveryBehavior); //Enable discovering the events endpoint host.AddServiceEndpoint(new UdpDiscoveryEndpoint()); host.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); return(host); }
public void Use() { // Without ServiceDiscoveryBehavior. var b = new EndpointDiscoveryBehavior(); IEndpointBehavior eb = b; var host = new ServiceHost(typeof(TestService)); var se = host.AddServiceEndpoint(typeof(ITestService), new BasicHttpBinding(), new Uri("http://localhost:37564")); se.Behaviors.Add(b); var bc = new BindingParameterCollection(); eb.AddBindingParameters(se, bc); Assert.AreEqual(0, bc.Count, "#1"); Assert.AreEqual(0, host.Extensions.Count, "#1-2"); eb.Validate(se); // This behavior itself does not populate discovery extension. It just configures the extension. Assert.AreEqual(0, host.Extensions.Count, "#2-2"); }
private static void ExportMetadata(ServiceEndpoint endpoint, EndpointDiscoveryBehavior discovery) { var exporter = new WsdlExporter(); exporter.ExportEndpoint(endpoint); var metadata = exporter.GetGeneratedMetadata(); var document = new XDocument(); using (var xmlWriter = document.CreateWriter()) { xmlWriter.WriteStartElement(WcfConstants.EndpointMetadata.LocalName, WcfConstants.EndpointMetadata.Namespace.NamespaceName); metadata.WriteTo(xmlWriter); xmlWriter.WriteEndElement(); xmlWriter.Flush(); } discovery.Extensions.Add(document.Root); }
/// <summary> /// Attaches a new endpoint to the given host. /// </summary> /// <param name="host">The host to which the endpoint should be attached.</param> /// <param name="implementedContract">The contract implemented by the endpoint.</param> /// <param name="localEndpoint">The ID of the local endpoint, to be used in the endpoint metadata.</param> /// <param name="allowAutomaticChannelDiscovery"> /// A flag that indicates whether or not the channel should provide automatic channel discovery. /// </param> /// <returns>The newly attached endpoint.</returns> public ServiceEndpoint AttachDiscoveryEntryEndpoint( ServiceHost host, Type implementedContract, EndpointId localEndpoint, bool allowAutomaticChannelDiscovery) { var endpoint = host.AddServiceEndpoint(implementedContract, GenerateBinding(), GenerateNewDiscoveryEntryAddress()); if (allowAutomaticChannelDiscovery) { var discoveryBehavior = new ServiceDiscoveryBehavior(); discoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint()); host.Description.Behaviors.Add(discoveryBehavior); host.Description.Endpoints.Add(new UdpDiscoveryEndpoint()); } var endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); endpointDiscoveryBehavior.Extensions.Add(new XElement("root", new XElement("EndpointId", localEndpoint.ToString()))); endpoint.Behaviors.Add(endpointDiscoveryBehavior); return endpoint; }
protected internal override object CreateBehavior() { var ret = new EndpointDiscoveryBehavior() { Enabled = this.Enabled }; foreach (ContractTypeNameElement ctn in ContractTypeNames) { ret.ContractTypeNames.Add(new XmlQualifiedName(ctn.Name, ctn.Namespace)); } foreach (XmlElementElement xee in Extensions) { ret.Extensions.Add(XElement.Load(new XmlNodeReader(xee.XmlElement))); } foreach (ScopeElement se in Scopes) { ret.Scopes.Add(se.Scope); } return(ret); }
protected override void Opening(ServiceHost serviceHost) { var serviceDiscovery = serviceHost.Description.Behaviors.Find <ServiceDiscoveryBehavior>(); if (serviceDiscovery == null) { serviceDiscovery = new ServiceDiscoveryBehavior(); serviceHost.Description.Behaviors.Add(serviceDiscovery); } if (announceEndpoints != null) { serviceDiscovery.AnnouncementEndpoints.AddAll(announceEndpoints); } var serviceMetadata = serviceHost.Extensions.OfType <IWcfDiscoveryMetadata>().ToArray(); foreach (var endpoint in serviceHost.Description.NonSystemEndpoints()) { var discovery = endpoint.Behaviors.Find <EndpointDiscoveryBehavior>(); if (discovery == null) { discovery = new EndpointDiscoveryBehavior(); endpoint.Behaviors.Add(discovery); } discovery.Scopes.AddAll(scopes); discovery.Extensions.AddAll(metadata); var discoveryMetaadata = endpoint.Behaviors.OfType <IWcfDiscoveryMetadata>(); AddDiscoveryMetadata(discoveryMetaadata, discovery); AddDiscoveryMetadata(serviceMetadata, discovery); if (strict == false) { ExportMetadata(endpoint, discovery); } } AddDiscoveryEndpoint(serviceHost); }
public void Open() { logger.Debug("ScreenCastService::Open(...)"); try { var session = mediaStreamer.Session; var videoSettings = session.VideoSettings; var videoDeviceName = videoSettings.CaptureDevice?.Name ?? ""; var hostName = session.StreamName; if (!string.IsNullOrEmpty(videoDeviceName)) { hostName += " (" + videoDeviceName + ")"; } var audioSettings = session.AudioSettings; var audioDeviceName = audioSettings.CaptureDevice?.Name ?? ""; var communicationPort = session.CommunicationPort; if (communicationPort < 0) { communicationPort = 0; } if (communicationPort == 0) {// FIXME: переделать // если порт не задан - ищем свободный начиная с 808 //communicationPort = GetRandomTcpPort(); var freeTcpPorts = MediaToolkit.Utils.NetTools.GetFreePortRange(System.Net.Sockets.ProtocolType.Tcp, 1, 808); if (freeTcpPorts != null && freeTcpPorts.Count() > 0) { communicationPort = freeTcpPorts.FirstOrDefault(); } } session.CommunicationPort = communicationPort; var communicationIp = session.NetworkIpAddress; var address = session.CommunicationAddress; this.ListenUri = new Uri(address); this.HostName = hostName; this.ServerId = MediaToolkit.Utils.RngProvider.GetRandomNumber().ToString(); Dictionary <string, string> endpointExtensions = new Dictionary <string, string> {// инфа которая будет доступна как расширение в WSDiscovery { "HostName", HostName }, { "StreamId", ServerId }, { "StreamName", session.StreamName }, { "AudioInfo", audioDeviceName }, { "VideoInfo", videoDeviceName }, }; //NetHttpBinding binding = new NetHttpBinding //{ // ReceiveTimeout = TimeSpan.MaxValue,//TimeSpan.FromSeconds(10), // SendTimeout = TimeSpan.FromSeconds(10), //}; //NetTcpSecurity security = new NetTcpSecurity //{ // Mode = SecurityMode.Transport, // Transport = new TcpTransportSecurity // { // ClientCredentialType = TcpClientCredentialType.Windows, // ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign, // }, //}; NetTcpSecurity security = new NetTcpSecurity { Mode = SecurityMode.None, }; var binding = new NetTcpBinding { ReceiveTimeout = TimeSpan.MaxValue,//TimeSpan.FromSeconds(10), SendTimeout = TimeSpan.FromSeconds(10), Security = security, // PortSharingEnabled = true, }; host = new ServiceHost(this, ListenUri); //host = new ServiceHost(this); //var endpoint = host.AddServiceEndpoint(typeof(IScreenCastService), binding, ""); var endpoint = host.AddServiceEndpoint(typeof(IScreenCastService), binding, ListenUri); if (communicationPort == 0) {// сейчас не работает на клиенте !! // нужно доделать клиент endpoint.ListenUriMode = System.ServiceModel.Description.ListenUriMode.Unique; } var endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); foreach (var key in endpointExtensions.Keys) { var element = new System.Xml.Linq.XElement(key, endpointExtensions[key]); endpointDiscoveryBehavior.Extensions.Add(element); } //var addrInfos = MediaToolkit.Utils.NetworkHelper.GetActiveUnicastIpAddressInfos(); //foreach (var addr in addrInfos) //{ // endpointDiscoveryBehavior.Scopes.Add(new Uri(uri, @"ListenAddr/" + addr.Address)); //} endpoint.EndpointBehaviors.Add(endpointDiscoveryBehavior); ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior(); serviceDiscoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint()); host.Description.Behaviors.Add(serviceDiscoveryBehavior); //host.AddServiceEndpoint(new UdpDiscoveryEndpoint()); host.Description.Endpoints.Add(new UdpDiscoveryEndpoint()); host.Opened += Host_Opened; host.Faulted += Host_Faulted; host.Closed += Host_Closed; host.Open(); foreach (var dispatcher in host.ChannelDispatchers) { var listener = dispatcher.Listener; if (listener != null) { var uri = listener.Uri; if (uri != null) { var _host = uri.Host; if (_host == session.NetworkIpAddress) { //получаем порт на котором работает служба // если порт задан динамически session.CommunicationPort = uri.Port; } logger.Info(uri); } } } logger.Debug("Service opened: " + ListenUri.ToString()); } catch (Exception ex) { logger.Error(ex); Close(); var caption = "Network Error"; var message = "Network host opening error. Check network port and other settings."; throw new StreamerException(message, caption); } }
protected internal override object CreateBehavior() { EndpointDiscoveryBehavior behavior = new EndpointDiscoveryBehavior(); behavior.Enabled = Enabled; if ((Scopes != null) && (Scopes.Count > 0)) { foreach (ScopeElement scopeElement in Scopes) { behavior.Scopes.Add(scopeElement.Scope); } } if (ContractTypeNames != null) { foreach (ContractTypeNameElement contractTypeNameElement in ContractTypeNames) { behavior.ContractTypeNames.Add( new XmlQualifiedName(contractTypeNameElement.Name, contractTypeNameElement.Namespace)); } } if ((Extensions != null) && (Extensions.Count > 0)) { foreach (XmlElementElement xmlElement in Extensions) { behavior.Extensions.Add(XElement.Parse(xmlElement.XmlElement.OuterXml)); } } return behavior; }
protected override object CreateBehavior () { var ret = new EndpointDiscoveryBehavior () { Enabled = this.Enabled }; foreach (ContractTypeNameElement ctn in ContractTypeNames) ret.ContractTypeNames.Add (new XmlQualifiedName (ctn.Name, ctn.Namespace)); foreach (XmlElementElement xee in Extensions) ret.Extensions.Add (XElement.Load (new XmlNodeReader (xee.XmlElement))); foreach (ScopeElement se in Scopes) ret.Scopes.Add (se.Scope); return ret; }