public static PowerShellResults <PSObject> GetCurrentResult(string progressId) { AsyncServiceManager.WorkItem workItem = null; PowerShellResults <PSObject> progressImpl = AsyncServiceManager.GetProgressImpl <PSObject>(progressId, out workItem); if (!string.IsNullOrEmpty(progressId) && workItem != null) { List <PSObject> list = null; AsyncGetListContext asyncGetListContext = workItem.AsyncGetListContext; List <string> unicodeOutputColumnNames = asyncGetListContext.UnicodeOutputColumnNames; bool flag = unicodeOutputColumnNames != null && unicodeOutputColumnNames.Count > 0; int num = 0; int num2 = 0; lock (workItem) { list = asyncGetListContext.PsObjectCollection; if (list != null) { num = asyncGetListContext.NextFetchStartAt; num2 = list.Count; asyncGetListContext.NextFetchStartAt = num2; if (flag && asyncGetListContext.UnicodeColumns == null) { asyncGetListContext.UnicodeColumns = new List <Tuple <int, string[], string> >(num2); } progressImpl.AsyncGetListContext = asyncGetListContext; if (progressImpl.ProgressRecord == null || progressImpl.ProgressRecord.HasCompleted) { asyncGetListContext.Completed = true; workItem.AsyncGetListContext = null; } } } progressImpl.StartIndex = num; progressImpl.EndIndex = num2; progressImpl.Output = new PSObject[num2 - num]; if (list != null) { int i = num; int num3 = 0; while (i < num2) { progressImpl.Output[num3] = list[i]; list[i] = null; i++; num3++; } } } return(progressImpl); }
public static void RegisterPowerShell(PowerShell powerShell) { int managedThreadId = Thread.CurrentThread.ManagedThreadId; if (AsyncServiceManager.workerThreads.Contains(managedThreadId)) { AsyncServiceManager.WorkItem workItem = (AsyncServiceManager.WorkItem)AsyncServiceManager.workerThreads[managedThreadId]; workItem.LegacyProgressRecord = new ProgressRecord(); powerShell.Streams.Progress.DataAdded += delegate(object sender, DataAddedEventArgs e) { AsyncServiceManager.OnProgress(workItem, ((PSDataCollection <ProgressRecord>)sender)[e.Index]); }; } }
private static bool?CheckCurrentWorkItemThreadSafe(Predicate <AsyncServiceManager.WorkItem> condition) { AsyncServiceManager.WorkItem currentThreadWorkItem = AsyncServiceManager.GetCurrentThreadWorkItem(); bool?result = null; if (currentThreadWorkItem != null) { lock (currentThreadWorkItem) { result = new bool?(condition(currentThreadWorkItem)); } } return(result); }
public static void RegisterPowerShellToActivity(PowerShell powerShell, CmdletActivity activity, IEnumerable pipelineInput, out List <PSObject> psDataCollection, bool isGetListAsync) { psDataCollection = null; int managedThreadId = Thread.CurrentThread.ManagedThreadId; if (AsyncServiceManager.workerThreads.Contains(managedThreadId)) { AsyncServiceManager.WorkItem workItem = (AsyncServiceManager.WorkItem)AsyncServiceManager.workerThreads[managedThreadId]; lock (workItem) { workItem.ProgressCalculator.SetPipelineInput(pipelineInput); workItem.PowerShell = powerShell; if (isGetListAsync && workItem.AsyncGetListContext.PsObjectCollection == null) { psDataCollection = new List <PSObject>(DDIHelper.GetListDefaultResultSize * 2); workItem.AsyncGetListContext.PsObjectCollection = psDataCollection; } } if (powerShell != null) { powerShell.Streams.Progress.DataAdded += delegate(object sender, DataAddedEventArgs e) { ProgressRecord progressRecord = ((PSDataCollection <ProgressRecord>)sender)[e.Index]; if (isGetListAsync) { AsyncServiceManager.OnProgress(workItem, progressRecord); return; } List <ErrorRecord> list = new List <ErrorRecord>(); if (AsyncServiceManager.IsCurrentWorkBulkEdit()) { Collection <ErrorRecord> collection = powerShell.Streams.Error.ReadAll(); foreach (ErrorRecord errorRecord in collection) { list.Add(new ErrorRecord(errorRecord)); } } string status = (progressRecord.RecordType != ProgressRecordType.Completed) ? progressRecord.StatusDescription : string.Empty; ProgressReportEventArgs progressReportEventArgs = new ProgressReportEventArgs(list, progressRecord.PercentComplete, status); DDIHelper.Trace("Async Progress Id: {0}, ProgressReportEventArgs: {1}", new object[] { workItem.Id, progressReportEventArgs }); activity.OnPSProgressReport(progressReportEventArgs); }; } } }
public static PowerShellResults InvokeAsync(Func <PowerShellResults> callback, Action <PowerShellResults> onCompleted, string uniqueUserIdentity, AsyncTaskType taskType, string commandStringForTrace) { AsyncServiceManager.AsyncTaskBudgetManager asyncTaskBudget; ThrottlingType throttlingType; switch (taskType) { case AsyncTaskType.AsyncGetList: asyncTaskBudget = AsyncServiceManager.getListAsyncTaskBudget; throttlingType = ThrottlingType.Default; break; case AsyncTaskType.AsyncGetListPreLoad: asyncTaskBudget = AsyncServiceManager.getListAsyncTaskBudget; throttlingType = ThrottlingType.PerUser; break; default: asyncTaskBudget = AsyncServiceManager.defaultAsyncTaskBudget; throttlingType = ThrottlingType.Default; break; } return(AsyncServiceManager.InvokeAsyncCore(callback, onCompleted, uniqueUserIdentity, asyncTaskBudget, commandStringForTrace, throttlingType)); }
public PowerShellResults <JsonDictionary <object> > GetProgress(string progressId) { return(AsyncServiceManager.GetProgress(progressId)); }
protected PowerShellResults InvokeAsync(PSCommand psCommand, Action <PowerShellResults> onCompleted) { return(AsyncServiceManager.InvokeAsync(() => this.Invoke(psCommand), onCompleted, RbacPrincipal.Current.UniqueName, AsyncTaskType.Default, psCommand.ToTraceString())); }
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 }); }
public static PowerShellResults <JsonDictionary <object> > GetProgress(string progressId) { AsyncServiceManager.WorkItem workItem = null; return(AsyncServiceManager.GetProgressImpl <JsonDictionary <object> >(progressId, out workItem)); }
public static bool IsCurrentWorkBulkEdit() { return(AsyncServiceManager.CheckCurrentWorkItemThreadSafe((AsyncServiceManager.WorkItem x) => x.ProgressCalculator is BulkEditProgressCalculator || x.ProgressCalculator is MaximumCountProgressCalculator) ?? false); }
public static bool IsCurrentWorkCancelled() { return(AsyncServiceManager.CheckCurrentWorkItemThreadSafe((AsyncServiceManager.WorkItem x) => x.Cancelled) ?? false); }
private static PowerShellResults <O> InvokeCore <O>(PSCommand psCommand, RunspaceMediator runspaceMediator, IEnumerable pipelineInput, WebServiceParameters parameters, CmdletActivity activity, bool isGetListAsync) { Func <WarningRecord, string> func = null; Func <Command, string> func2 = null; PSCommandExtension.EnsureNoWriteTaskInGetRequest(psCommand, parameters); PowerShellResults <O> powerShellResults = new PowerShellResults <O>(); ExTraceGlobals.EventLogTracer.TraceInformation <string, EcpTraceFormatter <PSCommand> >(0, 0L, "{0} tries to invoke {1}. For more details, refer to task trace", RbacPrincipal.Current.NameForEventLog, psCommand.GetTraceFormatter()); using (RunspaceProxy runspaceProxy = new RunspaceProxy(runspaceMediator)) { runspaceProxy.SetVariable("ConfirmPreference", "None"); if (parameters != null) { psCommand.AddParameters(parameters); } using (PowerShell powerShell = runspaceProxy.CreatePowerShell(psCommand)) { List <PSObject> list = null; if (activity != null) { AsyncServiceManager.RegisterPowerShellToActivity(powerShell, activity, pipelineInput, out list, isGetListAsync); } else { AsyncServiceManager.RegisterPowerShell(powerShell); } int requestLatency = 0; DateTime utcNow = DateTime.UtcNow; try { TaskPerformanceRecord taskPerformanceRecord = new TaskPerformanceRecord(psCommand.GetCmdletName(), PSCommandExtension.powerShellLatencyDetectionContextFactory, EcpEventLogConstants.Tuple_EcpPowerShellInvoked, EcpEventLogConstants.Tuple_EcpPowerShellCompleted, EcpEventLogExtensions.EventLog, new IPerformanceDataProvider[] { PerformanceContext.Current, RpcDataProvider.Instance, TaskPerformanceData.CmdletInvoked, TaskPerformanceData.BeginProcessingInvoked, TaskPerformanceData.ProcessRecordInvoked, TaskPerformanceData.EndProcessingInvoked, EcpPerformanceData.PowerShellInvoke }); try { using (EcpPerformanceData.PowerShellInvoke.StartRequestTimer()) { if (list == null) { powerShellResults.Output = powerShell.Invoke <O>(pipelineInput).ToArray <O>(); } else { powerShell.Invoke <PSObject>(pipelineInput, list); powerShellResults.Output = Array <O> .Empty; } } } finally { requestLatency = (int)taskPerformanceRecord.Stop().TotalMilliseconds; IDisposable disposable2 = taskPerformanceRecord; if (disposable2 != null) { disposable2.Dispose(); } } List <ErrorRecord> list2 = new List <ErrorRecord>(); bool flag = false; foreach (ErrorRecord errorRecord in powerShell.Streams.Error) { if (!flag) { flag = PSCommandExtension.TryPatchShouldContinueException(errorRecord, psCommand, parameters); } list2.Add(new ErrorRecord(errorRecord)); } powerShellResults.ErrorRecords = list2.ToArray(); PowerShellResults powerShellResults2 = powerShellResults; IEnumerable <WarningRecord> warning = powerShell.Streams.Warning; if (func == null) { func = ((WarningRecord warningRecord) => warningRecord.Message); } powerShellResults2.Warnings = warning.Select(func).ToArray <string>(); } catch (RuntimeException ex) { PSCommandExtension.TryPatchShouldContinueException(ex.ErrorRecord, psCommand, parameters); ErrorRecord errorRecord2; if (ex.ErrorRecord != null && !(ex is ParameterBindingException)) { errorRecord2 = new ErrorRecord(ex.ErrorRecord); } else { errorRecord2 = new ErrorRecord(ex); } powerShellResults.ErrorRecords = new ErrorRecord[] { errorRecord2 }; } finally { string text = HttpContext.Current.Request.QueryString["reqId"]; ServerLogEvent logEvent = new ServerLogEvent(psCommand, pipelineInput, requestLatency, string.IsNullOrEmpty(text) ? string.Empty : text, (powerShellResults.ErrorRecords != null && powerShellResults.ErrorRecords.Length > 0) ? powerShellResults.ErrorRecords.ToLogString() : string.Empty, (powerShellResults.Output != null) ? powerShellResults.Output.Length : 0); ServerLogger.Instance.LogEvent(logEvent); } PowerShellResults powerShellResults3 = powerShellResults; IEnumerable <Command> commands = psCommand.Commands; if (func2 == null) { func2 = ((Command cmd) => cmd.CommandText); } powerShellResults3.Cmdlets = commands.Select(func2).ToArray <string>(); if (powerShellResults.ErrorRecords.Length > 0) { ExTraceGlobals.EventLogTracer.TraceError <string, EcpTraceFormatter <PSCommand>, EcpTraceFormatter <ErrorRecord[]> >(0, 0L, "{0} invoked {1} and encountered errors: {2}", RbacPrincipal.Current.NameForEventLog, psCommand.GetTraceFormatter(), powerShellResults.ErrorRecords.GetTraceFormatter()); } CmdExecuteInfo cmdExecuteInfo = CmdletLogger.CaculateLogAndSaveToContext(powerShell, utcNow, powerShellResults.ErrorRecords); if (cmdExecuteInfo != null) { powerShellResults.CmdletLogInfo = new CmdExecuteInfo[] { cmdExecuteInfo }; } } } return(powerShellResults); }