public void Cleanup()
{
DebugTrace.TraceEnter(this, "Cleanup");
if (this.namedPipeActivationChannelFactory != null)
{
this.CloseChannelFactory(this.namedPipeActivationChannelFactory);
this.namedPipeActivationChannelFactory = null;
}
if (this.windowsActivationChannelFactory != null)
{
this.CloseChannelFactory(this.windowsActivationChannelFactory);
this.windowsActivationChannelFactory = null;
}
if (this.interopDatagramChannelFactory != null)
{
this.CloseChannelFactory(this.interopDatagramChannelFactory);
this.interopDatagramChannelFactory = null;
}
if (this.interopRegistrationChannelFactory != null)
{
this.CloseChannelFactory(this.interopRegistrationChannelFactory);
this.interopRegistrationChannelFactory = null;
}
if (this.interopActivationChannelFactory != null)
{
this.CloseChannelFactory(this.interopActivationChannelFactory);
this.interopActivationChannelFactory = null;
}
DebugTrace.TraceLeave(this, "Cleanup");
}
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);
}
}
protected void OnReceive(Message message)
{
DebugTrace.TraceEnter(this, "OnReceive");
if ((message != null) && !this.tokenResolver.FaultInSupportingToken(message))
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Failed to fault in SCT for supporting token signature");
}
Fault invalidParameters = Faults.Version(this.protocolVersion).InvalidParameters;
if (message.Headers.MessageId != null)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Attempting to send {0} fault", invalidParameters.Code.Name);
}
Message reply = Library.CreateFaultMessage(message.Headers.MessageId, message.Version, invalidParameters);
RequestReplyCorrelator.AddressReply(reply, new RequestReplyCorrelator.ReplyToInfo(message));
SendSecurityHeader header = SupportingTokenChannel <TChannel> .SecurityStandardsManager.CreateSendSecurityHeader(reply, string.Empty, true, false, SecurityAlgorithmSuite.Default, MessageDirection.Output);
header.RequireMessageProtection = false;
header.AddTimestamp(SecurityProtocolFactory.defaultTimestampValidityDuration);
reply = header.SetupExecution();
this.TrySendFaultReply(reply);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(Microsoft.Transactions.SR.GetString("SupportingTokenSignatureExpected")));
}
DebugTrace.TraceLeave(this, "OnReceive");
}
protected override void Close()
{
IChannel state = (IChannel)this.channel;
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Closing {0}", state.GetType().Name);
}
try
{
IAsyncResult result = state.BeginClose(Fx.ThunkCallback(new AsyncCallback(this.OnCloseComplete)), state);
if (result.CompletedSynchronously)
{
this.CloseComplete(result);
}
}
catch (CommunicationException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
DebugTrace.Trace(TraceLevel.Warning, "Exception {0} closing a proxy: {1}", exception.GetType().Name, exception.Message);
}
catch (TimeoutException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
DebugTrace.Trace(TraceLevel.Warning, "Exception {0} closing a proxy: {1}", exception2.GetType().Name, exception2.Message);
}
catch (Exception exception3)
{
DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} closing a proxy: {1}", exception3.GetType().Name, exception3);
Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception3);
}
}
private void TraceCheckIdentityResult(bool access, EndpointAddress service, Message message)
{
if (DebugTrace.Verbose)
{
if (DebugTrace.Pii)
{
string senderName = GetSenderName(message);
if (access)
{
DebugTrace.Trace(TraceLevel.Verbose, "Access granted by identity verifier to {0}", senderName);
}
else
{
DebugTrace.Trace(TraceLevel.Verbose, "Access denied by identity verifier to {0}, expected {1}", senderName, (service.Identity == null) ? service.Uri.AbsoluteUri : service.Identity.ToString());
}
}
else if (access)
{
DebugTrace.Trace(TraceLevel.Verbose, "Access granted by identity verifier");
}
else
{
DebugTrace.Trace(TraceLevel.Verbose, "Access denied by identity verifier");
}
}
}
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 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");
}
}
}
protected override void InitializeRuntime()
{
DebugTrace.TraceEnter(this, "OnCreateListeners");
base.InitializeRuntime();
if (base.SingletonInstance is IWSActivationCoordinator)
{
if (DebugTrace.Info)
{
for (int i = 0; i < base.ChannelDispatchers.Count; i++)
{
ChannelDispatcher dispatcher = base.ChannelDispatchers[i] as ChannelDispatcher;
if (dispatcher != null)
{
for (int j = 0; j < dispatcher.Endpoints.Count; j++)
{
EndpointDispatcher dispatcher2 = dispatcher.Endpoints[j];
DebugTrace.Trace(TraceLevel.Info, "Listening on {0}", dispatcher2.EndpointAddress.Uri);
}
}
}
}
}
else
{
this.CreateBaseEndpointAddress();
}
DebugTrace.TraceLeave(this, "OnCreateListeners");
}
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 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);
}
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);
}
private void CloseComplete(IAsyncResult result)
{
try
{
((IChannel)result.AsyncState).EndClose(result);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Closed {0}", base.GetType().Name);
}
}
catch (CommunicationException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
DebugTrace.Trace(TraceLevel.Warning, "Exception {0} closing a proxy: {1}", exception.GetType().Name, exception.Message);
}
catch (TimeoutException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
DebugTrace.Trace(TraceLevel.Warning, "Exception {0} closing a proxy: {1}", exception2.GetType().Name, exception2.Message);
}
catch (Exception exception3)
{
DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} closing a proxy: {1}", exception3.GetType().Name, exception3);
Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception3);
}
}
public bool FaultInSupportingToken(Message message)
{
DebugTrace.TraceEnter(this, "FaultInSupportingToken");
bool flag = false;
WsatRegistrationHeader header = this.ReadRegistrationHeader(message);
if (((header == null) || (header.TransactionId == Guid.Empty)) || string.IsNullOrEmpty(header.TokenId))
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Invalid or absent RegisterInfo in register message");
}
}
else
{
currentSct = this.DeriveToken(header.TransactionId, header.TokenId);
flag = true;
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Created SCT with id {0} for transaction {1}", header.TokenId, header.TransactionId);
}
}
DebugTrace.TraceLeave(this, "FaultInSupportingToken");
return(flag);
}
private static void UnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs args)
{
if (DebugTrace.Error)
{
Exception exceptionObject = (Exception)args.ExceptionObject;
DebugTrace.Trace(TraceLevel.Error, "Unhandled {0} thrown: {1}", exceptionObject.GetType().Name, exceptionObject);
}
}
public static void AddIssuedToken(Message message, RequestSecurityTokenResponse rstr)
{
TransactionFlowProperty.Ensure(message).IssuedTokens.Add(rstr);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Added issued token to message");
}
}
public IAsyncResult BeginSendRegister(ref Register register, AsyncCallback callback, object state)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Sending Register to {0}", base.to.Uri);
}
Message message = this.CreateRegisterMessage(ref register);
return(base.BeginSendRequest(message, callback, state));
}
public IAsyncResult BeginSendCreateCoordinationContext(ref CreateCoordinationContext create, AsyncCallback callback, object state)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Sending CreateCoordinationContext to {0}", base.to.Uri);
}
Message message = this.CreateCreateCoordinationContextMessage(ref create);
return(base.BeginSendRequest(message, callback, state));
}
public ICoordinationListener Add(IRegistrationCoordinator serviceInstance)
{
DebugTrace.TraceEnter("CoordinationService.Add (IRegistrationCoordinator)");
this.AssertProtocolServiceMode();
IWSRegistrationCoordinator dispatcher = RegistrationCoordinatorDispatcher.Instance(this, serviceInstance);
ICoordinationListener listener = this.CreateService(dispatcher, dispatcher.ContractType, BindingStrings.RegistrationCoordinatorSuffix(this.protocolVersion));
DebugTrace.TraceLeave("CoordinationService.Add (IRegistrationCoordinator)");
return(listener);
}
public ICoordinationListener Add(ICompletionParticipant serviceInstance)
{
DebugTrace.TraceEnter("CoordinationService.Add (ICompletionParticipant)");
this.AssertProtocolServiceMode();
IWSCompletionParticipant dispatcher = CompletionParticipantDispatcher.Instance(this, serviceInstance);
ICoordinationListener listener = this.CreateService(dispatcher, dispatcher.ContractType, BindingStrings.CompletionParticipantSuffix(this.protocolVersion));
DebugTrace.TraceLeave("CoordinationService.Add (ICompletionParticipant)");
return(listener);
}
public static void AddSupportingToken(Message message, RequestSecurityTokenResponse rstr)
{
GenericXmlSecurityToken token = rstr.GetIssuedToken(null, null, SecurityKeyEntropyMode.ServerEntropy, null, null, null);
SecurityMessageProperty property = new SecurityMessageProperty();
SupportingTokenSpecification item = new SupportingTokenSpecification(token, new List <IAuthorizationPolicy>().AsReadOnly(), SecurityTokenAttachmentMode.Endorsing, SecurityContextSecurityTokenParameters);
property.OutgoingSupportingTokens.Add(item);
message.Properties.Security = property;
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Attached supporting token {0} to register message", rstr.Context);
}
}
private TChannel WrapChannel(TChannel innerChannel)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Creating new SupportingTokenChannel<{0}>", typeof(TChannel).Name);
}
if (typeof(TChannel) == typeof(IDuplexChannel))
{
return((TChannel) new SupportingTokenDuplexChannel(this, (IDuplexChannel)innerChannel, this.tokenResolver, this.protocolVersion));
}
DiagnosticUtility.FailFast("SupportingTokenListener does not support " + typeof(TChannel).Name);
return(default(TChannel));
}
public Message SendRequest(Message message, string replyAction)
{
Message message2;
try
{
message2 = base.GetChannel(message).SendRequest(message);
}
catch (TimeoutException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
base.OnChannelFailure();
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception));
}
catch (QuotaExceededException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
base.OnChannelFailure();
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception2));
}
catch (FaultException exception3)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning);
base.OnChannelFailure();
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatFaultException(exception3.CreateMessageFault(), exception3.Action));
}
catch (CommunicationException exception4)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Warning);
base.OnChannelFailure();
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception4));
}
catch (Exception exception5)
{
DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} in RequestReplyProxy.SendRequest: {1}", exception5.GetType().Name, exception5);
base.OnChannelFailure();
Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception5);
return(null);
}
try
{
this.ValidateReply(message2, replyAction);
}
catch
{
message2.Close();
throw;
}
return(message2);
}
protected void OnMessageException(Message message, CommunicationException exception)
{
DebugTrace.Trace(TraceLevel.Warning, "{0} - {1} reading datagram with action {2}: {3}", base.GetType().Name, exception.GetType().Name, message.Headers.Action, exception.Message);
EndpointAddress faultToHeader = Library.GetFaultToHeader(message.Headers, this.protocolVersion);
if (faultToHeader == null)
{
DebugTrace.Trace(TraceLevel.Warning, "Ignoring invalid datagram - a fault-to header could not be obtained");
}
else
{
DatagramProxy proxy = null;
try
{
proxy = this.CreateFaultProxy(faultToHeader);
}
catch (CreateChannelFailureException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
DebugTrace.Trace(TraceLevel.Warning, "Ignoring invalid datagram: {0}", exception2.Message);
}
if (proxy != null)
{
try
{
IAsyncResult ar = proxy.BeginSendFault(message.Headers.MessageId, Faults.Version(this.protocolVersion).InvalidParameters, null, null);
proxy.EndSendMessage(ar);
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Sent InvalidParameters fault to {0}", proxy.To.Uri);
}
}
catch (WsatSendFailureException exception3)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning);
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "{0} sending InvalidParameters fault to {1}: {2}", exception3.GetType().Name, proxy.To.Uri, exception3.Message);
}
}
finally
{
proxy.Release();
}
}
}
}
public SecurityContextSecurityToken GetContext(UniqueId contextId, UniqueId generation)
{
DebugTrace.TraceEnter(this, "GetContext");
SecurityContextSecurityToken currentSct = null;
if (((SupportingTokenSecurityTokenResolver.currentSct != null) && (SupportingTokenSecurityTokenResolver.currentSct.ContextId == contextId)) && (SupportingTokenSecurityTokenResolver.currentSct.KeyGeneration == generation))
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Found SCT with matching id {0}", contextId);
}
currentSct = SupportingTokenSecurityTokenResolver.currentSct;
SupportingTokenSecurityTokenResolver.currentSct = null;
}
DebugTrace.TraceLeave(this, "GetContext");
return(currentSct);
}
public override SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver)
{
if (tokenRequirement == null)
{
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("tokenRequirement");
}
if (!(tokenRequirement.TokenType == ServiceModelSecurityTokenTypes.SecurityContext))
{
return(base.CreateSecurityTokenAuthenticator(tokenRequirement, out outOfBandTokenResolver));
}
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "CreateSecurityTokenAuthenticator for SecurityContext");
}
outOfBandTokenResolver = this.serverCreds.tokenResolver;
return(this.serverCreds.tokenAuthenticator);
}
private WsatRegistrationHeader ReadRegistrationHeader(Message message)
{
WsatRegistrationHeader header = null;
try
{
header = WsatRegistrationHeader.ReadFrom(message);
}
catch (InvalidEnlistmentHeaderException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error);
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Invalid RegisterInfo header found in register message: {0}", exception.Message);
}
}
return(header);
}
private void CreateBaseEndpointAddress()
{
if (DebugTrace.Info)
{
DebugTrace.Trace(TraceLevel.Info, "Creating base endpoint for {0}", base.SingletonInstance.GetType().Name);
}
if (((base.ChannelDispatchers.Count != 1) || (base.ChannelDispatchers[0] == null)) || ((base.ChannelDispatchers[0] as ChannelDispatcher).Endpoints.Count != 1))
{
DiagnosticUtility.FailFast("Must have exactly one endpoint dispatcher");
}
EndpointDispatcher dispatcher = (base.ChannelDispatchers[0] as ChannelDispatcher).Endpoints[0];
this.baseEndpoint = dispatcher.EndpointAddress;
if (DebugTrace.Info)
{
DebugTrace.Trace(TraceLevel.Info, "Listening on {0}", this.baseEndpoint.Uri);
}
}
public CoordinationService(CoordinationServiceConfiguration config, Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion)
{
this.protocolVersion = protocolVersion;
DebugTrace.TraceEnter(this, "CoordinationService");
try
{
this.Initialize(config);
}
catch
{
this.Cleanup();
throw;
}
finally
{
DebugTrace.TraceLeave(this, "CoordinationService");
}
}
private void BuildSidDictionary(List <string> windowsIdentities)
{
this.sids = new Dictionary <Claim, Claim>(windowsIdentities.Count, Claim.DefaultComparer);
foreach (string str in windowsIdentities)
{
Exception exception = null;
try
{
NTAccount account = new NTAccount(str);
SecurityIdentifier sid = (SecurityIdentifier)account.Translate(typeof(SecurityIdentifier));
Claim key = Claim.CreateWindowsSidClaim(sid);
if (!this.sids.ContainsKey(key))
{
this.sids.Add(key, key);
}
}
catch (ArgumentException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
exception = exception2;
}
catch (IdentityNotMappedException exception3)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning);
exception = exception3;
}
catch (SystemException exception4)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Warning);
exception = exception4;
}
if ((exception != null) && DebugTrace.Warning)
{
if (DebugTrace.Pii)
{
DebugTrace.Trace(TraceLevel.Warning, "Could not add account {0} to SID table: {1}", str, exception.Message);
}
else
{
DebugTrace.Trace(TraceLevel.Warning, "Could not add account to SID table: {0}", exception.GetType().Name);
}
}
}
}
protected IAsyncResult BeginSendRequest(Message message, AsyncCallback callback, object state)
{
IAsyncResult result;
base.AddRef();
try
{
result = base.GetChannel(message).BeginRequest(message, callback, state);
}
catch (TimeoutException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
base.OnChannelFailure();
result = new SendMessageFailureAsyncResult(exception, callback, state);
}
catch (QuotaExceededException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
base.OnChannelFailure();
result = new SendMessageFailureAsyncResult(exception2, callback, state);
}
catch (FaultException exception3)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning);
base.OnChannelFailure();
result = new SendMessageFailureAsyncResult(exception3, callback, state);
}
catch (CommunicationException exception4)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Warning);
base.OnChannelFailure();
result = new SendMessageFailureAsyncResult(exception4, callback, state);
}
catch (Exception exception5)
{
DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} in RequestReplyProxy.BeginSendRequest: {1}", exception5.GetType().Name, exception5);
base.OnChannelFailure();
throw Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception5);
}
return(result);
}
