private void HandleJobStateChanged(object sender, JobStateEventArgs e)
{
base.SetJobState(e.JobStateInfo.State);
if (this.IsFinishedState(e.JobStateInfo.State))
{
base.PSEndTime = new DateTime?(DateTime.Now);
System.Management.Automation.PowerShell powerShell = null;
Runspace runspace = null;
lock (base.SyncRoot)
{
if (this._job != null && this.IsFinishedState(this._job.JobStateInfo.State))
{
this._powerShell = null;
this._runspace = null;
}
}
if (powerShell != null)
{
powerShell.Dispose();
}
if (runspace != null)
{
runspace.Dispose();
}
if (this._asyncJobStop)
{
this._asyncJobStop = false;
this.OnStopJobCompleted(new AsyncCompletedEventArgs(null, false, null));
}
this.RemoveSetShouldExitFromHost();
}
}
private void HandleJobStateChanged(object sender, JobStateEventArgs e)
{
System.Management.Automation.Job job = sender as System.Management.Automation.Job;
this._tracer.WriteMessage("ReceiveJobCommand", "HandleJobStateChanged", Guid.Empty, job, "BEGIN wait for write existing data", null);
if (e.JobStateInfo.State != JobState.Running)
{
this._writeExistingData.WaitOne();
}
this._tracer.WriteMessage("ReceiveJobCommand", "HandleJobStateChanged", Guid.Empty, job, "END wait for write existing data", null);
lock (this._syncObject)
{
if (!this._jobsBeingAggregated.Contains(job))
{
this._tracer.WriteMessage("ReceiveJobCommand", "HandleJobStateChanged", Guid.Empty, job, "Returning because job is not in _jobsBeingAggregated", null);
return;
}
}
if (e.JobStateInfo.State == JobState.Blocked)
{
DoUnblockJob(job);
}
if (((this.Force == 0) && job.IsPersistentState(e.JobStateInfo.State)) || ((this.Force != 0) && job.IsFinishedState(e.JobStateInfo.State)))
{
this.WriteReasonError(job);
this.WriteJobStateInformationIfRequired(job, e);
this.StopAggregateResultsFromJob(job);
}
else
{
this._tracer.WriteMessage("ReceiveJobCommand", "HandleJobStateChanged", Guid.Empty, job, "Returning because job state does not meet wait requirements (continue aggregating)", new string[0]);
}
}
private void HandleJobStateChanged(object sender, JobStateEventArgs eventArgs)
{
if (this.job.IsFinishedState(this.job.JobStateInfo.State))
{
this.RaiseOperationCompleteEvent();
}
}
private void HandleStateChange(object sender, JobStateEventArgs args)
{
lock (lockObject)
{
var job = sender as AzureLongRunningJob;
xunitLogger.Information(string.Format("[statechangedhandler]: previous state: '{0}', current state: '{1}'", args.PreviousJobStateInfo?.State, args.JobStateInfo?.State));
if (args.JobStateInfo.State == JobState.Completed || args.JobStateInfo.State == JobState.Failed || args.JobStateInfo.State == JobState.Stopped)
{
this.jobCompleted.Set();
}
else
{
if (args.JobStateInfo.State == JobState.Blocked)
{
if (job != null)
{
job.TryStart();
}
}
}
}
}
private void HandleChildJobStateChanged(object sender, JobStateEventArgs e)
{
if (e.JobStateInfo.State != JobState.Blocked)
{
if (!base.IsFinishedState(e.JobStateInfo.State) || e.JobStateInfo.State == JobState.NotStarted)
{
return;
}
else
{
if (e.JobStateInfo.State == JobState.Failed)
{
this.atleastOneChildJobFailed = true;
}
bool flag = false;
lock (this.syncObject)
{
PSWmiJob pSWmiJob = this;
pSWmiJob.finishedChildJobsCount = pSWmiJob.finishedChildJobsCount + 1;
if (this.finishedChildJobsCount == base.ChildJobs.Count)
{
}
}
if (flag)
{
if (!this.atleastOneChildJobFailed)
{
if (!this._stopIsCalled)
{
base.SetJobState(JobState.Completed);
}
else
{
base.SetJobState(JobState.Stopped);
return;
}
}
else
{
base.SetJobState(JobState.Failed);
return;
}
}
return;
}
}
else
{
lock (this.syncObject)
{
PSWmiJob pSWmiJob1 = this;
pSWmiJob1.blockedChildJobsCount = pSWmiJob1.blockedChildJobsCount + 1;
}
base.SetJobState(JobState.Blocked, null);
return;
}
}
private void HandleJobStateChangedEvent(object sender, JobStateEventArgs stateChangedArgs)
{
Job job = sender as Job;
if (job.IsFinishedState(stateChangedArgs.JobStateInfo.State))
{
_debugCollection.Complete();
}
}
private void HandleJobStateChanged(object sender, JobStateEventArgs e)
{
if (IsFinishedState(e.JobStateInfo.State))
{
// Job transitioned to finished state.
this.StateChanged -= new EventHandler <JobStateEventArgs>(HandleJobStateChanged);
DisposeFileWatcher();
}
}
private void HandleJobStateChanged(object sender, JobStateEventArgs e)
{
ThreadJob job = sender as ThreadJob;
JobState state = e.JobStateInfo.State;
if (state == JobState.Completed ||
state == JobState.Stopped ||
state == JobState.Failed)
{
job.StateChanged -= new EventHandler <JobStateEventArgs>(HandleJobStateChanged);
DecrementCurrentJobs();
}
}
private void OnStateChanged(object sender, JobStateEventArgs e)
{
lock (_observationSync)
{
switch (e.JobStateInfo.State)
{
case JobState.Stopped:
{
foreach (var observer in _psObservers)
{
observer.OnFailed(new ErrorRecord(new OperationCanceledException(), "JobStopped", ErrorCategory.OperationStopped, this));
}
foreach (var observer in _observers)
{
observer.OnError(new OperationCanceledException());
}
}
break;
case JobState.Failed:
{
var lastError = (_output.TryPeek(out var er) ? er.Error : null) ??
new ErrorRecord(new JobFailedException(), "JobFailed", ErrorCategory.NotSpecified, this);
foreach (var observer in _psObservers)
{
observer.OnFailed(lastError);
}
foreach (var observer in _observers)
{
observer.OnError(lastError.Exception ?? new JobFailedException());
}
}
break;
case JobState.Completed:
{
foreach (var observer in _psObservers)
{
observer.OnCompleted();
}
foreach (var observer in _observers)
{
observer.OnCompleted();
}
}
break;
}
_observers.Clear();
_psObservers.Clear();
}
}
private void noWait_Job2_StateChanged(object sender, JobStateEventArgs e)
{
Job job = sender as Job;
switch (e.JobStateInfo.State)
{
case JobState.Completed:
case JobState.Stopped:
case JobState.Failed:
case JobState.Suspended:
case JobState.Suspending:
this.ProcessExecutionErrorsAndReleaseWaitHandle(job);
break;
}
}
private void HandleJobStateChangedEvent(object source, JobStateEventArgs eventArgs)
{
System.Management.Automation.Job item = (System.Management.Automation.Job)source;
lock (this._jobTrackingLock)
{
if (eventArgs.JobStateInfo.State == JobState.Blocked)
{
this._blockedJobs.Add(item);
}
else
{
this._blockedJobs.Remove(item);
}
if (((this.Force == 0) && item.IsPersistentState(eventArgs.JobStateInfo.State)) || ((this.Force != 0) && item.IsFinishedState(eventArgs.JobStateInfo.State)))
{
if (!item.IsFinishedState(eventArgs.JobStateInfo.State))
{
this._warnNotTerminal = true;
}
this._finishedJobs.Add(item);
}
else
{
this._finishedJobs.Remove(item);
}
if (this.Any.IsPresent)
{
if (this._finishedJobs.Count > 0)
{
this.SetEndProcessingAction(new Action(this.EndProcessingOutputSingleFinishedJob));
}
else if (this._blockedJobs.Count == this._jobsToWaitFor.Count)
{
this.SetEndProcessingAction(new Action(this.EndProcessingBlockedJobsError));
}
}
else if (this._finishedJobs.Count == this._jobsToWaitFor.Count)
{
this.SetEndProcessingAction(new Action(this.EndProcessingOutputAllFinishedJobs));
}
else if (this._blockedJobs.Count > 0)
{
this.SetEndProcessingAction(new Action(this.EndProcessingBlockedJobsError));
}
}
}
private void HandleJobStateChanged(object sender, JobStateEventArgs e)
{
SetJobState(e.JobStateInfo.State);
if (IsFinishedState(e.JobStateInfo.State))
{
PSEndTime = DateTime.Now;
// Dispose the PowerShell and Runspace objects.
System.Management.Automation.PowerShell disposePowerShell = null;
Runspace disposeRunspace = null;
lock (SyncRoot)
{
if (_job != null &&
IsFinishedState(_job.JobStateInfo.State))
{
disposePowerShell = _powerShell;
_powerShell = null;
disposeRunspace = _runspace;
_runspace = null;
}
}
if (disposePowerShell != null)
{
disposePowerShell.Dispose();
}
if (disposeRunspace != null)
{
disposeRunspace.Dispose();
}
// Raise async job stopped event, if needed.
if (_asyncJobStop)
{
_asyncJobStop = false;
OnStopJobCompleted(new AsyncCompletedEventArgs(null, false, null));
}
// Remove AllowSetShouldExit from host.
RemoveSetShouldExitFromHost();
}
}
private void WriteJobStateInformation(System.Management.Automation.Job job, JobStateEventArgs args = null)
{
bool flag;
this._eventArgsWritten.TryGetValue(job.InstanceId, out flag);
if (flag)
{
this._tracer.WriteMessage("ReceiveJobCommand", "WriteJobStateInformation", Guid.Empty, job, "State information already written, skipping another write", null);
}
else
{
JobStateEventArgs args2 = args ?? new JobStateEventArgs(job.JobStateInfo);
this._eventArgsWritten[job.InstanceId] = true;
this._tracer.WriteMessage("ReceiveJobCommand", "WriteJobStateInformation", Guid.Empty, job, "Writing job state changed event args", null);
PSObject obj2 = new PSObject(args2);
obj2.Properties.Add(new PSNoteProperty(RemotingConstants.EventObject, true));
this._results.Add(new PSStreamObject(PSStreamObjectType.Output, obj2, job.InstanceId));
}
}
private void HandleJobStateChanged(object sender, JobStateEventArgs e)
{
switch (e.JobStateInfo.State)
{
case JobState.Disconnected:
case JobState.Completed:
case JobState.Stopped:
case JobState.Failed:
this.job.StateChanged -= new EventHandler <JobStateEventArgs>(this.HandleJobStateChanged);
this.RemoveConnectionRetryHandler(sender as PSInvokeExpressionSyncJob);
lock (this.jobSyncObject)
{
if (this.disconnectComplete != null)
{
this.disconnectComplete.Set();
}
}
break;
}
}
private void noWait_Job2_StateChanged(object sender, JobStateEventArgs e)
{
System.Management.Automation.Job job = sender as System.Management.Automation.Job;
switch (e.JobStateInfo.State)
{
case JobState.Completed:
case JobState.Failed:
case JobState.Stopped:
case JobState.Suspended:
case JobState.Suspending:
this.ProcessExecutionErrorsAndReleaseWaitHandle(job);
break;
case JobState.Blocked:
case JobState.Disconnected:
break;
default:
return;
}
}
public void HandleStateChange(object sender, JobStateEventArgs args)
{
lock (this)
{
var job = sender as AzureLongRunningJob;
if (args.JobStateInfo.State == JobState.Completed || args.JobStateInfo.State == JobState.Failed || args.JobStateInfo.State == JobState.Stopped)
{
this.jobCompleted.Set();
}
else
{
if (args.JobStateInfo.State == JobState.Blocked)
{
if (job != null)
{
job.TryStart();
}
}
}
}
}
private void OnJobStateChanged(object sender, JobStateEventArgs e)
{
lock (_sync)
{
var state = e.JobStateInfo.State;
switch (state)
{
case JobState.Completed:
case JobState.Failed:
case JobState.Stopped:
case JobState.Disconnected:
{
_finished = true;
while (_continuations.Count > 0)
{
_continuations.Dequeue()();
}
}
break;
}
}
}
private void ThrottlingJob_StateChanged(object sender, JobStateEventArgs e)
{
this.CheckIfThrottlingJobIsComplete();
}
private void MonitoredJob_StateChanged(object sender, JobStateEventArgs e)
{
var job = (Job)sender;
this.CheckIfMonitoredJobIsComplete(job, e.JobStateInfo.State);
}
/// <summary>
/// Handles the Job state change event.
/// </summary>
/// <param name="sender">Originator of event, unused</param>
/// <param name="eventArgs">Event arguments containing Job state.</param>
private void HandleJobStateChanged(object sender, JobStateEventArgs eventArgs)
{
if (_job.IsFinishedState(_job.JobStateInfo.State))
{
// We are done when the job is in the finished state.
RaiseOperationCompleteEvent();
}
}
private void HandleJobStateChangedEvent(object source, JobStateEventArgs eventArgs)
{
Dbg.Assert(source is Job, "Caller should verify source is Job");
Dbg.Assert(eventArgs != null, "Caller should verify eventArgs != null");
var job = (Job)source;
lock (_jobTrackingLock)
{
Dbg.Assert(_blockedJobs.All(j => !_finishedJobs.Contains(j)), "Job cannot be in *both* _blockedJobs and _finishedJobs");
if (eventArgs.JobStateInfo.State == JobState.Blocked)
{
_blockedJobs.Add(job);
}
else
{
_blockedJobs.Remove(job);
}
// Treat jobs in Disconnected state as finished jobs since the user
// will have to reconnect the job before more information can be
// obtained.
// Suspended jobs require a Resume-Job call. Both of these states are persistent
// without user interaction.
// Wait should wait until a job is in a persistent state, OR if the force parameter
// is specified, until the job is in a finished state, which is a subset of
// persistent states.
if (!Force && job.IsPersistentState(eventArgs.JobStateInfo.State) || (Force && job.IsFinishedState(eventArgs.JobStateInfo.State)))
{
if (!job.IsFinishedState(eventArgs.JobStateInfo.State))
{
_warnNotTerminal = true;
}
_finishedJobs.Add(job);
}
else
{
_finishedJobs.Remove(job);
}
Dbg.Assert(_blockedJobs.All(j => !_finishedJobs.Contains(j)), "Job cannot be in *both* _blockedJobs and _finishedJobs");
if (this.Any.IsPresent)
{
if (_finishedJobs.Count > 0)
{
this.SetEndProcessingAction(this.EndProcessingOutputSingleFinishedJob);
}
else if (_blockedJobs.Count == _jobsToWaitFor.Count)
{
this.SetEndProcessingAction(this.EndProcessingBlockedJobsError);
}
}
else
{
if (_finishedJobs.Count == _jobsToWaitFor.Count)
{
this.SetEndProcessingAction(this.EndProcessingOutputAllFinishedJobs);
}
else if (_blockedJobs.Count > 0)
{
this.SetEndProcessingAction(this.EndProcessingBlockedJobsError);
}
}
}
}
private void WriteJobStateInformationIfRequired(System.Management.Automation.Job job, JobStateEventArgs args = null)
{
if (this._writeStateChangedEvents && job.IsPersistentState(job.JobStateInfo.State))
{
this.WriteJobStateInformation(job, args);
}
this.AutoRemoveJobIfRequired(job);
}
void childJob_StateChanged(object sender, JobStateEventArgs e)
{
this.SetJobState(e.JobStateInfo.State);
}
