Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / TransactionBridge / Microsoft / Transactions / Wsat / Protocol / DiagnosticTraceRecords.cs / 1 / DiagnosticTraceRecords.cs
//------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
// This file implements the trace records published by WS-AT
using System;
using System.ServiceModel.Channels;
using System.Diagnostics;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Xml;
using Microsoft.Transactions.Bridge;
using Microsoft.Transactions.Wsat.Messaging;
using System.ServiceModel.Diagnostics;
using DiagnosticUtility = Microsoft.Transactions.Bridge.DiagnosticUtility;
namespace Microsoft.Transactions.Wsat.Protocol
{
//
// Common definitions
//
enum TransactionOutcome
{
Committed,
Aborted,
InDoubt
}
//
// WS-AT protocol service trace records
//
static class TransactionTraceRecord
{
public static void SerializeRecord(XmlWriter xmlWriter, object o)
{
DataContractSerializer serializer = new DataContractSerializer(o.GetType());
serializer.WriteObject(xmlWriter, o);
}
}
// Critical
static class UnhandledStateMachineExceptionRecord
{
public static void TraceAndLog(
Guid enlistmentId,
string transactionId,
string stateMachineName,
string currentState,
StateMachineHistory history, /* optional */
Exception e)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Critical,
EventLogCategory.StateMachine,
EventLogEventId.UnhandledStateMachineExceptionRecordDescription,
transactionId,
stateMachineName,
currentState,
history == null ? string.Empty : history.ToString(),
enlistmentId.ToString(),
e.ToString());
}
}
static class FatalUnexpectedStateMachineEventRecord
{
public static void TraceAndLog(
Guid enlistmentId,
string transactionId,
string stateMachineName,
string currentState,
StateMachineHistory history, /* optional */
string eventName,
string eventDetails /* optional */
)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Critical,
EventLogCategory.StateMachine,
EventLogEventId.FatalUnexpectedStateMachineEvent,
transactionId,
stateMachineName,
currentState,
history == null ? string.Empty : history.ToString(),
eventName,
string.IsNullOrEmpty(eventDetails) ? string.Empty : eventDetails);
}
}
static class ParticipantRecoveryLogEntryCorruptRecord
{
public static void TraceAndLog(
Guid localTransactionId,
string transactionId,
byte[] recoveryData /* optional */,
Exception e
)
{
using (Activity.CreateActivity(localTransactionId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Critical,
EventLogCategory.StateMachine,
EventLogEventId.ParticipantRecoveryLogEntryCorrupt,
transactionId,
Convert.ToBase64String(recoveryData),
e.ToString());
}
}
}
static class CoordinatorRecoveryLogEntryCorruptRecord
{
public static void TraceAndLog(
Guid localTransactionId,
string transactionId,
byte[] recoveryData /* optional */,
Exception e
)
{
using (Activity.CreateActivity(localTransactionId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Critical,
EventLogCategory.StateMachine,
EventLogEventId.CoordinatorRecoveryLogEntryCorrupt,
transactionId,
Convert.ToBase64String(recoveryData),
e.ToString());
}
}
}
static class TransactionBridgeRecoveryFailureRecord
{
public static void TraceAndLog(Exception e)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Critical,
EventLogCategory.Wsat,
EventLogEventId.TransactionBridgeRecoveryFailure,
e.ToString());
}
}
// Error
static class CoordinatorRecoveryLogEntryCreationFailureRecord
{
public static void TraceAndLog(Guid enlistmentId,
string transactionId,
string reason,
Exception e)
{
using (Activity.CreateActivity(enlistmentId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Error,
EventLogCategory.StateMachine,
EventLogEventId.CoordinatorRecoveryLogEntryCreationFailure,
transactionId,
reason,
e.ToString());
}
}
}
static class ParticipantRecoveryLogEntryCreationFailureRecord
{
public static void TraceAndLog(Guid enlistmentId,
string transactionId,
string reason,
Exception e)
{
using (Activity.CreateActivity(enlistmentId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Error,
EventLogCategory.StateMachine,
EventLogEventId.ParticipantRecoveryLogEntryCreationFailure,
transactionId,
enlistmentId.ToString(),
reason,
e.ToString());
}
}
}
static class ProtocolInitializationFailureRecord
{
public static void TraceAndLog(Guid protocolId, string protocolName, Exception e)
{
using (Activity.CreateActivity(protocolId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Error,
EventLogCategory.Wsat,
EventLogEventId.ProtocolInitializationFailure,
protocolId.ToString(),
protocolName,
e.ToString());
}
}
}
static class ProtocolStartFailureRecord
{
public static void TraceAndLog(Guid protocolId, string protocolName, Exception e)
{
using (Activity.CreateActivity(protocolId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Error,
EventLogCategory.Wsat,
EventLogEventId.ProtocolStartFailure,
protocolId.ToString(),
protocolName,
e.ToString());
}
}
}
static class ProtocolRecoveryCompleteFailureRecord
{
public static void TraceAndLog(Guid protocolId, string protocolName, Exception e)
{
using (Activity.CreateActivity(protocolId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Error,
EventLogCategory.Wsat,
EventLogEventId.ProtocolRecoveryCompleteFailure,
protocolId.ToString(),
protocolName,
e.ToString());
}
}
}
static class ProtocolRecoveryBeginningFailureRecord
{
public static void TraceAndLog(Guid protocolId, string protocolName, Exception e)
{
using (Activity.CreateActivity(protocolId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Error,
EventLogCategory.Wsat,
EventLogEventId.ProtocolRecoveryBeginningFailure,
protocolId.ToString(),
protocolName,
e.ToString());
}
}
}
static class ProtocolStopFailureRecord
{
public static void TraceAndLog(Guid protocolId, string protocolName, Exception e)
{
using (Activity.CreateActivity(protocolId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Error,
EventLogCategory.Wsat,
EventLogEventId.ProtocolStopFailure,
protocolId.ToString(),
protocolName,
e.ToString());
}
}
}
// Warning
static class NonFatalUnexpectedStateMachineEventRecord
{
public static void TraceAndLog(
Guid enlistmentId,
string transactionId,
string stateMachine,
string currentState,
StateMachineHistory history, /* optional */
string eventName,
string eventDetails /* optional */
)
{
using (Activity.CreateActivity(enlistmentId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Warning,
EventLogCategory.StateMachine,
EventLogEventId.NonFatalUnexpectedStateMachineEvent,
transactionId,
stateMachine,
currentState,
history == null ? string.Empty : history.ToString(),
eventName,
string.IsNullOrEmpty(eventDetails) ? string.Empty : eventDetails);
}
}
}
static class PerformanceCounterInitializationFailureRecord
{
public static void TraceAndLog(Guid protocolId, string counterName, Exception e)
{
using (Activity.CreateActivity(protocolId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Warning,
EventLogCategory.PerformanceCounter,
EventLogEventId.PerformanceCounterInitializationFailure,
counterName,
e.ToString());
}
}
}
static class CreateTransactionFailureRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(Guid enlistmentId, string reason)
{
ReasonRecordSchema record = new ReasonRecordSchema(reason);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
TraceCode.CreateTransactionFailure,
SR.GetString(SR.CreateTransactionFailure),
record, null, enlistmentId, null);
}
}
static class EnlistTransactionFailureRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(Guid enlistmentId, CoordinationContext context, string reason)
{
ReasonRecordSchema record = new ReasonRecordSchema(reason);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
TraceCode.EnlistTransactionFailure,
SR.GetString(SR.EnlistTransactionFailure),
record, null, enlistmentId, null);
}
}
static class RegisterParticipantFailureRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(
Guid enlistmentId,
string transactionId,
ControlProtocol protocol,
EndpointAddress protocolService,
string reason,
ProtocolVersion protocolVersion
)
{
RegisterFailureRecordSchema record = RegisterFailureRecordSchema.Instance(
transactionId, protocol, protocolService, reason, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
GetCode(protocolVersion),
SR.GetString(SR.RegisterParticipantFailure),
record, null, enlistmentId, null);
}
static Type type = typeof(RegisterParticipantFailureRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.RegisterParticipantFailure;
case ProtocolVersion.Version11 :
return TraceCode.RegisterParticipantFailure11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
static class VolatileOutcomeTimeoutRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(
Guid enlistmentId,
string transactionId,
TransactionOutcome outcome,
TimeSpan timeout
)
{
EnlistmentTimeoutRecordSchema record = new EnlistmentTimeoutRecordSchema(
transactionId, enlistmentId, outcome, timeout);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
TraceCode.VolatileOutcomeTimeout,
SR.GetString(SR.VolatileOutcomeTimeout),
record, null, enlistmentId, null);
}
}
static class VolatileParticipantInDoubtRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(Guid enlistmentId,
EndpointAddress replyTo /* optional */,
ProtocolVersion protocolVersion
)
{
VolatileEnlistmentInDoubtRecordSchema record = VolatileEnlistmentInDoubtRecordSchema.Instance(
enlistmentId, replyTo, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
GetCode(protocolVersion),
SR.GetString(SR.VolatileParticipantInDoubt),
record, null, enlistmentId, null);
}
static Type type = typeof(VolatileParticipantInDoubtRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.VolatileParticipantInDoubt;
case ProtocolVersion.Version11 :
return TraceCode.VolatileParticipantInDoubt11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
static class DurableParticipantReplayWhilePreparingRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(Guid enlistmentId, string transactionId)
{
EnlistmentRecordSchema record = new EnlistmentRecordSchema(transactionId, enlistmentId);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
TraceCode.DurableParticipantReplayWhilePreparing,
SR.GetString(SR.DurableParticipantReplayWhilePreparing),
record, null, enlistmentId, null);
}
}
static class RegistrationCoordinatorFaultedRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(
Guid enlistmentId,
CoordinationContext context,
ControlProtocol protocol,
MessageFault fault
)
{
RegistrationCoordinatorFaultedSchema record = new RegistrationCoordinatorFaultedSchema(
context, protocol, fault);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
TraceCode.RegistrationCoordinatorFaulted,
SR.GetString(SR.RegistrationCoordinatorFaulted),
record, null, enlistmentId, null);
}
}
static class RegistrationCoordinatorFailedRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(
Guid enlistmentId,
CoordinationContext context,
ControlProtocol protocol,
Exception e
)
{
RegistrationCoordinatorFailedSchema record = new RegistrationCoordinatorFailedSchema(
context, protocol);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
TraceCode.RegistrationCoordinatorFailed,
SR.GetString(SR.RegistrationCoordinatorFailed),
record, null, enlistmentId, null);
}
}
static class RegistrationCoordinatorResponseInvalidMetadataRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(
Guid enlistmentId,
CoordinationContext context,
ControlProtocol protocol,
EndpointAddress coordinatorService,
Exception e /* optional */,
ProtocolVersion protocolVersion
)
{
RegistrationCoordinatorResponseInvalidMetadataSchema record = RegistrationCoordinatorResponseInvalidMetadataSchema.Instance(
context, protocol, coordinatorService, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
GetCode(protocolVersion),
SR.GetString(SR.RegistrationCoordinatorResponseInvalidMetadata),
record, e, enlistmentId, null);
}
static Type type = typeof(RegistrationCoordinatorResponseInvalidMetadataRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.RegistrationCoordinatorResponseInvalidMetadata;
case ProtocolVersion.Version11 :
return TraceCode.RegistrationCoordinatorResponseInvalidMetadata11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
static class RecoveredCoordinatorInvalidMetadataRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(
Guid enlistmentId,
string transactionId,
EndpointAddress coordinatorService,
ProtocolVersion protocolVersion
)
{
RecoverCoordinatorRecordSchema record = RecoverCoordinatorRecordSchema.Instance(
transactionId, coordinatorService, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
GetCode(protocolVersion),
SR.GetString(SR.RecoveredCoordinatorInvalidMetadata),
record, null, enlistmentId, null);
}
static Type type = typeof(RecoveredCoordinatorInvalidMetadataRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.RecoveredCoordinatorInvalidMetadata;
case ProtocolVersion.Version11 :
return TraceCode.RecoveredCoordinatorInvalidMetadata11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
static class RecoveredParticipantInvalidMetadataRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceWarning; }
}
public static void Trace(
Guid enlistmentId,
string transactionId,
EndpointAddress participantService,
ProtocolVersion protocolVersion
)
{
RecoverParticipantRecordSchema record = RecoverParticipantRecordSchema.Instance(
transactionId, enlistmentId, participantService, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
GetCode(protocolVersion),
SR.GetString(SR.RecoveredParticipantInvalidMetadata),
record, null, enlistmentId, null);
}
static Type type = typeof(RecoveredParticipantInvalidMetadataRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.RecoveredParticipantInvalidMetadata;
case ProtocolVersion.Version11 :
return TraceCode.RecoveredParticipantInvalidMetadata11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
// Information
static class EnlistTransactionRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(Guid enlistmentId, CoordinationContext context)
{
CoordinationContextRecordSchema record = new CoordinationContextRecordSchema(context);
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
TraceCode.EnlistTransaction,
SR.GetString(SR.EnlistTransaction),
record, null, enlistmentId, null);
}
}
}
static class RegisterCoordinatorRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(
Guid enlistmentId,
CoordinationContext context,
ControlProtocol protocol,
EndpointAddress coordinatorService,
ProtocolVersion protocolVersion
)
{
RegisterCoordinatorRecordSchema record = RegisterCoordinatorRecordSchema.Instance(
context, protocol, coordinatorService, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
GetCode(protocolVersion),
SR.GetString(SR.RegisterCoordinator),
record, null, enlistmentId, null);
}
static Type type = typeof(RegisterCoordinatorRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.RegisterCoordinator;
case ProtocolVersion.Version11 :
return TraceCode.RegisterCoordinator11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
static class RegisterParticipantRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(
Guid enlistmentId,
string transactionId,
ControlProtocol protocol,
EndpointAddress participantService,
ProtocolVersion protocolVersion
)
{
RegisterParticipantRecordSchema record = RegisterParticipantRecordSchema.Instance(
transactionId, enlistmentId, protocol, participantService, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
GetCode(protocolVersion),
SR.GetString(SR.RegisterParticipant),
record, null, enlistmentId, null);
}
static Type type = typeof(RegisterParticipantRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.RegisterParticipant;
case ProtocolVersion.Version11 :
return TraceCode.RegisterParticipant11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
static class ProtocolInitializedRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(Guid protocolId, string protocolName)
{
ProtocolServiceRecordSchema record = new ProtocolServiceRecordSchema(protocolName, protocolId);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
TraceCode.ProtocolInitialized,
SR.GetString(SR.ProtocolInitialized),
record, null, protocolId, null);
}
}
static class ProtocolStartedRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(Guid protocolId, string protocolName)
{
ProtocolServiceRecordSchema record = new ProtocolServiceRecordSchema(protocolName, protocolId);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
TraceCode.ProtocolStarted,
SR.GetString(SR.ProtocolStarted),
record, null, protocolId, null);
}
}
static class ProtocolRecoveryCompleteRecord
{
public static void TraceAndLog(Guid protocolId, string protocolName)
{
using (Activity.CreateActivity(protocolId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Information,
EventLogCategory.Wsat,
EventLogEventId.ProtocolRecoveryComplete,
protocolId.ToString(),
protocolName);
}
}
}
static class ProtocolStoppedRecord
{
public static void TraceAndLog(Guid protocolId, string protocolName)
{
using (Activity.CreateActivity(protocolId))
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Information,
EventLogCategory.Wsat,
EventLogEventId.ProtocolStopped,
protocolId.ToString(),
protocolName);
}
}
}
static class PrepareMessageRetryRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(Guid enlistmentId, string transactionId, int count)
{
ParticipantRetryMessageRecordSchema record = new ParticipantRetryMessageRecordSchema(
transactionId, enlistmentId, count);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
TraceCode.PrepareMessageRetry,
SR.GetString(SR.PrepareMessageRetry),
record, null, enlistmentId, null);
}
}
static class CommitMessageRetryRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(Guid enlistmentId, string transactionId, int count)
{
ParticipantRetryMessageRecordSchema record = new ParticipantRetryMessageRecordSchema(
transactionId, enlistmentId, count);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
TraceCode.CommitMessageRetry,
SR.GetString(SR.CommitMessageRetry),
record, null, enlistmentId, null);
}
}
static class PreparedMessageRetryRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(Guid enlistmentId, string transactionId, int count)
{
CoordinatorRetryMessageRecordSchema record = new CoordinatorRetryMessageRecordSchema(
transactionId, count);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
TraceCode.PreparedMessageRetry,
SR.GetString(SR.PreparedMessageRetry),
record, null, enlistmentId, null);
}
}
static class ReplayMessageRetryRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(Guid enlistmentId, string transactionId, int count)
{
CoordinatorRetryMessageRecordSchema record = new CoordinatorRetryMessageRecordSchema(
transactionId, count);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
TraceCode.ReplayMessageRetry,
SR.GetString(SR.ReplayMessageRetry),
record, null, enlistmentId, null);
}
}
static class ParticipantRecoveredRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(
Guid enlistmentId,
string transactionId,
EndpointAddress protocolService,
ProtocolVersion protocolVersion
)
{
RecoverParticipantRecordSchema record = RecoverParticipantRecordSchema.Instance(
transactionId, enlistmentId, protocolService, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
GetCode(protocolVersion),
SR.GetString(SR.ParticipantRecovered),
record, null, enlistmentId, null);
}
static Type type = typeof(ParticipantRecoveredRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.ParticipantRecovered;
case ProtocolVersion.Version11 :
return TraceCode.ParticipantRecovered11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
static class CoordinatorRecoveredRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(
Guid enlistmentId,
string transactionId,
EndpointAddress protocolService,
ProtocolVersion protocolVersion
)
{
RecoverCoordinatorRecordSchema record = RecoverCoordinatorRecordSchema.Instance(
transactionId, protocolService, protocolVersion);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
GetCode(protocolVersion),
SR.GetString(SR.CoordinatorRecovered),
record, null, enlistmentId, null);
}
static Type type = typeof(CoordinatorRecoveredRecord);
static TraceCode GetCode(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
switch (protocolVersion)
{
case ProtocolVersion.Version10 :
return TraceCode.CoordinatorRecovered;
case ProtocolVersion.Version11 :
return TraceCode.CoordinatorRecovered11;
default:
return 0; // inaccessible path because we have asserted the protocol version
}
}
}
static class EnlistmentIdentityCheckFailedRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceInformation; }
}
public static void Trace(Guid enlistmentId)
{
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
TraceCode.EnlistmentIdentityCheckFailed,
SR.GetString(SR.EnlistmentIdentityCheckFailed),
null, null, enlistmentId, null);
}
}
// Verbose
static class ParticipantStateMachineFinishedRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceVerbose; }
}
public static void Trace(Guid enlistmentId, string transactionId, TransactionOutcome outcome)
{
ParticipantOutcomeRecordSchema record = new ParticipantOutcomeRecordSchema(
transactionId, enlistmentId, outcome);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Verbose,
TraceCode.ParticipantStateMachineFinished,
SR.GetString(SR.ParticipantStateMachineFinished),
record, null, enlistmentId, null);
}
}
static class CoordinatorStateMachineFinishedRecord
{
public static bool ShouldTrace
{
get { return DiagnosticUtility.ShouldTraceVerbose; }
}
public static void Trace(Guid enlistmentId, string transactionId, TransactionOutcome outcome)
{
CoordinatorOutcomeRecordSchema record = new CoordinatorOutcomeRecordSchema(
transactionId, outcome);
DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Verbose,
TraceCode.CoordinatorStateMachineFinished,
SR.GetString(SR.CoordinatorStateMachineFinished),
record, null, enlistmentId, null);
}
}
static class ThumbPrintNotFoundRecord
{
public static void TraceAndLog(string thumbPrint)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Information,
EventLogCategory.Wsat,
EventLogEventId.ThumbPrintNotFound,
thumbPrint);
}
}
static class ThumbPrintNotValidatedRecord
{
public static void TraceAndLog(string thumbPrint)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Information,
EventLogCategory.Wsat,
EventLogEventId.ThumbPrintNotValidated,
thumbPrint);
}
}
static class SslNoPrivateKeyRecord
{
public static void TraceAndLog(string subject, string thumbPrint)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Information,
EventLogCategory.Wsat,
EventLogEventId.SslNoPrivateKey,
subject,
thumbPrint);
}
}
static class SslNoAccessiblePrivateKeyRecord
{
public static void TraceAndLog(string subject, string thumbPrint)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Information,
EventLogCategory.Wsat,
EventLogEventId.SslNoAccessiblePrivateKey,
subject,
thumbPrint);
}
}
static class MissingNecessaryKeyUsageRecord
{
public static void TraceAndLog(string subject, string thumbPrint, System.Security.Cryptography.X509Certificates.X509KeyUsageFlags keyUsage)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Information,
EventLogCategory.Wsat,
EventLogEventId.MissingNecessaryKeyUsage,
subject,
thumbPrint,
keyUsage.ToString());
}
}
static class MissingNecessaryEnhancedKeyUsageRecord
{
public static void TraceAndLog(string subject, string thumbPrint, string keyUsage)
{
DiagnosticUtility.EventLog.LogEvent(
TraceEventType.Information,
EventLogCategory.Wsat,
EventLogEventId.MissingNecessaryEnhancedKeyUsage,
subject,
thumbPrint,
keyUsage);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- Selector.cs
- XmlSchemaInfo.cs
- TypeValidationEventArgs.cs
- QueryCursorEventArgs.cs
- OleDbSchemaGuid.cs
- SessionState.cs
- BidPrivateBase.cs
- IncomingWebResponseContext.cs
- DeleteIndexBinder.cs
- GeometryHitTestParameters.cs
- FileDialog.cs
- SBCSCodePageEncoding.cs
- WebConfigurationFileMap.cs
- SortQuery.cs
- MultiPageTextView.cs
- WithStatement.cs
- PathNode.cs
- ServiceHandle.cs
- ParserContext.cs
- DocumentReferenceCollection.cs
- IProvider.cs
- RenderDataDrawingContext.cs
- LambdaCompiler.cs
- IPGlobalProperties.cs
- SoapFormatterSinks.cs
- RichTextBoxAutomationPeer.cs
- SamlSerializer.cs
- EdmProperty.cs
- ToolStripButton.cs
- UseAttributeSetsAction.cs
- WindowsListBox.cs
- DesignerWidgets.cs
- arabicshape.cs
- WindowsGrip.cs
- CompositionTarget.cs
- ComplexObject.cs
- AuthenticationService.cs
- DecimalStorage.cs
- GZipStream.cs
- SystemIPGlobalProperties.cs
- TerminatorSinks.cs
- XmlUtil.cs
- XmlFormatExtensionPrefixAttribute.cs
- PathFigureCollection.cs
- WindowsGraphics2.cs
- XPathChildIterator.cs
- GetLedgerRequest.cs
- ContentElementAutomationPeer.cs
- NavigationProperty.cs
- InboundActivityHelper.cs
- LongTypeConverter.cs
- _LocalDataStore.cs
- AutomationPeer.cs
- ChineseLunisolarCalendar.cs
- XPathDocumentIterator.cs
- Table.cs
- ByteRangeDownloader.cs
- DetectEofStream.cs
- BaseValidator.cs
- FixedHighlight.cs
- SecurityHelper.cs
- ipaddressinformationcollection.cs
- BinaryUtilClasses.cs
- ProjectedSlot.cs
- HtmlInputImage.cs
- TransformerInfo.cs
- RawStylusInput.cs
- RichTextBoxConstants.cs
- BaseDataListComponentEditor.cs
- BinHexDecoder.cs
- FormsAuthenticationEventArgs.cs
- Monitor.cs
- Debugger.cs
- HttpInputStream.cs
- EncryptedKey.cs
- assertwrapper.cs
- ACE.cs
- SingleTagSectionHandler.cs
- DelegateHelpers.cs
- MergeFailedEvent.cs
- RoutedEventHandlerInfo.cs
- SrgsDocument.cs
- ImageInfo.cs
- IndexedSelectQueryOperator.cs
- CompoundFileIOPermission.cs
- httpserverutility.cs
- Debug.cs
- QilGenerator.cs
- ScriptingProfileServiceSection.cs
- CookieHandler.cs
- DrawingVisual.cs
- UnionCqlBlock.cs
- InvalidPipelineStoreException.cs
- formatter.cs
- BitmapPalettes.cs
- HtmlSelect.cs
- FontNamesConverter.cs
- ProxyOperationRuntime.cs
- HttpWriter.cs
- RichTextBox.cs