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); }