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