public Writer(int fileDescriptor, CapturedOutputWriter monitor)
{
this.fileDescriptor = fileDescriptor;
this.monitor = monitor;
this.codeCellId = monitor.codeCellId;
}
public async Task RunAsync(
Compilation compilation,
CancellationToken cancellationToken = default(CancellationToken))
{
foreach (var assembly in new AssemblyDefinition [] { compilation.ExecutableAssembly }
.Concat(compilation.References ?? new AssemblyDefinition [] { }))
{
agent.LoadExternalDependencies(null, assembly?.ExternalDependencies);
}
Exception evaluationException = null;
var result = new Evaluation {
RequestId = compilation.MessageId,
CodeCellId = compilation.CodeCellId,
Phase = EvaluationPhase.Compiled
};
if (compilation?.ExecutableAssembly?.Content.PEImage != null)
{
result.Compilation = compilation;
}
loadedAssemblies = new List <AssemblyDefinition> ();
var savedStdout = Console.Out;
var savedStderr = Console.Error;
var capturedOutputWriter = new CapturedOutputWriter(compilation.CodeCellId);
Console.SetOut(capturedOutputWriter.StandardOutput);
Console.SetError(capturedOutputWriter.StandardError);
capturedOutputWriter.SegmentCaptured += CapturedOutputWriter_SegmentCaptured;
var stopwatch = new Stopwatch();
currentRunThread = Thread.CurrentThread;
currentRunThread.CurrentCulture = InteractiveCulture.CurrentCulture;
currentRunThread.CurrentUICulture = InteractiveCulture.CurrentUICulture;
initializedAgentIntegration = false;
try {
// We _only_ want to capture exceptions from user-code here but
// allow our own bugs to propagate out to the normal exception
// handling. The only reason we capture these exceptions is in
// case anything has been written to stdout/stderr by user-code
// before the exception was raised... we still want to send that
// captured output back to the client for rendering.
stopwatch.Start();
result.Result = await CoreRunAsync(compilation, cancellationToken);
} catch (AggregateException e) when(e.InnerExceptions?.Count == 1)
{
evaluationException = e;
// the Roslyn-emitted script delegates are async, so all exceptions
// raised within a delegate should be AggregateException; if there's
// just one inner exception, unwind it since the async nature of the
// script delegates is a REPL implementation detail.
result.Exception = ExceptionNode.Create(e.InnerExceptions [0]);
} catch (ThreadAbortException e) {
evaluationException = e;
result.Interrupted = true;
Thread.ResetAbort();
} catch (ThreadInterruptedException e) {
evaluationException = e;
result.Interrupted = true;
} catch (Exception e) {
evaluationException = e;
result.Exception = ExceptionNode.Create(e);
} finally {
stopwatch.Stop();
currentRunThread = null;
result.Phase = EvaluationPhase.Evaluated;
evaluations.Observers.OnNext(result);
capturedOutputWriter.SegmentCaptured -= CapturedOutputWriter_SegmentCaptured;
Console.SetOut(savedStdout);
Console.SetError(savedStderr);
}
result.EvaluationDuration = stopwatch.Elapsed;
// an exception in PrepareResult should not be explicitly caught
// here (see above) since it'll be handled at a higher level and can be
// flagged as being a bug in our code since this method should never throw.
result.Result = agent.RepresentationManager.Prepare(result.Result);
result.InitializedAgentIntegration = initializedAgentIntegration;
result.LoadedAssemblies = loadedAssemblies.ToArray();
result.CultureLCID = InteractiveCulture.CurrentCulture.LCID;
result.UICultureLCID = InteractiveCulture.CurrentUICulture.LCID;
result.Phase = EvaluationPhase.Represented;
evaluations.Observers.OnNext(result);
if (evaluationException != null)
{
evaluations.Observers.OnError(evaluationException);
}
agent.PublishEvaluation(result);
result.Phase = EvaluationPhase.Completed;
evaluations.Observers.OnNext(result);
}
public Writer(int fileDescriptor, CapturedOutputWriter monitor)
{
this.fileDescriptor = fileDescriptor;
this.monitor = monitor;
this.context = monitor.context;
}
