Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

485 lines
20 KiB
C#

//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------
namespace System.ServiceModel.Routing
{
using System;
using System.Collections.Generic;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.Transactions;
using System.Runtime.Diagnostics;
using System.ServiceModel.Diagnostics;
static class ClientFactory
{
public static IRoutingClient Create(RoutingEndpointTrait endpointTrait, RoutingService service, bool impersonating)
{
Type contractType = endpointTrait.RouterContract;
IRoutingClient client;
if (contractType == typeof(ISimplexDatagramRouter))
{
client = new SimplexDatagramClient(endpointTrait, service.RoutingConfig, impersonating);
}
else if (contractType == typeof(IRequestReplyRouter))
{
client = new RequestReplyClient(endpointTrait, service.RoutingConfig, impersonating);
}
else if (contractType == typeof(ISimplexSessionRouter))
{
client = new SimplexSessionClient(endpointTrait, service.RoutingConfig, impersonating);
}
else //if (contractType == typeof(IDuplexSessionRouter))
{
Fx.Assert(contractType == typeof(IDuplexSessionRouter), "Only one contract type remaining.");
client = new DuplexSessionClient(service, endpointTrait, impersonating);
}
return client;
}
abstract class RoutingClientBase<TChannel> : ClientBase<TChannel>, IRoutingClient
where TChannel : class
{
bool openCompleted;
object thisLock;
Queue<OperationAsyncResult> waiters;
protected RoutingClientBase(RoutingEndpointTrait endpointTrait, RoutingConfiguration routingConfig, bool impersonating)
: base(endpointTrait.Endpoint.Binding, endpointTrait.Endpoint.Address)
{
Initialize(endpointTrait, routingConfig, impersonating);
}
protected RoutingClientBase(RoutingEndpointTrait endpointTrait, RoutingConfiguration routingConfig, object callbackInstance, bool impersonating)
: base(new InstanceContext(callbackInstance), endpointTrait.Endpoint.Binding, endpointTrait.Endpoint.Address)
{
Initialize(endpointTrait, routingConfig, impersonating);
}
public RoutingEndpointTrait Key
{
get;
private set;
}
public event EventHandler Faulted;
static void ConfigureImpersonation(ServiceEndpoint endpoint, bool impersonating)
{
// Used for both impersonation and ASP.NET Compatibilty Mode. Both currently require
// everything to be synchronous.
if (impersonating)
{
CustomBinding binding = endpoint.Binding as CustomBinding;
if (binding == null)
{
binding = new CustomBinding(endpoint.Binding);
}
SynchronousSendBindingElement syncSend = binding.Elements.Find<SynchronousSendBindingElement>();
if (syncSend == null)
{
binding.Elements.Insert(0, new SynchronousSendBindingElement());
endpoint.Binding = binding;
}
}
}
static void ConfigureTransactionFlow(ServiceEndpoint endpoint)
{
CustomBinding binding = endpoint.Binding as CustomBinding;
if (binding == null)
{
binding = new CustomBinding(endpoint.Binding);
}
TransactionFlowBindingElement transactionFlow = binding.Elements.Find<TransactionFlowBindingElement>();
if (transactionFlow != null)
{
transactionFlow.AllowWildcardAction = true;
endpoint.Binding = binding;
}
}
void Initialize(RoutingEndpointTrait endpointTrait, RoutingConfiguration routingConfig, bool impersonating)
{
this.thisLock = new object();
this.Key = endpointTrait;
if (TD.RoutingServiceCreatingClientForEndpointIsEnabled())
{
TD.RoutingServiceCreatingClientForEndpoint(this.Key.ToString());
}
ServiceEndpoint clientEndpoint = endpointTrait.Endpoint;
ServiceEndpoint endpoint = this.Endpoint;
KeyedByTypeCollection<IEndpointBehavior> behaviors = endpoint.Behaviors;
endpoint.ListenUri = clientEndpoint.ListenUri;
endpoint.ListenUriMode = clientEndpoint.ListenUriMode;
endpoint.Name = clientEndpoint.Name;
foreach (IEndpointBehavior behavior in clientEndpoint.Behaviors)
{
// Remove if present, ok to call if not there (will simply return false)
behaviors.Remove(behavior.GetType());
behaviors.Add(behavior);
}
// If the configuration doesn't explicitly add MustUnderstandBehavior (to override us)
// add it here, with mustunderstand = false.
if (behaviors.Find<MustUnderstandBehavior>() == null)
{
behaviors.Add(new MustUnderstandBehavior(false));
}
// If the configuration doesn't explicitly turn off marshaling we add it here.
if (routingConfig.SoapProcessingEnabled && behaviors.Find<SoapProcessingBehavior>() == null)
{
behaviors.Add(new SoapProcessingBehavior());
}
ConfigureTransactionFlow(endpoint);
ConfigureImpersonation(endpoint, impersonating);
}
protected override TChannel CreateChannel()
{
TChannel channel = base.CreateChannel();
((ICommunicationObject)channel).Faulted += this.InnerChannelFaulted;
return channel;
}
public IAsyncResult BeginOperation(Message message, Transaction transaction, AsyncCallback callback, object state)
{
return new OperationAsyncResult(this, message, transaction, callback, state);
}
public Message EndOperation(IAsyncResult result)
{
return OperationAsyncResult.End(result);
}
protected abstract IAsyncResult OnBeginOperation(Message message, AsyncCallback callback, object state);
protected abstract Message OnEndOperation(IAsyncResult asyncResult);
void InnerChannelFaulted(object sender, EventArgs args)
{
EventHandler handlers = this.Faulted;
if (handlers != null)
{
handlers(this, args);
}
}
class OperationAsyncResult : TransactedAsyncResult
{
static AsyncCompletion openComplete = OpenComplete;
static AsyncCompletion operationComplete = OperationComplete;
static Action<object> signalWaiter;
RoutingClientBase<TChannel> parent;
Message replyMessage;
Message requestMessage;
Transaction transaction;
public OperationAsyncResult(RoutingClientBase<TChannel> parent, Message requestMessage, Transaction transaction, AsyncCallback callback, object state)
: base(callback, state)
{
this.parent = parent;
this.requestMessage = requestMessage;
this.transaction = transaction;
bool shouldOpen = false;
if (!this.parent.openCompleted)
{
lock (this.parent.thisLock)
{
if (!this.parent.openCompleted)
{
//The first to open initializes the waiters queue others add themselves to it.
if (this.parent.waiters == null)
{
//it's our job to open the proxy
this.parent.waiters = new Queue<OperationAsyncResult>();
shouldOpen = true;
}
else
{
//Someone beat us to it, just join the list of waiters.
this.parent.waiters.Enqueue(this);
return;
}
}
}
}
if (shouldOpen)
{
//we are the first so we need to open this channel
IAsyncResult asyncResult;
using (this.PrepareTransactionalCall(this.transaction))
{
//This will use the binding's OpenTimeout.
asyncResult = ((ICommunicationObject)this.parent).BeginOpen(this.PrepareAsyncCompletion(openComplete), this);
}
if (this.SyncContinue(asyncResult))
{
this.Complete(true);
}
}
else
{
if (this.CallOperation())
{
this.Complete(true);
}
}
}
public static Message End(IAsyncResult result)
{
OperationAsyncResult thisPtr = AsyncResult.End<OperationAsyncResult>(result);
return thisPtr.replyMessage;
}
static bool OpenComplete(IAsyncResult openResult)
{
OperationAsyncResult thisPtr = (OperationAsyncResult)openResult.AsyncState;
try
{
((ICommunicationObject)thisPtr.parent).EndOpen(openResult);
}
finally
{
Queue<OperationAsyncResult> localWaiters = null;
lock (thisPtr.parent.thisLock)
{
localWaiters = thisPtr.parent.waiters;
thisPtr.parent.waiters = null;
thisPtr.parent.openCompleted = true;
}
if (localWaiters != null && localWaiters.Count > 0)
{
if (signalWaiter == null)
{
signalWaiter = new Action<object>(SignalWaiter);
}
//foreach over Queue<T> goes FIFO
foreach (OperationAsyncResult waiter in localWaiters)
{
ActionItem.Schedule(signalWaiter, waiter);
}
}
}
return thisPtr.CallOperation();
}
bool CallOperation()
{
IAsyncResult asyncResult;
using (this.PrepareTransactionalCall(this.transaction))
{
asyncResult = this.parent.OnBeginOperation(this.requestMessage, this.PrepareAsyncCompletion(operationComplete), this);
}
return this.SyncContinue(asyncResult);
}
static bool OperationComplete(IAsyncResult result)
{
OperationAsyncResult thisPtr = (OperationAsyncResult)result.AsyncState;
thisPtr.replyMessage = thisPtr.parent.OnEndOperation(result);
return true;
}
static void SignalWaiter(object state)
{
OperationAsyncResult waiter = (OperationAsyncResult)state;
try
{
if (waiter.CallOperation())
{
waiter.Complete(false);
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
waiter.Complete(false, exception);
}
}
}
}
class SimplexDatagramClient : RoutingClientBase<ISimplexDatagramRouter>
{
public SimplexDatagramClient(RoutingEndpointTrait endpointTrait, RoutingConfiguration routingConfig, bool impersonating)
: base(endpointTrait, routingConfig, impersonating)
{
}
protected override IAsyncResult OnBeginOperation(Message message, AsyncCallback callback, object state)
{
return this.Channel.BeginProcessMessage(message, callback, state);
}
protected override Message OnEndOperation(IAsyncResult result)
{
this.Channel.EndProcessMessage(result);
return null;
}
}
class SimplexSessionClient : RoutingClientBase<ISimplexSessionRouter>
{
public SimplexSessionClient(RoutingEndpointTrait endointTrait, RoutingConfiguration routingConfig, bool impersonating)
: base(endointTrait, routingConfig, impersonating)
{
}
protected override IAsyncResult OnBeginOperation(Message message, AsyncCallback callback, object state)
{
return this.Channel.BeginProcessMessage(message, callback, state);
}
protected override Message OnEndOperation(IAsyncResult result)
{
this.Channel.EndProcessMessage(result);
return null;
}
}
class DuplexSessionClient : RoutingClientBase<IDuplexSessionRouter>
{
public DuplexSessionClient(RoutingService service, RoutingEndpointTrait endpointTrait, bool impersonating)
: base(endpointTrait, service.RoutingConfig, new DuplexCallbackProxy(service.ChannelExtension.ActivityID, endpointTrait.CallbackInstance), impersonating)
{
}
protected override IAsyncResult OnBeginOperation(Message message, AsyncCallback callback, object state)
{
return this.Channel.BeginProcessMessage(message, callback, state);
}
protected override Message OnEndOperation(IAsyncResult result)
{
this.Channel.EndProcessMessage(result);
return null;
}
class DuplexCallbackProxy : IDuplexRouterCallback
{
Guid activityID;
IDuplexRouterCallback callbackInstance;
EventTraceActivity eventTraceActivity;
public DuplexCallbackProxy(Guid activityID, IDuplexRouterCallback callbackInstance)
{
this.activityID = activityID;
this.callbackInstance = callbackInstance;
if (Fx.Trace.IsEtwProviderEnabled)
{
this.eventTraceActivity = new EventTraceActivity(activityID);
}
}
IAsyncResult IDuplexRouterCallback.BeginProcessMessage(Message message, AsyncCallback callback, object state)
{
FxTrace.Trace.SetAndTraceTransfer(this.activityID, true);
try
{
return new CallbackAsyncResult(this.callbackInstance, message, callback, state);
}
catch (Exception e)
{
if (TD.RoutingServiceDuplexCallbackExceptionIsEnabled())
{
TD.RoutingServiceDuplexCallbackException(this.eventTraceActivity, "DuplexCallbackProxy.BeginProcessMessage", e);
}
throw;
}
}
void IDuplexRouterCallback.EndProcessMessage(IAsyncResult result)
{
FxTrace.Trace.SetAndTraceTransfer(this.activityID, true);
try
{
CallbackAsyncResult.End(result);
}
catch (Exception e)
{
if (TD.RoutingServiceDuplexCallbackExceptionIsEnabled())
{
TD.RoutingServiceDuplexCallbackException(this.eventTraceActivity, "DuplexCallbackProxy.EndProcessMessage", e);
}
throw;
}
}
// We have to have an AsyncResult implementation here in order to handle the
// TransactionScope appropriately (use PrepareTransactionalCall, SyncContinue, etc...)
class CallbackAsyncResult : TransactedAsyncResult
{
static AsyncCompletion processCallback = ProcessCallback;
IDuplexRouterCallback callbackInstance;
public CallbackAsyncResult(IDuplexRouterCallback callbackInstance, Message message, AsyncCallback callback, object state)
: base(callback, state)
{
this.callbackInstance = callbackInstance;
IAsyncResult result;
using (this.PrepareTransactionalCall(TransactionMessageProperty.TryGetTransaction(message)))
{
result = this.callbackInstance.BeginProcessMessage(message,
this.PrepareAsyncCompletion(processCallback), this);
}
if (this.SyncContinue(result))
{
this.Complete(true);
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End<CallbackAsyncResult>(result);
}
static bool ProcessCallback(IAsyncResult result)
{
CallbackAsyncResult thisPtr = (CallbackAsyncResult)result.AsyncState;
thisPtr.callbackInstance.EndProcessMessage(result);
return true;
}
}
}
}
class RequestReplyClient : RoutingClientBase<IRequestReplyRouter>
{
public RequestReplyClient(RoutingEndpointTrait endpointTrait, RoutingConfiguration routingConfig, bool impersonating)
: base(endpointTrait, routingConfig, impersonating)
{
}
protected override IAsyncResult OnBeginOperation(Message message, AsyncCallback callback, object state)
{
return this.Channel.BeginProcessRequest(message, callback, state);
}
protected override Message OnEndOperation(IAsyncResult result)
{
return this.Channel.EndProcessRequest(result);
}
}
}
}