public static ParseArguments ( string args, object options ) : bool | ||
args | string | A |
options | object | An instance to receive values.
/// Parsing rules are defined using |
Résultat | bool |
private static void Main(string[] args) { var parser = new Parser(config => config.HelpWriter = Console.Out); if (args.Length == 0) { parser.ParseArguments<Options>(new[] { "--help" }); return; } Options options = null; parser.ParseArguments<Options>(args) .WithParsed(r => { options = r; }); if (string.IsNullOrEmpty(options.Job)) { Console.WriteLine("Job required!"); return; } Console.WriteLine(options.Job); switch (options.Job.ToLower()) { case "sqlread": SqlBenchmark.ReadAsync(options.Parallel).Wait(); break; case "migrate": Sql2MongoMigrator.MigrateAsync().Wait(); break; case "read": MongoDbBenchmark.ReadAsync(options.Parallel).Wait(); break; case "duplicate": MongoDbBenchmark.DuplicateAsync(options.Parallel).Wait(); break; case "replace": MongoDbBenchmark.ReplaceAsync(options.Parallel).Wait(); break; case "savesimple": MongoDbBenchmark.SaveSimpleAsync(options.Parallel).Wait(); break; case "savecomplex": MongoDbBenchmark.SaveComplexAsync(options.Parallel, false).Wait(); break; case "savecomplexfull": MongoDbBenchmark.SaveComplexAsync(options.Parallel, true).Wait(); break; default: Console.WriteLine("Invalid job!"); break; } }
/// <summary> /// Main method that runs the install program. /// </summary> /// <param name="args">Command line arguments.</param> private static void Main(string[] args) { InstallOptions installOptions = new InstallOptions(); Environment.CurrentDirectory = Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName; if (args.Contains("--help")) { Console.Write(installOptions.GetUsage()); Environment.Exit(0); } installLogger = new InstallLogger(installOptions.Quiet); Parser parser = new Parser(settings => { settings.MutuallyExclusive = true; }); if (!parser.ParseArguments(args, installOptions)) { installLogger.LogErrorLine("Invalid command line parameters"); Environment.Exit(1); } JsonConvert.DefaultSettings = () => new JsonSerializerSettings { Formatting = Formatting.None, ContractResolver = new DiscretionalContractResolver(), Converters = new JsonConverter[] { new JsonKnownTypeConverter() } }; new Program().Run(installOptions); }
public static int Main(string[] args) { //Check that all the necessary directories exist. CPFilePath.CreateDefaultDirectories(); //Create the CLI parser. CLIParser = new CommandLine.Parser(with => with.AutoVersion = false); //Based on the given command line flags, execute. if (args.Length > 0 && args[0] == "pkg") { return(CLIParser.ParseArguments <PackageManagerCLIOptions>(args) .MapResult( (PackageManagerCLIOptions opts) => { new Sharpie(opts); return 0; }, errs => HandleCLIParseErrors(errs) )); } else { return(CommandLine.Parser.Default.ParseArguments <InlineCLIOptions>(args) .MapResult( (InlineCLIOptions opts) => RunAlgoInline(opts, args), errs => HandleCLIParseErrors(errs) )); } }
/// <summary> /// Run the OpenHardwareMonitor application as a console application /// </summary> /// <param name="args"></param> /// <returns>0 in case of success, 1 if arguments mismatch, 2 if required application files are missing, 3 in case of unexpected errors, 9 if administrative privileges are missing, or higher values for task specific errors</returns> static int Main(string[] args) { int ExitCode = 0; try { if (!AllRequiredFilesAvailable()) { return(2); } CommandLine.Parser CaseInsensitiveParser = new CommandLine.Parser(settings => { settings.CaseSensitive = false; settings.HelpWriter = CommandLine.Parser.Default.Settings.HelpWriter; settings.EnableDashDash = CommandLine.Parser.Default.Settings.EnableDashDash; settings.CaseInsensitiveEnumValues = CommandLine.Parser.Default.Settings.CaseInsensitiveEnumValues; settings.IgnoreUnknownArguments = CommandLine.Parser.Default.Settings.IgnoreUnknownArguments; settings.MaximumDisplayWidth = CommandLine.Parser.Default.Settings.MaximumDisplayWidth; settings.ParsingCulture = CommandLine.Parser.Default.Settings.ParsingCulture; }); var Result = CaseInsensitiveParser.ParseArguments <CommandLineOptions.RunWebserver, CommandLineOptions.ReportToConsole, CommandLineOptions.ReportToFile>(args); ExitCode = Result.MapResult( (CommandLineOptions.RunWebserver opts) => RunConsoleHttpServerAndReturnExitCode(opts), (CommandLineOptions.ReportToConsole opts) => RunConsoleReportAndReturnExitCode(opts), (CommandLineOptions.ReportToFile opts) => RunFileReportAndReturnExitCode(opts), errs => 1); } catch (Exception ex) { if (VerboseMode) { Utility.WriteLogMessage("ERROR: " + ex.ToString(), null, true); } else { Utility.WriteLogMessage("ERROR: " + ex.Message, null, true); } ExitCode = 3; } if ((ExitCode == 1) && (!Utility.IsUserAdministrator())) { System.Console.Out.WriteLine("WARNING: you need to run this application with administrator permission"); System.Console.Out.WriteLine(); } if (WaitOnExitForSeconds > 0) { Console.Out.WriteLine("Waiting " + WaitOnExitForSeconds.ToString() + " seconds before exiting . . ."); System.Threading.Thread.Sleep(WaitOnExitForSeconds * 1000); } if (WaitOnExitForEnterKey) { Console.Out.WriteLine("Press <Enter> to exit . . ."); Console.ReadLine(); } return(ExitCode); }
static void Main(string[] args) { //(1)コマンドラインパーサーの初期化 ParserSettings setting = new ParserSettings(); setting.HelpWriter = Console.Error; var parser = new Parser(setting); //(2)オプション用クラスに引数を展開 var option = new ConsoleOption(); if (!parser.ParseArguments(args, option)) { //パラメータに問題がある場合は、失敗ステータスで終了 Environment.Exit(1); } var filePath = System.IO.Path.GetFullPath(option.OutputDirPath); var createYoutubeQRCode = new CreateYoutubeQRCodeLib.CreateYoutubeQRCode(); createYoutubeQRCode.TargetContentType = CreateYoutubeQRCodeLib.contentType.User; createYoutubeQRCode.ConsumerKey = option.ClientID; createYoutubeQRCode.ConsumerSecret = option.ClientSeacret; createYoutubeQRCode.TargetFolderPath = filePath; var t = createYoutubeQRCode.CreateQR(); t.Wait(); }
/// <summary> /// /// </summary> /// <param name="args"></param> static protected void Run(string[] args) { Thread.CurrentThread.Name = "NativeHost::Main"; try { SetConsoleCtrlHandler(new HandlerRoutine(ConsoleCtrlHandler), true); regService = new RegistryService(endpoint.Properties); BrowserType caller = endpoint.CheckBrowserCall(args); if (caller == BrowserType.Unknown) { Log.Debug("Native host started with args {0} ", args); Parser parser = new CommandLine.Parser(with => with.HelpWriter = null); parserResult = parser.ParseArguments <Options>(args); parser.Dispose(); parserResult .WithParsed(options => RunAndReturnExitCode(options)) .WithNotParsed(errors => DisplayHelp(errors)); } else { Log.Debug("Native host called by {1} with args {0} ", args, caller); DoHostListen(caller); } } catch (Exception e) { Log.Fatal(e.Message); } Log.CloseAndFlush(); Log.Debug("Native host will now exit"); }
/// <summary> /// Main entry point of the program /// </summary> /// <param name="args">Command line arguments to be parsed</param> static void Main(string[] args) { // We create your own command line parser to setup wanted options CommandLine.Parser parser = new CommandLine.Parser( with => { //with.HelpWriter = Console.Error; with.HelpWriter = null; // To display myself the help with.IgnoreUnknownArguments = false; with.CaseSensitive = false; } ); // Make the parsing ParserResult <CommandLineArguments> result = parser.ParseArguments <CommandLineArguments>(args); // In function of parser result, we run the program of we handle the errors result.WithParsed <CommandLineArguments>(opts => Run(opts)) .WithNotParsed <CommandLineArguments>((errs) => HandleParseError(errs, result) ); // Only for debug, when the program is launch under Visual Studio. if (Debugger.IsAttached) { Console.WriteLine("Press any key to exit"); Console.ReadKey(); } }
static void Main(string[] args) { using var parser = new CommandLine.Parser((settings) => { settings.CaseInsensitiveEnumValues = true; settings.HelpWriter = null; }); var result = parser.ParseArguments < CalculateOptions >(args); result.MapResult( (CalculateOptions options) => { return(Task.Run(async() => { return await new Calculator(options).Run(); }).GetAwaiter().GetResult()); }, errors => { var helpText = HelpText.AutoBuild(result, 96); helpText.Copyright = "Copyright (C) 2020 Frozen Mountain Software Ltd."; helpText.AddEnumValuesToHelpText = true; Console.Error.Write(helpText); return(1); }); }
public static ScryptCommandLineArgs Parse(string[] args, out string verb) { if (args.Length == 0) { // Work around a bug in CommandLineParser that doesn't correctly support a custom 'help' verb. Console.WriteLine(HelpText.AutoBuild(new ScryptCommandLineArgs(), _ => { }, true)); Environment.Exit(Parser.DefaultExitCodeFail); } string verbForClosure = null; var arguments = new ScryptCommandLineArgs(); var parser = new Parser(settings => { settings.HelpWriter = null; }); var parseSucceed = parser.ParseArguments(args, arguments, (foundVerb, subOptions) => { verbForClosure = foundVerb; }); if (!parseSucceed) { Console.WriteLine(HelpText.AutoBuild(arguments, _ => { }, true)); Environment.Exit(Parser.DefaultExitCodeFail); } verb = verbForClosure; return arguments; }
public bool TryParseArguments(IEnumerable <string> args, out ParserResult <Options> results) { _log.LogTrace("Trying to parse Options"); results = _parser.ParseArguments <Options>(args); return(results.Tag == ParserResultType.Parsed); }
static int Main(string[] args) { log.Info("Start."); var parser = new Parser(with => { with.HelpWriter = Console.Out; with.EnableDashDash = true; }); try { objWS_S = new EArchiveClient("EArchiveDefaultTest"); var isRunning = objWS_S.IsRunning(); if (!isRunning) { log.Error("Connection to webservice failed. Service is not running."); return 2; } } catch (Exception ex) { log.Error(ex, "Connection to webservice failed. Is certificate configured properly?"); return 1; } var result = parser.ParseArguments<SendLDocOptions, GetLDocOptions, SendLDocCSVOptions, GetSendLDocSchemaOptions>(args); var exitCode = result.MapResult( (SendLDocOptions opts) => RunSendAndReturnExitCode(opts), (GetLDocOptions opts) => RunGetAndReturnExitCode(opts), (SendLDocCSVOptions opts) => RunSendFromCsvAndReturnExitCode(opts), (GetSendLDocSchemaOptions opts) => RunGetSchemaAndReturnExitCode(opts), errs => 1 ); objWS_S.Close(); log.Info("All done."); return exitCode; }
public string GetUsageHelp() { using (var parser = new CommandLine.Parser((settings) => { settings.HelpWriter = null; })) { var args = Environment.GetCommandLineArgs(); var r = parser.ParseArguments <CommandLineOptions>(args).WithNotParsed(errs => { }); var help = HelpText.AutoBuild(r, (ht) => ht, (ex) => ex ); help.AddPreOptionsLine(" "); help.AddPreOptionsLine(string.Format("Usage: {0} --from Source --to Destination [--number number] [--log LogFileName]", ExeUtils.GetExeName())); help.AddPreOptionsLine(string.Format(" or: {0} --config ConfigFileName", ExeUtils.GetExeName())); help.AddPostOptionsLine(""); help.AddPostOptionsLine("Endpoint type: dir (directory) | cs (content storage)"); help.AddPostOptionsLine("Connection info:"); help.AddPostOptionsLine(" dir : directory_name"); help.AddPostOptionsLine(" cs : container_name token"); help.AddPostOptionsLine(""); help.AddPostOptionsLine(string.Format(@"Example: {0} -f cs TestContainer werlewkj32lwkejr324pfwer -t dir D:\Backup\TestContainer", ExeUtils.GetExeName())); help.AddPostOptionsLine(""); return(help); } }
public void Execute <T>(ICommandHandler handler, string[] args, CommandContext context) { var parser = new Clp.Parser(settings => { settings.AutoHelp = true; settings.AutoVersion = false; settings.HelpWriter = null; settings.IgnoreUnknownArguments = false; settings.CaseSensitive = false; }); var result = parser.ParseArguments <T>(args).WithParsed(options => Execute(handler, options, context)); result.WithNotParsed(errors => { var help = new HelpText(String.Empty, String.Empty) { AutoHelp = true, AutoVersion = false, AddDashesToOption = true }; help = HelpText.DefaultParsingErrorsHandler(result, help); help = help.AddOptions(result); var errorList = errors.ToList(); if (errorList.Count == 0 || errorList.Count == 1 && errorList[0].Tag == ErrorType.HelpRequestedError) { context.Output.WriteLine(help); } else { context.ErrorOutput.WriteLine(help); } }); }
public static void Main(string[] args) { var options = new Options(); var parser = new CommandLine.Parser(); if (parser.ParseArguments(args, options)) { var configManager = new CliConfigManager(); Config = configManager.GetConfig(); var configEntry = Config.Areas.FirstOrDefault(x => x.Id.Equals(options.ServiceEndpoint)); if (configEntry == null) { Console.WriteLine("Invalid endpoint!"); return; } var service = new Bus13RouteDataService(configEntry.Endpoint, configEntry.Id); if (options.List) { ListVehicles(service); } if (options.Trace) { if (string.IsNullOrEmpty(options.VehicleId)) { Console.WriteLine("Vehicle id must be supplied!"); return; } if (!string.IsNullOrEmpty(options.OutputDir) && !Directory.Exists(options.OutputDir)) { Console.WriteLine("Directory {0} doesn't exist!", options.OutputDir); return; } IVehicleTraceOutputWriter outputWriter = null; if (string.IsNullOrEmpty(options.OutputType) || string.Equals("kml", options.OutputType, StringComparison.InvariantCultureIgnoreCase)) { outputWriter = new KmlOutputWriter(GetOutputDir(options)); } if (string.Equals("json", options.OutputType, StringComparison.InvariantCultureIgnoreCase)) { outputWriter = new JsonOutputWriter(GetOutputDir(options)); } if (outputWriter == null) { outputWriter = new KmlOutputWriter(GetOutputDir(options)); } Trace(service, options.VehicleId, outputWriter); Console.ReadKey(); } } }
public static void Main(string[] args) { var parser = new CommandLine.Parser(configuration => configuration.HelpWriter = null); parser.ParseArguments <Options>(args) .WithParsed <Options>(Run) .WithNotParsed((errors) => Console.WriteLine($"Usage: ledger <journal>")); }
public static IArgOptions Parse(string[] args, out bool parsedOK) { var options = new ArgOptions(); var parser = new CommandLine.Parser(); parsedOK = parser.ParseArguments(args, options); return(options); }
public static void Main(string[] args) { var parser = new CommandLine.Parser(configuration => configuration.HelpWriter = null); parser.ParseArguments <Options>(args) .WithParsed <Options>(Run) .WithNotParsed((errors) => Console.WriteLine($"Usage: sherlock <db> [--password password] [--script script] [--item path]")); }
private static void Main(string[] args) { try { //Set lower priority for the process Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.BelowNormal; //Use only first processor Process.GetCurrentProcess().ProcessorAffinity = (IntPtr)1; //Change culture to en-US in order to use . as decimal separator System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.CreateSpecificCulture("en-US"); //Initializing arguments var options = new Options(); //Parsing arguments // CommandLine.Parser.Default.ParseArgumentsStrict(args, options); var parser = new CommandLine.Parser(with => with.HelpWriter = null); var parserResult = parser.ParseArguments <Options>(args); parserResult .WithParsed <Options>(opt => options = opt) .WithNotParsed(errs => DisplayHelp(parserResult, errs)); //Load XML with performance counters and calculate result //Load XML file using (var perfCounterList = new PerfCounterList(options.XmlFile, (string[])options.XmlParameters, options.Verbose)) { //Taking samples and calculate result of performance counters perfCounterList.Calculate(options.MaxSamples, options.TimeSamples); //No errors in PerfCounter, all counters are between ranges if (perfCounterList.GetGlobalExitCode() == 0) { Console.WriteLine( $"{perfCounterList.GetGlobalStatus()} - All performance counters between range {perfCounterList.GlobalPerfOutput}"); } //Some counters has values out of thresholds else { //Generate output with errors and performance data Console.WriteLine( $"{perfCounterList.GetGlobalStatus()} - {perfCounterList.GlobalOutput} {perfCounterList.GlobalPerfOutput}"); } //Exit code for monitoring software if (!options.NoAlerts) { Environment.Exit(perfCounterList.GetGlobalExitCode()); } else { Environment.Exit(0); } } } catch (Exception e) { //Return status and code unknown for monitoring software Console.WriteLine("Unknown: " + e.Message); Environment.Exit(3); } }
public static void Main(string[] args) { var parser = new CommandLine.Parser(settings => settings.HelpWriter = null); var result = parser.ParseArguments <EncodeOptions, DecodeOptions>(args); int output = result.MapResult( (EncodeOptions options) => { Watson.Encode(options, Console.OpenStandardOutput()); return(0); }, (DecodeOptions options) => { Watson.Decode(options, Console.OpenStandardOutput()); return(0); }, (errs) => { DisplayHelp(result); return(1); }); }
public static int Main(string[] args) { Options options = new Options(); using (Parser cmdParser = new Parser()) { cmdParser.ParseArguments(args, options); } List<string> files = Directory.EnumerateFiles(Environment.CurrentDirectory, options.Input, SearchOption.TopDirectoryOnly).ToList(); if (files.Count == 0) { Console.Error.WriteLine("File {0} not found", options.Input); return -1; } StreamWriter streamWriter; IParser parser; int result = AssertConditions(options, out streamWriter, out parser); if (result != 0) { string usage = options.GetUsage(); Console.WriteLine(usage); return result; } using (CSVWriter csvWriter = new CSVWriter(',', streamWriter)) { foreach(string file in files) { using (StreamReader reader = new StreamReader(file)) { if (options.Header) { string[] header = parser.GetHeader(); csvWriter.Append(header); } IEnumerable<string[]> rows = parser.Read(reader); foreach (string[] row in rows) { csvWriter.Append(row); } } } } return 0; }
static void Main(string[] args) { var parser = new CommandLine.Parser(with => with.HelpWriter = null); var parserResult = parser.ParseArguments <Options>(args); parserResult .WithParsed <Options>(options => Run(options)) .WithNotParsed(errs => DisplayHelp(parserResult, errs)); }
static void Main(string[] args) { // Create the cli parser with HelpWriter disabled, // since a custom help text will be used var cliParser = new CommandLine.Parser(with => with.HelpWriter = null); var cliParserResult = cliParser.ParseArguments(args, LoadVerbs()); cliParserResult.WithParsed(RunVerb); cliParserResult.WithNotParsed(errors => PrintHelp(cliParserResult)); }
private void InitializeOptions(IEnumerable <string> args) { _options = new CommandLineOptions(); using (var parser = new CommandLine.Parser((settings) => { settings.HelpWriter = null; })) { parser.ParseArguments <CommandLineOptions>(args) .WithParsed <CommandLineOptions>(opts => { _options = opts; }) .WithNotParsed(errs => { }); } }
static void Main(string[] args) { var container = CreateContainer(); var parser = new CommandLine.Parser(); var settings = new Settings(); parser.ParseArguments(args, settings); container.Resolve<TagsCloudVizualizer>() .GenerateCloud( settings.TextColor,settings.BackgroundColor,new Font(settings.FontName,10),new Size(10000,10000), settings.InputFileName, settings.OutputFileName); }
public bool Load(String[] args) { var parser = new CommandLine.Parser((settings) => { settings.CaseSensitive = false; settings.HelpWriter = null; }); return(parser.ParseArguments(args, this)); }
/// <summary> /// Console entry point /// </summary> /// <param name="args">command line arguments</param> /// <returns>0 if all extractions are successful.</returns> private static int Main(string[] args) { var options = new Options(); var parser = new Parser(settings => { settings.CaseSensitive = false; settings.HelpWriter = Console.Error; settings.ParsingCulture = CultureInfo.InvariantCulture; }); var result = parser.ParseArguments(args, options); if (!result) { Fail(); return -1; } TfsTeamProjectCollection tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(options.Collection)); try { tfs.EnsureAuthenticated(); } catch (Exception) { Fail("Connection to TFS failed"); return -1; } // Getting Identity Service var ims = tfs.GetService<IIdentityManagementService>(); var someExtractionFail = false; foreach (var userName in options.Users) { Console.WriteLine("===== Extracting Permissions for User {0} ======", userName); var fileName = Helpers.GenerateFileName(userName, options.OutputFile); var extractionStatus = ExtractPermissionForUserName(ims, userName, options, fileName, tfs); if (!extractionStatus) { someExtractionFail = true; } } if (someExtractionFail) { Fail("An error occured during the extraction"); return -1; } return 0; }
static void Main(string[] args) { // NOTES // 1. Start running in Debug mode in VS, I have set start up args (on project page) to be: // gitout.exe --plugin releasenotes --verbose --issuetracker "github" --accesstoken "sometoken" --reponame "myrepo" // you could also use: // gitout.exe --plugin semver // I have also set a post-build event on the ReleaseNotesPlugin project and the SemanticVersionPlugin project, // so that their assemblies are copied into the GitOut.exe directory, so that they can be discovered at runtime as a plugins. var parser = new CommandLine.Parser(with => with.IgnoreUnknownArguments = true); var appOptions = new Options(); if (parser.ParseArguments(args, appOptions)) { // parsing succeds // discover / load plugins var pluginManager = new PluginManager(); var plugin = pluginManager.GetPluginInstanceByName(appOptions.PluginName); if (plugin == null) { Console.WriteLine("Plugin not found for a command named: " + appOptions.PluginName); return; } try { // plugin execution context is context that we can pass to any plugin - and also could provide // the ability for plugins to access shared / central state. // it could contain commonly needed things like IssueTrackers, Loggers, or a service locator etc. var pluginExecutionContext = new PluginExecutionContext(); pluginExecutionContext.Args = args; // command line args defferred to the plugin. // Execute the plugin. plugin.Execute(pluginExecutionContext); } catch (Exception e) { HandlePluginExecutionError(e); return; } } else { // In addition to allowing particular plugins to be invoked on their own, // We could allow a workflow execution, based on a config file. // we could do that here by parsing a command that points to the yaml config // which would define which plugins were executed, with which settings, and in which order? Console.WriteLine("Failed to parse args, see usage."); } }
static void Main(string[] args) { try { var settings = new Settings(); using (var parser = new CommandLine.Parser(x => { x.CaseSensitive = false; x.IgnoreUnknownArguments = true; })) { if (!parser.ParseArguments(args, settings)) { Console.Error.WriteLine(settings.GetUsage()); return; } } if (settings.InputFiles == null) { RunMultiDumper(ref settings); } else { // We want to expand any wildcards in the input file list (and also fully qualify them) settings.InputFiles = settings.InputFiles .SelectMany(s => Directory .EnumerateFiles(Directory.GetCurrentDirectory(), s) .OrderByAlphaNumeric(x => x)) .ToList(); } if (settings.InputFiles == null || !settings.InputFiles.Any()) { Console.Error.WriteLine(settings.GetUsage()); throw new Exception("No inputs specified"); } using (var loader = new AudioLoader { AutoScalePercentage = settings.AutoScalePercentage, HighPassFilterFrequency = settings.HighPassFilterFrequency, VerticalScaleMultiplier = settings.VerticalScaleMultiplier, }) { loader.LoadAudio(settings.InputFiles); Render(settings, loader); } } catch (Exception e) { Console.Error.WriteLine($"Fatal: {e}"); } }
private static void ParseOptions(string[] args, Options options) { var parser = new Parser(delegate(ParserSettings settings) { settings.CaseSensitive = false; settings.HelpWriter = Console.Error; }); if (parser.ParseArguments(args, options) == false) throw new ArgumentException("Invalid command line"); }
private static void Main(string[] args) { try { var parser = new Parser(config => config.HelpWriter = Console.Out); parser.ParseArguments<Options>(args).WithParsed(Remap); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public static void Main([NotNull] string[] args) { Assert.ArgumentNotNull(args, "args"); CoreApp.InitializeLogging(); CoreApp.LogMainInfo(); Analytics.Start(); var filteredArgs = args.ToList(); var query = GetQueryAndFilterArgs(filteredArgs); var wait = GetWaitAndFilterArgs(filteredArgs); var parser = new Parser(with => with.HelpWriter = Console.Error); Assert.IsNotNull(parser, "parser"); var options = new MainCommandGroup(); EnsureAutoCompeteForCommands(options); if (!parser.ParseArguments(filteredArgs.ToArray(), options, delegate { })) { Console.WriteLine("Note, commands provide output when work is done i.e. without any progress indication."); Console.WriteLine("\r\n --query\t When specified, allows returning only part of any command's output"); Console.WriteLine("\r\n --data\t When specified, allows returning only 'data' part of any command's output"); Console.WriteLine("\r\n --wait\t When specified, waits for keyboard input before terminating"); Environment.Exit(Parser.DefaultExitCodeFail); } var result = options.SelectedCommand.Execute(); result = QueryResult(result, query); if (result == null) { return; } var serializer = new JsonSerializer { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.Indented, }; serializer.Converters.Add(new DirectoryInfoConverter()); var writer = Console.Out; serializer.Serialize(writer, result); if (wait) { Console.ReadKey(); } }
public static void CreateConfig() { if (!File.Exists(ConfigPath)) { System.Text.StringBuilder oStringBuilder = new StringBuilder(); oStringBuilder.AppendLine("<?xml version=\"1.0\" encoding=\"utf-8\" ?>"); oStringBuilder.AppendLine("<configuration>"); var oParser = new CommandLine.Parser(with => with.HelpWriter = null); var oParserResult = oParser.ParseArguments <Options>("--help".Split()); string sHelpText = HelpText.AutoBuild(oParserResult, HelpTextInstance => { HelpTextInstance.AdditionalNewLineAfterOption = false; //remove the extra newline between options HelpTextInstance.Heading = ""; HelpTextInstance.Copyright = ""; HelpTextInstance.MaximumDisplayWidth = 50000; HelpTextInstance.AddDashesToOption = false; HelpTextInstance.AutoVersion = false; HelpTextInstance.AutoHelp = false; return(HelpText.DefaultParsingErrorsHandler(oParserResult, HelpTextInstance)); }, e => e); sHelpText = Regex.Replace(sHelpText, @"\n ., ", " "); sHelpText = Regex.Replace(sHelpText, @" \[-. ", " [Default: "); oStringBuilder.AppendLine(" <!--" + sHelpText.Replace("<br/>", "\n".PadRight(37)) + "\n\n"); oStringBuilder.AppendLine(" To override a Key/Value pair, remove the leading and trailing HTML style comment tags surrounding the line (<!–– ––>)\n -->\n"); oParserResult = oParser.ParseArguments <Options>("".Split()); oParserResult.WithParsed <Options>(options => CreateConfigSection(options, ref oStringBuilder)); oStringBuilder.AppendLine("</configuration>"); var oOptions = new Options(); System.IO.File.WriteAllText(ConfigPath, oStringBuilder.ToString()); } }
public void Main(string[] args) { Parser parser = new Parser(config => { config.EnableDashDash = true; config.CaseSensitive = true; config.IgnoreUnknownArguments = false; config.HelpWriter = Out; }); parser.ParseArguments<Options>(args) .WithNotParsed(ArgumentsError) .WithParsed(Execute); }
static int Main(string[] args) { _logger.Info("App started"); var options = new Options(); var parser = new CommandLine.Parser(s => { s.MutuallyExclusive = false; }); var isValid = parser.ParseArguments(args, options); if (!isValid) { string msg = CommandLine.Text.HelpText.AutoBuild(options).ToString(); Console.WriteLine(msg); return(-1); } CLITester tester = new CLITester(options.Host, options.Port); tester.TestRetryCount = options.RetryCount; try { if (options.TestCmd != null) { _logger.Info("Run Test: " + options.TestCmd); string data = tester.Test(options.TestCmd); _logger.Info(data); } else if (options.Cmd != null) { _logger.Info("Run Cmd: " + options.Cmd); _logger.Info("Exp Val: " + options.ExpVal); string data = tester.CmdWaitRegx(options.Cmd, options.ExpVal); _logger.Info(data); } } catch (TestException ex) { _logger.Error(ex.Message); return(-1); } catch (Exception ex) { _logger.Error(ex); return(-2); } return(0); }
public static void Main(string[] args) { var options = new Options(); if (HasNoArguments(args)) { Console.Write(options.GetUsage()); Environment.Exit(1); } var parser = new Parser(); if (parser.ParseArguments(args, options)) { if (ShouldShowVersion(options)) { OutputVersion(); return; } try { var config = ConfigFactory.Create(options); var requester = new Requester(); var logger = LoggerFactory.Create(options); var warmer = WarmerFactory.Create(options, config, requester, logger); warmer.Warm(); } catch (XmlException e) { Console.WriteLine(""); Console.WriteLine("Invalid XML Config File"); Console.WriteLine("-----------------------"); Console.WriteLine(e.Message); } catch (FileNotFoundException e) { Console.WriteLine(""); Console.WriteLine("Could not find the file specifed. {0}", options.Inputfiles); Console.WriteLine("-----------------------"); Console.WriteLine(e.Message); } } else { Environment.Exit(1); } }
static void Main(string[] args) { var parser = new CommandLine.Parser(with => with.HelpWriter = null); var parserResult = parser.ParseArguments <Options>(args); parserResult .WithParsed <Options>(options => new Program(options).Run()) .WithNotParsed(errs => DisplayHelp(parserResult, errs)); #if DEBUG Console.Write("Press [Enter] to continue..."); Console.ReadLine(); #endif }
static int Main(string[] arguments) { CoreSettings settings = new CoreSettings(); Parser parser = new Parser(s => { s.IgnoreUnknownArguments = true; s.CaseSensitive = true; }); if(!parser.ParseArguments(arguments, settings)) { return 1; } else { return Launch(settings, arguments); } }
static IProgramOptions ParseCommandLine(string[] args) { var options = new CommandLineOptions.CommandLineOptions(); var parser = new Parser(settings => { settings.IgnoreUnknownArguments = true; settings.CaseSensitive = false; }); if (!parser.ParseArguments(args, options)) { Environment.Exit(1); } return options; }
private static void Main(string[] args) { StringWriter writer = new StringWriter(); Parser p = new Parser(with => with.HelpWriter = writer); TapCheckerOptions opts = new TapCheckerOptions(); if (!p.ParseArguments(args, opts)) { Console.WriteLine(writer.ToString()); return; } List<string> files = new List<string>(); if ((opts.Files.Length == 1) && (opts.Files[0] == "*")) { files.AddRange(Directory.GetFiles(".", "*.tap")); } else { files.AddRange(opts.Files.ToArray()); } ConsoleColor currentColor = Console.ForegroundColor; TapChecker checker = new TapChecker(); foreach (var fileToCheck in files) { List<ReportLine> report = checker.Check(fileToCheck, opts); foreach (var reportLine in report) { switch (reportLine.Status) { case ReportLineStatus.Info: Console.ForegroundColor = currentColor; break; case ReportLineStatus.Error: Console.ForegroundColor = ConsoleColor.Red; break; case ReportLineStatus.Warning: Console.ForegroundColor = ConsoleColor.Yellow; break; } Console.WriteLine(reportLine.Message); } Console.WriteLine(); } Console.ForegroundColor = currentColor; Console.WriteLine("Press enter to exit"); Console.ReadLine(); }
static int Main(string[] args) { if (DebugEnabled) { Debug($"Received {args.Length} arguments: {string.Join(" ", args)}"); } var code = -1; switch (args[0]) { case "inspect": code = Inspect(args[1]); break; case "launcher": code = MakeLauncher(args.Skip(1)); break; default: var parser = new CommandLine.Parser(with => with.HelpWriter = null); var result = parser.ParseArguments <BuildCommand>(args); if (result.Errors?.Any() == true) { var text = HelpText.AutoBuild(result); Console.Error.WriteLine(text.ToString()); return(-1); } var command = (BuildCommand)result.Value; switch (command.Action) { case "pack": case "restore": case "publish": case "build": code = Build((BuildCommand)command); break; default: return(Fail($"Unknown command: {command.Action}")); } break; } Debug($"exiting with code {code}"); return(code); }
public static void Main(string[] args) { if (Environment.OSVersion.Platform != PlatformID.Win32NT) { // See https://issues.bloomlibrary.org/youtrack/issue/BL-8475. Console.WriteLine("Harvester cannot run on Linux until we verify that phash computations always yield the same result on both Windows and Linux!"); return; } // See https://github.com/commandlineparser/commandline for documentation about CommandLine.Parser var parser = new CommandLine.Parser((settings) => { settings.CaseInsensitiveEnumValues = true; settings.CaseSensitive = false; settings.HelpWriter = Console.Error; }); try { parser.ParseArguments <HarvesterOptions, UpdateStateInParseOptions, BatchUpdateStateInParseOptions, GenerateProcessedFilesTSVOptions>(args) .WithParsed <HarvesterOptions>(options => { options.ValidateOptions(); Harvester.RunHarvest(options); }) .WithParsed <UpdateStateInParseOptions>(options => { HarvestStateUpdater.UpdateState(options.ParseDBEnvironment, options.ObjectId, options.NewState); }) .WithParsed <BatchUpdateStateInParseOptions>(options => { HarvestStateBatchUpdater.RunBatchUpdateStates(options); }) .WithParsed <GenerateProcessedFilesTSVOptions>(options => { ProcessedFilesInfoGenerator.GenerateTSV(options); }) .WithNotParsed(errors => { Console.Out.WriteLine("Error parsing command line arguments."); Environment.Exit(1); }); } catch (Exception e) { YouTrackIssueConnector.GetInstance(EnvironmentSetting.Unknown).ReportException(e, "An exception was thrown which was not handled by the program.", null); throw; } }
private static int Main(string[] args) { // Parse command line options if (args.Length == 1 && args[0].StartsWith("@")) { var argFile = args[0].Substring(1); if (File.Exists(argFile)) { args = File.ReadAllLines(argFile); } else { Console.WriteLine("File not found: " + argFile); return 1; } } var parser = new Parser(config => config.HelpWriter = Console.Out); if (args.Length == 0) { parser.ParseArguments<Options>(new[] { "--help" }); return 1; } Options options = null; var result = parser.ParseArguments<Options>(args) .WithParsed(r => { options = r; }); // Run process ! if (options != null) return Process(options); else return 1; }
private static int Main(string[] args) { // Set up the commandline parser var parser = new CommandLine.Parser(with => { with.CaseSensitive = false; with.HelpWriter = System.Console.Error; }); // Parse the commandline arguments and if successful, pass them to ProcessFile return(parser.ParseArguments <CommandlineOptions>(args).MapResult( (CommandlineOptions opts) => ProcessFile(opts.FilePath, opts.SortType.ToSortOrder()), errs => 1 )); }
private static int Main(string[] args) { var parser = new Parser( (settings) => { settings.EnableDashDash = true; settings.HelpWriter = Console.Error; }); var orchestrator = new Orchestrator(parser); var parserResult = parser.ParseArguments<RunasOptions, ElevateOptions, BootstrapOptions>(args); var exitCode = parserResult.MapResult( (RunasOptions opts) => { // Split username from domain if given var domainUserName = Utils.SplitUsernameAndDomain(opts.Username); var domain = domainUserName.Key; var userName = domainUserName.Value; // Get password from command line if not given SecureString passwordSecured; if (opts.Password == null) { Console.Write("Password: "); passwordSecured = Utils.GetConsoleSecurePassword(); } else { passwordSecured = opts.Password.ConvertToSecureString(); } // Exec return orchestrator.RunAs(opts.Command, opts.Arguments, domain, userName, passwordSecured, opts.Elevated); }, (ElevateOptions opts) => { // Exec return orchestrator.Elevate(opts.Command, opts.Arguments, opts.LogFilePath, opts.InitVerb); }, (BootstrapOptions opts) => { // Exec return orchestrator.Bootstrap(opts.Command, opts.Arguments, opts.LogFilePath, opts.InitVerb); }, errs => 1); return exitCode; }
public static async Task Main(string[] args) { var parser = new CommandLine.Parser(settings => { settings.CaseSensitive = false; settings.CaseInsensitiveEnumValues = true; settings.HelpWriter = null; }); var parserResult = parser.ParseArguments <RunOptions>(args); await parserResult.MapResult( (RunOptions options) => Run(options), errors => DisplayHelp(parserResult) ); }
public static void Main(string[] args) { Options = new AutomatrOptions(); Parser parser = new Parser(new Action<ParserSettings>((ParserSettings p) => { p.CaseSensitive = false; p.IgnoreUnknownArguments = false; p.MutuallyExclusive = true; })); bool parse = parser.ParseArguments(args, Options); if (Options.Version) { AutomatrLog.Log("Automatr " + Version, AutomatrLog.LogLevel.Info); return; } AutomatrConfig config = AutomatrConfig.Load(Options.ConfigPath); Automatr automatr = new Automatr(config); automatr.Run(); }
private static void Main(string[] args) { var parser = new CommandLine.Parser(with => { with.CaseSensitive = false; with.CaseInsensitiveEnumValues = true; with.HelpWriter = Console.Error; with.EnableDashDash = true; }); parser.ParseArguments <GenerateAllOptions, StepDefinitionOptions, NUnitOptions, MsTestOptions>(args) .WithParsed <GenerateAllOptions>(GenerateAll) .WithParsed <StepDefinitionOptions>(StepDefinitionReport) .WithParsed <NUnitOptions>(NUnitExecutionReport) .WithParsed <MsTestOptions>(MsTestExecutionReport) .WithNotParsed(err => Environment.ExitCode = ERROR_BAD_ARGUMENTS); }
static void Main(string[] args) { var options = new Options(); var parser = new Parser(); //If parsing was successful verify either a server is given or the file and receivers are given if (parser.ParseArguments(args, options) && (!string.IsNullOrWhiteSpace(options.Server) || (!string.IsNullOrWhiteSpace(options.File) && options.Clients != null && options.Clients.Any()))) { //If No Server is Given assume Current Box is the Server otherwise process act as if you are a client if (string.IsNullOrWhiteSpace(options.Server)) { var server = new CommandExecutionServer(options.Port, options.Timeout, options.File, options.Arguments, options.Clients, options.UseServer); var result = server.Start(); Console.WriteLine(result ? "Execution Successful! Processes Running." : "An Error Occured while attempting to execute the processes!"); } else { var client = new CommandExecutionClient(options.Port, options.Server); var process = client.Start(); if (process != null) { Console.WriteLine("Process Started!"); process.WaitForExit(); Console.WriteLine("Process Complete!"); } else { Console.WriteLine("Error occured when attempting to execute process!"); } } } else { Console.WriteLine(options.GetUsage()); return; } Console.WriteLine("Press Enter To Close The Console!"); Console.ReadLine(); }
public static void Run(string[] args) { var options = new Options(); var parser = new CommandLine.Parser(s => { s.CaseSensitive = false; s.MutuallyExclusive = true; s.HelpWriter = Console.Out; s.ParsingCulture = System.Globalization.CultureInfo.InvariantCulture; }); if (!parser.ParseArguments(args, options)) { return; } if (options.Folders.Count > 0) { var firstFolder = options.Folders.First(); var collection = new MediaCollection <ConsoleFilm>(firstFolder).Items; if (options.List) { foreach (var film in collection) { Console.WriteLine(String.Format("{0,-3} {1,-9} {2}", film.Rating, film.ImdbId, film.FolderName)); } } if (options.Decorate) { new IconService().ProcessValidFilms(collection, validFilms => Console.WriteLine("Complete! " + validFilms.Count() + " folders have been decorated with icons.")); } if (options.Watch) { new ConsoleFilmProcessingWatcher(firstFolder).InfiniteWait(); } } if (options.RunGui) { GuiApp.Run(); } }
public static void Run(string[] args) { var options = new Options(); var parser = new CommandLine.Parser(s => { s.CaseSensitive = false; s.MutuallyExclusive = true; s.HelpWriter = Console.Out; s.ParsingCulture = System.Globalization.CultureInfo.InvariantCulture; }); if (!parser.ParseArguments(args, options)) { return; } if (options.Folders.Count > 0) { var firstFolder = options.Folders.First(); var collection = new MediaCollection<ConsoleFilm>(firstFolder).Items; if (options.List) { foreach (var film in collection) { Console.WriteLine(String.Format("{0,-3} {1,-9} {2}", film.Rating, film.ImdbId, film.FolderName)); } } if(options.Decorate) { new IconService().ProcessValidFilms(collection, validFilms => Console.WriteLine("Complete! " + validFilms.Count() + " folders have been decorated with icons.")); } if(options.Watch) { new ConsoleFilmProcessingWatcher(firstFolder).InfiniteWait(); } } if (options.RunGui) { GuiApp.Run(); } }
static void Main(string[] args) { var options = new Options(); var parser = new Parser(config => config.HelpWriter = Console.Out); var result = parser.ParseArguments(args, options); if (options.Timeout > 0) { timeout = TimeSpan.FromMilliseconds(options.Timeout); } if (options.MaxRetries > 0) { maxRetries = options.MaxRetries; } RunPackageInstall(options.PackagePath, options.SitecoreUrl); }
public static void Main(string[] cmdLineArgs) { try { var args = new Args(); var parser = new Parser(); if (!parser.ParseArguments(cmdLineArgs, args)) { log.Fatal("Command line args could not be parsed. Exiting the application."); Environment.ExitCode = 1; } else { if (args.ConfigCheck) { VerifyConfiguration(); } else { if (!VerifyConfiguration()) { log.Fatal("The configuration validation failed, exiting the application."); Environment.ExitCode = 2; return; } if (args.RunInConsole) { RunInConsole(); } else { RunAsService(); } } } } catch (Exception ex) { log.Fatal(ex); } }
private FormatOptions Parse(out int result, params string[] args) { result = 1; FormatOptions options = null; var parser = new Parser(settings => { // CommandLine library help output is not thread-safe. We // disable console output entirely by providing a null writer settings.HelpWriter = null; }); result = parser.ParseArguments<FormatOptions>(args) .Return( (FormatOptions parsedOptions) => { options = parsedOptions; return 0; }, errs => ReportErrors(errs)); return options; }
/// <summary> /// Called when the command line tool starts. /// </summary> /// <param name="args">Arguments for the application.</param> static void Main(string[] args) { // Parse the command line options var exitCode = 0; var options = new GlobalOptions(); using (var parser = new Parser(settings => { settings.MutuallyExclusive = true; settings.HelpWriter = Console.Error; })) { if (!parser.ParseArguments(args, options, ExecuteVerb)) { exitCode = Parser.DefaultExitCodeFail; } } // Command line arguments not succesfully parsed #if DEBUG Console.ReadLine(); #endif Environment.Exit(exitCode); }
public static void Main(string[] args) { AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(ExceptionHandler); Printer.PrinterStream printerStream = new Printer.PrinterStream(); Parser parser = new Parser(new Action<ParserSettings>( (ParserSettings p) => { p.CaseSensitive = false; p.IgnoreUnknownArguments = false; p.HelpWriter = printerStream; p.MutuallyExclusive = true; })); Options = new LogrOptions(); if (!parser.ParseArguments(args, Options)) { printerStream.Flush(); Printer.RestoreDefaults(); Environment.Exit(CommandLine.Parser.DefaultExitCodeFail); } Log log = new Log(Options.Repo, Options.LogFile, (Options.Limit > 0) ? Options.Limit : (int?)null); log.Update(); log.Serialize(); }
static void Main(string[] args) { var options = new Options(); var parser = new Parser(config => config.HelpWriter = Console.Out); var result = parser.ParseArguments(args, options); if (options.Timeout > 0) { timeout = TimeSpan.FromMilliseconds(options.Timeout); } if (options.MaxRetries > 0) { maxRetries = options.MaxRetries; } Thread.Sleep(TimeSpan.FromSeconds(30)); RunPublish(options.SitecoreUrl, options.SourceDatabaseName, options.TargetDatabaseNames, options.LanguageNames); }
public static int Main(string[] args) { #if DEBUG args = "-s example.js -w ./world -x 0 -y 4 -z 0".Split(' '); #endif #if !DEBUG try { #endif Options options = new Options(); Parser cmdParser = new Parser(); if (!cmdParser.ParseArguments(args, options)) throw new ArgumentException("Invalid Commandline parameter!"); IntVector3 position = default(IntVector3); if (options.Output) { if (options.PositionY != 0) { position = new IntVector3(); position.x = options.PositionX; position.y = options.PositionY; position.z = options.PositionZ; } } JsScriptExecutor executor = new JsScriptExecutor(); executor.Run(options.LibPath, options.ScriptFile, options.WorldDirectory, position, options.IsSchematic); #if !DEBUG } catch (Exception e) { Console.WriteLine("An Error of type {0} occured!", e.GetType()); Console.WriteLine("Error Message: {0}", e.Message); return 1; } #endif return 0; }
private static void Main(string[] args) { Console.WriteLine("Args: " + string.Join(", ", args)); CommandLine.Parser commandLineParser = new Parser(settings => { settings.HelpWriter = Console.Error; settings.CaseSensitive = false; settings.IgnoreUnknownArguments = true; }); var options = new Options(); if (commandLineParser.ParseArguments(args, options)) { Console.WriteLine("Filename: {0}", options.InputFile); // Values are available here if (options.Verbose) Console.WriteLine("[Verbose] Args: {0}", string.Join(",", args)); } Console.ReadKey(); }
static void Main(string[] args) { var options = new Options(); var parser = new CommandLine.Parser(with => with.HelpWriter = System.Console.Error); if (parser.ParseArguments(args, options)) { if (options.Debug) { utils.Logger.Instance.BasicConfig(); } else { utils.Logger.Instance.XmlConfig(); } utils.Logger.Instance.Log.Info("Program Start"); utils.Logger.Instance.Log.Info("Arg RequestUri: " + options.RequestUri); Run(options); } }
static void Main(string[] args) { var mediator = BuildMediator(); var allTheCommands = (typeof(AddVerb).Assembly.GetTypes().Where(type => (typeof (IRequest).IsAssignableFrom(type)))).ToArray(); var parser = new Parser(with => { with.EnableDashDash = true; with.CaseSensitive = false; with.HelpWriter = System.Console.Out; }); var result = parser.ParseArguments(args, allTheCommands) as Parsed<object>; if (result != null) { mediator.Send((IRequest) result.Value); } else { Environment.Exit(1229); } }