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

860 lines
29 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{
using System;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.Diagnostics;
using System.Security;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Channels;
using System.ServiceModel.Diagnostics;
using System.Threading;
using System.Xml;
using System.Transactions;
using System.ServiceModel.Diagnostics.Application;
delegate void MessageRpcProcessor(ref MessageRpc rpc);
struct MessageRpc
{
internal readonly ServiceChannel Channel;
internal readonly ChannelHandler channelHandler;
internal readonly object[] Correlation;
internal readonly ServiceHostBase Host;
internal readonly OperationContext OperationContext;
internal ServiceModelActivity Activity;
internal Guid ResponseActivityId;
internal IAsyncResult AsyncResult;
internal bool CanSendReply;
internal bool SuccessfullySendReply;
internal CorrelationCallbackMessageProperty CorrelationCallback;
internal object[] InputParameters;
internal object[] OutputParameters;
internal object ReturnParameter;
internal bool ParametersDisposed;
internal bool DidDeserializeRequestBody;
internal TransactionMessageProperty TransactionMessageProperty;
internal TransactedBatchContext TransactedBatchContext;
internal Exception Error;
internal MessageRpcProcessor ErrorProcessor;
internal ErrorHandlerFaultInfo FaultInfo;
internal bool HasSecurityContext;
internal object Instance;
internal bool MessageRpcOwnsInstanceContextThrottle;
internal MessageRpcProcessor NextProcessor;
internal Collection<MessageHeaderInfo> NotUnderstoodHeaders;
internal DispatchOperationRuntime Operation;
internal Message Request;
internal RequestContext RequestContext;
internal bool RequestContextThrewOnReply;
internal UniqueId RequestID;
internal Message Reply;
internal TimeoutHelper ReplyTimeoutHelper;
internal RequestReplyCorrelator.ReplyToInfo ReplyToInfo;
internal MessageVersion RequestVersion;
internal ServiceSecurityContext SecurityContext;
internal InstanceContext InstanceContext;
internal bool SuccessfullyBoundInstance;
internal bool SuccessfullyIncrementedActivity;
internal bool SuccessfullyLockedInstance;
internal ReceiveContextRPCFacet ReceiveContext;
internal TransactionRpcFacet transaction;
internal IAspNetMessageProperty HostingProperty;
internal MessageRpcInvokeNotification InvokeNotification;
internal EventTraceActivity EventTraceActivity;
static AsyncCallback handleEndComplete = Fx.ThunkCallback(new AsyncCallback(HandleEndComplete));
static AsyncCallback handleEndAbandon = Fx.ThunkCallback(new AsyncCallback(HandleEndAbandon));
bool paused;
bool switchedThreads;
bool isInstanceContextSingleton;
SignalGate<IAsyncResult> invokeContinueGate;
internal MessageRpc(RequestContext requestContext, Message request, DispatchOperationRuntime operation,
ServiceChannel channel, ServiceHostBase host, ChannelHandler channelHandler, bool cleanThread,
OperationContext operationContext, InstanceContext instanceContext, EventTraceActivity eventTraceActivity)
{
Fx.Assert((operationContext != null), "System.ServiceModel.Dispatcher.MessageRpc.MessageRpc(), operationContext == null");
Fx.Assert(channelHandler != null, "System.ServiceModel.Dispatcher.MessageRpc.MessageRpc(), channelHandler == null");
this.Activity = null;
this.EventTraceActivity = eventTraceActivity;
this.AsyncResult = null;
this.CanSendReply = true;
this.Channel = channel;
this.channelHandler = channelHandler;
this.Correlation = EmptyArray.Allocate(operation.Parent.CorrelationCount);
this.CorrelationCallback = null;
this.DidDeserializeRequestBody = false;
this.TransactionMessageProperty = null;
this.TransactedBatchContext = null;
this.Error = null;
this.ErrorProcessor = null;
this.FaultInfo = new ErrorHandlerFaultInfo(request.Version.Addressing.DefaultFaultAction);
this.HasSecurityContext = false;
this.Host = host;
this.Instance = null;
this.MessageRpcOwnsInstanceContextThrottle = false;
this.NextProcessor = null;
this.NotUnderstoodHeaders = null;
this.Operation = operation;
this.OperationContext = operationContext;
this.paused = false;
this.ParametersDisposed = false;
this.ReceiveContext = null;
this.Request = request;
this.RequestContext = requestContext;
this.RequestContextThrewOnReply = false;
this.SuccessfullySendReply = false;
this.RequestVersion = request.Version;
this.Reply = null;
this.ReplyTimeoutHelper = new TimeoutHelper();
this.SecurityContext = null;
this.InstanceContext = instanceContext;
this.SuccessfullyBoundInstance = false;
this.SuccessfullyIncrementedActivity = false;
this.SuccessfullyLockedInstance = false;
this.switchedThreads = !cleanThread;
this.transaction = null;
this.InputParameters = null;
this.OutputParameters = null;
this.ReturnParameter = null;
this.isInstanceContextSingleton = InstanceContextProviderBase.IsProviderSingleton(this.Channel.DispatchRuntime.InstanceContextProvider);
this.invokeContinueGate = null;
if (!operation.IsOneWay && !operation.Parent.ManualAddressing)
{
this.RequestID = request.Headers.MessageId;
this.ReplyToInfo = new RequestReplyCorrelator.ReplyToInfo(request);
}
else
{
this.RequestID = null;
this.ReplyToInfo = new RequestReplyCorrelator.ReplyToInfo();
}
this.HostingProperty = AspNetEnvironment.Current.GetHostingProperty(request, true);
if (DiagnosticUtility.ShouldUseActivity)
{
this.Activity = TraceUtility.ExtractActivity(this.Request);
}
if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
{
this.ResponseActivityId = ActivityIdHeader.ExtractActivityId(this.Request);
}
else
{
this.ResponseActivityId = Guid.Empty;
}
this.InvokeNotification = new MessageRpcInvokeNotification(this.Activity, this.channelHandler);
if (this.EventTraceActivity == null && FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
{
if (this.Request != null)
{
this.EventTraceActivity = EventTraceActivityHelper.TryExtractActivity(this.Request, true);
}
}
}
internal bool FinalizeCorrelationImplicitly
{
get { return this.CorrelationCallback != null && this.CorrelationCallback.IsFullyDefined; }
}
internal bool IsPaused
{
get { return this.paused; }
}
internal bool SwitchedThreads
{
get { return this.switchedThreads; }
}
internal bool IsInstanceContextSingleton
{
set
{
this.isInstanceContextSingleton = value;
}
}
internal TransactionRpcFacet Transaction
{
get
{
if (this.transaction == null)
{
this.transaction = new TransactionRpcFacet(ref this);
}
return this.transaction;
}
}
internal void Abort()
{
this.AbortRequestContext();
this.AbortChannel();
this.AbortInstanceContext();
}
void AbortRequestContext(RequestContext requestContext)
{
try
{
requestContext.Abort();
ReceiveContextRPCFacet receiveContext = this.ReceiveContext;
if (receiveContext != null)
{
this.ReceiveContext = null;
IAsyncResult result = receiveContext.BeginAbandon(
TimeSpan.MaxValue,
handleEndAbandon,
new CallbackState
{
ReceiveContext = receiveContext,
ChannelHandler = this.channelHandler
});
if (result.CompletedSynchronously)
{
receiveContext.EndAbandon(result);
}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.channelHandler.HandleError(e);
}
}
internal void AbortRequestContext()
{
if (this.OperationContext.RequestContext != null)
{
this.AbortRequestContext(this.OperationContext.RequestContext);
}
if ((this.RequestContext != null) && (this.RequestContext != this.OperationContext.RequestContext))
{
this.AbortRequestContext(this.RequestContext);
}
TraceCallDurationInDispatcherIfNecessary(false);
}
void TraceCallDurationInDispatcherIfNecessary(bool requestContextWasClosedSuccessfully)
{
// only need to trace once (either for the failure or success case)
if (TD.DispatchFailedIsEnabled())
{
if (requestContextWasClosedSuccessfully)
{
TD.DispatchSuccessful(this.EventTraceActivity, this.Operation.Name);
}
else
{
TD.DispatchFailed(this.EventTraceActivity, this.Operation.Name);
}
}
}
internal void CloseRequestContext()
{
if (this.OperationContext.RequestContext != null)
{
this.DisposeRequestContext(this.OperationContext.RequestContext);
}
if ((this.RequestContext != null) && (this.RequestContext != this.OperationContext.RequestContext))
{
this.DisposeRequestContext(this.RequestContext);
}
TraceCallDurationInDispatcherIfNecessary(true);
}
void DisposeRequestContext(RequestContext context)
{
try
{
context.Close();
ReceiveContextRPCFacet receiveContext = this.ReceiveContext;
if (receiveContext != null)
{
this.ReceiveContext = null;
IAsyncResult result = receiveContext.BeginComplete(
TimeSpan.MaxValue,
null,
this.channelHandler,
handleEndComplete,
new CallbackState
{
ChannelHandler = this.channelHandler,
ReceiveContext = receiveContext
});
if (result.CompletedSynchronously)
{
receiveContext.EndComplete(result);
}
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.AbortRequestContext(context);
this.channelHandler.HandleError(e);
}
}
static void HandleEndAbandon(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
CallbackState callbackState = (CallbackState)result.AsyncState;
try
{
callbackState.ReceiveContext.EndAbandon(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
callbackState.ChannelHandler.HandleError(e);
}
}
static void HandleEndComplete(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
CallbackState callbackState = (CallbackState)result.AsyncState;
try
{
callbackState.ReceiveContext.EndComplete(result);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
callbackState.ChannelHandler.HandleError(e);
}
}
internal void AbortChannel()
{
if ((this.Channel != null) && this.Channel.HasSession)
{
try
{
this.Channel.Abort();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.channelHandler.HandleError(e);
}
}
}
internal void CloseChannel()
{
if ((this.Channel != null) && this.Channel.HasSession)
{
try
{
this.Channel.Close(ChannelHandler.CloseAfterFaultTimeout);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.channelHandler.HandleError(e);
}
}
}
internal void AbortInstanceContext()
{
if (this.InstanceContext != null && !this.isInstanceContextSingleton)
{
try
{
this.InstanceContext.Abort();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.channelHandler.HandleError(e);
}
}
}
internal void EnsureReceive()
{
using (ServiceModelActivity.BoundOperation(this.Activity))
{
ChannelHandler.Register(this.channelHandler);
}
}
bool ProcessError(Exception e)
{
MessageRpcProcessor handler = this.ErrorProcessor;
try
{
Type exceptionType = e.GetType();
if (exceptionType.IsAssignableFrom(typeof(FaultException)))
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
else
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Error);
}
if (TraceUtility.MessageFlowTracingOnly)
{
TraceUtility.SetActivityId(this.Request.Properties);
if (Guid.Empty == DiagnosticTraceBase.ActivityId)
{
Guid receivedActivityId = TraceUtility.ExtractActivityId(this.Request);
if (Guid.Empty != receivedActivityId)
{
DiagnosticTraceBase.ActivityId = receivedActivityId;
}
}
}
this.Error = e;
if (this.ErrorProcessor != null)
{
this.ErrorProcessor(ref this);
}
return (this.Error == null);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e2)
{
if (Fx.IsFatal(e2))
{
throw;
}
return ((handler != this.ErrorProcessor) && this.ProcessError(e2));
}
}
internal void DisposeParameters(bool excludeInput)
{
if (this.Operation.DisposeParameters)
{
this.DisposeParametersCore(excludeInput);
}
}
internal void DisposeParametersCore(bool excludeInput)
{
if (!this.ParametersDisposed)
{
if (!excludeInput)
{
this.DisposeParameterList(this.InputParameters);
}
this.DisposeParameterList(this.OutputParameters);
IDisposable disposableParameter = this.ReturnParameter as IDisposable;
if (disposableParameter != null)
{
try
{
disposableParameter.Dispose();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.channelHandler.HandleError(e);
}
}
this.ParametersDisposed = true;
}
}
void DisposeParameterList(object[] parameters)
{
IDisposable disposableParameter = null;
if (parameters != null)
{
foreach (Object obj in parameters)
{
disposableParameter = obj as IDisposable;
if (disposableParameter != null)
{
try
{
disposableParameter.Dispose();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.channelHandler.HandleError(e);
}
}
}
}
}
// See notes on UnPause and Resume (mutually exclusive)
// Pausing will Increment the BusyCount for the hosting environment
internal IResumeMessageRpc Pause()
{
Wrapper wrapper = new Wrapper(ref this);
this.paused = true;
return wrapper;
}
[Fx.Tag.SecurityNote(Critical = "Calls SecurityCritical method ApplyHostingIntegrationContextNoInline. Caller must ensure that"
+ "function is called appropriately and result is guarded and Dispose()'d correctly.")]
[SecurityCritical]
IDisposable ApplyHostingIntegrationContext()
{
if (this.HostingProperty != null)
{
return this.ApplyHostingIntegrationContextNoInline();
}
else
{
return null;
}
}
[Fx.Tag.SecurityNote(Critical = "Calls SecurityCritical method HostingMessageProperty.ApplyIntegrationContext. Caller must ensure that"
+ "function is called appropriately and result is guarded and Dispose()'d correctly.")]
[SecurityCritical]
[MethodImpl(MethodImplOptions.NoInlining)]
IDisposable ApplyHostingIntegrationContextNoInline()
{
return this.HostingProperty.ApplyIntegrationContext();
}
[Fx.Tag.SecurityNote(Critical = "Calls SecurityCritical method ApplyHostingIntegrationContext.",
Safe = "Does call properly and calls Dispose, doesn't leak control of the IDisposable out of the function.")]
[SecuritySafeCritical]
internal bool Process(bool isOperationContextSet)
{
using (ServiceModelActivity.BoundOperation(this.Activity))
{
bool completed = true;
if (this.NextProcessor != null)
{
MessageRpcProcessor processor = this.NextProcessor;
this.NextProcessor = null;
OperationContext originalContext;
OperationContext.Holder contextHolder;
if (!isOperationContextSet)
{
contextHolder = OperationContext.CurrentHolder;
originalContext = contextHolder.Context;
}
else
{
contextHolder = null;
originalContext = null;
}
IncrementBusyCount();
IDisposable hostedIntegrationContext = this.ApplyHostingIntegrationContext();
try
{
if (!isOperationContextSet)
{
contextHolder.Context = this.OperationContext;
}
processor(ref this);
if (!this.paused)
{
this.OperationContext.SetClientReply(null, false);
}
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (!this.ProcessError(e) && this.FaultInfo.Fault == null)
{
this.Abort();
}
}
finally
{
try
{
DecrementBusyCount();
if (hostedIntegrationContext != null)
{
hostedIntegrationContext.Dispose();
}
if (!isOperationContextSet)
{
contextHolder.Context = originalContext;
}
completed = !this.paused;
if (completed)
{
this.channelHandler.DispatchDone();
this.OperationContext.ClearClientReplyNoThrow();
}
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(e.Message, e);
}
}
}
return completed;
}
}
// UnPause is called on the original MessageRpc to continue work on the current thread, and the copy is ignored.
// Since the copy is ignored, Decrement the BusyCount
internal void UnPause()
{
this.paused = false;
DecrementBusyCount();
}
internal bool UnlockInvokeContinueGate(out IAsyncResult result)
{
return this.invokeContinueGate.Unlock(out result);
}
internal void PrepareInvokeContinueGate()
{
this.invokeContinueGate = new SignalGate<IAsyncResult>();
}
void IncrementBusyCount()
{
// Only increment the counter on the service side.
if (this.Host != null)
{
this.Host.IncrementBusyCount();
if (AspNetEnvironment.Current.TraceIncrementBusyCountIsEnabled())
{
AspNetEnvironment.Current.TraceIncrementBusyCount(SR.GetString(SR.ServiceBusyCountTrace, this.Operation.Action));
}
}
}
void DecrementBusyCount()
{
if (this.Host != null)
{
this.Host.DecrementBusyCount();
if (AspNetEnvironment.Current.TraceDecrementBusyCountIsEnabled())
{
AspNetEnvironment.Current.TraceDecrementBusyCount(SR.GetString(SR.ServiceBusyCountTrace, this.Operation.Action));
}
}
}
class CallbackState
{
public ReceiveContextRPCFacet ReceiveContext
{
get;
set;
}
public ChannelHandler ChannelHandler
{
get;
set;
}
}
class Wrapper : IResumeMessageRpc
{
MessageRpc rpc;
bool alreadyResumed;
internal Wrapper(ref MessageRpc rpc)
{
this.rpc = rpc;
if (rpc.NextProcessor == null)
{
Fx.Assert("MessageRpc.Wrapper.Wrapper: (rpc.NextProcessor != null)");
}
this.rpc.IncrementBusyCount();
}
public InstanceContext GetMessageInstanceContext()
{
return this.rpc.InstanceContext;
}
// Resume is called on the copy on some completing thread, whereupon work continues on that thread.
// BusyCount is Decremented as the copy is now complete
public void Resume(out bool alreadyResumedNoLock)
{
try
{
alreadyResumedNoLock = this.alreadyResumed;
this.alreadyResumed = true;
this.rpc.switchedThreads = true;
if (this.rpc.Process(false) && !rpc.InvokeNotification.DidInvokerEnsurePump)
{
this.rpc.EnsureReceive();
}
}
finally
{
this.rpc.DecrementBusyCount();
}
}
public void Resume(IAsyncResult result)
{
this.rpc.AsyncResult = result;
this.Resume();
}
public void Resume(object instance)
{
this.rpc.Instance = instance;
this.Resume();
}
public void Resume()
{
using (ServiceModelActivity.BoundOperation(this.rpc.Activity, true))
{
bool alreadyResumedNoLock;
this.Resume(out alreadyResumedNoLock);
if (alreadyResumedNoLock)
{
string text = SR.GetString(SR.SFxMultipleCallbackFromAsyncOperation, rpc.Operation.Name);
Exception error = new InvalidOperationException(text);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
}
}
}
public void SignalConditionalResume(IAsyncResult result)
{
if (this.rpc.invokeContinueGate.Signal(result))
{
this.rpc.AsyncResult = result;
Resume();
}
}
}
}
class MessageRpcInvokeNotification : IInvokeReceivedNotification
{
ServiceModelActivity activity;
ChannelHandler handler;
public MessageRpcInvokeNotification(ServiceModelActivity activity, ChannelHandler handler)
{
this.activity = activity;
this.handler = handler;
}
public bool DidInvokerEnsurePump { get; set; }
public void NotifyInvokeReceived()
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
ChannelHandler.Register(this.handler);
}
this.DidInvokerEnsurePump = true;
}
public void NotifyInvokeReceived(RequestContext request)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
ChannelHandler.Register(this.handler, request);
}
this.DidInvokerEnsurePump = true;
}
}
}