private void CoreInvoke(IEnumerable input, bool syncCall)
{
using (PipelineBase._trace.TraceMethod())
{
lock (this.SyncRoot)
{
if (this._disposed)
{
throw PipelineBase._trace.NewObjectDisposedException("pipeline");
}
if (this.Commands == null || this.Commands.Count == 0)
{
throw PipelineBase._trace.NewInvalidOperationException("Runspace", "NoCommandInPipeline");
}
if (this.PipelineState != PipelineState.NotStarted)
{
InvalidPipelineStateException pipelineStateException = new InvalidPipelineStateException(ResourceManagerCache.FormatResourceString("Runspace", "PipelineReInvokeNotAllowed"), this.PipelineState, PipelineState.NotStarted);
PipelineBase._trace.TraceException((Exception)pipelineStateException);
throw pipelineStateException;
}
if (syncCall)
{
if (input != null)
{
foreach (object obj in input)
{
this._inputStream.Write(obj);
}
}
this._inputStream.Close();
}
this._syncInvokeCall = syncCall;
this._pipelineFinishedEvent = new ManualResetEvent(false);
this.RunspaceBase.DoConcurrentCheckAndAddToRunningPipelines(this, syncCall);
this.SetPipelineState(PipelineState.Running);
}
try
{
this.StartPipelineExecution();
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
PipelineBase._trace.TraceException(ex);
this.RunspaceBase.RemoveFromRunningPipelineList(this);
this.SetPipelineState(PipelineState.Failed, ex);
throw;
}
}
}
private void CoreInvoke(IEnumerable input, bool syncCall)
{
lock (this.SyncRoot)
{
if (this._disposed)
{
throw PSTraceSource.NewObjectDisposedException("pipeline");
}
if ((base.Commands == null) || (base.Commands.Count == 0))
{
throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "NoCommandInPipeline", new object[0]);
}
if (this.PipelineState != System.Management.Automation.Runspaces.PipelineState.NotStarted)
{
InvalidPipelineStateException exception = new InvalidPipelineStateException(StringUtil.Format(RunspaceStrings.PipelineReInvokeNotAllowed, new object[0]), this.PipelineState, System.Management.Automation.Runspaces.PipelineState.NotStarted);
throw exception;
}
if ((syncCall && !(this._inputStream is PSDataCollectionStream <PSObject>)) && !(this._inputStream is PSDataCollectionStream <object>))
{
if (input != null)
{
foreach (object obj2 in input)
{
this._inputStream.Write(obj2);
}
}
this._inputStream.Close();
}
this._syncInvokeCall = syncCall;
this._pipelineFinishedEvent = new ManualResetEvent(false);
this.RunspaceBase.DoConcurrentCheckAndAddToRunningPipelines(this, syncCall);
this.SetPipelineState(System.Management.Automation.Runspaces.PipelineState.Running);
}
try
{
this.StartPipelineExecution();
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
this.RunspaceBase.RemoveFromRunningPipelineList(this);
this.SetPipelineState(System.Management.Automation.Runspaces.PipelineState.Failed, exception2);
throw;
}
}
/// <summary>
/// Invoke the pipeline asynchronously with input.
/// </summary>
/// <param name="input">input to provide to pipeline. Input is
/// used only for synchronous execution</param>
/// <param name="syncCall">True if this method is called from
/// synchronous invoke else false</param>
/// <remarks>
/// Results are returned through the <see cref="Pipeline.Output"/> reader.
/// </remarks>
/// <exception cref="InvalidOperationException">
/// No command is added to pipeline
/// </exception>
/// <exception cref="InvalidPipelineStateException">
/// PipelineState is not NotStarted.
/// </exception>
/// <exception cref="InvalidOperationException">
/// 1) A pipeline is already executing. Pipeline cannot execute
/// concurrently.
/// 2) InvokeAsync is called on nested pipeline. Nested pipeline
/// cannot be executed Asynchronously.
/// 3) Attempt is made to invoke a nested pipeline directly. Nested
/// pipeline must be invoked from a running pipeline.
/// </exception>
/// <exception cref="InvalidRunspaceStateException">
/// RunspaceState is not Open
/// </exception>
/// <exception cref="ObjectDisposedException">
/// Pipeline already disposed
/// </exception>
private void CoreInvoke(IEnumerable input, bool syncCall)
{
lock (SyncRoot)
{
// NTRAID#Windows Out Of Band Releases-915851-2005/09/13
if (_disposed)
{
throw PSTraceSource.NewObjectDisposedException("pipeline");
}
if (Commands == null || Commands.Count == 0)
{
throw PSTraceSource.NewInvalidOperationException(
RunspaceStrings.NoCommandInPipeline);
}
if (PipelineState != PipelineState.NotStarted)
{
InvalidPipelineStateException e =
new InvalidPipelineStateException
(
StringUtil.Format(RunspaceStrings.PipelineReInvokeNotAllowed),
PipelineState,
PipelineState.NotStarted
);
throw e;
}
if (syncCall && !(InputStream is PSDataCollectionStream <PSObject> || InputStream is PSDataCollectionStream <object>))
{
// Method is called from synchronous invoke.
if (input != null)
{
// TO-DO-Add a test make sure that ObjectDisposed
// exception is thrown
// Write input data in to inputStream and close the input
// pipe. If Input stream is already closed an
// ObjectDisposed exception will be thrown
foreach (object temp in input)
{
InputStream.Write(temp);
}
}
InputStream.Close();
}
SyncInvokeCall = syncCall;
// Create event which will be signalled when pipeline execution
// is completed/failed/stoped.
// Note:Runspace.Close waits for all the running pipeline
// to finish. This Event must be created before pipeline is
// added to list of running pipelines. This avoids the race condition
// where Close is called after pipeline is added to list of
// running pipeline but before event is created.
PipelineFinishedEvent = new ManualResetEvent(false);
// 1) Do the check to ensure that pipeline no other
// pipeline is running.
// 2) Runspace object maintains a list of pipelines in
// execution. Add this pipeline to the list.
RunspaceBase.DoConcurrentCheckAndAddToRunningPipelines(this, syncCall);
// Note: Set PipelineState to Running only after adding pipeline to list
// of pipelines in execution. AddForExecution checks that runspace is in
// state where pipeline can be run.
// StartPipelineExecution raises this event. See Windows Bug 1160481 for
// more details.
SetPipelineState(PipelineState.Running);
}
try
{
// Let the derived class start the pipeline execution.
StartPipelineExecution();
}
catch (Exception exception)
{
// If we fail in any of the above three steps, set the correct states.
RunspaceBase.RemoveFromRunningPipelineList(this);
SetPipelineState(PipelineState.Failed, exception);
// Note: we are not raising the events in this case. However this is
// fine as user is getting the exception.
throw;
}
}
/// <summary>
/// Initializes the underlying PowerShell object after verifying
/// if the pipeline is in a state where it can be invoked.
/// If invokeAndDisconnect is true then the remote PowerShell
/// command will be immediately disconnected after it begins
/// running.
/// </summary>
/// <param name="syncCall">true if called from a sync call</param>
/// <param name="invokeAndDisconnect">Invoke and Disconnect</param>
private void InitPowerShell(bool syncCall, bool invokeAndDisconnect = false)
{
if (_commands == null || _commands.Count == 0)
{
throw PSTraceSource.NewInvalidOperationException(
RunspaceStrings.NoCommandInPipeline);
}
if (_pipelineStateInfo.State != PipelineState.NotStarted)
{
InvalidPipelineStateException e =
new InvalidPipelineStateException
(
StringUtil.Format(RunspaceStrings.PipelineReInvokeNotAllowed),
_pipelineStateInfo.State,
PipelineState.NotStarted
);
throw e;
}
((RemoteRunspace)_runspace).DoConcurrentCheckAndAddToRunningPipelines(this, syncCall);
PSInvocationSettings settings = new PSInvocationSettings();
settings.AddToHistory = _addToHistory;
settings.InvokeAndDisconnect = invokeAndDisconnect;
_powershell.InitForRemotePipeline(_commands, _inputStream, _outputStream, _errorStream, settings, RedirectShellErrorOutputPipe);
_powershell.RemotePowerShell.HostCallReceived +=
new EventHandler<RemoteDataEventArgs<RemoteHostCall>>(HandleHostCallReceived);
}
private void InitPowerShell(bool syncCall, bool invokeAndDisconnect = false)
{
if ((this._commands == null) || (this._commands.Count == 0))
{
throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "NoCommandInPipeline", new object[0]);
}
if (this._pipelineStateInfo.State != PipelineState.NotStarted)
{
InvalidPipelineStateException exception = new InvalidPipelineStateException(StringUtil.Format(RunspaceStrings.PipelineReInvokeNotAllowed, new object[0]), this._pipelineStateInfo.State, PipelineState.NotStarted);
throw exception;
}
((RemoteRunspace) this._runspace).DoConcurrentCheckAndAddToRunningPipelines(this, syncCall);
PSInvocationSettings settings = new PSInvocationSettings {
AddToHistory = this._addToHistory,
InvokeAndDisconnect = invokeAndDisconnect
};
this._powershell.InitForRemotePipeline(this._commands, this._inputStream, this._outputStream, this._errorStream, settings, base.RedirectShellErrorOutputPipe);
this._powershell.RemotePowerShell.HostCallReceived += new EventHandler<RemoteDataEventArgs<RemoteHostCall>>(this.HandleHostCallReceived);
}
private void CoreInvoke(IEnumerable input, bool syncCall)
{
lock (this.SyncRoot)
{
if (this._disposed)
{
throw PSTraceSource.NewObjectDisposedException("pipeline");
}
if ((base.Commands == null) || (base.Commands.Count == 0))
{
throw PSTraceSource.NewInvalidOperationException("RunspaceStrings", "NoCommandInPipeline", new object[0]);
}
if (this.PipelineState != System.Management.Automation.Runspaces.PipelineState.NotStarted)
{
InvalidPipelineStateException exception = new InvalidPipelineStateException(StringUtil.Format(RunspaceStrings.PipelineReInvokeNotAllowed, new object[0]), this.PipelineState, System.Management.Automation.Runspaces.PipelineState.NotStarted);
throw exception;
}
if ((syncCall && !(this._inputStream is PSDataCollectionStream<PSObject>)) && !(this._inputStream is PSDataCollectionStream<object>))
{
if (input != null)
{
foreach (object obj2 in input)
{
this._inputStream.Write(obj2);
}
}
this._inputStream.Close();
}
this._syncInvokeCall = syncCall;
this._pipelineFinishedEvent = new ManualResetEvent(false);
this.RunspaceBase.DoConcurrentCheckAndAddToRunningPipelines(this, syncCall);
this.SetPipelineState(System.Management.Automation.Runspaces.PipelineState.Running);
}
try
{
this.StartPipelineExecution();
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
this.RunspaceBase.RemoveFromRunningPipelineList(this);
this.SetPipelineState(System.Management.Automation.Runspaces.PipelineState.Failed, exception2);
throw;
}
}
/// <summary>
/// Invoke the pipeline asynchronously with input.
/// </summary>
/// <param name="input">input to provide to pipeline. Input is
/// used only for synchronous execution</param>
/// <param name="syncCall">True if this method is called from
/// synchronous invoke else false</param>
/// <remarks>
/// Results are returned through the <see cref="Pipeline.Output"/> reader.
/// </remarks>
/// <exception cref="InvalidOperationException">
/// No command is added to pipeline
/// </exception>
/// <exception cref="InvalidPipelineStateException">
/// PipelineState is not NotStarted.
/// </exception>
/// <exception cref="InvalidOperationException">
/// 1) A pipeline is already executing. Pipeline cannot execute
/// concurrently.
/// 2) InvokeAsync is called on nested pipeline. Nested pipeline
/// cannot be executed Asynchronously.
/// 3) Attempt is made to invoke a nested pipeline directly. Nested
/// pipeline must be invoked from a running pipeline.
/// </exception>
/// <exception cref="InvalidRunspaceStateException">
/// RunspaceState is not Open
/// </exception>
/// <exception cref="ObjectDisposedException">
/// Pipeline already disposed
/// </exception>
private void CoreInvoke(IEnumerable input, bool syncCall)
{
lock (SyncRoot)
{
// NTRAID#Windows Out Of Band Releases-915851-2005/09/13
if (_disposed)
{
throw PSTraceSource.NewObjectDisposedException("pipeline");
}
if (Commands == null || Commands.Count == 0)
{
throw PSTraceSource.NewInvalidOperationException(
RunspaceStrings.NoCommandInPipeline);
}
if (PipelineState != PipelineState.NotStarted)
{
InvalidPipelineStateException e =
new InvalidPipelineStateException
(
StringUtil.Format(RunspaceStrings.PipelineReInvokeNotAllowed),
PipelineState,
PipelineState.NotStarted
);
throw e;
}
if (syncCall && !(InputStream is PSDataCollectionStream<PSObject> || InputStream is PSDataCollectionStream<object>))
{
//Method is called from synchronous invoke.
if (input != null)
{
//TO-DO-Add a test make sure that ObjectDisposed
//exception is thrown
//Write input data in to inputStream and close the input
//pipe. If Input stream is already closed an
//ObjectDisposed exception will be thrown
foreach (object temp in input)
{
InputStream.Write(temp);
}
}
InputStream.Close();
}
SyncInvokeCall = syncCall;
//Create event which will be signalled when pipeline execution
//is completed/failed/stoped.
//Note:Runspace.Close waits for all the running pipeline
//to finish. This Event must be created before pipeline is
//added to list of running pipelines. This avoids the race condition
//where Close is called after pipeline is added to list of
//running pipeline but before event is created.
PipelineFinishedEvent = new ManualResetEvent(false);
//1) Do the check to ensure that pipeline no other
// pipeline is running.
//2) Runspace object maintains a list of pipelines in
//execution. Add this pipeline to the list.
RunspaceBase.DoConcurrentCheckAndAddToRunningPipelines(this, syncCall);
//Note: Set PipelineState to Running only after adding pipeline to list
//of pipelines in execution. AddForExecution checks that runspace is in
//state where pipeline can be run.
//StartPipelineExecution raises this event. See Windows Bug 1160481 for
//more details.
SetPipelineState(PipelineState.Running);
}
try
{
//Let the derived class start the pipeline execution.
StartPipelineExecution();
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
//If we fail in any of the above three steps, set the correct states.
RunspaceBase.RemoveFromRunningPipelineList(this);
SetPipelineState(PipelineState.Failed, exception);
//Note: we are not raising the events in this case. However this is
//fine as user is getting the exception.
throw;
}
}
