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();
}
}
}
}
private X509Certificate2 ReadX509CertificateIdentity(ConfigurationProvider provider)
{
X509Certificate2 certificate;
string thumbprint = provider.ReadString("X509CertificateIdentity", null);
if (thumbprint == null)
{
certificate = null;
DebugTrace.Trace(TraceLevel.Warning, "{0} value could not be read", "X509CertificateIdentity");
return(certificate);
}
certificate = this.FindCertificateByThumbprint(thumbprint);
if (certificate == null)
{
ThumbPrintNotFoundRecord.TraceAndLog(thumbprint);
DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with thumbprint {0} could not be found", thumbprint);
return(certificate);
}
if (!this.ValidateIdentityCertificate(certificate))
{
ThumbPrintNotValidatedRecord.TraceAndLog(thumbprint);
DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with thumbprint {0} could not be validated", thumbprint);
certificate = null;
}
return(certificate);
}
public void Handle(object model)
{
// Find the full path to the template file,
// using current directory if argument isn't fully qualified
string templatePath = GetTemplatePath();
DebugTrace.Trace(this, "Rendering:" + templatePath);
DebugTrace.Trace(this, "Model:" + model.ToString());
var templateName = Path.GetFileName(templatePath);
var templateDirPath = Path.GetDirectoryName(templatePath);
SparkViewEngine engine = new SparkEngineFactory().GetSparkEngine <TView>(templateDirPath);
try
{
// compile and instantiate the template
string templateResult = ProcessViewTemplate(engine, templateName, model);
_fileWriter.Write(templateResult);
}
catch (Exception ex)
{
throw new SparkReportGenerationException("An exception occurred:" + ex.GetType().Name + "\r\n" +
ex.Message, ex);
}
}
private void StartListeners()
{
DebugTrace.TraceEnter(this, "StartListeners");
try
{
this.twoPhaseCommitCoordinatorListener.Start();
this.twoPhaseCommitParticipantListener.Start();
this.completionCoordinatorListener.Start();
this.registrationCoordinatorListener.Start();
this.activationCoordinatorListener.Start();
}
catch (MessagingInitializationException exception)
{
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Error starting a listener: {0}", exception);
}
this.CleanupOnFailure();
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new PluggableProtocolException(exception.Message, exception));
}
catch (Exception exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Error);
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Unknown exception starting a listener: {0}", exception2);
}
this.CleanupOnFailure();
throw;
}
DebugTrace.TraceLeave(this, "StartListeners");
}
public void RecoveryBeginning()
{
DebugTrace.TraceEnter(this, "RecoveryBeginning");
if (this.config.NetworkEndpointsEnabled)
{
try
{
this.coordination = new CoordinationService(this.config.PortConfiguration, this.protocolVersion);
this.activationCoordinatorListener = this.coordination.Add(this.activationCoordinator);
this.registrationCoordinatorListener = this.coordination.Add(this.registrationCoordinator);
this.completionCoordinatorListener = this.coordination.Add(this.completionCoordinator);
this.twoPhaseCommitCoordinatorListener = this.coordination.Add(this.twoPhaseCommitCoordinator);
this.twoPhaseCommitParticipantListener = this.coordination.Add(this.twoPhaseCommitParticipant);
}
catch (MessagingInitializationException exception)
{
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Error initializing CoordinationService: {0}", exception);
}
this.CleanupOnFailure();
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new PluggableProtocolException(exception.Message, exception));
}
catch (Exception exception2)
{
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Unknown exception initializing CoordinationService: {0}", exception2);
}
this.CleanupOnFailure();
throw;
}
}
DebugTrace.TraceLeave(this, "RecoveryBeginning");
}
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 LineStatus ExecuteLine(Scenario scenario, ScenarioContext scenarioContext, string line)
{
DebugTrace.Trace("ScenarioLineExecter.ExecuteLine", line);
InvocationChain chain = GetMatchingChain(scenarioContext, line);
if (chain == null)
{
var suggestion = _implementationHelper.Suggest(line);
_eventBus.Raise(new LinePending {
Scenario = scenario, Line = line, Suggestion = suggestion
});
return(LineStatus.Pending);
}
if (!ExecuteChain(scenario, scenarioContext, chain, line))
{
return(LineStatus.Failed);
}
_eventBus.Raise(new LinePassed {
Scenario = scenario, Line = line
});
return(LineStatus.Passed);
}
public PerformanceCounterWrapper(string counterName)
{
Exception exception;
string categoryName = "MSDTC Bridge 4.0.0.0";
try
{
this.counter = new PerformanceCounter(categoryName, counterName, string.Empty, false);
this.counter.RemoveInstance();
this.counter = new PerformanceCounter(categoryName, counterName, string.Empty, false);
exception = null;
}
catch (InvalidOperationException exception2)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
exception = exception2;
}
catch (Win32Exception exception3)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning);
exception = exception3;
}
if (exception != null)
{
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Unable to initialize performance counter {0}: {1}", counterName, exception);
}
PerformanceCounterInitializationFailureRecord.TraceAndLog(PluggableProtocol10.ProtocolGuid, counterName, exception);
}
}
private void Remove <T, S>(Dictionary <T, S> dictionary, ReaderWriterLock rwLock, T key, S value)
{
bool flag = false;
try
{
try
{
}
finally
{
rwLock.AcquireWriterLock(-1);
flag = true;
}
if (!dictionary.Remove(key))
{
DiagnosticUtility.FailFast("The lookup table does not contain the object");
}
}
finally
{
if (flag)
{
rwLock.ReleaseWriterLock();
}
}
if (DebugTrace.Verbose)
{
int count = dictionary.Count;
DebugTrace.Trace(TraceLevel.Verbose, "Removed {0} {1} from lookup table. Table contains {2} object{3}", value.GetType().Name, value, count, (count == 1) ? string.Empty : "s");
}
}
public void Rejoin(Enlistment enlistment, ProtocolProviderCallback callback, object obj)
{
DebugTrace.TraceEnter(this, "Rejoin");
ParticipantEnlistment participant = null;
try
{
participant = this.state.LogEntrySerialization.DeserializeParticipant(enlistment);
}
catch (SerializationException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Critical);
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Failed to deserialize log entry for participant: {0}", exception);
}
ParticipantRecoveryLogEntryCorruptRecord.TraceAndLog(enlistment.LocalTransactionId, enlistment.RemoteTransactionId, enlistment.GetRecoveryData(), exception);
DiagnosticUtility.FailFast("A participant recovery log entry could not be deserialized. This is a fatal condition.");
}
if (ParticipantRecoveredRecord.ShouldTrace)
{
ParticipantRecoveredRecord.Trace(participant.EnlistmentId, participant.Enlistment.RemoteTransactionId, (participant.ParticipantProxy != null) ? participant.ParticipantProxy.To : null, this.state.ProtocolVersion);
}
participant.StateMachine.Enqueue(new TmRejoinEvent(participant, callback, obj));
DebugTrace.TraceLeave(this, "Rejoin");
}
public void Replay(Enlistment enlistment, ProtocolProviderCallback callback, object obj)
{
DebugTrace.TraceEnter(this, "Replay");
CoordinatorEnlistment coordinator = null;
try
{
coordinator = this.state.LogEntrySerialization.DeserializeCoordinator(enlistment);
}
catch (SerializationException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Critical);
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Failed to deserialize log entry for coordinator: {0}", exception);
}
CoordinatorRecoveryLogEntryCorruptRecord.TraceAndLog(enlistment.LocalTransactionId, enlistment.RemoteTransactionId, enlistment.GetRecoveryData(), exception);
DiagnosticUtility.FailFast("A coordinator recovery log entry could not be deserialized. This is a fatal condition.");
}
if (CoordinatorRecoveredRecord.ShouldTrace)
{
CoordinatorRecoveredRecord.Trace(coordinator.EnlistmentId, coordinator.Enlistment.RemoteTransactionId, (coordinator.CoordinatorProxy != null) ? coordinator.CoordinatorProxy.To : null, this.state.ProtocolVersion);
}
coordinator.StateMachine.Enqueue(new TmReplayEvent(coordinator, callback, obj));
DebugTrace.TraceLeave(this, "Replay");
}
private void Add <T, S>(Dictionary <T, S> dictionary, ReaderWriterLock rwLock, T key, S value)
{
bool flag = false;
try
{
try
{
}
finally
{
rwLock.AcquireWriterLock(-1);
flag = true;
}
dictionary.Add(key, value);
}
finally
{
if (flag)
{
rwLock.ReleaseWriterLock();
}
}
if (DebugTrace.Verbose)
{
int count = dictionary.Count;
DebugTrace.Trace(TraceLevel.Verbose, "Added {0} {1} to lookup table. Table contains {2} object{3}", value.GetType().Name, value, count, (count == 1) ? string.Empty : "s");
}
}
public void Add(ITimerRecipient recipient, object token)
{
int count;
DebugTrace.TraceEnter(this, "Add");
TimeSpan span = recipient.NextNotification - this.state.ElapsedTime;
if ((span <= TimeSpan.Zero) || (span >= this.maxNotificationTime))
{
DiagnosticUtility.FailFast("The timer object has an invalid notification time");
}
lock (this.timerList.SyncRoot)
{
this.AssertState();
this.timerList.Add(recipient, token);
count = this.timerList.Count;
if (count == 1)
{
this.ActivateTimer();
}
}
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Added timer recipient to be reminded in {0} ms", (long)span.TotalMilliseconds);
DebugTrace.Trace(TraceLevel.Verbose, "Timer list depth at {0}", count);
}
DebugTrace.TraceLeave(this, "Add");
}
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 Remove(ITimerRecipient recipient)
{
int count;
int num2;
DebugTrace.TraceEnter(this, "Remove");
lock (this.timerList.SyncRoot)
{
this.AssertState();
count = this.timerList.Count;
this.timerList.Remove(recipient);
num2 = this.timerList.Count;
if ((count != num2) && (this.timerList.Count == 0))
{
this.DeactivateTimer();
}
}
if (DebugTrace.Verbose)
{
if (count == num2)
{
DebugTrace.Trace(TraceLevel.Verbose, "Timer recipient was not present. Timer list depth is still {0}", num2);
}
else
{
DebugTrace.Trace(TraceLevel.Verbose, "Removed timer recipient. Timer list depth is now {0}", num2);
}
}
DebugTrace.TraceLeave(this, "Remove");
}
public override void OnEvent(MsgDurablePrepareEvent e)
{
CoordinatorEnlistment coordinator = e.Coordinator;
Exception exception = null;
try
{
byte[] data = base.state.LogEntrySerialization.Serialize(coordinator);
coordinator.Enlistment.SetRecoveryData(data);
base.state.TransactionManagerSend.Prepare(coordinator);
e.StateMachine.ChangeState(base.state.States.CoordinatorPreparing);
}
catch (SerializationException exception2)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Error);
exception = exception2;
}
if (exception != null)
{
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Failed to serialize log entry for coordinator: {0}", exception);
}
CoordinatorRecoveryLogEntryCreationFailureRecord.TraceAndLog(coordinator.EnlistmentId, coordinator.Enlistment.RemoteTransactionId, exception.Message, exception);
base.state.TwoPhaseCommitParticipant.SendDurableAborted(coordinator);
base.state.TransactionManagerSend.Rollback(coordinator);
e.StateMachine.ChangeState(base.state.States.DurableAborted);
}
}
public void WriteResource(string resourceName, string destination, bool overwrite)
{
string fileName = Path.Combine(Directory.GetCurrentDirectory(), destination);
Filesystem.WriteFile(fileName, GetResource(resourceName), overwrite);
DebugTrace.Trace("Init Job", "Wrote file: " + destination);
}
public void SendFault(Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result, Fault fault)
{
this.state.Perf.FaultsSentCountPerInterval.Increment();
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Sending {0} fault to activation participant", fault.Code.Name);
}
ActivationProxy.SendFaultResponse(result, fault);
}
public void Raise <T>(T e)
{
DebugTrace.Trace("EventBus", "Raising " + typeof(T).FullName);
foreach (var handler in GetHandlersForType(typeof(T)).Cast <IHandle <T> >())
{
handler.Handle(e);
DebugTrace.Trace("EventBus", " ... handled by: " + handler.GetType().FullName);
}
}
private void DeactivateTimer()
{
DebugTrace.Trace(TraceLevel.Verbose, "Timer list is now empty. Canceling periodic timer notification");
if (!this.timer.Change(-1, -1) && DebugTrace.Info)
{
DebugTrace.Trace(TraceLevel.Info, "TimerManager.DeactivateTimer: Timer.Change returned false");
}
this.active = false;
this.AssertState();
}
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));
}
}
private LogEntry DeserializeLogEntry(byte[] buffer, Guid localTransactionId)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Deserializing {0} byte buffer", buffer.Length);
}
MemoryStream mem = new MemoryStream(buffer, 0, buffer.Length, false, true);
LogEntry logEntry = this.DeserializeHeader(mem, localTransactionId);
return(this.CreateDeserializer(mem, logEntry).Deserialize());
}
public void OnTimerNotification(object token)
{
TimerInstance objA = (TimerInstance)token;
lock (this.timerLock)
{
if (!this.timer.Active)
{
DebugTrace.Trace(TraceLevel.Verbose, "Notification discarded due to inactive timer");
return;
}
if (!object.ReferenceEquals(objA, this.timer.Instance))
{
DebugTrace.Trace(TraceLevel.Verbose, "Notification discarded due to mismatched policy");
return;
}
this.timer.Notifications += 1L;
if ((this.timer.Policy.MaxNotifications == 0) || (this.timer.Notifications < this.timer.Policy.MaxNotifications))
{
if (this.timer.Notifications == 1L)
{
this.timer.CurrentInterval = this.timer.Policy.NotificationInterval;
}
else
{
int intervalIncreasePercentage = this.timer.Policy.IntervalIncreasePercentage;
long ticks = this.timer.CurrentInterval.Ticks;
ticks += (ticks / 100L) * intervalIncreasePercentage;
if (ticks < 0L)
{
ticks = 0x7ffffffffffffffeL;
}
TimeSpan maxNotificationInterval = new TimeSpan(ticks);
if (maxNotificationInterval > this.timer.Policy.MaxNotificationInterval)
{
maxNotificationInterval = this.timer.Policy.MaxNotificationInterval;
}
this.timer.CurrentInterval = maxNotificationInterval;
}
this.timer.NextNotification = this.state.ElapsedTime + this.timer.CurrentInterval;
this.state.TimerManager.Add(this, this.timer.Instance);
}
else
{
this.timer.Active = false;
if (this.timer.Notifications > this.timer.Policy.MaxNotifications)
{
return;
}
}
}
this.OnTimer(objA.Profile);
}
public void Register(object handler)
{
if (IsAlreadyRegistered(handler))
{
DebugTrace.Trace("EventBus", "Tried to add a handler of type " + handler.GetType() + " but it was already registered.");
return;
}
_handlers.Add(handler);
AssociateWithHandledEventTypes(handler);
}
private bool ValidateIdentityCertificate(X509Certificate2 identity)
{
string subject = this.ExtractSubjectName(identity);
if (!identity.HasPrivateKey)
{
SslNoPrivateKeyRecord.TraceAndLog(subject, identity.Thumbprint);
DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with subject name {0} and thumbprint {1} does not have a private key", subject, identity.Thumbprint);
return(false);
}
try
{
AsymmetricAlgorithm privateKey = identity.PrivateKey;
}
catch (CryptographicException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
SslNoAccessiblePrivateKeyRecord.TraceAndLog(subject, identity.Thumbprint);
DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with subject name {0} and thumbprint {1} does not have an accessible private key", subject, identity.Thumbprint);
return(false);
}
X509KeyUsageExtension extension = (X509KeyUsageExtension)identity.Extensions["2.5.29.15"];
if ((extension != null) && ((extension.KeyUsages & (X509KeyUsageFlags.DigitalSignature | X509KeyUsageFlags.KeyEncipherment)) != (X509KeyUsageFlags.DigitalSignature | X509KeyUsageFlags.KeyEncipherment)))
{
MissingNecessaryKeyUsageRecord.TraceAndLog(subject, identity.Thumbprint, X509KeyUsageFlags.DigitalSignature | X509KeyUsageFlags.KeyEncipherment);
DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with subject name {0} and thumbprint {1} does not provide {2} among its KeyUsages", subject, identity.Thumbprint, (X509KeyUsageFlags.DigitalSignature | X509KeyUsageFlags.KeyEncipherment).ToString());
return(false);
}
X509EnhancedKeyUsageExtension extension2 = (X509EnhancedKeyUsageExtension)identity.Extensions["2.5.29.37"];
if (extension2 != null)
{
if (extension2.EnhancedKeyUsages["1.3.6.1.5.5.7.3.2"] == null)
{
MissingNecessaryEnhancedKeyUsageRecord.TraceAndLog(subject, identity.Thumbprint, "1.3.6.1.5.5.7.3.2");
DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with subject name {0} and thumbprint {1} does not provide {2} as one of its EnhancedKeyUsages", subject, identity.Thumbprint, "1.3.6.1.5.5.7.3.2");
return(false);
}
if (extension2.EnhancedKeyUsages["1.3.6.1.5.5.7.3.1"] == null)
{
MissingNecessaryEnhancedKeyUsageRecord.TraceAndLog(subject, identity.Thumbprint, "1.3.6.1.5.5.7.3.1");
DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with subject name {0} and thumbprint {1} does not provide {2} as one of its EnhancedKeyUsages", subject, identity.Thumbprint, "1.3.6.1.5.5.7.3.1");
return(false);
}
}
if (DebugTrace.Info)
{
DebugTrace.Trace(TraceLevel.Info, "Identity certificate was successfully validated");
}
return(true);
}
private void ActivateTimer()
{
if (!this.timer.Change(this.reminderGranularity, this.reminderGranularity) && DebugTrace.Info)
{
DebugTrace.Trace(TraceLevel.Info, "TimerManager.ActivateTimer: Timer.Change returned false");
}
this.active = true;
this.AssertState();
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Activated timer notification to {0} seconds", (int)this.reminderGranularity.TotalSeconds);
}
}
public void Write(string s)
{
if (_overwrite && File.Exists(OutputFile))
{
File.Delete(OutputFile);
}
DebugTrace.Trace("FileWriter", "writing file: " + OutputFile);
using (var stream = File.AppendText(OutputFile))
{
stream.Write(s);
}
}
private byte[] SerializeLogEntry(LogEntry logEntry)
{
byte[] buffer = new WsATv1LogEntrySerializer(logEntry, this.protocolVersion).Serialize();
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Serialized {0} byte buffer", buffer.Length);
}
if (buffer.Length > this.maxLogEntrySize)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(Microsoft.Transactions.SR.GetString("SerializationLogEntryTooBig", new object[] { buffer.Length })));
}
return(buffer);
}
private void ReadDiagnosticTracingConfiguration(ConfigurationProvider provider)
{
this.tracePii = provider.ReadInteger("DiagnosticTracingTracePII", 0) != 0;
DebugTrace.Pii = this.tracePii;
this.diagnosticTraceLevel = this.ReadTraceSourceLevel(provider, "DiagnosticTracing", this.diagnosticTraceLevel);
if (this.diagnosticTraceLevel != SourceLevels.Off)
{
bool flag = provider.ReadInteger("DiagnosticTracingActivityTracing", 0) != 0;
if (flag)
{
this.diagnosticTraceLevel |= SourceLevels.ActivityTracing;
}
try
{
Microsoft.Transactions.Bridge.DiagnosticUtility.InitializeTransactionSource(this.diagnosticTraceLevel);
}
catch (SystemException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "WS-AT diagnostic tracing will be disabled : {0}", exception.Message);
}
this.diagnosticTraceLevel = SourceLevels.Off;
}
Microsoft.Transactions.Bridge.DiagnosticUtility.Level = this.diagnosticTraceLevel;
this.serviceModelDiagnosticTraceLevel = this.ReadTraceSourceLevel(provider, "ServiceModelDiagnosticTracing", this.serviceModelDiagnosticTraceLevel);
if (this.serviceModelDiagnosticTraceLevel != SourceLevels.Off)
{
bool propagateActivity = provider.ReadInteger("DiagnosticTracingPropagateActivity", 0) != 0;
if (flag)
{
this.serviceModelDiagnosticTraceLevel |= SourceLevels.ActivityTracing;
}
try
{
Microsoft.Transactions.Bridge.DiagnosticUtility.InitializeServiceModelSource(this.serviceModelDiagnosticTraceLevel, propagateActivity, this.tracePii);
}
catch (SystemException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "ServiceModel diagnostic tracing will be disabled : {0}", exception2.Message);
}
this.serviceModelDiagnosticTraceLevel = SourceLevels.Off;
}
System.ServiceModel.DiagnosticUtility.Level = this.serviceModelDiagnosticTraceLevel;
}
}
}
public ClusterRegistryConfigurationProvider(SafeHResource hResource)
{
this.hKey = Microsoft.Transactions.Wsat.Clusters.SafeNativeMethods.GetClusterResourceKey(hResource, RegistryRights.ExecuteKey);
if (this.hKey.IsInvalid)
{
int num = Marshal.GetLastWin32Error();
this.hKey.SetHandleAsInvalid();
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ConfigurationProviderException(Microsoft.Transactions.SR.GetString("GetClusterResourceKeyFailed", new object[] { num })));
}
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Opened cluster resource key");
}
}
