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 TrySendFault(DatagramProxy proxy, UniqueId messageID, Fault fault) { if (proxy == null) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Could not create a proxy to send {0} fault", fault.Code.Name); } } else { this.state.Perf.FaultsSentCountPerInterval.Increment(); if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Sending {0} fault to {1}", fault.Code.Name, Ports.TryGetAddress(proxy)); } IAsyncResult ar = proxy.BeginSendFault(messageID, fault, this.sendFaultComplete, proxy); if (ar.CompletedSynchronously) { this.OnSendFaultComplete(ar, proxy); } } }
public void Fault(Message message, MessageFault fault) { if (this.CheckMessage(message, false) != null) { this.state.Perf.FaultsReceivedCountPerInterval.Increment(); } if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Ignoring {0} fault from completion participant at {1}: {2}", Library.GetFaultCodeName(fault), Ports.TryGetFromAddress(message), Library.GetFaultCodeReason(fault)); } }
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); } }
public void SendCommitted(EndpointAddress sendTo) { if (sendTo != null) { CompletionParticipantProxy proxy = this.state.TryCreateCompletionParticipantProxy(sendTo); if (proxy != null) { try { if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Sending Committed to unrecognized completion participant at {0}", Ports.TryGetAddress(proxy)); } IAsyncResult ar = proxy.BeginSendCommitted(this.politeSendComplete, proxy); if (ar.CompletedSynchronously) { this.OnSendComplete(ar, null, proxy); } } finally { proxy.Release(); } } } }
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 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); }
public void SendReadOnly(EndpointAddress sendTo) { if (sendTo != null) { TwoPhaseCommitCoordinatorProxy proxy = this.state.TryCreateTwoPhaseCommitCoordinatorProxy(sendTo); if (proxy != null) { try { if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Sending ReadOnly to unrecognized participant at {0}", Ports.TryGetAddress(proxy)); } IAsyncResult ar = proxy.BeginSendReadOnly(this.politeSendComplete, proxy); if (ar.CompletedSynchronously) { this.OnPoliteSendComplete(ar, proxy); } } finally { proxy.Release(); } } } }
public void Fault(Message message, MessageFault fault) { CoordinatorEnlistment enlistment; VolatileCoordinatorEnlistment enlistment2; if (this.CheckMessage(message, false, out enlistment, out enlistment2)) { if (enlistment != null) { enlistment.StateMachine.Enqueue(new MsgDurableCoordinatorFaultEvent(enlistment, fault)); } else if (enlistment2 != null) { enlistment2.StateMachine.Enqueue(new MsgVolatileCoordinatorFaultEvent(enlistment2, fault)); } else if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Ignoring {0} fault from unrecognized coordinator at {1}: {2}", Library.GetFaultCodeName(fault), Ports.TryGetFromAddress(message), Library.GetFaultCodeReason(fault)); } this.state.Perf.FaultsReceivedCountPerInterval.Increment(); } }
private ParticipantEnlistment CheckMessage(Message message, bool fault, bool preparedOrReplay) { Guid guid; ControlProtocol protocol; if (!Ports.TryGetEnlistment(message, out guid, out protocol)) { DebugTrace.Trace(TraceLevel.Warning, "Could not read enlistment header from message"); if (fault) { 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.Verbose, "Enlistment {0} could not be found", guid); if (preparedOrReplay) { if (protocol == ControlProtocol.Volatile2PC) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Received Prepared or Replay from unrecognized volatile participant at {0}", Ports.TryGetFromAddress(message)); } if (VolatileParticipantInDoubtRecord.ShouldTrace) { VolatileParticipantInDoubtRecord.Trace(guid, Library.GetReplyToHeader(message.Headers), this.state.ProtocolVersion); } this.SendFault(message, this.state.Faults.UnknownTransaction); } else if (protocol == ControlProtocol.Durable2PC) { this.SendRollback(message); } else { this.SendFault(message, this.state.Faults.InvalidParameters); } } else if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Ignoring message from unrecognized participant at {0}", Ports.TryGetFromAddress(message)); } return(null); } ParticipantEnlistment enlistment2 = enlistment as ParticipantEnlistment; if ((enlistment2 == null) || (protocol != enlistment2.ControlProtocol)) { DebugTrace.Trace(TraceLevel.Warning, "Enlistment state does not match message for {0}", guid); if (fault) { this.SendFault(message, this.state.Faults.InvalidParameters); } return(null); } if (enlistment2.ParticipantProxy == null) { DebugTrace.TxTrace(TraceLevel.Warning, enlistment2.EnlistmentId, "Participant enlistment was not correctly recovered"); if (fault) { this.SendFault(message, this.state.Faults.InvalidPolicy); } return(null); } if (this.state.Service.Security.CheckIdentity(enlistment2.ParticipantProxy, message)) { return(enlistment2); } if (EnlistmentIdentityCheckFailedRecord.ShouldTrace) { EnlistmentIdentityCheckFailedRecord.Trace(enlistment2.EnlistmentId); } return(null); }
public void SendRollback(EndpointAddress sendTo) { if (sendTo != null) { TwoPhaseCommitParticipantProxy proxy = this.state.TryCreateTwoPhaseCommitParticipantProxy(sendTo); if (proxy != null) { try { if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Sending Rollback to unrecognized participant at {0}", Ports.TryGetAddress(proxy)); } proxy.From = this.CreateForgottenSource(); IAsyncResult ar = proxy.BeginSendRollback(this.politeSendComplete, proxy); if (ar.CompletedSynchronously) { this.OnPoliteSendComplete(ar, proxy); } } finally { proxy.Release(); } } } }
public void SendRollback(ParticipantEnlistment participant) { if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Sending Rollback to {0} participant at {1}", participant.ControlProtocol, Ports.TryGetAddress(participant.ParticipantProxy)); } IAsyncResult ar = participant.ParticipantProxy.BeginSendRollback(this.sendComplete, participant); if (ar.CompletedSynchronously) { this.OnSendComplete(ar, participant); } }
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); } }