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) { }