void UseCase1Core (Uri serviceUri, AnnouncementEndpoint aEndpoint, DiscoveryEndpoint dEndpoint)
{
// actual service, announcing to 4989
var host = new ServiceHost (typeof (TestService));
var sdb = new ServiceDiscoveryBehavior ();
sdb.AnnouncementEndpoints.Add (aEndpoint);
host.Description.Behaviors.Add (sdb);
host.AddServiceEndpoint (typeof (ITestService), new BasicHttpBinding (), serviceUri);
host.Open ();
// It does not start announcement very soon, so wait for a while.
Thread.Sleep (1000);
foreach (var edm in host.Extensions.Find<DiscoveryServiceExtension> ().PublishedEndpoints)
TextWriter.Null.WriteLine ("Published Endpoint: " + edm.Address);
try {
// actual client, with DiscoveryClientBindingElement
var be = new DiscoveryClientBindingElement () { DiscoveryEndpointProvider = new ManagedDiscoveryEndpointProvider (dEndpoint) };
var clientBinding = new CustomBinding (new BasicHttpBinding ());
clientBinding.Elements.Insert (0, be);
var cf = new ChannelFactory<ITestService> (clientBinding, DiscoveryClientBindingElement.DiscoveryEndpointAddress);
var ch = cf.CreateChannel ();
Assert.AreEqual ("TEST", ch.Echo ("TEST"), "#1");
} finally {
host.Close ();
}
}
public void Use ()
{
var b = new ServiceDiscoveryBehavior ();
b.AnnouncementEndpoints.Add (new UdpAnnouncementEndpoint ());
IServiceBehavior sb = b;
var host = new ServiceHost (new Uri ("http://localhost:37564"));
var bc = new BindingParameterCollection ();
sb.AddBindingParameters (host.Description, host, host.Description.Endpoints, bc);
Assert.AreEqual (0, bc.Count, "#1");
Assert.AreEqual (0, host.Extensions.Count, "#2-1");
sb.Validate (host.Description, host);
// ... 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 (0, host.ChannelDispatchers.Count, "#3-1");
sb.ApplyDispatchBehavior (host.Description, host);
Assert.AreEqual (0, host.Description.Endpoints.Count, "#3-2");
Assert.AreEqual (2, host.ChannelDispatchers.Count, "#3-3"); // for online and offline announcements
Assert.AreEqual (0, dse.PublishedEndpoints.Count, "#3-4"); // discovery endpoints are not "published"
int idx = 0;
foreach (var cdisb in host.ChannelDispatchers) {
var cdis = cdisb as ChannelDispatcher;
string head = "#4." + idx + ".";
Assert.IsNull (cdis, head + "dispatcher");
if (cdisb.Listener != null)
Assert.AreEqual ("urn:schemas-microsoft-org:ws:2008:07:discovery", cdisb.Listener.Uri.ToString (), head + "uri");
// else ... WHOA! .NET "OnlineAnnouncementChannelDispatcher" type does not seem to provide the listener.
idx++;
}
}
public DiscoverableAttribute(Type resolverType, string[] ignoredContractTypeNames, string[] ignoredEndpoints, params Type[] pluginTypes)
{
_ignoredContractTypeNames = ignoredContractTypeNames ?? new string[] { };
_ignoredEndpoints = ignoredEndpoints ?? new string[] { };
var resolver = Activator.CreateInstance(resolverType) as IDiscoveryServiceResolver;
var binding = resolver.AnnouncementBinding;
var endpointUrl = resolver.AnnouncementEndpoint;
_announcementEndpoint = new AnnouncementEndpoint(binding, new EndpointAddress(endpointUrl));
var serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(_announcementEndpoint);
_serviceDiscoveryBehavior = serviceDiscoveryBehavior;
// initialize the plugin instances (ensure the parameter is not null)
var plugins = new List<PluginBase>();
foreach (var plugInType in pluginTypes ?? new Type[] { })
{
var plugin = Activator.CreateInstance(plugInType) as PluginBase;
if (plugin != null)
{
plugins.Add(plugin);
}
}
_plugins = plugins;
}
protected override void OnStart(string[] args)
{
// Just to be really safe.
if (host != null)
{
host.Close();
host = null;
}
// Create the host.
host = new ServiceHost(typeof(ComplexNetworkWorkerService));
// The ABCs in code!
/*
Uri address = new Uri("net.tcp://localhost:1012/myservice");
NetTcpBinding binding = new NetTcpBinding();
Type contract = typeof(IComplexNetworkWorkerService);
// Add this endpoint.
host.AddServiceEndpoint(contract, binding, address);
*/
// discovery
ServiceDiscoveryBehavior discoveryBehavior = new ServiceDiscoveryBehavior();
host.Description.Behaviors.Add(discoveryBehavior);
host.AddServiceEndpoint(new UdpDiscoveryEndpoint());
discoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
// Open the host.
host.Open();
}
static void Main(string[] args)
{
Uri baseAddress = new Uri("net.tcp://localhost:9002/CalculatorService/" + Guid.NewGuid().ToString());
Uri announcementEndpointAddress = new Uri("net.tcp://localhost:9021/Announcement");
//create service host
ServiceHost host = new ServiceHost(typeof(CalculatorService),baseAddress);
ServiceDebugBehavior sdb = host.Description.Behaviors.Find<ServiceDebugBehavior>();
if (sdb == null)
{
host.Description.Behaviors.Add(
new ServiceDebugBehavior() { IncludeExceptionDetailInFaults = true });
}
else
{
if (!sdb.IncludeExceptionDetailInFaults)
{
sdb.IncludeExceptionDetailInFaults = true;
}
}
//try
//{
//add a service endpoint
ServiceEndpoint netTcpEndpoint = host.AddServiceEndpoint(typeof(ICalculatorService),new NetTcpBinding(),string.Empty);
//create an announcement endpoint, which points to the Announcement endpoint hosted by the proxy service
AnnouncementEndpoint announcementEndpoint = new AnnouncementEndpoint(new NetTcpBinding(),new EndpointAddress(announcementEndpointAddress));
//create a servicediscoveryBehavior and add the announcement endpoint
ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(announcementEndpoint);
//add the serviceDiscoveryBehavior to the service host to make the service discovnerable
host.Description.Behaviors.Add(serviceDiscoveryBehavior);
//start listening for messages
host.Open();
Console.WriteLine("Calculator Service started at {0}", baseAddress);
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
host.Close();
//}
//catch (CommunicationException e)
//{
// Console.WriteLine(e.Message);
//}
//catch (TimeoutException e)
//{
// Console.WriteLine(e.Message);
//}
//if (host.State != CommunicationState.Closed)
//{
// Console.WriteLine("Aborting the service...");
// host.Abort();
//}
}
static void UseCase1Core (Uri serviceUri, AnnouncementEndpoint aEndpoint, DiscoveryEndpoint dEndpoint)
{
var host = new ServiceHost (typeof (TestService));
var sdb = new ServiceDiscoveryBehavior ();
sdb.AnnouncementEndpoints.Add (aEndpoint);
host.Description.Behaviors.Add (sdb);
host.AddServiceEndpoint (typeof (ITestService), new BasicHttpBinding (), serviceUri);
host.Open ();
Console.WriteLine ("Type [CR] to quit ...");
Console.ReadLine ();
host.Close ();
}
public Host()
{
Uri baseAddress = new Uri(string.Format("net.tcp://{0}:8228/discovery",
System.Net.Dns.GetHostName(), Guid.NewGuid().ToString()));
//WSHttpBinding binding = new WSHttpBinding(SecurityMode.None, true);
//NetHttpBinding binding = new NetHttpBinding(BasicHttpSecurityMode.None, true);
NetTcpBinding binding = new NetTcpBinding(SecurityMode.None, false);
binding.MaxReceivedMessageSize = 1024000000;
binding.MaxBufferPoolSize = 4096000;
binding.TransferMode = TransferMode.Streamed;
binding.ReceiveTimeout = TimeSpan.MaxValue;
binding.SendTimeout = TimeSpan.MaxValue;
serviceHost = new ServiceHost(typeof(ServerManagement), baseAddress);
serviceHost.AddServiceEndpoint(typeof(IServerManagement), binding, string.Empty);
//Uri httpbaseAddress = new Uri(string.Format("http://{0}:8227/discovery",
//System.Net.Dns.GetHostName(), Guid.NewGuid().ToString()));
//// Create a ServiceHost for the CalculatorService type.
//WSHttpBinding httpbinding = new WSHttpBinding(SecurityMode.None, true);
//httpbinding.MaxReceivedMessageSize = 1024000000;
//httpbinding.MaxBufferPoolSize = 4096000;
//discoverHost = new ServiceHost(typeof(ServerManagement), httpbaseAddress);
//discoverHost.AddServiceEndpoint(typeof(IServerManagement), httpbinding, string.Empty);
// ** DISCOVERY ** //
// make the service discoverable by adding the discovery behavior
ServiceDiscoveryBehavior discoveryBehavior = new ServiceDiscoveryBehavior();
serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
// send announcements on UDP multicast transport
discoveryBehavior.AnnouncementEndpoints.Add(
new UdpAnnouncementEndpoint());
// ** DISCOVERY ** //
// add the discovery endpoint that specifies where to publish the services
serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint());
string ip = "127.0.0.1";
int port = 8229;
string uri = string.Format("net.tcp://{0}:{1}", ip, port);
NetTcpBinding publishbinding = new NetTcpBinding();
binding.ReceiveTimeout = TimeSpan.MaxValue;
publishhost = new ServiceHost(typeof(MessagePublishServiceImpl));
publishhost.AddServiceEndpoint(typeof(IMessagePublishService), publishbinding, uri);
MessageCenter.Instance.ListenerAdded += new EventHandler<MessageListenerEventArgs>(Instance_ListenerAdded);
MessageCenter.Instance.ListenerRemoved += new EventHandler<MessageListenerEventArgs>(Instance_ListenerRemoved);
MessageCenter.Instance.NotifyError += new EventHandler<MessageNotifyErrorEventArgs>(Instance_NotifyError);
}
static void Main()
{
var dnsName = Dns.GetHostName();
// Define the base address of the service
var baseAddress = new Uri(string.Format("net.tcp://{0}:9002/CalculatorService/{1}", dnsName, Guid.NewGuid().ToString()));
// Define the endpoint address where announcement messages will be sent
var announcementEndpointAddress = new Uri(string.Format("http://{0}:8001/Announcement", dnsName));
// Create the service host
var serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
try
{
// Add a service endpoint
var netTcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new NetTcpBinding(), string.Empty);
// Create an announcement endpoint, which points to the Announcement Endpoint hosted by the proxy service.
var announcementEndpoint = new AnnouncementEndpoint(new WSHttpBinding(SecurityMode.None), new EndpointAddress(announcementEndpointAddress));
// Create a ServiceDiscoveryBehavior and add the announcement endpoint
var serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(announcementEndpoint);
// Add the ServiceDiscoveryBehavior to the service host to make the service discoverable
serviceHost.Description.Behaviors.Add(serviceDiscoveryBehavior);
// Start listening for messages
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 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 ();
}
}
public static void Main()
{
Uri baseAddress = new Uri("net.tcp://localhost:9002/CalculatorService/" + Guid.NewGuid().ToString());
Uri announcementEndpointAddress = new Uri("net.tcp://localhost:9021/Announcement");
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
try
{
ServiceEndpoint netTcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new NetTcpBinding(), string.Empty);
// Create an announcement endpoint, which points to the Announcement Endpoint hosted by the proxy service.
AnnouncementEndpoint announcementEndpoint = new AnnouncementEndpoint(new NetTcpBinding(), new EndpointAddress(announcementEndpointAddress));
ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(announcementEndpoint);
// Make the service discoverable
serviceHost.Description.Behaviors.Add(serviceDiscoveryBehavior);
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 static void Main()
{
Uri baseAddress = new Uri("http://localhost:8000/" + Guid.NewGuid().ToString());
// Create a ServiceHost for the CalculatorService type.
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
serviceHost.AddServiceEndpoint(typeof(ICalculatorService), new WSHttpBinding(), String.Empty);
ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
// Announce the availability of the service over UDP multicast
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
try
{
// Make the service discoverable over UDP multicast
serviceHost.Description.Behaviors.Add(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();
}
}
private static void StartDiscoveryService()
{
Uri baseAddress = Discovery.AvailableTcpBaseAddress;
Console.WriteLine(baseAddress.ToString());
using (ServiceHost host = new ServiceHost(typeof(ScannerService), baseAddress))
{
host.AddServiceEndpoint(typeof(IScanner), DiscoveryHelper.CreateBinding(), string.Empty);
ServiceDiscoveryBehavior discoveryBehavior = new ServiceDiscoveryBehavior();
host.Description.Behaviors.Add(discoveryBehavior);
host.AddServiceEndpoint(new UdpDiscoveryEndpoint());
discoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
host.Open();
//Can do blocking calls:
Console.WriteLine("Press ENTER to shut down service.");
Console.ReadLine();
}
}
private static void Main()
{
try
{
Console.Write("Please enter tester id: ");
// ReSharper disable PossibleNullReferenceException
TesterId = Console.ReadLine().Replace(" ", string.Empty);
// ReSharper restore PossibleNullReferenceException
Console.WriteLine(Environment.NewLine);
StartAnnouncementService();
Thread.Sleep(400);
var testNode = new TestNode();
Host = new ServiceHost(testNode, BaseAddress);
Host.AddServiceEndpoint(typeof (ITestNode), new WSHttpBinding(), string.Empty);
var serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
Host.Description.Behaviors.Add(serviceDiscoveryBehavior);
Host.AddServiceEndpoint(new UdpDiscoveryEndpoint());
Host.Open();
Console.WriteLine("Press any key to exit . . . .");
Console.ReadKey(true);
}
catch (Exception ex)
{
PrintErrorMessageToConsole(ex);
}
}
void IServiceBehavior.ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
{
if (serviceDescription == null)
{
throw FxTrace.Exception.ArgumentNull("serviceDescription");
}
if (serviceHostBase == null)
{
throw FxTrace.Exception.ArgumentNull("serviceHostBase");
}
DiscoveryServiceExtension discoveryServiceExtension = serviceHostBase.Extensions.Find <DiscoveryServiceExtension>();
if (discoveryServiceExtension != null)
{
DiscoveryService discoveryService = discoveryServiceExtension.ValidateAndGetDiscoveryService();
ServiceDiscoveryBehavior.SetDiscoveryImplementation(serviceHostBase, discoveryService);
if (this.announcementEndpoints.Count > 0)
{
serviceHostBase.ChannelDispatchers.Add(
new OnlineAnnouncementChannelDispatcher(
serviceHostBase,
this.announcementEndpoints,
discoveryServiceExtension.InternalPublishedEndpoints,
discoveryService.MessageSequenceGenerator));
serviceHostBase.ChannelDispatchers.Insert(0,
new OfflineAnnouncementChannelDispatcher(
serviceHostBase,
this.announcementEndpoints,
discoveryServiceExtension.InternalPublishedEndpoints,
discoveryService.MessageSequenceGenerator));
}
}
}
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);
}
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);
AddAdditionalMetadata(serviceHost, discovery);
if (strict == false)
{
ExportMetadata(endpoint, discovery);
}
}
AddDiscoveryEndpoint(serviceHost);
}
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
{
Binding binding;
DiscoveryVersion ver;
ver = DiscoveryVersion.WSDiscovery11;
binding = new WSHttpBinding(SecurityMode.None);
// To enable WSDiscoveryApril2005 and Soap12WSAddressingAugust2004
//ver = DiscoveryVersion.WSDiscoveryApril2005;
//binding = new CustomBinding(new TextMessageEncodingBindingElement(MessageVersion.Soap12WSAddressingAugust2004, Encoding.UTF8), new HttpTransportBindingElement());
ServiceEndpoint wsEndpoint = serviceHost.AddServiceEndpoint(typeof(IServiceHelloWCF), binding, "");
EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior();
// Add the discovery behavior to the endpoint.
wsEndpoint.Behaviors.Add(endpointDiscoveryBehavior);
// Make the service discoverable over UDP multicast
ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
// Announce the availability of the service over UDP multicast
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint(ver));
// Make the service discoverable over UDP multicast.
serviceHost.Description.Behaviors.Add(serviceDiscoveryBehavior);
serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint(ver));
// Announce the availability of the service over UDP multicast
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();
}
}
public void OpenAll(string hostName)
{
try
{
//startup CheckinHandler listener
Uri baseAddress = new Uri(string.Format("net.tcp://{0}:8000/discovery/CheckinHandler/{1}", hostName, Guid.NewGuid()));
ServiceHost host = new ServiceHost(typeof(CheckinHandler), baseAddress);
//add CheckinHandler endpoint
host.AddServiceEndpoint(typeof(ICheckinHandler), new NetTcpBinding(SecurityMode.None), baseAddress.ToString());
//make CheckinHandler service discoverable
var discoveryBehavior = new ServiceDiscoveryBehavior();
host.Description.Behaviors.Add(discoveryBehavior);
//add the discovery endpoint that specifies where to public CheckinHandler service
host.AddServiceEndpoint(new UdpDiscoveryEndpoint());
_serviceHosts.Add(host);
host.Open();
//startup DatabaseAdmin listener
baseAddress = new Uri(string.Format("net.tcp://{0}:8010/discovery/DatabaseAdmin/{1}", hostName, Guid.NewGuid()));
host = new ServiceHost(typeof(DatabaseAdmin), baseAddress);
//add DatabaseAdmin endpoint
host.AddServiceEndpoint(typeof(IDatabaseAdmin), new NetTcpBinding(SecurityMode.None), baseAddress.ToString());
//make DatabaseAdmin service discoverable
discoveryBehavior = new ServiceDiscoveryBehavior();
host.Description.Behaviors.Add(discoveryBehavior);
//add the discovery endpoint that specifies where to public DatabaseAdmin service
host.AddServiceEndpoint(new UdpDiscoveryEndpoint());
_serviceHosts.Add(host);
host.Open();
//startup PilotCheckin listener
baseAddress = new Uri(string.Format("net.tcp://{0}:8020/discovery/PilotCheckinHandler/{1}", hostName, Guid.NewGuid()));
host = new ServiceHost(typeof(PilotCheckinHandler), baseAddress);
//add PilotCheckin endpoint
host.AddServiceEndpoint(typeof(IPilotCheckin), new NetTcpBinding(SecurityMode.None), baseAddress.ToString());
//make PilotCheckin service discoverable
discoveryBehavior = new ServiceDiscoveryBehavior();
host.Description.Behaviors.Add(discoveryBehavior);
//add the discovery endpoint that specifies where to public PilotCheckin service
host.AddServiceEndpoint(new UdpDiscoveryEndpoint());
_serviceHosts.Add(host);
host.Open();
}
catch (Exception e)
{
Console.WriteLine("Unexpected error in ServiceManager.OpenAll: " + e.Message);
}
}
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;
}
}
private void CreateServiceHost(IEventService instance)
{
var guid = Guid.NewGuid();
host = new ServiceHost(instance,
GetUri(guid));
host.AddServiceEndpoint(
typeof(IEventService),
GetBinding(),
"EventService");
#if !NET35
var discoveryBehavior = new ServiceDiscoveryBehavior();
host.Description.Behaviors.Add(discoveryBehavior);
host.AddServiceEndpoint(new UdpDiscoveryEndpoint());
discoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
#else
discoverer = new Discovery.ServiceDiscoverer();
StartDiscoverer(discoverer, guid);
#endif
host.Description.Behaviors.Add(new ServiceThrottlingBehavior
{
MaxConcurrentSessions = 1000
});
host.Description.Endpoints[0].Contract.Operations[0].Behaviors.Add(new EncryptionBehavior { EncryptionKey = encryptionKey });
host.Opened += (s, e) => IsStarted = true;
host.Closed += (s, e) => IsStarted = false;
}
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 void UseHttpBinding ()
{
var ahost = new ServiceHost (typeof (AnnouncementService));
var aendpoint = new AnnouncementEndpoint (new CustomBinding (new HttpTransportBindingElement ()), new EndpointAddress ("http://localhost:4989"));
var ib = new InspectionBehavior ();
object state = new object ();
ib.RequestReceived += delegate {
InspectionBehavior.State = state;
return null;
};
aendpoint.Behaviors.Add (ib);
ahost.AddServiceEndpoint (aendpoint);
ahost.Open ();
try {
Assert.IsTrue (ib.DispatchBehaviorApplied, "#1");
var b = new ServiceDiscoveryBehavior ();
b.AnnouncementEndpoints.Add (new AnnouncementEndpoint (new CustomBinding (new HttpTransportBindingElement ()), new EndpointAddress ("http://localhost:4989")));
IServiceBehavior sb = b;
var host = new ServiceHost (typeof (TestService));
var se = host.AddServiceEndpoint (typeof (ITestService), new BasicHttpBinding (), new Uri ("http://localhost:37564"));
var bc = new BindingParameterCollection ();
sb.AddBindingParameters (host.Description, host, host.Description.Endpoints, bc);
sb.Validate (host.Description, host);
// ... should "validate" not "apply dispatch behavior" do "add host extension" job? I doubt that.
var dse = host.Extensions.Find<DiscoveryServiceExtension> ();
Assert.IsNotNull (dse, "#2");
sb.ApplyDispatchBehavior (host.Description, host);
// The IEndpointBehavior from ServiceDiscoveryBehavior, when ApplyDispatchBehavior() is invoked, publishes an endpoint.
se.Behaviors [0].ApplyDispatchBehavior (se, new EndpointDispatcher (new EndpointAddress ("http://localhost:37564"), "ITestService", "http://tempuri.org/"));
host.Open ();
try {
Assert.AreEqual (state, InspectionBehavior.State, "#3");
} finally {
host.Close ();
}
} finally {
ahost.Close ();
}
}
/// <summary>
/// 为当前宿主中承载的服务启用自动发现机制。
/// </summary>
/// <param name="enableMEX">是否启用元数据交换服务，默认为 <c>true</c>。</param>
/// <param name="enableHttpGet">是否启用 Http Get 协议。</param>
public void EnableDiscovery(bool enableMEX = true, bool enableHttpGet = true)
{
// 如果没有为服务配置终结点，则为服务添加默认终结点
if (this.Description.Endpoints.Count == 0)
{
this.AddDefaultEndpoints();
}
// 为服务添加一个 UdpDiscoveryEndpoint 以支持自动发现
if (!this.HasUdpDiscoveryEndpoint)
{
this.AddServiceEndpoint(new UdpDiscoveryEndpoint());
}
// 为服务添加发现行为
if (!this.HasDiscoveryBehavior)
{
ServiceDiscoveryBehavior discovery = new ServiceDiscoveryBehavior();
// 为发现行为添加UDP多播公告终结点，以向侦听客户端公告服务可用性
discovery.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
// 将发现行为添加到服务中
this.Description.Behaviors.Add(discovery);
}
// 如果启用元数据交换，则为服务的每一个基址添加元数据交换行为
if (enableMEX == true)
{
#region
if (!this.HasMetadataBehavior)
{
ServiceMetadataBehavior metadataBehavior = new ServiceMetadataBehavior();
this.Description.Behaviors.Add( metadataBehavior );
for (int i = 0; i < this.BaseAddresses.Count; i++)
{
switch (this.BaseAddresses[i].Scheme.ToLower())
{
case "http":
metadataBehavior.HttpGetEnabled = enableHttpGet;
break;
case "https":
metadataBehavior.HttpsGetEnabled = enableHttpGet;
break;
default:
break;
}
}
}
if (!this.HasMetadataExchangeEndpoint)
{
foreach (Uri baseAddress in this.BaseAddresses)
{
Binding binding = null;
// 根据基址的不同架构，为元数据交换服务创建绑定
switch (baseAddress.Scheme.ToLower())
{
case "net.tcp":
binding = MetadataExchangeBindings.CreateMexTcpBinding();
break;
case "net.pipe":
binding = MetadataExchangeBindings.CreateMexNamedPipeBinding();
break;
case "http":
binding = MetadataExchangeBindings.CreateMexHttpBinding();
break;
case "https":
binding = MetadataExchangeBindings.CreateMexHttpsBinding();
break;
}
if (binding != null)
{
this.AddServiceEndpoint(typeof(IMetadataExchange), binding, "MEX");
}
}
}
#endregion
}
}
public static ServiceHost Start()
{
Debug.Log("Starting WFC service...");
try
{
var service = new ServiceHost(typeof(Sync), new Uri("http://localhost:8080/tLog"));
service.AddServiceEndpoint(typeof(ISync), new BasicHttpBinding(), new Uri("http://localhost:8080/tLog"));
ServiceDiscoveryBehavior discoveryBehavior = new ServiceDiscoveryBehavior();
service.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
// send announcements on UDP multicast transport
discoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
service.Description.Endpoints.Add(new UdpDiscoveryEndpoint());
service.Open();
return service;
}
catch (Exception)
{
//fixme
var service = new ServiceHost(typeof(Sync), new Uri("http://localhost:80/Temporary_Listen_Addresses/TLog"));
service.AddServiceEndpoint(typeof(ISync), new BasicHttpBinding(), new Uri("http://localhost:80/Temporary_Listen_Addresses/TLog"));
ServiceDiscoveryBehavior discoveryBehavior = new ServiceDiscoveryBehavior();
service.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
// send announcements on UDP multicast transport
discoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
service.Description.Endpoints.Add(new UdpDiscoveryEndpoint());
service.Open();
return service;
}
}
static void Main(string[] args)
{
#if DEBUG
Console.WriteLine("Mode=Debug");
#else
Console.WriteLine("Mode=Release");
#endif
using (IUnityContainer container = new UnityContainer())
{
RegisterTypes(container);
Uri masterAddress = new Uri("net.tcp://localhost:57344/Orationi/Master/v1/");
Uri apiAddress = new Uri("http://localhost:57345/Orationi/Master/Api/v1/");
ServiceHost masterHost = new UnityServiceHost(container, typeof(OrationiMasterService), masterAddress);
ServiceHost apiHost = new UnityServiceHost(container, typeof(OrationiMasterApiService), apiAddress);
try
{
masterHost.AddServiceEndpoint(typeof(IOrationiMasterService), new NetTcpBinding(SecurityMode.None), string.Empty);
// ** DISCOVERY ** //
// make the service discoverable by adding the discovery behavior
ServiceDiscoveryBehavior discoveryBehavior = new ServiceDiscoveryBehavior();
masterHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior());
// send announcements on UDP multicast transport
discoveryBehavior.AnnouncementEndpoints.Add(new UdpAnnouncementEndpoint());
// ** DISCOVERY ** //
// add the discovery endpoint that specifies where to publish the services
masterHost.Description.Endpoints.Add(new UdpDiscoveryEndpoint());
masterHost.Open();
var apiEndpoint = apiHost.AddServiceEndpoint(typeof(IOrationiApiService), new WebHttpBinding(WebHttpSecurityMode.None), string.Empty);
apiEndpoint.EndpointBehaviors.Add(new WebHttpBehavior());
apiEndpoint.Behaviors.Add(new CorsSupportBehavior());
ServiceMetadataBehavior smb = apiHost.Description.Behaviors.Find<ServiceMetadataBehavior>() ?? new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
smb.MetadataExporter.PolicyVersion = PolicyVersion.Policy15;
apiHost.Description.Behaviors.Add(smb);
apiHost.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName, MetadataExchangeBindings.CreateMexHttpBinding(), "mex");
apiHost.Open();
Console.WriteLine("\nMaster Service is running...");
Console.WriteLine("\nAvailable Endpoints:");
masterHost.Description.Endpoints.ToList().ForEach(endpoint => Console.WriteLine(endpoint.Address.ToString()));
Console.WriteLine("\nMaster Api Service is running...");
Console.WriteLine("\nAvailable Endpoints:");
apiHost.Description.Endpoints.ToList().ForEach(endpoint => Console.WriteLine(endpoint.Address.ToString()));
Console.WriteLine("Press <ENTER> to terminate service.");
Console.WriteLine();
Console.ReadLine();
// Close the ServiceHostBase to shutdown the service.
masterHost.Close();
apiHost.Close();
}
catch (CommunicationException ce)
{
Console.WriteLine("An exception occurred: {0}", ce.Message);
masterHost.Abort();
apiHost.Abort();
}
}
}
