// Token: 0x0600016F RID: 367 RVA: 0x00009B94 File Offset: 0x00007D94
internal void Shutdown()
{
if (this.synchronizeTask != null)
{
try
{
if (!this.synchronizeTask.Wait(30000))
{
this.cancellationTokenSource.Cancel();
this.synchronizeTask.Wait(30000);
}
}
catch (AggregateException ex)
{
if (ex.InnerException != null)
{
if (!(ex.InnerException is LocalizedException) && GrayException.IsGrayException(ex.InnerException))
{
ExWatson.SendReport(ex.InnerException, ReportOptions.None, null);
}
SearchEventLogger.Instance.LogFailedToSyncDiscoveryHoldToExchangeOnlineEvent(ex.InnerException);
}
}
finally
{
if (this.synchronizeTask.IsCompleted)
{
this.synchronizeTask.Dispose();
this.cancellationTokenSource.Dispose();
}
this.synchronizeTask = null;
this.cancellationTokenSource = null;
}
}
}
// Token: 0x06007276 RID: 29302 RVA: 0x0017B2BC File Offset: 0x001794BC
private CostHandle(Budget budget, Action <CostHandle> releaseAction, string description, TimeSpan preCharge)
{
if (budget == null)
{
throw new ArgumentNullException("budget");
}
if (string.IsNullOrEmpty(description))
{
ExWatson.SendReport(new ArgumentNullException("cost handle description is null or empty"), ReportOptions.DoNotCollectDumps | ReportOptions.DeepStackTraceHash, null);
}
if (preCharge < TimeSpan.Zero)
{
throw new ArgumentException("preCharge cannot be a negative timespan", "preCharge");
}
this.Budget = budget;
this.Key = Interlocked.Increment(ref CostHandle.nextKey);
this.StartTime = TimeProvider.UtcNow - preCharge;
this.PreCharge = preCharge;
this.ReleaseAction = releaseAction;
this.Budget.AddOutstandingAction(this);
this.DisposedByThread = -1;
this.DisposedAt = DateTime.MinValue;
this.Description = description;
this.MaxLiveTime = Budget.GetMaxActionTime(this.CostType);
}
public override Guid GetExternalDirectoryOrganizationId(LoadBalancingMiniRecipient recipient)
{
if (recipient.OrganizationId == OrganizationId.ForestWideOrgId)
{
return(TenantPartitionHint.ExternalDirectoryOrganizationIdForRootOrg);
}
string text;
try
{
text = recipient.OrganizationId.ToExternalDirectoryOrganizationId();
}
catch (InvalidOperationException ex)
{
string extraData = string.Format("OrgId: {0}, recipientGuid: {1}, database: {2}", recipient.OrganizationId.GetTenantGuid(), recipient.ExchangeObjectId, recipient.Database);
ExWatson.SendReport(ex, ReportOptions.None, extraData);
throw new InvalidOrganizationException(recipient.OrganizationId.ToString(), ex);
}
Guid result;
if (!Guid.TryParse(text, out result))
{
throw new InvalidOrganizationIdentityException(string.Format("{0}", recipient.OrganizationId), text);
}
return(result);
}
internal static bool CatchNonFatalExceptions(Action action, string diagnosticsDataToLog = null)
{
bool result = false;
try
{
action();
}
catch (Exception ex)
{
if (ex is OutOfMemoryException || ex is StackOverflowException || ex is ThreadAbortException)
{
throw;
}
result = true;
diagnosticsDataToLog = (diagnosticsDataToLog ?? string.Empty);
if (!(ex is StoragePermanentException) && !(ex is StorageTransientException))
{
ReportOptions options = ActivityLoggingConfig.Instance.IsDumpCollectionEnabled ? ReportOptions.None : ReportOptions.DoNotCollectDumps;
ExWatson.SendReport(ex, options, diagnosticsDataToLog);
}
InferenceDiagnosticsLog.Log("CatchNonFatalExceptions", new List <string>
{
diagnosticsDataToLog,
ex.ToString()
});
}
return(result);
}
private void reportButton_Click(object sender, EventArgs e)
{
using (new ControlWaitCursor(this))
{
ExWatson.SendReport(this.Exception);
}
}
private void ForwardKnownExceptions(Action operation, Func <Exception, bool> ignoreExceptionOperation = null)
{
Exception failure = null;
try
{
CommonUtils.CatchKnownExceptions(operation, delegate(Exception f)
{
failure = f;
});
}
catch (Exception ex)
{
MrsTracer.Service.Error("Unhandled exception in MRS:\n{0}\n{1}", new object[]
{
CommonUtils.FullExceptionMessage(ex),
ex.StackTrace
});
ExWatson.SendReport(ex);
throw;
}
if (failure != null && (ignoreExceptionOperation == null || !ignoreExceptionOperation(failure)))
{
MailboxReplicationServiceFault.Throw(failure);
}
}
private void ExecuteAsyncRequest(HttpWebRequest request)
{
try
{
ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "[PreloadSessionDataRequestCreator::ExecuteAsyncRequest]: Executing preload request");
LiveIdAuthenticationCounters.TotalSessionDataPreloadRequestsSent.Increment();
using (request.GetResponse())
{
}
}
catch (Exception ex)
{
if (!(ex is HttpException) && !(ex is WebException))
{
ExWatson.SendReport(ex, ReportOptions.DoNotFreezeThreads, null);
}
LiveIdAuthenticationCounters.TotalSessionDataPreloadRequestsFailed.Increment();
ExTraceGlobals.CoreTracer.TraceError <Exception>(0L, "[PreloadSessionDataRequestCreator::ExecuteAsyncRequest]: General exception {0}.", ex);
}
finally
{
try
{
request.Abort();
}
catch
{
}
}
}
public override byte[] Notify(int version, int type, byte[] inputParameterBytes)
{
byte[] result2;
try
{
using (new Timer(new TimerCallback(RpcServerWrapper.CrashOnCallTimeout), Thread.CurrentThread, RpcServerWrapper.notifyRequestTimeout, TimeSpan.FromMilliseconds(-1.0)))
{
WorkItemBase workItem = WorkItemBase.Deserialize(inputParameterBytes);
SyncNotificationResult result = null;
try
{
WorkItemBase workItem2 = SyncManager.EnqueueWorkItem(workItem);
result = new SyncNotificationResult(UnifiedPolicyNotificationFactory.Create(workItem2, new ADObjectId()));
}
catch (SyncAgentExceptionBase error)
{
result = new SyncNotificationResult(error);
}
NotificationRpcOutParameters notificationRpcOutParameters = new NotificationRpcOutParameters(result);
result2 = notificationRpcOutParameters.Serialize();
}
}
catch (Exception ex)
{
ExWatson.SendReport(ex, ReportOptions.None, null);
NotificationRpcOutParameters notificationRpcOutParameters = new NotificationRpcOutParameters(new SyncNotificationResult(ex));
result2 = notificationRpcOutParameters.Serialize();
}
return(result2);
}
private void GetMailTipsWorker(object state)
{
MailTipsState mailTipsState = null;
try
{
mailTipsState = (MailTipsState)state;
ExTraceGlobals.CoreCallTracer.TraceDebug((long)this.GetHashCode(), "MailTipsNotificationHandler.GetMailTipsWorker");
this.GetMailTipsInBatches(mailTipsState);
this.mailTipsNotifier.AddToPayload(mailTipsState);
this.mailTipsNotifier.PickupData();
}
catch (Exception ex)
{
ExTraceGlobals.CoreTracer.TraceError <Exception>((long)this.GetHashCode(), "Generic exception caught during GetMailTipsWorker call: {0}", ex);
if (Globals.SendWatsonReports)
{
ExTraceGlobals.CoreTracer.TraceError((long)this.GetHashCode(), "Sending watson report.");
ExWatson.AddExtraData(this.GetExtraWatsonData(mailTipsState));
ExWatson.SendReport(ex, ReportOptions.None, null);
}
}
finally
{
Interlocked.Decrement(ref this.concurrentRequestCount);
ExTraceGlobals.CoreCallTracer.TraceError <string, int>((long)this.GetHashCode(), "MailTipsNotificationHandler.GetMailTipsWorker, {0} concurrent requests count decremented to {1}", this.primarySmtpAddress, this.concurrentRequestCount);
}
}
// Token: 0x0600016E RID: 366 RVA: 0x00009AC4 File Offset: 0x00007CC4
internal void Start(MailboxSession mailboxSession)
{
if (DiscoveryHoldSynchronizer.IsOnPremDiscoveryArbitrationMailbox(mailboxSession))
{
if (this.cancellationTokenSource == null)
{
this.cancellationTokenSource = new CancellationTokenSource();
}
if (this.synchronizeTask != null && this.synchronizeTask.IsCompleted)
{
this.synchronizeTask.Dispose();
this.synchronizeTask = null;
}
if (this.synchronizeTask == null)
{
this.synchronizeTask = new Task(new Action <object>(this.Synchronize), mailboxSession.MailboxOwner.ObjectId.ObjectGuid, this.cancellationTokenSource.Token);
this.synchronizeTask.ContinueWith(delegate(Task task)
{
if (task.IsFaulted && task.Exception != null && task.Exception.InnerException != null)
{
if (!(task.Exception.InnerException is LocalizedException) && GrayException.IsGrayException(task.Exception.InnerException))
{
ExWatson.SendReport(task.Exception.InnerException, ReportOptions.None, null);
}
SearchEventLogger.Instance.LogFailedToSyncDiscoveryHoldToExchangeOnlineEvent(task.Exception.InnerException);
}
}, this.cancellationTokenSource.Token);
this.synchronizeTask.Start();
}
}
}
public void DisposePendingNotificationClientRequest()
{
if (base.OwaContext.UserContext == null)
{
return;
}
this.pendingManager = base.OwaContext.UserContext.PendingRequestManager;
object parameter = base.GetParameter("Fn");
if (parameter != null)
{
bool flag = (bool)parameter;
}
int num = 0;
try
{
base.UserContext.DangerousBeginUnlockedAction(false, out num);
if (num != 1)
{
ExWatson.SendReport(new InvalidOperationException("Thread held more than 1 lock in DisposePendingNotificationClientRequest method."), ReportOptions.None, null);
}
bool flag2 = this.pendingManager.HandleFinishRequestFromClient();
HttpResponse httpResponse = base.OwaContext.HttpContext.Response;
httpResponse.Write("var syncFnshRq = ");
httpResponse.Write(flag2 ? "1" : "0");
httpResponse.AppendHeader("X-OWA-EventResult", "0");
Utilities.MakePageNoCacheNoStore(httpResponse);
httpResponse.ContentType = Utilities.GetContentTypeString(base.ResponseContentType);
}
finally
{
base.UserContext.DangerousEndUnlockedAction(false, num);
}
}
internal void Process(HttpContext context)
{
ExTraceGlobals.WebHealthTracer.TraceDebug((long)this.GetHashCode(), "ExWebTimeoutReportHandler::ProcessHealth()");
try
{
if (ExMonitoringRequestTracker.Instance.IsKnownMonitoringRequest(context.Request))
{
context.Response.StatusCode = 200;
}
else
{
context.Response.StatusCode = 403;
}
}
catch (Exception ex)
{
Exception ex2;
Exception ex = ex2;
ExTraceGlobals.WebHealthTracer.TraceError <Exception>((long)this.GetHashCode(), "ExWebTimeoutReportHandler::Process encountered error {0}", ex);
ThreadPool.QueueUserWorkItem(delegate(object o)
{
ExWatson.SendReport(ex, ReportOptions.DoNotCollectDumps | ReportOptions.DoNotFreezeThreads, string.Empty);
});
}
}
internal static void UserContextRemovedCallback(string key, object value, CacheItemRemovedReason reason)
{
try
{
}
finally
{
try
{
UserContextManager.UserContextCacheWrapper userContextCacheWrapper = value as UserContextManager.UserContextCacheWrapper;
if (userContextCacheWrapper.UserContext != null)
{
ExTraceGlobals.UserContextTracer.TraceDebug <string, UserContext, int>(0L, "Removing user context from cache, Key={0}, User context instance={1}, Reason={2}", key, userContextCacheWrapper.UserContext, (int)reason);
UserContextManager.TerminateSession(userContextCacheWrapper.UserContext, reason);
}
}
catch (ThreadAbortException)
{
}
catch (Exception exception)
{
if (Globals.SendWatsonReports)
{
ExTraceGlobals.CoreTracer.TraceDebug(0L, "Sending watson report");
ExWatson.SendReport(exception, ReportOptions.None, null);
}
}
}
}
// Token: 0x0600031F RID: 799 RVA: 0x0000D79C File Offset: 0x0000B99C
public static void AssertOrWatson(bool condition, string formatString, params object[] parameters)
{
if (condition)
{
return;
}
StringBuilder stringBuilder = new StringBuilder("ASSERT_WATSON: ");
if (formatString != null)
{
if (parameters != null)
{
stringBuilder.AppendFormat(CultureInfo.InvariantCulture, formatString, parameters);
}
else
{
stringBuilder.Append(formatString);
}
}
string text = stringBuilder.ToString();
ExTraceGlobals.ReplayApiTracer.TraceError <string>(0L, "AssertOrWatson: Sending Watson report. {0}", text);
Exception exception = null;
try
{
throw new ExAssertException(text);
}
catch (ExAssertException ex)
{
exception = ex;
}
ExWatson.SendReport(exception, ReportOptions.None, "AssertOrWatson");
}
internal static void SendInstantMessageWatsonReport(IUserContext userContext, Exception exception)
{
Microsoft.Exchange.Clients.Owa.Server.LyncIMLogging.ExTraceGlobals.InstantMessagingTracer.TraceDebug(0L, "Exception: Type: {0} Error: {1}.", new object[]
{
exception.GetType(),
exception.Message
});
if (Globals.SendWatsonReports)
{
Microsoft.Exchange.Clients.Owa.Server.LyncIMLogging.ExTraceGlobals.InstantMessagingTracer.TraceDebug(0L, "Sending watson report");
ReportOptions options = (exception is AccessViolationException || exception is InvalidProgramException || exception is TypeInitializationException) ? ReportOptions.ReportTerminateAfterSend : ReportOptions.None;
ExWatson.AddExtraData(InstantMessageUtilities.GetExtraWatsonData(userContext));
ExWatson.SendReport(exception, options, null);
}
if (exception is AccessViolationException)
{
Microsoft.Exchange.Clients.Owa.Server.LyncIMLogging.ExTraceGlobals.InstantMessagingTracer.TraceDebug(0L, "Shutting down OWA due to unrecoverable exception");
ErrorHandlerUtilities.TerminateProcess();
return;
}
if ((exception is InvalidProgramException || exception is TypeInitializationException) && Interlocked.Exchange(ref InstantMessageUtilities.queuedDelayedRestart, 1) == 0)
{
new Thread(new ThreadStart(InstantMessageUtilities.DelayedRestartUponUnexecutableCode)).Start();
}
}
public static void FailFast(string message, bool alwaysTerminate)
{
bool flag = ExDiagnostics.FailFastMode != FailFastMode.Exception && ExDiagnostics.FailFastMode != FailFastMode.Test;
flag = (flag || alwaysTerminate);
try
{
ExDiagnostics.failFastEventHandlers(flag);
}
catch
{
}
if (ExDiagnostics.FailFastMode == FailFastMode.Test && !flag)
{
throw new TestFailFastException(message);
}
FailFastException ex = new FailFastException(message, new StackTrace(1, true).ToString());
ExWatson.SendReport(ex);
if (flag)
{
Environment.Exit(1);
return;
}
throw ex;
}
// Token: 0x0600768B RID: 30347 RVA: 0x0018667C File Offset: 0x0018487C
private void HandleTimeoutCacheWorkerException(Exception unhandledException)
{
ExTraceGlobals.ResourceHealthManagerTracer.TraceError <Exception>((long)this.GetHashCode(), "[ResourceHealthMonitorManager.HandleTimeoutCacheWorkerException] Encountered exception on timeout cache worker thread. Exception: {0}", unhandledException);
if (!(unhandledException is ThreadAbortException) && !(unhandledException is AppDomainUnloadedException))
{
ExWatson.SendReport(unhandledException);
}
}
internal static void FriendlyWatson(Exception exception)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
ExWatson.SendReport(exception, ReportOptions.DeepStackTraceHash, null);
}
private static void ReportWatson(Exception e)
{
if (!ExWatson.IsWatsonReportAlreadySent(e))
{
ExWatson.SendReport(e, ReportOptions.None, null);
ExWatson.SetWatsonReportAlreadySent(e);
}
}
private void EnforceInternalState(ContactsUploaderPerformanceTracker.InternalState expectedState, string action)
{
if (this.internalState != expectedState)
{
string message = string.Format("{0} can only be performed when state is {1}. Present state is {2}", action, expectedState, this.internalState);
ExWatson.SendReport(new InvalidOperationException(message), ReportOptions.None, null);
}
}
// Token: 0x0600105C RID: 4188 RVA: 0x0003EDF8 File Offset: 0x0003CFF8
private bool TryParseUserContextKey(string contextKey, out UserContextKey contextKeyObj)
{
bool flag = UserContextKey.TryParse(contextKey, out contextKeyObj);
if (!flag)
{
ExTraceGlobals.NotificationsCallTracer.TraceError <string>((long)this.GetHashCode(), "RemoteNotificationManager.TryParseUserContextKey - couldn't parse UserContextKey {0}, skipping cleanup", contextKey);
ExWatson.SendReport(new ArgumentException(string.Format("RemoteNotificationManager::TryParseUserContextKey - TryParse failed for UserContextKey string - '{0}'", contextKey)), ReportOptions.None, null);
}
return(flag);
}
private void LogInputData()
{
try
{
this.UpdateCustomLoggingData();
}
catch (Exception exception)
{
ExWatson.SendReport(exception, ReportOptions.DoNotCollectDumps | ReportOptions.DoNotLogProcessAndThreadIds | ReportOptions.DoNotFreezeThreads, string.Empty);
}
}
// Token: 0x06000E4B RID: 3659 RVA: 0x00055CE4 File Offset: 0x00053EE4
private static void SubmitInformationalWatson(IExchangePrincipal exchangePrincipal, TimeSpan retryTimeSpan)
{
try
{
string message = string.Format("Sharing Policy Assistant could not process mailbox for {0} even after:{1} hours. Threshold:{2} hours", exchangePrincipal.MailboxInfo.PrimarySmtpAddress, retryTimeSpan.TotalHours, SharingPolicyAssistant.RetryThresholdLimit.TotalHours);
throw new InvalidOperationException(message);
}
catch (InvalidOperationException exception)
{
ExWatson.SendReport(exception, ReportOptions.DoNotCollectDumps | ReportOptions.DeepStackTraceHash | ReportOptions.DoNotFreezeThreads, string.Empty);
}
}
private void SendWatsonReport <TException>(TException exception) where TException : Exception
{
try
{
throw exception;
}
catch (TException ex)
{
TException ex2 = (TException)((object)ex);
ExWatson.SendReport(ex2, ReportOptions.None, ex2.Message);
}
}
internal void ProcessHealth(IExWebHealthResponseWrapper response)
{
ExTraceGlobals.WebHealthTracer.TraceDebug((long)this.GetHashCode(), "ExWebHealthHandler::ProcessHealth()");
string value = "Passed";
response.AddHeader("X-MSExchApplicationHealthHandler", this.appName);
Func <ExWebHealthHandler.CustomHealthCheckResult> customHealthCallback = this.CustomHealthCallback;
if (customHealthCallback != null)
{
ExTraceGlobals.WebHealthTracer.TraceDebug((long)this.GetHashCode(), "ExWebHealthHandler::ProcessHealth calling custom health check callback ");
try
{
ExWebHealthHandler.CustomHealthCheckResult customHealthCheckResult = customHealthCallback();
ExTraceGlobals.WebHealthTracer.TraceDebug <ExWebHealthHandler.CustomHealthCheckResult>((long)this.GetHashCode(), "ExWebHealthHandler::ProcessHealth Custom health check status = {0}", customHealthCheckResult);
if (customHealthCheckResult == ExWebHealthHandler.CustomHealthCheckResult.Healthy)
{
value = "Passed";
}
else if (customHealthCheckResult == ExWebHealthHandler.CustomHealthCheckResult.NotHealthy)
{
value = "Failed";
}
else
{
value = "NonDeterministic";
}
}
catch (Exception ex)
{
Exception ex2;
Exception ex = ex2;
ExTraceGlobals.WebHealthTracer.TraceError <Exception>((long)this.GetHashCode(), "ExWebHealthHandler::ProcessHealth Callback encountered error {0}", ex);
if (ex is OutOfMemoryException)
{
value = "Failed";
}
else
{
value = "NonDeterministic";
if (this.ShouldSubmitWatson(ex))
{
ThreadPool.QueueUserWorkItem(delegate(object o)
{
ExWatson.SendReport(ex, ReportOptions.DoNotCollectDumps, string.Empty);
});
}
}
}
}
response.AddHeader("X-MSExchApplicationHealthHandlerStatus", value);
response.StatusCode = 200;
}
internal static void FriendlyWatson(Exception exception)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
ActivityContext.RaiseEvent(ActivityContext.GetCurrentActivityScope(), new ActivityEventArgs(ActivityEventType.WatsonActivity, exception.Message));
if (!ActivityContext.DisableFriendlyWatsonForTesting)
{
ExWatson.SendReport(exception, ReportOptions.DoNotCollectDumps | ReportOptions.DeepStackTraceHash, null);
}
}
private MailboxSession CreateMailboxSession(IExchangePrincipal principal)
{
if (principal.MailboxInfo.IsArchive && !principal.IsCrossSiteAccessAllowed)
{
StackTrace stackTrace = new StackTrace();
Exception exception = new OwaInvalidOperationException(string.Format("Archive Sessions should be allowed cross site, stack trace {0}", stackTrace.ToString()));
ExWatson.SendReport(exception, ReportOptions.None, null);
}
MailboxSession mailboxSession = this.userContext.LogonIdentity.CreateMailboxSession(principal, Thread.CurrentThread.CurrentCulture, HttpContext.Current.Request);
mailboxSession.ExTimeZone = this.userContext.MailboxSession.ExTimeZone;
return(mailboxSession);
}
private void BeginInvokeInternal(TaskCompleteCallback callback)
{
base.BeginInvoke(callback);
try
{
GrayException.MapAndReportGrayExceptions(delegate()
{
try
{
this.asyncResult = this.BeginInvoke();
}
catch (SoapException exception)
{
this.HandleException(exception);
}
catch (UriFormatException exception2)
{
this.HandleException(exception2);
}
catch (WebException exception3)
{
this.HandleException(exception3);
}
catch (IOException ex2)
{
SocketException ex3 = ex2.InnerException as SocketException;
if (ex3 == null)
{
ExWatson.SendReport(ex2, ReportOptions.None, null);
this.HandleException(ex2);
}
else
{
this.HandleException(ex3);
}
}
catch (LocalizedException exception4)
{
this.HandleException(exception4);
}
});
}
catch (GrayException ex)
{
this.HandleException(ex.InnerException);
}
if (this.asyncResult == null && this.CompleteAtomically())
{
this.Complete();
}
}
// Token: 0x06000961 RID: 2401 RVA: 0x0003F4C0 File Offset: 0x0003D6C0
public static bool TryHandleException(long id, string action, string source, Exception ex)
{
ExTraceGlobals.AssistantTracer.TraceError <string, string, Exception>(id, "Exception is caught during {0} for {1}: {2}", action, source, ex);
if (ex is StorageTransientException || ex is StoragePermanentException || ex is AITransientException || ex is MissingSystemMailboxException || ex is LocalServerException || ex is DataValidationException || ex is DataSourceTransientException || ex is DataSourceOperationException)
{
return(true);
}
if (GrayException.IsGrayException(ex))
{
ExWatson.SendReport(ex, ReportOptions.None, null);
return(true);
}
return(false);
}
// Token: 0x060000F9 RID: 249 RVA: 0x00008004 File Offset: 0x00006204
public static void SendWatson(Exception exception)
{
bool flag = true;
if (!bool.TryParse(ConfigurationManager.AppSettings["SendWatsonReport"], out flag))
{
flag = true;
}
if (flag)
{
ExTraceGlobals.CoreTracer.TraceDebug(0L, "Sending Watson report");
ExWatson.SendReport(exception, ReportOptions.None, null);
}
}
