mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
485 lines
20 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|
|
}
|