public bool Execute()
{
ActivityImplementationContext activityImplementationContext = null;
if (this.commandQueue != null)
{
bool flag = this.commandQueue.TryDequeue(out activityImplementationContext);
lock (this.SyncRoot)
{
while (flag)
{
RunCommandsArguments runCommandsArgument = new RunCommandsArguments(this.ActivityParams, this.Output, this.Input, this, this.WorkflowHost, this.RunInProc, this.ParameterDefaults, this.ActivityType, this.PrepareSession, this.ActivityObject, activityImplementationContext);
Interlocked.Increment(ref this.CommandsRunningCount);
PSActivity.BeginRunOneCommand(runCommandsArgument);
flag = this.commandQueue.TryDequeue(out activityImplementationContext);
}
this.AllCommandsStarted = true;
}
return(true);
}
else
{
throw new InvalidOperationException("commandQueue");
}
}
internal RunCommandsArguments(ActivityParameters activityParameters, PSDataCollection <PSObject> output, PSDataCollection <PSObject> input, PSActivityContext psActivityContext, PSWorkflowHost workflowHost, bool runInProc, Dictionary <string, object> parameterDefaults, Type activityType, PrepareSessionDelegate prepareSession, object activityObject, ActivityImplementationContext implementationContext)
{
this.ActivityParameters = activityParameters;
this.Output = output;
this.Input = input;
this.PSActivityContext = psActivityContext;
this.ParameterDefaults = parameterDefaults;
this.ActivityType = activityType;
this.Delegate = prepareSession;
this.ActivityObject = activityObject;
this.WorkflowHost = workflowHost;
this.ImplementationContext = implementationContext;
this.CommandExecutionType = RunCommandsArguments.DetermineCommandExecutionType(implementationContext.ConnectionInfo, runInProc, activityType, psActivityContext);
}
internal override void DoCleanup(RunCommandsArguments args, WaitCallback callback)
{
PSWorkflowHost workflowHost = args.WorkflowHost;
WSManConnectionInfo connectionInfo = args.ImplementationContext.PowerShellInstance.Runspace.ConnectionInfo as WSManConnectionInfo;
args.CleanupTimeout = this.timeout;
if (connectionInfo != null)
{
workflowHost.RemoteRunspaceProvider.RequestCleanup(connectionInfo, callback, args);
}
else
{
if (callback != null)
{
callback(args);
return;
}
}
}
internal override void DoCleanup(RunCommandsArguments args, WaitCallback callback)
{
PSWorkflowHost workflowHost = args.WorkflowHost;
WSManConnectionInfo connectionInfo = args.ImplementationContext.PowerShellInstance.Runspace.ConnectionInfo as WSManConnectionInfo;
args.CleanupTimeout = this.timeout;
if (connectionInfo != null)
{
workflowHost.RemoteRunspaceProvider.RequestCleanup(connectionInfo, callback, args);
}
else
{
if (callback != null)
{
callback(args);
return;
}
}
}
/// <summary>
/// Method that needs to be overridden to perform the actual
/// cleanup action
/// </summary>
/// <param name="args">RunCommandsArguments</param>
/// <param name="callback">callback to call when cleanup
/// is done</param>
/// <remarks>The signature forces this method to be internal</remarks>
internal virtual void DoCleanup(RunCommandsArguments args, WaitCallback callback)
{
throw new NotImplementedException();
}
private static bool HandleRunOneCommandException(RunCommandsArguments args, Exception e)
{
bool flag = false;
PSActivityContext pSActivityContext = args.PSActivityContext;
ActivityImplementationContext implementationContext = args.ImplementationContext;
ActivityParameters activityParameters = args.ActivityParameters;
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
PowerShell powerShellInstance = implementationContext.PowerShellInstance;
object[] objArray = new object[1];
objArray[0] = powerShellInstance;
traceSource.WriteMessage(string.Format(CultureInfo.InvariantCulture, "Exception handling for command {0}.", objArray));
object[] message = new object[1];
message[0] = e.Message;
traceSource.WriteMessage(string.Format(CultureInfo.InvariantCulture, "Got exception running command: {0}.", message));
int actionAttempts = 0x7fffffff;
if (!pSActivityContext.IsCanceled)
{
if (pSActivityContext.runningCommands.ContainsKey(powerShellInstance))
{
actionAttempts = pSActivityContext.runningCommands[powerShellInstance].ActionAttempts;
}
flag = PSActivity.HandleFailure(actionAttempts, activityParameters.ActionRetryCount, activityParameters.ActionRetryInterval, implementationContext, "ActivityActionFailed", e, pSActivityContext);
}
}
return flag;
}
private static void BeginSetVariablesInRemoteRunspace(RunCommandsArguments args)
{
Runspace runspace = args.ImplementationContext.PowerShellInstance.Runspace;
PSActivityEnvironment pSActivityEnvironment = args.ImplementationContext.PSActivityEnvironment;
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
traceSource.WriteMessage("BEGIN BeginSetVariablesInRemoteRunspace");
PowerShell powerShell = PowerShell.Create();
powerShell.Runspace = runspace;
powerShell.AddScript("\r\n Get-Variable -Exclude input | Remove-Variable 2> $Null;$error.Clear();$input | Foreach-Object {$nvp=$_}; foreach($k in $nvp.keys){set-variable -name $k -value $nvp[$k]}\r\n ");
Dictionary<string, object> variablesToSetInRunspace = PSActivity.GetVariablesToSetInRunspace(pSActivityEnvironment);
PSDataCollection<object> objs = new PSDataCollection<object>();
objs.Add(variablesToSetInRunspace);
PSDataCollection<object> objs1 = objs;
objs1.Complete();
args.HelperCommand = powerShell;
args.HelperCommandInput = objs1;
PSActivity.BeginInvokeOnPowershellCommand(powerShell, objs1, null, new AsyncCallback(PSActivity.SetVariablesCallback), args);
traceSource.WriteMessage("END BeginSetVariablesInRemoteRunspace");
}
}
private static void InitializeOneCommand(RunCommandsArguments args)
{
ActivityParameters activityParameters = args.ActivityParameters;
PSActivityContext pSActivityContext = args.PSActivityContext;
PSWorkflowHost workflowHost = args.WorkflowHost;
//TODO: REIVEW: args.ParameterDefaults;
Type activityType = args.ActivityType;
PrepareSessionDelegate @delegate = args.Delegate;
object activityObject = args.ActivityObject;
ActivityImplementationContext implementationContext = args.ImplementationContext;
int commandExecutionType = args.CommandExecutionType;
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
PowerShell powerShellInstance = implementationContext.PowerShellInstance;
object[] objArray = new object[1];
objArray[0] = powerShellInstance;
traceSource.WriteMessage(string.Format(CultureInfo.InvariantCulture, "Beginning initialization for command '{0}'.", objArray));
lock (pSActivityContext.runningCommands)
{
if (!PSActivity.CheckForCancel(pSActivityContext))
{
if (!pSActivityContext.runningCommands.ContainsKey(powerShellInstance))
{
pSActivityContext.runningCommands[powerShellInstance] = new RetryCount();
}
}
else
{
return;
}
}
if (!PSActivity.CheckForCancel(pSActivityContext))
{
RetryCount item = pSActivityContext.runningCommands[powerShellInstance];
item.ActionAttempts = item.ActionAttempts + 1;
if (commandExecutionType != 5)
{
PSActivity.UpdatePowerShell(implementationContext, pSActivityContext, activityType, @delegate, activityObject);
}
int num = commandExecutionType;
switch (num)
{
case 0:
{
PSActivity.InitializeActivityEnvironmentAndAddRequiredModules(implementationContext, activityParameters);
workflowHost.LocalRunspaceProvider.BeginGetRunspace(null, 0, 0, new AsyncCallback(PSActivity.LocalRunspaceProviderCallback), args);
goto Label1;
}
case 1:
case 5:
{
Label1:
break;
}
case 2:
{
PSActivity.InitializeActivityEnvironmentAndAddRequiredModules(implementationContext, activityParameters);
goto Label1;
}
case 3:
{
PSActivity.DisposeRunspaceInPowerShell(powerShellInstance, false);
PSActivity.InitializeActivityEnvironmentAndAddRequiredModules(implementationContext, activityParameters);
WSManConnectionInfo connectionInfo = powerShellInstance.Runspace.ConnectionInfo as WSManConnectionInfo;
uint? connectionRetryCount = activityParameters.ConnectionRetryCount;
uint? connectionRetryInterval = activityParameters.ConnectionRetryInterval;
workflowHost.RemoteRunspaceProvider.BeginGetRunspace(connectionInfo, connectionRetryCount.GetValueOrDefault(0), connectionRetryInterval.GetValueOrDefault(0), new AsyncCallback(PSActivity.ConnectionManagerCallback), args);
goto Label1;
}
case 4:
{
workflowHost.LocalRunspaceProvider.BeginGetRunspace(null, 0, 0, new AsyncCallback(PSActivity.LocalRunspaceProviderCallback), args);
goto Label1;
}
default:
{
goto Label1;
}
}
}
}
}
private static void ReleaseResourcesAndCheckForEnd(System.Management.Automation.PowerShell ps, RunCommandsArguments args, bool removeHandlersFromStreams, bool attemptRetry)
{
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
PSActivityContext pSActivityContext = args.PSActivityContext;
if (removeHandlersFromStreams)
{
PSActivity.RemoveHandlersFromStreams(ps, args);
}
PSActivity.RunOneCommandFinally(args, attemptRetry);
traceSource.WriteMessage(string.Format(CultureInfo.InvariantCulture, "PowerShell activity: Finished running command.", new object[0]));
PSActivity.DecrementRunningCountAndCheckForEnd(pSActivityContext);
}
}
private static void BeginRunspaceInitializeSetup(RunCommandsArguments args)
{
PSActivityEnvironment pSActivityEnvironment = args.ImplementationContext.PSActivityEnvironment;
Runspace runspace = args.ImplementationContext.PowerShellInstance.Runspace;
string[] pSRequiredModules = args.ActivityParameters.PSRequiredModules;
PSActivityContext pSActivityContext = args.PSActivityContext;
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
traceSource.WriteMessage("BEGIN BeginRunspaceInitializeSetup");
if (args.CommandExecutionType != 4)
{
if (runspace.ConnectionInfo == null)
{
try
{
PSActivity.SetVariablesInRunspaceUsingProxy(pSActivityEnvironment, runspace);
}
catch (Exception exception1)
{
Exception exception = exception1;
bool flag = PSActivity.HandleRunOneCommandException(args, exception);
if (!flag)
{
traceSource.WriteMessage("Setting variables for command failed, returning");
PSActivity.RunOneCommandFinally(args, false);
}
else
{
traceSource.WriteMessage("Setting variables for command failed, attempting retry");
PSActivity.CloseRunspace(args.ImplementationContext.PowerShellInstance.Runspace, args.CommandExecutionType, args.WorkflowHost, pSActivityContext);
PSActivity.BeginActionRetry(args);
}
PSActivity.DecrementRunningCountAndCheckForEnd(pSActivityContext);
return;
}
}
else
{
PSActivity.BeginSetVariablesInRemoteRunspace(args);
return;
}
}
if ((int)pSRequiredModules.Length <= 0)
{
PSActivity.BeginPowerShellInvocation(args);
}
else
{
PSActivity.BeginImportRequiredModules(args);
}
traceSource.WriteMessage("END BeginRunspaceInitializeSetup");
}
}
private static void ExecuteCleanupActivity(RunCommandsArguments args)
{
PSCleanupActivity activityObject = args.ActivityObject as PSCleanupActivity;
if (activityObject != null)
{
activityObject.DoCleanup(args, new WaitCallback(PSActivity.CleanupActivityCallback));
return;
}
else
{
throw new ArgumentNullException("args");
}
}
public void Cancel()
{
ActivityImplementationContext activityImplementationContext = null;
IAsyncResult asyncResult = null;
if (this.WorkflowHost != null)
{
if (this.commandQueue != null)
{
while (!this.commandQueue.IsEmpty)
{
bool flag = this.commandQueue.TryDequeue(out activityImplementationContext);
if (!flag)
{
continue;
}
PowerShell powerShellInstance = activityImplementationContext.PowerShellInstance;
object[] objArray = new object[1];
objArray[0] = powerShellInstance;
this._tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture, "PowerShell activity: Cancelling pending command {0}.", objArray));
powerShellInstance.Dispose();
}
}
PSResumableActivityHostController pSActivityHostController = this.WorkflowHost.PSActivityHostController as PSResumableActivityHostController;
if (pSActivityHostController == null)
{
PSOutOfProcessActivityController pSOutOfProcessActivityController = this.WorkflowHost.PSActivityHostController as PSOutOfProcessActivityController;
if (pSOutOfProcessActivityController != null)
{
while (this.AsyncResults.Count > 0)
{
this.AsyncResults.TryDequeue(out asyncResult);
pSOutOfProcessActivityController.CancelInvokePowerShell(asyncResult);
}
}
}
else
{
pSActivityHostController.StopAllResumablePSCommands(this.JobInstanceId);
}
while (this.runningCommands.Count > 0)
{
PowerShell powerShell = null;
lock (this.runningCommands)
{
Dictionary <PowerShell, RetryCount> .KeyCollection.Enumerator enumerator = this.runningCommands.Keys.GetEnumerator();
try
{
if (enumerator.MoveNext())
{
PowerShell current = enumerator.Current;
powerShell = current;
}
}
finally
{
enumerator.Dispose();
}
if (powerShell == null)
{
break;
}
}
if (powerShell.InvocationStateInfo.State == PSInvocationState.Running)
{
object[] objArray1 = new object[1];
objArray1[0] = powerShell;
this._tracer.WriteMessage(string.Format(CultureInfo.InvariantCulture, "PowerShell activity: Stopping command {0}.", objArray1));
try
{
powerShell.Stop();
}
catch (NullReferenceException nullReferenceException)
{
}
catch (InvalidOperationException invalidOperationException)
{
}
}
if (powerShell.InvocationStateInfo.State != PSInvocationState.Completed || powerShell.HadErrors)
{
this.Failed = true;
}
int num = RunCommandsArguments.DetermineCommandExecutionType(powerShell.Runspace.ConnectionInfo as WSManConnectionInfo, this.RunInProc, this.ActivityType, this);
if (num != 1)
{
PSActivity.CloseRunspaceAndDisposeCommand(powerShell, this.WorkflowHost, this, num);
}
this.runningCommands.Remove(powerShell);
}
return;
}
else
{
throw new InvalidOperationException("WorkflowHost");
}
}
private static void BeginActionRetry(RunCommandsArguments args)
{
PSActivityContext pSActivityContext = args.PSActivityContext;
Interlocked.Increment(ref pSActivityContext.CommandsRunningCount);
PSActivity.BeginRunOneCommand(args);
}
private static void BeginExecuteOneCommand(RunCommandsArguments args)
{
PSActivityContext pSActivityContext = args.PSActivityContext;
PSWorkflowHost workflowHost = args.WorkflowHost;
ActivityImplementationContext implementationContext = args.ImplementationContext;
PSDataCollection<PSObject> input = args.Input;
PSDataCollection<PSObject> output = args.Output;
int commandExecutionType = args.CommandExecutionType;
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
PowerShell powerShellInstance = implementationContext.PowerShellInstance;
object[] objArray = new object[1];
objArray[0] = powerShellInstance;
traceSource.WriteMessage(string.Format(CultureInfo.InvariantCulture, "BEGIN BeginExecuteOneCommand {0}.", objArray));
int num = commandExecutionType;
switch (num)
{
case 0:
{
powerShellInstance.Runspace.ThreadOptions = PSThreadOptions.UseCurrentThread;
ThreadPool.QueueUserWorkItem(new WaitCallback(PSActivity.InitializeRunspaceAndExecuteCommandWorker), args);
break;
}
case 1:
{
ThreadPool.QueueUserWorkItem(new WaitCallback(PSActivity.ExecuteOneRunspaceFreeCommandWorker), args);
break;
}
case 2:
{
if (!PSActivity.CheckForCancel(pSActivityContext))
{
PSResumableActivityHostController pSActivityHostController = workflowHost.PSActivityHostController as PSResumableActivityHostController;
if (pSActivityHostController == null)
{
PSOutOfProcessActivityController pSOutOfProcessActivityController = workflowHost.PSActivityHostController as PSOutOfProcessActivityController;
if (pSOutOfProcessActivityController == null)
{
break;
}
PSActivity.AddHandlersToStreams(powerShellInstance, args);
IAsyncResult asyncResult = pSOutOfProcessActivityController.BeginInvokePowerShell(powerShellInstance, input, output, implementationContext.PSActivityEnvironment, new AsyncCallback(PSActivity.ActivityHostManagerCallback), args);
pSActivityContext.AsyncResults.Enqueue(asyncResult);
break;
}
else
{
PowerShellStreams<PSObject, PSObject> powerShellStream = new PowerShellStreams<PSObject, PSObject>();
if (!pSActivityHostController.SupportDisconnectedPSStreams)
{
powerShellStream.InputStream = input;
powerShellStream.OutputStream = output;
powerShellStream.DebugStream = powerShellInstance.Streams.Debug;
powerShellStream.ErrorStream = powerShellInstance.Streams.Error;
powerShellStream.ProgressStream = powerShellInstance.Streams.Progress;
powerShellStream.VerboseStream = powerShellInstance.Streams.Verbose;
powerShellStream.WarningStream = powerShellInstance.Streams.Warning;
}
else
{
powerShellStream.InputStream = input;
powerShellStream.OutputStream = new PSDataCollection<PSObject>();
powerShellStream.ErrorStream = new PSDataCollection<ErrorRecord>();
powerShellStream.DebugStream = new PSDataCollection<DebugRecord>();
powerShellStream.ProgressStream = new PSDataCollection<ProgressRecord>();
powerShellStream.VerboseStream = new PSDataCollection<VerboseRecord>();
powerShellStream.WarningStream = new PSDataCollection<WarningRecord>();
}
pSActivityHostController.StartResumablePSCommand(args.PSActivityContext.JobInstanceId, (Bookmark)args.PSActivityContext.AsyncState, powerShellInstance, powerShellStream, implementationContext.PSActivityEnvironment, (PSActivity)pSActivityContext.ActivityObject);
break;
}
}
else
{
return;
}
}
case 3:
{
PSActivity.ArgsTableForRunspaces.TryAdd(powerShellInstance.Runspace.InstanceId, args);
PSActivity.InitializeRunspaceAndExecuteCommandWorker(args);
break;
}
case 4:
{
ThreadPool.QueueUserWorkItem(new WaitCallback(PSActivity.InitializeRunspaceAndExecuteCommandWorker), args);
break;
}
case 5:
{
PSActivity.ExecuteCleanupActivity(args);
break;
}
}
traceSource.WriteMessage("END BeginExecuteOneCommand");
}
}
private static void AddHandlersToStreams(System.Management.Automation.PowerShell commandToRun, RunCommandsArguments args)
{
if (commandToRun == null || args == null)
{
return;
}
else
{
bool mergeErrorToOutput = args.PSActivityContext.MergeErrorToOutput;
if (mergeErrorToOutput)
{
commandToRun.Streams.Error.DataAdded += new EventHandler<DataAddedEventArgs>(PSActivity.HandleErrorDataAdded);
}
if (args.PSActivityContext.Output != null)
{
args.PSActivityContext.Output.DataAdding += new EventHandler<DataAddingEventArgs>(PSActivity.HandleOutputDataAdding);
}
commandToRun.Streams.Error.DataAdding += new EventHandler<DataAddingEventArgs>(PSActivity.HandleErrorDataAdding);
commandToRun.Streams.Progress.DataAdding += new EventHandler<DataAddingEventArgs>(PSActivity.HandleProgressDataAdding);
commandToRun.Streams.Verbose.DataAdding += new EventHandler<DataAddingEventArgs>(PSActivity.HandleInformationalRecordDataAdding);
commandToRun.Streams.Warning.DataAdding += new EventHandler<DataAddingEventArgs>(PSActivity.HandleInformationalRecordDataAdding);
commandToRun.Streams.Debug.DataAdding += new EventHandler<DataAddingEventArgs>(PSActivity.HandleInformationalRecordDataAdding);
PSActivity.ArgsTable.TryAdd(commandToRun.InstanceId, args);
return;
}
}
private static void RunspaceDisconnectedCallback(RunCommandsArguments args, Exception runspaceDisconnectedException)
{
PSActivityContext pSActivityContext = args.PSActivityContext;
ActivityImplementationContext implementationContext = args.ImplementationContext;
PowerShell powerShellInstance = implementationContext.PowerShellInstance;
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
traceSource.WriteMessage("Executing callback when remote runspace got disconnected");
bool flag = false;
try
{
try
{
if (!PSActivity.CheckForCancel(pSActivityContext))
{
implementationContext.CleanUp();
if (args.HelperCommand != null)
{
args.HelperCommand.Dispose();
args.HelperCommand = null;
}
traceSource.WriteMessage(string.Format(CultureInfo.InvariantCulture, "Runspace disconnected is treated as an errors in executing the command.", new object[0]));
pSActivityContext.Failed = true;
throw runspaceDisconnectedException;
}
else
{
return;
}
}
catch (Exception exception1)
{
Exception exception = exception1;
flag = PSActivity.HandleRunOneCommandException(args, exception);
if (flag)
{
PSActivity.BeginActionRetry(args);
}
}
}
finally
{
PSActivity.RemoveHandlersFromStreams(powerShellInstance, args);
PSActivity.RunOneCommandFinally(args, flag);
traceSource.WriteMessage(string.Format(CultureInfo.InvariantCulture, "PowerShell activity: Finished running command.", new object[0]));
PSActivity.DecrementRunningCountAndCheckForEnd(pSActivityContext);
}
}
}
private static void RunOneCommandFinally(RunCommandsArguments args, bool attemptRetry)
{
if (!attemptRetry)
{
PSActivityContext pSActivityContext = args.PSActivityContext;
ActivityImplementationContext implementationContext = args.ImplementationContext;
PSWorkflowHost workflowHost = args.WorkflowHost;
PowerShell powerShellInstance = implementationContext.PowerShellInstance;
lock (pSActivityContext.runningCommands)
{
pSActivityContext.runningCommands.Remove(powerShellInstance);
}
if (!pSActivityContext.IsCanceled && args.CommandExecutionType != 1)
{
PSActivity.CloseRunspaceAndDisposeCommand(powerShellInstance, workflowHost, pSActivityContext, args.CommandExecutionType);
}
return;
}
else
{
return;
}
}
public bool Execute()
{
ActivityImplementationContext activityImplementationContext = null;
if (this.commandQueue != null)
{
bool flag = this.commandQueue.TryDequeue(out activityImplementationContext);
lock (this.SyncRoot)
{
while (flag)
{
RunCommandsArguments runCommandsArgument = new RunCommandsArguments(this.ActivityParams, this.Output, this.Input, this, this.WorkflowHost, this.RunInProc, this.ParameterDefaults, this.ActivityType, this.PrepareSession, this.ActivityObject, activityImplementationContext);
Interlocked.Increment(ref this.CommandsRunningCount);
PSActivity.BeginRunOneCommand(runCommandsArgument);
flag = this.commandQueue.TryDequeue(out activityImplementationContext);
}
this.AllCommandsStarted = true;
}
return true;
}
else
{
throw new InvalidOperationException("commandQueue");
}
}
private static void BeginInvokeOnPowershellCommand(System.Management.Automation.PowerShell ps, PSDataCollection<object> varsInput, PSInvocationSettings settings, AsyncCallback callback, RunCommandsArguments args)
{
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
try
{
ps.BeginInvoke<object>(varsInput, settings, callback, args);
}
catch (Exception exception1)
{
Exception exception = exception1;
bool flag = PSActivity.ProcessException(args, exception);
if (!flag)
{
PSActivity.ReleaseResourcesAndCheckForEnd(ps, args, false, false);
}
else
{
PSActivity.BeginActionRetry(args);
}
traceSource.TraceException(exception);
}
}
}
/// <summary>
/// Method that needs to be overridden to perform the actual
/// cleanup action
/// </summary>
/// <param name="args">RunCommandsArguments</param>
/// <param name="callback">callback to call when cleanup
/// is done</param>
/// <remarks>The signature forces this method to be internal</remarks>
internal virtual void DoCleanup(RunCommandsArguments args, WaitCallback callback)
{
throw new NotImplementedException();
}
internal static void BeginRunOneCommand(RunCommandsArguments args)
{
PSActivityContext pSActivityContext = args.PSActivityContext;
ActivityImplementationContext implementationContext = args.ImplementationContext;
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
PowerShell powerShellInstance = implementationContext.PowerShellInstance;
object[] objArray = new object[1];
objArray[0] = powerShellInstance;
traceSource.WriteMessage(string.Format(CultureInfo.InvariantCulture, "Begining action to run command {0}.", objArray));
if (!PSActivity.CheckForCancel(pSActivityContext))
{
PSActivity.InitializeOneCommand(args);
if (args.CommandExecutionType != 3 && args.CommandExecutionType != 0 && args.CommandExecutionType != 4)
{
PSActivity.BeginExecuteOneCommand(args);
}
}
}
}
private static void BeginImportRequiredModules(RunCommandsArguments args)
{
Runspace runspace = args.ImplementationContext.PowerShellInstance.Runspace;
PSActivityEnvironment pSActivityEnvironment = args.ImplementationContext.PSActivityEnvironment;
System.Management.Automation.PowerShell powerShell = System.Management.Automation.PowerShell.Create();
if (pSActivityEnvironment == null)
{
powerShell.AddCommand("Import-Module").AddParameter("Name", args.ActivityParameters.PSRequiredModules).AddParameter("ErrorAction", ActionPreference.Stop);
}
else
{
powerShell.AddCommand("Import-Module").AddParameter("Name", pSActivityEnvironment.Modules).AddParameter("ErrorAction", ActionPreference.Stop);
}
PowerShellTraceSource traceSource = PowerShellTraceSourceFactory.GetTraceSource();
using (traceSource)
{
traceSource.WriteMessage("Importing modules in runspace ", runspace.InstanceId);
powerShell.Runspace = runspace;
args.HelperCommand = powerShell;
PSActivity.BeginInvokeOnPowershellCommand(powerShell, null, null, new AsyncCallback(PSActivity.ImportRequiredModulesCallback), args);
}
}
private static bool ProcessException(RunCommandsArguments args, Exception e)
{
string str = null;
Guid guid;
IContainsErrorRecord containsErrorRecord;
ErrorRecord errorRecord;
string str1 = null;
Guid guid1;
bool flag = false;
PSActivityContext pSActivityContext = args.PSActivityContext;
ActivityImplementationContext implementationContext = args.ImplementationContext;
PowerShell powerShellInstance = implementationContext.PowerShellInstance;
uint? connectionRetryCount = args.ActivityParameters.ConnectionRetryCount;
if (!connectionRetryCount.HasValue)
{
uint? connectionRetryInterval = args.ActivityParameters.ConnectionRetryInterval;
if (!connectionRetryInterval.HasValue)
{
containsErrorRecord = e as IContainsErrorRecord;
if (containsErrorRecord != null)
{
errorRecord = containsErrorRecord.ErrorRecord;
if (PSActivity.GetComputerNameAndJobIdForCommand(powerShellInstance.InstanceId, out str1, out guid1))
{
PSActivity.AddIdentifierInfoToErrorRecord(errorRecord, str1, guid1);
}
}
flag = PSActivity.HandleRunOneCommandException(args, e);
return flag;
}
}
if (e.InnerException != null && e.InnerException as IContainsErrorRecord != null)
{
IContainsErrorRecord containsErrorRecord1 = e as IContainsErrorRecord;
if (containsErrorRecord1.ErrorRecord.FullyQualifiedErrorId.StartsWith("CimJob_BrokenCimSession", StringComparison.OrdinalIgnoreCase))
{
int actionAttempts = 0x7fffffff;
if (!pSActivityContext.IsCanceled)
{
if (pSActivityContext.runningCommands.ContainsKey(powerShellInstance))
{
actionAttempts = pSActivityContext.runningCommands[powerShellInstance].ActionAttempts;
}
flag = PSActivity.HandleFailure(actionAttempts, args.ActivityParameters.ConnectionRetryCount, args.ActivityParameters.ConnectionRetryInterval, implementationContext, "ActivityActionFailed", null, pSActivityContext);
}
if (!flag)
{
ErrorRecord errorRecord1 = containsErrorRecord1.ErrorRecord;
if (PSActivity.GetComputerNameAndJobIdForCommand(powerShellInstance.InstanceId, out str, out guid))
{
PSActivity.AddIdentifierInfoToErrorRecord(errorRecord1, str, guid);
}
if (implementationContext.PSComputerName == null || (int)implementationContext.PSComputerName.Length <= 1)
{
lock (pSActivityContext.exceptions)
{
pSActivityContext.exceptions.Add(e);
}
}
else
{
PSActivity.WriteError(e, "ActivityActionFailed", ErrorCategory.InvalidResult, implementationContext.PowerShellInstance.Runspace.ConnectionInfo, pSActivityContext);
}
}
return flag;
}
}
containsErrorRecord = e as IContainsErrorRecord;
if (containsErrorRecord != null)
{
errorRecord = containsErrorRecord.ErrorRecord;
if (PSActivity.GetComputerNameAndJobIdForCommand(powerShellInstance.InstanceId, out str1, out guid1))
{
PSActivity.AddIdentifierInfoToErrorRecord(errorRecord, str1, guid1);
}
}
flag = PSActivity.HandleRunOneCommandException(args, e);
return flag;
}