/// <summary>
/// Stop the pipeline synchronously
/// </summary>
public override void Stop()
{
bool isAlreadyStopping = false;
if (CanStopPipeline(out isAlreadyStopping))
{
// A pipeline can be stopped before it is started.so protecting against that
if (_powershell != null)
{
IAsyncResult asyncresult = null;
try
{
asyncresult = _powershell.BeginStop(null, null);
}
catch (ObjectDisposedException)
{
throw PSTraceSource.NewObjectDisposedException("Pipeline");
};
asyncresult.AsyncWaitHandle.WaitOne();
}
}
// Waits until pipeline completes stop as this is a sync call.
PipelineFinishedEvent.WaitOne();
}
/// <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(IEnumerable input)
{
// NTRAID#Windows Out Of Band Releases-915851-2005/09/13
if (_disposed)
{
throw PSTraceSource.NewObjectDisposedException("pipeline");
}
CoreInvoke(input, true);
// Wait for pipeline to finish execution
PipelineFinishedEvent.WaitOne();
if (SyncInvokeCall)
{
// Raise the pipeline completion events. These events are set in
// pipeline execution thread. However for Synchronous execution
// we raise the event in the main thread.
RaisePipelineStateEvents();
}
if (PipelineStateInfo.State == PipelineState.Stopped)
{
return(new Collection <PSObject>());
}
else if (PipelineStateInfo.State == PipelineState.Failed && PipelineStateInfo.Reason != null)
{
// If this is an error pipe for a hosting applicationand we are logging,
// then log the error.
if (this.Runspace.GetExecutionContext.EngineHostInterface.UI.IsTranscribing)
{
this.Runspace.ExecutionContext.InternalHost.UI.TranscribeResult(this.Runspace, PipelineStateInfo.Reason.Message);
}
throw PipelineStateInfo.Reason;
}
// Execution completed successfully
// 2004/06/30-JonN was ReadAll() which was non-blocking
return(Output.NonBlockingRead(Int32.MaxValue));
}
/// <summary>
/// Stop the running pipeline.
/// </summary>
/// <param name="syncCall">If true pipeline is stoped synchronously
/// else asynchronously.</param>
private void CoreStop(bool syncCall)
{
// Is pipeline already in stopping state.
bool alreadyStopping = false;
lock (SyncRoot)
{
switch (PipelineState)
{
case PipelineState.NotStarted:
SetPipelineState(PipelineState.Stopping);
SetPipelineState(PipelineState.Stopped);
break;
// If pipeline execution has failed or completed or
// stoped, return silently.
case PipelineState.Stopped:
case PipelineState.Completed:
case PipelineState.Failed:
return;
// If pipeline is in Stopping state, ignore the second
// stop.
case PipelineState.Stopping:
alreadyStopping = true;
break;
case PipelineState.Running:
SetPipelineState(PipelineState.Stopping);
break;
}
}
// If pipeline is already in stopping state. Wait for pipeline
// to finish. We do need to raise any events here as no
// change of state has occurred.
if (alreadyStopping)
{
if (syncCall)
{
PipelineFinishedEvent.WaitOne();
}
return;
}
// Raise the event outside the lock
RaisePipelineStateEvents();
// A pipeline can be stoped before it is started. See NotStarted
// case in above switch statement. This is done to allow stoping a pipeline
// in another thread before it has been started.
lock (SyncRoot)
{
if (PipelineState == PipelineState.Stopped)
{
// Note:if we have reached here, Stopped state was set
// in PipelineState.NotStarted case above. Only other
// way Stopped can be set when this method calls
// StopHelper below
return;
}
}
// Start stop operation in derived class
ImplementStop(syncCall);
}