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 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 PSRemotingJob() { this.moreData = true; this.hideComputerName = true; this.throttleManager = new ThrottleManager(); this._syncObject = new object(); }
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; } } } }
private void RetryFailedSessions() { EventHandler <EventArgs> eventHandler = null; using (ManualResetEvent manualResetEvent = new ManualResetEvent(false)) { Collection <PSSession> pSSessions = new Collection <PSSession>(); List <IThrottleOperation> throttleOperations = new List <IThrottleOperation>(); this.retryThrottleManager.ThrottleLimit = this.ThrottleLimit; ThrottleManager throttleManager = this.retryThrottleManager; if (eventHandler == null) { eventHandler = (object sender, EventArgs eventArgs) => manualResetEvent.Set(); } throttleManager.ThrottleComplete += eventHandler; foreach (PSSession failedSession in this.failedSessions) { throttleOperations.Add(new ConnectPSSessionCommand.ConnectRunspaceOperation(failedSession, this.stream, base.Host, new QueryRunspaces(), pSSessions)); } this.retryThrottleManager.SubmitOperations(throttleOperations); this.retryThrottleManager.EndSubmitOperations(); manualResetEvent.WaitOne(); foreach (PSSession pSSession in pSSessions) { base.RunspaceRepository.AddOrReplace(pSSession); } } }
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); }
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>(); }
/// <summary> /// This method is called periodically to refresh the thottle policy. /// </summary> /// <remarks> /// Currently, this method does no updates to the policy. However, in the future, we'll update the throttle policy dynamically. These will require /// making async calls to Table Storage. /// </remarks> /// <returns>a task</returns> public Task <IPolicyRepository> RefreshingThottlePolicy() { // get policy object from cache var policy = this.PolicyRepository.FirstOrDefault(ThrottleManager.GetPolicyKey()); // here where we will update the policy // apply policy updates ThrottleManager.UpdatePolicy(policy, this.PolicyRepository); return(Task.FromResult(this.PolicyRepository)); }
internal PSWmiJob(Cmdlet cmds, string[] computerName, int throttleLimit, string command, int count) : base(command, null) { this.throttleManager = new ThrottleManager(); this.syncObject = new object(); base.PSJobTypeName = "WmiJob"; this.throttleManager.ThrottleLimit = throttleLimit; for (int i = 0; i < (int)computerName.Length; i++) { PSWmiChildJob pSWmiChildJob = new PSWmiChildJob(cmds, computerName[i], this.throttleManager, count); pSWmiChildJob.StateChanged += new EventHandler <JobStateEventArgs>(this.HandleChildJobStateChanged); pSWmiChildJob.JobUnblocked += new EventHandler(this.HandleJobUnblocked); base.ChildJobs.Add(pSWmiChildJob); } this.CommonInit(throttleLimit); }
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 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); }
/// <summary> /// After a decouple or part explosion, it's possible for this vessel to /// still have an assigned flight control parameter that is coming from /// a kOS core that is no longer on this vessel but is instead on the newly /// branched vessel we left behind. If so, that parameter needs to be /// removed from this vessel. The new kOSVesselModule will take care of /// making a new parameter on the new vessel, but this kOSVesselModule needs /// to detach it from this one. /// </summary> private void ResetPhysicallyDetachedParameters() { List <string> removeKeys = new List <string>(); foreach (string key in flightControlParameters.Keys) { IFlightControlParameter p = flightControlParameters[key]; if (p.GetShared() != null && p.GetShared().Vessel != null && Vessel != null && p.GetShared().Vessel.id != Vessel.id) { removeKeys.Add(key); } } foreach (string key in removeKeys) { SafeHouse.Logger.SuperVerbose(string.Format( "kOSVesselModule: re-defaulting parameter \"{0}\" because it's on a detached part of the vessel.", key)); RemoveFlightControlParameter(key); IFlightControlParameter p = null; if (key.Equals("steering")) { p = new SteeringManager(Vessel); } else if (key.Equals("throttle")) { p = new ThrottleManager(Vessel); } else if (key.Equals("wheelsteering")) { p = new WheelSteeringManager(Vessel); } else if (key.Equals("wheelthrottle")) { p = new WheelThrottleManager(Vessel); } else if (key.Equals("flightcontrol")) { p = new FlightControl(Vessel); } if (p != null) { AddFlightControlParameter(key, p); } } foundWrongVesselAutopilot = false; }
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 PSRemotingChildJob( string remoteCommand, ExecutionCmdletHelper helper, ThrottleManager throttleManager) : base(remoteCommand) { using (PSRemotingChildJob.tracer.TraceConstructor((object)this)) { this.helper = helper; this.remoteRunspace = helper.Pipeline.Runspace; this.remotePipeline = helper.Pipeline as RemotePipeline; this.throttleManager = throttleManager; if (this.remoteRunspace is RemoteRunspace remoteRunspace && remoteRunspace.RunspaceStateInfo.State == RunspaceState.BeforeOpen) { remoteRunspace.URIRedirectionReported += new EventHandler <RemoteDataEventArgs <Uri> >(this.HandleURIDirectionReported); } this.AggregateResultsFromHelper(helper); this.RegisterThrottleComplete(throttleManager); } }
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); } }
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 void UpdateRateLimits() { //init policy repo var policyRepository = new PolicyCacheRepository(); //get policy object from cache var policy = policyRepository.FirstOrDefault(ThrottleManager.GetPolicyKey()); //update client rate limits policy.ClientRules["api-client-key-1"] = new RateLimits { PerMinute = 50, PerHour = 500 }; //add new client rate limits policy.ClientRules.Add("api-client-key-3", new RateLimits { PerMinute = 60, PerHour = 600 }); //apply policy updates ThrottleManager.UpdatePolicy(policy, policyRepository); }
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(); } }
internal PSInvokeExpressionSyncJob( List <IThrottleOperation> operations, ThrottleManager throttleManager) { this.Results.AddRef(); this.throttleManager = throttleManager; this.RegisterThrottleComplete(this.throttleManager); foreach (IThrottleOperation operation in operations) { ExecutionCmdletHelper helper = operation as ExecutionCmdletHelper; if (helper.Pipeline.Runspace is RemoteRunspace runspace && runspace.RunspaceStateInfo.State == RunspaceState.BeforeOpen) { runspace.URIRedirectionReported += new EventHandler <RemoteDataEventArgs <Uri> >(((PSRemotingChildJob)this).HandleURIDirectionReported); runspace.StateChanged += new EventHandler <RunspaceStateEventArgs>(this.HandleRunspaceStateChanged); } this.helpers.Add(helper); this.AggregateResultsFromHelper(helper); RemotePipeline pipeline = helper.Pipeline as RemotePipeline; this.powershells.Add(pipeline.PowerShell.InstanceId, pipeline.PowerShell); } throttleManager.SubmitOperations(operations); throttleManager.EndSubmitOperations(); }
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; } }
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); }
protected void UnregisterThrottleComplete(ThrottleManager throttleManager) { throttleManager.ThrottleComplete -= new EventHandler <EventArgs>(this.HandleThrottleComplete); }