public VolatileTwoPhaseCommitCoordinatorEvent(VolatileCoordinatorEnlistment 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; }
public void OnEnlistPrePrepare(TmEnlistPrePrepareEvent e) { this.enlistPrePrepareEvent = e; if (this.volatileCoordinators == null) { this.volatileCoordinators = new List <VolatileCoordinatorEnlistment>(); } VolatileCoordinatorEnlistment item = new VolatileCoordinatorEnlistment(base.state, this); this.volatileCoordinators.Add(item); base.state.Lookup.AddEnlistment(item); if (this.registerVolatileCoordinator != null) { Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Duplicate EnlistPrePrepare from TM"); } this.registerVolatileCoordinator = item; }
public MsgVolatilePrepareEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator) { }
public MsgRegisterVolatileResponseEvent(VolatileCoordinatorEnlistment volatileCoordinator, RegisterResponse response, TwoPhaseCommitCoordinatorProxy proxy) : base(volatileCoordinator, response, proxy) { this.volatileCoordinator = volatileCoordinator; }
protected VolatileCoordinatorEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator) { this.coordinator = coordinator; }
public MsgVolatileRollbackEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator) { }
private void OnVolatileSendComplete(IAsyncResult ar, VolatileCoordinatorEnlistment volatileCoordinator) { Exception exception = null; try { volatileCoordinator.CoordinatorProxy.EndSendMessage(ar); } catch (WsatSendFailureException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); DebugTrace.TraceSendFailure(volatileCoordinator.EnlistmentId, exception2); this.state.Perf.MessageSendFailureCountPerInterval.Increment(); exception = exception2; } if (exception != null) { volatileCoordinator.StateMachine.Enqueue(new MsgVolatileCoordinatorSendFailureEvent(volatileCoordinator)); } }
public void SendVolatileRegister(VolatileCoordinatorEnlistment volatileCoordinator) { this.SendRegister(volatileCoordinator.Coordinator, ControlProtocol.Volatile2PC, volatileCoordinator.ParticipantService, this.sendVolatileRegisterComplete, volatileCoordinator); }
public TmPrePrepareResponseEvent(VolatileCoordinatorEnlistment coordinator, Status status) : base(coordinator, status) { }
public MsgVolatileCoordinatorSendFailureEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator) { }
public void PrePrepare(VolatileCoordinatorEnlistment volatileCoordinator) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, volatileCoordinator.EnlistmentId, "Sending PrePrepare to transaction manager"); } this.coordination.PrePrepare(volatileCoordinator.Enlistment, this.prePrepareResponseCallback, volatileCoordinator); }
protected VolatileCoordinatorFaultEvent(VolatileCoordinatorEnlistment coordinator, MessageFault fault) : base(coordinator) { this.fault = fault; }
public void SendVolatileReadOnly(VolatileCoordinatorEnlistment coordinator) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending ReadOnly to volatile coordinator at {0}", Ports.TryGetAddress(coordinator.CoordinatorProxy)); } IAsyncResult ar = coordinator.CoordinatorProxy.BeginSendReadOnly(this.volatileSendComplete, coordinator); if (ar.CompletedSynchronously) { this.OnVolatileSendComplete(ar, coordinator); } }
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; }
protected VolatileCoordinatorStatusEvent(VolatileCoordinatorEnlistment coordinator, Microsoft.Transactions.Bridge.Status status) : base(coordinator) { this.status = status; }
public MsgVolatileCoordinatorFaultEvent(VolatileCoordinatorEnlistment coordinator, MessageFault fault) : base(coordinator, fault) { }
public MsgVolatileCommitEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator) { }
protected void TrySendAborted(VolatileCoordinatorEnlistment coordinator) { if (coordinator.CoordinatorProxy != null) { this.state.TwoPhaseCommitParticipant.SendVolatileAborted(coordinator); } }
public void OnEnlistPrePrepare(TmEnlistPrePrepareEvent e) { this.enlistPrePrepareEvent = e; if (this.volatileCoordinators == null) { this.volatileCoordinators = new List<VolatileCoordinatorEnlistment>(); } VolatileCoordinatorEnlistment item = new VolatileCoordinatorEnlistment(base.state, this); this.volatileCoordinators.Add(item); base.state.Lookup.AddEnlistment(item); if (this.registerVolatileCoordinator != null) { Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Duplicate EnlistPrePrepare from TM"); } this.registerVolatileCoordinator = item; }