internal static void Initialize(IRpcServiceManager serviceManager, ExEventLog eventLog)
{
Util.ThrowOnNullArgument(serviceManager, "serviceManager");
Util.ThrowOnNullArgument(eventLog, "eventLog");
RfriServer.rfriAsyncDispatch = new RfriAsyncDispatch();
RfriServer.eventLog = eventLog;
serviceManager.AddServer(new Action(RfriServer.Start), new Action(RfriServer.Stop));
}
internal static void ReportException(Exception exception, ExEventLog exEventLog, ExEventLog.EventTuple eventTuple, ExWatson.IsExceptionInteresting knownExceptions, object eventObject, Trace trace, string traceFormat)
{
Diagnostics.LogExceptionWithTrace(exEventLog, eventTuple, null, trace, eventObject, traceFormat, exception);
if (Diagnostics.IsSendReportValid(exception, knownExceptions))
{
ExWatson.HandleException(new UnhandledExceptionEventArgs(exception, false), ReportOptions.None);
ExWatson.SetWatsonReportAlreadySent(exception);
}
}
internal static void LogEvent(ExEventLog eventLogger, ExEventLog.EventTuple eventInfo, string periodicKey, params object[] messageArguments)
{
if (messageArguments == null)
{
throw new ArgumentNullException("messageArguments");
}
object[] array = new object[messageArguments.Length + 2];
array[0] = Logger.processName;
array[1] = Logger.processId;
messageArguments.CopyTo(array, 2);
eventLogger.LogEvent(eventInfo, periodicKey, array);
}
// Token: 0x0600001D RID: 29 RVA: 0x00003074 File Offset: 0x00001274
internal static void GenerateErrorMessage(HttpResponse response, ExEventLog eventLogger, ExEventLog.EventTuple tuple, Exception error, string tenant)
{
Logger.LogEvent(eventLogger, tuple, null, new object[]
{
error,
tenant
});
response.Clear();
response.StatusCode = 500;
response.ContentType = "application/soap+xml;charset=UTF-8";
response.Write(error.Message);
response.End();
}
// Token: 0x060000F7 RID: 247 RVA: 0x0000439C File Offset: 0x0000259C
internal static void LogEvent(ExEventLog eventLogger, ExEventLog.EventTuple eventId, bool includeAnchorContext, params string[] messageArgs)
{
AnchorUtil.ThrowOnNullArgument(eventLogger, "eventLogger");
AnchorUtil.ThrowOnNullArgument(messageArgs, "messageArgs");
if (messageArgs == null || messageArgs.Length <= 0)
{
return;
}
if (includeAnchorContext)
{
messageArgs[0] = AnchorLogContext.Current.ToString() + ":" + messageArgs[0];
}
eventLogger.LogEvent(eventId, AnchorLogContext.Current.Source, messageArgs);
}
protected override void InternalProcessRecord()
{
base.InternalProcessRecord();
OrganizationId organizationId = this.FindOrganizationId();
ExEventLog exEventLog = new ExEventLog(TestExchangeNotification.ComponentId, "MSExchange Common");
exEventLog.LogEvent(organizationId, CommonEventLogConstants.Tuple_TenantMonitoringTestEvent, this.PeriodicKey, this.InsertionStrings);
base.WriteObject(new MonitoringData
{
Events =
{
this.CreateSuccessEvent()
}
});
}
internal static void Initialize(ExEventLog eventLog, Action stopService)
{
Configuration.GeneralTracer.TraceDebug(0L, "Configuration.Initialize");
Configuration.ServiceEnabled = true;
Configuration.stopService = stopService;
Configuration.eventLog = eventLog;
Configuration.EncryptionRequired = true;
Configuration.LoadAppConfig();
Configuration.LoadRegistryConfig();
if (Configuration.LoadADConfiguration())
{
Configuration.ExchangeRpcClientAccessChangeNotification(null);
}
Configuration.IsDatacenter = Datacenter.IsMicrosoftHostedOnly(true);
}
internal static bool LogExceptionWithTrace(ExEventLog exEventLog, ExEventLog.EventTuple tuple, string periodicKey, Trace tagTracer, object thisObject, string traceFormat, Exception exception)
{
tagTracer.TraceError <Exception>((long)((thisObject == null) ? 0 : thisObject.GetHashCode()), traceFormat, exception);
string text = string.Format(traceFormat, exception.ToString());
if (text.Length > 32000)
{
text = text.Substring(0, 2000) + "...\n" + text.Substring(text.Length - 20000, 20000);
}
return(exEventLog.LogEvent(tuple, periodicKey, new object[]
{
Diagnostics.processId,
Diagnostics.processName,
text
}));
}
// Token: 0x0600001B RID: 27 RVA: 0x00002FB8 File Offset: 0x000011B8
internal static void LogError(ExEventLog eventLogger, TraceSource traceSource, string message, Exception exception, ExEventLog.EventTuple?eventInfo, string user)
{
traceSource.TraceEvent(TraceEventType.Error, 0, "{0} - {1}", new object[]
{
message,
exception
});
ExTraceGlobals.RedirectionTracer.TraceError <string, Exception>(0L, "{0} - {1}", message, exception);
if (eventInfo != null)
{
Logger.LogEvent(eventLogger, eventInfo.Value, user, new object[]
{
user,
exception
});
}
}
internal static void LogMexAgentFaultEvent(ExEventLog eventLog, Exception exception, string agentName, string eventTopic)
{
ArgumentValidator.ThrowIfNull("eventLog", eventLog);
ArgumentValidator.ThrowIfNull("exception", exception);
string text = exception.GetType().Name;
if (text == "SmtpResponseException")
{
return;
}
eventLog.LogEvent(EdgeExtensibilityEventLogConstants.Tuple_MExAgentFault, agentName + "," + text, new object[]
{
agentName,
text,
exception.Message,
eventTopic
});
}
public override void Work()
{
ExEventLog eventLogger = AuthService.EventLogger;
bool flag = false;
ServiceHost serviceHost = null;
eventLogger.LogEvent(SecurityEventLogConstants.Tuple_AuthServiceStarting, "LiveIdServerStarting", null);
try
{
serviceHost = new ServiceHost(typeof(AuthService), new Uri[0]);
try
{
serviceHost.Open();
flag = true;
eventLogger.LogEvent(SecurityEventLogConstants.Tuple_AuthServiceStarted, "LiveIdServerStarted", null);
}
catch (AddressAlreadyInUseException ex)
{
eventLogger.LogEvent(SecurityEventLogConstants.Tuple_AuthServiceFailedToRegisterEndpoint, "AuthServiceFailedToStart", new object[]
{
ex.Message
});
}
base.StopEvent.WaitOne();
}
finally
{
if (flag)
{
serviceHost.Abort();
eventLogger.LogEvent(SecurityEventLogConstants.Tuple_AuthServiceStopped, "AuthServiceStopped", null);
}
if (serviceHost != null)
{
serviceHost.Close();
serviceHost = null;
}
}
}
// Token: 0x060012DD RID: 4829 RVA: 0x0003D4C8 File Offset: 0x0003B6C8
internal static T ExecuteWSManPluginAPI <T>(string funcName, bool throwException, bool trackLatency, T defaultReturnValue, Func <T> func)
{
ExWatson.IsExceptionInteresting isExceptionInteresting = null;
T result;
try
{
AuthZLogger.SafeAppendColumn(RpsCommonMetadata.GenericLatency, funcName, DateTime.UtcNow.ToString());
string funcName2 = funcName;
bool throwException2 = throwException;
LatencyTracker latencyTracker = trackLatency ? AuthZLogHelper.latencyTracker : null;
ExEventLog rbacEventLogger = AuthZLogHelper.RbacEventLogger;
ExEventLog.EventTuple tuple_RemotePSPublicAPIFailed = Microsoft.Exchange.Configuration.ObjectModel.EventLog.TaskEventLogConstants.Tuple_RemotePSPublicAPIFailed;
Trace publicPluginAPITracer = Microsoft.Exchange.Diagnostics.Components.Authorization.ExTraceGlobals.PublicPluginAPITracer;
if (isExceptionInteresting == null)
{
isExceptionInteresting = ((object ex) => AuthZPluginHelper.IsFatalException(ex as Exception));
}
result = Diagnostics.ExecuteAndLog <T>(funcName2, throwException2, latencyTracker, rbacEventLogger, tuple_RemotePSPublicAPIFailed, publicPluginAPITracer, isExceptionInteresting, delegate(Exception ex)
{
AuthZLogHelper.LogException(ex, funcName, throwException);
}, defaultReturnValue, () => AuthZLogHelper.HandleExceptionAndRetry <T>(funcName, func, throwException, defaultReturnValue));
}
catch (Exception ex)
{
string arg = (AuthZLogger.ActivityScope != null) ? AuthZLogger.ActivityScope.ActivityId.ToString() : null;
AuthZLogHelper.EndLogging(true);
Exception ex3;
string str = string.Format("[FailureCategory={0}] ", FailureCategory.AuthZ + "-" + ex3.GetType().Name);
string str2 = string.Format("[AuthZRequestId={0}]", arg);
LocalizedString message = new LocalizedString(str2 + str + ex3.Message);
AuthorizationException ex2 = new AuthorizationException(message, ex3);
throw ex2;
}
return(result);
}
public AuthAdminLogger(string applicationName, AnchorConfig config, ExEventLog eventLog) : base(applicationName, config, eventLog)
{
}
// Token: 0x0600001A RID: 26 RVA: 0x00002F98 File Offset: 0x00001198
internal static void LogError(ExEventLog eventLogger, TraceSource traceSource, string message, Exception exception)
{
Logger.LogError(eventLogger, traceSource, message, exception, null, null);
}
private static void LogEvent(ExEventLog logChannel, ExEventLog.EventTuple eventInfo, string periodicKey, params object[] messageArguments)
{
logChannel.LogEvent(eventInfo, periodicKey, messageArguments);
ExTraceGlobals.EventTracer.Information(0L, eventInfo.ToString(), messageArguments);
}
// Token: 0x06000033 RID: 51 RVA: 0x000034F8 File Offset: 0x000016F8
internal static Uri GetRedirectUrlForTenantSite(string organization, string redirectTemplate, Uri originalUrl, ExEventLog eventLogger)
{
if (organization == null)
{
return(null);
}
ADSessionSettings sessionSettings;
try
{
Guid externalDirectoryOrganizationId;
sessionSettings = (Guid.TryParse(organization, out externalDirectoryOrganizationId) ? ADSessionSettings.FromExternalDirectoryOrganizationId(externalDirectoryOrganizationId) : ADSessionSettings.FromTenantCUName(organization));
}
catch (CannotResolveTenantNameException)
{
return(null);
}
catch (CannotResolveExternalDirectoryOrganizationIdException)
{
return(null);
}
ITenantConfigurationSession session = DirectorySessionFactory.Default.CreateTenantConfigurationSession(ConsistencyMode.PartiallyConsistent, sessionSettings, 180, "GetRedirectUrlForTenantSite", "f:\\15.00.1497\\sources\\dev\\Configuration\\src\\RedirectionModule\\RedirectionHelper.cs");
ExchangeConfigurationUnit exchangeConfigurationUnit = RedirectionHelper.ResolveConfigurationUnitByName(organization, session);
if (exchangeConfigurationUnit == null || exchangeConfigurationUnit.ManagementSiteLink == null)
{
return(null);
}
ADSite localSite = LocalSiteCache.LocalSite;
ADObjectId adobjectId = ADObjectIdResolutionHelper.ResolveDN(exchangeConfigurationUnit.ManagementSiteLink);
Logger.LogEvent(eventLogger, TaskEventLogConstants.Tuple_LiveIdRedirection_UsingManagementSiteLink, organization, new object[]
{
organization,
exchangeConfigurationUnit.AdminDisplayVersion,
exchangeConfigurationUnit.ManagementSiteLink
});
if (adobjectId.Equals(localSite.Id))
{
return(null);
}
foreach (ADObjectId adobjectId2 in localSite.ResponsibleForSites)
{
if (adobjectId2.Equals(adobjectId))
{
Logger.LogEvent(eventLogger, TaskEventLogConstants.Tuple_LiveIdRedirection_TargetSitePresentOnResponsibleForSite, organization, new object[]
{
organization,
adobjectId,
adobjectId2
});
return(null);
}
}
return(RedirectionHelper.GetRedirectUrlForTenantSite(adobjectId, redirectTemplate, originalUrl));
}
public TaskPerformanceRecord(string taskName, LatencyDetectionContextFactory latencyDetectionContextFactory, ExEventLog.EventTuple startTuple, ExEventLog.EventTuple endTuple, ExEventLog eventLog, params IPerformanceDataProvider[] performanceDataProviders) : this(taskName, latencyDetectionContextFactory, startTuple, endTuple, eventLog)
{
this.Start(performanceDataProviders);
}
public TaskPerformanceRecord(string taskName, LatencyDetectionContextFactory latencyDetectionContextFactory, ExEventLog.EventTuple startTuple, ExEventLog.EventTuple endTuple, ExEventLog eventLog)
{
this.TaskName = taskName;
this.latencyDetectionContextFactory = latencyDetectionContextFactory;
this.startTuple = startTuple;
this.endTuple = endTuple;
this.eventLog = eventLog;
this.correlationId = TaskPerformanceRecord.NextCorrelationId.ToString();
}
internal static void ExecuteAndLog(string funcName, bool missionCritical, LatencyTracker latencyTracker, ExEventLog eventLog, ExEventLog.EventTuple eventTuple, Trace tracer, ExWatson.IsExceptionInteresting isExceptionInteresting, Action <Exception> onError, Action action)
{
Diagnostics.ExecuteAndLog <bool>(funcName, missionCritical, latencyTracker, eventLog, eventTuple, tracer, isExceptionInteresting, onError, true, delegate()
{
action();
return(true);
});
}
internal static T ExecuteAndLog <T>(string funcName, bool missionCritical, LatencyTracker latencyTracker, ExEventLog eventLog, ExEventLog.EventTuple eventTuple, Trace tracer, ExWatson.IsExceptionInteresting isExceptionInteresting, Action <Exception> onError, T defaultReturnValue, Func <T> func)
{
bool flag = false;
T result;
try
{
tracer.TraceDebug <Func <T> >(0L, "[{0}] Enter.", func);
if (latencyTracker != null)
{
flag = latencyTracker.StartInternalTracking(funcName);
}
result = func();
}
catch (Exception ex)
{
if (onError != null)
{
onError(ex);
}
Diagnostics.ReportException(ex, eventLog, eventTuple, isExceptionInteresting, null, tracer, string.Format("Func {0} throws Exception {{0}}.", funcName));
if (missionCritical)
{
throw;
}
result = defaultReturnValue;
}
finally
{
if (flag)
{
latencyTracker.EndInternalTracking(funcName);
}
tracer.TraceDebug <Func <T> >(0L, "[{0}] Exit.", func);
}
return(result);
}
// Token: 0x060000F6 RID: 246 RVA: 0x0000438E File Offset: 0x0000258E
internal static void LogEvent(ExEventLog eventLogger, ExEventLog.EventTuple eventId, params string[] messageArgs)
{
AnchorLogger.LogEvent(eventLogger, eventId, true, messageArgs);
}
// Token: 0x060000DA RID: 218 RVA: 0x00003E6C File Offset: 0x0000206C
public AnchorLogger(string applicationName, AnchorConfig config, Trace trace, ExEventLog eventLogger)
{
this.Config = config;
this.log = new AnchorLog(applicationName, this.Config, trace);
this.EventLogger = eventLogger;
}
