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