internal LocalPipeline(System.Management.Automation.Runspaces.LocalRunspace runspace, CommandCollection command, bool addToHistory, bool isNested, ObjectStreamBase inputStream, ObjectStreamBase outputStream, ObjectStreamBase errorStream, PSInformationalBuffers infoBuffers) : base(runspace, command, addToHistory, isNested, inputStream, outputStream, errorStream, infoBuffers)
{
this._historyIdForThisPipeline = -1L;
this._invokeHistoryIds = new List<long>();
this._stopper = new PipelineStopper(this);
this.InitStreams();
}
/// <summary>
/// Create a Pipeline with an existing command string.
/// Caller should validate all the parameters.
/// </summary>
/// <param name="runspace">
/// The LocalRunspace to associate with this pipeline.
/// </param>
/// <param name="command">
/// The command to invoke.
/// </param>
/// <param name="addToHistory">
/// If true, add the command to history.
/// </param>
/// <param name="isNested">
/// If true, mark this pipeline as a nested pipeline.
/// </param>
/// <param name="inputStream">
/// Stream to use for reading input objects.
/// </param>
/// <param name="errorStream">
/// Stream to use for writing error objects.
/// </param>
/// <param name="outputStream">
/// Stream to use for writing output objects.
/// </param>
/// <param name="infoBuffers">
/// Buffers used to write progress, verbose, debug, warning, information
/// information of an invocation.
/// </param>
/// <exception cref="ArgumentNullException">
/// Command is null and add to history is true
/// </exception>
/// <exception cref="ArgumentNullException">
/// 1. InformationalBuffers is null
/// </exception>
protected PipelineBase(Runspace runspace,
CommandCollection command,
bool addToHistory,
bool isNested,
ObjectStreamBase inputStream,
ObjectStreamBase outputStream,
ObjectStreamBase errorStream,
PSInformationalBuffers infoBuffers)
: base(runspace, command)
{
Dbg.Assert(null != inputStream, "Caller Should validate inputstream parameter");
Dbg.Assert(null != outputStream, "Caller Should validate outputStream parameter");
Dbg.Assert(null != errorStream, "Caller Should validate errorStream parameter");
Dbg.Assert(null != infoBuffers, "Caller Should validate informationalBuffers parameter");
Dbg.Assert(null != command, "Command cannot be null");
// Since we are constructing this pipeline using a commandcollection we dont need
// to add cmd to CommandCollection again (Initialize does this).. because of this
// I am handling history here..
Initialize(runspace, null, false, isNested);
if (true == addToHistory)
{
// get command text for history..
string cmdText = command.GetCommandStringForHistory();
HistoryString = cmdText;
AddToHistory = addToHistory;
}
//Initialize streams
InputStream = inputStream;
OutputStream = outputStream;
ErrorStream = errorStream;
InformationalBuffers = infoBuffers;
}
public ObjectWriter([In, Out] ObjectStreamBase stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
this._stream = stream;
}
private void HandleInputDataReady(object sender, EventArgs e)
{
lock (this.inputSyncObject)
{
ObjectStreamBase inputstream = sender as ObjectStreamBase;
this.WriteInput(inputstream);
}
}
public ObjectWriter([In, Out] ObjectStreamBase stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
this._stream = stream;
}
/// <summary>
/// Construct with an existing ObjectStream.
/// </summary>
/// <param name="stream">The stream to read.</param>
/// <exception cref="ArgumentNullException">Thrown if the specified stream is null.</exception>
protected ObjectReaderBase([In, Out] ObjectStreamBase stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream), "stream may not be null");
}
_stream = stream;
}
/// <summary>
/// Construct with an existing ObjectStream.
/// </summary>
/// <param name="stream">The stream to read.</param>
/// <exception cref="ArgumentNullException">Thrown if the specified stream is null.</exception>
public ObjectReaderBase([In, Out] ObjectStreamBase stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream", "stream may not be null");
}
_stream = stream;
}
public ObjectReaderBase([In, Out] ObjectStreamBase stream)
{
this._monitorObject = new object();
if (stream == null)
{
throw new ArgumentNullException("stream", "stream may not be null");
}
this._stream = stream;
}
protected PipelineBase(System.Management.Automation.Runspaces.Runspace runspace, string command, bool addToHistory, bool isNested) : base(runspace)
{
this._pipelineStateInfo = new System.Management.Automation.Runspaces.PipelineStateInfo(System.Management.Automation.Runspaces.PipelineState.NotStarted);
this._performNestedCheck = true;
this._executionEventQueue = new Queue<ExecutionEventQueueItem>();
this._syncRoot = new object();
this.Initialize(runspace, command, addToHistory, isNested);
this._inputStream = new ObjectStream();
this._outputStream = new ObjectStream();
this._errorStream = new ObjectStream();
}
/// <summary>
/// Construct with an existing ObjectStream.
/// </summary>
/// <param name="stream">The stream to write.</param>
/// <exception cref="ArgumentNullException">Thrown if the specified stream is null.</exception>
public ObjectWriter([In, Out] ObjectStreamBase stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
_stream = stream;
#if (false)
stream.WriteReady += new EventHandler(this.OnWriteReady);
#endif
}
/// <summary>
/// Create a Pipeline with an existing command string.
/// Caller should validate all the parameters.
/// </summary>
/// <param name="runspace">
/// The LocalRunspace to associate with this pipeline.
/// </param>
/// <param name="command">
/// The command to execute.
/// </param>
/// <param name="addToHistory">
/// If true, add the command(s) to the history list of the runspace.
/// </param>
/// <param name="isNested">
/// If true, mark this pipeline as a nested pipeline.
/// </param>
/// <param name="inputStream">
/// Stream to use for reading input objects.
/// </param>
/// <param name="errorStream">
/// Stream to use for writing error objects.
/// </param>
/// <param name="outputStream">
/// Stream to use for writing output objects.
/// </param>
/// <param name="infoBuffers">
/// Buffers used to write progress, verbose, debug, warning, information
/// information of an invocation.
/// </param>
internal LocalPipeline(LocalRunspace runspace,
CommandCollection command,
bool addToHistory,
bool isNested,
ObjectStreamBase inputStream,
ObjectStreamBase outputStream,
ObjectStreamBase errorStream,
PSInformationalBuffers infoBuffers)
: base(runspace, command, addToHistory, isNested, inputStream, outputStream, errorStream, infoBuffers)
{
_stopper = new PipelineStopper(this);
InitStreams();
}
private void WriteInput(ObjectStreamBase inputstream)
{
foreach (object obj2 in inputstream.ObjectReader.NonBlockingRead(0x7fffffff))
{
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInput(obj2, this.clientRunspacePoolId, this.clientPowerShellId));
}
if (!inputstream.IsOpen)
{
foreach (object obj3 in inputstream.ObjectReader.NonBlockingRead(0x7fffffff))
{
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInput(obj3, this.clientRunspacePoolId, this.clientPowerShellId));
}
inputstream.DataReady -= new EventHandler(this.HandleInputDataReady);
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInputEnd(this.clientRunspacePoolId, this.clientPowerShellId));
}
}
internal void SendInput(ObjectStreamBase inputstream)
{
if (!inputstream.IsOpen && (inputstream.Count == 0))
{
lock (this.inputSyncObject)
{
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInputEnd(this.clientRunspacePoolId, this.clientPowerShellId));
return;
}
}
lock (this.inputSyncObject)
{
inputstream.DataReady += new EventHandler(this.HandleInputDataReady);
this.WriteInput(inputstream);
}
}
protected PipelineBase(System.Management.Automation.Runspaces.Runspace runspace, CommandCollection command, bool addToHistory, bool isNested, ObjectStreamBase inputStream, ObjectStreamBase outputStream, ObjectStreamBase errorStream, PSInformationalBuffers infoBuffers) : base(runspace, command)
{
this._pipelineStateInfo = new System.Management.Automation.Runspaces.PipelineStateInfo(System.Management.Automation.Runspaces.PipelineState.NotStarted);
this._performNestedCheck = true;
this._executionEventQueue = new Queue<ExecutionEventQueueItem>();
this._syncRoot = new object();
this.Initialize(runspace, null, false, isNested);
if (addToHistory)
{
string commandStringForHistory = command.GetCommandStringForHistory();
this._historyString = commandStringForHistory;
this._addToHistory = addToHistory;
}
this._inputStream = inputStream;
this._outputStream = outputStream;
this._errorStream = errorStream;
this._informationalBuffers = infoBuffers;
}
internal void SendInput(ObjectStreamBase inputstream)
{
using (ClientPowerShellDataStructureHandler.tracer.TraceMethod())
{
if (!inputstream.IsOpen && inputstream.Count == 0)
{
lock (this.inputSyncObject)
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInputEnd(this.clientRunspacePoolId, this.clientPowerShellId));
}
else
{
lock (this.inputSyncObject)
{
inputstream.DataReady += new EventHandler(this.HandleInputDataReady);
this.WriteInput(inputstream);
}
}
}
}
private void WriteInput(ObjectStreamBase inputstream)
{
using (ClientPowerShellDataStructureHandler.tracer.TraceMethod())
{
foreach (object data in inputstream.ObjectReader.NonBlockingRead(int.MaxValue))
{
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInput(data, this.clientRunspacePoolId, this.clientPowerShellId));
}
if (inputstream.IsOpen)
{
return;
}
foreach (object data in inputstream.ObjectReader.NonBlockingRead(int.MaxValue))
{
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInput(data, this.clientRunspacePoolId, this.clientPowerShellId));
}
inputstream.DataReady -= new EventHandler(this.HandleInputDataReady);
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInputEnd(this.clientRunspacePoolId, this.clientPowerShellId));
}
}
/// <summary>
/// Initialize the client remote powershell instance
/// </summary>
/// <param name="inputstream">input for execution</param>
/// <param name="errorstream">error stream to which
/// data needs to be written to</param>
/// <param name="informationalBuffers">informational buffers
/// which will hold debug, verbose and warning messages</param>
/// <param name="settings">settings based on which this powershell
/// needs to be executed</param>
/// <param name="outputstream">output stream to which data
/// needs to be written to</param>
internal void Initialize(
ObjectStreamBase inputstream, ObjectStreamBase outputstream,
ObjectStreamBase errorstream, PSInformationalBuffers informationalBuffers,
PSInvocationSettings settings)
{
initialized = true;
this.informationalBuffers = informationalBuffers;
InputStream = inputstream;
this.errorstream = errorstream;
this.outputstream = outputstream;
this.settings = settings;
if (settings == null || settings.Host == null)
{
hostToUse = runspacePool.Host;
}
else
{
hostToUse = settings.Host;
}
dataStructureHandler = runspacePool.DataStructureHandler.CreatePowerShellDataStructureHandler(this);
// register for events from the data structure handler
dataStructureHandler.InvocationStateInfoReceived +=
new EventHandler<RemoteDataEventArgs<PSInvocationStateInfo>>(HandleInvocationStateInfoReceived);
dataStructureHandler.OutputReceived += new EventHandler<RemoteDataEventArgs<object>>(HandleOutputReceived);
dataStructureHandler.ErrorReceived += new EventHandler<RemoteDataEventArgs<ErrorRecord>>(HandleErrorReceived);
dataStructureHandler.InformationalMessageReceived +=
new EventHandler<RemoteDataEventArgs<InformationalMessage>>(HandleInformationalMessageReceived);
dataStructureHandler.HostCallReceived +=
new EventHandler<RemoteDataEventArgs<RemoteHostCall>>(HandleHostCallReceived);
dataStructureHandler.ClosedNotificationFromRunspacePool +=
new EventHandler<RemoteDataEventArgs<Exception>>(HandleCloseNotificationFromRunspacePool);
dataStructureHandler.BrokenNotificationFromRunspacePool +=
new EventHandler<RemoteDataEventArgs<Exception>>(HandleBrokenNotificationFromRunspacePool);
dataStructureHandler.ConnectCompleted += new EventHandler<RemoteDataEventArgs<Exception>>(HandleConnectCompleted);
dataStructureHandler.ReconnectCompleted += new EventHandler<RemoteDataEventArgs<Exception>>(HandleConnectCompleted);
dataStructureHandler.RobustConnectionNotification +=
new EventHandler<ConnectionStatusEventArgs>(HandleRobustConnectionNotification);
dataStructureHandler.CloseCompleted +=
new EventHandler<EventArgs>(HandleCloseCompleted);
}
public ObjectWriter([In, Out] ObjectStreamBase stream)
{
using (ObjectWriter._trace.TraceConstructor((object)this))
this._stream = stream != null ? stream : throw new ArgumentNullException(nameof(stream));
}
public ObjectReaderBase([In, Out] ObjectStreamBase stream)
{
using (ObjectReaderBase <T> ._trace.TraceConstructor((object)this))
this._stream = stream != null ? stream : throw new ArgumentNullException(nameof(stream), "stream may not be null");
}
private void WriteInput(ObjectStreamBase inputstream)
{
foreach (object obj2 in inputstream.ObjectReader.NonBlockingRead(0x7fffffff))
{
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInput(obj2, this.clientRunspacePoolId, this.clientPowerShellId));
}
if (!inputstream.IsOpen)
{
foreach (object obj3 in inputstream.ObjectReader.NonBlockingRead(0x7fffffff))
{
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInput(obj3, this.clientRunspacePoolId, this.clientPowerShellId));
}
inputstream.DataReady -= new EventHandler(this.HandleInputDataReady);
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInputEnd(this.clientRunspacePoolId, this.clientPowerShellId));
}
}
internal void SendInput(ObjectStreamBase inputstream)
{
if (!inputstream.IsOpen && (inputstream.Count == 0))
{
lock (this.inputSyncObject)
{
this.SendDataAsync(RemotingEncoder.GeneratePowerShellInputEnd(this.clientRunspacePoolId, this.clientPowerShellId));
return;
}
}
lock (this.inputSyncObject)
{
inputstream.DataReady += new EventHandler(this.HandleInputDataReady);
this.WriteInput(inputstream);
}
}