static void RunCodeUnderDiscoveryHost(Uri serviceUri, Uri dHostUri, Action <Uri, AnnouncementEndpoint, DiscoveryEndpoint> action) { var aEndpoint = new UdpAnnouncementEndpoint(DiscoveryVersion.WSDiscoveryApril2005, new Uri("soap.udp://239.255.255.250:3802/")); var dbinding = new CustomBinding(new HttpTransportBindingElement()); var dAddress = new EndpointAddress(dHostUri); var dEndpoint = new DiscoveryEndpoint(dbinding, dAddress); 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); }
private static void Main() { var proxyUri = new Uri("net.tcp://localhost:8001/Probe"); var proxyBinding = new NetTcpBinding(SecurityMode.None); var proxyEndpoint = new DiscoveryEndpoint(proxyBinding, new EndpointAddress(proxyUri)); var svcBinding = new NetTcpBinding(SecurityMode.None); var svcFactory = new ChannelFactory <ICombateSvcChannel>(svcBinding); GameMaster.Init(proxyEndpoint, svcFactory); var selfHost = new ServiceHost(typeof(GameMasterSvc)); try { selfHost.Open(); Console.WriteLine("Game Server started."); Console.WriteLine(); } catch (Exception e) { switch (e) { case CommunicationObjectFaultedException _: case EndpointNotFoundException _: Console.WriteLine("The Discovery Proxy couldn't be reached."); break; case TimeoutException _: Console.WriteLine("The Discovery Proxy is unresponsive."); break; case CommunicationException _: Console.WriteLine("The Discovery Proxy refused the connection."); break; default: Console.WriteLine(e); break; } Console.WriteLine(); selfHost.Abort(); } Console.WriteLine("Press <ENTER> to terminate the server."); Console.WriteLine(); Console.ReadLine(); try { selfHost.Close(); } catch (Exception) { selfHost.Abort(); } GameMaster.ProbeClientReseter.Dispose(); }
static void RunCodeUnderDiscoveryHost(Uri serviceUri, Action <Uri, DiscoveryEndpoint> action) { var dBinding = new CustomBinding(new TextMessageEncodingBindingElement(), new TcpTransportBindingElement()); var dEndpoint = new DiscoveryEndpoint(DiscoveryVersion.WSDiscovery11, ServiceDiscoveryMode.Adhoc, dBinding, new EndpointAddress("net.tcp://" + hostname + ":9090/")); var ib = new InspectionBehavior(); ib.RequestSending += delegate(ref Message msg, IClientChannel channel) { var mb = msg.CreateBufferedCopy(0x10000); msg = mb.CreateMessage(); Console.WriteLine(mb.CreateMessage()); return(null); }; ib.ReplyReceived += delegate(ref Message msg, object id) { var mb = msg.CreateBufferedCopy(0x10000); msg = mb.CreateMessage(); Console.WriteLine(mb.CreateMessage()); }; 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); }; dEndpoint.Behaviors.Add(ib); action(serviceUri, dEndpoint); }
static EndpointAddress FindCalculatorServiceAddress() { // Create DiscoveryClient DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8001/DiscoveryRouter/")); DiscoveryClient discoveryClient = new DiscoveryClient(discoveryEndpoint); Console.WriteLine("Finding ICalculatorService endpoints..."); Console.WriteLine(); // Find ICalculatorService endpoints FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService)); findCriteria.Duration = TimeSpan.FromSeconds(10); FindResponse findResponse = discoveryClient.Find(findCriteria); Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count); Console.WriteLine(); if (findResponse.Endpoints.Count > 0) { return(findResponse.Endpoints[0].Address); } else { return(null); } }
/// <summary> /// 启动服务发现代理托管器 /// </summary> /// <returns>服务宿主</returns> public ServiceHost Open() { if (proxyHost != null && proxyHost.State != CommunicationState.Closed) { throw new InvalidProgramException("This proxy host has been opened."); } // create a new service host with a singleton proxy proxyHost = new ServiceHost(new T()); // create the discovery endpoint DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(ServiceConfiguration.DefaultNetTcpBindingName), new EndpointAddress(proxyAddress)); discoveryEndpoint.IsSystemEndpoint = false; // add UDP Annoucement endpoint proxyHost.AddServiceEndpoint(new UdpAnnouncementEndpoint()); // add the discovery endpoint proxyHost.AddServiceEndpoint(discoveryEndpoint); proxyHost.Open(); Console.WriteLine("Discovery Proxy {0}", proxyAddress); return(proxyHost); }
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(); }
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(); } } }
static DiscoveryEndpoint ValidateAndGetDiscoveryEndpoint(ChannelEndpointElement channelEndpointElement) { if (string.IsNullOrEmpty(channelEndpointElement.Kind)) { throw FxTrace.Exception.AsError( new ConfigurationErrorsException( SR2.DiscoveryConfigDiscoveryEndpointMissingKind( typeof(DiscoveryEndpoint).FullName))); } ServiceEndpoint serviceEndpoint = ConfigLoader.LookupEndpoint(channelEndpointElement, null); if (serviceEndpoint == null) { throw FxTrace.Exception.AsError( new ConfigurationErrorsException( SR2.DiscoveryConfigInvalidEndpointConfiguration( channelEndpointElement.Kind))); } DiscoveryEndpoint discoveryEndpoint = serviceEndpoint as DiscoveryEndpoint; if (discoveryEndpoint == null) { throw FxTrace.Exception.AsError( new InvalidOperationException( SR2.DiscoveryConfigInvalidDiscoveryEndpoint( typeof(DiscoveryEndpoint).FullName, channelEndpointElement.Kind, serviceEndpoint.GetType().FullName))); } return(discoveryEndpoint); }
public TService Discover <TService>() where TService : class { var discoveryBinding = _options.DiscoveryBindingFactory.Invoke(); if (!string.Equals(discoveryBinding.Scheme, _options.ProbeEndpoint.Scheme)) { throw new ArgumentException("ProbeEndpoint is not valid for the given DiscoveryBinding", nameof(ServiceModelDiscoveryOptions.ProbeEndpoint)); } var probeEndpointAddress = new EndpointAddress(_options.ProbeEndpoint); var discoveryEndpoint = new DiscoveryEndpoint(discoveryBinding, probeEndpointAddress); try { var criteria = new FindCriteria(typeof(TService)); var endpoints = _discoveryClient.FindEndpoints(discoveryEndpoint, criteria); var items = from endpoint in endpoints let binding = _bindingFactory.Create(typeof(TService), endpoint.Address.Uri.Scheme) where binding != null let channel = _channelFactory.CreateChannel <TService>(binding, endpoint.Address) select channel; return(items.FirstOrDefault()); } catch (Exception ex) { _logger.LogError(ex, $"An error occurred while resolving the service {typeof(TService).Name}"); } return(null); }
private DiscoveryEndpoint DiscoverEndpoint(DiscoveryEndpoint endpoint, bool required) { using (var discover = new DiscoveryClient(UdpDiscoveryEndpoint ?? new UdpDiscoveryEndpoint())) { var criteria = new FindCriteria(endpoint.Contract.ContractType) { MaxResults = 1 }; if (DiscoveryDuration.HasValue) { criteria.Duration = DiscoveryDuration.Value; } var discovered = discover.Find(criteria); if (discovered.Endpoints.Count > 0) { var endpointMetadata = discovered.Endpoints[0]; var binding = Binding ?? AbstractChannelBuilder.GetBindingFromMetadata(endpointMetadata); return(new DiscoveryEndpoint(binding, endpointMetadata.Address)); } if (required) { throw new EndpointNotFoundException("Unable to locate a ServiceCatalog on the network."); } return(null); } }
public List <AlexaProperty> FindRelatedProperties(IPremiseObject endpoint, string currentController) { List <AlexaProperty> relatedProperties = new List <AlexaProperty>(); DiscoveryEndpoint discoveryEndpoint = PremiseServer.GetDiscoveryEndpointAsync(endpoint).GetAwaiter().GetResult(); if (discoveryEndpoint == null) { return(relatedProperties); } foreach (Capability capability in discoveryEndpoint.capabilities) { if (capability.@interface == currentController) { continue; } if (PremiseServer.Controllers.ContainsKey(capability.@interface)) { IAlexaController controller = PremiseServer.Controllers[capability.@interface]; controller.SetEndpoint(endpoint); relatedProperties.AddRange(controller.GetPropertyStates()); } } return(relatedProperties); }
static void Main(string[] args) { // Create a DiscoveryEndpoint that points to the DiscoveryProxy Uri probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe"); DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress(probeEndpointAddress)); DiscoveryClient discoveryClient = new DiscoveryClient(discoveryEndpoint); Console.WriteLine("Finding ICalculatorService endpoints using the proxy at {0}", probeEndpointAddress); Console.WriteLine(); try { // Find ICalculatorService endpoints FindResponse findResponse = discoveryClient.Find(new FindCriteria(typeof(ICalculatorService))); Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count); Console.WriteLine(); // Check to see if endpoints were found, if so then invoke the service. if (findResponse.Endpoints.Count > 0) { InvokeCalculatorService(findResponse.Endpoints[0].Address); } } catch (Exception e) { Console.WriteLine("This client was unable to connect to and query the proxy. Ensure that the proxy is up and running."); } Console.WriteLine("Press <ENTER> to exit."); Console.ReadLine(); }
/// <summary> /// Parses a URL and turns it into authority and discovery endpoint URL. /// </summary> /// <param name="input">The input.</param> /// <param name="path">The path to the discovery document. If not specified this defaults to .well-known/open-id-configuration</param> /// <returns></returns> /// <exception cref="System.InvalidOperationException"> /// Malformed URL /// </exception> public static DiscoveryEndpoint ParseUrl(string input, string path = null) { if (String.IsNullOrEmpty(path)) { path = OidcConstants.Discovery.DiscoveryEndpoint; } var success = Uri.TryCreate(input, UriKind.Absolute, out var uri); if (success == false) { throw new InvalidOperationException("Malformed URL"); } if (!DiscoveryEndpoint.IsValidScheme(uri)) { throw new InvalidOperationException("Malformed URL"); } var url = input.RemoveTrailingSlash(); if (path.StartsWith("/")) { path = path.Substring(1); } if (url.EndsWith(path, StringComparison.OrdinalIgnoreCase)) { return(new DiscoveryEndpoint(url.Substring(0, url.Length - path.Length - 1), url)); } else { return(new DiscoveryEndpoint(url, url.EnsureTrailingSlash() + path)); } }
public DiscoveredEndpointModel ManagedBy(BindingAddressEndpointModel endpoint) { var endpointAddress = endpoint.EndpointAddress ?? new EndpointAddress(endpoint.Address); DiscoveryEndpoint = new DiscoveryEndpoint(endpoint.Binding, endpointAddress); return(this); }
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(); } }
/// <summary> /// Creates the discovery client. /// </summary> /// <returns>DiscoveryClient.</returns> private static DiscoveryClient CreateDiscoveryClient() { var discoveryEndpoint = new DiscoveryEndpoint( BindingFactory.CreateBindingFromKey(BindingFactory.Key.WsHttpBindingNoSecurity), new EndpointAddress(new Uri(ConfigurationHelper.CloudProbe))); return(new DiscoveryClient(discoveryEndpoint)); }
public void Custom_path_is_supported(string input, string documentPath) { var result = DiscoveryEndpoint.ParseUrl(input, documentPath); // test parse URL logic result.Url.Should().Be("https://server:123/strange-location/openid-configuration"); result.Authority.Should().Be("https://server:123"); }
public void Various_urls_should_normalize(string input) { var result = DiscoveryEndpoint.ParseUrl(input); // test parse URL logic result.Url.Should().Be("https://server:123/.well-known/openid-configuration"); result.Authority.Should().Be("https://server:123"); }
protected internal override ServiceEndpoint CreateServiceEndpoint (ContractDescription contractDescription) { if (contractDescription == null) throw new ArgumentNullException ("contractDescription"); var ret = new DiscoveryEndpoint (DiscoveryVersion, DiscoveryMode) { MaxResponseDelay = this.MaxResponseDelay }; if (ret.Contract.ContractType != contractDescription.ContractType) throw new ArgumentException ("The argument contractDescription does not represent the expected Discovery contract"); return ret; }
} //Feito public override IEnumerable <PlayerPC> GetPlayers() { List <WCFPlayerPC> pcs = new List <WCFPlayerPC>(); Uri probeEndpointAddress = new Uri(CompleteServerAddress); NetTcpBinding binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; binding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None; DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(binding, new EndpointAddress(probeEndpointAddress)); DiscoveryClient discoveryClient = new DiscoveryClient(discoveryEndpoint); try { FindResponse findResponse = discoveryClient.Find(new FindCriteria(typeof(IPlayer))); WCFPlayerPC pc; foreach (var endpoint in findResponse.Endpoints) { try { NetTcpBinding bindingPC = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; binding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None; PlayerProxy client = new PlayerProxy(binding, endpoint.Address); client.Open(); List <WCFScreenInformation> displays = client.GetDisplayInformation().ToList <WCFScreenInformation>(); client.Close(); pc = new WCFPlayerPC() { Displays = displays, Endpoint = endpoint.Address }; pcs.Add(pc); } catch (EndpointNotFoundException) { continue; } } } catch { return(null); } return(pcs.Cast <PlayerPC>()); } //Feito
public DiscoveryProxyEndpoint(DiscoveryEndpoint endpoint) { if (endpoint == null) { throw new ArgumentNullException("endpoint"); } this.endpoint = endpoint; }
private void DiscoverEndpoint(DiscoveryEndpoint discoveryEndpoint, DiscoveredEndpointModel model) { using (var discover = new DiscoveryClient(discoveryEndpoint)) { var criteria = CreateSearchCriteria(model); var discovered = discover.Find(criteria); if (discovered.Endpoints.Count > 0) { var binding = model.Binding; var endpointMetadata = discovered.Endpoints[0]; if (discovered.Endpoints.Count > 1 && model.EndpointPreference != null) { endpointMetadata = model.EndpointPreference(discovered.Endpoints); if (endpointMetadata == null) { throw new EndpointNotFoundException(string.Format( "More than one endpoint was discovered for contract {0}. " + "However, an endpoint could be selected. This is most likely " + "a bug with the user-defined endpoint prefeence.", contract.FullName)); } } if (binding == null && model.DeriveBinding == false) { binding = GetBindingFromMetadata(endpointMetadata); } var address = endpointMetadata.Address; if (model.Identity != null) { address = new EndpointAddress(address.Uri, model.Identity, address.Headers); } binding = GetEffectiveBinding(binding, address.Uri); var innerCreator = GetChannel(contract, binding, address); channelCreator = () => { var channel = (IChannel)innerCreator(); if (channel is IContextChannel) { var metadata = new DiscoveredEndpointMetadata(endpointMetadata); ((IContextChannel)channel).Extensions.Add(metadata); } return(channel); }; } else { throw new EndpointNotFoundException(string.Format( "Unable to discover the endpoint for contract {0}. " + "Either no service exists or it does not support discovery.", contract.FullName)); } } }
protected internal override void InitializeFrom(ServiceEndpoint endpoint) { base.InitializeFrom(endpoint); DiscoveryEndpoint source = (DiscoveryEndpoint)endpoint; this.MaxResponseDelay = source.MaxResponseDelay; this.DiscoveryVersion = source.DiscoveryVersion; this.DiscoveryMode = source.DiscoveryMode; }
/// <summary> /// Needs to be called before using any other method or all will return null /// </summary> /// <exception cref="ArgumentNullException"></exception> /// <param name="probeEndpoint"></param> /// <param name="svcFactory"></param> public static void Init(DiscoveryEndpoint probeEndpoint, ChannelFactory <ICombateSvcChannel> svcFactory) { Manager = new GameManager(); ProbeClient = new DiscoveryClient(probeEndpoint); ProbeClientReseter = new Timer(ReloadProbeClient, probeEndpoint, 900000, 900000); // 15min. SvcFactory = svcFactory; }
public ResolveAsyncResult(ResolveCriteria resolveCriteria, DiscoveryEndpoint forwardingDiscoveryEndpoint, AsyncCallback callback, object state) : base(callback, state) { this.resolveCriteria = resolveCriteria; this.discoveryClient = new DiscoveryClient(forwardingDiscoveryEndpoint); this.discoveryClient.ResolveCompleted += new EventHandler <ResolveCompletedEventArgs>(ResolveCompleted); // Forwards the Resolve request message this.discoveryClient.ResolveAsync(resolveCriteria); }
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); }
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(); } }
/// <summary> /// Initializes the listener from a binding element. /// </summary> internal UaTcpChannelListener(UaTcpTransportBindingElement bindingElement, BindingContext context) : base(context.Binding) { // assign a unique guid to the listener. m_listenerId = Guid.NewGuid().ToString(); SetUri(context.ListenUriBaseAddress, context.ListenUriRelativeAddress); m_descriptions = bindingElement.Descriptions; m_configuration = bindingElement.Configuration; m_quotas = new TcpChannelQuotas(); m_quotas.MaxBufferSize = m_configuration.MaxBufferSize; m_quotas.MaxMessageSize = m_configuration.MaxMessageSize; m_quotas.ChannelLifetime = m_configuration.ChannelLifetime; m_quotas.SecurityTokenLifetime = m_configuration.SecurityTokenLifetime; m_quotas.MessageContext = bindingElement.MessageContext; foreach (object parameter in context.BindingParameters) { ServiceCredentials credentials = parameter as ServiceCredentials; if (credentials != null) { // TBD - paste the cert with the private key with the additional chain. m_serverCertificate = CertificateFactory.Create(credentials.ServiceCertificate.Certificate, credentials.ServiceCertificate.Certificate); m_quotas.CertificateValidator = credentials.ClientCertificate.Authentication.CustomCertificateValidator; } } m_bufferManager = new BufferManager("Server", (int)bindingElement.MaxBufferPoolSize, m_quotas.MaxBufferSize); m_channels = new Dictionary <uint, TcpServerChannel>(); m_channelQueue = new Queue <UaTcpReplyChannel>(); m_acceptQueue = new Queue <TcpAsyncOperation <IReplySessionChannel> >(); // link the channel directly to the server. // this is a hack designed to work around a bug in the WCF framework that results in lost requests during stress testing. if (bindingElement.ServiceHost != null) { if (bindingElement.ServiceHost.Server is DiscoveryServerBase) { m_callback = new DiscoveryEndpoint(bindingElement.ServiceHost); } else { m_callback = new SessionEndpoint(bindingElement.ServiceHost); } } }
public DiscoveryInnerClientAdhocCD1(DiscoveryEndpoint discoveryEndpoint, IDiscoveryInnerClientResponse responseReceiver) { Fx.Assert(discoveryEndpoint != null, "The discoveryEndpoint parameter cannot be null"); Fx.Assert(responseReceiver != null, "The responseReceiver parameter cannot be null"); this.responseReceiver = responseReceiver; if (discoveryEndpoint.Behaviors.Find <DiscoveryCallbackBehavior>() == null) { discoveryEndpoint.Behaviors.Insert(0, new DiscoveryCallbackBehavior()); } this.duplexInnerClient = new DuplexClientCD1(this, discoveryEndpoint); }
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(); }
private void DiscoveryEndpointFaulted(object sender, DiscoveryEndpointFaultEventArgs args) { using (var locker = @lock.ForReadingUpgradeable()) { if (args.Culprit != endpoint) { return; } locker.Upgrade(); endpoint = null; } }
public IDiscoveryInnerClient CreateDiscoveryInnerClient(DiscoveryEndpoint discoveryEndpoint, IDiscoveryInnerClientResponse responseReceiver) { if (discoveryEndpoint.DiscoveryMode == ServiceDiscoveryMode.Adhoc) { return new DiscoveryInnerClientAdhoc11(discoveryEndpoint, responseReceiver); } else if (discoveryEndpoint.DiscoveryMode == ServiceDiscoveryMode.Managed) { return new DiscoveryInnerClientManaged11(discoveryEndpoint, responseReceiver); } else { throw FxTrace.Exception.AsError(new ArgumentException(SR.DiscoveryIncorrectMode(discoveryEndpoint.DiscoveryMode))); } }