public static void CreateTransactionResponse(Enlistment enlistment, Status status, object obj)
{
MsgCreateTransactionEvent e = (MsgCreateTransactionEvent)obj;
CompletionEnlistment protocolProviderContext = (CompletionEnlistment)enlistment.ProtocolProviderContext;
protocolProviderContext.StateMachine.Enqueue(new TmCreateTransactionResponseEvent(protocolProviderContext, status, e));
}
public MsgRegisterCompletionEvent(CompletionEnlistment completion, ref Register register, RequestAsyncResult result, CompletionParticipantProxy proxy) : base(completion)
{
this.register = register;
proxy.AddRef();
this.proxy = proxy;
this.result = result;
}
public override void OnEvent(TmAsyncRollbackEvent e)
{
CompletionEnlistment completion = (CompletionEnlistment)e.Enlistment;
completion.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.Aborted(completion);
e.StateMachine.ChangeState(base.state.States.CompletionAborted);
}
private void SendComplete(IAsyncResult ar)
{
if (!ar.CompletedSynchronously)
{
CompletionEnlistment asyncState = (CompletionEnlistment)ar.AsyncState;
this.OnSendComplete(ar, asyncState, asyncState.ParticipantProxy);
}
}
public void Commit(CompletionEnlistment completion)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, completion.EnlistmentId, "Sending completion Commit to transaction manager");
}
this.coordination.Commit(completion.Enlistment, this.completionCommitResponseCallback, completion);
}
public void Aborted(CompletionEnlistment completion)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, completion.EnlistmentId, "Replying Aborted to transaction manager");
}
completion.DeliverCallback(Status.Aborted);
}
public override void OnEvent(MsgCreateTransactionEvent e)
{
CompletionEnlistment completion = e.Completion;
EnlistmentOptions options = completion.CreateEnlistmentOptions(e.Body.Expires, e.Body.ExpiresPresent, e.Body.IsolationLevel, 0, null);
base.state.TransactionManagerSend.CreateTransaction(completion, options, e);
e.StateMachine.ChangeState(base.state.States.CompletionCreating);
}
public CompletionParticipantEvent(CompletionEnlistment completion) : base(completion)
{
MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders;
this.faultTo = Library.GetFaultToHeader(incomingMessageHeaders, base.state.ProtocolVersion);
this.replyTo = Library.GetReplyToHeader(incomingMessageHeaders);
this.messageID = incomingMessageHeaders.MessageId;
}
public override void OnEvent(MsgRegisterCompletionEvent e)
{
CompletionEnlistment completion = e.Completion;
completion.SetCompletionProxy(e.Proxy);
base.state.RegistrationCoordinator.SendRegisterResponse(completion, e.Result, ControlProtocol.Completion, completion.CoordinatorService);
e.StateMachine.ChangeState(base.state.States.CompletionActive);
}
public override void Enter(StateMachine stateMachine)
{
base.Enter(stateMachine);
if (RegisterParticipantRecord.ShouldTrace)
{
CompletionEnlistment enlistment = (CompletionEnlistment)stateMachine.Enlistment;
RegisterParticipantRecord.Trace(enlistment.EnlistmentId, enlistment.Enlistment.RemoteTransactionId, ControlProtocol.Completion, enlistment.ParticipantProxy.To, base.state.ProtocolVersion);
}
}
public void Commit(Message message)
{
CompletionEnlistment completion = this.CheckMessage(message, true);
if (completion != null)
{
completion.StateMachine.Enqueue(new MsgCompletionCommitEvent(completion));
}
}
public void SendCommitted(CompletionEnlistment completion)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, completion.EnlistmentId, "Sending Committed to completion participant at {0}", Ports.TryGetAddress(completion.ParticipantProxy));
}
IAsyncResult ar = completion.ParticipantProxy.BeginSendCommitted(this.sendComplete, completion);
if (ar.CompletedSynchronously)
{
this.OnSendComplete(ar, completion, completion.ParticipantProxy);
}
}
private CompletionEnlistment CheckMessage(Message message, bool reply)
{
Guid guid;
if (!Ports.TryGetEnlistment(message, out guid))
{
DebugTrace.Trace(TraceLevel.Warning, "Could not read enlistment header from message");
if (reply)
{
this.SendFault(message, this.state.Faults.InvalidParameters);
}
return(null);
}
Microsoft.Transactions.Wsat.Protocol.TransactionEnlistment enlistment = this.state.Lookup.FindEnlistment(guid);
if (enlistment == null)
{
DebugTrace.Trace(TraceLevel.Warning, "Could not find enlistment {0}", guid);
if (reply)
{
this.SendFault(message, this.state.Faults.InvalidState);
}
return(null);
}
CompletionEnlistment enlistment2 = enlistment as CompletionEnlistment;
if (enlistment2 == null)
{
DebugTrace.Trace(TraceLevel.Warning, "Completion message received for non-completion enlistment {0}", guid);
if (reply)
{
this.SendFault(message, this.state.Faults.InvalidParameters);
}
return(null);
}
if (this.state.Service.Security.CheckIdentity(enlistment2.ParticipantProxy, message))
{
return(enlistment2);
}
if (EnlistmentIdentityCheckFailedRecord.ShouldTrace)
{
EnlistmentIdentityCheckFailedRecord.Trace(enlistment2.EnlistmentId);
}
return(null);
}
private void OnSendComplete(IAsyncResult ar, CompletionEnlistment completion, CompletionParticipantProxy proxy)
{
try
{
proxy.EndSendMessage(ar);
}
catch (WsatSendFailureException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
this.state.Perf.MessageSendFailureCountPerInterval.Increment();
if (completion != null)
{
DebugTrace.TraceSendFailure(completion.EnlistmentId, exception);
}
else
{
DebugTrace.TraceSendFailure(exception);
}
}
}
public void CreateCoordinationContext(Message message, Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result)
{
Microsoft.Transactions.Wsat.Messaging.CreateCoordinationContext create = new Microsoft.Transactions.Wsat.Messaging.CreateCoordinationContext(message, this.state.ProtocolVersion);
CoordinationContext currentContext = create.CurrentContext;
if (currentContext == null)
{
CompletionEnlistment completion = new CompletionEnlistment(this.state);
completion.StateMachine.Enqueue(new MsgCreateTransactionEvent(completion, ref create, result));
}
else
{
TransactionContextManager contextManager = this.state.Lookup.FindTransactionContextManager(currentContext.Identifier);
if (contextManager == null)
{
bool flag;
contextManager = new TransactionContextManager(this.state, currentContext.Identifier);
contextManager = this.state.Lookup.FindOrAddTransactionContextManager(contextManager, out flag);
}
contextManager.StateMachine.Enqueue(new TransactionContextEnlistTransactionEvent(contextManager, ref create, result));
}
}
public override void OnEvent(TmCreateTransactionResponseEvent e)
{
MsgCreateTransactionEvent sourceEvent = e.SourceEvent;
CompletionEnlistment completion = e.Completion;
if (e.Status != Status.Success)
{
Fault cannotCreateContext = base.state.Faults.CannotCreateContext;
base.state.ActivationCoordinator.SendFault(sourceEvent.Result, cannotCreateContext);
if (CreateTransactionFailureRecord.ShouldTrace)
{
CreateTransactionFailureRecord.Trace(completion.EnlistmentId, Microsoft.Transactions.SR.GetString("PplCreateTransactionFailed", new object[] { e.Status.ToString() }));
}
completion.StateMachine.ChangeState(base.state.States.CompletionInitializationFailed);
}
else
{
completion.OnRootTransactionCreated();
TransactionContext transactionContext = completion.ContextManager.TransactionContext;
base.state.ActivationCoordinator.SendCreateCoordinationContextResponse(transactionContext, sourceEvent.Result);
completion.StateMachine.ChangeState(base.state.States.CompletionCreated);
}
}
public override void OnEvent(TmCompletionCommitResponseEvent e)
{
Microsoft.Transactions.Wsat.StateMachines.State completionCommitted;
CompletionEnlistment completion = e.Completion;
switch (e.Status)
{
case Status.Committed:
base.state.CompletionCoordinator.SendCommitted(completion);
completionCommitted = base.state.States.CompletionCommitted;
break;
case Status.Aborted:
base.state.CompletionCoordinator.SendAborted(completion);
completionCommitted = base.state.States.CompletionAborted;
break;
default:
DiagnosticUtility.FailFast("Invalid status code");
completionCommitted = null;
break;
}
e.StateMachine.ChangeState(completionCommitted);
}
protected CompletionStatusEvent(CompletionEnlistment completion, Microsoft.Transactions.Bridge.Status status) : base(completion)
{
this.status = status;
}
public TmCreateTransactionResponseEvent(CompletionEnlistment completion, Status status, MsgCreateTransactionEvent e) : base(completion, status)
{
this.e = e;
}
public MsgCompletionCommitEvent(CompletionEnlistment completion) : base(completion)
{
}
public MsgCompletionRollbackEvent(CompletionEnlistment completion) : base(completion)
{
}
public void CreateTransaction(CompletionEnlistment completion, EnlistmentOptions options, MsgCreateTransactionEvent e)
{
DebugTrace.Trace(TraceLevel.Info, "Sending CreateTransaction to transaction manager");
this.propagation.CreateTransaction(completion.Enlistment, options, this.createTransactionResponseCallback, e);
}
public void Register(Message message, Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result)
{
Microsoft.Transactions.Wsat.Messaging.Register register = new Microsoft.Transactions.Wsat.Messaging.Register(message, this.state.ProtocolVersion);
EndpointAddress participantProtocolService = register.ParticipantProtocolService;
WsatRegistrationHeader header = WsatRegistrationHeader.ReadFrom(message);
if (header == null)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message with no registration header");
}
this.SendFault(result, this.state.Faults.InvalidParameters);
return;
}
switch (register.Protocol)
{
case ControlProtocol.Completion:
{
CompletionEnlistment completion = this.state.Lookup.FindEnlistment(header.TransactionId) as CompletionEnlistment;
if (completion != null)
{
CompletionParticipantProxy proxy = this.state.TryCreateCompletionParticipantProxy(participantProtocolService);
if (proxy == null)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message for completion on no completion enlistment");
}
this.SendFault(result, this.state.Faults.InvalidParameters);
return;
}
try
{
completion.StateMachine.Enqueue(new MsgRegisterCompletionEvent(completion, ref register, result, proxy));
return;
}
finally
{
proxy.Release();
}
break;
}
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting uncorrelated Register message for completion");
}
this.SendFault(result, this.state.Faults.UnknownCompletionEnlistment);
return;
}
case ControlProtocol.Volatile2PC:
case ControlProtocol.Durable2PC:
break;
default:
goto Label_0222;
}
if (!this.state.TransactionManager.Settings.NetworkOutboundAccess)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message because outbound transactions are disabled");
}
this.SendFault(result, this.state.Faults.ParticipantRegistrationNetAccessDisabled);
return;
}
if (register.Loopback == this.state.ProcessId)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting recursive Register message from self");
}
this.SendFault(result, this.state.Faults.ParticipantRegistrationLoopback);
return;
}
TwoPhaseCommitParticipantProxy proxy2 = this.state.TryCreateTwoPhaseCommitParticipantProxy(participantProtocolService);
if (proxy2 == null)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message because 2PC proxy could not be created");
}
this.SendFault(result, this.state.Faults.InvalidParameters);
return;
}
try
{
ParticipantEnlistment participant = new ParticipantEnlistment(this.state, header, register.Protocol, proxy2);
this.state.TransactionManagerSend.Register(participant, new MsgRegisterEvent(participant, ref register, result));
return;
}
finally
{
proxy2.Release();
}
Label_0222:
Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Registration protocol should have been validated");
}
public TmCompletionRollbackResponseEvent(CompletionEnlistment completion, Status status) : base(completion, status)
{
}
public MsgCreateTransactionEvent(CompletionEnlistment completion, ref CreateCoordinationContext create, RequestAsyncResult result) : base(completion)
{
this.create = create;
this.result = result;
}
protected CompletionEvent(CompletionEnlistment completion) : base(completion)
{
this.completion = completion;
}
public CompletionStateMachine(CompletionEnlistment completion) : base(completion)
{
}
public static void CompletionRollbackResponse(Enlistment enlistment, Status status, object obj)
{
CompletionEnlistment completion = (CompletionEnlistment)obj;
completion.StateMachine.Enqueue(new TmCompletionRollbackResponseEvent(completion, status));
}
public TmCompletionCommitResponseEvent(CompletionEnlistment completion, Status status) : base(completion, status)
{
}
