internal static bool IsConcurrent(ChannelDispatcher runtime, bool hasSession) { bool isConcurrencyModeSingle = true; if (ConcurrencyBehavior.SupportsTransactedBatch(runtime)) { return false; } foreach (EndpointDispatcher endpointDispatcher in runtime.Endpoints) { if (endpointDispatcher.DispatchRuntime.EnsureOrderedDispatch) { return false; } if (endpointDispatcher.DispatchRuntime.ConcurrencyMode != ConcurrencyMode.Single) { isConcurrencyModeSingle = false; } } if (!isConcurrencyModeSingle) { return true; } if (!hasSession) { return true; } return false; }
private static void CreateHttpGetChannelDispatcher(ServiceHostBase host, Uri listenUri, MetadataSet metadata) { //创建Binding TextMessageEncodingBindingElement messageEncodingElement = new TextMessageEncodingBindingElement() { MessageVersion = MessageVersion.None }; HttpTransportBindingElement transportElement = new HttpTransportBindingElement(); Utility.SetPropertyValue(transportElement, "Method", "GET"); Binding binding = new CustomBinding(messageEncodingElement, transportElement); //创建ChannelListener IChannelListener listener = binding.BuildChannelListener<IReplyChannel>(listenUri, string.Empty, ListenUriMode.Explicit, new BindingParameterCollection()); ChannelDispatcher dispatcher = new ChannelDispatcher(listener, "ServiceMetadataBehaviorHttpGetBinding", binding) { MessageVersion = binding.MessageVersion }; //创建EndpointDispatcher EndpointDispatcher endpoint = new EndpointDispatcher(new EndpointAddress(listenUri), "IHttpGetMetadata", "http://www.artech.com/"); //创建DispatchOperation,并设置DispatchMessageFormatter和OperationInvoker DispatchOperation operation = new DispatchOperation(endpoint.DispatchRuntime, "Get", "*", "*"); operation.Formatter = Utility.CreateInstance<IDispatchMessageFormatter>(MessageOperationFormatterType, Type.EmptyTypes, new object[0]); MethodInfo method = typeof(IHttpGetMetadata).GetMethod("Get"); operation.Invoker = Utility.CreateInstance<IOperationInvoker>(SyncMethodInvokerType, new Type[] { typeof(MethodInfo) }, new object[] { method }); endpoint.DispatchRuntime.Operations.Add(operation); //设置SingletonInstanceContext和InstanceContextProvider MetadataProvisionService serviceInstance = new MetadataProvisionService(metadata); endpoint.DispatchRuntime.SingletonInstanceContext = new InstanceContext(host, serviceInstance); endpoint.DispatchRuntime.InstanceContextProvider = Utility.CreateInstance<IInstanceContextProvider>(SingletonInstanceContextProviderType, new Type[] { typeof(DispatchRuntime) }, new object[] { endpoint.DispatchRuntime }); dispatcher.Endpoints.Add(endpoint); //设置ContractFilter和AddressFilter endpoint.ContractFilter = new MatchAllMessageFilter(); endpoint.AddressFilter = new MatchAllMessageFilter(); host.ChannelDispatchers.Add(dispatcher); }
internal ListenerHandler(IListenerBinder listenerBinder, ChannelDispatcher channelDispatcher, ServiceHostBase host, ServiceThrottle throttle, IDefaultCommunicationTimeouts timeouts) { this.listenerBinder = listenerBinder; if (!((this.listenerBinder != null))) { Fx.Assert("ListenerHandler.ctor: (this.listenerBinder != null)"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("listenerBinder"); } this.channelDispatcher = channelDispatcher; if (!((this.channelDispatcher != null))) { Fx.Assert("ListenerHandler.ctor: (this.channelDispatcher != null)"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelDispatcher"); } this.host = host; if (!((this.host != null))) { Fx.Assert("ListenerHandler.ctor: (this.host != null)"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("host"); } this.throttle = throttle; if (!((this.throttle != null))) { Fx.Assert("ListenerHandler.ctor: (this.throttle != null)"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("throttle"); } this.timeouts = timeouts; this.endpoints = channelDispatcher.EndpointDispatcherTable; this.acceptor = new ErrorHandlingAcceptor(listenerBinder, channelDispatcher); }
protected void UnregisterListenerCommon (ChannelDispatcher channel, TimeSpan timeout) { var entry = Entries.First (e => e.ChannelDispatcher == channel); Entries.Remove (entry); entry.WaitHandle.Set (); // make sure to finish pending requests. }
public HttpChannelListenerEntry (ChannelDispatcher channel, EventWaitHandle waitHandle) { ChannelDispatcher = channel; WaitHandle = waitHandle; ContextQueue = new Queue<HttpContextInfo> (); RetrieverLock = new object (); }
public bool Handle(Exception exception, ChannelDispatcher dispatcher, WCFServiceController wcfServiceController) { if (this.pendingRestart) { return false; } if (!(exception is CommunicationException)) { AcceptedErrorLimitation.Add(exception); if (AcceptedErrorLimitation.ExceedLimit()) { AutoRestartLimitation.Add(exception); if (AutoRestartLimitation.ExceedLimit()) { _logger.LogWarning("Unable solve exception with configured max-times of WCF Service restart." + string.Format( "WCF Servuce {0}, Times of Auto-Restart has exceed the max value within configued time range, waiting window service restart", wcfServiceController.ServiceName)); this.pendingRestart = true; return false; } else { AcceptedErrorLimitation.ResetCount(); return Handle(wcfServiceController); } } } return true; }
internal ErrorBehavior(ChannelDispatcher channelDispatcher) { this.handlers = EmptyArray<IErrorHandler>.ToArray(channelDispatcher.ErrorHandlers); this.debug = channelDispatcher.IncludeExceptionDetailInFaults; this.isOnServer = channelDispatcher.IsOnServer; this.messageVersion = channelDispatcher.MessageVersion; }
private void SetIsolationLevel(ChannelDispatcher channelDispatcher) { if (channelDispatcher == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelDispatcher"); } channelDispatcher.TransactionIsolationLevel = this.transactionIsolationLevel; }
protected void RegisterListenerCommon (ChannelDispatcher channel, TimeSpan timeout) { lock (entries_lock) { Entries.Add (new HttpChannelListenerEntry (channel, new AutoResetEvent (false))); Entries.Sort (HttpChannelListenerEntry.CompareEntries); } }
internal DispatchRuntime(ClientRuntime proxyRuntime, SharedRuntimeState shared) : this(shared) { ClientRuntime = proxyRuntime ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(proxyRuntime)); _instanceProvider = new CallbackInstanceProvider(); _channelDispatcher = new ChannelDispatcher(shared); _instanceContextProvider = InstanceContextProviderBase.GetProviderForMode(InstanceContextMode.PerSession, this); Fx.Assert(!shared.IsOnServer, "Client constructor called on server?"); }
public Task <object> InvokeAsync(object instance, object[] inputs, out object[] outputs) { outputs = EmptyArray <object> .Allocate(0); Message message = inputs[0] as Message; if (message == null) { return(null); } string action = message.Headers.Action; FaultCode code = FaultCode.CreateSenderFaultCode(AddressingStrings.ActionNotSupported, message.Version.Addressing.Namespace); string reasonText = SR.Format(SR.SFxNoEndpointMatchingContract, action); FaultReason reason = new FaultReason(reasonText); FaultException exception = new FaultException(reason, code); ErrorBehavior.ThrowAndCatch(exception); ServiceChannel serviceChannel = OperationContext.Current.InternalServiceChannel; OperationContext.Current.OperationCompleted += delegate(object sender, EventArgs e) { ChannelDispatcher channelDispatcher = _dispatchRuntime.ChannelDispatcher; if (!channelDispatcher.HandleError(exception) && serviceChannel.HasSession) { try { serviceChannel.Close(ChannelHandler.CloseAfterFaultTimeout); } catch (Exception ex) { if (Fx.IsFatal(ex)) { throw; } channelDispatcher.HandleError(ex); } } }; if (_dispatchRuntime._shared.EnableFaults) { MessageFault fault = MessageFault.CreateFault(code, reason, action); return(Task.FromResult((object)Message.CreateMessage(message.Version, fault, message.Version.Addressing.DefaultFaultAction))); } else { OperationContext.Current.RequestContext.Close(); OperationContext.Current.RequestContext = null; return(Task.FromResult((object)null)); } }
public ListenerLoopManager(ChannelDispatcher owner) { this.owner = owner; var sba = owner.Host != null?owner.Host.Description.Behaviors.Find <ServiceBehaviorAttribute> () : null; if (sba != null) { address_filter_mode = sba.AddressFilterMode; } }
public void ApplyDispatchBehaviorAddsTheProvider() { // TODO: Figure out how to mock up the service host with endpoint dispatchers var listenerMock = new Mock<IChannelListener>(); var channelDispatcher = new ChannelDispatcher(listenerMock.Object); var hostMock = new Mock<ServiceHostBase>(); hostMock.Object.ChannelDispatchers.Add(channelDispatcher); var provider = new WcfChannelInstanceProvider(null); provider.ApplyDispatchBehavior(null, hostMock.Object); }
private static void ApplyDispatchBehavior(ChannelDispatcher dispatcher) { // Don't add an error handler if it already exists foreach (IErrorHandler errorHandler in dispatcher.ErrorHandlers) { if (errorHandler is ExceptionConverterErrorHandler) return; } dispatcher.ErrorHandlers.Add(new ExceptionConverterErrorHandler()); }
internal void Attach(ChannelDispatcher channelDispatcher) { if (ChannelDispatcher != null) { Exception error = new InvalidOperationException(SR.SFxEndpointDispatcherMultipleChannelDispatcher0); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error); } ChannelDispatcher = channelDispatcher ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(channelDispatcher)); _listenUri = channelDispatcher.Listener.Uri; }
// This is a workaround to the fact that the id of the dispatcher and endpoint must match // for the endpoint to be exposed in the service metadata. For simply using the service, // this step is not necessary. private void AssociateEndpointToDispatcher(ServiceEndpoint endpoint, ChannelDispatcher dispatcher) { BindingFlags instanceBindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public; PropertyInfo endpointIdProperty = typeof(ServiceEndpoint).GetProperty("Id", instanceBindingFlags); PropertyInfo endpointDispatcherIdProperty = typeof(EndpointDispatcher).GetProperty("Id", instanceBindingFlags); string endpointId = endpointIdProperty.GetValue(endpoint, null) as string; foreach (EndpointDispatcher ed in dispatcher.Endpoints) { endpointDispatcherIdProperty.SetValue(ed, endpointId, null); } }
internal DispatchRuntime(ClientRuntime proxyRuntime, SharedRuntimeState shared) : this(shared) { if (proxyRuntime == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("proxyRuntime"); } _proxyRuntime = proxyRuntime; _channelDispatcher = new ChannelDispatcher(shared); Fx.Assert(!shared.IsOnServer, "Client constructor called on server?"); }
private static void ApplyDispatchBehavior(System.ServiceModel.Dispatcher.ChannelDispatcher dispatcher) { // Don't add an error handler if it already exists foreach (IErrorHandler errorHandler in dispatcher.ErrorHandlers) { if (errorHandler is CustomInspectorBehavior) { return; } } dispatcher.ErrorHandlers.Add(new CustomInspectorBehavior()); }
internal ErrorHandlingAcceptor(IListenerBinder binder, ChannelDispatcher dispatcher) { if (binder == null) { Fx.Assert("binder is null"); } if (dispatcher == null) { Fx.Assert("dispatcher is null"); } this.binder = binder; this.dispatcher = dispatcher; }
internal SharedTransactedBatchContext(ChannelHandler handler, ChannelDispatcher dispatcher, int maxConcurrentBatches) { this.handler = handler; this.maxBatchSize = dispatcher.MaxTransactedBatchSize; this.maxConcurrentBatches = maxConcurrentBatches; this.currentBatchSize = dispatcher.MaxTransactedBatchSize; this.currentConcurrentBatches = 0; this.currentConcurrentDispatches = 0; this.successfullCommits = 0; this.isBatching = true; this.isolationLevel = dispatcher.TransactionIsolationLevel; this.txTimeout = TransactionBehavior.NormalizeTimeout(dispatcher.TransactionTimeout); this.BatchingStateChanged(this.isBatching); }
internal SharedTransactedBatchContext(ChannelHandler handler, ChannelDispatcher dispatcher, int maxConcurrentBatches) { this.handler = handler; this.maxBatchSize = dispatcher.MaxTransactedBatchSize; this.maxConcurrentBatches = maxConcurrentBatches; this.currentBatchSize = dispatcher.MaxTransactedBatchSize; this.currentConcurrentBatches = 0; this.currentConcurrentDispatches = 0; this.successfullCommits = 0; this.isBatching = true; this.isolationLevel = dispatcher.TransactionIsolationLevel; this.txTimeout = TransactionBehavior.NormalizeTimeout(dispatcher.TransactionTimeout); BatchingStateChanged(this.isBatching); }
public object Invoke(object instance, object[] inputs, out object[] outputs) { FaultException exception; ServiceChannel serviceChannel; outputs = EmptyArray <object> .Allocate(0); Message message = inputs[0] as Message; if (message != null) { string action = message.Headers.Action; if (DiagnosticUtility.ShouldTraceInformation) { TraceUtility.TraceEvent(TraceEventType.Information, 0x80037, System.ServiceModel.SR.GetString("TraceCodeUnhandledAction"), new StringTraceRecord("Action", action), this, null, message); } FaultCode code = FaultCode.CreateSenderFaultCode("ActionNotSupported", message.Version.Addressing.Namespace); FaultReason reason = new FaultReason(System.ServiceModel.SR.GetString("SFxNoEndpointMatchingContract", new object[] { action })); exception = new FaultException(reason, code); System.ServiceModel.Dispatcher.ErrorBehavior.ThrowAndCatch(exception); serviceChannel = OperationContext.Current.InternalServiceChannel; OperationContext.Current.OperationCompleted += delegate(object sender, EventArgs e) { ChannelDispatcher channelDispatcher = this.dispatchRuntime.ChannelDispatcher; if (!channelDispatcher.HandleError(exception) && serviceChannel.HasSession) { try { serviceChannel.Close(ChannelHandler.CloseAfterFaultTimeout); } catch (Exception exception1) { if (Fx.IsFatal(exception1)) { throw; } channelDispatcher.HandleError(exception1); } } }; if (this.dispatchRuntime.shared.EnableFaults) { MessageFault fault = MessageFault.CreateFault(code, reason, action); return(Message.CreateMessage(message.Version, fault, message.Version.Addressing.DefaultFaultAction)); } OperationContext.Current.RequestContext.Close(); OperationContext.Current.RequestContext = null; } return(null); }
internal void Detach(ChannelDispatcher channelDispatcher) { if (channelDispatcher == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelDispatcher"); } if (_channelDispatcher != channelDispatcher) { Exception error = new InvalidOperationException(SR.SFxEndpointDispatcherDifferentChannelDispatcher0); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error); } _channelDispatcher = null; }
internal void Detach(ChannelDispatcher channelDispatcher) { if (channelDispatcher == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelDispatcher"); } if (this.channelDispatcher != channelDispatcher) { Exception error = new InvalidOperationException(SR.GetString(SR.SFxEndpointDispatcherDifferentChannelDispatcher0)); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error); } this.ReleasePerformanceCounters(); this.channelDispatcher = null; }
internal void Attach(ChannelDispatcher channelDispatcher) { if (channelDispatcher == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelDispatcher"); } if (this.channelDispatcher != null) { Exception error = new InvalidOperationException(SR.GetString(SR.SFxEndpointDispatcherMultipleChannelDispatcher0)); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error); } this.channelDispatcher = channelDispatcher; this.listenUri = channelDispatcher.Listener.Uri; }
public void ApplyDispatchBehavior_Test() { // Arrange ServiceHostBase host = new TestableServiceHostBase(); Mock<IChannelListener> listener = new Mock<IChannelListener>(); ChannelDispatcher dispatcher = new ChannelDispatcher(listener.Object); host.ChannelDispatchers.Add(dispatcher); ServiceHttpErrorBehaviorAttribute attribute = new ServiceHttpErrorBehaviorAttribute(typeof(HttpErrorHandler)); // Act attribute.ApplyDispatchBehavior(null, host); // Assert Assert.IsType<HttpErrorHandler>(dispatcher.ErrorHandlers.First()); }
internal static bool IsConcurrent(ChannelDispatcher runtime, bool hasSession) { if (!SupportsTransactedBatch(runtime)) { if (!hasSession) { return true; } foreach (EndpointDispatcher dispatcher in runtime.Endpoints) { if (dispatcher.DispatchRuntime.ConcurrencyMode != ConcurrencyMode.Single) { return true; } } } return false; }
internal static bool IsConcurrent(ChannelDispatcher runtime, bool hasSession) { if (!SupportsTransactedBatch(runtime)) { if (!hasSession) { return(true); } foreach (EndpointDispatcher dispatcher in runtime.Endpoints) { if (dispatcher.DispatchRuntime.ConcurrencyMode != ConcurrencyMode.Single) { return(true); } } } return(false); }
public void ApplyDispatchBehavior () { var se = CreateEndpoint (); var od = se.Contract.Operations [0]; // in .NET 3.5 it adds "OperationSelectorBehavior" int initCB = ContractDescription.GetContract (typeof (IMyService)).Behaviors.Count; // in .NET 3.5 it adds // - OperationInvokeBehavior, // - OperationBehaviorAttribute, // - DataContractSerializerOperationBehavior and // - DataContractSerializerOperationGenerator int initOB = od.Behaviors.Count; // Assert.AreEqual (1, initCB, "#0-1"); // Assert.AreEqual (4, initOB, "#0-2"); var b = new WebHttpBehavior (); se.Behaviors.Add (b); var ed = new EndpointDispatcher (se.Address, se.Contract.Name, se.Contract.Namespace); IChannelListener l = new WebHttpBinding ().BuildChannelListener<IReplyChannel> (new BindingParameterCollection ()); var cd = new ChannelDispatcher (l); cd.Endpoints.Add (ed); // without it this test results in NRE (it blindly adds IErrorHandler). Assert.AreEqual (0, cd.ErrorHandlers.Count, "#1-1"); Assert.IsNull (ed.DispatchRuntime.OperationSelector, "#1-2"); Assert.AreEqual (1, se.Behaviors.Count, "#1-3-1"); Assert.AreEqual (initCB, se.Contract.Behaviors.Count, "#1-3-2"); Assert.AreEqual (initOB, od.Behaviors.Count, "#1-3-3"); Assert.IsTrue (ed.AddressFilter is EndpointAddressMessageFilter, "#1-4"); b.ApplyDispatchBehavior (se, ed); // FIXME: implement and enable it later //Assert.AreEqual (1, cd.ErrorHandlers.Count, "#2-1"); Assert.AreEqual (typeof (WebHttpDispatchOperationSelector), ed.DispatchRuntime.OperationSelector.GetType (), "#2-2"); Assert.AreEqual (1, se.Behaviors.Count, "#3-1"); Assert.AreEqual (initCB, se.Contract.Behaviors.Count, "#3-2"); Assert.AreEqual (initOB, od.Behaviors.Count, "#3-3"); // ... i.e. nothing is added. Assert.IsTrue (ed.AddressFilter is PrefixEndpointAddressMessageFilter, "#3-4"); Assert.AreEqual (0, ed.DispatchRuntime.Operations.Count, "#4-0"); // hmm... really? }
internal ListenerHandler(IListenerBinder listenerBinder, ChannelDispatcher channelDispatcher, IDefaultCommunicationTimeouts timeouts) { _listenerBinder = listenerBinder; if (!((_listenerBinder != null))) { Fx.Assert("ListenerHandler.ctor: (this.listenerBinder != null)"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("listenerBinder"); } _channelDispatcher = channelDispatcher; if (!((_channelDispatcher != null))) { Fx.Assert("ListenerHandler.ctor: (this.channelDispatcher != null)"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelDispatcher"); } _timeouts = timeouts; _endpoints = channelDispatcher.EndpointDispatcherTable; }
internal ListenerHandler(IListenerBinder listenerBinder, ChannelDispatcher channelDispatcher, IDefaultCommunicationTimeouts timeouts) { _listenerBinder = listenerBinder; if (!((_listenerBinder != null))) { Fx.Assert("ListenerHandler.ctor: (this.listenerBinder != null)"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("listenerBinder"); } _channelDispatcher = channelDispatcher; if (!((_channelDispatcher != null))) { Fx.Assert("ListenerHandler.ctor: (this.channelDispatcher != null)"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelDispatcher"); } _timeouts = timeouts; _endpoints = channelDispatcher.EndpointDispatcherTable; }
private void TransferChannelFromPendingList(ref MessageRpc rpc) { if (rpc.Channel.IsPending) { rpc.Channel.IsPending = false; ChannelDispatcher channelDispatcher = rpc.Channel.ChannelDispatcher; IInstanceContextProvider provider = _instance.InstanceContextProvider; if (!InstanceContextProviderBase.IsProviderSessionful(provider) && !InstanceContextProviderBase.IsProviderSingleton(provider)) { IChannel proxy = rpc.Channel.Proxy as IChannel; if (!rpc.InstanceContext.IncomingChannels.Contains(proxy)) { channelDispatcher.Channels.Add(proxy); } } channelDispatcher.PendingChannels.Remove(rpc.Channel.Binder.Channel); } }
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ListenerHandler listener, SessionIdleManager idleManager) { ChannelDispatcher channelDispatcher = listener.ChannelDispatcher; _messageVersion = messageVersion; _isManualAddressing = channelDispatcher.ManualAddressing; _binder = binder; _listener = listener; _receiveSynchronously = channelDispatcher.ReceiveSynchronously; _sendAsynchronously = channelDispatcher.SendAsynchronously; _duplexBinder = binder as DuplexChannelBinder; _hasSession = binder.HasSession; _isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, _hasSession); if (channelDispatcher.MaxPendingReceives > 1) { throw NotImplemented.ByDesign; } if (channelDispatcher.BufferedReceiveEnabled) { _binder = new BufferedReceiveBinder(_binder); } _receiver = new ErrorHandlingReceiver(_binder, channelDispatcher); _idleManager = idleManager; Fx.Assert((_idleManager != null) == (_binder.HasSession && _listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout"); _requestInfo = new RequestInfo(this); if (_listener.State == CommunicationState.Opened) { _listener.ChannelDispatcher.Channels.IncrementActivityCount(); _incrementedActivityCountInConstructor = true; } }
private ChannelDispatcher BuildChannelDispatcher(Uri listenUri, ServiceHostBase host) { BindingParameterCollection parameters = new BindingParameterCollection(); VirtualPathExtension item = host.Extensions.Find<VirtualPathExtension>(); if (item != null) { parameters.Add(item); } IChannelListener<IReplyChannel> listener = null; WebHttpBinding binding = new WebHttpBinding(); if (binding.CanBuildChannelListener<IReplyChannel>(parameters)) { listener = binding.BuildChannelListener<IReplyChannel>(listenUri, parameters); } ChannelDispatcher channelDispatcher = new ChannelDispatcher(listener) { MessageVersion = MessageVersion.None }; return channelDispatcher; }
protected override bool ProcessRequest(MessageProcessingContext mrc) { Exception ex = mrc.ProcessingException; DispatchRuntime dispatchRuntime = mrc.OperationContext.EndpointDispatcher.DispatchRuntime; //invoke all user handlers ChannelDispatcher channelDispatcher = dispatchRuntime.ChannelDispatcher; foreach (IErrorHandler handler in channelDispatcher.ErrorHandlers) { if (handler.HandleError(ex)) { break; } } // FIXME: remove them. FaultConverter also covers errors like EndpointNotFoundException, which this handler never covers. And checking converter twice is extraneous, so this part is just extraneous. // FIXME: actually everything is done in OperationInvokerHandler now... FaultConverter fc = FaultConverter.GetDefaultFaultConverter(dispatchRuntime.ChannelDispatcher.MessageVersion); Message res = null; if (!fc.TryCreateFaultMessage(ex, out res)) { throw ex; } mrc.ReplyMessage = res; if (duplex != null) { mrc.Reply(duplex, true); } else { mrc.Reply(true); } return(false); }
void AddMetadataEndpoint(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher, bool debugMode) { Uri baseAddress = endpoint.Address.Uri; if (baseAddress == null) { return; } ServiceHostBase host = endpointDispatcher.ChannelDispatcher.Host; UriBuilder builder = new UriBuilder(baseAddress); builder.Path += builder.Path.EndsWith("/", StringComparison.OrdinalIgnoreCase) ? (WebScriptClientGenerator.GetMetadataEndpointSuffix(debugMode)) : ("/" + WebScriptClientGenerator.GetMetadataEndpointSuffix(debugMode)); EndpointAddress metadataAddress = new EndpointAddress(builder.Uri); foreach (ServiceEndpoint serviceEndpoint in host.Description.Endpoints) { if (EndpointAddress.UriEquals(serviceEndpoint.Address.Uri, metadataAddress.Uri, true, false))// ignoreCase // includeHostNameInComparison { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR2.GetString(SR2.JsonNoEndpointAtMetadataAddress, this.GetType().ToString(), serviceEndpoint.Address, serviceEndpoint.Name, host.Description.Name))); } } HttpTransportBindingElement transportBindingElement; HttpTransportBindingElement existingTransportBindingElement = endpoint.Binding.CreateBindingElements().Find<HttpTransportBindingElement>(); if (existingTransportBindingElement != null) { transportBindingElement = (HttpTransportBindingElement)existingTransportBindingElement.Clone(); } else { if (baseAddress.Scheme == "https") { transportBindingElement = new HttpsTransportBindingElement(); } else { transportBindingElement = new HttpTransportBindingElement(); } } transportBindingElement.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard; transportBindingElement.TransferMode = TransferMode.Buffered; transportBindingElement.MaxBufferSize = MaxMetadataEndpointBufferSize; transportBindingElement.MaxReceivedMessageSize = MaxMetadataEndpointBufferSize; Binding metadataBinding = new CustomBinding( new WebScriptMetadataMessageEncodingBindingElement(), transportBindingElement); BindingParameterCollection parameters = host.GetBindingParameters(endpoint); // build endpoint dispatcher ContractDescription metadataContract = ContractDescription.GetContract(typeof(ServiceMetadataExtension.IHttpGetMetadata)); OperationDescription metadataOperation = metadataContract.Operations[0]; EndpointDispatcher metadataEndpointDispatcher = new EndpointDispatcher(metadataAddress, metadataContract.Name, metadataContract.Namespace); DispatchOperation dispatchOperation = new DispatchOperation(metadataEndpointDispatcher.DispatchRuntime, metadataOperation.Name, metadataOperation.Messages[0].Action, metadataOperation.Messages[1].Action); dispatchOperation.Formatter = new WebScriptMetadataFormatter(); dispatchOperation.Invoker = new SyncMethodInvoker(metadataOperation.SyncMethod); metadataEndpointDispatcher.DispatchRuntime.Operations.Add(dispatchOperation); metadataEndpointDispatcher.DispatchRuntime.SingletonInstanceContext = new InstanceContext(host, new WebScriptClientGenerator(endpoint, debugMode, !String.IsNullOrEmpty(this.JavascriptCallbackParameterName))); metadataEndpointDispatcher.DispatchRuntime.InstanceContextProvider = new SingletonInstanceContextProvider(metadataEndpointDispatcher.DispatchRuntime); // build channel dispatcher IChannelListener<IReplyChannel> listener = null; if (metadataBinding.CanBuildChannelListener<IReplyChannel>(parameters)) { listener = metadataBinding.BuildChannelListener<IReplyChannel>(metadataAddress.Uri, parameters); } ChannelDispatcher metadataChannelDispatcher = new ChannelDispatcher(listener); metadataChannelDispatcher.MessageVersion = MessageVersion.None; metadataChannelDispatcher.Endpoints.Add(metadataEndpointDispatcher); host.ChannelDispatchers.Add(metadataChannelDispatcher); }
internal EndpointDispatcherCollection(ChannelDispatcher owner) : base(owner.ThisLock) { _owner = owner; }
internal ErrorHandlingAcceptor(IListenerBinder binder, ChannelDispatcher dispatcher) { this.binder = binder; this.dispatcher = dispatcher; }
private void ApplyDispatchBehavior(ChannelDispatcher dispatcher) { // Don't add an error handler if it already exists foreach (IErrorHandler errorHandler in dispatcher.ErrorHandlers) { if (errorHandler is ExceptionMarshallingErrorHandler) { return; } } dispatcher.ErrorHandlers.Add(new ExceptionMarshallingErrorHandler()); }
private bool HandleError(Exception e) { return(ChannelDispatcher.HandleError(e)); }
public abstract void UnregisterListener (ChannelDispatcher channel, TimeSpan timeout);
internal ErrorHandlingReceiver(IChannelBinder binder, ChannelDispatcher dispatcher) { _binder = binder; _dispatcher = dispatcher; }
private void ApplyDispatchBehavior(ChannelDispatcher dispatcher) { //Nothing here }
public EndpointDispatcherCollection(ChannelDispatcher owner) { this.owner = owner; }
void CreateWorkflowManagementEndpoint(WorkflowServiceHost workflowServiceHost) { Binding controlEndpointBinding; if (workflowServiceHost.InternalBaseAddresses.Contains(Uri.UriSchemeNetPipe)) { controlEndpointBinding = NamedPipeControlEndpointBinding; } else if (workflowServiceHost.InternalBaseAddresses.Contains(Uri.UriSchemeHttp)) { controlEndpointBinding = HttpControlEndpointBinding; } else { return; } Uri controlEndpointAddress = ServiceHost.GetVia(controlEndpointBinding.Scheme, new Uri(ControlEndpointAddress, UriKind.Relative), workflowServiceHost.InternalBaseAddresses); XmlQualifiedName contractName = new XmlQualifiedName(XD2.WorkflowInstanceManagementService.ContractName, XD2.WorkflowServices.Namespace); //Create the Endpoint Dispatcher EndpointAddress address = new EndpointAddress(controlEndpointAddress.AbsoluteUri); EndpointDispatcher endpointDispatcher = new EndpointDispatcher(address, XD2.WorkflowInstanceManagementService.ContractName, XD2.WorkflowServices.Namespace, true) { ContractFilter = new ActionMessageFilter( NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Abandon, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Cancel, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Run, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Suspend, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Terminate, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedCancel, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedRun, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedSuspend, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedTerminate, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedUnsuspend, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedUpdate, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Unsuspend, null, false), NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Update, null, false)), }; //Create Listener ServiceEndpoint endpoint = new ServiceEndpoint(WorkflowControlEndpoint.WorkflowControlServiceContract, controlEndpointBinding, address); BindingParameterCollection parameters = workflowServiceHost.GetBindingParameters(endpoint); IChannelListener listener; if (controlEndpointBinding.CanBuildChannelListener<IDuplexSessionChannel>(controlEndpointAddress, parameters)) { listener = controlEndpointBinding.BuildChannelListener<IDuplexSessionChannel>(controlEndpointAddress, parameters); } else if (controlEndpointBinding.CanBuildChannelListener<IReplySessionChannel>(controlEndpointAddress, parameters)) { listener = controlEndpointBinding.BuildChannelListener<IReplySessionChannel>(controlEndpointAddress, parameters); } else { listener = controlEndpointBinding.BuildChannelListener<IReplyChannel>(controlEndpointAddress, parameters); } //Add the operations bool formatRequest; bool formatReply; foreach (OperationDescription operation in WorkflowControlEndpoint.WorkflowControlServiceContract.Operations) { DataContractSerializerOperationBehavior dataContractSerializerOperationBehavior = new DataContractSerializerOperationBehavior(operation); DispatchOperation operationDispatcher = new DispatchOperation(endpointDispatcher.DispatchRuntime, operation.Name, NamingHelper.GetMessageAction(operation, false), NamingHelper.GetMessageAction(operation, true)) { Formatter = (IDispatchMessageFormatter)dataContractSerializerOperationBehavior.GetFormatter(operation, out formatRequest, out formatReply, false), Invoker = new ControlOperationInvoker( operation, new WorkflowControlEndpoint(controlEndpointBinding, address), null, workflowServiceHost), }; endpointDispatcher.DispatchRuntime.Operations.Add(operationDispatcher); OperationBehaviorAttribute operationAttribute = operation.Behaviors.Find<OperationBehaviorAttribute>(); ((IOperationBehavior)operationAttribute).ApplyDispatchBehavior(operation, operationDispatcher); } DispatchRuntime dispatchRuntime = endpointDispatcher.DispatchRuntime; dispatchRuntime.ConcurrencyMode = ConcurrencyMode.Multiple; dispatchRuntime.InstanceContextProvider = new DurableInstanceContextProvider(workflowServiceHost); dispatchRuntime.InstanceProvider = new DurableInstanceProvider(workflowServiceHost); dispatchRuntime.ServiceAuthorizationManager = new WindowsAuthorizationManager(this.WindowsGroup); //Create the Channel Dispatcher ServiceDebugBehavior serviceDebugBehavior = workflowServiceHost.Description.Behaviors.Find<ServiceDebugBehavior>(); ServiceBehaviorAttribute serviceBehaviorAttribute = workflowServiceHost.Description.Behaviors.Find<ServiceBehaviorAttribute>(); bool includeDebugInfo = false; if (serviceDebugBehavior != null) { includeDebugInfo |= serviceDebugBehavior.IncludeExceptionDetailInFaults; } if (serviceBehaviorAttribute != null) { includeDebugInfo |= serviceBehaviorAttribute.IncludeExceptionDetailInFaults; } ChannelDispatcher channelDispatcher = new ChannelDispatcher(listener, controlEndpointBinding.Name, controlEndpointBinding) { MessageVersion = controlEndpointBinding.MessageVersion, Endpoints = { endpointDispatcher }, ServiceThrottle = workflowServiceHost.ServiceThrottle }; workflowServiceHost.ChannelDispatchers.Add(channelDispatcher); }
public ListenerLoopManager(ChannelDispatcher owner) { this.owner = owner; }
public bool TryDequeueRequest (ChannelDispatcher channel, TimeSpan timeout, out HttpContextInfo context) { DateTime start = DateTime.Now; context = null; var ce = Entries.FirstOrDefault (e => e.ChannelDispatcher == channel); if (ce == null) return false; lock (ce.RetrieverLock) { var q = ce.ContextQueue; if (q.Count == 0) { bool ret = ce.WaitHandle.WaitOne (timeout); return ret && TryDequeueRequest (channel, timeout - (DateTime.Now - start), out context); // recurse, am lazy :/ } context = q.Dequeue (); return true; } }
// FIXME: use timeout public override void UnregisterListener (ChannelDispatcher channel, TimeSpan timeout) { UnregisterListenerCommon (channel, timeout); // stop the server if there is no more registered listener. if (Entries.Count > 0) return; #if USE_SEPARATE_LOOP loop.Abort (); #else this.listener.Stop (); #endif }
private static bool SupportsTransactedBatch(ChannelDispatcher channelDispatcher) { return(channelDispatcher.IsTransactedReceive && (channelDispatcher.MaxTransactedBatchSize > 0)); }
internal ChannelDispatcherBehaviorCollection(ChannelDispatcher outer) : base(outer.ThisLock) { _outer = outer; }
public override void RegisterListener (ChannelDispatcher channel, HttpTransportBindingElement element, TimeSpan timeout) { RegisterListenerCommon (channel, timeout); }
public void InitializeServiceHost(ServiceDescription description, ServiceHostBase serviceHost) { if (serviceHost.ImplementedContracts != null && serviceHost.ImplementedContracts.Count > 0) { EnsureThereAreApplicationEndpoints(description); } ValidateDescription(description, serviceHost); AspNetEnvironment.Current.AddHostingBehavior(serviceHost, description); ServiceBehaviorAttribute instanceSettings = description.Behaviors.Find<ServiceBehaviorAttribute>(); InitializeServicePerformanceCounters(serviceHost); Dictionary<ListenUriInfo, StuffPerListenUriInfo> stuffPerListenUriInfo = new Dictionary<ListenUriInfo, StuffPerListenUriInfo>(); Dictionary<EndpointAddress, Collection<EndpointInfo>> endpointInfosPerEndpointAddress = new Dictionary<EndpointAddress, Collection<EndpointInfo>>(); // Ensure ListenUri and group endpoints per ListenUri for (int i = 0; i < description.Endpoints.Count; i++) { //Ensure ReceiveContextSettings before building channel bool requiresReceiveContext = false; //at least one operation had ReceiveContextEnabledAttribute ServiceEndpoint endpoint = description.Endpoints[i]; foreach (OperationDescription operation in endpoint.Contract.Operations) { if (operation.Behaviors.Find<ReceiveContextEnabledAttribute>() != null) { requiresReceiveContext = true; break; } } if (requiresReceiveContext) { IReceiveContextSettings receiveContextSettings = endpoint.Binding.GetProperty<IReceiveContextSettings>(new BindingParameterCollection()); if (receiveContextSettings == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR.GetString(SR.SFxReceiveContextSettingsPropertyMissing, endpoint.Contract.Name, typeof(ReceiveContextEnabledAttribute).Name, endpoint.Address.Uri.AbsoluteUri, typeof(IReceiveContextSettings).Name))); } //Enable ReceiveContext on the binding. receiveContextSettings.Enabled = true; } ListenUriInfo listenUriInfo = GetListenUriInfoForEndpoint(serviceHost, endpoint); if (!stuffPerListenUriInfo.ContainsKey(listenUriInfo)) { stuffPerListenUriInfo.Add(listenUriInfo, new StuffPerListenUriInfo()); } stuffPerListenUriInfo[listenUriInfo].Endpoints.Add(endpoint); } foreach (KeyValuePair<ListenUriInfo, StuffPerListenUriInfo> stuff in stuffPerListenUriInfo) { Uri listenUri = stuff.Key.ListenUri; ListenUriMode listenUriMode = stuff.Key.ListenUriMode; BindingParameterCollection parameters = stuff.Value.Parameters; Binding binding = stuff.Value.Endpoints[0].Binding; EndpointIdentity identity = stuff.Value.Endpoints[0].Address.Identity; // same EndpointAddressTable instance must be shared between channelDispatcher and parameters ThreadSafeMessageFilterTable<EndpointAddress> endpointAddressTable = new ThreadSafeMessageFilterTable<EndpointAddress>(); parameters.Add(endpointAddressTable); bool supportContextSession = false; // add service-level binding parameters foreach (IServiceBehavior behavior in description.Behaviors) { if (behavior is IContextSessionProvider) { supportContextSession = true; } behavior.AddBindingParameters(description, serviceHost, stuff.Value.Endpoints, parameters); } for (int i = 0; i < stuff.Value.Endpoints.Count; i++) { ServiceEndpoint endpoint = stuff.Value.Endpoints[i]; string viaString = listenUri.AbsoluteUri; // ensure all endpoints with this ListenUriInfo have same binding if (endpoint.Binding != binding) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ABindingInstanceHasAlreadyBeenAssociatedTo1, viaString))); } // ensure all endpoints with this ListenUriInfo have same identity if (!object.Equals(endpoint.Address.Identity, identity)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException( SR.GetString(SR.SFxWhenMultipleEndpointsShareAListenUriTheyMustHaveSameIdentity, viaString))); } // add binding parameters (endpoint scope and below) AddMsmqIntegrationContractInformation(endpoint); SecurityContractInformationEndpointBehavior.ServerInstance.AddBindingParameters(endpoint, parameters); AddBindingParameters(endpoint, parameters); } // build IChannelListener and ChannelDispatcher IChannelListener listener; Type channelType = this.BuildChannelListener(stuff.Value, serviceHost, listenUri, listenUriMode, supportContextSession, out listener); XmlQualifiedName bindingQname = new XmlQualifiedName(binding.Name, binding.Namespace); ChannelDispatcher channelDispatcher = new ChannelDispatcher(listener, bindingQname.ToString(), binding); channelDispatcher.SetEndpointAddressTable(endpointAddressTable); stuff.Value.ChannelDispatcher = channelDispatcher; bool canReceiveInTransaction = false; // at least one operation is TransactionScopeRequired int transactedBatchSize = int.MaxValue; for (int i = 0; i < stuff.Value.Endpoints.Count; i++) { ServiceEndpoint endpoint = stuff.Value.Endpoints[i]; string viaString = listenUri.AbsoluteUri; EndpointFilterProvider provider = new EndpointFilterProvider(); EndpointDispatcher dispatcher = DispatcherBuilder.BuildDispatcher(serviceHost, description, endpoint, endpoint.Contract, provider); for (int j = 0; j < endpoint.Contract.Operations.Count; j++) { OperationDescription operation = endpoint.Contract.Operations[j]; OperationBehaviorAttribute operationBehavior = operation.Behaviors.Find<OperationBehaviorAttribute>(); if (null != operationBehavior && operationBehavior.TransactionScopeRequired) { canReceiveInTransaction = true; break; } } if (!endpointInfosPerEndpointAddress.ContainsKey(endpoint.Address)) { endpointInfosPerEndpointAddress.Add(endpoint.Address, new Collection<EndpointInfo>()); } endpointInfosPerEndpointAddress[endpoint.Address].Add(new EndpointInfo(endpoint, dispatcher, provider)); channelDispatcher.Endpoints.Add(dispatcher); TransactedBatchingBehavior batchBehavior = endpoint.Behaviors.Find<TransactedBatchingBehavior>(); if (batchBehavior == null) { transactedBatchSize = 0; } else { if (!canReceiveInTransaction) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MsmqBatchRequiresTransactionScope))); transactedBatchSize = System.Math.Min(transactedBatchSize, batchBehavior.MaxBatchSize); } if (PerformanceCounters.PerformanceCountersEnabled || PerformanceCounters.MinimalPerformanceCountersEnabled) { PerformanceCounters.AddPerformanceCountersForEndpoint(serviceHost, endpoint.Contract, dispatcher); } } // end foreach "endpoint" if (canReceiveInTransaction) { BindingElementCollection bindingElements = binding.CreateBindingElements(); foreach (BindingElement bindingElement in bindingElements) { ITransactedBindingElement txElement = bindingElement as ITransactedBindingElement; if (null != txElement && txElement.TransactedReceiveEnabled) { channelDispatcher.IsTransactedReceive = true; channelDispatcher.MaxTransactedBatchSize = transactedBatchSize; break; } } } //Set the mode of operation for ChannelDispatcher based on binding Settings. IReceiveContextSettings receiveContextSettings = binding.GetProperty<IReceiveContextSettings>(new BindingParameterCollection()); if (receiveContextSettings != null) { channelDispatcher.ReceiveContextEnabled = receiveContextSettings.Enabled; } serviceHost.ChannelDispatchers.Add(channelDispatcher); } // end foreach "ListenUri/ChannelDispatcher" group // run service behaviors for (int i = 0; i < description.Behaviors.Count; i++) { IServiceBehavior serviceBehavior = description.Behaviors[i]; serviceBehavior.ApplyDispatchBehavior(description, serviceHost); } foreach (KeyValuePair<ListenUriInfo, StuffPerListenUriInfo> stuff in stuffPerListenUriInfo) { for (int i = 0; i < stuff.Value.Endpoints.Count; i++) { ServiceEndpoint endpoint = stuff.Value.Endpoints[i]; // rediscover which dispatcher goes with this endpoint Collection<EndpointInfo> infos = endpointInfosPerEndpointAddress[endpoint.Address]; EndpointInfo info = null; foreach (EndpointInfo ei in infos) { if (ei.Endpoint == endpoint) { info = ei; break; } } EndpointDispatcher dispatcher = info.EndpointDispatcher; // run contract behaviors for (int k = 0; k < endpoint.Contract.Behaviors.Count; k++) { IContractBehavior behavior = endpoint.Contract.Behaviors[k]; behavior.ApplyDispatchBehavior(endpoint.Contract, endpoint, dispatcher.DispatchRuntime); } // run endpoint behaviors BindingInformationEndpointBehavior.Instance.ApplyDispatchBehavior(endpoint, dispatcher); TransactionContractInformationEndpointBehavior.Instance.ApplyDispatchBehavior(endpoint, dispatcher); for (int j = 0; j < endpoint.Behaviors.Count; j++) { IEndpointBehavior eb = endpoint.Behaviors[j]; eb.ApplyDispatchBehavior(endpoint, dispatcher); } // run operation behaviors DispatcherBuilder.BindOperations(endpoint.Contract, null, dispatcher.DispatchRuntime); } } this.EnsureRequiredRuntimeProperties(endpointInfosPerEndpointAddress); // Warn about obvious demux conflicts foreach (Collection<EndpointInfo> endpointInfos in endpointInfosPerEndpointAddress.Values) { // all elements of endpointInfos share the same Address (and thus EndpointListener.AddressFilter) if (endpointInfos.Count > 1) { for (int i = 0; i < endpointInfos.Count; i++) { for (int j = i + 1; j < endpointInfos.Count; j++) { // if not same ListenUri, won't conflict // if not same ChannelType, may not conflict (some transports demux based on this) // if they share a ChannelDispatcher, this means same ListenUri and same ChannelType if (endpointInfos[i].EndpointDispatcher.ChannelDispatcher == endpointInfos[j].EndpointDispatcher.ChannelDispatcher) { EndpointFilterProvider iProvider = endpointInfos[i].FilterProvider; EndpointFilterProvider jProvider = endpointInfos[j].FilterProvider; // if not default EndpointFilterProvider, we won't try to throw, you're on your own string commonAction; if (iProvider != null && jProvider != null && HaveCommonInitiatingActions(iProvider, jProvider, out commonAction)) { // you will definitely get a MultipleFiltersMatchedException at runtime, // so let's go ahead and throw now throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR.GetString(SR.SFxDuplicateInitiatingActionAtSameVia, endpointInfos[i].Endpoint.ListenUri, commonAction))); } } } } } } }
public override void UnregisterListener (ChannelDispatcher channel, TimeSpan timeout) { UnregisterListenerCommon (channel, timeout); }
// FIXME: use timeout public override void RegisterListener (ChannelDispatcher channel, HttpTransportBindingElement element, TimeSpan timeout) { RegisterListenerCommon (channel, timeout); if (Entries.Count != 1) return; if (element != null) { var l = listener; l.AuthenticationSchemeSelectorDelegate = delegate (HttpListenerRequest req) { return element.AuthenticationScheme; }; l.Realm = element.Realm; l.UnsafeConnectionNtlmAuthentication = element.UnsafeConnectionNtlmAuthentication; } // Start here. It is shared between channel listeners // that share the same listen Uri. So there is no other appropriate place. #if USE_SEPARATE_LOOP // this cannot be enabled because it causes infinite loop when ChannelDispatcher is not involved. loop = new Thread (new ThreadStart (delegate { listener.Start (); try { while (true) ProcessNewContext (listener.GetContext ()); } catch (ThreadAbortException) { Thread.ResetAbort (); } listener.Stop (); })); loop.Start (); #else listener.Start (); listener.BeginGetContext (GetContextCompleted, null); #endif }
public abstract void RegisterListener (ChannelDispatcher channel, HttpTransportBindingElement element, TimeSpan timeout);