public void Replay(Message message)
{
ProtocolVersionHelper.AssertProtocolVersion10(this.protocolVersion, typeof(TwoPhaseCommitCoordinatorDispatcher), "constr");
try
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Dispatching 2PC Replay message");
if (DebugTrace.Pii)
{
DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message));
}
}
ReplayMessage.ReadFrom(message, this.protocolVersion);
this.dispatch.Replay(message);
}
catch (CommunicationException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
base.OnMessageException(message, exception);
}
catch (Exception exception2)
{
DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} dispatching Replay message: {1}", exception2.GetType().Name, exception2);
Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception2);
}
}
public override void OnEvent(MsgReplayEvent e)
{
ProtocolVersionHelper.AssertProtocolVersion10(base.state.ProtocolVersion, typeof(DurableActive), "OnEvent(replay)");
ParticipantEnlistment participant = e.Participant;
base.state.TwoPhaseCommitCoordinator.SendRollback(participant);
base.state.TransactionManagerSend.Rollback(participant);
e.StateMachine.ChangeState(base.state.States.DurableAborted);
}
public void Replay(Message message)
{
ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, base.GetType(), "Replay");
ParticipantEnlistment participant = this.CheckMessage(message, true, true);
if (participant != null)
{
participant.StateMachine.Enqueue(new MsgReplayEvent(participant));
}
}
public static MessageSecurityVersion SecurityVersion(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(MessagingVersionHelper), "SecurityVersion");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(MessageSecurityVersion.WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11);
case ProtocolVersion.Version11:
return(MessageSecurityVersion.WSSecurity11WSTrust13WSSecureConversation13WSSecurityPolicy12);
}
return(null);
}
public static string InteropBindingQName(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "InteropBindingQName");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(InteropBindingQName10);
case ProtocolVersion.Version11:
return(InteropBindingQName11);
}
return(null);
}
public static IWSCompletionCoordinator Instance(CoordinationService service, ICompletionCoordinator dispatch)
{
ProtocolVersionHelper.AssertProtocolVersion(service.ProtocolVersion, typeof(CompletionCoordinatorDispatcher), "Instance");
switch (service.ProtocolVersion)
{
case ProtocolVersion.Version10:
return(new CompletionCoordinatorDispatcher10(service, dispatch));
case ProtocolVersion.Version11:
return(new CompletionCoordinatorDispatcher11(service, dispatch));
}
return(null);
}
public static IdentifierElement Instance(string identifier, ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(IdentifierElement), "V");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(new IdentifierElement10(identifier));
case ProtocolVersion.Version11:
return(new IdentifierElement11(identifier));
}
return(null);
}
private static SecurityStandardsManager CreateStandardsManager(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "CreateStandardsManager");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(SecurityStandardsManager.DefaultInstance);
case ProtocolVersion.Version11:
return(SecurityStandardsManager2007);
}
return(null);
}
public static CoordinationStrings Version(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationStrings), "V");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(CoordinationStrings10.Instance);
case ProtocolVersion.Version11:
return(CoordinationStrings11.Instance);
}
return(null);
}
public override void OnEvent(MsgReplayEvent e)
{
ProtocolVersionHelper.AssertProtocolVersion10(base.state.ProtocolVersion, typeof(DurablePreparing), "OnEvent(replay)");
ParticipantEnlistment participant = e.Participant;
if (DurableParticipantReplayWhilePreparingRecord.ShouldTrace)
{
DurableParticipantReplayWhilePreparingRecord.Trace(participant.EnlistmentId, participant.Enlistment.RemoteTransactionId);
}
base.state.TwoPhaseCommitCoordinator.SendRollback(participant);
base.state.TransactionManagerSend.Aborted(participant);
e.StateMachine.ChangeState(base.state.States.DurableAborted);
}
public static Message CreateRecoverMessage(MessageVersion version, ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(NotificationMessage), "CreateRecoverMessage");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(new ReplayMessage(version, protocolVersion));
case ProtocolVersion.Version11:
return(new PreparedMessage(version, protocolVersion));
}
return(null);
}
public static string TwoPhaseCommitCoordinatorSuffix(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "TwoPhaseCommitCoordinatorSuffix");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return("TwoPhaseCommit/Coordinator/");
case ProtocolVersion.Version11:
return("TwoPhaseCommit/Coordinator11/");
}
return(null);
}
public static IWSTwoPhaseCommitCoordinator Instance(CoordinationService service, ITwoPhaseCommitCoordinator dispatch)
{
ProtocolVersionHelper.AssertProtocolVersion(service.ProtocolVersion, typeof(TwoPhaseCommitCoordinatorDispatcher), "V");
switch (service.ProtocolVersion)
{
case ProtocolVersion.Version10:
return(new TwoPhaseCommitCoordinatorDispatcher10(service, dispatch));
case ProtocolVersion.Version11:
return(new TwoPhaseCommitCoordinatorDispatcher11(service, dispatch));
}
return(null);
}
public static System.ServiceModel.Channels.MessageVersion MessageVersion(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(MessagingVersionHelper), "MessageVersion");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(System.ServiceModel.Channels.MessageVersion.Soap11WSAddressingAugust2004);
case ProtocolVersion.Version11:
return(System.ServiceModel.Channels.MessageVersion.Soap11WSAddressing10);
}
return(null);
}
public static string RegistrationCoordinatorSuffix(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "RegistrationCoordinatorSuffix");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return("Registration/Coordinator/");
case ProtocolVersion.Version11:
return("Registration/Coordinator11/");
}
return(null);
}
public static string CompletionParticipantSuffix(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "CompletionParticipantSuffix");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return("Completion/Participant/");
case ProtocolVersion.Version11:
return("Completion/Participant11/");
}
return(null);
}
public static Faults Version(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(Faults), "V");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(Faults10.Instance);
case ProtocolVersion.Version11:
return(Faults11.Instance);
}
return(null);
}
public static EndpointAddress GetFaultToHeader(MessageHeaders headers, ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(Library), "GetFaultToHeader");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(GetFaultToHeader10(headers));
case ProtocolVersion.Version11:
return(GetFaultToHeader11(headers));
}
return(null);
}
public static string StandardParticipantAddressPath(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(WsATv1LogEntrySerializer), "StandardParticipantAddressPath");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(standardParticipantAddressPath10);
case ProtocolVersion.Version11:
return(standardParticipantAddressPath11);
}
return(null);
}
public static AtomicTransactionXmlDictionaryStrings Version(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(AtomicTransactionXmlDictionaryStrings), "V");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(AtomicTransactionXmlDictionaryStrings10.Instance);
case ProtocolVersion.Version11:
return(AtomicTransactionXmlDictionaryStrings11.Instance);
}
return(null);
}
private static DataContractSerializer IdentifierElementSerializer(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "IdentifierElementSerializer");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
if (identifierElementSerializer10 == null)
{
identifierElementSerializer10 = new DataContractSerializer(typeof(IdentifierElement10));
}
return(identifierElementSerializer10);
case ProtocolVersion.Version11:
if (identifierElementSerializer11 == null)
{
identifierElementSerializer11 = new DataContractSerializer(typeof(IdentifierElement11));
}
return(identifierElementSerializer11);
}
return(null);
}
public static void CreateIssuedToken(Guid transactionId, string coordinationContextId, ProtocolVersion protocolVersion, out RequestSecurityTokenResponse issuedToken, out string sctId)
{
sctId = CoordinationContext.CreateNativeIdentifier(Guid.NewGuid());
byte[] key = DeriveIssuedTokenKey(transactionId, sctId);
DateTime utcNow = DateTime.UtcNow;
SecurityContextSecurityToken token = new SecurityContextSecurityToken(new UniqueId(sctId), key, utcNow, utcNow + TimeSpan.FromDays(36500.0));
BinarySecretSecurityToken token2 = new BinarySecretSecurityToken(key);
SecurityStandardsManager standardsManager = CreateStandardsManager(protocolVersion);
RequestSecurityTokenResponse response = new RequestSecurityTokenResponse(standardsManager)
{
TokenType = standardsManager.SecureConversationDriver.TokenTypeUri,
RequestedUnattachedReference = SecurityContextSecurityTokenParameters.CreateKeyIdentifierClause(token, SecurityTokenReferenceStyle.External),
RequestedAttachedReference = SecurityContextSecurityTokenParameters.CreateKeyIdentifierClause(token, SecurityTokenReferenceStyle.Internal),
RequestedSecurityToken = token,
RequestedProofToken = token2
};
DataContractSerializer serializer = IdentifierElementSerializer(protocolVersion);
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "CreateIssuedToken");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
response.SetAppliesTo <IdentifierElement10>(new IdentifierElement10(coordinationContextId), serializer);
break;
case ProtocolVersion.Version11:
response.SetAppliesTo <IdentifierElement11>(new IdentifierElement11(coordinationContextId), serializer);
break;
}
response.MakeReadOnly();
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Created issued token with id {0} for transaction {1}", sctId, transactionId);
}
issuedToken = response;
}
public static void SetReplyAddress(Message message, EndpointAddress replyTo, ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(MessagingVersionHelper), "SetReplyAddress");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
if (message.Headers.ReplyTo == null)
{
message.Headers.ReplyTo = replyTo;
}
if (message.Headers.MessageId == null)
{
message.Headers.MessageId = new UniqueId();
}
return;
case ProtocolVersion.Version11:
if (message.Headers.From == null)
{
message.Headers.From = replyTo;
}
return;
}
}
public ActivationCoordinatorDispatcher10(CoordinationService service, IActivationCoordinator dispatch)
{
ProtocolVersionHelper.AssertProtocolVersion10(service.ProtocolVersion, typeof(ActivationCoordinatorDispatcher10), "constr");
this.activationCoordinatorDispatcher = new ActivationCoordinatorDispatcher(service, dispatch);
}
public TwoPhaseCommitCoordinatorDispatcher11(CoordinationService service, ITwoPhaseCommitCoordinator dispatch)
{
ProtocolVersionHelper.AssertProtocolVersion11(service.ProtocolVersion, typeof(TwoPhaseCommitCoordinatorDispatcher11), "constr");
this.twoPhaseCommitCoordinatorDispatcher = new TwoPhaseCommitCoordinatorDispatcher(service, dispatch);
}
public override void OnEvent(MsgReplayEvent e)
{
ProtocolVersionHelper.AssertProtocolVersion10(base.state.ProtocolVersion, typeof(DurableRejoined), "OnEvent(replay)");
}
protected override void SerializeExtended()
{
Guid guid;
DebugTrace.TraceEnter(this, "SerializeExtended");
WsATv1LogEntryFlags flags = 0;
WsATv1LogEntryFlags pathFlags = 0;
EndpointAddress endpoint = base.logEntry.Endpoint;
Uri uri = endpoint.Uri;
if (GetRemoteEnlistmentId(endpoint, out guid))
{
flags = (WsATv1LogEntryFlags)((byte)(flags | WsATv1LogEntryFlags.OptimizedEndpointRepresentation));
if (string.Compare(uri.Scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) != 0)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Endpoints must use the HTTPS scheme");
}
if (0x944 == uri.Port)
{
flags = (WsATv1LogEntryFlags)((byte)(flags | WsATv1LogEntryFlags.UsesDefaultPort));
}
pathFlags = GetPathFlags(endpoint, this.protocolVersion);
flags = (WsATv1LogEntryFlags)((byte)(flags | pathFlags));
}
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "SerializeExtended flags: {0}", flags);
}
byte num = 0;
ProtocolVersionHelper.AssertProtocolVersion(this.protocolVersion, base.GetType(), "SerializeExtended");
switch (this.protocolVersion)
{
case ProtocolVersion.Version10:
num = 1;
break;
case ProtocolVersion.Version11:
num = 2;
break;
}
base.mem.WriteByte(num);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote version: {0} bytes", base.mem.Length);
}
base.mem.WriteByte((byte)flags);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote flags: {0} bytes", base.mem.Length);
}
if (((byte)(flags & WsATv1LogEntryFlags.OptimizedEndpointRepresentation)) == 0)
{
SerializationUtils.WriteEndpointAddress(base.mem, endpoint, this.protocolVersion);
}
else
{
SerializationUtils.WriteGuid(base.mem, ref guid);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote enlistmentId: {0} bytes", base.mem.Length);
}
SerializationUtils.WriteString(base.mem, uri.Host);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote hostName: {0} bytes", base.mem.Length);
}
if (((byte)(flags & WsATv1LogEntryFlags.UsesDefaultPort)) == 0)
{
if ((uri.Port < 0) || (uri.Port > 0xffff))
{
Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("TCP port must be valid");
}
SerializationUtils.WriteInt(base.mem, uri.Port);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote port: {0} bytes", base.mem.Length);
}
}
if (((int)pathFlags) == 0)
{
SerializationUtils.WriteString(base.mem, uri.AbsolutePath);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote address path: {0} bytes", base.mem.Length);
}
}
}
DebugTrace.TraceLeave(this, "DeserializeExtended");
}
public override void OnEvent(MsgReplayEvent e)
{
ProtocolVersionHelper.AssertProtocolVersion10(base.state.ProtocolVersion, typeof(DurableCommitting), "OnEvent(replay)");
base.state.TwoPhaseCommitCoordinator.SendCommit(e.Participant);
}
public static RequestSecurityTokenResponse GetIssuedToken(Message message, string identifier, ProtocolVersion protocolVersion)
{
ICollection <RequestSecurityTokenResponse> is2 = TransactionFlowProperty.TryGetIssuedTokens(message);
if (is2 == null)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "No issued tokens found in message");
}
return(null);
}
string str = CoordinationStrings.Version(protocolVersion).Identifier;
string str2 = CoordinationStrings.Version(protocolVersion).Namespace;
foreach (RequestSecurityTokenResponse response in is2)
{
string str3;
string str4;
response.GetAppliesToQName(out str3, out str4);
if ((str3 == str) && (str4 == str2))
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Found issued token in message");
}
try
{
IdentifierElement appliesTo = null;
DataContractSerializer serializer = IdentifierElementSerializer(protocolVersion);
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "GetIssuedToken");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
appliesTo = response.GetAppliesTo <IdentifierElement10>(serializer);
break;
case ProtocolVersion.Version11:
appliesTo = response.GetAppliesTo <IdentifierElement11>(serializer);
break;
}
if (!(appliesTo.Identifier != identifier))
{
return(response);
}
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Issued token identifier does not match expected {0}", identifier);
}
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(Microsoft.Transactions.SR.GetString("IssuedTokenIdentifierMismatch")));
}
catch (SerializationException exception)
{
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Issued token AppliesTo element could not be deserialized: {0}", exception.Message);
}
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(exception.Message, exception));
}
return(response);
}
}
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "No matching issued token found in message");
}
return(null);
}
public CompletionCoordinatorDispatcher10(CoordinationService service, ICompletionCoordinator dispatch)
{
ProtocolVersionHelper.AssertProtocolVersion10(service.ProtocolVersion, typeof(CompletionCoordinatorDispatcher10), "constr");
this.completionCoordinatorDispatcher = new CompletionCoordinatorDispatcher(service, dispatch);
}
