internal static MinishellStream ToMinishellStream(string stream)
{
MinishellStream unknown = MinishellStream.Unknown;
if ("output".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
return(MinishellStream.Output);
}
if ("error".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
return(MinishellStream.Error);
}
if ("debug".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
return(MinishellStream.Debug);
}
if ("verbose".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
return(MinishellStream.Verbose);
}
if ("warning".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
return(MinishellStream.Warning);
}
if ("progress".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
unknown = MinishellStream.Progress;
}
return(unknown);
}
internal static MinishellStream ToMinishellStream(string stream)
{
MinishellStream minishellStream = MinishellStream.Unknown;
if ("output".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
minishellStream = MinishellStream.Output;
}
else if ("error".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
minishellStream = MinishellStream.Error;
}
else if ("debug".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
minishellStream = MinishellStream.Debug;
}
else if ("verbose".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
minishellStream = MinishellStream.Verbose;
}
else if ("warning".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
minishellStream = MinishellStream.Warning;
}
else if ("progress".Equals(stream, StringComparison.OrdinalIgnoreCase))
{
minishellStream = MinishellStream.Progress;
}
return(minishellStream);
}
private void AddObjectToWriter(object data, MinishellStream stream)
{
try
{
ProcessOutputObject processOutputObject = new ProcessOutputObject(data, stream);
lock (this.writer)
this.writer.Write((object)processOutputObject);
}
catch (PipelineClosedException ex)
{
}
catch (ObjectDisposedException ex)
{
}
}
private void AddObjectToWriter(object data, MinishellStream stream)
{
try
{
ProcessOutputObject obj2 = new ProcessOutputObject(data, stream);
lock (this.writer)
{
this.writer.Write(obj2);
}
}
catch (PipelineClosedException)
{
}
catch (ObjectDisposedException)
{
}
}
/// <summary>
/// Adds one object to writer
/// </summary>
private void AddObjectToWriter(object data, MinishellStream stream)
{
try
{
ProcessOutputObject dataObject = new ProcessOutputObject(data, stream);
//writer is shared between Error and Output reader.
lock (_writer)
{
_writer.Write(dataObject);
}
}
catch (PipelineClosedException)
{
// The output queue may have been closed asynchronously
;
}
catch (System.ObjectDisposedException)
{
// The output queue may have been disposed asynchronously when StopProcessing is called...
;
}
}
/// <summary>
/// Build an output object
/// </summary>
/// <param name="data">The data to output</param>
/// <param name="stream">stream to which data belongs</param>
internal ProcessOutputObject(object data, MinishellStream stream)
{
Data = data;
Stream = stream;
}
internal ProcessOutputObject(object data, MinishellStream stream)
{
this.data = data;
this.stream = stream;
}
private void ReadXml()
{
try
{
Deserializer deserializer = new Deserializer(XmlReader.Create(this.streamReader, InternalDeserializer.XmlReaderSettingsForCliXml));
while (!deserializer.Done())
{
string str;
object obj2 = deserializer.Deserialize(out str);
MinishellStream unknown = MinishellStream.Unknown;
if (str != null)
{
unknown = StringToMinishellStreamConverter.ToMinishellStream(str);
}
if (unknown == MinishellStream.Unknown)
{
unknown = this.isOutput ? MinishellStream.Output : MinishellStream.Error;
}
if ((unknown == MinishellStream.Output) || (obj2 != null))
{
if (unknown == MinishellStream.Error)
{
if (obj2 is PSObject)
{
obj2 = ErrorRecord.FromPSObjectForRemoting(PSObject.AsPSObject(obj2));
}
else
{
string targetObject = null;
try
{
targetObject = (string)LanguagePrimitives.ConvertTo(obj2, typeof(string), CultureInfo.InvariantCulture);
}
catch (PSInvalidCastException)
{
continue;
}
obj2 = new ErrorRecord(new RemoteException(targetObject), "NativeCommandError", ErrorCategory.NotSpecified, targetObject);
}
}
else if (((unknown == MinishellStream.Debug) || (unknown == MinishellStream.Verbose)) || (unknown == MinishellStream.Warning))
{
try
{
obj2 = LanguagePrimitives.ConvertTo(obj2, typeof(string), CultureInfo.InvariantCulture);
}
catch (PSInvalidCastException)
{
continue;
}
}
this.AddObjectToWriter(obj2, unknown);
}
}
}
catch (XmlException exception)
{
string cliXmlError = NativeCP.CliXmlError;
XmlException exception2 = new XmlException(string.Format(null, cliXmlError, new object[] { this.isOutput ? MinishellStream.Output : MinishellStream.Error, this.processPath, exception.Message }), exception);
ErrorRecord data = new ErrorRecord(exception2, "ProcessStreamReader_CliXmlError", ErrorCategory.SyntaxError, this.processPath);
this.AddObjectToWriter(data, MinishellStream.Error);
}
}
internal ProcessOutputObject(object data, MinishellStream stream)
{
this.data = data;
this.stream = stream;
}
private void ReadXml()
{
try
{
Deserializer deserializer = new Deserializer((XmlReader) new XmlTextReader((TextReader)this.streamReader));
while (!deserializer.Done())
{
string streamName;
object obj = deserializer.Deserialize(out streamName);
MinishellStream stream = MinishellStream.Unknown;
if (streamName != null)
{
stream = StringToMinishellStreamConverter.ToMinishellStream(streamName);
}
if (stream == MinishellStream.Unknown)
{
stream = this.isOutput ? MinishellStream.Output : MinishellStream.Error;
}
if (stream == MinishellStream.Output || obj != null)
{
switch (stream)
{
case MinishellStream.Error:
if (obj is PSObject)
{
obj = (object)ErrorRecord.FromPSObjectForRemoting(PSObject.AsPSObject(obj));
break;
}
string message;
try
{
message = (string)LanguagePrimitives.ConvertTo(obj, typeof(string), (IFormatProvider)CultureInfo.InvariantCulture);
}
catch (PSInvalidCastException ex)
{
ProcessStreamReader.tracer.TraceException((Exception)ex);
continue;
}
obj = (object)new ErrorRecord((Exception) new RemoteException(message), "NativeCommandError", ErrorCategory.NotSpecified, (object)message);
break;
case MinishellStream.Verbose:
case MinishellStream.Warning:
case MinishellStream.Debug:
try
{
obj = LanguagePrimitives.ConvertTo(obj, typeof(string), (IFormatProvider)CultureInfo.InvariantCulture);
break;
}
catch (PSInvalidCastException ex)
{
ProcessStreamReader.tracer.TraceException((Exception)ex);
continue;
}
}
this.AddObjectToWriter(obj, stream);
}
}
}
catch (XmlException ex)
{
ProcessStreamReader.tracer.TraceException((Exception)ex);
this.AddObjectToWriter((object)new ErrorRecord((Exception) new XmlException(string.Format((IFormatProvider)null, ResourceManagerCache.GetResourceString("NativeCP", "CliXmlError"), (object)(MinishellStream)(this.isOutput ? 0 : 1), (object)this.processPath, (object)ex.Message), (Exception)ex), "ProcessStreamReader_CliXmlError", ErrorCategory.SyntaxError, (object)this.processPath), MinishellStream.Error);
}
}
