public static async Task <int> Main(string[] args)
{
var command = new RootCommand()
{
Description = "Developer tools and publishing for microservices.",
};
// Show commandline help unless a subcommand was used.
command.Handler = CommandHandler.Create <IHelpBuilder>(help =>
{
help.Write(command);
return(1);
});
var builder = new CommandLineBuilder(command);
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
var parser = builder.Build();
return(await parser.InvokeAsync(args));
}
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));
}
public static async Task <int> Main(string[] args)
{
var command = new RootCommand
{
Commands.Deploy.Command(),
// ...add more commands here
};
command.Name = "clud";
command.Description = "clud deployment tool";
// Show commandline help unless a sub-command was used.
command.Handler = CommandHandler.Create <IHelpBuilder>(help =>
{
ConsoleHelpers.PrintLogo();
help.Write(command);
return(1);
});
var builder = new CommandLineBuilder(command);
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
var parser = builder.Build();
return(await parser.InvokeAsync(args));
}
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 static Task <int> Main(string[] args)
{
var root = new RootCommand();
root.Handler = CommandHandler.Create <IConsole, IHelpBuilder>((console, help) =>
{
// looks a bit gross but avoids a newline
console.Out.Write(@" _____ __ __ _
/ ___/_____/ /_ ___ ____ ___ ____ _/ /_(_)____
\__ \/ ___/ __ \/ _ \/ __ `__ \/ __ `/ __/ / ___/
___/ / /__/ / / / __/ / / / / / /_/ / /_/ / /__
/____/\___/_/ /_/\___/_/ /_/ /_/\__,_/\__/_/\___/
The helpful database schema querying tool.
");
help.Write(root);
return(1);
});
var configFileOption = new Option <FileInfo>(
"--config",
getDefaultValue: () => new FileInfo(
Path.Combine(Directory.GetCurrentDirectory(),
"schematic.config.json"
)),
description: "A path to a configuration file used to retrieve options such as connection strings."
).ExistingOnly();
root.AddGlobalOption(configFileOption);
root.AddCommand(new OrmCommand());
root.AddCommand(new LintCommand());
root.AddCommand(new ReportCommand());
root.AddCommand(new TestCommand());
var builder = new CommandLineBuilder(root);
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
var parser = builder.Build();
return(parser.InvokeAsync(args));
}
static async Task Main(string[] args)
{
var command = new RootCommand("Run a .NET Framework website in IIS")
{
new Argument <DirectoryInfo?>(CLIHelper.ParsePath <DirectoryInfo>)
{
Arity = ArgumentArity.ExactlyOne,
Description = "The relative or absolute path to the .NET Framework project directory",
Name = "path",
},
new Argument <DirectoryInfo?>(CLIHelper.ParsePath <DirectoryInfo>)
{
Arity = ArgumentArity.ZeroOrOne,
Description = "The relative or absolute path to the solution directory",
Name = "solutionPath"
},
new Option("--no-build", "Do not build the website before launching it"),
new Option("--name", "The name of the website")
{
Argument = new Argument <string>("name")
},
new Option("--port", "The port that the website should listen on")
{
Argument = new Argument <int>("port")
}
};
command.Handler = CommandHandler.Create <CommandArguments>(async arg =>
{
if (string.IsNullOrEmpty(arg.Path?.FullName))
{
throw new Exception("Argument 'path' is required.");
}
var environmentVariables = EnvironmentHelper.LoadEnvironmentVariables();
await using var iisHost = new IISHost(environmentVariables);
await iisHost.Run(arg.Console, arg, arg.Token);
});
var builder = new CommandLineBuilder(command);
builder.UseHelp();
builder.UseDebugDirective();
builder.UseExceptionHandler(CLIHelper.HandleException);
builder.CancelOnProcessTermination();
var parser = builder.Build();
await parser.InvokeAsync(args);
}
public static async Task <int> Main(string[] args)
{
// Create a root command with some options
var command = new RootCommand();
command.Add(Commands.RunCronJob(args));
command.Description = "Worker/Cronjob Example";
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.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
// Allow fancy drawing.
builder.UseAnsiTerminalWhenAvailable();
// default
command.Handler = CommandHandler.Create <IConsole>(console =>
{
CreateHostBuilder(args).Build().Run();
});
var parser = builder.Build();
return(await parser.InvokeAsync(args));
}
static async Task Main(string[] args)
{
var command = new RootCommand("Run a .NET Framework project")
{
new Argument <DirectoryInfo?>(CLIHelper.ParsePath <DirectoryInfo>)
{
Arity = ArgumentArity.ExactlyOne,
Description = "The relative or absolute path to the .NET Framework project directory",
Name = "path"
},
new Argument <DirectoryInfo?>(CLIHelper.ParsePath <DirectoryInfo>)
{
Arity = ArgumentArity.ZeroOrOne,
Description = "The relative or absolute path to the solution directory",
Name = "solutionPath"
},
new Option <bool>("--no-restart", "Keep running project even after rebuilds")
{
IsRequired = false
}
};
command.Handler = CommandHandler.Create <CommandArguments>(async arg =>
{
if (string.IsNullOrEmpty(arg.Path?.FullName))
{
throw new Exception("Argument 'path' is required.");
}
arg.Arguments = CLIHelper.ParseArguments();
await using var dnfHost = new DNFHost();
await dnfHost.Run(arg.Console, arg, arg.Token);
});
var builder = new CommandLineBuilder(command);
builder.UseHelp();
builder.UseDebugDirective();
builder.UseExceptionHandler(CLIHelper.HandleException);
builder.CancelOnProcessTermination();
var parser = builder.Build();
await parser.InvokeAsync(args);
}
private static Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration().MinimumLevel.Debug().WriteTo.Console().CreateLogger();
var serviceCollection = new ServiceCollection();
var command = new RootCommand {
Description = "Nauta command line tool."
};
command.AddCommand(CreateCredentialsCommand());
command.AddCommand(CreateOpenCommand());
command.AddCommand(CreateCloseCommand());
command.AddCommand(CreateTimeCommand());
// Show commandline help unless a subcommand was used.
command.Handler = CommandHandler.Create <IHelpBuilder>(
help =>
{
help.Write(command);
return(1);
});
var builder = new CommandLineBuilder(command);
builder.UseExceptionHandler(
(exception, context) =>
{
Log.Error(exception, "Error executing command '{command}'.", context.ParseResult.CommandResult.Token.Value);
});
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.CancelOnProcessTermination();
var parser = builder.Build();
return(parser.InvokeAsync(args));
}
public static Task <int> Main(string[] args)
{
var command = new RootCommand()
{
Description = "Developer tools and publishing for microservices.",
};
command.AddGlobalOption(StandardOptions.NoDefaultOptions);
command.AddCommand(CreateInitCommand());
command.AddCommand(CreateGenerateCommand());
command.AddCommand(CreateRunCommand());
command.AddCommand(CreateBuildCommand());
command.AddCommand(CreatePushCommand());
command.AddCommand(CreateDeployCommand());
command.AddCommand(CreateUndeployCommand());
// Show commandline help unless a subcommand was used.
command.Handler = CommandHandler.Create <IHelpBuilder>(help =>
{
help.Write(command);
return(1);
});
var builder = new CommandLineBuilder(command);
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
builder.UseMiddleware(DefaultOptionsMiddleware);
var parser = builder.Build();
return(parser.InvokeAsync(args));
}
public static async Task <int> Main(string[] args)
{
RootCommand rootCommand = new RootCommand("Atari Lynx Command-line Interface");
rootCommand.AddCommand(new ComLynxCommand());
rootCommand.AddCommand(new BllCommand());
rootCommand.AddCommand(new FlashcardCommand());
// Show commandline help unless a subcommand was used.
rootCommand.Handler = CommandHandler.Create <IHelpBuilder>(help =>
{
help.Write(rootCommand);
return(1);
});
var verboseOption = new Option <bool>("--verbose", "Show verbose output");
verboseOption.AddAlias("-v");
rootCommand.TryAddGlobalOption(verboseOption);
var builder = new CommandLineBuilder(rootCommand);
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
//builder.UseMiddleware(DefaultOptionsMiddleware);
var parser = builder.Build();
return(await parser.InvokeAsync(args));
//return await rootCommand.InvokeAsync(args);
}
static async Task <int> Main(string[] args)
{
var command = new RootCommand();
command.AddCommand(DeployCommand.Create());
command.AddCommand(InitCommand.Create());
command.AddCommand(GenerateCommand.Create());
command.AddCommand(PackageCommand.Create());
command.AddCommand(PushCommand.Create());
command.Description = "white-glove service for .NET and kubernetes";
command.Handler = CommandHandler.Create <IHelpBuilder>(help =>
{
help.Write(command);
return(1);
});
var builder = new CommandLineBuilder(command);
// Parsing behavior
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 command = new RootCommand("Dumps usage of PlatformNotSupportedException");
var directoryArgument = new Argument <DirectoryInfo>();
directoryArgument.SetDefaultValue(new DirectoryInfo(Environment.CurrentDirectory));
directoryArgument.ExistingOnly();
command.AddOption(new Option(new[] { "-d", "--directory", })
{
Argument = directoryArgument,
Required = false,
});
command.Handler = CommandHandler.Create <IConsole, DirectoryInfo>(async(console, directory) =>
{
await Dumper.DumpAsync(console, directory);
});
var builder = new CommandLineBuilder(command);
// Parsing behavior
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.UsePrefixes(new[] { "-", "--", }); // disable garbage windows conventions
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
var parser = builder.Build();
return(await parser.InvokeAsync(args));
}