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;
}
