// Start the Process
private void Start(out string errorMessage, out string outputMessage)
{
errorMessage = string.Empty;
outputMessage = string.Empty;
ErrorStream = null;
OutputStream = null;
try
{
pStartInfo.Arguments = this.command;
process = new Process();
process.StartInfo = pStartInfo;
process.Start();
ErrorStream = process.StandardError;
OutputStream = process.StandardOutput;
errorMessage = ErrorStream.ReadToEnd();
outputMessage = OutputStream.ReadToEnd();
process.WaitForExit();
}
catch (Exception e)
{
this.ErrorMessage = e.Message;
}
finally
{
if (!process.HasExited)
{
process.Close();
}
}
}
private static void Test(int errorSize, bool failRequest)
{
var actualSize = errorSize + 128;
//var data = new string('@', actualSize + bufferSize);
//byte[] bytes = Encoding.UTF8.GetBytes(data);
var bytes = CreateData(actualSize);
// must precompute this and set in headers to avoid hash computation on ErrorStream
// affecting the test
var payloadhash = UtilityMethods.ToHex(UtilityMethods.ComputeSHA256(bytes), true);
ErrorStream es = ErrorStream.Create(bytes);
if (failRequest)
{
es.MaxReadBytes = errorSize;
}
// 1 rewind for S3 pre-marshallers which reset position to 0
// 1 rewind for exception at error size
es.MinRewinds = 2;
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = "foo1",
AutoCloseStream = false
};
putRequest.Headers["x-amz-content-sha256"] = payloadhash;
putRequest.InputStream = es;
CallWithTimeout(() => Client.PutObject(putRequest), TimeSpan.FromSeconds(10));
}
public void Evaluate(string expression)
{
try {
object result;
bool result_set;
ErrorStream.Clear();
string ret = this.Evaluator.Evaluate(expression, out result, out result_set);
if (result_set)
{
if (result is ILScene)
{
Panel.Scene = (result as ILScene);
}
else
{
m_shell.WriteText(Environment.NewLine);
m_shell.WriteText(result.ToString());
}
}
else if (ErrorStream.Length > 0)
{
m_shell.WriteError(ErrorStream.ToString());
}
Panel.Configure();
Panel.Refresh();
} catch (Exception exc) {
m_shell.WriteError(exc.ToString());
}
}
public void TestStreamRetry2()
{
string data = "sample data";
byte[] bytes = Encoding.UTF8.GetBytes(data);
// must precompute this and set in headers to avoid hash computation on ErrorStream
// affecting the test
var payloadhash = UtilityMethods.ToHex(UtilityMethods.ComputeSHA256(bytes), true);
ErrorStream es = ErrorStream.Create(bytes, readOnly: true);
es.MaxReadBytes = 3;
int requestCount = 0;
es.OnRead += (s, e) =>
{
if (++requestCount == 2)
{
throw new WebException("Fake WebException", WebExceptionStatus.KeepAliveFailure);
}
};
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = "foo",
InputStream = es,
Headers = { ContentLength = data.Length },
};
putRequest.Headers["x-amz-content-sha256"] = payloadhash;
var exception = AssertExtensions.ExpectException <AmazonServiceException>(() => Client.PutObject(putRequest));
es = ErrorStream.Create(bytes, readOnly: true);
es.MaxReadBytes = 3;
putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = "foo",
InputStream = es,
Headers = { ContentLength = data.Length },
};
putRequest.Headers["X-Amz-Content-SHA256"] = payloadhash;
Client.PutObject(putRequest);
string responseData;
using (var responseStream = Client.GetObject(new GetObjectRequest
{
BucketName = bucketName,
Key = putRequest.Key
}).ResponseStream)
using (StreamReader reader = new StreamReader(responseStream))
{
responseData = reader.ReadToEnd();
}
Assert.AreEqual(data, responseData);
}
public void WriteError(ErrorRecord errorRecord)
{
var psobj = PSObject.AsPSObject(errorRecord);
// if merged with stdout, we can later on check to which stream the object usually belongs
psobj.WriteToErrorStream = true;
ErrorStream.Write(psobj);
ExecutionContext.AddToErrorVariable(errorRecord);
if (MergeErrorToOutput)
{
OutputStream.Write(psobj);
}
}
public static void Error(object value)
{
string txt = ErrorPrefix + value.ToString();
if (AutomaticNewline)
{
ErrorStream.WriteLine(txt);
}
else
{
ErrorStream.Write(txt);
}
}
public void Dispose()
{
if (!IsDisposed)
{
FinishStream();
}
IsDisposed = true;
InStream?.Dispose();
OutStream?.Dispose();
ErrorStream?.Dispose();
}
public void TestStreamRetry1()
{
string data = "sample data";
byte[] bytes = Encoding.UTF8.GetBytes(data);
// must precompute this and set in headers to avoid hash computation on ErrorStream
// affecting the test
var payloadhash = UtilityMethods.ToHex(UtilityMethods.ComputeSHA256(bytes), true);
ErrorStream es = ErrorStream.Create(bytes);
es.MaxReadBytes = 3;
int requestCount = 0;
es.OnRead += (s, e) =>
{
if (++requestCount == 2)
{
throw new IOException("Fake Exception");
}
};
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = "foo1",
InputStream = es,
AutoCloseStream = false
};
putRequest.Headers["x-amz-content-sha256"] = payloadhash;
Client.PutObject(putRequest);
string responseData;
using (var responseStream = Client.GetObject(new GetObjectRequest
{
BucketName = bucketName,
Key = putRequest.Key
}).ResponseStream)
using (StreamReader reader = new StreamReader(responseStream))
{
responseData = reader.ReadToEnd();
}
Assert.AreEqual(data, responseData);
requestCount = 0;
putRequest.InputStream = es;
Client.PutObject(putRequest);
TestStreamRetry2();
}
public void Dispose()
{
if (!_isDisposed)
{
if (_objectsToDispose != null)
{
foreach (var h in _objectsToDispose)
{
h.Dispose();
}
}
_inputReadPipe?.Dispose();
_outputWritePipe?.Dispose();
_errorWritePipe?.Dispose();
InputStream?.Dispose();
OutputStream?.Dispose();
ErrorStream?.Dispose();
_isDisposed = true;
}
}
public void Evaluate(string expression)
{
try {
object result;
bool result_set;
ErrorStream.Clear();
string ret = this.Evaluator.Evaluate(expression, out result, out result_set);
if (result_set)
{
if (result is ILScene)
{
if (m_cleanUpExample != null)
{
m_cleanUpExample();
m_cleanUpExample = null;
}
PanelForm.Panel.Scene = (result as ILScene);
}
else
{
m_shell.WriteText(Environment.NewLine);
m_shell.WriteText(result.ToString());
}
}
else if (ErrorStream.Length > 0)
{
m_shell.WriteError(ErrorStream.ToString());
}
PanelForm.Panel.Configure();
PanelForm.Panel.Refresh();
} catch (ArgumentException exc) {
m_shell.WriteError(exc.Message.ToString());
} catch (ILNumerics.Exceptions.ILArgumentException exc) {
m_shell.WriteError(exc.Message.ToString());
} catch (Exception exc) {
m_shell.WriteError(exc.ToString());
}
}
public void WriteErrorLine(string line) => ErrorStream.Write(line + EndOfLine);
public void WriteError(object value)
{
ErrorStream.Write(value);
}
public Stream Any(ErrorStream request)
{
throw new NotImplementedException("Exception in Stream Response");
}
/// <summary>
/// Runs a process.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="workingDirectory">The working directory.</param>
public async Task StartProcessAsync(string fileName, string arguments, string workingDirectory = null)
{
// Are we showing diagnostics?
if (ShowDiagnostics)
{
await WriteOutputAsync("Preparing to run " + fileName, Color.FromArgb(255, 0, 255, 0));
if (!string.IsNullOrEmpty(arguments))
{
await WriteOutputAsync(" with arguments " + arguments + "." + Environment.NewLine, Color.FromArgb(255, 0, 255, 0));
}
else
{
await WriteOutputAsync("." + Environment.NewLine, Color.FromArgb(255, 0, 255, 0));
}
}
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
var result = await ProcessLauncher.RunToCompletionAsync(
fileName,
arguments,
new ProcessLauncherOptions
{
WorkingDirectory = workingDirectory,
StandardOutput = OutputStream,
StandardError = ErrorStream
});
using (var outStreamRedirect = OutputStream.GetInputStreamAt(0))
{
var size = OutputStream.Size;
using (var dataReader = new DataReader(outStreamRedirect))
{
var bytesLoaded = await dataReader.LoadAsync((uint)size);
var stringRead = dataReader.ReadString(bytesLoaded);
await WriteOutputAsync(stringRead, Colors.White);
}
}
using (var errStreamRedirect = ErrorStream.GetInputStreamAt(0))
{
using (var dataReader = new DataReader(errStreamRedirect))
{
var size = ErrorStream.Size;
var bytesLoaded = await dataReader.LoadAsync((uint)size);
var stringRead = dataReader.ReadString(bytesLoaded);
await WriteOutputAsync(stringRead, Colors.Red);
}
}
}
catch (UnauthorizedAccessException uex)
{
await WriteOutputAsync($"Exception Thrown: {uex.Message}{Environment.NewLine}", Colors.Red);
await WriteOutputAsync($"Make sure you're allowed to run the specified exe; either{Environment.NewLine}" +
$"\t1) Add the exe to the AppX package, or{Environment.NewLine}" +
$"\t2) Add the absolute path of the exe to the allow list:{Environment.NewLine}" +
$"\t\tHKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\EmbeddedMode\\ProcessLauncherAllowedExecutableFilesList.{Environment.NewLine}{Environment.NewLine}" +
$"Also, make sure the <iot:Capability Name=\"systemManagement\" /> has been added to the AppX manifest capabilities.{Environment.NewLine}", Colors.Red);
}
catch (Exception ex)
{
await WriteOutputAsync($"Exception Thrown: {ex.Message}{Environment.NewLine}", Colors.Red);
await WriteOutputAsync($"{ex.StackTrace}{Environment.NewLine}", Colors.Red);
}
});
}
