protected void ProcessJobFailure(ExecutionCmdletHelper helper, out Exception failureException, out ErrorRecord failureErrorRecord)
{
RemotePipeline pipeline = helper.Pipeline as RemotePipeline;
RemoteRunspace runspace = pipeline.GetRunspace() as RemoteRunspace;
failureException = null;
failureErrorRecord = null;
if (helper.InternalException != null)
{
string errorId = "RemotePipelineExecutionFailed";
failureException = helper.InternalException;
if ((failureException is InvalidRunspaceStateException) || (failureException is InvalidRunspacePoolStateException))
{
errorId = "InvalidSessionState";
if (!string.IsNullOrEmpty(failureException.Source))
{
errorId = string.Format(CultureInfo.InvariantCulture, "{0},{1}", new object[] { errorId, failureException.Source });
}
}
failureErrorRecord = new ErrorRecord(helper.InternalException, errorId, ErrorCategory.OperationStopped, helper);
}
else if (runspace.RunspaceStateInfo.State == RunspaceState.Broken)
{
failureException = runspace.RunspaceStateInfo.Reason;
object computerName = runspace.ConnectionInfo.ComputerName;
string str2 = null;
PSRemotingTransportException exception = failureException as PSRemotingTransportException;
string fQEIDFromTransportError = WSManTransportManagerUtils.GetFQEIDFromTransportError((exception != null) ? exception.ErrorCode : 0, "PSSessionStateBroken");
if (exception != null)
{
str2 = "[" + runspace.ConnectionInfo.ComputerName + "] ";
if (exception.ErrorCode == -2144108135)
{
string str4 = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.URIRedirectionReported, new object[] { exception.Message, "MaximumConnectionRedirectionCount", "PSSessionOption", "AllowRedirection" });
str2 = str2 + str4;
}
else if (!string.IsNullOrEmpty(exception.Message))
{
str2 = str2 + exception.Message;
}
else if (!string.IsNullOrEmpty(exception.TransportMessage))
{
str2 = str2 + exception.TransportMessage;
}
}
if (failureException == null)
{
failureException = new RuntimeException(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemoteRunspaceOpenUnknownState, new object[] { runspace.RunspaceStateInfo.State }));
}
failureErrorRecord = new ErrorRecord(failureException, computerName, fQEIDFromTransportError, ErrorCategory.OpenError, null, null, null, null, null, str2, null);
}
else if (pipeline.PipelineStateInfo.State == PipelineState.Failed)
{
object targetObject = runspace.ConnectionInfo.ComputerName;
failureException = pipeline.PipelineStateInfo.Reason;
if (failureException != null)
{
RemoteException exception2 = failureException as RemoteException;
ErrorRecord errorRecord = null;
if (exception2 != null)
{
errorRecord = exception2.ErrorRecord;
}
else
{
errorRecord = new ErrorRecord(pipeline.PipelineStateInfo.Reason, "JobFailure", ErrorCategory.OperationStopped, targetObject);
}
string str5 = ((RemoteRunspace)pipeline.GetRunspace()).ConnectionInfo.ComputerName;
Guid instanceId = pipeline.GetRunspace().InstanceId;
OriginInfo originInfo = new OriginInfo(str5, instanceId);
failureErrorRecord = new RemotingErrorRecord(errorRecord, originInfo);
}
}
}
/// <summary>
/// Remove a job from the appropriate store.
/// </summary>
/// <param name="job">Job object to remove.</param>
/// <param name="cmdlet"></param>
/// <param name="writeErrorOnException"></param>
/// <param name="throwExceptions">If true, will throw all JobSourceAdapter exceptions to caller.
/// This is needed if RemoveJob is being called from an event handler in Receive-Job.</param>
/// <returns>True if job is found.</returns>
internal bool RemoveJob(Job2 job, Cmdlet cmdlet, bool writeErrorOnException, bool throwExceptions = false)
{
bool jobFound = false;
lock (_syncObject)
{
foreach (JobSourceAdapter sourceAdapter in _sourceAdapters.Values)
{
Job2 foundJob = null;
#pragma warning disable 56500
try
{
foundJob = sourceAdapter.GetJobByInstanceId(job.InstanceId, true);
}
catch (Exception exception)
{
// Since we are calling into 3rd party code
// catching Exception is allowed. In all
// other cases the appropriate exception
// needs to be caught.
// sourceAdapter.GetJobByInstanceId() threw unknown exception.
_tracer.TraceException(exception);
if (throwExceptions)
{
throw;
}
WriteErrorOrWarning(writeErrorOnException, cmdlet, exception, "JobSourceAdapterGetJobError", sourceAdapter);
}
#pragma warning restore 56500
if (foundJob == null)
{
continue;
}
jobFound = true;
RemoveJobIdForReuse(foundJob);
#pragma warning disable 56500
try
{
sourceAdapter.RemoveJob(job);
}
catch (Exception exception)
{
// Since we are calling into 3rd party code
// catching Exception is allowed. In all
// other cases the appropriate exception
// needs to be caught.
// sourceAdapter.RemoveJob() threw unknown exception.
_tracer.TraceException(exception);
if (throwExceptions)
{
throw;
}
WriteErrorOrWarning(writeErrorOnException, cmdlet, exception, "JobSourceAdapterRemoveJobError", sourceAdapter);
}
#pragma warning restore 56500
}
}
if (!jobFound && throwExceptions)
{
var message = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.ItemNotFoundInRepository,
"Job repository", job.InstanceId.ToString());
throw new ArgumentException(message);
}
return(jobFound);
}
protected override void ProcessRecord()
{
List <System.Management.Automation.Job> collection = null;
string parameterSetName = base.ParameterSetName;
if (parameterSetName != null)
{
if (!(parameterSetName == "NameParameterSet"))
{
if (parameterSetName == "InstanceIdParameterSet")
{
collection = base.FindJobsMatchingByInstanceId(true, false, true, false);
goto Label_00A2;
}
if (parameterSetName == "SessionIdParameterSet")
{
collection = base.FindJobsMatchingBySessionId(true, false, true, false);
goto Label_00A2;
}
if (parameterSetName == "StateParameterSet")
{
collection = base.FindJobsMatchingByState(false);
goto Label_00A2;
}
if (parameterSetName == "FilterParameterSet")
{
collection = base.FindJobsMatchingByFilter(false);
goto Label_00A2;
}
}
else
{
collection = base.FindJobsMatchingByName(true, false, true, false);
goto Label_00A2;
}
}
collection = base.CopyJobsToList(this.jobs, false, false);
Label_00A2:
this._allJobsToSuspend.AddRange(collection);
foreach (System.Management.Automation.Job job in collection)
{
Job2 key = job as Job2;
if (key == null)
{
base.WriteError(new ErrorRecord(PSTraceSource.NewNotSupportedException("RemotingErrorIdStrings", "JobSuspendNotSupported", new object[] { job.Id }), "Job2OperationNotSupportedOnJob", ErrorCategory.InvalidType, job));
}
else
{
string target = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemovePSJobWhatIfTarget, new object[] { job.Command, job.Id });
if (base.ShouldProcess(target, "Suspend"))
{
if (this._wait)
{
this._cleanUpActions.Add(key, new EventHandler <AsyncCompletedEventArgs>(this.HandleSuspendJobCompleted));
}
else
{
if (key.IsFinishedState(key.JobStateInfo.State) || (key.JobStateInfo.State == JobState.Stopping))
{
this._warnInvalidState = true;
goto Label_0277;
}
if ((key.JobStateInfo.State == JobState.Suspending) || (key.JobStateInfo.State == JobState.Suspended))
{
goto Label_0277;
}
key.StateChanged += new EventHandler <JobStateEventArgs>(this.noWait_Job2_StateChanged);
}
key.SuspendJobCompleted += new EventHandler <AsyncCompletedEventArgs>(this.HandleSuspendJobCompleted);
lock (this._syncObject)
{
if (!this._pendingJobs.Contains(key.InstanceId))
{
this._pendingJobs.Add(key.InstanceId);
}
}
if (!this._wait && ((key.IsFinishedState(key.JobStateInfo.State) || (key.JobStateInfo.State == JobState.Suspending)) || (key.JobStateInfo.State == JobState.Suspended)))
{
this.ProcessExecutionErrorsAndReleaseWaitHandle(key);
}
key.SuspendJobAsync(this.force, RemotingErrorIdStrings.ForceSuspendJob);
}
Label_0277 :;
}
}
}
/// <summary>
/// Suspend the Job.
/// </summary>
protected override void ProcessRecord()
{
//List of jobs to suspend
List <Job> jobsToSuspend = null;
switch (ParameterSetName)
{
case NameParameterSet:
{
jobsToSuspend = FindJobsMatchingByName(true, false, true, false);
}
break;
case InstanceIdParameterSet:
{
jobsToSuspend = FindJobsMatchingByInstanceId(true, false, true, false);
}
break;
case SessionIdParameterSet:
{
jobsToSuspend = FindJobsMatchingBySessionId(true, false, true, false);
}
break;
case StateParameterSet:
{
jobsToSuspend = FindJobsMatchingByState(false);
}
break;
case FilterParameterSet:
{
jobsToSuspend = FindJobsMatchingByFilter(false);
}
break;
default:
{
jobsToSuspend = CopyJobsToList(_jobs, false, false);
}
break;
}
_allJobsToSuspend.AddRange(jobsToSuspend);
foreach (Job job in jobsToSuspend)
{
var job2 = job as Job2;
// If the job is not Job2, the suspend operation is not supported.
if (job2 == null)
{
WriteError(
new ErrorRecord(
PSTraceSource.NewNotSupportedException(RemotingErrorIdStrings.JobSuspendNotSupported, job.Id),
"Job2OperationNotSupportedOnJob", ErrorCategory.InvalidType, (object)job));
continue;
}
string targetString =
PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemovePSJobWhatIfTarget,
job.Command, job.Id);
if (ShouldProcess(targetString, VerbsLifecycle.Suspend))
{
if (_wait)
{
_cleanUpActions.Add(job2, HandleSuspendJobCompleted);
}
else
{
if (job2.IsFinishedState(job2.JobStateInfo.State) || job2.JobStateInfo.State == JobState.Stopping)
{
_warnInvalidState = true;
continue;
}
if (job2.JobStateInfo.State == JobState.Suspending || job2.JobStateInfo.State == JobState.Suspended)
{
continue;
}
job2.StateChanged += noWait_Job2_StateChanged;
}
job2.SuspendJobCompleted += HandleSuspendJobCompleted;
lock (_syncObject)
{
if (!_pendingJobs.Contains(job2.InstanceId))
{
_pendingJobs.Add(job2.InstanceId);
}
}
// there could be possiblility that the job gets completed befor or after the
// subscribing to nowait_job2_statechanged event so checking it again.
if (!_wait && (job2.IsFinishedState(job2.JobStateInfo.State) || job2.JobStateInfo.State == JobState.Suspending || job2.JobStateInfo.State == JobState.Suspended))
{
this.ProcessExecutionErrorsAndReleaseWaitHandle(job2);
}
job2.SuspendJobAsync(_force, RemotingErrorIdStrings.ForceSuspendJob);
}
}
}
private void HandleRunspaceStateChanged(object sender, OperationStateEventArgs stateEventArgs)
{
ErrorRecord errorRecord;
PSRemotingTransportException exception2;
string str;
if (sender == null)
{
throw PSTraceSource.NewArgumentNullException("sender");
}
if (stateEventArgs == null)
{
throw PSTraceSource.NewArgumentNullException("stateEventArgs");
}
RunspaceStateEventArgs baseEvent = stateEventArgs.BaseEvent as RunspaceStateEventArgs;
RunspaceState state = baseEvent.RunspaceStateInfo.State;
OpenRunspaceOperation operation = sender as OpenRunspaceOperation;
RemoteRunspace operatedRunspace = operation.OperatedRunspace;
if (operatedRunspace != null)
{
operatedRunspace.URIRedirectionReported -= new EventHandler <RemoteDataEventArgs <Uri> >(this.HandleURIDirectionReported);
}
PipelineWriter objectWriter = this.stream.ObjectWriter;
Exception reason = baseEvent.RunspaceStateInfo.Reason;
switch (state)
{
case RunspaceState.Opened:
{
PSSession remoteRunspaceInfo = new PSSession(operatedRunspace);
base.RunspaceRepository.Add(remoteRunspaceInfo);
Action <Cmdlet> action = cmdlet => cmdlet.WriteObject(remoteRunspaceInfo);
if (objectWriter.IsOpen)
{
objectWriter.Write(action);
}
return;
}
case RunspaceState.Closed:
{
Uri uri = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <Uri>(operatedRunspace.ConnectionInfo, "ConnectionUri", null);
string message = base.GetMessage(RemotingErrorIdStrings.RemoteRunspaceClosed, new object[] { (uri != null) ? uri.AbsoluteUri : string.Empty });
Action <Cmdlet> action3 = cmdlet => cmdlet.WriteVerbose(message);
if (objectWriter.IsOpen)
{
objectWriter.Write(action3);
}
if (reason != null)
{
ErrorRecord errorRecord2 = new ErrorRecord(reason, "PSSessionStateClosed", ErrorCategory.OpenError, operatedRunspace);
Action <Cmdlet> action4 = cmdlet => cmdlet.WriteError(errorRecord2);
if (objectWriter.IsOpen)
{
objectWriter.Write(action4);
}
}
return;
}
case RunspaceState.Closing:
return;
case RunspaceState.Broken:
exception2 = reason as PSRemotingTransportException;
str = null;
if (exception2 != null)
{
OpenRunspaceOperation operation2 = sender as OpenRunspaceOperation;
if (operation2 != null)
{
string computerName = operation2.OperatedRunspace.ConnectionInfo.ComputerName;
if (exception2.ErrorCode != -2144108135)
{
str = "[" + computerName + "] ";
if (!string.IsNullOrEmpty(exception2.Message))
{
str = str + exception2.Message;
}
else if (!string.IsNullOrEmpty(exception2.TransportMessage))
{
str = str + exception2.TransportMessage;
}
break;
}
string str3 = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.URIRedirectionReported, new object[] { exception2.Message, "MaximumConnectionRedirectionCount", "PSSessionOption", "AllowRedirection" });
str = "[" + computerName + "] " + str3;
}
}
break;
default:
return;
}
PSRemotingDataStructureException exception3 = reason as PSRemotingDataStructureException;
if (exception3 != null)
{
OpenRunspaceOperation operation3 = sender as OpenRunspaceOperation;
if (operation3 != null)
{
string str4 = operation3.OperatedRunspace.ConnectionInfo.ComputerName;
str = "[" + str4 + "] " + exception3.Message;
}
}
if (reason == null)
{
reason = new RuntimeException(base.GetMessage(RemotingErrorIdStrings.RemoteRunspaceOpenUnknownState, new object[] { state }));
}
string fQEIDFromTransportError = WSManTransportManagerUtils.GetFQEIDFromTransportError((exception2 != null) ? exception2.ErrorCode : 0, this._defaultFQEID);
errorRecord = new ErrorRecord(reason, operatedRunspace, fQEIDFromTransportError, ErrorCategory.OpenError, null, null, null, null, null, str, null);
Action <Cmdlet> action2 = cmdlet => cmdlet.WriteError(errorRecord);
if (objectWriter.IsOpen)
{
objectWriter.Write(action2);
}
this.toDispose.Add(operatedRunspace);
}
/// <summary>
/// Stop the Job.
/// </summary>
protected override void ProcessRecord()
{
//List of jobs to stop
List <Job> jobsToStop = null;
switch (ParameterSetName)
{
case NameParameterSet:
{
jobsToStop = FindJobsMatchingByName(true, false, true, false);
}
break;
case InstanceIdParameterSet:
{
jobsToStop = FindJobsMatchingByInstanceId(true, false, true, false);
}
break;
case SessionIdParameterSet:
{
jobsToStop = FindJobsMatchingBySessionId(true, false, true, false);
}
break;
case StateParameterSet:
{
jobsToStop = FindJobsMatchingByState(false);
}
break;
case FilterParameterSet:
{
jobsToStop = FindJobsMatchingByFilter(false);
}
break;
default:
{
jobsToStop = CopyJobsToList(_jobs, false, false);
}
break;
}
_allJobsToStop.AddRange(jobsToStop);
foreach (Job job in jobsToStop)
{
if (this.Stopping)
{
return;
}
if (job.IsFinishedState(job.JobStateInfo.State))
{
continue;
}
string targetString =
PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemovePSJobWhatIfTarget,
job.Command, job.Id);
if (ShouldProcess(targetString, VerbsLifecycle.Stop))
{
Job2 job2 = job as Job2;
// if it is a Job2, then async is supported
// stop the job asynchronously
if (job2 != null)
{
_cleanUpActions.Add(job2, HandleStopJobCompleted);
job2.StopJobCompleted += HandleStopJobCompleted;
lock (_syncObject)
{
if (!job2.IsFinishedState(job2.JobStateInfo.State) &&
!_pendingJobs.Contains(job2.InstanceId))
{
_pendingJobs.Add(job2.InstanceId);
}
}
job2.StopJobAsync();
}
else
{
job.StopJob();
}
}
}
}
public PowerShellProcessInstance(Version powerShellVersion, PSCredential credential, ScriptBlock initializationScript, bool useWow64)
{
this._syncObject = new object();
string pSExePath = PSExePath;
if (useWow64)
{
string environmentVariable = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
if (!string.IsNullOrEmpty(environmentVariable) && (environmentVariable.Equals("amd64", StringComparison.OrdinalIgnoreCase) || environmentVariable.Equals("ia64", StringComparison.OrdinalIgnoreCase)))
{
pSExePath = PSExePath.ToLowerInvariant().Replace(@"\system32\", @"\syswow64\");
if (!System.IO.File.Exists(pSExePath))
{
throw new PSInvalidOperationException(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.IPCWowComponentNotPresent, new object[] { pSExePath }));
}
}
}
string str4 = string.Empty;
Version version = powerShellVersion ?? PSVersionInfo.PSVersion;
if (null == version)
{
version = new Version(3, 0);
}
str4 = string.Format(CultureInfo.InvariantCulture, "-Version {0}", new object[] { new Version(version.Major, version.Minor) });
str4 = string.Format(CultureInfo.InvariantCulture, "{0} -s -NoLogo -NoProfile", new object[] { str4 });
if (initializationScript != null)
{
string str5 = initializationScript.ToString();
if (!string.IsNullOrEmpty(str5))
{
string str6 = Convert.ToBase64String(Encoding.Unicode.GetBytes(str5));
str4 = string.Format(CultureInfo.InvariantCulture, "{0} -EncodedCommand {1}", new object[] { str4, str6 });
}
}
ProcessStartInfo info = new ProcessStartInfo {
FileName = useWow64 ? pSExePath : PSExePath,
Arguments = str4,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true,
LoadUserProfile = true
};
this._startInfo = info;
if (credential != null)
{
NetworkCredential networkCredential = credential.GetNetworkCredential();
this._startInfo.UserName = networkCredential.UserName;
this._startInfo.Domain = string.IsNullOrEmpty(networkCredential.Domain) ? "." : networkCredential.Domain;
this._startInfo.Password = credential.Password;
}
System.Diagnostics.Process process = new System.Diagnostics.Process {
StartInfo = this._startInfo,
EnableRaisingEvents = true
};
this._process = process;
}
public InvalidJobStateException(JobState currentState, string actionMessage) : base(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.InvalidJobStateSpecific, new object[] { currentState, actionMessage }))
{
this.currState = currentState;
}
protected override void ProcessRecord()
{
List <System.Management.Automation.Job> collection = null;
string parameterSetName = base.ParameterSetName;
if (parameterSetName != null)
{
if (!(parameterSetName == "NameParameterSet"))
{
if (parameterSetName == "InstanceIdParameterSet")
{
collection = base.FindJobsMatchingByInstanceId(true, false, true, false);
goto Label_00A2;
}
if (parameterSetName == "SessionIdParameterSet")
{
collection = base.FindJobsMatchingBySessionId(true, false, true, false);
goto Label_00A2;
}
if (parameterSetName == "StateParameterSet")
{
collection = base.FindJobsMatchingByState(false);
goto Label_00A2;
}
if (parameterSetName == "FilterParameterSet")
{
collection = base.FindJobsMatchingByFilter(false);
goto Label_00A2;
}
}
else
{
collection = base.FindJobsMatchingByName(true, false, true, false);
goto Label_00A2;
}
}
collection = base.CopyJobsToList(this.jobs, false, false);
Label_00A2:
this._allJobsToStop.AddRange(collection);
foreach (System.Management.Automation.Job job in collection)
{
if (base.Stopping)
{
break;
}
if (!job.IsFinishedState(job.JobStateInfo.State))
{
string target = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemovePSJobWhatIfTarget, new object[] { job.Command, job.Id });
if (base.ShouldProcess(target, "Stop"))
{
Job2 key = job as Job2;
if (key != null)
{
this._cleanUpActions.Add(key, new EventHandler <AsyncCompletedEventArgs>(this.HandleStopJobCompleted));
key.StopJobCompleted += new EventHandler <AsyncCompletedEventArgs>(this.HandleStopJobCompleted);
lock (this._syncObject)
{
if (!key.IsFinishedState(key.JobStateInfo.State) && !this._pendingJobs.Contains(key.InstanceId))
{
this._pendingJobs.Add(key.InstanceId);
}
}
key.StopJobAsync();
}
else
{
job.StopJob();
ContainerParentJob job3 = job as ContainerParentJob;
if ((job3 != null) && (job3.ExecutionError.Count > 0))
{
foreach (ErrorRecord record in from e in job3.ExecutionError
where e.FullyQualifiedErrorId == "ContainerParentJobStopError"
select e)
{
base.WriteError(record);
}
}
}
}
}
}
}
protected override void ProcessRecord()
{
List <System.Management.Automation.Job> collection = null;
string parameterSetName = base.ParameterSetName;
if (parameterSetName != null)
{
if (!(parameterSetName == "NameParameterSet"))
{
if (parameterSetName == "InstanceIdParameterSet")
{
collection = base.FindJobsMatchingByInstanceId(true, false, true, false);
goto Label_00A2;
}
if (parameterSetName == "SessionIdParameterSet")
{
collection = base.FindJobsMatchingBySessionId(true, false, true, false);
goto Label_00A2;
}
if (parameterSetName == "StateParameterSet")
{
collection = base.FindJobsMatchingByState(false);
goto Label_00A2;
}
if (parameterSetName == "FilterParameterSet")
{
collection = base.FindJobsMatchingByFilter(false);
goto Label_00A2;
}
}
else
{
collection = base.FindJobsMatchingByName(true, false, true, false);
goto Label_00A2;
}
}
collection = base.CopyJobsToList(this.jobs, false, false);
Label_00A2:
this._allJobsToResume.AddRange(collection);
foreach (System.Management.Automation.Job job in collection)
{
Job2 key = job as Job2;
if (key == null)
{
base.WriteError(new ErrorRecord(PSTraceSource.NewNotSupportedException("RemotingErrorIdStrings", "JobResumeNotSupported", new object[] { job.Id }), "Job2OperationNotSupportedOnJob", ErrorCategory.InvalidType, job));
}
else
{
string target = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemovePSJobWhatIfTarget, new object[] { job.Command, job.Id });
if (base.ShouldProcess(target, "Resume"))
{
this._cleanUpActions.Add(key, new EventHandler <AsyncCompletedEventArgs>(this.HandleResumeJobCompleted));
key.ResumeJobCompleted += new EventHandler <AsyncCompletedEventArgs>(this.HandleResumeJobCompleted);
lock (this._syncObject)
{
if (!this._pendingJobs.Contains(key.InstanceId))
{
this._pendingJobs.Add(key.InstanceId);
}
}
key.ResumeJobAsync();
}
}
}
}
internal static Exception NewRemoteHostCallFailedException(RemoteHostMethodId methodId) => (Exception) new PSRemotingDataStructureException(PSRemotingErrorInvariants.FormatResourceString(PSRemotingErrorId.RemoteHostCallFailed, (object)RemoteHostMethodInfo.LookUp(methodId).Name));
internal static Exception NewDecodingFailedException() => (Exception) new PSRemotingDataStructureException(PSRemotingErrorInvariants.FormatResourceString(PSRemotingErrorId.RemoteHostDecodingFailed));
internal static Exception NewRemoteRunspaceDoesNotSupportPushRunspaceException() => (Exception) new PSRemotingDataStructureException(PSRemotingErrorInvariants.FormatResourceString(PSRemotingErrorId.RemoteRunspaceDoesNotSupportPushRunspace));
public InvalidJobStateException() : base(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.InvalidJobStateGeneral, new object[0]))
{
}
public InvalidJobStateException()
: base(PSRemotingErrorInvariants.FormatResourceString(PSRemotingErrorId.InvalidJobStateGeneral))
{
}
internal InvalidJobStateException(JobState currentState) : base(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.InvalidJobStateGeneral, new object[0]))
{
this.currState = currentState;
}
internal InvalidJobStateException(JobState currentState)
: base(PSRemotingErrorInvariants.FormatResourceString(PSRemotingErrorId.InvalidJobStateGeneral))
{
using (InvalidJobStateException.tracer.TraceConstructor((object)this))
this.currState = currentState;
}
/// <summary>
/// Initializes a new instance of the <see cref="PowerShellProcessInstance"/> class. Initializes the underlying dotnet process class.
/// </summary>
/// <param name="powerShellVersion">Specifies the version of powershell.</param>
/// <param name="credential">Specifies a user account credentials.</param>
/// <param name="initializationScript">Specifies a script that will be executed when the powershell process is initialized.</param>
/// <param name="useWow64">Specifies if the powershell process will be 32-bit.</param>
/// <param name="workingDirectory">Specifies the initial working directory for the new powershell process.</param>
public PowerShellProcessInstance(Version powerShellVersion, PSCredential credential, ScriptBlock initializationScript, bool useWow64, string workingDirectory)
{
string exePath = PwshExePath;
bool startingWindowsPowerShell51 = false;
#if !UNIX
// if requested PS version was "5.1" then we start Windows PS instead of PS Core
startingWindowsPowerShell51 = (powerShellVersion != null) && (powerShellVersion.Major == 5) && (powerShellVersion.Minor == 1);
if (startingWindowsPowerShell51)
{
if (WinPwshExePath is null)
{
throw new PSInvalidOperationException(RemotingErrorIdStrings.WindowsPowerShellNotPresent);
}
exePath = WinPwshExePath;
if (useWow64)
{
string procArch = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
if ((!string.IsNullOrEmpty(procArch)) && (procArch.Equals("amd64", StringComparison.OrdinalIgnoreCase) ||
procArch.Equals("ia64", StringComparison.OrdinalIgnoreCase)))
{
exePath = WinPwshExePath.ToLowerInvariant().Replace("\\system32\\", "\\syswow64\\");
if (!File.Exists(exePath))
{
string message = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.WowComponentNotPresent, exePath);
throw new PSInvalidOperationException(message);
}
}
}
}
#endif
// 'WindowStyle' is used only if 'UseShellExecute' is 'true'. Since 'UseShellExecute' is set
// to 'false' in our use, we can ignore the 'WindowStyle' setting in the initialization below.
_startInfo = new ProcessStartInfo
{
FileName = exePath,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
#if !UNIX
LoadUserProfile = true,
#endif
};
#if !UNIX
if (startingWindowsPowerShell51)
{
_startInfo.ArgumentList.Add("-Version");
_startInfo.ArgumentList.Add("5.1");
// if starting Windows PowerShell, need to remove PowerShell specific segments of PSModulePath
_startInfo.Environment["PSModulePath"] = ModuleIntrinsics.GetWindowsPowerShellModulePath();
}
#endif
_startInfo.ArgumentList.Add("-s");
_startInfo.ArgumentList.Add("-NoLogo");
_startInfo.ArgumentList.Add("-NoProfile");
if (!string.IsNullOrWhiteSpace(workingDirectory) && !startingWindowsPowerShell51)
{
_startInfo.ArgumentList.Add("-wd");
_startInfo.ArgumentList.Add(workingDirectory);
}
if (initializationScript != null)
{
var scriptBlockString = initializationScript.ToString();
if (!string.IsNullOrEmpty(scriptBlockString))
{
var encodedCommand = Convert.ToBase64String(Encoding.Unicode.GetBytes(scriptBlockString));
_startInfo.ArgumentList.Add("-EncodedCommand");
_startInfo.ArgumentList.Add(encodedCommand);
}
}
if (credential != null)
{
Net.NetworkCredential netCredential = credential.GetNetworkCredential();
_startInfo.UserName = netCredential.UserName;
_startInfo.Domain = string.IsNullOrEmpty(netCredential.Domain) ? "." : netCredential.Domain;
_startInfo.Password = credential.Password;
}
Process = new Process {
StartInfo = _startInfo, EnableRaisingEvents = true
};
}
internal override void ConnectAsync()
{
string path = Path.Combine(Utils.GetApplicationBase(Utils.DefaultPowerShellShellID), "powershell.exe");
if (this.connectionInfo != null && this.connectionInfo.RunAs32)
{
string environmentVariable = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
if (environmentVariable.Equals("amd64", StringComparison.OrdinalIgnoreCase) || environmentVariable.Equals("ia64", StringComparison.OrdinalIgnoreCase))
{
path = path.ToLowerInvariant().Replace("\\system32\\", "\\syswow64\\");
if (!System.IO.File.Exists(path))
{
throw new PSInvalidOperationException(PSRemotingErrorInvariants.FormatResourceString(PSRemotingErrorId.IPCWowComponentNotPresent, (object)path));
}
}
}
string str = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "-s -NoLogo -NoProfile");
if (this.connectionInfo.InitializationScript != null && !string.IsNullOrEmpty(this.connectionInfo.InitializationScript.ToString()))
{
string base64String = Convert.ToBase64String(Encoding.Unicode.GetBytes(this.connectionInfo.InitializationScript.ToString()));
str = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "{0} -EncodedCommand {1}", (object)str, (object)base64String);
}
ProcessStartInfo processStartInfo = new ProcessStartInfo();
processStartInfo.FileName = path;
processStartInfo.Arguments = str;
processStartInfo.UseShellExecute = false;
processStartInfo.RedirectStandardInput = true;
processStartInfo.RedirectStandardOutput = true;
processStartInfo.RedirectStandardError = true;
processStartInfo.WindowStyle = ProcessWindowStyle.Hidden;
processStartInfo.CreateNoWindow = true;
processStartInfo.LoadUserProfile = true;
if (this.connectionInfo.Credential != null)
{
NetworkCredential networkCredential = this.connectionInfo.Credential.GetNetworkCredential();
processStartInfo.UserName = networkCredential.UserName;
processStartInfo.Domain = !string.IsNullOrEmpty(networkCredential.Domain) ? networkCredential.Domain : ".";
processStartInfo.Password = this.connectionInfo.Credential.Password;
}
BaseTransportManager.ETWTracer.AnalyticChannel.WriteInformation(PSEventId.WSManCreateShell, PSOpcode.Connect, PSTask.CreateRunspace, (object)this.RunspacePoolInstanceId);
try
{
lock (this.syncObject)
{
if (this.isClosed)
{
return;
}
this.serverProcess = new Process();
this.serverProcess.StartInfo = processStartInfo;
this.serverProcess.EnableRaisingEvents = true;
this.serverProcess.OutputDataReceived += new DataReceivedEventHandler(this.OnOutputDataReceived);
this.serverProcess.ErrorDataReceived += new DataReceivedEventHandler(this.OnErrorDataReceived);
this.serverProcess.Exited += new EventHandler(this.OnExited);
this.serverProcess.Start();
this.serverProcess.BeginOutputReadLine();
this.serverProcess.BeginErrorReadLine();
this.stdInWriter = new OutOfProcessTextWriter((TextWriter)this.serverProcess.StandardInput);
}
}
catch (Win32Exception ex)
{
this.RaiseErrorHandler(new TransportErrorOccuredEventArgs(new PSRemotingTransportException(PSRemotingErrorId.IPCExceptionLaunchingProcess, new object[1]
{
(object)ex.Message
})
{
ErrorCode = ex.ErrorCode
}, TransportMethodEnum.CreateShellEx));
return;
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
this.RaiseErrorHandler(new TransportErrorOccuredEventArgs(new PSRemotingTransportException(PSRemotingErrorId.IPCExceptionLaunchingProcess, new object[1]
{
(object)ex.Message
}), TransportMethodEnum.CreateShellEx));
return;
}
this.SendOneItem();
}
/// <summary>
///
/// </summary>
/// <param name="powerShellVersion"></param>
/// <param name="credential"></param>
/// <param name="initializationScript"></param>
/// <param name="useWow64"></param>
public PowerShellProcessInstance(Version powerShellVersion, PSCredential credential, ScriptBlock initializationScript, bool useWow64)
{
string psWow64Path = s_PSExePath;
if (useWow64)
{
string procArch = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
if ((!string.IsNullOrEmpty(procArch)) && (procArch.Equals("amd64", StringComparison.OrdinalIgnoreCase) ||
procArch.Equals("ia64", StringComparison.OrdinalIgnoreCase)))
{
psWow64Path = s_PSExePath.ToLowerInvariant().Replace("\\system32\\", "\\syswow64\\");
if (!File.Exists(psWow64Path))
{
string message =
PSRemotingErrorInvariants.FormatResourceString(
RemotingErrorIdStrings.IPCWowComponentNotPresent,
psWow64Path);
throw new PSInvalidOperationException(message);
}
}
}
string processArguments = string.Empty;
// Adding Version parameter to powershell.exe
// Version parameter needs to go before all other parameters because the native layer looks for Version or
// PSConsoleFile parameters before parsing other parameters.
// The other parameters get parsed in the managed layer.
Version tempVersion = powerShellVersion ?? PSVersionInfo.PSVersion;
processArguments = string.Format(CultureInfo.InvariantCulture,
"-Version {0}", new Version(tempVersion.Major, tempVersion.Minor));
processArguments = string.Format(CultureInfo.InvariantCulture,
"{0} -s -NoLogo -NoProfile", processArguments);
if (initializationScript != null)
{
string scripBlockAsString = initializationScript.ToString();
if (!string.IsNullOrEmpty(scripBlockAsString))
{
string encodedCommand =
Convert.ToBase64String(Encoding.Unicode.GetBytes(scripBlockAsString));
processArguments = string.Format(CultureInfo.InvariantCulture,
"{0} -EncodedCommand {1}", processArguments, encodedCommand);
}
}
// 'WindowStyle' is used only if 'UseShellExecute' is 'true'. Since 'UseShellExecute' is set
// to 'false' in our use, we can ignore the 'WindowStyle' setting in the initialization below.
_startInfo = new ProcessStartInfo
{
FileName = useWow64 ? psWow64Path : s_PSExePath,
Arguments = processArguments,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
LoadUserProfile = true,
};
if (credential != null)
{
Net.NetworkCredential netCredential = credential.GetNetworkCredential();
_startInfo.UserName = netCredential.UserName;
_startInfo.Domain = string.IsNullOrEmpty(netCredential.Domain) ? "." : netCredential.Domain;
#if CORECLR
_startInfo.PasswordInClearText = ClrFacade.ConvertSecureStringToString(credential.Password);
#else
_startInfo.Password = credential.Password;
#endif
}
Process = new Process {
StartInfo = _startInfo, EnableRaisingEvents = true
};
}
protected override void ProcessRecord()
{
IHostSupportsInteractiveSession session = base.Host as IHostSupportsInteractiveSession;
if (session == null)
{
base.WriteError(new ErrorRecord(new ArgumentException(base.GetMessage(RemotingErrorIdStrings.HostDoesNotSupportPushRunspace)), PSRemotingErrorId.HostDoesNotSupportPushRunspace.ToString(), ErrorCategory.InvalidArgument, null));
}
/*
* else if (((base.Context != null) && (base.Context.EngineHostInterface != null)) && ((base.Context.EngineHostInterface.ExternalHost != null) && (base.Context.EngineHostInterface.ExternalHost is ServerRemoteHost)))
* {
* base.WriteError(new ErrorRecord(new ArgumentException(base.GetMessage(RemotingErrorIdStrings.RemoteHostDoesNotSupportPushRunspace)), PSRemotingErrorId.RemoteHostDoesNotSupportPushRunspace.ToString(), ErrorCategory.InvalidArgument, null));
* }
*/
else
{
InternalHost targetObject = base.Host as InternalHost;
if ((targetObject != null) && targetObject.HostInNestedPrompt())
{
base.ThrowTerminatingError(new ErrorRecord(new InvalidOperationException(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.HostInNestedPrompt, new object[0])), "HostInNestedPrompt", ErrorCategory.InvalidOperation, targetObject));
}
RemoteRunspace runspaceMatchingRunspaceId = null;
string parameterSetName = base.ParameterSetName;
if (parameterSetName != null)
{
if (!(parameterSetName == "ComputerName"))
{
if (parameterSetName == "Uri")
{
runspaceMatchingRunspaceId = this.CreateRunspaceWhenUriParameterSpecified();
}
else if (parameterSetName == "Session")
{
runspaceMatchingRunspaceId = (RemoteRunspace)this.remoteRunspaceInfo.Runspace;
}
else if (parameterSetName == "InstanceId")
{
runspaceMatchingRunspaceId = this.GetRunspaceMatchingRunspaceId(this.InstanceId);
}
else if (parameterSetName == "Id")
{
runspaceMatchingRunspaceId = this.GetRunspaceMatchingSessionId(this.Id);
}
else if (parameterSetName == "Name")
{
runspaceMatchingRunspaceId = this.GetRunspaceMatchingName(this.Name);
}
}
else
{
runspaceMatchingRunspaceId = this.CreateRunspaceWhenComputerNameParameterSpecified();
}
}
if (runspaceMatchingRunspaceId != null)
{
if (runspaceMatchingRunspaceId.RunspaceStateInfo.State == RunspaceState.Disconnected)
{
if (!runspaceMatchingRunspaceId.CanConnect)
{
string message = StringUtil.Format(RemotingErrorIdStrings.SessionNotAvailableForConnection, new object[0]);
base.WriteError(new ErrorRecord(new RuntimeException(message), "EnterPSSessionCannotConnectDisconnectedSession", ErrorCategory.InvalidOperation, runspaceMatchingRunspaceId));
return;
}
Exception innerException = null;
try
{
runspaceMatchingRunspaceId.Connect();
}
catch (PSRemotingTransportException exception2)
{
innerException = exception2;
}
catch (PSInvalidOperationException exception3)
{
innerException = exception3;
}
catch (InvalidRunspacePoolStateException exception4)
{
innerException = exception4;
}
if (innerException != null)
{
string str2 = StringUtil.Format(RemotingErrorIdStrings.SessionConnectFailed, new object[0]);
base.WriteError(new ErrorRecord(new RuntimeException(str2, innerException), "EnterPSSessionConnectSessionFailed", ErrorCategory.InvalidOperation, runspaceMatchingRunspaceId));
return;
}
if (runspaceMatchingRunspaceId.RunspaceAvailability == RunspaceAvailability.Busy)
{
string str3 = StringUtil.Format(RemotingErrorIdStrings.EnterPSSessionDisconnected, runspaceMatchingRunspaceId.Name);
base.WriteError(new ErrorRecord(new RuntimeException(str3, innerException), "EnterPSSessionConnectSessionNotAvailable", ErrorCategory.InvalidOperation, this.remoteRunspaceInfo));
runspaceMatchingRunspaceId.DisconnectAsync();
return;
}
}
if (runspaceMatchingRunspaceId.RunspaceStateInfo.State != RunspaceState.Opened)
{
if (base.ParameterSetName == "Session")
{
string str4 = (this.remoteRunspaceInfo != null) ? this.remoteRunspaceInfo.Name : string.Empty;
base.WriteError(new ErrorRecord(new ArgumentException(base.GetMessage(RemotingErrorIdStrings.EnterPSSessionBrokenSession, new object[] { str4, runspaceMatchingRunspaceId.ConnectionInfo.ComputerName, runspaceMatchingRunspaceId.InstanceId })), PSRemotingErrorId.PushedRunspaceMustBeOpen.ToString(), ErrorCategory.InvalidArgument, null));
}
else
{
base.WriteError(new ErrorRecord(new ArgumentException(base.GetMessage(RemotingErrorIdStrings.PushedRunspaceMustBeOpen)), PSRemotingErrorId.PushedRunspaceMustBeOpen.ToString(), ErrorCategory.InvalidArgument, null));
}
}
else
{
if (runspaceMatchingRunspaceId.RunspaceAvailability != RunspaceAvailability.Available)
{
base.WriteWarning(base.GetMessage(RunspaceStrings.RunspaceNotReady));
}
try
{
session.PushRunspace(runspaceMatchingRunspaceId);
}
catch (Exception)
{
if ((runspaceMatchingRunspaceId != null) && runspaceMatchingRunspaceId.ShouldCloseOnPop)
{
runspaceMatchingRunspaceId.Close();
}
throw;
}
}
}
}
}
/// <summary>
/// Resume the Job.
/// </summary>
protected override void ProcessRecord()
{
//List of jobs to resume
List <Job> jobsToResume = null;
switch (ParameterSetName)
{
case NameParameterSet:
{
jobsToResume = FindJobsMatchingByName(true, false, true, false);
}
break;
case InstanceIdParameterSet:
{
jobsToResume = FindJobsMatchingByInstanceId(true, false, true, false);
}
break;
case SessionIdParameterSet:
{
jobsToResume = FindJobsMatchingBySessionId(true, false, true, false);
}
break;
case StateParameterSet:
{
jobsToResume = FindJobsMatchingByState(false);
}
break;
case FilterParameterSet:
{
jobsToResume = FindJobsMatchingByFilter(false);
}
break;
default:
{
jobsToResume = CopyJobsToList(_jobs, false, false);
}
break;
}
_allJobsToResume.AddRange(jobsToResume);
// Blue: 151804 When resuming a single suspended workflow job, Resume-job cmdlet doesn't wait for the job to be in running state
// Setting Wait to true so that this cmdlet will wait for the running job state.
if (_allJobsToResume.Count == 1)
{
Wait = true;
}
foreach (Job job in jobsToResume)
{
var job2 = job as Job2;
// If the job is not Job2, the resume operation is not supported.
if (job2 == null)
{
WriteError(new ErrorRecord(PSTraceSource.NewNotSupportedException(RemotingErrorIdStrings.JobResumeNotSupported, job.Id), "Job2OperationNotSupportedOnJob", ErrorCategory.InvalidType, (object)job));
continue;
}
string targetString = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemovePSJobWhatIfTarget, job.Command, job.Id);
if (ShouldProcess(targetString, VerbsLifecycle.Resume))
{
_cleanUpActions.Add(job2, HandleResumeJobCompleted);
job2.ResumeJobCompleted += HandleResumeJobCompleted;
lock (_syncObject)
{
if (!_pendingJobs.Contains(job2.InstanceId))
{
_pendingJobs.Add(job2.InstanceId);
}
}
job2.ResumeJobAsync();
}
}
}
/// <summary>
/// </summary>
/// <param name="powerShellVersion"></param>
/// <param name="credential"></param>
/// <param name="initializationScript"></param>
/// <param name="useWow64"></param>
public PowerShellProcessInstance(Version powerShellVersion, PSCredential credential, ScriptBlock initializationScript, bool useWow64)
{
string psWow64Path = PwshExePath;
if (useWow64)
{
string procArch = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
if (!string.IsNullOrEmpty(procArch) && (procArch.Equals("amd64", StringComparison.OrdinalIgnoreCase) ||
procArch.Equals("ia64", StringComparison.OrdinalIgnoreCase)))
{
psWow64Path = PwshExePath.ToLowerInvariant().Replace("\\system32\\", "\\syswow64\\");
if (!File.Exists(psWow64Path))
{
string message =
PSRemotingErrorInvariants.FormatResourceString(
RemotingErrorIdStrings.IPCWowComponentNotPresent,
psWow64Path);
throw new PSInvalidOperationException(message);
}
}
}
string processArguments = " -s -NoLogo -NoProfile";
if (initializationScript != null)
{
string scripBlockAsString = initializationScript.ToString();
if (!string.IsNullOrEmpty(scripBlockAsString))
{
string encodedCommand =
Convert.ToBase64String(Encoding.Unicode.GetBytes(scripBlockAsString));
processArguments = string.Format(CultureInfo.InvariantCulture,
"{0} -EncodedCommand {1}", processArguments, encodedCommand);
}
}
// 'WindowStyle' is used only if 'UseShellExecute' is 'true'. Since 'UseShellExecute' is set
// to 'false' in our use, we can ignore the 'WindowStyle' setting in the initialization below.
_startInfo = new ProcessStartInfo
{
FileName = useWow64 ? psWow64Path : PwshExePath,
Arguments = processArguments,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
#if !UNIX
LoadUserProfile = true,
#endif
};
if (credential != null)
{
Net.NetworkCredential netCredential = credential.GetNetworkCredential();
_startInfo.UserName = netCredential.UserName;
_startInfo.Domain = string.IsNullOrEmpty(netCredential.Domain) ? "." : netCredential.Domain;
_startInfo.Password = credential.Password;
}
Process = new Process {
StartInfo = _startInfo, EnableRaisingEvents = true
};
}
