public VolatileCoordinatorEnlistment(ProtocolState state, CoordinatorEnlistment coordinator) : base(state) { this.coordinator = coordinator; base.enlistment = this.coordinator.Enlistment; base.stateMachine = this.coordinator.StateMachine; base.CreateParticipantService(); }
public VolatileCoordinatorEnlistment(ProtocolState state, CoordinatorEnlistment coordinator) : base(state) { this.coordinator = coordinator; base.enlistment = this.coordinator.Enlistment; base.stateMachine = this.coordinator.StateMachine; base.CreateParticipantService(); }
public DurableTwoPhaseCommitCoordinatorEvent(CoordinatorEnlistment coordinator) : base(coordinator) { MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders; this.faultTo = Library.GetFaultToHeader(incomingMessageHeaders, base.state.ProtocolVersion); this.replyTo = Library.GetReplyToHeader(incomingMessageHeaders); this.messageID = incomingMessageHeaders.MessageId; }
private void OnSendRegisterComplete(CoordinatorEnlistment coordinator, ControlProtocol protocol, IAsyncResult ar) { SynchronizationEvent event2; EndpointAddress to = null; try { RegisterResponse response = coordinator.RegistrationProxy.EndSendRegister(ar); to = response.CoordinatorProtocolService; TwoPhaseCommitCoordinatorProxy proxy = this.state.TryCreateTwoPhaseCommitCoordinatorProxy(to); if (proxy == null) { if (RegistrationCoordinatorResponseInvalidMetadataRecord.ShouldTrace) { RegistrationCoordinatorResponseInvalidMetadataRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, to, null, this.state.ProtocolVersion); } event2 = new MsgRegistrationCoordinatorSendFailureEvent(coordinator); } else { try { if (protocol == ControlProtocol.Durable2PC) { event2 = new MsgRegisterDurableResponseEvent(coordinator, response, proxy); } else { VolatileCoordinatorEnlistment asyncState = (VolatileCoordinatorEnlistment) ar.AsyncState; event2 = new MsgRegisterVolatileResponseEvent(asyncState, response, proxy); } } finally { proxy.Release(); } } } catch (WsatFaultException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); event2 = new MsgRegistrationCoordinatorFaultEvent(coordinator, protocol, exception.Fault); if (RegistrationCoordinatorFaultedRecord.ShouldTrace) { RegistrationCoordinatorFaultedRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, exception.Fault); } } catch (WsatMessagingException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); this.state.Perf.MessageSendFailureCountPerInterval.Increment(); if (RegistrationCoordinatorFailedRecord.ShouldTrace) { RegistrationCoordinatorFailedRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, exception2); } DebugTrace.TraceSendFailure(coordinator.EnlistmentId, exception2); event2 = new MsgRegistrationCoordinatorSendFailureEvent(coordinator); } coordinator.StateMachine.Enqueue(event2); }
public void Aborted(CoordinatorEnlistment coordinator) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Replying Aborted to transaction manager"); } coordinator.DeliverCallback(Status.Aborted); }
public void Commit(CoordinatorEnlistment coordinator) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending Commit to transaction manager"); } this.coordination.Commit(coordinator.Enlistment, this.commitResponseCallback, coordinator); }
public override void OnEvent(TransactionContextEnlistTransactionEvent e) { e.ContextManager.Requests.Enqueue(e); e.StateMachine.ChangeState(base.state.States.TransactionContextInitializingCoordinator); CoordinatorEnlistment coordinator = new CoordinatorEnlistment(base.state, e.ContextManager, e.Body.CurrentContext, e.Body.IssuedToken); CreateCoordinationContext body = e.Body; MsgEnlistTransactionEvent event2 = new MsgEnlistTransactionEvent(coordinator, ref body, e.Result); coordinator.StateMachine.Enqueue(event2); }
public void EnqueueRecoveryReplay(TmReplayEvent e) { if (!this.recovering) { Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Cannot enqueue recovery event outside of recovery"); } if (DebugTrace.Info) { CoordinatorEnlistment coordinator = e.Coordinator; DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Enqueuing recovery replay for coordinator at {0}", Ports.TryGetAddress(coordinator.CoordinatorProxy)); } this.recoveryQueue.Enqueue(e); }
public void SendDurableRegister(CoordinatorEnlistment coordinator) { this.SendRegister(coordinator, ControlProtocol.Durable2PC, coordinator.ParticipantService, this.sendDurableRegisterComplete, coordinator); }
protected CoordinatorEvent(CoordinatorEnlistment coordinator) : base(coordinator) { this.coordinator = coordinator; }
public MsgRegistrationCoordinatorFaultEvent(CoordinatorEnlistment coordinator, ControlProtocol protocol, MessageFault fault) : base(coordinator, fault) { this.protocol = protocol; }
public void SendRecoverMessage(CoordinatorEnlistment coordinator) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending Replay to durable coordinator at {0}", Ports.TryGetAddress(coordinator.CoordinatorProxy)); } IAsyncResult ar = coordinator.CoordinatorProxy.BeginSendRecoverMessage(this.durableSendComplete, coordinator); if (ar.CompletedSynchronously) { this.OnDurableSendComplete(ar, coordinator); } }
public MsgEnlistTransactionEvent(CoordinatorEnlistment coordinator, ref CreateCoordinationContext create, RequestAsyncResult result) : base(coordinator) { this.create = create; this.result = result; }
public MsgDurablePrepareEvent(CoordinatorEnlistment coordinator) : base(coordinator) { }
public CoordinatorStateMachine(CoordinatorEnlistment coordinator) : base(coordinator) { this.coordinator = coordinator; }
public void EnlistPrePrepareResponse(CoordinatorEnlistment coordinator, Status status) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Replying {0} to transaction manager's EnlistPrePrepare", status); } coordinator.DeliverCallback(status); }
private bool CheckMessage(Message message, bool fault, out CoordinatorEnlistment durableCoordinator, out VolatileCoordinatorEnlistment volatileCoordinator) { Guid guid; TwoPhaseCommitCoordinatorProxy coordinatorProxy; durableCoordinator = null; volatileCoordinator = null; if (!Ports.TryGetEnlistment(message, out guid)) { DebugTrace.Trace(TraceLevel.Warning, "Could not read enlistment header from message"); if (fault) { this.SendFault(message, this.state.Faults.InvalidParameters); } return false; } Microsoft.Transactions.Wsat.Protocol.TransactionEnlistment enlistment = this.state.Lookup.FindEnlistment(guid); if (enlistment == null) { DebugTrace.Trace(TraceLevel.Warning, "Could not find enlistment {0}", guid); return true; } durableCoordinator = enlistment as CoordinatorEnlistment; if (durableCoordinator == null) { volatileCoordinator = enlistment as VolatileCoordinatorEnlistment; if (volatileCoordinator == null) { DebugTrace.Trace(TraceLevel.Warning, "2PC message received for non-2PC enlistment {0}", guid); if (fault) { this.SendFault(message, this.state.Faults.InvalidParameters); } return false; } coordinatorProxy = volatileCoordinator.CoordinatorProxy; } else { coordinatorProxy = durableCoordinator.CoordinatorProxy; } if (coordinatorProxy == null) { if ((durableCoordinator != null) && object.ReferenceEquals(durableCoordinator.StateMachine.State, this.state.States.CoordinatorFailedRecovery)) { DebugTrace.TxTrace(TraceLevel.Warning, enlistment.EnlistmentId, "Coordinator enlistment was not correctly recovered"); if (fault) { this.SendFault(message, this.state.Faults.InvalidPolicy); } return false; } if (DebugTrace.Warning) { DebugTrace.TxTrace(TraceLevel.Warning, enlistment.EnlistmentId, "Received premature message with action {0}", message.Headers.Action); } if (fault) { this.SendFault(message, this.state.Faults.InvalidState); } return false; } if (this.state.Service.Security.CheckIdentity(coordinatorProxy, message)) { return true; } if (EnlistmentIdentityCheckFailedRecord.ShouldTrace) { EnlistmentIdentityCheckFailedRecord.Trace(enlistment.EnlistmentId); } return false; }
public TimerCoordinatorEvent(CoordinatorEnlistment coordinator, TimerProfile profile) : base(coordinator) { this.profile = profile; }
public TmPrepareResponseEvent(CoordinatorEnlistment coordinator, Status status) : base(coordinator, status) { }
public void Replayed(CoordinatorEnlistment coordinator) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Replying Success to transaction manager's Replay"); } coordinator.DeliverCallback(Status.Success); }
public void Prepare(CoordinatorEnlistment coordinator) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending Prepare to transaction manager"); } this.coordination.Prepare(coordinator.Enlistment, this.prepareResponseCallback, coordinator); }
public void EnlistTransaction(CoordinatorEnlistment coordinator, EnlistmentOptions options, MsgEnlistTransactionEvent e) { DebugTrace.Trace(TraceLevel.Info, "Sending CreateSuperiorEnlistment to transaction manager"); this.propagation.CreateSuperiorEnlistment(coordinator.Enlistment, options, this.enlistTransactionResponseCallback, e); }
private void SendRegister(CoordinatorEnlistment coordinator, ControlProtocol protocol, EndpointAddress protocolService, AsyncCallback callback, object callbackState) { Register register = new Register(this.state.ProtocolVersion) { Protocol = protocol, Loopback = this.state.ProcessId, ParticipantProtocolService = protocolService, SupportingToken = coordinator.SuperiorIssuedToken }; if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending Register for {0} to {1}", protocol, Ports.TryGetAddress(coordinator.RegistrationProxy)); } IAsyncResult ar = coordinator.RegistrationProxy.BeginSendRegister(ref register, callback, callbackState); if (ar.CompletedSynchronously) { this.OnSendRegisterComplete(coordinator, protocol, ar); } }
public MsgRegistrationCoordinatorSendFailureEvent(CoordinatorEnlistment coordinator) : base(coordinator) { }
public MsgDurableCoordinatorSendFailureEvent(CoordinatorEnlistment coordinator) : base(coordinator) { }
public MsgDurableRollbackEvent(CoordinatorEnlistment coordinator) : base(coordinator) { }
protected void TrySendAborted(CoordinatorEnlistment coordinator) { if (coordinator.CoordinatorProxy != null) { this.state.TwoPhaseCommitParticipant.SendDurableAborted(coordinator); } }
public TmCommitResponseEvent(CoordinatorEnlistment coordinator, Status status) : base(coordinator, status) { }
protected CoordinatorFaultEvent(CoordinatorEnlistment coordinator, MessageFault fault) : base(coordinator) { this.fault = fault; }
public MsgDurableCoordinatorFaultEvent(CoordinatorEnlistment coordinator, MessageFault fault) : base(coordinator, fault) { }
public MsgRegisterDurableResponseEvent(CoordinatorEnlistment coordinator, RegisterResponse response, TwoPhaseCommitCoordinatorProxy proxy) : base(coordinator, response, proxy) { this.coordinator = coordinator; }
public TmReplayEvent(CoordinatorEnlistment coordinator, ProtocolProviderCallback callback, object state) : base(coordinator, callback, state) { }