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

1286 lines
57 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.Activities
{
using System;
using System.Activities;
using System.Activities.DynamicUpdate;
using System.Activities.Tracking;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Runtime;
using System.Runtime.Diagnostics;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Activities.Description;
using System.ServiceModel.Activities.Tracking;
using System.ServiceModel.Channels;
using System.ServiceModel.Diagnostics;
using System.Transactions;
using System.Xml.Linq;
using SR2 = System.ServiceModel.Activities.SR;
using System.Runtime.DurableInstancing;
using System.Security;
using System.ServiceModel.Description;
using System.Xml;
sealed class InternalReceiveMessage : NativeActivity
{
const string OperationNamePropertyName = "OperationName";
const string ServiceContractNamePropertyName = "ServiceContractName";
const string WSContextInstanceIdName = "wsc-instanceId";
const string InstanceIdKey = ContextMessageProperty.InstanceIdKey;
static string runtimeTransactionHandlePropertyName = typeof(RuntimeTransactionHandle).FullName;
Collection<CorrelationInitializer> correlationInitializers;
BookmarkCallback onMessageBookmarkCallback;
ServiceDescriptionData additionalData;
string operationBookmarkName;
Variable<VolatileReceiveMessageInstance> receiveMessageInstance;
WaitForReply waitForReply;
CompletionCallback onClientReceiveMessageComplete;
Variable<Bookmark> extensionReceiveBookmark;
public InternalReceiveMessage()
{
this.CorrelatesWith = new InArgument<CorrelationHandle>(context => (CorrelationHandle)null);
this.receiveMessageInstance = new Variable<VolatileReceiveMessageInstance>();
this.waitForReply = new WaitForReply { Instance = this.receiveMessageInstance };
this.onClientReceiveMessageComplete = new CompletionCallback(ClientScheduleOnReceiveMessageCallback);
this.extensionReceiveBookmark = new Variable<Bookmark>();
}
public string Action
{
get;
set;
}
public bool CanCreateInstance
{
get;
set;
}
public Collection<CorrelationInitializer> CorrelationInitializers
{
get
{
if (this.correlationInitializers == null)
{
this.correlationInitializers = new Collection<CorrelationInitializer>();
}
return this.correlationInitializers;
}
}
public InArgument<CorrelationHandle> CorrelatesWith
{
get;
set;
}
public OutArgument<Message> Message
{
get;
set;
}
public InArgument<NoPersistHandle> NoPersistHandle
{
get;
set;
}
public string OperationName
{
get;
set;
}
protected override bool CanInduceIdle
{
get
{
return true;
}
}
internal bool IsOneWay
{
get;
set;
}
// Added becuase there isn't a good way to distinguish
// between the Receive and ReceiveReply modes of execution of this activity.
// The Execute method distinguishes between those modes by predicating
// on followingCorrelation not being null and being able to
// acquire the RequestContext off the handle. We do not use RequestContext
// for the SendReceiveExtension based code-paths hence need
// another mechanism.
internal bool IsReceiveReply
{
get;
set;
}
internal ServiceDescriptionData AdditionalData
{
get
{
if (this.additionalData == null)
{
this.additionalData = new ServiceDescriptionData();
}
return this.additionalData;
}
}
public XName ServiceContractName
{
get;
set;
}
// Used by CreateProtocolBookmark and WorkflowOperationBehavior
internal string OperationBookmarkName
{
get
{
if (this.operationBookmarkName == null)
{
this.operationBookmarkName = BookmarkNameHelper.CreateBookmarkName(this.OperationName, this.ServiceContractName);
}
return this.operationBookmarkName;
}
}
internal string OwnerDisplayName { get; set; }
protected override void OnCreateDynamicUpdateMap(NativeActivityUpdateMapMetadata metadata, Activity originalActivity)
{
InternalReceiveMessage originalInternalReceive = (InternalReceiveMessage)originalActivity;
if (this.ServiceContractName != originalInternalReceive.ServiceContractName)
{
metadata.SaveOriginalValue(ServiceContractNamePropertyName, originalInternalReceive.ServiceContractName);
}
if (this.OperationName != originalInternalReceive.OperationName)
{
metadata.SaveOriginalValue(OperationNamePropertyName, originalInternalReceive.OperationName);
}
}
protected override void UpdateInstance(NativeActivityUpdateContext updateContext)
{
// we only care about the server-side Receive since the client-side Receive is not persistable.
// only valid instance update condition is when a bookmark with OperationBookmarkName is found.
CorrelationHandle followingCorrelation = (this.CorrelatesWith == null) ? null : (CorrelationHandle)updateContext.GetValue(this.CorrelatesWith);
if (followingCorrelation == null)
{
followingCorrelation = updateContext.FindExecutionProperty(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
}
BookmarkScope bookmarkScope;
if (followingCorrelation != null && followingCorrelation.Scope != null)
{
bookmarkScope = followingCorrelation.Scope;
}
else
{
bookmarkScope = updateContext.DefaultBookmarkScope;
}
string savedOriginalOperationName = (string)updateContext.GetSavedOriginalValue(OperationNamePropertyName);
XName savedOriginalServiceContractName = (XName)updateContext.GetSavedOriginalValue(ServiceContractNamePropertyName);
if ((savedOriginalOperationName == null && savedOriginalServiceContractName == null) || (savedOriginalOperationName == this.OperationName && savedOriginalServiceContractName == this.ServiceContractName))
{
// neither ServiceContractName nor OperationName have changed
// nothing to do, so exit early.
return;
}
string originalOperationBookmarkName = BookmarkNameHelper.CreateBookmarkName(savedOriginalOperationName ?? this.OperationName, savedOriginalServiceContractName ?? this.ServiceContractName);
if (updateContext.RemoveBookmark(originalOperationBookmarkName, bookmarkScope))
{
// if we are here, it means Receive is on the server-side and waiting for a request message to arrive
updateContext.CreateBookmark(this.OperationBookmarkName, new BookmarkCallback(this.OnMessage), bookmarkScope);
}
else
{
// this means Receive is in a state DU is not allowed.
updateContext.DisallowUpdate(SR.InvalidReceiveStateForDU);
}
}
ReceiveSettings GetReceiveSettings()
{
string actionName = null;
if (!string.IsNullOrWhiteSpace(this.Action))
{
actionName = this.Action;
}
else
{
// These values are null in the ReceiveReply configuration
if (this.ServiceContractName != null && !string.IsNullOrWhiteSpace(this.OperationName))
{
actionName = NamingHelper.GetMessageAction(new XmlQualifiedName(this.ServiceContractName.ToString()), this.OperationName, null, false);
}
}
ReceiveSettings receiveSettings = new ReceiveSettings
{
Action = actionName,
CanCreateInstance = this.CanCreateInstance,
OwnerDisplayName = this.OwnerDisplayName
};
return receiveSettings;
}
protected override void Abort(NativeActivityAbortContext context)
{
SendReceiveExtension sendReceiveExtension = context.GetExtension<SendReceiveExtension>();
if (sendReceiveExtension != null)
{
Bookmark pendingBookmark = this.extensionReceiveBookmark.Get(context);
if (pendingBookmark != null)
{
sendReceiveExtension.Cancel(pendingBookmark);
}
}
base.Abort(context);
}
protected override void Cancel(NativeActivityContext context)
{
SendReceiveExtension sendReceiveExtension = context.GetExtension<SendReceiveExtension>();
if (sendReceiveExtension != null)
{
Bookmark pendingBookmark = this.extensionReceiveBookmark.Get(context);
if (pendingBookmark != null)
{
sendReceiveExtension.Cancel(pendingBookmark);
context.RemoveBookmark(pendingBookmark);
}
}
base.Cancel(context);
}
// Activity Entry point: Phase 1: Execute
// A separate code-path for extension based execution least impacts
// the existing workflow hosts. In the future we will add an extension from
// workflowservicehost and always use the extension.
protected override void Execute(NativeActivityContext executionContext)
{
SendReceiveExtension sendReceiveExtension = executionContext.GetExtension<SendReceiveExtension>();
if (sendReceiveExtension != null)
{
this.ExecuteUsingExtension(sendReceiveExtension, executionContext);
}
else
{
// this activity's runtime DU particpation(UpdateInstance) is dependent on
// the following server side logic for resolving CorrelationHandle and creating a protocol bookmark.
CorrelationHandle followingCorrelation = (this.CorrelatesWith == null) ? null : this.CorrelatesWith.Get(executionContext);
bool triedAmbientCorrelation = false;
CorrelationHandle ambientCorrelation = null;
if (followingCorrelation == null)
{
ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
triedAmbientCorrelation = true;
if (ambientCorrelation != null)
{
followingCorrelation = ambientCorrelation;
}
}
CorrelationRequestContext requestContext;
if (followingCorrelation != null && followingCorrelation.TryAcquireRequestContext(executionContext, out requestContext))
{
// Client receive that is following a send.
ReceiveMessageInstanceData instance = new ReceiveMessageInstanceData(requestContext);
// for perf, cache the ambient correlation information
if (triedAmbientCorrelation)
{
instance.SetAmbientCorrelation(ambientCorrelation);
}
ClientScheduleOnReceivedMessage(executionContext, instance);
}
else
{
// Server side receive
// Validation of correlatesWithHandle
if (ambientCorrelation == null)
{
ambientCorrelation = executionContext.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
}
if (!this.IsOneWay && ambientCorrelation == null)
{
CorrelationHandle channelCorrelationHandle = CorrelationHandle.GetExplicitRequestReplyCorrelation(executionContext, this.correlationInitializers);
if (channelCorrelationHandle == null)
{
// With a two-way contract, we require a request/reply correlation handle
throw FxTrace.Exception.AsError(new InvalidOperationException(
SR2.ReceiveMessageNeedsToPairWithSendMessageForTwoWayContract(this.OperationName)));
}
}
BookmarkScope bookmarkScope = (followingCorrelation != null) ? followingCorrelation.EnsureBookmarkScope(executionContext) : executionContext.DefaultBookmarkScope;
if (this.onMessageBookmarkCallback == null)
{
this.onMessageBookmarkCallback = new BookmarkCallback(this.OnMessage);
}
executionContext.CreateBookmark(this.OperationBookmarkName, this.onMessageBookmarkCallback, bookmarkScope);
}
}
}
// Phase 2a: server side message has arrived and resumed the protocol bookmark
void OnMessage(NativeActivityContext executionContext, Bookmark bookmark, object state)
{
WorkflowOperationContext workflowContext = state as WorkflowOperationContext;
if (workflowContext == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.WorkflowMustBeHosted));
}
ReceiveMessageInstanceData instance = new ReceiveMessageInstanceData(
new CorrelationResponseContext
{
WorkflowOperationContext = workflowContext,
});
SetupTransaction(executionContext, instance);
}
// Phase 3: Setup Transaction for server receive case.
//
void SetupTransaction(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
WorkflowOperationContext workflowContext = instance.CorrelationResponseContext.WorkflowOperationContext;
if (workflowContext.CurrentTransaction != null)
{
//get the RuntimeTransactionHandle from the ambient
RuntimeTransactionHandle handle = null;
handle = executionContext.Properties.Find(runtimeTransactionHandlePropertyName) as RuntimeTransactionHandle;
if (handle != null)
{
//You are probably inside a TransactedReceiveScope
//TransactedReceiveData is used to pass information about the Initiating Transaction to the TransactedReceiveScope
//so that it can subsequently call Complete or Commit on it at the end of the scope
TransactedReceiveData transactedReceiveData = executionContext.Properties.Find(TransactedReceiveData.TransactedReceiveDataExecutionPropertyName) as TransactedReceiveData;
if (transactedReceiveData != null)
{
if (this.AdditionalData.IsFirstReceiveOfTransactedReceiveScopeTree)
{
Fx.Assert(workflowContext.OperationContext != null, "InternalReceiveMessage.SetupTransaction - Operation Context was null");
Fx.Assert(workflowContext.OperationContext.TransactionFacet != null, "InternalReceiveMessage.SetupTransaction - Transaction Facet was null");
transactedReceiveData.InitiatingTransaction = workflowContext.OperationContext.TransactionFacet.Current;
}
}
Transaction currentTransaction = handle.GetCurrentTransaction(executionContext);
if (currentTransaction != null)
{
if (!currentTransaction.Equals(workflowContext.CurrentTransaction))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.FlowedTransactionDifferentFromAmbient));
}
else
{
ServerScheduleOnReceivedMessage(executionContext, instance);
return;
}
}
ReceiveMessageState receiveMessageState = new ReceiveMessageState
{
CurrentTransaction = workflowContext.CurrentTransaction.Clone(),
Instance = instance
};
handle.RequireTransactionContext(executionContext, RequireContextCallback, receiveMessageState);
return;
}
else
{
//Receive was probably not used within a TransactionFlowScope since no ambient transaction handle was found
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.ReceiveNotWithinATransactedReceiveScope));
}
}
ServerScheduleOnReceivedMessage(executionContext, instance);
}
internal static Guid TraceCorrelationActivityId
{
[Fx.Tag.SecurityNote(Critical = "Critical because Trace.CorrelationManager has a Link demand for UnmanagedCode.",
Safe = "Safe because we aren't leaking a critical resource.")]
[SecuritySafeCritical]
get
{
return Trace.CorrelationManager.ActivityId;
}
}
void ProcessReceiveMessageTrace(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
if (TraceUtility.MessageFlowTracing)
{
if (TraceUtility.ActivityTracing)
{
instance.AmbientActivityId = InternalReceiveMessage.TraceCorrelationActivityId;
}
Guid receivedActivityId = Guid.Empty;
if (instance.CorrelationRequestContext != null)
{
//client side reply
receivedActivityId = TraceUtility.GetReceivedActivityId(instance.CorrelationRequestContext.OperationContext);
}
else if (instance.CorrelationResponseContext != null)
{
//server side receive
receivedActivityId = instance.CorrelationResponseContext.WorkflowOperationContext.E2EActivityId;
}
ProcessReceiveMessageTrace(executionContext, receivedActivityId);
}
}
void ProcessReceiveMessageTrace(NativeActivityContext executionContext, Guid receivedActivityId)
{
if (TraceUtility.MessageFlowTracing)
{
try
{
//
ReceiveMessageRecord messageFlowTrackingRecord = new ReceiveMessageRecord(MessagingActivityHelper.MessageCorrelationReceiveRecord)
{
E2EActivityId = receivedActivityId
};
executionContext.Track(messageFlowTrackingRecord);
if (receivedActivityId != Guid.Empty && DiagnosticTraceBase.ActivityId != receivedActivityId)
{
DiagnosticTraceBase.ActivityId = receivedActivityId;
}
FxTrace.Trace.SetAndTraceTransfer(executionContext.WorkflowInstanceId, true);
if (TraceUtility.ActivityTracing)
{
if (TD.StartSignpostEventIsEnabled())
{
TD.StartSignpostEvent(new DictionaryTraceRecord(new Dictionary<string, string>(3) {
{ MessagingActivityHelper.ActivityName, this.DisplayName },
{ MessagingActivityHelper.ActivityType, MessagingActivityHelper.MessagingActivityTypeActivityExecution },
{ MessagingActivityHelper.ActivityInstanceId, executionContext.ActivityInstanceId }
}));
}
}
else if (TD.WfMessageReceivedIsEnabled())
{
TD.WfMessageReceived(new EventTraceActivity(receivedActivityId), executionContext.WorkflowInstanceId);
}
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
FxTrace.Exception.AsInformation(ex);
}
}
}
void RequireContextCallback(NativeActivityTransactionContext transactionContext, object state)
{
Fx.Assert(transactionContext != null, "TransactionContext is null");
ReceiveMessageState receiveMessageState = state as ReceiveMessageState;
Fx.Assert(receiveMessageState != null, "ReceiveMessageState is null");
transactionContext.SetRuntimeTransaction(receiveMessageState.CurrentTransaction);
NativeActivityContext executionContext = transactionContext as NativeActivityContext;
Fx.Assert(executionContext != null, "Failed to cast ActivityTransactionContext to NativeActivityContext");
ServerScheduleOnReceivedMessage(executionContext, receiveMessageState.Instance);
}
// Phase 4: Set up the Message as OutArgument and invoke the OnReceivedMessage activity action
void ServerScheduleOnReceivedMessage(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
Fx.Assert(instance.CorrelationResponseContext != null, "Server side receive must have CorrelationResponseContext");
// if we infer the contract as Message the first input parameter will be the requestMessage from the client
Message request = instance.CorrelationResponseContext.WorkflowOperationContext.Inputs[0] as Message;
Fx.Assert(request != null, "WorkflowOperationContext.Inputs[0] must be of type Message");
Fx.Assert(request.State == MessageState.Created, "The request message must be in Created state");
this.Message.Set(executionContext, request);
// update instance->CorrelationResponseContext with the MessageVersion information, this is later used by
// ToReply formatter to construct the reply message
instance.CorrelationResponseContext.MessageVersion = ((Message)instance.CorrelationResponseContext.WorkflowOperationContext.Inputs[0]).Version;
// initialize the relevant correlation handle(s) with the 'anonymous' response context
CorrelationHandle ambientHandle = instance.GetAmbientCorrelation(executionContext);
CorrelationHandle correlatesWithHandle = (this.CorrelatesWith == null) ? null : this.CorrelatesWith.Get(executionContext);
// populate instance keys first
MessagingActivityHelper.InitializeCorrelationHandles(executionContext, correlatesWithHandle, ambientHandle, this.correlationInitializers,
instance.CorrelationResponseContext.WorkflowOperationContext.OperationContext.IncomingMessageProperties);
// for the request/reply handle
// then store the response context in the designated correlation handle
// first check for an explicit association
CorrelationHandle channelCorrelationHandle = CorrelationHandle.GetExplicitRequestReplyCorrelation(executionContext, this.correlationInitializers);
if (this.IsOneWay)
{
// this is one way, verify that the channelHandle is null
if (channelCorrelationHandle != null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.RequestReplyHandleShouldNotBePresentForOneWay));
}
// we need to enter the nopersistzone using the NoPersistHandle and exit it in the formatter
if (this.NoPersistHandle != null)
{
NoPersistHandle noPersistHandle = this.NoPersistHandle.Get(executionContext);
if (noPersistHandle != null)
{
noPersistHandle.Enter(executionContext);
}
}
}
else
{
// first check for an explicit association
if (channelCorrelationHandle != null)
{
if (!channelCorrelationHandle.TryRegisterResponseContext(executionContext, instance.CorrelationResponseContext))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.TryRegisterRequestContextFailed));
}
}
else// if that fails, use ambient handle. we should never initialize CorrelatesWith with response context
{
Fx.Assert(ambientHandle != null, "Ambient handle should not be null for two-way server side receive/sendReply");
if (!ambientHandle.TryRegisterResponseContext(executionContext, instance.CorrelationResponseContext))
{
// With a two-way contract, the request context must be initialized
throw FxTrace.Exception.AsError(new InvalidOperationException(
SR2.ReceiveMessageNeedsToPairWithSendMessageForTwoWayContract(this.OperationName)));
}
}
// validate that NoPersistHandle is null, we should have nulled it out in Receive->SetIsOneWay during ContractInference
Fx.Assert(this.NoPersistHandle == null, "NoPersistHandle should be null in case of two-way");
}
// for the duplex handle: we want to save the callback context in the correlation handle
if (instance.CorrelationCallbackContext != null)
{
// Pass the CorrelationCallbackContext to correlation handle.
CorrelationHandle callbackHandle = CorrelationHandle.GetExplicitCallbackCorrelation(executionContext, this.correlationInitializers);
// if that is not set, then try the ambientHandle, we will not use the CorrelatesWith handle to store callback context
if (callbackHandle == null)
{
callbackHandle = ambientHandle;
}
if (callbackHandle != null)
{
callbackHandle.CallbackContext = instance.CorrelationCallbackContext;
}
}
FinalizeScheduleOnReceivedMessage(executionContext, instance);
}
void ClientScheduleOnReceivedMessage(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
Fx.Assert(instance.CorrelationRequestContext != null, "Client side receive must have CorrelationRequestContext");
// client side: retrieve the reply from the request context
if (instance.CorrelationRequestContext.TryGetReply())
{
// Reply has already come back because one of the following happened:
// (1) Receive reply completed synchronously
// (2) Async receive reply completed very quickly and channel callback already happened by now
ClientScheduleOnReceiveMessageCore(executionContext, instance);
FinalizeScheduleOnReceivedMessage(executionContext, instance);
}
else
{
// Async path: wait for reply to come back
VolatileReceiveMessageInstance volatileInstance = new VolatileReceiveMessageInstance { Instance = instance };
this.receiveMessageInstance.Set(executionContext, volatileInstance);
if (onClientReceiveMessageComplete == null)
{
onClientReceiveMessageComplete = new CompletionCallback(ClientScheduleOnReceiveMessageCallback);
}
executionContext.ScheduleActivity(this.waitForReply, onClientReceiveMessageComplete);
}
}
void ClientScheduleOnReceiveMessageCallback(NativeActivityContext executionContext, ActivityInstance completedInstance)
{
VolatileReceiveMessageInstance volatileInstance = this.receiveMessageInstance.Get(executionContext);
ReceiveMessageInstanceData instance = volatileInstance.Instance;
if (instance.CorrelationRequestContext.TryGetReply())
{
ClientScheduleOnReceiveMessageCore(executionContext, instance);
}
FinalizeScheduleOnReceivedMessage(executionContext, instance);
}
void ClientScheduleOnReceiveMessageCore(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
Fx.Assert(instance.CorrelationRequestContext.Reply != null, "Reply message cannot be null!");
// Initialize CorrelationContext and CorrelationCallbackContext
instance.InitializeContextAndCallbackContext();
CorrelationHandle ambientHandle = instance.GetAmbientCorrelation(executionContext);
if (instance.CorrelationRequestContext.CorrelationKeyCalculator != null)
{
// Client side reply do not use CorrelatesWith to initialize correlation
instance.CorrelationRequestContext.Reply = MessagingActivityHelper.InitializeCorrelationHandles(executionContext,
null, ambientHandle, this.correlationInitializers,
instance.CorrelationRequestContext.CorrelationKeyCalculator, instance.CorrelationRequestContext.Reply);
}
// for the duplex-case
// we would receive the Server Context in the Request-Reply message, we have to save the Server Context so that subsequent sends from the client to
// the server can use this context to reach the correct Server instance
if (instance.CorrelationContext != null)
{
// Pass the CorrelationContext to correlation handle.
// Correlation handle will have to be in the correlation Initializers collection
CorrelationHandle contextHandle = CorrelationHandle.GetExplicitContextCorrelation(executionContext, this.correlationInitializers);
// if that is not set, then try the ambient handle
if (contextHandle == null)
{
// get the cached ambient handle, we only use explicit handle or ambient handle to store the context
contextHandle = ambientHandle;
}
if (contextHandle != null)
{
contextHandle.Context = instance.CorrelationContext;
}
}
// set the Message with what is in the correlationRequestContext
// this Message needs to be closed later by the formatter
Message request = instance.CorrelationRequestContext.Reply;
this.Message.Set(executionContext, request);
}
void FinalizeScheduleOnReceivedMessage(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
ProcessReceiveMessageTrace(executionContext, instance);
IList<IReceiveMessageCallback> receiveMessageCallbacks = MessagingActivityHelper.GetCallbacks<IReceiveMessageCallback>(executionContext.Properties);
if (receiveMessageCallbacks != null && receiveMessageCallbacks.Count > 0)
{
OperationContext operationContext = instance.GetOperationContext();
// invoke the callback that user might have added in the AEC in the previous activity
// e.g. distributed compensation activity will add this so that they can convert a message back to
// an execution property
foreach (IReceiveMessageCallback receiveMessageCallback in receiveMessageCallbacks)
{
receiveMessageCallback.OnReceiveMessage(operationContext, executionContext.Properties);
}
}
// call this method with or without callback
this.FinalizeReceiveMessageCore(executionContext, instance);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument correlatesWithArgument = new RuntimeArgument(Constants.CorrelatesWith, Constants.CorrelationHandleType, ArgumentDirection.In);
if (this.CorrelatesWith == null)
{
this.CorrelatesWith = new InArgument<CorrelationHandle>();
}
metadata.Bind(this.CorrelatesWith, correlatesWithArgument);
metadata.AddArgument(correlatesWithArgument);
if (this.correlationInitializers != null)
{
int count = 0;
foreach (CorrelationInitializer correlation in this.correlationInitializers)
{
if (correlation.CorrelationHandle != null)
{
RuntimeArgument argument = new RuntimeArgument(Constants.Parameter + count,
correlation.CorrelationHandle.ArgumentType, correlation.CorrelationHandle.Direction, true);
metadata.Bind(correlation.CorrelationHandle, argument);
metadata.AddArgument(argument);
count++;
}
}
}
RuntimeArgument receiveMessageArgument = new RuntimeArgument(Constants.Message, Constants.MessageType, ArgumentDirection.Out);
if (this.Message == null)
{
this.Message = new OutArgument<Message>();
}
metadata.Bind(this.Message, receiveMessageArgument);
metadata.AddArgument(receiveMessageArgument);
RuntimeArgument noPersistHandleArgument = new RuntimeArgument(Constants.NoPersistHandle, Constants.NoPersistHandleType, ArgumentDirection.In);
if (this.NoPersistHandle == null)
{
this.NoPersistHandle = new InArgument<NoPersistHandle>();
}
metadata.Bind(this.NoPersistHandle, noPersistHandleArgument);
metadata.AddArgument(noPersistHandleArgument);
metadata.AddImplementationVariable(this.receiveMessageInstance);
metadata.AddImplementationVariable(this.extensionReceiveBookmark);
metadata.AddImplementationChild(this.waitForReply);
}
// Phase 5: Useful for the both client and server side receive. It passes down the response context if it is two way or
// throw the exception right back to the workflow if it is not expected.
void FinalizeReceiveMessageCore(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
if (instance != null)
{
if (instance.CorrelationRequestContext != null && instance.CorrelationRequestContext.Reply != null)
{
// This should be closed by the formatter after desrializing the message
// clean this reply message up for a following receive
//instance.CorrelationRequestContext.Reply.Close();
}
else if (instance.CorrelationResponseContext != null)
{
// this is only for the server side
if (this.IsOneWay)
{
// mark this workflow service operation as complete
instance.CorrelationResponseContext.WorkflowOperationContext.SetOperationCompleted();
if (instance.CorrelationResponseContext.Exception != null)
{
// We got an unexpected exception while running the OnReceivedMessage action
throw FxTrace.Exception.AsError(instance.CorrelationResponseContext.Exception);
}
}
}
//reset the trace
this.ResetTrace(executionContext, instance);
}
}
void ResetTrace(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
this.ResetTrace(executionContext, instance.AmbientActivityId);
if (TraceUtility.ActivityTracing)
{
instance.AmbientActivityId = Guid.Empty;
}
}
void ResetTrace(NativeActivityContext executionContext, Guid ambientActivityId)
{
if (TraceUtility.ActivityTracing)
{
if (TD.StopSignpostEventIsEnabled())
{
TD.StopSignpostEvent(new DictionaryTraceRecord(new Dictionary<string, string>(3) {
{ MessagingActivityHelper.ActivityName, this.DisplayName },
{ MessagingActivityHelper.ActivityType, MessagingActivityHelper.MessagingActivityTypeActivityExecution },
{ MessagingActivityHelper.ActivityInstanceId, executionContext.ActivityInstanceId }
}));
}
FxTrace.Trace.SetAndTraceTransfer(ambientActivityId, true);
}
else if (TD.WfMessageReceivedIsEnabled())
{
TD.WfMessageReceived(new EventTraceActivity(executionContext.WorkflowInstanceId), ambientActivityId);
}
}
void ExecuteUsingExtension(SendReceiveExtension sendReceiveExtension, NativeActivityContext executionContext)
{
Fx.Assert(sendReceiveExtension != null, "SendReceiveExtension should be available here.");
CorrelationHandle followingCorrelation = null;
if (!this.TryGetCorrelatesWithHandle(executionContext, out followingCorrelation))
{
followingCorrelation = CorrelationHandle.GetAmbientCorrelation(executionContext);
if (followingCorrelation == null)
{
if (!this.IsOneWay)
{
if (!this.correlationInitializers.TryGetRequestReplyCorrelationHandle(executionContext, out followingCorrelation))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(
SR2.ReceiveMessageNeedsToPairWithSendMessageForTwoWayContract(this.OperationName)));
}
}
}
}
Bookmark bookmark = executionContext.CreateBookmark(this.OnReceiveMessageFromExtension);
this.extensionReceiveBookmark.Set(executionContext, bookmark);
InstanceKey correlatesWithValue = null;
if (followingCorrelation != null)
{
if (this.IsReceiveReply && followingCorrelation.TransientInstanceKey != null)
{
correlatesWithValue = followingCorrelation.TransientInstanceKey;
}
else
{
correlatesWithValue = followingCorrelation.InstanceKey;
}
}
sendReceiveExtension.RegisterReceive(this.GetReceiveSettings(), correlatesWithValue, bookmark);
}
void OnReceiveMessageFromExtension(NativeActivityContext executionContext, Bookmark bookmark, object state)
{
SendReceiveExtension sendReceiveExtension = executionContext.GetExtension<SendReceiveExtension>();
if (sendReceiveExtension == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.SendReceiveExtensionNotFound));
}
// Now that the bookmark has been resumed, clear out the workflow variable holding its value.
this.extensionReceiveBookmark.Set(executionContext, null);
MessageContext messageContext = state as MessageContext;
if (messageContext == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.InvalidDataFromReceiveBookmarkState(this.OperationName)));
}
this.Message.Set(executionContext, messageContext.Message);
this.ProcessReceiveMessageTrace(executionContext, messageContext.EndToEndTracingId);
this.InitializeCorrelationHandles(executionContext, messageContext.Message.Properties, messageContext.EndToEndTracingId);
this.ResetTrace(executionContext, InternalReceiveMessage.TraceCorrelationActivityId);
}
void InitializeCorrelationHandles(NativeActivityContext executionContext, MessageProperties messageProperties, Guid e2eTracingId)
{
CorrelationHandle ambientHandle = CorrelationHandle.GetAmbientCorrelation(executionContext);
HostSettings hostSettings = executionContext.GetExtension<SendReceiveExtension>().HostSettings;
if (this.IsReceiveReply)
{
// Client side ReceiveReply.
MessagingActivityHelper.InitializeCorrelationHandles(executionContext, null, ambientHandle, this.correlationInitializers, messageProperties);
// Set InstanceKey on ContextCorrelation/Ambient handle.
InstanceKey contextCorrelationInstanceKey;
if (this.TryGetContextCorrelationInstanceKey(hostSettings, messageProperties, out contextCorrelationInstanceKey))
{
CorrelationHandle contextCorrelationHandle = CorrelationHandle.GetExplicitContextCorrelation(executionContext, this.correlationInitializers);
MessagingActivityHelper.InitializeCorrelationHandles(executionContext, contextCorrelationHandle, ambientHandle, null, contextCorrelationInstanceKey, null);
}
// ensure we clear the transient correlation handle so that it can be reused by subsequent request-reply pairs
if (ambientHandle != null)
{
ambientHandle.TransientInstanceKey = null;
}
}
else
{
// Server side receive. Can be a one-way Receive or a Receive-SendReply.
CorrelationHandle requestReplyHandle = CorrelationHandle.GetExplicitRequestReplyCorrelation(executionContext, this.correlationInitializers);
if (requestReplyHandle == null && ambientHandle == null && !this.IsOneWay)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(
SR2.ReceiveMessageNeedsToPairWithSendMessageForTwoWayContract(this.OperationName)));
}
if (requestReplyHandle != null && this.IsOneWay)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.RequestReplyHandleShouldNotBePresentForOneWay));
}
CorrelationHandle correlatesWithHandle;
this.TryGetCorrelatesWithHandle(executionContext, out correlatesWithHandle);
MessagingActivityHelper.InitializeCorrelationHandles(executionContext, correlatesWithHandle, ambientHandle, this.correlationInitializers, messageProperties);
if (!this.IsOneWay)
{
InstanceKey requestReplyCorrelationInstanceKey;
if (this.TryGetRequestReplyCorrelationInstanceKey(messageProperties, out requestReplyCorrelationInstanceKey))
{
MessagingActivityHelper.InitializeCorrelationHandles(executionContext, requestReplyHandle, ambientHandle, null, requestReplyCorrelationInstanceKey, null);
}
else
{
if (requestReplyHandle != null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.FailedToInitializeRequestReplyCorrelationHandle(this.OperationName)));
}
}
}
this.UpdateE2ETracingId(e2eTracingId, correlatesWithHandle, ambientHandle, requestReplyHandle);
// Set InstanceKey on CallbackCorrelation/Ambient handle.
InstanceKey callbackContextCorrelationInstanceKey;
if (this.TryGetCallbackContextCorrelationInstanceKey(hostSettings, messageProperties, out callbackContextCorrelationInstanceKey))
{
CorrelationHandle callbackContextCorrelationHandle = CorrelationHandle.GetExplicitCallbackCorrelation(executionContext, this.correlationInitializers);
MessagingActivityHelper.InitializeCorrelationHandles(executionContext, callbackContextCorrelationHandle, ambientHandle, null, callbackContextCorrelationInstanceKey, null);
}
}
}
void UpdateE2ETracingId(Guid e2eTracingId, CorrelationHandle correlatesWith, CorrelationHandle ambientHandle, CorrelationHandle requestReplyHandle)
{
if (correlatesWith != null)
{
correlatesWith.E2ETraceId = e2eTracingId;
}
else if (ambientHandle != null)
{
ambientHandle.E2ETraceId = e2eTracingId;
}
else if (requestReplyHandle != null)
{
requestReplyHandle.E2ETraceId = e2eTracingId;
}
}
bool TryGetCallbackContextCorrelationInstanceKey(HostSettings hostSettings, MessageProperties messageProperties, out InstanceKey callbackContextCorrelationInstanceKey)
{
callbackContextCorrelationInstanceKey = null;
CallbackContextMessageProperty callbackContext;
if (CallbackContextMessageProperty.TryGet(messageProperties, out callbackContext))
{
if (callbackContext.Context != null)
{
string instanceId = null;
if (callbackContext.Context.TryGetValue(InstanceIdKey, out instanceId))
{
IDictionary<string, string> keyData = new Dictionary<string, string>(1)
{
{ WSContextInstanceIdName, instanceId }
};
callbackContextCorrelationInstanceKey = new CorrelationKey(keyData, hostSettings.ScopeName, null);
}
}
}
return callbackContextCorrelationInstanceKey != null;
}
bool TryGetContextCorrelationInstanceKey(HostSettings hostSettings, MessageProperties messageProperties, out InstanceKey correlationContextInstanceKey)
{
correlationContextInstanceKey = null;
ContextMessageProperty contextProperties = null;
if (ContextMessageProperty.TryGet(messageProperties, out contextProperties))
{
if (contextProperties.Context != null)
{
string instanceId = null;
if (contextProperties.Context.TryGetValue(InstanceIdKey, out instanceId))
{
IDictionary<string, string> keyData = new Dictionary<string, string>(1)
{
{ WSContextInstanceIdName, instanceId }
};
correlationContextInstanceKey = new CorrelationKey(keyData, hostSettings.ScopeName, null);
}
}
}
return correlationContextInstanceKey != null;
}
bool TryGetRequestReplyCorrelationInstanceKey(MessageProperties messageProperties, out InstanceKey instanceKey)
{
instanceKey = null;
CorrelationMessageProperty correlationMessageProperty;
if (messageProperties.TryGetValue<CorrelationMessageProperty>(CorrelationMessageProperty.Name, out correlationMessageProperty))
{
foreach (InstanceKey key in correlationMessageProperty.TransientCorrelations)
{
InstanceValue value;
if (key.Metadata.TryGetValue(WorkflowServiceNamespace.RequestReplyCorrelation, out value))
{
instanceKey = key;
break;
}
}
}
return instanceKey != null;
}
bool TryGetCorrelatesWithHandle(NativeActivityContext context, out CorrelationHandle correlationHandle)
{
correlationHandle = null;
if (this.CorrelatesWith != null)
{
correlationHandle = this.CorrelatesWith.Get(context);
}
return correlationHandle != null;
}
[DataContract]
internal class VolatileReceiveMessageInstance
{
public VolatileReceiveMessageInstance()
{
}
// Note that we do not mark this DataMember since we don�t want it to be serialized
public ReceiveMessageInstanceData Instance { get; set; }
}
// This class defines the instance data that is saved in a variable. This will be initialized with null, and only be
// used to pass data around during the execution. It is not intended to be persisted, thus it is not marked with
// DataContract and DataMemeber.
internal class ReceiveMessageInstanceData
{
bool triedAmbientCorrelation;
CorrelationHandle ambientCorrelation;
public ReceiveMessageInstanceData(CorrelationRequestContext requestContext)
{
Fx.Assert(requestContext != null, "requestContext is a required parameter");
this.CorrelationRequestContext = requestContext;
}
public ReceiveMessageInstanceData(CorrelationResponseContext responseContext)
{
Fx.Assert(responseContext != null, "responseContext is a required parameter");
this.CorrelationResponseContext = responseContext;
this.CorrelationCallbackContext =
MessagingActivityHelper.CreateCorrelationCallbackContext(responseContext.WorkflowOperationContext.OperationContext.IncomingMessageProperties);
}
// For the client-receive case. Saves the context retrieved from the handle
public CorrelationRequestContext CorrelationRequestContext
{
get;
private set;
}
// For the server-receive case. The context that will be used to by the following send.
public CorrelationResponseContext CorrelationResponseContext
{
get;
private set;
}
public CorrelationCallbackContext CorrelationCallbackContext
{
get;
private set;
}
public CorrelationContext CorrelationContext
{
get;
private set;
}
public Guid AmbientActivityId
{
get;
set;
}
public CorrelationHandle GetAmbientCorrelation(NativeActivityContext context)
{
if (this.triedAmbientCorrelation)
{
return this.ambientCorrelation;
}
this.triedAmbientCorrelation = true;
this.ambientCorrelation = context.Properties.Find(CorrelationHandle.StaticExecutionPropertyName) as CorrelationHandle;
return this.ambientCorrelation;
}
public void SetAmbientCorrelation(CorrelationHandle ambientCorrelation)
{
Fx.Assert(!this.triedAmbientCorrelation, "can only set ambient correlation once");
this.ambientCorrelation = ambientCorrelation;
this.triedAmbientCorrelation = true;
}
internal OperationContext GetOperationContext()
{
if (this.CorrelationRequestContext != null)
{
return this.CorrelationRequestContext.OperationContext;
}
else if (this.CorrelationResponseContext != null)
{
return this.CorrelationResponseContext.WorkflowOperationContext.OperationContext;
}
return null;
}
public void InitializeContextAndCallbackContext()
{
Fx.Assert(this.CorrelationRequestContext.Reply != null, "Reply message cannot be null for context and callback!");
this.CorrelationCallbackContext =
MessagingActivityHelper.CreateCorrelationCallbackContext(this.CorrelationRequestContext.Reply.Properties);
// this is the context that the server must have send back in the initial hand-shake
this.CorrelationContext =
MessagingActivityHelper.CreateCorrelationContext(this.CorrelationRequestContext.Reply.Properties);
}
}
class ReceiveMessageState
{
public Transaction CurrentTransaction
{
get;
set;
}
public ReceiveMessageInstanceData Instance
{
get;
set;
}
}
class WaitForReply : AsyncCodeActivity
{
public WaitForReply()
{
}
public InArgument<VolatileReceiveMessageInstance> Instance
{
get;
set;
}
protected override void CacheMetadata(CodeActivityMetadata metadata)
{
RuntimeArgument instanceArgument = new RuntimeArgument("Instance", typeof(VolatileReceiveMessageInstance), ArgumentDirection.In);
if (this.Instance == null)
{
this.Instance = new InArgument<VolatileReceiveMessageInstance>();
}
metadata.Bind(this.Instance, instanceArgument);
metadata.SetArgumentsCollection(
new Collection<RuntimeArgument>
{
instanceArgument
});
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
VolatileReceiveMessageInstance volatileInstance = this.Instance.Get(context);
return new WaitForReplyAsyncResult(volatileInstance.Instance, callback, state);
}
protected override void EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
{
WaitForReplyAsyncResult.End(result);
}
protected override void Cancel(AsyncCodeActivityContext context)
{
VolatileReceiveMessageInstance volatileInstance = this.Instance.Get(context);
volatileInstance.Instance.CorrelationRequestContext.Cancel();
base.Cancel(context);
}
class WaitForReplyAsyncResult : AsyncResult
{
static Action<object, TimeoutException> onReceiveReply;
public WaitForReplyAsyncResult(ReceiveMessageInstanceData instance, AsyncCallback callback, object state)
: base(callback, state)
{
if (onReceiveReply == null)
{
onReceiveReply = new Action<object, TimeoutException>(OnReceiveReply);
}
if (instance.CorrelationRequestContext.WaitForReplyAsync(onReceiveReply, this))
{
Complete(true);
}
}
public static void End(IAsyncResult result)
{
AsyncResult.End<WaitForReplyAsyncResult>(result);
}
static void OnReceiveReply(object state, TimeoutException timeoutException)
{
WaitForReplyAsyncResult thisPtr = (WaitForReplyAsyncResult)state;
thisPtr.Complete(false);
}
}
}
}
}