public void Rollback(Message message) { try { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching completion Rollback message"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } RollbackMessage.ReadFrom(message, this.service.ProtocolVersion); this.dispatch.Rollback(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 completion Rollback message: {1}", exception2.GetType().Name, exception2); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception2); } }
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); } }
private void Fault(Message message) { try { MessageFault fault = MessageFault.CreateFault(message, 0x10000); if (DebugTrace.Verbose) { FaultCode baseFaultCode = Library.GetBaseFaultCode(fault); DebugTrace.Trace(TraceLevel.Verbose, "Dispatching participant completion fault {0}", (baseFaultCode == null) ? "unknown" : baseFaultCode.Name); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } this.dispatch.Fault(message, fault); } 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 completion fault from participant: {1}", exception2.GetType().Name, exception2); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception2); } }
public RegisterResponse EndSendRegister(IAsyncResult ar) { RegisterResponse response; try { Message message = base.EndSendRequest(ar, base.coordinationStrings.RegisterResponseAction); using (message) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching RegisterResponse reply"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } response = new RegisterResponse(message, base.protocolVersion); } } catch (CommunicationException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatReceiveFailureException(exception)); } return(response); }
public IAsyncResult BeginCreateCoordinationContext(Message message, AsyncCallback callback, object state) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching CreateCoordinationContext request"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result = new Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult(message, callback, state); try { this.dispatch.CreateCoordinationContext(message, result); } catch (InvalidMessageException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); base.OnMessageException(result, message, exception, Faults.Version(this.service.ProtocolVersion).InvalidParameters); } catch (CommunicationException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); base.OnMessageException(result, message, exception2, Faults.Version(this.service.ProtocolVersion).CreateContextDispatchFailed); } catch (Exception exception3) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} dispatching CreateCoordinationContext message: {1}", exception3.GetType().Name, exception3); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception3); } return(result); }
private SecurityContextSecurityToken DeriveToken(Guid transactionId, string tokenId) { byte[] key = CoordinationServiceSecurity.DeriveIssuedTokenKey(transactionId, tokenId); DateTime utcNow = DateTime.UtcNow; return(new SecurityContextSecurityToken(new UniqueId(tokenId), key, utcNow, utcNow + TimeSpan.FromMinutes(5.0))); }
public CreateCoordinationContext(Message message, Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion) : this(protocolVersion) { if (message.IsEmpty) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"))); } XmlDictionaryReader readerAtBodyContents = message.GetReaderAtBodyContents(); using (readerAtBodyContents) { this.ReadFrom(readerAtBodyContents); try { message.ReadFromBodyContentsToEnd(readerAtBodyContents); } catch (XmlException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception)); } } if (this.CurrentContext != null) { try { this.IssuedToken = CoordinationServiceSecurity.GetIssuedToken(message, this.CurrentContext.Identifier, protocolVersion); } catch (XmlException exception2) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(exception2.Message, exception2)); } } }
private RegisterMessage CreateRegisterMessage(ref Register register) { RegisterMessage message = new RegisterMessage(base.messageVersion, ref register); if (register.SupportingToken != null) { CoordinationServiceSecurity.AddSupportingToken(message, register.SupportingToken); } return(message); }
public static void SendCreateCoordinationContextResponse(Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result, ref CreateCoordinationContextResponse response) { Message message = new CreateCoordinationContextResponseMessage(result.MessageVersion, ref response); if (response.IssuedToken != null) { CoordinationServiceSecurity.AddIssuedToken(message, response.IssuedToken); } result.Finished(message); }
private CreateCoordinationContextMessage CreateCreateCoordinationContextMessage(ref CreateCoordinationContext create) { CreateCoordinationContextMessage message = new CreateCoordinationContextMessage(base.messageVersion, ref create); if (create.IssuedToken != null) { CoordinationServiceSecurity.AddIssuedToken(message, create.IssuedToken); } return(message); }
public RegisterResponse SendRegister(ref Register register) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Sending Register to {0}", base.to.Uri); } Message message = this.CreateRegisterMessage(ref register); Message message2 = base.SendRequest(message, base.coordinationStrings.RegisterResponseAction); using (message2) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching RegisterResponse reply"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message2)); } } return(new RegisterResponse(message2, base.protocolVersion)); } }
public CreateCoordinationContextResponse SendCreateCoordinationContext(ref CreateCoordinationContext create) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Sending CreateCoordinationContext to {0}", base.to.Uri); } Message message = this.CreateCreateCoordinationContextMessage(ref create); Message message2 = base.SendRequest(message, base.coordinationStrings.CreateCoordinationContextResponseAction); using (message2) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching CreateCoordinationContextResponse reply"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message2)); } } return(new CreateCoordinationContextResponse(message2, base.protocolVersion)); } }
private void TraceAccessCheckResult(bool result, MessageProperties messageProperties) { if (result) { if (DebugTrace.Info) { if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Info, "Access granted to {0} by global ACL", CoordinationServiceSecurity.GetSenderName(messageProperties)); } else { DebugTrace.Trace(TraceLevel.Info, "Access granted by global ACL"); } } } else if (DebugTrace.Warning) { if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Warning, "Access denied to {0} by global ACL", CoordinationServiceSecurity.GetSenderName(messageProperties)); } else { DebugTrace.Trace(TraceLevel.Warning, "Access denied by global ACL"); } } }
private void Initialize(CoordinationServiceConfiguration config) { DebugTrace.TraceEnter(this, "Initialize"); this.config = config; this.security = new CoordinationServiceSecurity(); if ((config.Mode == 0) || ((config.Mode & ~(CoordinationServiceMode.ProtocolService | CoordinationServiceMode.Formatter)) != 0)) { DiagnosticUtility.FailFast("Invalid CoordinationServiceMode"); } if ((config.Mode & CoordinationServiceMode.ProtocolService) == 0) { if (!string.IsNullOrEmpty(config.BasePath)) { DiagnosticUtility.FailFast("A base path must not be provided if protocol service mode is not enabled"); } if (!string.IsNullOrEmpty(config.HostName)) { DiagnosticUtility.FailFast("A hostname must not be provided if protocol service mode is not enabled"); } } else { if (string.IsNullOrEmpty(config.BasePath)) { DiagnosticUtility.FailFast("A base path must be provided if protocol service mode is enabled"); } if (string.IsNullOrEmpty(config.HostName)) { DiagnosticUtility.FailFast("A hostname must be provided if protocol service mode is enabled"); } if (config.X509Certificate == null) { DiagnosticUtility.FailFast("No authentication mechanism was provided for the protocol service"); } } this.globalAclAuthz = new GlobalAclOperationRequirement(config.GlobalAclWindowsIdentities, config.GlobalAclX509CertificateThumbprints, this.protocolVersion); if ((this.config.Mode & CoordinationServiceMode.ProtocolService) != 0) { this.httpsBaseAddressUri = new UriBuilder(Uri.UriSchemeHttps, this.config.HostName, this.config.HttpsPort, this.config.BasePath).Uri; this.namedPipeBaseAddressUri = new UriBuilder(Uri.UriSchemeNetPipe, "localhost", -1, this.config.HostName + "/" + this.config.BasePath).Uri; } this.namedPipeActivationBinding = new NamedPipeBinding(this.protocolVersion); if (this.config.RemoteClientsEnabled) { this.windowsActivationBinding = new WindowsRequestReplyBinding(this.protocolVersion); } this.interopDatagramBinding = new Microsoft.Transactions.Wsat.Messaging.InteropDatagramBinding(this.protocolVersion); this.interopRegistrationBinding = new Microsoft.Transactions.Wsat.Messaging.InteropRegistrationBinding(this.httpsBaseAddressUri, this.config.SupportingTokensEnabled, this.protocolVersion); this.interopActivationBinding = new Microsoft.Transactions.Wsat.Messaging.InteropActivationBinding(this.httpsBaseAddressUri, this.protocolVersion); ClientCredentials item = new ClientCredentials { ClientCertificate = { Certificate = this.config.X509Certificate }, ServiceCertificate = { DefaultCertificate = this.config.X509Certificate } }; if ((this.config.Mode & CoordinationServiceMode.ProtocolService) != 0) { this.interopDatagramChannelFactory = this.CreateChannelFactory <IDatagramService>(this.interopDatagramBinding); this.interopDatagramChannelFactory.Endpoint.Behaviors.Remove <ClientCredentials>(); this.interopDatagramChannelFactory.Endpoint.Behaviors.Add(item); this.OpenChannelFactory <IDatagramService>(this.interopDatagramChannelFactory); this.interopRegistrationChannelFactory = this.CreateChannelFactory <IRequestReplyService>(this.interopRegistrationBinding); this.interopRegistrationChannelFactory.Endpoint.Behaviors.Remove <ClientCredentials>(); this.interopRegistrationChannelFactory.Endpoint.Behaviors.Add(item); this.OpenChannelFactory <IRequestReplyService>(this.interopRegistrationChannelFactory); } if ((config.Mode & CoordinationServiceMode.Formatter) != 0) { if (this.config.X509Certificate != null) { this.interopActivationChannelFactory = this.CreateChannelFactory <IRequestReplyService>(this.interopActivationBinding); this.interopActivationChannelFactory.Endpoint.Behaviors.Remove <ClientCredentials>(); this.interopActivationChannelFactory.Endpoint.Behaviors.Add(item); this.OpenChannelFactory <IRequestReplyService>(this.interopActivationChannelFactory); } this.namedPipeActivationChannelFactory = this.CreateChannelFactory <IRequestReplyService>(this.namedPipeActivationBinding); this.OpenChannelFactory <IRequestReplyService>(this.namedPipeActivationChannelFactory); if (this.config.RemoteClientsEnabled) { this.windowsActivationChannelFactory = this.CreateChannelFactory <IRequestReplyService>(this.windowsActivationBinding); this.OpenChannelFactory <IRequestReplyService>(this.windowsActivationChannelFactory); } } this.requestReplyChannelCache = new ChannelMruCache <IRequestReplyService>(); if ((this.config.Mode & CoordinationServiceMode.ProtocolService) != 0) { this.datagramChannelCache = new ChannelMruCache <IDatagramService>(); } DebugTrace.TraceLeave(this, "Initialize"); }