static void RunCodeUnderDiscoveryHost(Uri serviceUri, Uri aHostUri, Action <Uri, AnnouncementEndpoint, DiscoveryEndpoint> action)
{
var abinding = new CustomBinding(new HttpTransportBindingElement());
var aAddress = new EndpointAddress(aHostUri);
var aEndpoint = new AnnouncementEndpoint(abinding, aAddress);
var dEndpoint = new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscovery11, new Uri("soap.udp://239.255.255.250:3802/"));
var ib = new InspectionBehavior();
ib.RequestReceived += delegate(ref Message msg, IClientChannel
channel, InstanceContext instanceContext) {
var mb = msg.CreateBufferedCopy(0x10000);
msg = mb.CreateMessage();
Console.Error.WriteLine(mb.CreateMessage());
return(null);
};
ib.ReplySending += delegate(ref Message msg, object o) {
var mb = msg.CreateBufferedCopy(0x10000);
msg = mb.CreateMessage();
Console.Error.WriteLine(mb.CreateMessage());
};
dEndpoint.Behaviors.Add(ib);
aEndpoint.Behaviors.Add(ib);
action(serviceUri, aEndpoint, dEndpoint);
}
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();
//}
}
private AnnouncementClient CreateClient()
{
var endpointAddress = new EndpointAddress(_options.RegistryUri);
var endpoint = new AnnouncementEndpoint(_options.Binding, endpointAddress);
return(new AnnouncementClient(endpoint));
}
void RunCodeUnderDiscoveryHost1(Uri serviceUri, Uri dHostUri, Uri aHostUri, Action <Uri, AnnouncementEndpoint, DiscoveryEndpoint> action)
{
// announcement service
var abinding = new CustomBinding(new HttpTransportBindingElement());
var aAddress = new EndpointAddress(aHostUri);
var aEndpoint = new AnnouncementEndpoint(abinding, aAddress);
// discovery service
var dbinding = new CustomBinding(new HttpTransportBindingElement());
var dAddress = new EndpointAddress(dHostUri);
var dEndpoint = new DiscoveryEndpoint(dbinding, dAddress);
// Without this, .NET rejects the host as if it had no service.
dEndpoint.IsSystemEndpoint = false;
// it internally hosts an AnnouncementService
using (var inst = new AnnouncementBoundDiscoveryService(aEndpoint)) {
var host = new ServiceHost(inst);
host.AddServiceEndpoint(dEndpoint);
try {
host.Open();
action(serviceUri, aEndpoint, dEndpoint);
} finally {
host.Close();
}
}
}
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);
try {
// actual client, with DiscoveryClientBindingElement
var be = new DiscoveryClientBindingElement()
{
DiscoveryEndpointProvider = new SimpleDiscoveryEndpointProvider(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");
cf.Close();
} finally {
host.Close();
}
}
static void Main(string[] args)
{
DiscoveryEndpoint dsed1, dsed2;
dsed1 = new DiscoveryEndpoint(DiscoveryVersion.WSDiscoveryApril2005, ServiceDiscoveryMode.Adhoc);
dsed2 = new DiscoveryEndpoint(DiscoveryVersion.WSDiscoveryApril2005, ServiceDiscoveryMode.Managed);
Console.WriteLine($"WSDiscoveryApril2005 dsed1 {dsed1.Contract.ContractType.Name } dsed2 {dsed2.Contract.ContractType.Name }");
dsed1 = new DiscoveryEndpoint(DiscoveryVersion.WSDiscovery11, ServiceDiscoveryMode.Adhoc);
dsed2 = new DiscoveryEndpoint(DiscoveryVersion.WSDiscovery11, ServiceDiscoveryMode.Managed);
Console.WriteLine($"WSDiscoveryApril2005 dsed1 {dsed1.Contract.ContractType.Name } dsed2 {dsed2.Contract.ContractType.Name }");
dsed1 = new DiscoveryEndpoint(DiscoveryVersion.WSDiscoveryCD1, ServiceDiscoveryMode.Adhoc);
dsed2 = new DiscoveryEndpoint(DiscoveryVersion.WSDiscoveryCD1, ServiceDiscoveryMode.Managed);
Console.WriteLine($"WSDiscoveryApril2005 dsed1 {dsed1.Contract.ContractType.Name } dsed2 {dsed2.Contract.ContractType.Name }");
AnnouncementEndpoint announcementEndpoint;
announcementEndpoint = new AnnouncementEndpoint(DiscoveryVersion.WSDiscovery11);
Console.WriteLine($"WSDiscovery11 dsed1 {announcementEndpoint.Contract.ContractType.Name } ");
announcementEndpoint = new AnnouncementEndpoint(DiscoveryVersion.WSDiscoveryApril2005);
Console.WriteLine($"WSDiscoveryApril2005 dsed1 {announcementEndpoint.Contract.ContractType.Name } ");
announcementEndpoint = new AnnouncementEndpoint(DiscoveryVersion.WSDiscoveryCD1);
Console.WriteLine($"WSDiscoveryCD1 dsed1 {announcementEndpoint.Contract.ContractType.Name } ");
Console.Read();
}
protected override ServiceEndpoint CreateServiceEndpoint (ContractDescription contractDescription)
{
if (contractDescription == null)
throw new ArgumentNullException ("contractDescription");
var ret = new AnnouncementEndpoint (DiscoveryVersion) { MaxAnnouncementDelay = this.MaxAnnouncementDelay };
if (ret.Contract.ContractType != contractDescription.ContractType)
throw new ArgumentException ("The argument contractDescription does not represent the expected Announcement contract");
return ret;
}
protected internal override void InitializeFrom(ServiceEndpoint endpoint)
{
base.InitializeFrom(endpoint);
AnnouncementEndpoint source = (AnnouncementEndpoint)endpoint;
this.MaxAnnouncementDelay = source.MaxAnnouncementDelay;
this.DiscoveryVersion = source.DiscoveryVersion;
}
public WcfDiscoveryExtension AnnounceUsing(AnnouncementEndpoint endpoint)
{
if (announceEndpoints == null)
{
announceEndpoints = new HashSet <AnnouncementEndpoint>();
}
announceEndpoints.Add(endpoint);
return(this);
}
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;
}
}
static void RunCodeUnderDiscoveryHost(Uri serviceUri, Uri dHostUri, Uri aHostUri, Action <Uri, AnnouncementEndpoint, DiscoveryEndpoint> action)
{
var abinding = new CustomBinding(new HttpTransportBindingElement());
var aAddress = new EndpointAddress(aHostUri);
var aEndpoint = new AnnouncementEndpoint(abinding, aAddress);
var dbinding = new CustomBinding(new HttpTransportBindingElement());
var dAddress = new EndpointAddress(dHostUri);
var dEndpoint = new DiscoveryEndpoint(dbinding, dAddress);
action(serviceUri, aEndpoint, dEndpoint);
}
protected internal override void InitializeFrom(ServiceEndpoint endpoint)
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
AnnouncementEndpoint ae = (AnnouncementEndpoint)endpoint;
DiscoveryVersion = ae.DiscoveryVersion;
MaxAnnouncementDelay = ae.MaxAnnouncementDelay;
}
static void RunCodeUnderDiscoveryHost(Uri serviceUri, Uri aHostUri)
{
// announcement service
var abinding = new CustomBinding(new HttpTransportBindingElement());
var aAddress = new EndpointAddress(aHostUri);
var aEndpoint = new AnnouncementEndpoint(abinding, aAddress);
// discovery service
var dBinding = new CustomBinding(new TextMessageEncodingBindingElement(), new TcpTransportBindingElement());
var dEndpoint = new DiscoveryEndpoint(DiscoveryVersion.WSDiscovery11, ServiceDiscoveryMode.Adhoc, dBinding, new EndpointAddress("net.tcp://" + hostname + ":9090/"));
// Without this, .NET rejects the host as if it had no service.
dEndpoint.IsSystemEndpoint = false;
var ib = new InspectionBehavior();
ib.ReplySending += delegate(ref Message msg, object o) {
var mb = msg.CreateBufferedCopy(0x10000);
msg = mb.CreateMessage();
Console.Error.WriteLine(mb.CreateMessage());
};
ib.RequestReceived += delegate(ref Message msg, IClientChannel channel, InstanceContext instanceContext) {
var mb = msg.CreateBufferedCopy(0x10000);
msg = mb.CreateMessage();
Console.Error.WriteLine(mb.CreateMessage());
return(null);
};
ib.ReplyReceived += delegate(ref Message msg, object o) {
var mb = msg.CreateBufferedCopy(0x10000);
msg = mb.CreateMessage();
Console.Error.WriteLine(mb.CreateMessage());
};
ib.RequestSending += delegate(ref Message msg, IClientChannel channel) {
var mb = msg.CreateBufferedCopy(0x10000);
msg = mb.CreateMessage();
Console.Error.WriteLine(mb.CreateMessage());
return(null);
};
dEndpoint.Behaviors.Add(ib);
aEndpoint.Behaviors.Add(ib);
// it internally hosts an AnnouncementService
using (var inst = new AnnouncementBoundDiscoveryService(aEndpoint)) {
var host = new ServiceHost(inst);
host.AddServiceEndpoint(dEndpoint);
host.Description.Behaviors.Find <ServiceDebugBehavior> ()
.IncludeExceptionDetailInFaults = true;
host.Open();
Console.WriteLine("Type [CR] to quit...");
Console.ReadLine();
host.Close();
}
}
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 AnnouncementBoundDiscoveryService(AnnouncementEndpoint aendpoint)
{
var ans = new AnnouncementService();
ans.OnlineAnnouncementReceived += RegisterEndpoint;
ans.OfflineAnnouncementReceived += UnregisterEndpoint;
ahost = new ServiceHost(ans);
ahost.AddServiceEndpoint(aendpoint);
ahost.Open();
foreach (var cd in ahost.ChannelDispatchers)
{
TextWriter.Null.WriteLine("AnnouncementService.ChannelDispatcher " + cd.Listener.Uri);
}
}
public void DefaultValues()
{
var de = new AnnouncementEndpoint();
Assert.AreEqual(DiscoveryVersion.WSDiscovery11, de.DiscoveryVersion, "#1");
Assert.AreEqual(TimeSpan.Zero, de.MaxAnnouncementDelay, "#2");
Assert.IsNotNull(de.Contract, "#11"); // some version-dependent internal type.
Assert.AreEqual("http://docs.oasis-open.org/ws-dd/ns/discovery/2009/01", de.Contract.Namespace, "#11-2");
Assert.AreEqual("Client", de.Contract.Name, "#11-3");
Assert.IsNull(de.Binding, "#12");
Assert.IsNull(de.Address, "#13");
Assert.IsNull(de.ListenUri, "#14");
Assert.AreEqual(0, de.Behaviors.Count, "#15");
}
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();
}
}
public AnnouncementBoundDiscoveryService(AnnouncementEndpoint aendpoint)
{
var ans = new AnnouncementService();
ans.OnlineAnnouncementReceived += RegisterEndpoint;
ans.OfflineAnnouncementReceived += UnregisterEndpoint;
ahost = new ServiceHost(ans);
ahost.AddServiceEndpoint(aendpoint);
ahost.Description.Behaviors.Find <ServiceDebugBehavior> ().IncludeExceptionDetailInFaults = true;
ahost.Open();
foreach (var cd in ahost.ChannelDispatchers)
{
TextWriter.Null.WriteLine("AnnouncementService.ChannelDispatcher " + cd.Listener.Uri);
}
}
protected override void OnApplyConfiguration(ServiceEndpoint endpoint, ServiceEndpointElement serviceEndpointElement)
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
AnnouncementEndpoint ae = (AnnouncementEndpoint)endpoint;
if (!ae.DiscoveryVersion.Equals(DiscoveryVersion))
{
throw new ArgumentException("Argument AnnouncementEndpoint is initialized with different DiscoveryVersion");
}
ae.MaxAnnouncementDelay = MaxAnnouncementDelay;
ae.Address = serviceEndpointElement.CreateEndpointAddress(); // it depends on InternalVisibleTo(System.ServiceModel)
ae.Binding = ConfigUtil.CreateBinding(serviceEndpointElement.Binding, serviceEndpointElement.BindingConfiguration); // it depends on InternalVisibleTo(System.ServiceModel)
}
protected internal override ServiceEndpoint CreateServiceEndpoint(ContractDescription contractDescription)
{
if (contractDescription == null)
{
throw new ArgumentNullException("contractDescription");
}
var ret = new AnnouncementEndpoint(DiscoveryVersion)
{
MaxAnnouncementDelay = this.MaxAnnouncementDelay
};
if (ret.Contract.ContractType != contractDescription.ContractType)
{
throw new ArgumentException("The argument contractDescription does not represent the expected Announcement contract");
}
return(ret);
}
public static void Main()
{
Uri probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe");
Uri announcementEndpointAddress = new Uri("net.tcp://localhost:9021/Announcement");
// Host the DiscoveryProxy service
ServiceHost proxyServiceHost = new ServiceHost(new DiscoveryProxyService());
try
{
// Add DiscoveryEndpoint to receive Probe and Resolve messages
DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress(probeEndpointAddress));
discoveryEndpoint.IsSystemEndpoint = false;
// Add AnnouncementEndpoint to receive Hello and Bye announcement messages
AnnouncementEndpoint announcementEndpoint = new AnnouncementEndpoint(new NetTcpBinding(), new EndpointAddress(announcementEndpointAddress));
proxyServiceHost.AddServiceEndpoint(discoveryEndpoint);
proxyServiceHost.AddServiceEndpoint(announcementEndpoint);
proxyServiceHost.Open();
Console.WriteLine("Proxy Service started.");
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
proxyServiceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (proxyServiceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting the service...");
proxyServiceHost.Abort();
}
}
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();
}
}
/// <summary>
/// Enables the discovery.
/// </summary>
/// <param name="host">The host.</param>
public static void EnableDiscovery(this ServiceHostBase host)
{
var announcementEndpointUrl = ConfigurationHelper.CloudAnnounce;
if (String.IsNullOrWhiteSpace(announcementEndpointUrl))
{
var errorMessage = string.Format(
"No value found for key '{0}' in configuration file"
+ ", please provide a key '{0}' in the section AppConfig and set its value to the appropriate announcement endpoint url",
ConfigurationHelper.CloudAnnounce
);
throw new ApplicationException(errorMessage);
}
var announcementEndpoint = new AnnouncementEndpoint(
BindingFactory.CreateBindingFromKey(BindingFactory.Key.WsHttpBindingNoSecurity),
new EndpointAddress(announcementEndpointUrl));
var discovery = new ServiceDiscoveryBehavior();
discovery.AnnouncementEndpoints.Add(announcementEndpoint);
host.Description.Behaviors.Add(discovery);
}
public AnnouncementClientApril2005(AnnouncementEndpoint endpoint)
: base(endpoint)
{
}
void ApplyConfiguration(ServiceEndpoint endpoint)
{
AnnouncementEndpoint announcementEndpoint = (AnnouncementEndpoint)endpoint;
announcementEndpoint.MaxAnnouncementDelay = this.MaxAnnouncementDelay;
}
public static void Main()
{
var probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe");
var announcementEndpointAddress = new Uri("net.tcp://localhost:9021/Announcement");
var probePortSharingBinding = new NetTcpBinding(SecurityMode.None);
var announcementPortSharingBinding = new NetTcpBinding(SecurityMode.None);
if (IsAdministrator())
{
probePortSharingBinding.PortSharingEnabled = true;
announcementPortSharingBinding.PortSharingEnabled = true;
}
// Host the DiscoveryProxy service
var proxyServiceHost = new ServiceHost(new DiscoveryProxyService());
try
{
// Add DiscoveryEndpoint to receive Probe and Resolve messages
var discoveryEndpoint =
new DiscoveryEndpoint(probePortSharingBinding, new EndpointAddress(probeEndpointAddress))
{
IsSystemEndpoint = false
};
// Add AnnouncementEndpoint to receive Hello and Bye announcement messages
var announcementEndpoint =
new AnnouncementEndpoint(announcementPortSharingBinding, new EndpointAddress(announcementEndpointAddress));
proxyServiceHost.AddServiceEndpoint(discoveryEndpoint);
proxyServiceHost.AddServiceEndpoint(announcementEndpoint);
proxyServiceHost.Open();
Console.WriteLine("Proxy Service started.");
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
proxyServiceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message + "\n\r");
if (e.Message.Contains("There is already a listener"))
{
Console.WriteLine("Try to run the application as Administrator:");
Console.WriteLine("Right click it and then select \"Run as administrator\".\n\r");
}
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (proxyServiceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting the service...");
Console.ReadLine();
proxyServiceHost.Abort();
}
}
public AnnouncementClientCD1(AnnouncementEndpoint endpoint)
: base(endpoint)
{
}
public IAnnouncementInnerClient CreateAnnouncementInnerClient(AnnouncementEndpoint announcementEndpoint)
{
return new AnnouncementInnerClient11(announcementEndpoint);
}
static void Main(string[] args)
{
string port = "";
bool validOption = false;
#region Escolher a porta para os probes
do
{
Console.WriteLine("Port for probe (where clients will connect to find servers) " + Environment.NewLine +
"[ENTER: 8001 | r: random | value: 1 - 65535]:");
port = Console.ReadLine();
switch (port.ToLower())
{
case "r": port = NetworkingToolkit.RandomPort().ToString();
validOption = true;
break;
case "": port = "8001";
validOption = true;
break;
default:
int i;
if (int.TryParse(port, out i))
{
validOption = i < 65535;
}
else
{
validOption = false;
}
break;
}
Console.WriteLine((validOption ? "Listening for probes on port " : "Invalid option: ") + port + Environment.NewLine);
}while (!validOption);
Uri probeEndpointAddress = new Uri("net.tcp://" + NetworkingToolkit.LocalIPAddress + ":" + port + "/Probe");
#endregion
#region Escolher a porta para os announcements
do
{
Console.WriteLine("Port for announcement (where servers will announce themselves) " + Environment.NewLine +
"[ENTER: 9021 | r: random | value: 1 - 65535]:");
port = Console.ReadLine();
switch (port.ToLower())
{
case "r": port = NetworkingToolkit.RandomPort().ToString();
validOption = true;
break;
case "": port = "9021";
validOption = true;
break;
default:
int i;
if (int.TryParse(port, out i))
{
validOption = i < 65535;
}
else
{
validOption = false;
}
break;
}
Console.WriteLine(validOption ? "Listening for announcements on port " + port : "Invalid option");
}while (!validOption);
Uri announcementEndpointAddress = new Uri("net.tcp://" + NetworkingToolkit.LocalIPAddress + ":" + port + "/Announcement");
#endregion
//Host the DiscoveryProxy service
ServiceDiscoveryProxy proxyServiceInstance = new ServiceDiscoveryProxy();
ServiceHost proxyServiceHost = new ServiceHost(proxyServiceInstance);
try
{
//Add DiscoveryEndpoint to receive Probe and Resolve messages
NetTcpBinding bindingDiscovery = new NetTcpBinding();
bindingDiscovery.Security.Mode = SecurityMode.None;
bindingDiscovery.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None;
DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(bindingDiscovery, new EndpointAddress(probeEndpointAddress));
discoveryEndpoint.IsSystemEndpoint = false;
//Add AnnouncementEndpoint to receive HAI and KTHXBYE announcement messages
NetTcpBinding bindingAnnouncement = new NetTcpBinding();
bindingAnnouncement.Security.Mode = SecurityMode.None;
//bindingAnnouncement.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None;
AnnouncementEndpoint announcementEndpoint = new AnnouncementEndpoint(bindingAnnouncement, new EndpointAddress(announcementEndpointAddress));
proxyServiceHost.AddServiceEndpoint(discoveryEndpoint);
proxyServiceHost.AddServiceEndpoint(announcementEndpoint);
proxyServiceInstance.PrintDiscoveryMetadata += ServiceDiscoveryProxy_PrintDiscoveryMetadata;
proxyServiceHost.Open();
Console.WriteLine("Proxy Service started.");
Console.WriteLine("Probe endpoint: " + discoveryEndpoint.Address);
Console.WriteLine("Announcement endpoint: " + announcementEndpoint.Address);
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate the service.");
Console.WriteLine();
Console.ReadLine();
proxyServiceHost.Close();
}
catch (CommunicationException e)
{
Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
Console.WriteLine(e.Message);
}
if (proxyServiceHost.State != CommunicationState.Closed)
{
Console.WriteLine("Aborting the service...");
proxyServiceHost.Abort();
}
}
public IAnnouncementInnerClient CreateAnnouncementInnerClient(AnnouncementEndpoint announcementEndpoint)
{
return(new AnnouncementInnerClient11(announcementEndpoint));
}
private void StartService(string serverIP, string serverPort, string localPort)
{
if (!(NetworkingToolkit.ValidateIPAddress(serverIP) && NetworkingToolkit.ValidatePort(serverPort) && NetworkingToolkit.ValidatePort(localPort)))
{
throw new ArgumentException()
{
Source = "ListeningForm.StartService(string serverIP, string serverPort, string localPort)"
}
}
;
////endereço do player
Uri baseAddress = new Uri(String.Format("net.tcp://{0}:{1}/PlayerService/{2}", NetworkingToolkit.LocalIPAddress, localPort, Guid.NewGuid()));
////endpoint para onde as mensagens de announcement serão enviadas
Uri announcementEndpointAddress = new Uri(String.Format("net.tcp://{0}:{1}/Announcement", serverIP, serverPort));
//criar o host do serviço
serviceHost = new ServiceHost(typeof(PlayerService), baseAddress);
try
{
////Adicionar um endpoint para o serviço
//NetTcpBinding tcpBindingService = new NetTcpBinding();
//tcpBindingService.Security.Mode = SecurityMode.None; //Alterar a autenticação para um modelo melhor
////tcpBindingService.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None;
//tcpBindingService.MaxReceivedMessageSize = 10000000;
//tcpBindingService.MaxBufferSize = 10000000;
//tcpBindingService.MaxBufferPoolSize = 10000000;
//ServiceEndpoint netTcpEndpoint = serviceHost.AddServiceEndpoint(typeof(IPlayer), tcpBindingService, string.Empty);
//Criar um endpoint para o announcement server, que aponta para o DiscoveryProxy
NetTcpBinding tcpBindingAnnouncement = new NetTcpBinding();
tcpBindingAnnouncement.Security.Mode = SecurityMode.None; //Alterar a autenticação para um modelo melhor
////http://nerdwords.blogspot.pt/2008/01/wcf-error-socket-connection-was-aborted.html
AnnouncementEndpoint announcementEndpoint = new AnnouncementEndpoint(tcpBindingAnnouncement, new EndpointAddress(announcementEndpointAddress));
//Criar um DiscoveryBehaviour e adicionar o endpoint
ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
serviceDiscoveryBehavior.AnnouncementEndpoints.Add(announcementEndpoint);
#if EXPOSE_METADATA
//Adicionar um endpoint MEX (Metadata EXchange) por TCP
System.ServiceModel.Channels.BindingElement bindingElement = new System.ServiceModel.Channels.TcpTransportBindingElement();
System.ServiceModel.Channels.CustomBinding binding = new System.ServiceModel.Channels.CustomBinding(bindingElement);
System.ServiceModel.Description.ServiceMetadataBehavior metadataBehavior = serviceHost.Description.Behaviors.Find <System.ServiceModel.Description.ServiceMetadataBehavior>();
if (metadataBehavior == null)
{
metadataBehavior = new System.ServiceModel.Description.ServiceMetadataBehavior();
serviceHost.Description.Behaviors.Add(metadataBehavior);
}
serviceHost.AddServiceEndpoint(typeof(System.ServiceModel.Description.IMetadataExchange), binding, "MEX");
#endif
//Adicionar o serviceDiscoveryBehavior ao host para poder ser descoberto
serviceHost.Description.Behaviors.Add(serviceDiscoveryBehavior);
serviceHost.Open();
Clipboard.SetText(baseAddress.ToString());
}
catch (CommunicationException e)
{
Log(e);
}
catch (TimeoutException e)
{
Log(e);
}
catch (Exception ex)
{
Log(ex);
}
}
void serviceHost_UnknownMessageReceived(object sender, UnknownMessageReceivedEventArgs e)
{
Log("Mensagem desconhecida recebida");
Log(e.Message.ToString());
}
void serviceHost_RefreshState(object sender, EventArgs e)
{
this.RefreshState();
}
public AnnouncementInnerClientCD1(AnnouncementEndpoint announcementEndpoint)
: base(announcementEndpoint)
{
this.discoveryMessageSequenceGenerator = new DiscoveryMessageSequenceGenerator();
}
