protected PSRemotingJob() { this.moreData = true; this.hideComputerName = true; this.throttleManager = new ThrottleManager(); this._syncObject = new object(); }
internal static void SubmitOperations(List<object> operations, ThrottleManager throttleManager) { List<IThrottleOperation> list = new List<IThrottleOperation>(); foreach (object obj2 in operations) { list.Add((IThrottleOperation) obj2); } throttleManager.SubmitOperations(list); }
internal static void SubmitOperations(List <object> operations, ThrottleManager throttleManager) { List <IThrottleOperation> list = new List <IThrottleOperation>(); foreach (object obj2 in operations) { list.Add((IThrottleOperation)obj2); } throttleManager.SubmitOperations(list); }
internal static void SubmitOperations(List <object> operations, ThrottleManager throttleManager) { List <IThrottleOperation> newOperations = new List <IThrottleOperation>(); foreach (object operation in operations) { newOperations.Add((IThrottleOperation)operation); } throttleManager.SubmitOperations(newOperations); }
internal PSRemotingJob(string[] computerNames, List<IThrottleOperation> computerNameHelpers, string remoteCommand, int throttleLimit, string name) : base(remoteCommand, name) { this.moreData = true; this.hideComputerName = true; this.throttleManager = new ThrottleManager(); this._syncObject = new object(); foreach (ExecutionCmdletHelperComputerName name2 in computerNameHelpers) { PSRemotingChildJob item = new PSRemotingChildJob(remoteCommand, name2, this.throttleManager); item.StateChanged += new EventHandler<JobStateEventArgs>(this.HandleChildJobStateChanged); item.JobUnblocked += new EventHandler(this.HandleJobUnblocked); base.ChildJobs.Add(item); } this.CommonInit(throttleLimit, computerNameHelpers); }
internal PSWmiJob(Cmdlet cmds, string[] computerName, int throttleLimt, string command) : base(command, null) { this.throttleManager = new ThrottleManager(); this.syncObject = new object(); base.PSJobTypeName = "WmiJob"; this.throttleManager.ThrottleLimit = throttleLimt; for (int i = 0; i < (int)computerName.Length; i++) { PSWmiChildJob pSWmiChildJob = new PSWmiChildJob(cmds, computerName[i], this.throttleManager); pSWmiChildJob.StateChanged += new EventHandler<JobStateEventArgs>(this.HandleChildJobStateChanged); pSWmiChildJob.JobUnblocked += new EventHandler(this.HandleJobUnblocked); base.ChildJobs.Add(pSWmiChildJob); } this.CommonInit(throttleLimt); }
internal PSRemotingJob(PSSession[] remoteRunspaceInfos, List<IThrottleOperation> runspaceHelpers, string remoteCommand, int throttleLimit, string name) : base(remoteCommand, name) { this.moreData = true; this.hideComputerName = true; this.throttleManager = new ThrottleManager(); this._syncObject = new object(); for (int i = 0; i < remoteRunspaceInfos.Length; i++) { ExecutionCmdletHelperRunspace helper = (ExecutionCmdletHelperRunspace) runspaceHelpers[i]; PSRemotingChildJob item = new PSRemotingChildJob(remoteCommand, helper, this.throttleManager); item.StateChanged += new EventHandler<JobStateEventArgs>(this.HandleChildJobStateChanged); item.JobUnblocked += new EventHandler(this.HandleJobUnblocked); base.ChildJobs.Add(item); } this.CommonInit(throttleLimit, runspaceHelpers); }
internal PSRemotingChildJob(string remoteCommand, ExecutionCmdletHelper helper, ThrottleManager throttleManager) : base(remoteCommand) { this.hideComputerName = true; this.SyncObject = new object(); base.UsesResultsCollection = true; this.helper = helper; this.remoteRunspace = helper.Pipeline.Runspace; this.remotePipeline = helper.Pipeline as RemotePipeline; this.throttleManager = throttleManager; RemoteRunspace remoteRunspace = this.remoteRunspace as RemoteRunspace; if ((remoteRunspace != null) && (remoteRunspace.RunspaceStateInfo.State == RunspaceState.BeforeOpen)) { remoteRunspace.URIRedirectionReported += new EventHandler<RemoteDataEventArgs<Uri>>(this.HandleURIDirectionReported); } this.AggregateResultsFromHelper(helper); this.RegisterThrottleComplete(throttleManager); }
internal PSRemotingJob(List<IThrottleOperation> helpers, int throttleLimit, string name, bool aggregateResults) : base(string.Empty, name) { this.moreData = true; this.hideComputerName = true; this.throttleManager = new ThrottleManager(); this._syncObject = new object(); foreach (ExecutionCmdletHelper helper in helpers) { PSRemotingChildJob item = new PSRemotingChildJob(helper, this.throttleManager, aggregateResults); item.StateChanged += new EventHandler<JobStateEventArgs>(this.HandleChildJobStateChanged); item.JobUnblocked += new EventHandler(this.HandleJobUnblocked); base.ChildJobs.Add(item); } base.CloseAllStreams(); base.SetJobState(JobState.Disconnected); this.throttleManager.ThrottleLimit = throttleLimit; this.throttleManager.SubmitOperations(helpers); this.throttleManager.EndSubmitOperations(); }
internal PSInvokeExpressionSyncJob(List<IThrottleOperation> operations, ThrottleManager throttleManager) { base.UsesResultsCollection = true; base.Results.AddRef(); this.throttleManager = throttleManager; base.RegisterThrottleComplete(this.throttleManager); foreach (IThrottleOperation operation in operations) { ExecutionCmdletHelper item = operation as ExecutionCmdletHelper; RemoteRunspace runspace = item.Pipeline.Runspace as RemoteRunspace; if ((runspace != null) && (runspace.RunspaceStateInfo.State == RunspaceState.BeforeOpen)) { runspace.URIRedirectionReported += new EventHandler<RemoteDataEventArgs<Uri>>(this.HandleURIDirectionReported); runspace.StateChanged += new EventHandler<RunspaceStateEventArgs>(this.HandleRunspaceStateChanged); } this.helpers.Add(item); base.AggregateResultsFromHelper(item); RemotePipeline pipeline = item.Pipeline as RemotePipeline; this.powershells.Add(pipeline.PowerShell.InstanceId, pipeline.PowerShell); } }
internal PSWmiChildJob(Cmdlet cmds, string computerName, ThrottleManager throttleManager, int count) : base(null, null) { this.syncObject = new object(); this.statusMessage = "test"; base.UsesResultsCollection = true; this.computerName = computerName; this.throttleManager = throttleManager; this.wmiSinkArray = new ArrayList(); ManagementOperationObserver managementOperationObserver = new ManagementOperationObserver(); this.wmiSinkArray.Add(managementOperationObserver); PSWmiChildJob pSWmiChildJob = this; pSWmiChildJob.sinkCompleted = pSWmiChildJob.sinkCompleted + count; managementOperationObserver.ObjectReady += new ObjectReadyEventHandler(this.NewObject); managementOperationObserver.Completed += new CompletedEventHandler(this.JobDone); this.helper = new WmiAsyncCmdletHelper(this, cmds, computerName, managementOperationObserver, count); this.helper.WmiOperationState += new EventHandler<WmiJobStateEventArgs>(this.HandleWMIState); this.helper.ShutdownComplete += new EventHandler<EventArgs>(this.JobDoneForWin32Shutdown); base.SetJobState(JobState.NotStarted); IThrottleOperation throttleOperation = this.helper; throttleOperation.OperationComplete += new EventHandler<OperationStateEventArgs>(this.HandleOperationComplete); throttleManager.ThrottleComplete += new EventHandler<EventArgs>(this.HandleThrottleComplete); throttleManager.AddOperation(throttleOperation); }
internal PSRemotingChildJob(ExecutionCmdletHelper helper, ThrottleManager throttleManager, bool aggregateResults = false) { this.hideComputerName = true; this.SyncObject = new object(); base.UsesResultsCollection = true; this.helper = helper; this.remotePipeline = helper.Pipeline as RemotePipeline; this.remoteRunspace = helper.Pipeline.Runspace; this.throttleManager = throttleManager; if (aggregateResults) { this.AggregateResultsFromHelper(helper); } else { this.remotePipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(this.HandlePipelineStateChanged); this.remotePipeline.Output.DataReady += new EventHandler(this.HandleOutputReady); this.remotePipeline.Error.DataReady += new EventHandler(this.HandleErrorReady); } IThrottleOperation operation = helper; operation.OperationComplete += new EventHandler<OperationStateEventArgs>(this.HandleOperationComplete); base.SetJobState(JobState.Disconnected, null); }
private void CloseOrDisconnectAllRemoteRunspaces(Func<List<RemoteRunspace>> getRunspaces) { List<RemoteRunspace> list = getRunspaces(); if (list.Count != 0) { EventHandler<EventArgs> handler = null; using (ManualResetEvent remoteRunspaceCloseCompleted = new ManualResetEvent(false)) { ThrottleManager manager = new ThrottleManager(); if (handler == null) { handler = (sender, e) => remoteRunspaceCloseCompleted.Set(); } manager.ThrottleComplete += handler; foreach (RemoteRunspace runspace in list) { IThrottleOperation operation = new CloseOrDisconnectRunspaceOperationHelper(runspace); manager.AddOperation(operation); } manager.EndSubmitOperations(); remoteRunspaceCloseCompleted.WaitOne(); } } }
private void StopOrDisconnectAllJobs() { List<RemoteRunspace> disconnectRunspaces; if (this.JobRepository.Jobs.Count != 0) { disconnectRunspaces = new List<RemoteRunspace>(); EventHandler<EventArgs> handler = null; using (ManualResetEvent jobsStopCompleted = new ManualResetEvent(false)) { ThrottleManager manager = new ThrottleManager(); if (handler == null) { handler = (sender, e) => jobsStopCompleted.Set(); } manager.ThrottleComplete += handler; foreach (Job job in this.JobRepository.Jobs) { if (job is PSRemotingJob) { if (!job.CanDisconnect) { manager.AddOperation(new StopJobOperationHelper(job)); } else if (job.JobStateInfo.State == JobState.Running) { IEnumerable<RemoteRunspace> runspaces = job.GetRunspaces(); if (runspaces != null) { disconnectRunspaces.AddRange(runspaces); } } } } manager.EndSubmitOperations(); jobsStopCompleted.WaitOne(); } this.CloseOrDisconnectAllRemoteRunspaces(() => disconnectRunspaces); } }
public ConnectPSSessionCommand() { this.allSessions = new Collection<PSSession>(); this.throttleManager = new ThrottleManager(); this.operationsComplete = new ManualResetEvent(true); this.queryRunspaces = new QueryRunspaces(); this.stream = new ObjectStream(); this.retryThrottleManager = new ThrottleManager(); this.failedSessions = new Collection<PSSession>(); }
private void SubmitAndWaitForConnect(List<IThrottleOperation> connectJobOperations) { using (ThrottleManager manager = new ThrottleManager()) { EventHandler<EventArgs> handler2 = null; using (ManualResetEvent connectResult = new ManualResetEvent(false)) { if (handler2 == null) { handler2 = (sender, eventArgs) => connectResult.Set(); } EventHandler<EventArgs> handler = handler2; manager.ThrottleComplete += handler; try { manager.ThrottleLimit = 0; manager.SubmitOperations(connectJobOperations); manager.EndSubmitOperations(); connectResult.WaitOne(); } finally { manager.ThrottleComplete -= handler; } } } }
protected void Dispose(bool disposing) { if (disposing) { this.throttleManager.Dispose(); this.operationsComplete.WaitOne(); this.operationsComplete.Close(); this.throttleManager.ThrottleComplete -= new EventHandler<EventArgs>(this.HandleThrottleComplete); this.throttleManager = null; foreach (RemoteRunspace runspace in this.toDispose) { runspace.Dispose(); } foreach (List<IThrottleOperation> list in this.allOperations) { foreach (OpenRunspaceOperation operation in list) { operation.Dispose(); } } this.stream.Dispose(); } }
protected void UnregisterThrottleComplete(ThrottleManager throttleManager) { throttleManager.ThrottleComplete -= new EventHandler<EventArgs>(this.HandleThrottleComplete); }
protected virtual void DoCleanupOnFinished() { bool flag = false; if (!this.cleanupDone) { lock (this.SyncObject) { if (!this.cleanupDone) { this.cleanupDone = true; flag = true; } } } if (flag) { this.StopAggregateResultsFromHelper(this.helper); this.helper.OperationComplete -= new EventHandler<OperationStateEventArgs>(this.HandleOperationComplete); this.UnregisterThrottleComplete(this.throttleManager); this.throttleManager = null; } }
/// <summary> /// Closes or disconnects all the remote runspaces passed in by the getRunspace /// function. If a remote runspace supports disconnect then it will be disconnected /// rather than closed. /// </summary> private void CloseOrDisconnectAllRemoteRunspaces(Func<List<RemoteRunspace>> getRunspaces) { List<RemoteRunspace> runspaces = getRunspaces(); if (runspaces.Count == 0) { return; } // whether the close of all remoterunspaces completed using (ManualResetEvent remoteRunspaceCloseCompleted = new ManualResetEvent(false)) { ThrottleManager throttleManager = new ThrottleManager(); throttleManager.ThrottleComplete += delegate (object sender, EventArgs e) { remoteRunspaceCloseCompleted.Set(); }; foreach (RemoteRunspace remoteRunspace in runspaces) { IThrottleOperation operation = new CloseOrDisconnectRunspaceOperationHelper(remoteRunspace); throttleManager.AddOperation(operation); } throttleManager.EndSubmitOperations(); remoteRunspaceCloseCompleted.WaitOne(); } }
/// <summary> /// internal dispose method which does the actual disposing /// </summary> /// <param name="disposing">whether called from dispose or finalize</param> private void Dispose(bool disposing) { if (disposing) { // this call fixes bug Windows 7 #278836 // by making sure the server is stopped even if it is waiting // for further input from this Invoke-Command cmdlet this.StopProcessing(); // wait for all operations to complete _operationsComplete.WaitOne(); _operationsComplete.Dispose(); if (!_asjob) { if (_job != null) { // job will be null in the "InProcess" case _job.Dispose(); } _throttleManager.ThrottleComplete -= new EventHandler<EventArgs>(HandleThrottleComplete); _throttleManager.Dispose(); _throttleManager = null; } // clear the invoke command references we have stored if (_clearInvokeCommandOnRunspace) { ClearInvokeCommandOnRunspaces(); } _input.Dispose(); lock (_jobSyncObject) { if (_disconnectComplete != null) { _disconnectComplete.Dispose(); _disconnectComplete = null; } } } } // Dispose
/// <summary> /// Disconnects all disconnectable jobs listed in the JobRepository. /// </summary> private void StopOrDisconnectAllJobs() { if (JobRepository.Jobs.Count == 0) { return; } List<RemoteRunspace> disconnectRunspaces = new List<RemoteRunspace>(); using (ManualResetEvent jobsStopCompleted = new ManualResetEvent(false)) { ThrottleManager throttleManager = new ThrottleManager(); throttleManager.ThrottleComplete += delegate (object sender, EventArgs e) { jobsStopCompleted.Set(); }; foreach (Job job in this.JobRepository.Jobs) { // Only stop or disconnect PowerShell jobs. if (job is PSRemotingJob == false) { continue; } if (!job.CanDisconnect) { // If the job cannot be disconnected then add it to // the stop list. throttleManager.AddOperation(new StopJobOperationHelper(job)); } else if (job.JobStateInfo.State == JobState.Running) { // Otherwise add disconnectable runspaces to list so that // they can be disconnected. IEnumerable<RemoteRunspace> jobRunspaces = job.GetRunspaces(); if (jobRunspaces != null) { disconnectRunspaces.AddRange(jobRunspaces); } } } // foreach job // Stop jobs. throttleManager.EndSubmitOperations(); jobsStopCompleted.WaitOne(); } // using jobsStopCompleted // Disconnect all disconnectable job runspaces found. CloseOrDisconnectAllRemoteRunspaces(() => { return disconnectRunspaces; }); }
private void Dispose(bool disposing) { if (disposing) { this.StopProcessing(); this.operationsComplete.WaitOne(); this.operationsComplete.Close(); if (!this.asjob) { if (this.job != null) { this.job.Dispose(); } this.throttleManager.ThrottleComplete -= new EventHandler<EventArgs>(this.HandleThrottleComplete); this.throttleManager.Dispose(); this.throttleManager = null; } if (this.clearInvokeCommandOnRunspace) { this.ClearInvokeCommandOnRunspaces(); } this.input.Dispose(); lock (this.jobSyncObject) { if (this.disconnectComplete != null) { this.disconnectComplete.Close(); this.disconnectComplete = null; } } } }
/// <summary> /// Internal constructor for initializing WMI jobs, where WMI command is executed a variable /// number of times. /// </summary> internal PSWmiChildJob(Cmdlet cmds, string computerName, ThrottleManager throttleManager, int count) : base(null, null) { UsesResultsCollection = true; Location = computerName; _throttleManager = throttleManager; _wmiSinkArray = new ArrayList(); ManagementOperationObserver wmiSink = new ManagementOperationObserver(); _wmiSinkArray.Add(wmiSink); _sinkCompleted += count; wmiSink.ObjectReady += new ObjectReadyEventHandler(this.NewObject); wmiSink.Completed += new CompletedEventHandler(this.JobDone); _helper = new WmiAsyncCmdletHelper(this, cmds, computerName, wmiSink, count); _helper.WmiOperationState += new EventHandler<WmiJobStateEventArgs>(HandleWMIState); _helper.ShutdownComplete += new EventHandler<EventArgs>(JobDoneForWin32Shutdown); SetJobState(JobState.NotStarted); IThrottleOperation operation = _helper; operation.OperationComplete += new EventHandler<OperationStateEventArgs>(HandleOperationComplete); throttleManager.ThrottleComplete += new EventHandler<EventArgs>(HandleThrottleComplete); throttleManager.AddOperation(operation); }
internal static void AddOperation(object operation, ThrottleManager throttleManager) { throttleManager.AddOperation((IThrottleOperation) operation); }
internal static void AddOperation(object operation, ThrottleManager throttleManager) { throttleManager.AddOperation((IThrottleOperation)operation); }
internal static void SubmitOperations(List<object> operations, ThrottleManager throttleManager) { List<IThrottleOperation> newOperations = new List<IThrottleOperation>(); foreach (object operation in operations) { newOperations.Add((IThrottleOperation)operation); } throttleManager.SubmitOperations(newOperations); }