public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartStdIO startStdIO = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
startServer ??= (startupOptions, invocationContext) =>
Program.ConstructWebHost(startupOptions).Run();
jupyter ??= JupyterCommand.Do;
startStdIO ??= StdIOCommand.Do;
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion);
// Setup telemetry.
telemetry ??= new Telemetry.Telemetry(
VersionSensor.Version().AssemblyInformationalVersion,
firstTimeUseNoticeSentinel);
var filter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
var verboseOption = new Option <bool>(
"--verbose",
"Enable verbose logging to the console");
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
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 httpPortRangeOption = new Option <PortRange>(
"--http-port-range",
parseArgument: result =>
{
if (result.Parent.Parent.Children.FirstOrDefault(c => c.Symbol == httpPortOption) is OptionResult conflictingOption)
{
var parsed = result.Parent as OptionResult;
result.ErrorMessage = $"Cannot specify both {conflictingOption.Token.Value} and {parsed.Token.Value} together";
return(null);
}
var source = result.Tokens[0].Value;
if (string.IsNullOrWhiteSpace(source))
{
result.ErrorMessage = "Must specify a port range";
return(null);
}
var parts = source.Split(new[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
result.ErrorMessage = "Must specify a port range";
return(null);
}
if (!int.TryParse(parts[0], out var start) || !int.TryParse(parts[1], out var end))
{
result.ErrorMessage = "Must specify a port range as StartPort-EndPort";
return(null);
}
if (start > end)
{
result.ErrorMessage = "Start port must be lower then end port";
return(null);
}
var pr = new PortRange(start, end);
return(pr);
},
description: "Specifies the range of port to use to enable HTTP services");
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");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(StdIO());
rootCommand.AddCommand(HttpServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(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 (!firstTimeUseNoticeSentinel.Exists() && !Telemetry.Telemetry.SkipFirstTimeExperience)
{
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.AddOption(logPathOption);
command.AddOption(verboseOption);
return(command);
}
Command Jupyter()
{
var command = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
logPathOption,
verboseOption,
httpPortRangeOption,
new Argument <FileInfo>
{
Name = "connection-file"
}.ExistingOnly()
};
command.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext>(JupyterHandler);
var installCommand = new Command("install", "Install the .NET kernel for Jupyter")
{
logPathOption,
verboseOption,
httpPortRangeOption,
pathOption
};
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, PortRange, DirectoryInfo>(InstallHandler);
command.AddCommand(installCommand);
return(command);
Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context)
{
services = RegisterKernelInServiceCollection(services, startupOptions, options.DefaultKernel);
services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton <FrontendEnvironment>(c => c.GetService <BrowserFrontendEnvironment>())
.AddSingleton(c =>
{
return(CommandScheduler.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >()
.Trace()
.Handle(delivery)));
})
.AddSingleton(c => new JupyterRequestContextHandler(
c.GetRequiredService <IKernel>())
.Trace())
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(startupOptions, console, startServer, context));
}
Task <int> InstallHandler(IConsole console, InvocationContext context, PortRange httpPortRange, DirectoryInfo location) =>
new JupyterInstallCommand(console, jupyterKernelSpecInstaller: new JupyterKernelSpecInstaller(console), httpPortRange, location).InvokeAsync();
}
Command HttpServer()
{
var command = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http")
{
defaultKernelOption,
httpPortOption,
logPathOption,
httpPortRangeOption
};
command.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
if (startupOptions.HttpPort == null && startupOptions.HttpPortRange == null)
{
startupOptions.HttpPort = HttpPort.Auto;
}
RegisterKernelInServiceCollection(services, startupOptions, options.DefaultKernel);
return(jupyter(startupOptions, console, startServer, context));
});
return(command);
}
Command StdIO()
{
var command = new Command(
"stdio",
"Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
logPathOption,
httpPortOption,
httpPortRangeOption
};
command.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
if (startupOptions.EnableHttpApi)
{
RegisterKernelInServiceCollection(services, startupOptions, options.DefaultKernel,
kernel => StdIOCommand.CreateServer(kernel, console));
startServer?.Invoke(startupOptions, context);
return(Task.FromResult(0));
}
return(startStdIO(
startupOptions,
CreateKernel(options.DefaultKernel, new BrowserFrontendEnvironment(), startupOptions, null),
console));
});
return(command);
}
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartStdIO startStdIO = null,
StartHttp startHttp = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var disposeOnQuit = new CompositeDisposable();
startServer ??= (startupOptions, invocationContext) =>
{
var webHost = Program.ConstructWebHost(startupOptions);
disposeOnQuit.Add(webHost);
webHost.Run();
};
jupyter ??= JupyterCommand.Do;
startStdIO ??= StdIOCommand.Do;
startHttp ??= HttpCommand.Do;
// 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;
foreach (var directive in directives)
{
switch (directive.Key)
{
case "vscode":
case "jupyter":
case "synapse":
frontendTelemetryAdded = true;
entryItems.Add(new KeyValuePair <string, string>("frontend", directive.Key));
break;
}
}
if (!frontendTelemetryAdded)
{
if (commandResult.Command.Name == "jupyter")
{
entryItems.Add(new KeyValuePair <string, string>("frontend", "jupyter"));
}
}
});
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");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(StdIO());
rootCommand.AddCommand(HttpServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(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 (!firstTimeUseNoticeSentinel.Exists() && !Telemetry.Telemetry.SkipFirstTimeExperience)
{
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 command = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
httpPortRangeOption,
new Argument <FileInfo>
{
Name = "connection-file"
}.ExistingOnly()
};
command.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);
command.AddCommand(installCommand);
return(command);
Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
services = RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ => new HtmlNotebookFrontedEnvironment());
serviceCollection.AddSingleton <FrontendEnvironment>(c =>
c.GetService <HtmlNotebookFrontedEnvironment>());
});
services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(c =>
{
return(CommandScheduler.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >()
.Trace()
.Handle(delivery)));
})
.AddSingleton(c => new JupyterRequestContextHandler(
c.GetRequiredService <Kernel>())
.Trace())
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(startupOptions, console, startServer, context));
}
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 command = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http")
{
defaultKernelOption,
httpPortOption
};
command.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ =>
{
var frontendEnvironment = new BrowserFrontendEnvironment();
return(frontendEnvironment);
});
serviceCollection.AddSingleton <FrontendEnvironment>(c => c.GetRequiredService <BrowserFrontendEnvironment>());
});
return(startHttp(startupOptions, console, startServer, context));
});
return(command);
}
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 command = new Command(
"stdio",
"Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
httpPortRangeOption
};
command.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext, CancellationToken>(
(startupOptions, options, console, context, cancellationToken) =>
{
if (startupOptions.EnableHttpApi)
{
RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ => new HtmlNotebookFrontedEnvironment());
serviceCollection.AddSingleton <FrontendEnvironment>(c =>
c.GetService <HtmlNotebookFrontedEnvironment>());
}, kernel =>
{
StdIOCommand.CreateServer(kernel, console);
kernel.UseQuiCommand(disposeOnQuit, cancellationToken);
});
return(startHttp(startupOptions, console, startServer, context));
}
{
var kernel = CreateKernel(options.DefaultKernel, new BrowserFrontendEnvironment(),
startupOptions);
disposeOnQuit.Add(kernel);
kernel.UseQuiCommand(disposeOnQuit, cancellationToken);
return(startStdIO(
startupOptions,
kernel,
console));
}
});
return(command);
}