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
1286 lines
57 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|