public static async Task <int> Main(string[] args)
{
SetupConsoleEncoding();
var rootCommand = new RootCommand();
var interactiveCommand = new Command("interactive")
{
Handler = CommandHandler.Create <string, CancellationToken>(InteractiveCommand.Interactive)
};
interactiveCommand.AddAlias("i");
var arg = new Option <string>("--project");
arg.AddAlias("-p");
interactiveCommand.Add(arg);
rootCommand.Add(interactiveCommand);
var studioCommand = new Command("studio")
{
Handler = CommandHandler.Create(StudioCommand.Studio)
};
studioCommand.AddAlias("s");
rootCommand.Add(studioCommand);
return(await rootCommand.InvokeAsync(args).ConfigureAwait(false));
}
static int Main(string[] args)
{
var rootCommand = new RootCommand("Tool to transform T4 templates during build");
var timeoutOption = new Option <int>(new string[] { "--lock-timeout", "-t" }, () => 60, "Timeout in seconds to wait for another instance to be done");
rootCommand.Add(timeoutOption);
var tpArgument = new Argument <FileInfo[]>("templates", "The templates to transform").ExistingOnly();
var transformCommand = new Command("transform", "Transform the T4 templates");
transformCommand.Add(tpArgument);
var skipOption = new Option <bool>(new[] { "--skip-up-to-date", "-s" }, "Skip templates whose output is up-to-date");
transformCommand.Add(skipOption);
var parallelOption = new Option <bool>(new[] { "--parallel", "-p" }, "Transform templates in parallel");
transformCommand.Add(parallelOption);
transformCommand.Handler = CommandHandler.Create <FileInfo[], int, bool, bool>(Transform);
rootCommand.Add(transformCommand);
var cleanCommand = new Command("clean", "List the output files");
cleanCommand.Add(tpArgument);
cleanCommand.Handler = CommandHandler.Create <FileInfo[], int>(Clean);
rootCommand.Add(cleanCommand);
return(rootCommand.InvokeAsync(args).Result);
}
static async Task DefineArguments(string[] args)
{
// <definearguments>
var delayArgument = new Argument <int>
(name: "delay",
description: "An argument that is parsed as an int.",
getDefaultValue: () => 42);
var messageArgument = new Argument <string>
("message", "An argument that is parsed as a string.");
var rootCommand = new RootCommand();
rootCommand.Add(delayArgument);
rootCommand.Add(messageArgument);
rootCommand.SetHandler((int delayArgumentValue, string messageArgumentValue) =>
{
Console.WriteLine($"<delay> argument = {delayArgumentValue}");
Console.WriteLine($"<message> argument = {messageArgumentValue}");
},
delayArgument, messageArgument);
await rootCommand.InvokeAsync(args);
// </definearguments>
Console.WriteLine("Sample command line.");
await rootCommand.InvokeAsync("21 \"Hello world!\"");
}
static async Task <int> Main(string[] args)
{
var command = new RootCommand();
command.Add(RunCommand(args));
command.Add(NewCommand());
command.Description = "Process manager and orchestrator for microservices.";
var builder = new CommandLineBuilder(command);
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.UsePrefixes(new[] { "-", "--", }); // disable garbage windows conventions
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
// Allow fancy drawing.
builder.UseAnsiTerminalWhenAvailable();
var parser = builder.Build();
return(await parser.InvokeAsync(args));
}
static async Task <int> Main(string[] args)
{
var rootCommand = new RootCommand()
{
};
var validateCommand = new Command("validate")
{
new Option("--input", "Input OpenAPI description file path or URL", typeof(string))
};
validateCommand.Handler = CommandHandler.Create <string>(OpenApiService.ValidateOpenApiDocument);
var transformCommand = new Command("transform")
{
new Option("--input", "Input OpenAPI description file path or URL", typeof(string)),
new Option("--output", "Output OpenAPI description file", typeof(FileInfo), arity: ArgumentArity.ZeroOrOne),
new Option("--version", "OpenAPI specification version", typeof(OpenApiSpecVersion)),
new Option("--format", "File format", typeof(OpenApiFormat)),
new Option("--inline", "Inline $ref instances", typeof(bool)),
new Option("--resolveExternal", "Resolve external $refs", typeof(bool)),
new Option("--filterByOperationIds", "Filters OpenApiDocument by OperationId(s) provided", typeof(string)),
new Option("--filterByTags", "Filters OpenApiDocument by Tag(s) provided", typeof(string))
};
transformCommand.Handler = CommandHandler.Create <string, FileInfo, OpenApiSpecVersion, OpenApiFormat, string, string, bool, bool>(
OpenApiService.ProcessOpenApiDocument);
rootCommand.Add(transformCommand);
rootCommand.Add(validateCommand);
// Parse the incoming args and invoke the handler
return(await rootCommand.InvokeAsync(args));
}
static async Task DefineOptions(string[] args)
{
// <defineoptions>
var delayOption = new Option <int>
(name: "--delay",
description: "An option whose argument is parsed as an int.",
getDefaultValue: () => 42);
var messageOption = new Option <string>
("--message", "An option whose argument is parsed as a string.");
var rootCommand = new RootCommand();
rootCommand.Add(delayOption);
rootCommand.Add(messageOption);
rootCommand.SetHandler((int delayOptionValue, string messageOptionValue) =>
{
Console.WriteLine($"--delay = {delayOptionValue}");
Console.WriteLine($"--message = {messageOptionValue}");
},
delayOption, messageOption);
// </defineoptions>
await rootCommand.InvokeAsync(args);
Console.WriteLine("Sample command line.");
await rootCommand.InvokeAsync("--delay 21 --message \"Hello world!\"");
}
internal int Run(string[] args)
{
var rootCommand = new RootCommand();
rootCommand.Add(new Argument <FileInfo>("startup-assembly")
{
Description = "Startup assembly of the host application."
});
rootCommand.Add(new Option <string>("--password", "Administrator password."));
rootCommand.Add(new Option <bool>("--no-pause", "Don't wait for user input after execution."));
//Lack of this switch means that the dbupdate command should start the command rhetos.exe dbupdate
//in another process with the host applications runtimeconfig.json and deps.json files
rootCommand.Add(new Option <bool>(ExecuteCommandInCurrentProcessOptionName)
{
IsHidden = true
});
rootCommand.Handler =
CommandHandler.Create((FileInfo startupAssembly, string password, bool executeCommandInCurrentProcess) =>
{
if (executeCommandInCurrentProcess)
{
return(SafeExecuteCommand(() => ExecuteCommand(startupAssembly.FullName, password)));
}
else
{
return(InvokeAsExternalProcess(startupAssembly.FullName, args));
}
});
return(rootCommand.Invoke(args));
}
public static int Main(string[] args)
{
var cmd = new RootCommand()
{
new Option <string>("--package-tests-sdk", "The SDK version to use for package tests"),
new Option <bool>("--package-tests-suppress-nologo", "Suppress --nologo when running package tests"),
new Option <bool>("--skip-pack-dependency", "Skip the \"pack\" target as a dependency"),
};
cmd.Add(new Argument("targets")
{
Arity = ArgumentArity.ZeroOrMore, Description = "The targets to run or list."
});
foreach (var option in Options.Definitions)
{
cmd.Add(new Option(new[] { option.ShortName, option.LongName }.Where(n => !string.IsNullOrWhiteSpace(n)).ToArray(), option.Description));
}
cmd.Handler = CommandHandler.Create <string, bool, bool>((packageTestsSdk, packageTestsSuppressNoLogo, skipPackDependency) =>
{
var cmdLine = cmd.Parse(args);
var targets = cmdLine.CommandResult.Tokens.Select(token => token.Value);
var options = new Options(Options.Definitions.Select(o => (o.LongName, cmdLine.ValueForOption <bool>(o.LongName))));
Run(targets, options, packageTestsSdk, packageTestsSuppressNoLogo, skipPackDependency);
});
return(cmd.Invoke(args));
}
public void Run(string[] args)
{
_context.Database.Migrate();
Console.WriteLine("Media Processor");
Analysis analysis = new Analysis(_context, _config);
Cleanup cleanup = new Cleanup(_context);
Converter converter = new Converter(_context, _config);
var rootCommand = new RootCommand();
var analyzeCommand = new Command("analyze");
var cmdAnalyzeFile = new Command("file");
cmdAnalyzeFile.AddOption(new Option <string>("--filename"));
cmdAnalyzeFile.AddOption(new Option <string>("--content_type"));
cmdAnalyzeFile.Handler = CommandHandler.Create <string, string>(analysis.ProcessFile);
var cmdConvert = new Command("convert");
var cmdConvertFile = new Command("file");
cmdConvertFile.AddOption(new Option <string>("--filename"));
cmdConvertFile.AddOption(new Option <string>("--content_type"));
cmdConvertFile.Handler = CommandHandler.Create <string, string>(converter.ProcessFile);
cmdConvert.Add(cmdConvertFile);
var cmdConvertDB = new Command("db");
cmdConvertDB.Handler = CommandHandler.Create(converter.ProcessDB);
cmdConvert.Add(cmdConvertDB);
var cmdConvertSingleDB = new Command("singledb");
cmdConvertSingleDB.Handler = CommandHandler.Create(converter.ProcessSingleDB);
cmdConvert.Add(cmdConvertSingleDB);
var cmdAnalyzeDir = new Command("dir");
cmdAnalyzeDir.AddOption(new Option <string>("--path"));
cmdAnalyzeDir.AddOption(new Option <string>("--content_type"));
cmdAnalyzeDir.Handler = CommandHandler.Create <string, string>(analysis.ProcessDir);
var cmdConfig = new Command("cfg");
var cmdConfigAnalyze = new Command("analyze");
cmdConfigAnalyze.Handler = CommandHandler.Create(analysis.AnalyzeCfg);
var cmdConfigCleanup = new Command("cleanup");
cmdConfigCleanup.Handler = CommandHandler.Create(cleanup.CleanupDB);
analyzeCommand.Add(cmdAnalyzeFile);
analyzeCommand.Add(cmdAnalyzeDir);
cmdConfig.Add(cmdConfigAnalyze);
cmdConfig.Add(cmdConfigCleanup);
rootCommand.Add(analyzeCommand);
rootCommand.Add(cmdConfig);
rootCommand.Add(cmdConvert);
rootCommand.InvokeAsync(args).Wait();
}
public static void Main(string[] args)
{
var rootCommand = new RootCommand("Utility for inspecting the Git index file.")
{
new Option <string>(new[] { "-f", "--file" })
{
Description = "Path to a .git/index file",
}
};
var infoCommand = new Command("info", "Show summary information about the index");
var listCommand = new Command("list", "List and filter index entries")
{
new Argument("path")
{
Description = "Filter based on path prefix",
Arity = ArgumentArity.ZeroOrOne
},
new Option <bool>("--ignore-case", "Perform case-insensitive filtering on paths"),
new Option <bool>(new[] { "-U", "--ctime" }, "Use time of file creation, instead of last modification"),
new Option <bool>(new[] { "-n", "--numeric-uid-gid" }, "Use numeric user and group IDs"),
new Option <bool>(new[] { "-S", "--skip-worktree" }, "Show only entries with the skip-worktree bit set"),
new Option <bool>(new[] { "-s", "--no-skip-worktree" }, "Do not show entries with the skip-worktree bit set")
};
rootCommand.Add(infoCommand);
rootCommand.Add(listCommand);
infoCommand.Handler = CommandHandler.Create <InfoOptions>(Info);
listCommand.Handler = CommandHandler.Create <ListOptions>(List);
int exitCode = rootCommand.Invoke(args);
Environment.Exit(exitCode);
}
static async Task IntAndString(string[] args)
{
// <intandstring>
var delayOption = new Option <int>
("--delay", "An option whose argument is parsed as an int.");
var messageOption = new Option <string>
("--message", "An option whose argument is parsed as a string.");
var rootCommand = new RootCommand("Model binding example");
rootCommand.Add(delayOption);
rootCommand.Add(messageOption);
rootCommand.SetHandler(
// <lambda>
(int delayOptionValue, string messageOptionValue) =>
{
DisplayIntAndString(delayOptionValue, messageOptionValue);
},
// </lambda>
// <services>
delayOption, messageOption);
// </services>
await rootCommand.InvokeAsync(args);
// </intandstring>
await rootCommand.InvokeAsync("--delay 42 --message \"Hello world!\"");
}
public static Task Main(string[] args)
{
var collectCommand = new Command("collect")
{
new Option <DirectoryInfo>("--directory", getDefaultValue: () => new DirectoryInfo(Directory.GetCurrentDirectory())),
new Option <string>("--pattern", getDefaultValue: () => "*.jpg"),
new Option <string>("--collectionID")
{
Required = true
},
new Option <bool>("--recurse", getDefaultValue: () => false),
};
var searchCommand = new Command("search")
{
new Option <DirectoryInfo>("--directory", getDefaultValue: () => new DirectoryInfo(Directory.GetCurrentDirectory())),
new Option <string>("--pattern", getDefaultValue: () => "*.jpg"),
new Option <string>("--collectionID")
{
Required = true
},
new Option <bool>("--recurse", getDefaultValue: () => false),
};
collectCommand.Handler = CommandHandler.Create <CollectOptions>(options => new CollectCommand(options).ExecuteAsync());
searchCommand.Handler = CommandHandler.Create <SearchOptions>(options => new SearchCommand(options).ExecuteAsync());
var rootCommand = new RootCommand();
rootCommand.Add(collectCommand);
rootCommand.Add(searchCommand);
rootCommand.AddGlobalOption(new Option <string>("--access-key", "Amazon Rekognition access key")
{
Required = true
});
rootCommand.AddGlobalOption(new Option <string>("--secret-key", "Amazon Rekognition secret key")
{
Required = true
});
var regionOption = new Option <RegionEndpoint>("--region",
new ParseArgument <RegionEndpoint>(target => RegionEndpoint.GetBySystemName(target.Tokens[0].Value)));
regionOption.Description = "System name of an AWS region";
regionOption.Required = true;
regionOption.WithSuggestions(RegionEndpoint.EnumerableAllRegions
.Where(r => r.SystemName.StartsWith("eu-", StringComparison.OrdinalIgnoreCase))
.Select(r => r.SystemName)
.ToArray());
rootCommand.AddGlobalOption(regionOption);
rootCommand.Description = "Amazon Rekognition testing tool";
return(rootCommand.InvokeAsync(args));
}
public static int Main(string[] args)
{
var root = new RootCommand("Dotnet linux cert helper: Install and list PKCS#12 certificates for *nix system");
var installCommand = new Command("install", "Install certificates, optionally with password supplied")
{
new Option <string>(new string[] { "--path", "-f" }, "Path of the certificate")
{
IsRequired = true
},
new Option <string>(new string[] { "--password", "-p" }, "Password of the certificate"),
new Option <string>(new string[] { "--store-name", "-n" }, () => "My", "Specify store name, available value: " +
"[AddressBook AuthRoot CertificateAuthority Disallowed My Root TrustedPeople TrustedPublisher]"),
new Option <string>(new string[] { "--store-location", "-l" }, () => "CurrentUser", "Specify store location, available value: [CurrentUser LocalMachine]")
};
var autoInstallCommand = new Command("auto-install", $"Auto install certificates (with {PKCS12_PASSWORD_EXTENSION} pairs) from path specified")
{
new Option <string>(new string[] { "--path", "-f" }, () => "/Certificates", "Path of the directory"),
new Option <string>(new string[] { "--store-name", "-n" }, () => "My", "Specify store name, available value: " +
"[AddressBook AuthRoot CertificateAuthority Disallowed My Root TrustedPeople TrustedPublisher]"),
new Option <string>(new string[] { "--store-location", "-l" }, () => "CurrentUser", "Specify store location, available value: [CurrentUser LocalMachine]")
};
// TODO: Remove this
// For backward compatibility
var autoInstallDeprecatingCommand = new Command("autoInstallCerts", $"Auto install certificates (with {PKCS12_PASSWORD_EXTENSION} pairs) from path specified")
{
new Option <string>(new string[] { "--path", "-f" }, () => "/Certificates", "Path of the directory")
};
// Make this hidden
autoInstallDeprecatingCommand.IsHidden = true;
var listCommand = new Command("list", "List certificates, can be filtered by store name or location")
{
new Option <string>(new string[] { "--store-name", "-n" }, "Specify store name, available value: " +
"[AddressBook AuthRoot CertificateAuthority Disallowed My Root TrustedPeople TrustedPublisher]"),
new Option <string>(new string[] { "--store-location", "-l" }, "Specify store location, available value: [CurrentUser LocalMachine]")
};
installCommand.Handler = CommandHandler.Create <string, string, string, string>(InstallCertificate);
autoInstallCommand.Handler = CommandHandler.Create <string, string, string>(AutoInstallCertificates);
// TODO: Remove this
autoInstallDeprecatingCommand.Handler = CommandHandler.Create <string>(AutoInstallCertificates);
listCommand.Handler = CommandHandler.Create <string, string>(ListCertificates);
root.Add(installCommand);
root.Add(autoInstallCommand);
// TODO: Remove this
root.Add(autoInstallDeprecatingCommand);
root.Add(listCommand);
return(root.InvokeAsync(args).Result);
}
public static int Run(string[] args)
{
var rootCommand = new RootCommand();
rootCommand.Add(new Option <VerbosityLevel>("--verbosity", VerbosityLevel.Normal, "Output verbosity level. Allowed values are normal and diagnostic."));
rootCommand.Add(new Option <string[]>("--trace", Array.Empty <string>(), "Output additional trace loggers specified by name."));
var buildCommand = new Command("build", "Generates C# code, database model file and other project assets.");
// CurrentDirectory by default, because rhetos.exe on *build* is expected to be located in NuGet package cache.
buildCommand.Add(new Argument <DirectoryInfo>("project-root-folder", () => new DirectoryInfo(Environment.CurrentDirectory))
{
Description = "Project folder where csproj file is located. If not specified, current working directory is used by default."
});
buildCommand.Add(new Option <bool>("--msbuild-format", false, "Adjust error output format for MSBuild integration."));
buildCommand.Handler = CommandHandler.Create((DirectoryInfo projectRootFolder, bool msbuildFormat, VerbosityLevel verbosity, string[] trace) =>
{
var program = new Program(verbosity, trace);
program.SafeExecuteCommand(() => program.Build(projectRootFolder.FullName), "Build", msbuildFormat);
});
rootCommand.AddCommand(buildCommand);
var dbUpdateCommand = new Command("dbupdate", "Updates the database structure and initializes the application data in the database.");
dbUpdateCommand.Add(new Argument <FileInfo>("startup-assembly")
{
Description = "Startup assembly of the host application."
});
dbUpdateCommand.Add(new Option <bool>("--short-transactions", "Commit transaction after creating or dropping each database object."));
dbUpdateCommand.Add(new Option <bool>("--skip-recompute", "Skip automatic update of computed data with KeepSynchronized. See output log for data that needs updating."));
//Lack of this switch means that the dbupdate command should start the command rhetos.exe dbupdate
//in another process with the host applications runtimeconfig.json and deps.json files
var executeCommandInCurrentProcessOption = new Option <bool>(ExecuteCommandInCurrentProcessOptionName);
executeCommandInCurrentProcessOption.IsHidden = true;
dbUpdateCommand.Add(executeCommandInCurrentProcessOption);
dbUpdateCommand.Handler =
CommandHandler.Create((FileInfo startupAssembly, bool shortTransactions, bool skipRecompute, bool executeCommandInCurrentProcess, VerbosityLevel verbosity, string[] trace) =>
{
var program = new Program(verbosity, trace);
if (executeCommandInCurrentProcess)
{
return(program.SafeExecuteCommand(() => program.DbUpdate(startupAssembly.FullName, shortTransactions, skipRecompute), "DbUpdate", msBuildErrorFormat: false));
}
else
{
return(program.InvokeDbUpdateAsExternalProcess(startupAssembly.FullName, args));
}
});
rootCommand.AddCommand(dbUpdateCommand);
return(rootCommand.Invoke(args));
}
private Task WrapAsync(string[] args)
{
var rootCommand = new RootCommand();
//这里会调用下面的方法
var addCommand = Utils.CreateAddCommand(ConvertOptionsAndDoNextAsync <AddOptions>);
var deleteCommand = Utils.CreateDeleteCommand(ConvertOptionsAndDoNextAsync <DeleteOptions>);
var lookupCommand = Utils.CreateSearchCommand(ConvertOptionsAndDoNextAsync <LookOptions>);
rootCommand.Add(addCommand);
rootCommand.Add(deleteCommand);
rootCommand.Add(lookupCommand);
return(rootCommand.InvokeAsync(args));
}
private static CommandLineBuilder BuildCommandLine()
{
RootCommand root = new RootCommand("parent")
{
Description = "Microsoft IoT Plug and Play Device Model Repository CLI"
};
root.Add(BuildExportCommand());
root.Add(BuildValidateCommand());
root.Add(BuildImportModelCommand());
return(new CommandLineBuilder(root));
}
private static CommandLineBuilder GetCommandLine()
{
RootCommand root = new RootCommand("parent")
{
Description = $"Microsoft IoT Models Repository CommandLine v{Outputs.CommandLineVersion}"
};
root.Name = Outputs.RootCommandName;
root.Add(BuildExportCommand());
root.Add(BuildValidateCommand());
root.Add(BuildImportModelCommand());
root.Add(BuildRepoIndexCommand());
root.Add(BuildRepoExpandCommand());
root.AddGlobalOption(CommonOptions.Debug);
root.AddGlobalOption(CommonOptions.Silent);
CommandLineBuilder builder = new CommandLineBuilder(root);
builder.UseMiddleware(async(context, next) =>
{
AzureEventSourceListener listener = null;
try
{
if (context.ParseResult.Tokens.Any(x => x.Type == TokenType.Option && x.Value == "--debug"))
{
Outputs.WriteHeader();
listener = AzureEventSourceListener.CreateConsoleLogger(EventLevel.Verbose);
Outputs.WriteDebug(context.ParseResult.ToString());
}
if (context.ParseResult.Tokens.Any(x => x.Type == TokenType.Option && x.Value == "--silent"))
{
System.Console.SetOut(TextWriter.Null);
}
await next(context);
}
finally
{
if (listener != null)
{
listener.Dispose();
}
}
});
return(builder);
}
private static RootCommand BuildRootCommand()
{
var rootCommand = new RootCommand();
rootCommand.Handler = CommandHandler.Create((IHelpBuilder help) =>
{
help.Write(rootCommand);
});
rootCommand.Add(BuildExtractCommand());
rootCommand.Add(BuildQueueCommand());
rootCommand.Add(BuildQueueAllCommand());
return(rootCommand);
}
public static async Task <int> Main(string[] args)
{
var command = new RootCommand();
command.Add(ScrapeCommand.Create());
command.Description = "Scrapes test results from AzDO, xUnit files, etc. and stores it in a database.";
var builder = new CommandLineBuilder(command);
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.UsePrefixes(new[] { "-", "--", }); // disable garbage windows conventions
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
// Allow fancy drawing.
builder.UseAnsiTerminalWhenAvailable();
var parser = builder.Build();
return(await parser.InvokeAsync(args));
}
public CodeFenceAnnotationsParser(
IDefaultCodeBlockAnnotations defaultAnnotations = null,
Action <Command> configureCsharpCommand = null,
Action <Command> configureFsharpCommand = null,
Action <Command> configureConsoleCommand = null)
{
_defaultAnnotations = defaultAnnotations;
var languageBinder =
new Lazy <ModelBinder>(() => new ModelBinder(CodeBlockAnnotationsType));
_modelBindersByCommand = new Dictionary <ICommand, Lazy <ModelBinder> >
{
[CreateCsharpCommand(configureCsharpCommand)] = languageBinder,
[CreateFsharpCommand(configureFsharpCommand)] = languageBinder,
[CreateConsoleCommand(configureConsoleCommand)] = new Lazy <ModelBinder>(() => new ModelBinder(typeof(OutputBlockAnnotations)))
};
_supportedLanguages = new HashSet <string>(_modelBindersByCommand.Keys.SelectMany(c => c.Aliases));
var rootCommand = new RootCommand();
foreach (var command in _modelBindersByCommand.Keys)
{
rootCommand.Add((Command)command);
}
_parser = new Parser(rootCommand);
}
public async Task <int> Run(string[] args)
{
var root = new RootCommand();
root.Add(_serviceProvider.GetRequiredService <TestVerb>());
return(await root.InvokeAsync(args));
}
public static RootCommand GetRootCommand()
{
var rootCommand = new RootCommand();
rootCommand.Name = "nrustlightning-cli";
rootCommand.Description = "CLI interface for requesting to NRustLightning server";
foreach (var op in GetOptions())
{
rootCommand.Add(op);
}
foreach (var sub in GetSubCommands())
{
rootCommand.AddCommand(sub);
}
rootCommand.AddValidator(result =>
{
var hasNetwork = result.Children.Contains("network");
if (result.Children.Contains("mainnet") && hasNetwork)
{
return("You cannot specify both '--network' and '--mainnet'");
}
if (result.Children.Contains("testnet") && hasNetwork)
{
return("You cannot specify both '--network' and '--testnet'");
}
if (result.Children.Contains("regtest") && hasNetwork)
{
return("You cannot specify both '--network' and '--regtest'");
}
return(null);
});
return(rootCommand);
}
static async Task FromAmong(string[] args)
{
// <staticlist>
var languageOption = new Option <string>(
"--language",
"An option that that must be one of the values of a static list.")
.FromAmong(
"csharp",
"fsharp",
"vb",
"pwsh",
"sql");
// </staticlist>
var rootCommand = new RootCommand("Static list example");
rootCommand.Add(languageOption);
rootCommand.SetHandler((string languageOptionValue) =>
{
Console.WriteLine($"--language = {languageOptionValue}");
},
languageOption);
await rootCommand.InvokeAsync(args);
Console.WriteLine("Request help, provide a valid language, provide an invalid language.");
await rootCommand.InvokeAsync("-h");
await rootCommand.InvokeAsync("--language csharp");
await rootCommand.InvokeAsync("--language not-a-language");
}
static int Main(string[] args)
{
RootCommand root = new RootCommand();
Command addUser = new Command("adduser")
{
new Option <string>(new string[] { "--username", "-u" }, description: "The name of the user/account"),
new Option <string>(new string[] { "--password", "-p" }, description: "The password for the new user/account"),
};
addUser.Handler = CommandHandler.Create <string, string>(async(username, password) =>
{
IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", true, true)
.AddJsonFile("secrets.json", true, true)
.Build();
CalorieContext db = new CalorieContext(config);
AuthService auth = new AuthService(db);
await auth.CreateUserAsync(username, password);
Console.WriteLine("User {0} created", username);
});
root.Add(addUser);
return(root.InvokeAsync(args).Result);
}
static async Task FileInfoExample(string[] args)
{
// <fileinfo>
var fileOption = new Option <FileInfo>("--file");
var command = new RootCommand();
command.Add(fileOption);
command.SetHandler(
(FileInfo? file) =>
{
if (file is not null)
{
Console.WriteLine($"File name: {file?.FullName}");
}
else
{
Console.WriteLine("Not a valid file name.");
}
}, fileOption);
await command.InvokeAsync(args);
// </fileinfo>
await command.InvokeAsync("--file scl.runtimeconfig.json");
await command.InvokeAsync("--file newfile.json");
}
static async Task ArraysAndLists(string[] args)
{
// <ienumerable>
var itemsOption = new Option <IEnumerable <string> >("--items")
{
AllowMultipleArgumentsPerToken = true
};
var command = new RootCommand("IEnumerable binding example");
command.Add(itemsOption);
command.SetHandler(
(IEnumerable <string> items) =>
{
Console.WriteLine(items.GetType());
foreach (var item in items)
{
Console.WriteLine(item);
}
}, itemsOption);
await command.InvokeAsync(args);
// </ienumerable>
await command.InvokeAsync("--items one --items two --items three");
await command.InvokeAsync("--items one two three");
}
static async Task HiddenOption(string[] args)
{
// <hiddenoption>
var endpointOption = new Option <Uri>("--endpoint")
{
IsHidden = true
};
var command = new RootCommand();
command.Add(endpointOption);
command.SetHandler(
(Uri? uri) =>
{
Console.WriteLine(uri?.GetType());
Console.WriteLine(uri?.ToString());
}, endpointOption);
await command.InvokeAsync(args);
// </hiddenoption>
Console.WriteLine("Request help for hidden option.");
await command.InvokeAsync("-h");
Console.WriteLine("Provide hidden option.");
await command.InvokeAsync("--endpoint https://contoso.com");
}
private Parser GetDirectiveParser()
{
if (_directiveParser == null)
{
var root = new RootCommand();
foreach (var c in _directiveCommands)
{
root.Add(c);
}
var commandLineBuilder =
new CommandLineBuilder(root)
.ParseResponseFileAs(ResponseFileHandling.Disabled)
.UseMiddleware(
context => context.BindingContext
.AddService(
typeof(KernelInvocationContext),
() => KernelInvocationContext.Current));
commandLineBuilder.EnableDirectives = false;
_directiveParser = commandLineBuilder.Build();
}
return(_directiveParser);
}
public JetfireRootCommand(IEnumerable <IJetfireSubCommand> subCommands)
{
Command = new RootCommand
{
new Option <string>(
alias: "--cluster",
description: "The CDF cluster where Jetfire is hosted (e.g. greenfield, europe-west1-1)"
)
};
foreach (var subCommand in subCommands)
{
Command.Add(subCommand.Command);
}
var _ = new CommandLineBuilder(Command)
.UseVersionOption()
.UseHelp()
.UseParseDirective()
.UseDebugDirective()
.UseSuggestDirective()
.RegisterWithDotnetSuggest()
.UseTypoCorrections()
.UseParseErrorReporting()
.CancelOnProcessTermination()
.Build();
}
public static RootCommand AppendFactoriesCommand(
this RootCommand baseCommand,
IEnumerable <EntityFactory> factories
)
{
factories.ToList().ForEach(f => baseCommand.Add(f.GenerateCommand()));
return(baseCommand);
}