public async Task extensions_can_access_connections_to_create_proxies()
{
using var kernel = CreateCompositeKernel();
using var remoteKernel = new FakeRemoteKernel();
var receiver = new MultiplexingKernelCommandAndEventReceiver(remoteKernel.Receiver);
using var host = new KernelHost(kernel, remoteKernel.Sender, receiver);
var _ = host.ConnectAsync();
var ext = new ConfiguringExtension();
await ext.OnLoadAsync(kernel);
var submitCode = new SubmitCode(
@"#!javascript
test for remote kernel");
var result = await kernel.SendAsync(submitCode);
var kernelEvents = result.KernelEvents.ToSubscribedList();
kernelEvents.Should().ContainSingle <CommandSucceeded>()
.Which
.Command
.Should()
.BeOfType <SubmitCode>()
.Which
.Code
.Should()
.Be(submitCode.Code);
}
private static async Task <(CompositeKernel, FakeRemoteKernel)> CreateCompositeKernelWithJavaScriptProxyKernel()
{
var compositeKernel = new CompositeKernel
{
new CSharpKernel().UseValueSharing()
};
compositeKernel.DefaultKernelName = "csharp";
var remoteKernel = new FakeRemoteKernel();
var receiver = new MultiplexingKernelCommandAndEventReceiver(remoteKernel.Receiver);
var host = new KernelHost(compositeKernel, remoteKernel.Sender, receiver);
var _ = host.ConnectAsync();
var kernelInfo = new KernelInfo("javascript")
{
DestinationUri = new("kernel://remote/js")
};
var javascriptKernel = await host.CreateProxyKernelOnDefaultConnectorAsync(kernelInfo);
javascriptKernel.UseValueSharing(new JavaScriptKernelValueDeclarer());
compositeKernel.RegisterForDisposal(remoteKernel);
compositeKernel.RegisterForDisposal(host);
return(compositeKernel, remoteKernel);
}
public static async Task <int> Do(StartupOptions startupOptions, KernelHost kernelHost, IConsole console)
{
var disposable = Program.StartToolLogging(startupOptions);
await kernelHost.ConnectAndWaitAsync();
disposable.Dispose();
return(0);
}
protected override Task <IDisposable> ConnectHostAsync(CompositeKernel remoteKernel, string pipeName)
{
var serverStream = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous);
var kernelCommandAndEventPipeStreamReceiver = new KernelCommandAndEventPipeStreamReceiver(serverStream);
var kernelCommandAndEventPipeStreamSender = new KernelCommandAndEventPipeStreamSender(serverStream);
var host = new KernelHost(remoteKernel,
kernelCommandAndEventPipeStreamSender,
new MultiplexingKernelCommandAndEventReceiver(kernelCommandAndEventPipeStreamReceiver));
Task.Run(() =>
{
// required as waiting connection on named pipe server will block
serverStream.WaitForConnection();
var _ = host.ConnectAsync();
});
RegisterForDisposal(host);
return(Task.FromResult <IDisposable>(host));
}
public async Task javascript_ProxyKernel_can_share_a_value_from_csharp()
{
using var kernel = new CompositeKernel
{
new CSharpKernel()
};
kernel.DefaultKernelName = "csharp";
using var remoteKernel = new FakeRemoteKernel();
var receiver = new MultiplexingKernelCommandAndEventReceiver(remoteKernel.Receiver);
using var host = new KernelHost(kernel, remoteKernel.Sender, receiver);
var _ = host.ConnectAsync();
var kernelInfo = new KernelInfo("javascript", null, new Uri("kernel://remote/js"));
var javascriptKernel = await host.CreateProxyKernelOnDefaultConnectorAsync(kernelInfo);
javascriptKernel.UseValueSharing(new JavaScriptKernelValueDeclarer());
await kernel.SubmitCodeAsync("var csharpVariable = 123;");
var submitCode = new SubmitCode(@"
#!javascript
#!share --from csharp csharpVariable");
await kernel.SendAsync(submitCode);
var remoteCommands = remoteKernel.Sender.Commands;
remoteCommands.Should()
.ContainSingle <SubmitCode>()
.Which
.Code
.Should()
.Be("csharpVariable = 123;");
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartKernelHost startKernelHost = null,
StartNotebookParser startNotebookParser = null,
StartHttp startHttp = null,
Action onServerStarted = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
var operation = Log.OnEnterAndExit();
if (services is null)
{
throw new ArgumentNullException(nameof(services));
}
var disposeOnQuit = new CompositeDisposable();
startServer ??= (startupOptions, invocationContext) =>
{
operation.Info("constructing webhost");
var webHost = Program.ConstructWebHost(startupOptions);
disposeOnQuit.Add(webHost);
operation.Info("starting kestrel server");
webHost.Start();
onServerStarted?.Invoke();
webHost.WaitForShutdown();
operation.Dispose();
};
jupyter ??= JupyterCommand.Do;
startKernelHost ??= KernelHostLauncher.Do;
startNotebookParser ??= ParseNotebookCommand.Do;
startHttp ??= HttpCommand.Do;
var isVSCode = false;
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion);
var clearTextProperties = new[]
{
"frontend"
};
// Setup telemetry.
telemetry ??= new Telemetry.Telemetry(
VersionSensor.Version().AssemblyInformationalVersion,
firstTimeUseNoticeSentinel,
"dotnet/interactive/cli");
var filter = new TelemetryFilter(
Sha256Hasher.HashWithNormalizedCasing,
clearTextProperties,
(commandResult, directives, entryItems) =>
{
// add frontend
var frontendTelemetryAdded = false;
// check if is codespaces
if (!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("CODESPACES")))
{
frontendTelemetryAdded = true;
isVSCode = true;
entryItems.Add(new KeyValuePair <string, string>("frontend", "gitHubCodeSpaces"));
}
if (!frontendTelemetryAdded)
{
foreach (var directive in directives)
{
switch (directive.Key)
{
case "jupyter":
case "synapse":
case "vscode":
frontendTelemetryAdded = true;
isVSCode = directive.Key.ToLowerInvariant() == "vscode";
entryItems.Add(new KeyValuePair <string, string>("frontend", directive.Key));
break;
}
}
}
if (!frontendTelemetryAdded)
{
switch (commandResult.Command.Name)
{
case "jupyter":
entryItems.Add(new KeyValuePair <string, string>("frontend", commandResult.Command.Name));
frontendTelemetryAdded = true;
break;
}
}
if (!frontendTelemetryAdded)
{
var frontendName = Environment.GetEnvironmentVariable("DOTNET_INTERACTIVE_FRONTEND_NAME");
if (string.IsNullOrWhiteSpace(frontendName))
{
frontendName = "unknown";
}
entryItems.Add(new KeyValuePair <string, string>("frontend", frontendName));
}
});
var verboseOption = new Option <bool>(
"--verbose",
"Enable verbose logging to the console");
var logPathOption = new Option <DirectoryInfo>(
"--log-path",
"Enable file logging to the specified directory");
var pathOption = new Option <DirectoryInfo>(
"--path",
"Installs the kernelspecs to the specified directory")
.ExistingOnly();
var defaultKernelOption = new Option <string>(
"--default-kernel",
description: "The default language for the kernel",
getDefaultValue: () => "csharp").AddCompletions("fsharp", "csharp", "pwsh");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(StdIO());
rootCommand.AddCommand(NotebookParser());
rootCommand.AddCommand(HttpServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.AddMiddleware(async(context, next) =>
{
if (context.ParseResult.Errors.Count == 0)
{
telemetry.SendFiltered(filter, context.ParseResult);
}
// If sentinel does not exist, print the welcome message showing the telemetry notification.
if (!Telemetry.Telemetry.SkipFirstTimeExperience &&
!firstTimeUseNoticeSentinel.Exists())
{
context.Console.Out.WriteLine();
context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage);
firstTimeUseNoticeSentinel.CreateIfNotExists();
}
await next(context);
})
.Build());
RootCommand DotnetInteractive()
{
var command = new RootCommand
{
Name = "dotnet-interactive",
Description = "Interactive programming for .NET."
};
command.AddGlobalOption(logPathOption);
command.AddGlobalOption(verboseOption);
return(command);
}
Command Jupyter()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services",
isDefault: true);
var jupyterCommand = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
httpPortRangeOption,
new Argument <FileInfo>
{
Name = "connection-file",
Description = "The path to a connection file provided by Jupyter"
}.ExistingOnly()
};
jupyterCommand.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext, CancellationToken>(JupyterHandler);
var installCommand = new Command("install", "Install the .NET kernel for Jupyter")
{
httpPortRangeOption,
pathOption
};
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, HttpPortRange, DirectoryInfo>(InstallHandler);
jupyterCommand.AddCommand(installCommand);
return(jupyterCommand);
async Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
var frontendEnvironment = new HtmlNotebookFrontendEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
kernel.Add(
new JavaScriptKernel(),
new[] { "js" });
services.AddKernel(kernel);
kernel.VisitSubkernels(k =>
{
switch (k)
{
case CSharpKernel csharpKernel:
csharpKernel.UseJupyterHelpers();
break;
case FSharpKernel fsharpKernel:
fsharpKernel.UseJupyterHelpers();
break;
case PowerShellKernel powerShellKernel:
powerShellKernel.UseJupyterHelpers();
break;
}
});
var clientSideKernelClient = new SignalRBackchannelKernelClient();
services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(clientSideKernelClient)
.AddSingleton(c =>
{
return(new JupyterRequestContextScheduler(delivery => c.GetRequiredService <JupyterRequestContextHandler>()
.Handle(delivery)));
})
.AddSingleton(c => new JupyterRequestContextHandler(kernel))
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
var result = await jupyter(startupOptions, console, startServer, context);
return(result);
}
Task <int> InstallHandler(IConsole console, InvocationContext context, HttpPortRange httpPortRange, DirectoryInfo path)
{
var jupyterInstallCommand = new JupyterInstallCommand(console, new JupyterKernelSpecInstaller(console), httpPortRange, path);
return(jupyterInstallCommand.InvokeAsync());
}
}
Command HttpServer()
{
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
if (result.Tokens.Count == 0)
{
return(HttpPort.Auto);
}
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
},
isDefault: true);
var httpCommand = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http")
{
defaultKernelOption,
httpPortOption
};
httpCommand.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
var frontendEnvironment = new BrowserFrontendEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
kernel.Add(
new JavaScriptKernel(),
new[] { "js" });
services.AddKernel(kernel)
.AddSingleton(new SignalRBackchannelKernelClient());
onServerStarted ??= () =>
{
console.Out.WriteLine("Application started. Press Ctrl+C to shut down.");
};
return(startHttp(startupOptions, console, startServer, context));
});
return(httpCommand);
}
Command StdIO()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services");
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
if (result.FindResultFor(httpPortRangeOption) is { } conflictingOption)
{
var parsed = result.Parent as OptionResult;
result.ErrorMessage = $"Cannot specify both {conflictingOption.Token.Value} and {parsed.Token.Value} together";
return(null);
}
if (result.Tokens.Count == 0)
{
return(HttpPort.Auto);
}
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
});
var workingDirOption = new Option <DirectoryInfo>(
"--working-dir",
() => new DirectoryInfo(Environment.CurrentDirectory),
"Working directory to which to change after launching the kernel.");
var stdIOCommand = new Command(
"stdio",
"Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
httpPortRangeOption,
httpPortOption,
workingDirOption
};
stdIOCommand.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext>(
async(startupOptions, options, console, context) =>
{
Console.InputEncoding = Encoding.UTF8;
Console.OutputEncoding = Encoding.UTF8;
Environment.CurrentDirectory = startupOptions.WorkingDir.FullName;
FrontendEnvironment frontendEnvironment = startupOptions.EnableHttpApi
? new HtmlNotebookFrontendEnvironment()
: new BrowserFrontendEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
services.AddKernel(kernel);
kernel = kernel.UseQuitCommand();
var host = new KernelHost(kernel, new KernelCommandAndEventTextStreamSender(Console.Out),
new MultiplexingKernelCommandAndEventReceiver(
new KernelCommandAndEventTextReceiver(Console.In)));
if (isVSCode)
{
var vscodeSetup = new VSCodeClientKernelsExtension();
await vscodeSetup.OnLoadAsync(kernel);
}
if (startupOptions.EnableHttpApi)
{
var clientSideKernelClient = new SignalRBackchannelKernelClient();
services.AddSingleton(clientSideKernelClient);
if (isVSCode)
{
((HtmlNotebookFrontendEnvironment)frontendEnvironment).RequiresAutomaticBootstrapping = false;
}
else
{
kernel.Add(
new JavaScriptKernel(clientSideKernelClient),
new[] { "js" });
}
onServerStarted ??= () =>
{
var _ = host.ConnectAsync();
};
await startHttp(startupOptions, console, startServer, context);
}
else
{
if (!isVSCode)
{
await host.CreateProxyKernelOnDefaultConnectorAsync(new KernelInfo("javascript", "javascript")
{
Aliases = new[] { "js" },
DestinationUri = new Uri("kernel://webview/javascript")
});
}
await startKernelHost(startupOptions, host, console);
}
return(0);
});
return(stdIOCommand);
}
