private void CoreClose(bool syncCall) { bool flag = false; lock (this.SyncRoot) { if ((this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.Closed) || (this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.Broken)) { return; } if (this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.BeforeOpen) { this.SetRunspaceState(System.Management.Automation.Runspaces.RunspaceState.Closing, null); this.SetRunspaceState(System.Management.Automation.Runspaces.RunspaceState.Closed, null); this.RaiseRunspaceStateEvents(); return; } if (this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.Opening) { Monitor.Exit(this.SyncRoot); try { this.RunspaceOpening.Wait(); } finally { Monitor.Enter(this.SyncRoot); } } if (this._bSessionStateProxyCallInProgress) { throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "RunspaceCloseInvalidWhileSessionStateProxy", new object[0]); } if (this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.Closing) { flag = true; } else { if (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.Opened) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotInOpenedState, this.RunspaceState.ToString()), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.Opened); throw exception; } this.SetRunspaceState(System.Management.Automation.Runspaces.RunspaceState.Closing); } } if (!flag) { this.RaiseRunspaceStateEvents(); PSSQMAPI.NoteRunspaceEnd(base.InstanceId); this.CloseHelper(syncCall); } else if (syncCall) { this.WaitForFinishofPipelines(); } }
/// <summary> /// Converts the current to an InvalidRunspaceStateException. /// </summary> internal InvalidRunspaceStateException ToInvalidRunspaceStateException() { InvalidRunspaceStateException exception = new InvalidRunspaceStateException( RunspaceStrings.InvalidRunspaceStateGeneral, this); exception.CurrentState = RunspacePoolStateToRunspaceState(this.CurrentState); exception.ExpectedState = RunspacePoolStateToRunspaceState(this.ExpectedState); return(exception); }
internal void AddToRunningPipelineList(PipelineBase pipeline) { lock (this._runningPipelines.SyncRoot) { if (!this._bypassRunspaceStateCheck && (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.Opened)) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, this.RunspaceState.ToString()), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.Opened); throw exception; } this._runningPipelines.Add(pipeline); this.currentlyRunningPipeline = pipeline; } }
private void CoreOpen(bool syncCall) { lock (this.SyncRoot) { if (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.BeforeOpen) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.CannotOpenAgain, new object[] { this.RunspaceState.ToString() }), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.BeforeOpen); throw exception; } this.SetRunspaceState(System.Management.Automation.Runspaces.RunspaceState.Opening); } this.RaiseRunspaceStateEvents(); PSSQMAPI.NoteRunspaceStart(base.InstanceId); this.OpenHelper(syncCall); }
private void DoConcurrentCheckAndMarkSessionStateProxyCallInProgress() { lock (this._syncRoot) { if (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.Opened) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotInOpenedState, this.RunspaceState.ToString()), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.Opened); throw exception; } if (this._bSessionStateProxyCallInProgress) { throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "AnotherSessionStateProxyInProgress", new object[0]); } Pipeline currentlyRunningPipeline = this.GetCurrentlyRunningPipeline(); if (currentlyRunningPipeline != null) { if ((currentlyRunningPipeline != this.pulsePipeline) && (!currentlyRunningPipeline.IsNested || (this.pulsePipeline == null))) { throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "NoSessionStateProxyWhenPipelineInProgress", new object[0]); } Monitor.Exit(this._syncRoot); try { this.WaitForFinishofPipelines(); } finally { Monitor.Enter(this._syncRoot); } this.DoConcurrentCheckAndMarkSessionStateProxyCallInProgress(); } else { this._bSessionStateProxyCallInProgress = true; } } }
private void CoreOpen(bool syncCall) { lock (this.SyncRoot) { if (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.BeforeOpen) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.CannotOpenAgain, new object[] { this.RunspaceState.ToString() }), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.BeforeOpen); throw exception; } this.SetRunspaceState(System.Management.Automation.Runspaces.RunspaceState.Opening); } this.RaiseRunspaceStateEvents(); PSSQMAPI.NoteRunspaceStart(base.InstanceId); this.OpenHelper(syncCall); }
private void CoreClose(bool syncCall) { bool flag = false; lock (this.SyncRoot) { if ((this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.Closed) || (this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.Broken)) { return; } if (this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.BeforeOpen) { this.SetRunspaceState(System.Management.Automation.Runspaces.RunspaceState.Closing, null); this.SetRunspaceState(System.Management.Automation.Runspaces.RunspaceState.Closed, null); this.RaiseRunspaceStateEvents(); return; } if (this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.Opening) { Monitor.Exit(this.SyncRoot); try { this.RunspaceOpening.Wait(); } finally { Monitor.Enter(this.SyncRoot); } } if (this._bSessionStateProxyCallInProgress) { throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "RunspaceCloseInvalidWhileSessionStateProxy", new object[0]); } if (this.RunspaceState == System.Management.Automation.Runspaces.RunspaceState.Closing) { flag = true; } else { if (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.Opened) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotInOpenedState, this.RunspaceState.ToString()), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.Opened); throw exception; } this.SetRunspaceState(System.Management.Automation.Runspaces.RunspaceState.Closing); } } if (!flag) { this.RaiseRunspaceStateEvents(); PSSQMAPI.NoteRunspaceEnd(base.InstanceId); this.CloseHelper(syncCall); } else if (syncCall) { this.WaitForFinishofPipelines(); } }
internal void AddToRunningPipelineList(PipelineBase pipeline) { lock (this._runningPipelines.SyncRoot) { if (!this._bypassRunspaceStateCheck && (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.Opened)) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, this.RunspaceState.ToString()), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.Opened); throw exception; } this._runningPipelines.Add(pipeline); this.currentlyRunningPipeline = pipeline; } }
/// <summary> /// Add the pipeline to list of pipelines in execution. /// </summary> /// <param name="pipeline">Pipeline to add to the /// list of pipelines in execution</param> /// /// <exception cref="InvalidRunspaceStateException"> /// Thrown if the runspace is not in the Opened state. /// <see cref="RunspaceState"/>. /// </exception> /// /// <exception cref="ArgumentNullException">Thrown if /// <paramref name="pipeline"/> is null. /// </exception> internal void AddToRunningPipelineList(PipelineBase pipeline) { Dbg.Assert(pipeline != null, "caller should validate the parameter"); lock (_pipelineListLock) { if (ByPassRunspaceStateCheck == false && RunspaceState != RunspaceState.Opened) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, RunspaceState.ToString()), RunspaceState, RunspaceState.Opened ); throw e; } //Add the pipeline to list of Executing pipeline. //Note:_runningPipelines is always accessed with the lock so //there is no need to create a synchronized version of list RunningPipelines.Add(pipeline); _currentlyRunningPipeline = pipeline; } }
/// <summary> /// Close the runspace /// </summary> /// <param name="syncCall">If true runspace is closed synchronously /// else runspaces is closed asynchronously /// </param> /// /// <exception cref="InvalidRunspaceStateException"> /// RunspaceState is BeforeOpen or Opening /// </exception> /// /// <exception cref="InvalidOperationException"> /// If SessionStateProxy has some method call in progress /// </exception> private void CoreClose(bool syncCall) { bool alreadyClosing = false; lock (SyncRoot) { if (RunspaceState == RunspaceState.Closed || RunspaceState == RunspaceState.Broken) { return; } else if (RunspaceState == RunspaceState.BeforeOpen) { SetRunspaceState(RunspaceState.Closing, null); SetRunspaceState(RunspaceState.Closed, null); RaiseRunspaceStateEvents(); return; } else if (RunspaceState == RunspaceState.Opening) { // Wait till the runspace is opened - This is set in DoOpenHelper() // Release the lock before we wait Monitor.Exit(SyncRoot); try { RunspaceOpening.Wait(); } finally { // Acquire the lock before we carry on with the rest operations Monitor.Enter(SyncRoot); } } if (_bSessionStateProxyCallInProgress) { throw PSTraceSource.NewInvalidOperationException(RunspaceStrings.RunspaceCloseInvalidWhileSessionStateProxy); } if (RunspaceState == RunspaceState.Closing) { alreadyClosing = true; } else { if (RunspaceState != RunspaceState.Opened) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.RunspaceNotInOpenedState, RunspaceState.ToString()), RunspaceState, RunspaceState.Opened ); throw e; } SetRunspaceState(RunspaceState.Closing); } } if (alreadyClosing) { //Already closing is set to true if Runspace is already //in closing. In this case wait for runspace to close. //This can happen in two scenarios: //1) User calls Runspace.Close from two threads. //2) In remoting, some error from data structure handler layer can start //runspace closure. At the same time, user can call //remove runspace. // if (syncCall) { WaitForFinishofPipelines(); } return; } //Raise Event outside the lock RaiseRunspaceStateEvents(); //Call the derived class implementation to do the actual work CloseHelper(syncCall); }
/// <summary> /// Asserts if the current state of the runspace is BeforeOpen /// </summary> private void AssertIfStateIsBeforeOpen() { lock (_syncRoot) { //Call fails if RunspaceState is not BeforeOpen. if (_runspaceStateInfo.State != RunspaceState.BeforeOpen) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.CannotOpenAgain, new object[] { _runspaceStateInfo.State.ToString() } ), _runspaceStateInfo.State, RunspaceState.BeforeOpen ); throw e; } } }
public override Collection<PSObject> Connect() { Collection<PSObject> collection; this.InitPowerShellForConnect(true); try { collection = this._powershell.Connect(); } catch (InvalidRunspacePoolStateException) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipelineConnect, this._runspace.RunspaceStateInfo.State.ToString()), this._runspace.RunspaceStateInfo.State, RunspaceState.Opened); throw exception; } if (((collection.Count == 0) && (this._outputCollection != null)) && (this._outputCollection.Count > 0)) { collection = new Collection<PSObject>(this._outputCollection); } return collection; }
/// <summary> /// Connects synchronously to a running command on a remote server. /// The pipeline object must be in the disconnected state. /// </summary> /// <returns>A collection of result objects.</returns> public override Collection<PSObject> Connect() { InitPowerShellForConnect(true); Collection<PSObject> results; try { results = _powershell.Connect(); } catch (InvalidRunspacePoolStateException) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipelineConnect, _runspace.RunspaceStateInfo.State.ToString()), _runspace.RunspaceStateInfo.State, RunspaceState.Opened ); throw e; } // PowerShell object will return empty results if it was provided an alternative object to // collect output in. Check to see if the output was collected in a member variable. if (results.Count == 0) { if (_outputCollection != null && _outputCollection.Count > 0) { results = new Collection<PSObject>(_outputCollection); } } return results; }
/// <summary> /// Connects asynchronously to a running command on a remote server. /// </summary> public override void ConnectAsync() { InitPowerShellForConnect(false); try { _powershell.ConnectAsync(); } catch (InvalidRunspacePoolStateException) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipelineConnect, _runspace.RunspaceStateInfo.State.ToString()), _runspace.RunspaceStateInfo.State, RunspaceState.Opened ); throw e; } }
/// <summary> /// Invoke the pipeline, synchronously, returning the results as an /// array of objects. /// </summary> /// <param name="input">an array of input objects to pass to the pipeline. /// Array may be empty but may not be null</param> /// <returns>An array of zero or more result objects</returns> /// <remarks>Caller of synchronous exectute should not close /// input objectWriter. Synchronous invoke will always close the input /// objectWriter. /// /// On Synchronous Invoke if output is throttled and no one is reading from /// output pipe, Execution will block after buffer is full. /// </remarks> public override Collection<PSObject> Invoke(System.Collections.IEnumerable input) { if (input == null) { this.InputStream.Close(); } InitPowerShell(true); Collection<PSObject> results; try { results = _powershell.Invoke(input); } catch (InvalidRunspacePoolStateException) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, _runspace.RunspaceStateInfo.State.ToString()), _runspace.RunspaceStateInfo.State, RunspaceState.Opened ); throw e; } return results; }
public void ProcessRunspaceException(Runspace runspace, int attempt, InvalidRunspaceStateException e) { RunspaceStateInfo info = runspace.RunspaceStateInfo; if (info != null) { LOGGER.TraceEvent(TraceEventType.Warning, CAT_DEFAULT, "Runspace is in wrong state. Exception: {0}, State: {1}, Reason: {2}, Attempt number: {3}", e, info.State, info.Reason, attempt); } else { LOGGER.TraceEvent(TraceEventType.Warning, CAT_DEFAULT, "Runspace is in wrong state. Exception: {0}, Attempt number: {1}", e, attempt); } if (attempt == MAX_ATTEMPTS) { LOGGER.TraceEvent(TraceEventType.Error, CAT_DEFAULT, "Maximum number of attempts achieved, signalling the exception"); _runSpacePool.returnFailedRunspace(runspace); throw e; } else { runspace = _runSpacePool.getAnotherRunspace(runspace); } }
/// <summary> /// Converts the current to an InvalidRunspaceStateException /// </summary> internal InvalidRunspaceStateException ToInvalidRunspaceStateException() { InvalidRunspaceStateException exception = new InvalidRunspaceStateException( RunspaceStrings.InvalidRunspaceStateGeneral, this); exception.CurrentState = RunspacePoolStateToRunspaceState(this.CurrentState); exception.ExpectedState = RunspacePoolStateToRunspaceState(this.ExpectedState); return exception; }
private void DoConcurrentCheckAndMarkSessionStateProxyCallInProgress() { lock (this._syncRoot) { if (this.RunspaceState != System.Management.Automation.Runspaces.RunspaceState.Opened) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotInOpenedState, this.RunspaceState.ToString()), this.RunspaceState, System.Management.Automation.Runspaces.RunspaceState.Opened); throw exception; } if (this._bSessionStateProxyCallInProgress) { throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "AnotherSessionStateProxyInProgress", new object[0]); } Pipeline currentlyRunningPipeline = this.GetCurrentlyRunningPipeline(); if (currentlyRunningPipeline != null) { if ((currentlyRunningPipeline != this.pulsePipeline) && (!currentlyRunningPipeline.IsNested || (this.pulsePipeline == null))) { throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "NoSessionStateProxyWhenPipelineInProgress", new object[0]); } Monitor.Exit(this._syncRoot); try { this.WaitForFinishofPipelines(); } finally { Monitor.Enter(this._syncRoot); } this.DoConcurrentCheckAndMarkSessionStateProxyCallInProgress(); } else { this._bSessionStateProxyCallInProgress = true; } } }
internal void AddToRunningPipelineList(RemotePipeline pipeline) { lock (this._syncRoot) { if ((!this._bypassRunspaceStateCheck && (this._runspaceStateInfo.State != RunspaceState.Opened)) && (this._runspaceStateInfo.State != RunspaceState.Disconnected)) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, this._runspaceStateInfo.State.ToString()), this._runspaceStateInfo.State, RunspaceState.Opened); if (this.ConnectionInfo != null) { exception.Source = this.ConnectionInfo.ComputerName; } throw exception; } this._runningPipelines.Add(pipeline); } }
public override Collection<PSObject> Invoke(IEnumerable input) { Collection<PSObject> collection; if (input == null) { this.InputStream.Close(); } this.InitPowerShell(true, false); try { collection = this._powershell.Invoke(input); } catch (InvalidRunspacePoolStateException) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, this._runspace.RunspaceStateInfo.State.ToString()), this._runspace.RunspaceStateInfo.State, RunspaceState.Opened); throw exception; } return collection; }
/// <summary> /// Opens the runspace. /// </summary> /// <param name="syncCall">If true runspace is opened synchronously /// else runspaces is opened asynchronously /// </param> /// <exception cref="InvalidRunspaceStateException"> /// RunspaceState is not BeforeOpen /// </exception> private void CoreOpen(bool syncCall) { bool etwEnabled = RunspaceEventSource.Log.IsEnabled(); if (etwEnabled) RunspaceEventSource.Log.OpenRunspaceStart(); lock (SyncRoot) { //Call fails if RunspaceState is not BeforeOpen. if (RunspaceState != RunspaceState.BeforeOpen) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.CannotOpenAgain, new object[] { RunspaceState.ToString() }), RunspaceState, RunspaceState.BeforeOpen ); throw e; } SetRunspaceState(RunspaceState.Opening); } //Raise event outside the lock RaiseRunspaceStateEvents(); OpenHelper(syncCall); if (etwEnabled) RunspaceEventSource.Log.OpenRunspaceStop(); // We report startup telementry when opening the runspace - because this is the first time // we are really using PowerShell. This isn't the cleanest place though, because // sometimes there are many runspaces created - the callee ensures telemetry is only // reported once. Note that if the host implements IHostProvidesTelemetryData, we rely // on the host calling ReportStartupTelemetry. if (!(this.Host is IHostProvidesTelemetryData)) { TelemetryAPI.ReportStartupTelemetry(null); } }
private void CoreInvokeAsync() { try { _powershell.BeginInvoke(); } catch (InvalidRunspacePoolStateException) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, _runspace.RunspaceStateInfo.State.ToString()), _runspace.RunspaceStateInfo.State, RunspaceState.Opened ); throw e; } }
/// <summary> /// Add the pipeline to list of pipelines in execution. /// </summary> /// <param name="pipeline">Pipeline to add to the /// list of pipelines in execution</param> /// /// <exception cref="InvalidRunspaceStateException"> /// Thrown if the runspace is not in the Opened state. /// <see cref="RunspaceState"/>. /// </exception> /// /// <exception cref="ArgumentNullException">Thrown if /// <paramref name="pipeline"/> is null. /// </exception> internal void AddToRunningPipelineList(RemotePipeline pipeline) { Dbg.Assert(pipeline != null, "caller should validate the parameter"); lock (_syncRoot) { if (_bypassRunspaceStateCheck == false && _runspaceStateInfo.State != RunspaceState.Opened && _runspaceStateInfo.State != RunspaceState.Disconnected) // Disconnected runspaces can have running pipelines. { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.RunspaceNotOpenForPipeline, _runspaceStateInfo.State.ToString() ), _runspaceStateInfo.State, RunspaceState.Opened ); if (this.ConnectionInfo != null) { e.Source = this.ConnectionInfo.ComputerName; } throw e; } //Add the pipeline to list of Executing pipeline. //Note:_runningPipelines is always accessed with the lock so //there is no need to create a synchronized version of list _runningPipelines.Add(pipeline); } }
/// <summary> /// This method ensures that SessionStateProxy call is allowed and if /// allowed it sets a variable to disallow further SessionStateProxy or /// pipeline calls. /// </summary> private void DoConcurrentCheckAndMarkSessionStateProxyCallInProgress() { lock (SyncRoot) { if (RunspaceState != RunspaceState.Opened) { InvalidRunspaceStateException e = new InvalidRunspaceStateException ( StringUtil.Format(RunspaceStrings.RunspaceNotInOpenedState, RunspaceState.ToString()), RunspaceState, RunspaceState.Opened ); throw e; } if (_bSessionStateProxyCallInProgress == true) { throw PSTraceSource.NewInvalidOperationException(RunspaceStrings.AnotherSessionStateProxyInProgress); } Pipeline runningPipeline = GetCurrentlyRunningPipeline(); if (runningPipeline != null) { // Detect if we're running an engine pulse, or we're running a nested pipeline // from an engine pulse if (runningPipeline == PulsePipeline || (runningPipeline.IsNested && PulsePipeline != null)) { // If so, wait and try again // Release the lock before we wait for the pulse pipelines Monitor.Exit(SyncRoot); try { WaitForFinishofPipelines(); } finally { // Acquire the lock before we carry on with the rest operations Monitor.Enter(SyncRoot); } DoConcurrentCheckAndMarkSessionStateProxyCallInProgress(); return; } else { throw PSTraceSource.NewInvalidOperationException(RunspaceStrings.NoSessionStateProxyWhenPipelineInProgress); } } //Now we can invoke session state proxy _bSessionStateProxyCallInProgress = true; } }
private void AssertIfStateIsBeforeOpen() { lock (this._syncRoot) { if (this._runspaceStateInfo.State != RunspaceState.BeforeOpen) { InvalidRunspaceStateException exception = new InvalidRunspaceStateException(StringUtil.Format(RunspaceStrings.CannotOpenAgain, new object[] { this._runspaceStateInfo.State.ToString() }), this._runspaceStateInfo.State, RunspaceState.BeforeOpen); throw exception; } } }