コード例 #1
0
 protected override void OnLoad(EventArgs e)
 {
     base.OnLoad(e);
     try
     {
         LinkedInConfig    linkedInConfig          = this.ReadConfiguration();
         LinkedInAppConfig config                  = this.ReadAppConfiguration();
         LinkedInAppAuthorizationResponse response = new LinkedInAuthenticator(linkedInConfig, new LinkedInWebClient(config, LinkedInSetup.Tracer), LinkedInSetup.Tracer).AuthorizeApplication(base.Request.QueryString, base.Request.Cookies, base.Response.Cookies, this.GetAuthorizationCallbackUrl());
         this.ProcessAuthorizationResponse(response);
     }
     catch (ExchangeConfigurationException ex)
     {
         EcpEventLogConstants.Tuple_BadLinkedInConfiguration.LogPeriodicEvent(EcpEventLogExtensions.GetPeriodicKeyPerUser(), new object[]
         {
             EcpEventLogExtensions.GetUserNameToLog(),
             ex
         });
         ErrorHandlingUtil.TransferToErrorPage("badlinkedinconfiguration");
     }
     catch (LinkedInAuthenticationException ex2)
     {
         EcpEventLogConstants.Tuple_LinkedInAuthorizationError.LogEvent(new object[]
         {
             EcpEventLogExtensions.GetUserNameToLog(),
             ex2
         });
         ErrorHandlingUtil.TransferToErrorPage("linkedinauthorizationerror");
     }
 }
コード例 #2
0
 public static void ShowServerErrors(ErrorInformationBase[] errorInfos, System.Web.UI.Page page)
 {
     if (errorInfos != null && errorInfos.Length > 0)
     {
         ErrorHandlingUtil.ShowServerErrors(errorInfos.ToInfos(), page);
     }
 }
コード例 #3
0
 private void DisplayResults <T>(PowerShellResults <T> results) where T : PimSubscription
 {
     if (results.Failed)
     {
         if (results.ErrorRecords[0].Exception is ManagementObjectNotFoundException)
         {
             ErrorHandlingUtil.TransferToErrorPage("liveidmismatch");
             return;
         }
         if (results.ErrorRecords[0].Exception is ValidateSecretFailureException)
         {
             ErrorHandlingUtil.TransferToErrorPage("verificationfailed");
             return;
         }
         ErrorHandlingUtil.TransferToErrorPage("verificationprocessingerror");
         return;
     }
     else
     {
         if (results.Output.Length == 0)
         {
             ErrorHandlingUtil.TransferToErrorPage("verificationprocessingerror");
             return;
         }
         this.msgText.Text = OwaOptionStrings.VerificationSuccessText(results.Output[0].EmailAddress);
         base.Title        = OwaOptionStrings.VerificationSuccessPageTitle;
         return;
     }
 }
コード例 #4
0
 protected override void OnLoad(EventArgs e)
 {
     this.EnableViewState = true;
     base.OnLoad(e);
     if (base.IsPostBack)
     {
         if (string.Compare(this.SenderButtonId, base.CommitButtonClientID) != 0 && string.Compare(this.SenderButtonId, base.BackButton.ClientID) != 0 && string.Compare(this.SenderButtonId, base.NextButton.ClientID) != 0)
         {
             this.ShowDisabledWizard(Strings.WebServiceErrorMessage);
             return;
         }
     }
     else
     {
         Exception lastError = base.Server.GetLastError();
         if (lastError != null)
         {
             InfoCore infoCore = lastError.ToErrorInformationBase().ToInfo();
             if (lastError.IsMaxRequestLengthExceededException())
             {
                 infoCore.Message = Strings.MigrationFileTooBig;
                 infoCore.Details = string.Empty;
                 base.Server.ClearError();
             }
             ErrorHandlingUtil.ShowServerError(infoCore, this.Page);
         }
     }
 }
コード例 #5
0
 protected void ShowDisabledWizard(string reason)
 {
     this.IsInError             = true;
     base.NextButton.Disabled   = true;
     base.BackButton.Disabled   = true;
     base.CommitButton.Disabled = true;
     ErrorHandlingUtil.ShowServerError(reason, string.Empty, this.Page);
 }
コード例 #6
0
 public static void ShowServerError(InfoCore errorInfo, System.Web.UI.Page page)
 {
     if (errorInfo != null)
     {
         ErrorHandlingUtil.ShowServerErrors(new InfoCore[]
         {
             errorInfo
         }, page);
     }
 }
コード例 #7
0
        private static void Application_PostAcquireRequestState(object sender, EventArgs e)
        {
            if (!VirtualDirectoryConfiguration.EcpVirtualDirectoryAnonymousAuthenticationEnabled)
            {
                ExTraceGlobals.RBACTracer.TraceInformation(0, 0L, "Anonymous authentication must be enabled in ECP.");
                throw new ExchangeConfigurationException(Strings.AnonymousAuthenticationDisabledErrorMessage);
            }
            HttpRequest             request = HttpContext.Current.Request;
            HttpBrowserCapabilities browser = request.Browser;

            if (browser != null && browser.IsBrowser("IE") && browser.MajorVersion < 7)
            {
                ErrorHandlingUtil.TransferToErrorPage("browsernotsupported");
            }
        }
コード例 #8
0
 public static void SendReportForCriticalException(HttpContext context, Exception exception)
 {
     if (exception.IsUICriticalException() && exception.IsControlPanelException())
     {
         ExWatson.AddExtraData(ErrorHandlingUtil.GetEcpWatsonExtraData(context, exception));
         EcpPerfCounters.SendWatson.Increment();
         RbacPrincipal rbacPrincipal = context.User as RbacPrincipal;
         if (rbacPrincipal != null && ExTraceConfiguration.Instance.InMemoryTracingEnabled)
         {
             TroubleshootingContext troubleshootingContext = rbacPrincipal.RbacConfiguration.TroubleshootingContext;
             troubleshootingContext.SendTroubleshootingReportWithTraces(exception, ErrorHandlingUtil.GetEcpWatsonTitle(exception, context));
             return;
         }
         ExWatson.SendReport(exception, ReportOptions.ReportTerminateAfterSend, exception.GetCustomMessage());
     }
 }
コード例 #9
0
        private InboxRule GetMessageInfo(string messageId)
        {
            InboxRules inboxRules = base.RuleService as InboxRules;
            PowerShellResults <InboxRule> mailMessage = inboxRules.GetMailMessage(new NewInboxRule
            {
                FromMessageId = new Identity(messageId, messageId),
                ValidateOnly  = new bool?(true),
                AllowExceuteThruHttpGetRequest = true
            });

            if (mailMessage.Failed)
            {
                string cause = (mailMessage.ErrorRecords[0].Exception is ManagementObjectNotFoundException) ? "messagenotfound" : "unexpected";
                ErrorHandlingUtil.TransferToErrorPage(cause);
            }
            return(mailMessage.Value);
        }
コード例 #10
0
        private void Application_PostAuthenticateRequest(object sender, EventArgs e)
        {
            HttpContext httpContext = HttpContext.Current;
            string      text        = httpContext.Request.Headers["msExchProxyUri"];

            if (!string.IsNullOrEmpty(text))
            {
                Uri    uri   = new Uri(text);
                string text2 = (uri.Segments.Length > 1) ? uri.Segments[1].TrimEnd(new char[]
                {
                    '/'
                }) : string.Empty;
                if (text2.Equals(RbacModule.ecpAppPath.Value, StringComparison.OrdinalIgnoreCase) && !text2.Equals(RbacModule.ecpAppPath.Value))
                {
                    string url = "/" + RbacModule.ecpAppPath + uri.PathAndQuery.Substring(RbacModule.ecpAppPath.Value.Length + 1);
                    httpContext.Response.Redirect(url, true);
                    return;
                }
            }
            if (httpContext.Request.HttpMethod == "GET" && !RbacModule.bypassXFrameOptions && !RbacModule.xFrameOptionsExceptionList.Contains(httpContext.Request.AppRelativeCurrentExecutionFilePath))
            {
                httpContext.Response.Headers.Set("X-Frame-Options", "SameOrigin");
            }
            AuthenticationSettings authenticationSettings = new AuthenticationSettings(httpContext);

            httpContext.User = authenticationSettings.Session;
            authenticationSettings.Session.SetCurrentThreadPrincipal();
            if (!httpContext.IsAcsOAuthRequest())
            {
                httpContext.CheckCanary();
            }
            authenticationSettings.Session.RequestReceived();
            if (authenticationSettings.Session is RbacPrincipal)
            {
                if (!OAuthHelper.IsWebRequestAllowed(httpContext))
                {
                    ErrorHandlingUtil.TransferToErrorPage("notavailableforpartner");
                }
                if (!LoginUtil.CheckUrlAccess(httpContext.Request.FilePath))
                {
                    ErrorHandlingUtil.TransferToErrorPage("noroles");
                    return;
                }
                this.FlightRewrite(httpContext);
            }
        }
コード例 #11
0
        private void ImportContactsRequest()
        {
            if (base.Request.Files.Count == 0 || string.IsNullOrEmpty(base.Request.Files[0].FileName))
            {
                this.currentPage = ImportContactListForm.ImportContactListPageState.UploadCsvFilePage;
                ErrorHandlingUtil.ShowServerError(OwaOptionStrings.ImportContactListNoFileUploaded, string.Empty, this.Page);
                return;
            }
            HttpPostedFile httpPostedFile = base.Request.Files[0];

            this.filename = string.Empty;
            try
            {
                this.filename = Path.GetFileName(httpPostedFile.FileName);
            }
            catch (ArgumentException)
            {
                this.filename = null;
            }
            if (string.IsNullOrEmpty(this.filename))
            {
                this.currentPage = ImportContactListForm.ImportContactListPageState.UploadCsvFilePage;
                ErrorHandlingUtil.ShowServerError(OwaOptionClientStrings.FileUploadFailed, string.Empty, this.Page);
                return;
            }
            ImportContactListParameters importContactListParameters = new ImportContactListParameters();

            importContactListParameters.CSVStream = httpPostedFile.InputStream;
            ImportContactList importContactList = new ImportContactList();
            PowerShellResults <ImportContactsResult> powerShellResults = importContactList.ImportObject(Identity.FromExecutingUserId(), importContactListParameters);

            if (!powerShellResults.Failed)
            {
                this.importResult = powerShellResults.Output[0];
                this.currentPage  = ImportContactListForm.ImportContactListPageState.ImportContactListResultPage;
                return;
            }
            this.currentPage = ImportContactListForm.ImportContactListPageState.UploadCsvFilePage;
            if (powerShellResults.ErrorRecords[0].Exception is ImportContactsException)
            {
                ErrorHandlingUtil.ShowServerError(powerShellResults.ErrorRecords[0].Message, string.Empty, this.Page);
                return;
            }
            ErrorHandlingUtil.ShowServerErrors(powerShellResults.ErrorRecords, this.Page);
        }
コード例 #12
0
        public ErrorInformationBase(Exception exception)
        {
            this.Exception = exception;
            if (string.IsNullOrEmpty(this.Message))
            {
                this.Message = exception.Message;
            }
            if (ErrorHandlingUtil.CanShowDebugInfo(this.Exception))
            {
                this.CallStack = this.Exception.ToTraceString();
            }
            IExceptionDetails exceptionDetails = this.Exception as IExceptionDetails;

            if (exceptionDetails != null)
            {
                this.Details = exceptionDetails.Details;
            }
        }
コード例 #13
0
        protected override void OnLoad(EventArgs e)
        {
            string subscriptionTypeParam = this.Context.Request.QueryString["st"];
            string subscriptionGuidParam = this.Context.Request.QueryString["su"];
            string text = this.Context.Request.QueryString["ss"];
            AggregationSubscriptionType aggregationSubscriptionType;
            Guid   subscriptionId;
            string queryParam;

            if (!this.ValidateUrlParameters(subscriptionTypeParam, subscriptionGuidParam, text, out aggregationSubscriptionType, out subscriptionId, out queryParam))
            {
                throw new BadQueryParameterException(queryParam);
            }
            ADObjectId executingUserId = RbacPrincipal.Current.ExecutingUserId;
            AggregationSubscriptionIdentity    subId = new AggregationSubscriptionIdentity(executingUserId, subscriptionId);
            AggregationSubscriptionIdParameter aggregationSubscriptionIdParameter = new AggregationSubscriptionIdParameter(subId);
            string text2 = aggregationSubscriptionIdParameter.ToString();

            if (text2 == null)
            {
                ErrorHandlingUtil.TransferToErrorPage("unexpected");
                return;
            }
            if (aggregationSubscriptionType == AggregationSubscriptionType.Pop)
            {
                PopSubscriptions   popSubscriptions   = new PopSubscriptions();
                SetPopSubscription setPopSubscription = new SetPopSubscription();
                setPopSubscription.ValidateSecret = text;
                setPopSubscription.AllowExceuteThruHttpGetRequest = true;
                Identity identity = new Identity(text2, text2);
                PowerShellResults <PopSubscription> results = popSubscriptions.SetObject(identity, setPopSubscription);
                this.DisplayResults <PopSubscription>(results);
                return;
            }
            ImapSubscriptions   imapSubscriptions   = new ImapSubscriptions();
            SetImapSubscription setImapSubscription = new SetImapSubscription();

            setImapSubscription.ValidateSecret = text;
            setImapSubscription.AllowExceuteThruHttpGetRequest = true;
            Identity identity2 = new Identity(text2, text2);
            PowerShellResults <ImapSubscription> results2 = imapSubscriptions.SetObject(identity2, setImapSubscription);

            this.DisplayResults <ImapSubscription>(results2);
        }
コード例 #14
0
        protected override void OnLoad(EventArgs e)
        {
            string a;

            if ((a = this.Provider.ToLowerInvariant()) != null)
            {
                if (a == "facebook")
                {
                    base.Server.Transfer("~/Connect/FacebookSetup.aspx");
                    return;
                }
                if (a == "linkedin")
                {
                    base.Server.Transfer("~/Connect/LinkedInSetup.aspx");
                    return;
                }
            }
            ErrorHandlingUtil.TransferToErrorPage("badrequesttopeopleconnectmainbadproviderparameter");
        }
コード例 #15
0
 protected override void OnLoad(EventArgs e)
 {
     base.OnLoad(e);
     try
     {
         this.ctlUserConsentForm.Visible = false;
         FacebookAuthenticatorConfig config = this.ReadConfiguration();
         FacebookAuthenticator       facebookAuthenticator = new FacebookAuthenticator(config);
         AppAuthorizationResponse    response = FacebookAuthenticator.ParseAppAuthorizationResponse(base.Request.QueryString);
         if (!FacebookAuthenticator.IsRedirectFromFacebook(response))
         {
             string text = facebookAuthenticator.GetAppAuthorizationUri().ToString();
             if (this.IsReconnect())
             {
                 base.Response.Redirect(text);
             }
             else
             {
                 this.ctlUserConsentForm.Visible          = true;
                 this.ctlUserConsentForm.AuthorizationUrl = text;
             }
         }
         else if (facebookAuthenticator.IsAuthorizationGranted(response))
         {
             this.ProcessAuthorizationGranted(response);
         }
         else
         {
             this.ProcessAuthorizationDenied();
         }
     }
     catch (ExchangeConfigurationException ex)
     {
         EcpEventLogConstants.Tuple_BadFacebookConfiguration.LogPeriodicEvent(EcpEventLogExtensions.GetPeriodicKeyPerUser(), new object[]
         {
             EcpEventLogExtensions.GetUserNameToLog(),
             ex
         });
         ErrorHandlingUtil.TransferToErrorPage("badfacebookconfiguration");
     }
 }
コード例 #16
0
 protected override void OnInit(EventArgs e)
 {
     base.OnInit(e);
     this.InstallMarketplaceAssetID = this.Context.Request.QueryString["AssetID"];
     this.MarketplaceQueryMarket    = this.Context.Request.QueryString["LC"];
     this.Scope        = this.Context.Request.QueryString["Scope"];
     this.DeploymentId = this.Context.Request.QueryString["DeployId"];
     this.Etoken       = this.GetClientTokenParameter(this.Context.Request.RawUrl);
     if (!string.IsNullOrWhiteSpace(this.InstallMarketplaceAssetID) && !string.IsNullOrWhiteSpace(this.MarketplaceQueryMarket))
     {
         return;
     }
     EcpEventLogConstants.Tuple_MissingRequiredParameterDetected.LogPeriodicEvent(EcpEventLogExtensions.GetPeriodicKeyPerUser(), new object[]
     {
         EcpEventLogExtensions.GetUserNameToLog(),
         this.Context.GetRequestUrlForLog(),
         (this.InstallMarketplaceAssetID != null) ? this.InstallMarketplaceAssetID : string.Empty,
         (this.MarketplaceQueryMarket != null) ? this.MarketplaceQueryMarket : string.Empty
     });
     ErrorHandlingUtil.TransferToErrorPage("badofficecallback");
 }
コード例 #17
0
 private void ExecuteUpload()
 {
     try
     {
         if (base.Request.Files.Count == 0 || string.IsNullOrEmpty(base.Request.Files[0].FileName))
         {
             ErrorHandlingUtil.ShowServerError(Strings.ISVNoFileUploaded, string.Empty, this.Page);
         }
         else
         {
             DLPISVService  dlpisvservice  = new DLPISVService();
             HttpPostedFile httpPostedFile = base.Request.Files[0];
             byte[]         array          = new byte[httpPostedFile.ContentLength];
             httpPostedFile.InputStream.Read(array, 0, array.Length);
             PowerShellResults powerShellResults = dlpisvservice.ProcessUpload(new DLPNewPolicyUploadParameters
             {
                 Mode         = this.policyMode.SelectedValue,
                 State        = RuleState.Enabled.ToString(),
                 Name         = this.name.Text,
                 Description  = this.description.Text,
                 TemplateData = array
             });
             if (powerShellResults.Failed)
             {
                 ErrorHandlingUtil.ShowServerErrors(powerShellResults.ErrorRecords, this.Page);
             }
             else
             {
                 this.Page.RegisterStartupScript("windowclose", string.Format("<script>{0}</script>", "window.opener.RefreshPolicyListView();window.close();"));
             }
         }
     }
     catch (Exception ex)
     {
         ErrorHandlingUtil.ShowServerError(ex.Message, string.Empty, this.Page);
     }
 }
コード例 #18
0
        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));
            }
        }
コード例 #19
0
 bool IErrorHandler.HandleError(Exception error)
 {
     ErrorHandlingUtil.SendReportForCriticalException(HttpContext.Current, error);
     return(false);
 }
コード例 #20
0
        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
            });
        }