public RunController(
StartupOptions options,
RoslynWorkspaceServer workspaceServer)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
_workspaceServer = workspaceServer;
}
protected async Task <(ICodeRunner runner, Package workspace)> GetRunnerAndWorkspaceBuild(
[CallerMemberName] string testName = null)
{
var workspace = await Create.ConsoleWorkspaceCopy(testName);
var server = new RoslynWorkspaceServer(workspace);
return(server, workspace);
}
protected async Task <(ICodeRunner server, Package workspace)> GetRunnerAndWorkspace(
[CallerMemberName] string testName = null)
{
var package = await Create.WebApiWorkspaceCopy(testName);
var server = new RoslynWorkspaceServer(new PackageRegistry());
return(server, package);
}
protected async Task <(ICodeCompiler server, Package workspace)> GetRunnerAndWorkspace(
[CallerMemberName] string testName = null)
{
var workspace = await Create.NetstandardWorkspaceCopy(testName);
var server = new RoslynWorkspaceServer(workspace);
return(server, workspace);
}
public async void Syntax_Tree_Has_Same_Language_As_Package()
{
var package = await Create.ConsoleWorkspaceCopy();
var workspace = WorkspaceFactory.CreateWorkspaceFromDirectory(package.Directory, package.Name, includeInstrumentation: true);
var roslynWorkspaceServer = new RoslynWorkspaceServer(package);
Func <Task> run = () => roslynWorkspaceServer.Run(new WorkspaceRequest(workspace));
run.Should().NotThrow();
}
public async Task When_workspace_was_not_registered_then_GetWorkspaceServer_will_return_a_working_server()
{
var unregisteredWorkspace = await Default.ConsoleWorkspace();
var server = new RoslynWorkspaceServer(_registry);
var workspaceRequest = WorkspaceRequestFactory.CreateRequestFromDirectory(unregisteredWorkspace.Directory, unregisteredWorkspace.Name);
var result = await server.Run(workspaceRequest);
result.Succeeded.Should().BeTrue();
}
public async Task HandleAsync(OpenProject command, KernelInvocationContext context)
{
var package = await CreateConsoleWorkspacePackage();
_workspaceServer = new RoslynWorkspaceServer(package);
var extractor = new BufferFromRegionExtractor();
_workspace = extractor.Extract(command.Project.Files.Select(f => new Protocol.File(f.RelativeFilePath, f.Content)).ToArray());
context.Publish(new ProjectOpened(command, _workspace.Buffers.GroupBy(b => b.Id.FileName)
.OrderBy(g => g.Key).Select(g => new ProjectItem(g.Key, g.Select(r => r.Id.RegionName).Where(r => r != null).OrderBy(r => r).ToList())).ToList()));
}
public async Task <RunResult> Run(WorkspaceRequest request, Budget budget = null)
{
var workspace = request.Workspace;
var package = await _packageFinder.Find <Package>(workspace.WorkspaceType);
workspace = await _transformer.TransformAsync(workspace);
var(packageWithChanges, _) = await Compile(package, workspace, request.RequestId);
using (packageWithChanges)
{
return(await RoslynWorkspaceServer.RunConsoleAsync(
packageWithChanges,
new SerializableDiagnostic[] { },
budget,
request.RequestId,
workspace.IncludeInstrumentation,
request.RunArgs));
}
}
public async Task Run_starts_the_kestrel_server_and_provides_a_WebServer_feature_that_can_receive_requests()
{
var registry = Default.PackageFinder;
var server = new RoslynWorkspaceServer(registry);
var package = await registry.Get <IHaveADirectory>("aspnet.webapi");
var workspace = WorkspaceFactory.CreateWorkspaceFromDirectory(package.Directory, "aspnet.webapi");
using (var runResult = await server.Run(new WorkspaceRequest(workspace, "Program.cs")))
{
var webServer = runResult.GetFeature <WebServer>();
var response = await webServer.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/api/values")).CancelIfExceeds(new TimeBudget(35.Seconds()));
var result = await response.EnsureSuccess()
.DeserializeAs <string[]>();
result.Should().Equal("value1", "value2");
}
}
public async Task NuGet_packages_can_be_added_during_initialization()
{
var workspaceId = Package.CreateDirectory(nameof(NuGet_packages_can_be_added_during_initialization)).Name;
registry.Add(workspaceId,
options =>
{
options.CreateUsingDotnet("console");
options.AddPackageReference("Twilio", "5.9.2");
});
var workspaceServer = new RoslynWorkspaceServer(registry);
var workspace = Workspace.FromSource(
@"
using System;
using Twilio.Clients;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;
namespace Twilio_try.dot.net_sample
{
class Program
{
static void Main()
{
var sendFromPhoneNumber = new PhoneNumber(""TWILIO_PHONE_NUMBER"");
var sendToPhoneNumber = new PhoneNumber(""RECIPIENT_PHONE_NUMBER"");
}
}
}",
workspaceType: workspaceId);
var result = await workspaceServer.Run(new WorkspaceRequest(workspace));
result.Succeeded.Should().BeTrue(because: "compilation can't succeed unless the NuGet package has been restored.");
}
public CompileController(
RoslynWorkspaceServer workspaceServer)
{
_workspaceServer = workspaceServer;
}
public LanguageServicesController(RoslynWorkspaceServer workspaceServer)
{
_workspaceServer = workspaceServer ?? throw new ArgumentNullException(nameof(workspaceServer));
}
public async Task <ICommandDeliveryResult> Handle(
ICommandDelivery <JupyterRequestContext> delivery)
{
switch (delivery.Command.Request.Header.MessageType)
{
case MessageTypeValues.ExecuteRequest:
var transient = new Dictionary <string, object> {
{ "display_id", Guid.NewGuid().ToString() }
};
var jObject = (JObject)delivery.Command.Request.Content;
var executeRequest = jObject.ToObject <ExecuteRequest>();
var code = executeRequest.Code;
var workspace = new Workspace(
files: new[]
{
new File("Program.cs", Scaffold())
},
buffers: new[]
{
new Buffer(new BufferId("Program.cs", "main"), code),
},
workspaceType: "console");
var workspaceRequest = new WorkspaceRequest(workspace);
var server = new RoslynWorkspaceServer(new PackageRegistry());
var result = await server.Run(workspaceRequest);
var messageBuilder = delivery.Command.Builder;
var ioPubChannel = delivery.Command.IoPubChannel;
var serverChannel = delivery.Command.ServerChannel;
if (!executeRequest.Silent)
{
_executionCount++;
var executeInput = messageBuilder.CreateMessage(
MessageTypeValues.ExecuteInput,
new ExecuteInput
{
Code = code,
ExecutionCount = _executionCount
},
delivery.Command.Request.Header);
ioPubChannel.Send(executeInput);
}
// execute result
var output = string.Join("\n", result.Output);
// executeResult data
var executeResultData = new ExecuteResult()
{
Data = new JObject
{
{ "text/html", output },
{ "text/plain", output }
},
Transient = transient,
ExecutionCount = _executionCount
};
var resultSucceeded = result.Succeeded &&
result.Exception == null;
if (resultSucceeded)
{
// reply ok
var executeReplyPayload = new ExecuteReplyOk
{
ExecutionCount = _executionCount
};
// send to server
var executeReply = messageBuilder.CreateMessage(
MessageTypeValues.ExecuteReply,
executeReplyPayload,
delivery.Command.Request.Header);
executeReply.Identifiers = delivery.Command.Request.Identifiers;
serverChannel.Send(executeReply);
}
else
{
var errorContent = new Error
{
EName = string.IsNullOrWhiteSpace(result.Exception)
? "Compile Error"
: "Unhandled Exception",
EValue = output,
Traceback = new List <string>()
};
// reply Error
var executeReplyPayload = new ExecuteReplyError(errorContent)
{
ExecutionCount = _executionCount
};
// send to server
var executeReply = messageBuilder.CreateMessage(
MessageTypeValues.ExecuteReply,
executeReplyPayload,
delivery.Command.Request.Header);
executeReply.Identifiers = delivery.Command.Request.Identifiers;
serverChannel.Send(executeReply);
if (!executeRequest.Silent)
{
// send on io
var error = messageBuilder.CreateMessage(
MessageTypeValues.Error,
errorContent,
delivery.Command.Request.Header);
ioPubChannel.Send(error);
// send on stderr
var stdErr = new StdErrStream
{
Text = errorContent.EValue
};
var stream = messageBuilder.CreateMessage(
MessageTypeValues.Stream,
stdErr,
delivery.Command.Request.Header);
ioPubChannel.Send(stream);
}
}
if (!executeRequest.Silent && resultSucceeded)
{
// send on io
var executeResultMessage = messageBuilder.CreateMessage(
MessageTypeValues.ExecuteResult,
executeResultData,
delivery.Command.Request.Header);
ioPubChannel.Send(executeResultMessage);
}
break;
}
return(delivery.Complete());
}
