private void OnEndRequest(object sender, EventArgs e)
{
HttpContext httpContext = HttpContext.Current;
if (Utility.IsResourceRequest(httpContext.GetRequestUrl().LocalPath))
{
return;
}
ActivityContextManager.CleanupActivityContext(httpContext);
}
private void OnBeginRequest(object sender, EventArgs e)
{
HttpContext httpContext = HttpContext.Current;
if (Utility.IsResourceRequest(httpContext.GetRequestUrl().LocalPath))
{
return;
}
ActivityContextManager.InitializeActivityContext(httpContext, ActivityContextLoggerId.Request);
string str = ActivityContext.ActivityId.FormatForLog();
if (HttpContext.Current.Request.QueryString.ToString().Length > 0)
{
HttpContext.Current.Response.AppendToLog("&ActID=" + str);
return;
}
HttpContext.Current.Response.AppendToLog("ActID=" + str);
}
void IDispatchMessageInspector.BeforeSendReply(ref Message reply, object correlationState)
{
PerfRecord.Current.WebServiceCallCompleted();
if (reply != null)
{
HttpResponseMessageProperty httpResponseMessageProperty;
if (reply.Properties.ContainsKey(HttpResponseMessageProperty.Name))
{
httpResponseMessageProperty = (HttpResponseMessageProperty)reply.Properties[HttpResponseMessageProperty.Name];
}
else
{
httpResponseMessageProperty = new HttpResponseMessageProperty();
reply.Properties.Add(HttpResponseMessageProperty.Name, httpResponseMessageProperty);
}
httpResponseMessageProperty.Headers.Set("Cache-Control", "no-cache, no-store");
}
RbacPrincipal.Current.RbacConfiguration.TroubleshootingContext.TraceOperationCompletedAndUpdateContext();
ActivityContextManager.CleanupActivityContext(HttpContext.Current);
}
private static void Application_Error(object sender, EventArgs e)
{
HttpContext httpContext = HttpContext.Current;
Exception ex = httpContext.GetError();
ExTraceGlobals.EventLogTracer.TraceError <EcpTraceFormatter <Exception> >(0, 0L, "Application Error: {0}", ex.GetTraceFormatter());
DDIHelper.Trace("Application Error: {0}", new object[]
{
ex.GetTraceFormatter()
});
EcpPerfCounters.AspNetErrors.Increment();
EcpEventLogConstants.Tuple_RequestFailed.LogPeriodicFailure(EcpEventLogExtensions.GetUserNameToLog(), httpContext.GetRequestUrlForLog(), ex, EcpEventLogExtensions.GetFlightInfoForLog());
RbacPrincipal current = RbacPrincipal.GetCurrent(false);
string tenantName = string.Empty;
if (current != null)
{
OrganizationId organizationId = current.RbacConfiguration.OrganizationId;
if (organizationId != null && organizationId.OrganizationalUnit != null)
{
tenantName = organizationId.OrganizationalUnit.Name;
}
}
ActivityContextLogger.Instance.LogEvent(new PeriodicFailureEvent(ActivityContext.ActivityId.FormatForLog(), tenantName, httpContext.GetRequestUrlForLog(), ex, EcpEventLogExtensions.GetFlightInfoForLog()));
ActivityContextManager.CleanupActivityContext(httpContext);
if (ex is DelegatedSecurityTokenExpiredException)
{
ErrorHandlingModule.HandleDelegatedSecurityTokenExpire(httpContext);
return;
}
if (httpContext.IsWebServiceRequest())
{
string errorCause = DiagnosticsBehavior.GetErrorCause(ex);
ErrorHandlingUtil.SendReportForCriticalException(httpContext, ex);
ErrorHandlingModule.SendJsonError(httpContext, ex, errorCause);
return;
}
if (httpContext.IsUploadRequest())
{
ErrorHandlingUtil.SendReportForCriticalException(httpContext, ex);
ErrorHandlingModule.SendJsonErrorForUpload(httpContext, ex);
return;
}
if (ex is HttpException && ex.InnerException != null)
{
ex = ex.InnerException;
}
httpContext.Request.ServerVariables["X-ECP-ERROR"] = ex.GetType().FullName;
string text = null;
string text2 = null;
if (ex is OverBudgetException)
{
text = "overbudget";
}
else if (ex is IdentityNotMappedException || ex is TransientException)
{
text = "transientserviceerror";
}
else if (ex is ObjectNotFoundException)
{
if (ex.InnerException is NonUniqueRecipientException)
{
text = "nonuniquerecipient";
}
else
{
text = "nonmailbox";
}
}
else if (ex is ServerNotInSiteException || ex is LowVersionUserDeniedException)
{
text = "lowversion";
}
else if (ex is CmdletAccessDeniedException || ex is DelegatedAccessDeniedException)
{
text = "noroles";
}
else if (ex is UrlNotFoundOrNoAccessException)
{
text = "urlnotfoundornoaccess";
}
else if (ex is BadRequestException)
{
text = "badrequest";
}
else if (ex is BadQueryParameterException)
{
text = "badqueryparameter";
}
else if (ex is ProxyFailureException)
{
text = "transientserviceerror";
}
else if (ex is ProxyCantFindCasServerException)
{
text = "proxy";
}
else if (ex is CasServerNotSupportEsoException)
{
text = "noeso";
}
else if (ex is RegionalSettingsNotConfiguredException)
{
text = "regionalsettingsnotconfigured";
}
else if (ex is SecurityException || (ErrorHandlingUtil.KnownReflectedExceptions.Value.ContainsKey("Microsoft.Exchange.Hygiene.Security.Authorization.NoValidRolesAssociatedToUserException, Microsoft.Exchange.Hygiene.Security.Authorization") && ex.GetType() == ErrorHandlingUtil.KnownReflectedExceptions.Value["Microsoft.Exchange.Hygiene.Security.Authorization.NoValidRolesAssociatedToUserException, Microsoft.Exchange.Hygiene.Security.Authorization"]))
{
text = "noroles";
}
else if (ex is ExchangeConfigurationException)
{
text = "anonymousauthenticationdisabled";
}
else if (ex is CannotAccessOptionsWithBEParamOrCookieException)
{
text = "cannotaccessoptionswithbeparamorcookie";
}
else if (ex.IsMaxRequestLengthExceededException())
{
EcpPerfCounters.RedirectToError.Increment();
text2 = httpContext.Request.AppRelativeCurrentExecutionFilePath;
}
else
{
ErrorHandlingUtil.SendReportForCriticalException(httpContext, ex);
if (!ErrorHandlingUtil.ShowIisNativeErrorPage && !ex.IsInterestingHttpException())
{
text = "unexpected";
}
}
if (text2 != null)
{
httpContext.Server.Transfer(text2, true);
return;
}
if (text != null)
{
ErrorHandlingModule.TransferToErrorPage(text, ErrorHandlingUtil.CanShowDebugInfo(ex));
}
}
private static PowerShellResults InvokeAsyncCore(Func <PowerShellResults> callback, Action <PowerShellResults> onCompleted, string uniqueUserIdentity, AsyncServiceManager.AsyncTaskBudgetManager asyncTaskBudget, string commandStringForTrace, ThrottlingType throttlingType)
{
if (string.IsNullOrEmpty(uniqueUserIdentity))
{
throw new ArgumentNullException("uniqueUserIdentity cannot be null.");
}
AsyncServiceManager.AsyncTaskThrottlingStatus asyncTaskThrottlingStatus = asyncTaskBudget.RegisterAsyncTask(uniqueUserIdentity, commandStringForTrace, throttlingType);
if (asyncTaskThrottlingStatus != AsyncServiceManager.AsyncTaskThrottlingStatus.None)
{
LocalizedString value = (asyncTaskThrottlingStatus == AsyncServiceManager.AsyncTaskThrottlingStatus.PerAppThrottlingHit) ? Strings.LongRunPerAppThrottlingHit : Strings.LongRunPerUserThrottlingHit;
asyncTaskBudget.UnregisterAsyncTask(uniqueUserIdentity, throttlingType);
return(new PowerShellResults
{
ErrorRecords = new ErrorRecord[]
{
new ErrorRecord(new InvalidOperationException(value))
}
});
}
AsyncServiceManager.WorkItem workItem = new AsyncServiceManager.WorkItem(Guid.NewGuid().ToString());
AsyncServiceManager.workItems[workItem.Id] = workItem;
CultureInfo currentCulture = CultureInfo.CurrentCulture;
IPrincipal currentPrincipal = Thread.CurrentPrincipal;
OperationContext currentOperationContext = OperationContext.Current;
HttpContext currentHttpContext = HttpContext.Current;
commandStringForTrace = ((commandStringForTrace == null) ? string.Empty : commandStringForTrace);
RbacPrincipal rbacSession = RbacPrincipal.GetCurrent(false);
ThreadPool.QueueUserWorkItem(delegate(object state)
{
int managedThreadId = Thread.CurrentThread.ManagedThreadId;
AsyncServiceManager.WorkItem workItem;
AsyncServiceManager.workerThreads[managedThreadId] = workItem;
CultureInfo currentCulture = CultureInfo.CurrentCulture;
IPrincipal currentPrincipal = Thread.CurrentPrincipal;
OperationContext value2 = OperationContext.Current;
HttpContext value3 = HttpContext.Current;
Thread.CurrentThread.CurrentCulture = (Thread.CurrentThread.CurrentUICulture = currentCulture);
Thread.CurrentPrincipal = currentPrincipal;
OperationContext.Current = currentOperationContext;
HttpContext.Current = AsyncServiceManager.CloneHttpContextForLongRunningThread(currentHttpContext);
ActivityContextManager.InitializeActivityContext(HttpContext.Current, ActivityContextLoggerId.LongRunning);
PowerShellResults powerShellResults = null;
try
{
EcpEventLogConstants.Tuple_AsyncWebRequestStarted.LogEvent(new object[]
{
uniqueUserIdentity,
managedThreadId,
commandStringForTrace
});
powerShellResults = callback();
object obj = AsyncServiceManager.workerThreads[managedThreadId];
}
catch (Exception exception)
{
powerShellResults = new PowerShellResults();
powerShellResults.ErrorRecords = new ErrorRecord[]
{
new ErrorRecord(exception)
};
EcpEventLogConstants.Tuple_AsyncWebRequestFailed.LogEvent(new object[]
{
uniqueUserIdentity,
managedThreadId,
exception.GetTraceFormatter(),
commandStringForTrace
});
ErrorHandlingUtil.SendReportForCriticalException(currentHttpContext, exception);
DDIHelper.Trace("Async work item {0}, Error: {1}", new object[]
{
workItem.Id,
exception.GetTraceFormatter()
});
}
finally
{
AsyncServiceManager.workerThreads.Remove(managedThreadId);
lock (workItem)
{
workItem.Results = powerShellResults;
ProgressRecord progressRecord = workItem.LegacyProgressRecord ?? ((workItem.ProgressCalculator == null) ? new ProgressRecord() : workItem.ProgressCalculator.ProgressRecord);
powerShellResults.ProgressRecord = progressRecord;
progressRecord.HasCompleted = true;
progressRecord.IsCancelled = workItem.Cancelled;
workItem.FinishedEvent.Set();
}
asyncTaskBudget.UnregisterAsyncTask(uniqueUserIdentity, throttlingType);
if (onCompleted != null)
{
onCompleted(powerShellResults);
}
EcpEventLogConstants.Tuple_AsyncWebRequestEnded.LogEvent(new object[]
{
uniqueUserIdentity,
managedThreadId,
commandStringForTrace
});
ActivityContextManager.CleanupActivityContext(HttpContext.Current);
Thread.CurrentThread.CurrentCulture = (Thread.CurrentThread.CurrentUICulture = currentCulture);
Thread.CurrentPrincipal = currentPrincipal;
OperationContext.Current = value2;
HttpContext.Current = value3;
GC.KeepAlive(rbacSession);
}
});
return(new PowerShellResults
{
ProgressId = workItem.Id
});
}
