Exemple #1
0
        public static void Main(string[] args)
        {
            ParserResult <Options> result = Parser.Default.ParseArguments <Options>(args);

            if (result.Tag == ParserResultType.NotParsed)
            {
                return;
            }

            var           options = result.MapResult(o => o, xs => new Options());
            BenchmarkType b       = (BenchmarkType)options.Benchmark;

            if (b == BenchmarkType.Ycsb)
            {
                var test = new FASTER_YcsbBenchmark(options.ThreadCount, options.NumaStyle, options.Distribution, options.ReadPercent, options.Backup);
                test.Run();
            }
            else if (b == BenchmarkType.SpanByte)
            {
                var test = new FasterSpanByteYcsbBenchmark(options.ThreadCount, options.NumaStyle, options.Distribution, options.ReadPercent, options.Backup);
                test.Run();
            }
            else if (b == BenchmarkType.ConcurrentDictionaryYcsb)
            {
                var test = new ConcurrentDictionary_YcsbBenchmark(options.ThreadCount, options.NumaStyle, options.Distribution, options.ReadPercent);
                test.Run();
            }
        }
Exemple #2
0
        static void Main(string[] args)
        {
            Console.WriteLine("LYRA Command Line Client");
            Console.WriteLine("Version: " + "0.5.3");

            ParserResult <Options> result = Parser.Default.ParseArguments <Options>(args);

            using (var host = CreateHost())
            {
                host.Start();

                var client = host.Services.GetService <IHostedService>();


                // activate api serivce grain
                // debug test
                var c = client;

                //var gf = host.Services.GetService<IGrainFactory>();
                //var nodeApi = c.Node;

                var wm        = new WalletManager();
                int mapresult = result.MapResult((Options options) => wm.RunWallet(options).Result, _ => CommandLineError());

                if (mapresult != 0)
                {
                    if (mapresult == -2)
                    {
                        Console.WriteLine("Unsupported parameters");
                    }
                }
            }
        }
Exemple #3
0
        static async Task Main(string[] args)
        {
            IConfiguration configuration = new ConfigurationBuilder()
                                           .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                                           .Build();

            CosmosClient client = new CosmosClientBuilder(configuration.GetConnectionString("Cosmos"))
                                  .WithApplicationName("OnDotNetRocks")
                                  .Build();

            await Program.InitializeContainersAsync(client);

            // Parse command line arguments
            ParserResult <CommandLineOptions> result = Parser.Default.ParseArguments <CommandLineOptions>(args);

            try
            {
                await result.MapResult(async options => await Program.ParseOptionsAndRunAsync(options, client), _ => Task.CompletedTask);

                Console.WriteLine("Job's done.");
            }
            catch (ArgumentException exception)
            {
                Console.WriteLine(exception.Message);
                Console.WriteLine("Options: --processor \"<name>\": Starts a processor instance with a particular name.");
                Console.WriteLine("         --estimator: Starts an estimator to watch for changes.");
                Console.WriteLine("         --writer <number>: Starts a writer for a fixed number of documents.");
            }
        }
Exemple #4
0
        private static CommandOptions ParseArguments(string[] args)
        {
            // Parse command line options
            ParserResult <object> parserResult = Parser.Default.ParseArguments <
                ProjectCommandOptions,
                RepositoryCommandOptions,
                PullRequestCommandOptions,
                BuildDefinitionCommandOptions>(args);

            // Map results after parsing
            CommandOptions commandOptions = null;

            parserResult.MapResult <ProjectCommandOptions, RepositoryCommandOptions, PullRequestCommandOptions, BuildDefinitionCommandOptions, object>(
                (ProjectCommandOptions opts) => commandOptions         = opts,
                (RepositoryCommandOptions opts) => commandOptions      = opts,
                (PullRequestCommandOptions opts) => commandOptions     = opts,
                (BuildDefinitionCommandOptions opts) => commandOptions = opts,
                (errs) => 1);

            // Return null if not able to parse
            if (parserResult.Tag == ParserResultType.NotParsed)
            {
                HelpText helpText = HelpText.AutoBuild(parserResult);
                helpText.AddEnumValuesToHelpText = true;
                helpText.AddOptions(parserResult);
                commandOptions = null;
            }

            // Return list of parsed commands
            return(commandOptions);
        }
Exemple #5
0
        static void VarLenServer(string[] args)
        {
            Console.WriteLine("FASTER variable-length KV server");

            ParserResult <Options> result = Parser.Default.ParseArguments <Options>(args);

            if (result.Tag == ParserResultType.NotParsed)
            {
                return;
            }
            var opts = result.MapResult(o => o, xs => new Options());

            opts.GetSettings(out var logSettings, out var checkpointSettings, out var indexSize);

            // Create a new instance of the FasterKV, customized for variable-length blittable data (represented by SpanByte)
            // With SpanByte, keys and values are stored inline in the FASTER log as [ 4 byte length | payload ]
            var store = new FasterKV <SpanByte, SpanByte>(indexSize, logSettings, checkpointSettings);

            if (opts.Recover)
            {
                store.Recover();
            }

            // Create a new server based on above store. You specify additional details such as the serializer (to read and write
            // from and to the wire) and functions (to communicate with FASTER via IFunctions)
            var server = new FasterKVServer <SpanByte, SpanByte, SpanByte, SpanByteAndMemory, SpanByteFunctionsForServer <long>, SpanByteSerializer>
                             (store, wp => new SpanByteFunctionsForServer <long>(wp), opts.Address, opts.Port, new SpanByteSerializer(), default);

            server.Start();
            Console.WriteLine("Started server");
            Thread.Sleep(Timeout.Infinite);
        }
Exemple #6
0
        static void FixedLenServer(string[] args)
        {
            Console.WriteLine("FASTER fixed-length (binary) KV server");

            ParserResult <Options> result = Parser.Default.ParseArguments <Options>(args);

            if (result.Tag == ParserResultType.NotParsed)
            {
                return;
            }
            var opts = result.MapResult(o => o, xs => new Options());

            opts.GetSettings(out var logSettings, out var checkpointSettings, out var indexSize);

            // We use blittable structs Key and Value to construct a costomized server for fixed-length types
            var store = new FasterKV <Key, Value>(indexSize, logSettings, checkpointSettings);

            if (opts.Recover)
            {
                store.Recover();
            }

            // We specify FixedLenSerializer as our in-built serializer for blittable (fixed length) types
            // This server can be used with compatible clients such as FixedLenClient and FASTER.benchmark
            var server = new FasterKVServer <Key, Value, Input, Output, Functions, FixedLenSerializer <Key, Value, Input, Output> >
                             (store, e => new Functions(), opts.Address, opts.Port);

            server.Start();
            Thread.Sleep(Timeout.Infinite);
        }
Exemple #7
0
        private static int ParseFirstArgNotVerb(string[] p_Args, Parser p_Parser)
        {
            // if no verb specified print help message
            if (p_Args.Length == 1)
            {
                List <string> _args = new(p_Args) {
                    "help"
                };
                p_Args = _args.ToArray();
            }

            // Just make verb firts lol
            if (!new List <string>()
            {
                "help", "--help", "version", "--version"
            }.Contains(p_Args[0]))
            {
                string temp = p_Args[0];
                p_Args[0] = p_Args[1];
                p_Args[1] = temp;
            }

            ParserResult <object> result = p_Parser.ParseArguments <BaseOptions, AddOptions, RemoveOptions, RenameOptions, ExtractOptions, ListOptions, CatOptions>(p_Args);

            return(result.MapResult(
                       (AddOptions p_Options) => RunAdd(p_Options),
                       (RemoveOptions p_Options) => RunRemove(p_Options),
                       (RenameOptions p_Options) => RunRename(p_Options),
                       (ExtractOptions p_Options) => RunExtract(p_Options),
                       (ListOptions p_Options) => RunList(p_Options),
                       (CatOptions p_Options) => RunCat(p_Options),
                       p_Errors => DisplayHelp(result)
                       ));
        }
Exemple #8
0
        static int Main(string[] args)
        {
            ParserResult <object> parserResult = Parser.Default.ParseArguments(args, ValidVerbs);
            ReturnCode            retcode      = parserResult.MapResult((VerbBase opts) => opts.RunAsPipe(), errs => ReturnCode.InputError);

            return((int)retcode);
        }
Exemple #9
0
        public static int Run(string[] p_Args)
        {
            Parser parser = new(p_With => {
                p_With.HelpWriter = null;
                p_With.CaseInsensitiveEnumValues = true;
                p_With.CaseSensitive = false;
            });

            // Default parsing with verb as first arg
            ParserResult <object> result = parser.ParseArguments <BaseOptions, AddOptions, RemoveOptions, RenameOptions, ExtractOptions, ListOptions, CatOptions>(p_Args);

            return(result.MapResult(
                       (AddOptions p_Options) => RunAdd(p_Options),
                       (RemoveOptions p_Options) => RunRemove(p_Options),
                       (RenameOptions p_Options) => RunRename(p_Options),
                       (ExtractOptions p_Options) => RunExtract(p_Options),
                       (ListOptions p_Options) => RunList(p_Options),
                       (CatOptions p_Options) => RunCat(p_Options),
                       p_Errors => {
                foreach (Error error in p_Errors)
                {
                    if (error.Tag == ErrorType.BadVerbSelectedError)
                    {
                        return ParseFirstArgNotVerb(p_Args, parser);     // if first arg is not verb it is must be PackedPath
                    }
                }
                return DisplayHelp(result);
            }
                       ));
        }
Exemple #10
0
        /// <summary>
        /// Entry point for the application
        /// </summary>
        /// <param name="args">application arguments</param>
        /// <returns>a task that represents the asynchronous operation</returns>
        private static async Task <int> Main(string[] args)
        {
            ParserResult <object> result = Parser.Default.ParseArguments <SubmitOptions, GetOptions, GetFileBySha256Options>(args);

            try
            {
                await result.MapResult(
                    async (SubmitOptions options) => await SubmitAsync(options),
                    async (GetOptions options) => await GetAsync(options),
                    async (GetFileBySha256Options options) => await GetFileBySha256Async(options),
                    async (IEnumerable <Error> errors) => await HandleErrorsAsync(errors));
            }
            catch (CLIENT.EvaluationServiceException ex)
            {
                await Console.Error.WriteLineAsync($"An error has occurred while calling the Evaluation Service: {ex}");

                return((int)ProgramExitCodes.EvaluationServiceError);
            }
            catch (Exception ex)
            {
                await Console.Error.WriteLineAsync($"An unhandled error has occurred: {ex}");

                return((int)ProgramExitCodes.GenericError);
            }

            return((int)ProgramExitCodes.Ok);
        }
Exemple #11
0
        private static int ParseArgumentsAndExecute(string[] args)
        {
            ParserResult <SynchronizerArguments> parseResult = Parser.Default.ParseArguments <SynchronizerArguments>(args);

            _log.Info($"Parsing program arguments: {String.Join(" ", args)}");
            return(parseResult.MapResult
                   (
                       synchronizerArguments =>
            {
                synchronizerArguments.Validate();

                _log.Info("Initializing injection container");
                Container container = SynchronizerContainerRegistrator.Register();
                container.GetInstance <IServerUri>().Uri = synchronizerArguments.EtcdEndpoint;
                _engine = container.GetInstance <IEngine>();

                _mainTask = Task.Run(() =>
                {
                    _engine.Start();
                    return 0;
                });

                Console.CancelKeyPress += OnExit;
                _closing.WaitOne();

                return _mainTask.Result;
            },
                       notParsedErrors =>
            {
                HandleParseErrors(notParsedErrors.GetEnumerator());
                return -1;
            }
                   ));
        }
Exemple #12
0
        private static void Main(string[] args)
        {
            Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;

            ParserResult <Options> result = Parser.Default.ParseArguments <Options>(args);

            result.MapResult(options => Run(options), _ => 1);
        }
 public static async Task Either <T>(this ParserResult <T> result,
                                     Func <T, Task> parsedFunc,
                                     Func <IEnumerable <Error>, Task> notParsedFunc)
 {
     await result.MapResult(
         async result => await parsedFunc(result),
         async errors => await notParsedFunc(errors));
 }
Exemple #14
0
        static void Main(string[] args)
        {
            Console.CancelKeyPress += (sender, eventArgs) =>
            {
                eventArgs.Cancel = true;
                tokenSource.Cancel();
            };

            ParserResult <Options> parseResults = Parser.Default.ParseArguments <Options>(args);

            options = parseResults.MapResult(
                parsed => parsed,
                notParsed =>
            {
                return(default(Options));
            });

            if (options == default(Options))
            {
                return;
            }

            if (options.csvoutput != null)
            {
                //Create CSV file and write header row.
                csvFile = new CSVFile(options.csvoutput);

                var columnlist = new List <string>
                {
                    "Message#",
                    "Date Time",
                    "Routing Key",
                    "Exchange",
                    "Body"
                };

                csvFile.WriteRow(columnlist);

                var connectionString = options.AMQP;

                Console.WriteLine("Trace is running. Ctrl-C to exit");

                HandleDelivery();
                try
                {
                    using (ConnectAndSubscribe(connectionString))
                    {
                        tokenSource.Token.WaitHandle.WaitOne();
                    }

                    Console.WriteLine("Shutdown");
                }
                catch (Exception e)
                {
                    Console.Out.WriteLine(e.Message);
                }
            }
        }
 public static JObject MapOk <T1>(ParserResult <T1> result)
 {
     return(result.MapResult(variablesObj => JObject.FromObject(variablesObj, JsonSerializer.Create(new JsonSerializerSettings {
         NullValueHandling = NullValueHandling.Ignore
     })),
                             errors => {
         Console.WriteLine($"Failed to read parameterObj: {string.Join(",", errors)} "); return null;
     }));
 }
Exemple #16
0
        private static int Main(string[] args)
        {
            ParserResult <object> result = Parser.Default.ParseArguments <ParseOptions, ShellOptions>(args);

            return(result.MapResult(
                       (ParseOptions opts) => RunMain(opts),
                       (ShellOptions opts) => RunShell(opts),
                       errs => 1));
        }
Exemple #17
0
        internal bool Parse(string[] args)
        {
            ParserResult <Options> result = Parser.Default.ParseArguments <Options>(args);

            if (result.Tag == ParserResultType.NotParsed)
            {
                return(false);
            }
            Options = result.MapResult(o => o, xs => new Options());
Exemple #18
0
        private static async Task <int> Main(string[] args)
        {
            result = Parser.Default.ParseArguments <DeployWithSlotOptions, DeployInplaceOptions>(args);

            return(await result.MapResult(
                       async (DeployWithSlotOptions opts) => await Run(opts),
                       async (DeployInplaceOptions opts) => await Run(opts),
                       async errs => await HandleParseErrorAsync(errs)));
        }
Exemple #19
0
        public string Process(string[] args)
        {
            ParserResult <PredictOption> parsedResult = Parser.Default.ParseArguments <PredictOption>(args);
            string result = parsedResult.MapResult(
                opts => HandlePredictCommand(opts),
                errors => ShowError(errors)
                );

            return(result);
        }
Exemple #20
0
        internal TestLoader(string[] args)
        {
            error = true;
            ParserResult <Options> result = Parser.Default.ParseArguments <Options>(args);

            if (result.Tag == ParserResultType.NotParsed)
            {
                return;
            }
            Options = result.MapResult(o => o, xs => new Options());
Exemple #21
0
        // Using EF Core                - for interfacing with data
        //   with: Npgsql               - for default data storage
        //   with: InMemoryDatabase     - for unit testing
        //   with: FileContextCore      - for feature parity
        // Using MSTest                 - for unit testing
        // Using CommandLine            - for parsing command line args
        static int Main(string[] args)
        {
            // Valid contexts are: Remote (PostgreSQL) or Local (local JSON file)
            DbContextOptions <BordsContext> options = DataContexts.Local;

            using BordsContext db = new BordsContext(options);
            BoardLib lib = new BoardLib(db);

            // Parse and perform command
            ParserResult <object> parsedArguments = Parser.Default.ParseArguments <
                ListOptions,
                NewTaskOptions,
                DeleteTaskOptions,
                CheckTaskOptions,
                MoveTaskOptions,
                EditTaskOptions,
                PrioritizeTaskOptions>(args);

            try
            {
                bool GracefullyExecuted = parsedArguments
                                          .MapResult(
                    (ListOptions opts) => true,
                    (NewTaskOptions opts) => (
                        (opts.Boardname == null) ? lib.CreateTask(opts.Description, opts.Priority) : lib.CreateTask(opts.Boardname, opts.Description, opts.Priority)
                        ) is Task ? true : false,
                    (DeleteTaskOptions opts) => lib.DeleteTask(opts.TaskId) is Task ? true : false,
                    (CheckTaskOptions opts) => lib.ToggleTaskComplete(opts.TaskId) is Task ? true : false,
                    (MoveTaskOptions opts) => lib.MoveTask(opts.TaskId, opts.DestinationBoard) is Task ? true : false,
                    (EditTaskOptions opts) => lib.DescribeTask(opts.TaskId, opts.NewDescription) is Task ? true : false,
                    (PrioritizeTaskOptions opts) => lib.PrioritizeTask(opts.TaskId, opts.NewPriority) is Task ? true : false,
                    errs => false);

                lib.CleanupEmptyBoards();
                lib.PrintAll();

                return(GracefullyExecuted ? 0 : 1);
            }
            catch (Exception ex)
            {
                if (ex is BadTaskIdException)
                {
                    Console.WriteLine("A Task with that ID was not found");
                }
                else if (ex is PriorityOutOfBoundsException)
                {
                    Console.WriteLine("Priority must be an integer of 1, 2, or 3");
                }
                else
                {
                    throw ex;
                }
                return(1);
            }
        }
        public static IndexerParameters ParseCommandLine(IEnumerable <string> args)
        {
            ParserResult <IndexerParameters> res = Parser.Default.ParseArguments <IndexerParameters>(args);
            IndexerParameters result             = res.MapResult(options => {
                return(options);
            }, errors => {
                return(null);
            });

            return(result);
        }
Exemple #23
0
 public async static Task Main(string[] args)
 {
     Parser parser = new Parser(config => { config.CaseInsensitiveEnumValues = true; });
     ParserResult <CommandLineOptions> parserResult = parser.ParseArguments <CommandLineOptions>(args);
     await parserResult.MapResult(
         options =>
     {
         Generate(options);
         return(Task.CompletedTask);
     },
         (_) => Task.CompletedTask)
     .ConfigureAwait(true);
 }
Exemple #24
0
 public static async Task <int> MapResult(
     this ParserResult <object> result,
     Func <SyncOpts, Task <int> > parsedSync,
     Func <PrintOpts, Task <int> > parsedPrint,
     Func <ReadOpts, Task <int> > parsedRead,
     Func <ListOpts, Task <int> > parsedList,
     Func <NotParsed <object>, Task <int> > notParsed)
 => await result.MapResult(
     parsedSync,
     parsedPrint,
     parsedRead,
     parsedList,
     notParsedFunc : _ => notParsed((NotParsed <object>)result));
Exemple #25
0
        static int Main(string[] args)
        {
            ParserResult <object> operation = Parser.Default
                                              .ParseArguments <ExtractWikiDbOperation, GenerateDictionaryOperation, QueryDictionaryOperation, SummarizeDictionaryOperation, CleanDictionaryOperation>(args);

            return(operation.MapResult(
                       (ExtractWikiDbOperation op) => op.Extract(),
                       (GenerateDictionaryOperation op) => op.Generate(),
                       (QueryDictionaryOperation op) => op.Query(),
                       (SummarizeDictionaryOperation op) => op.Summarize(),
                       (CleanDictionaryOperation op) => op.Clean(),
                       _ => 1));
        }
Exemple #26
0
 public string GetParseResult(params string[] args)
 {
     using (Parser parser = CreateParser())
     {
         ParserResult <object> result = parser.ParseVerbs(
             args, dynamicVerbFactory, typeof(BuildVerb), typeof(GenerateVerb), typeof(GetVerb),
             typeof(SetVerb), typeof(UpdateVerb), typeof(InstallVerb),
             typeof(ScanSdksVerb),
             typeof(ShowLogVerb), typeof(MigrateCliVerb));
         return(result
                .MapResult((object verb) => ConvertToString(verb),
                           (errors) => ConvertError(result)));
     }
 }
        private static void Main(string[] args)
        {
            // Initializing
            string executablePath = (Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly()).Location;
            string location       = executablePath;

            if (string.IsNullOrEmpty(location))
            {
                location = Environment.GetCommandLineArgs().FirstOrDefault();
            }

            RunnerFolder = Path.GetDirectoryName(location);

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                Platform = Platform.Windows;
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                Platform = Platform.Linux;
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                Platform = Platform.MacOS;
            }
            else
            {
                Console.Error.WriteLine("The current platform is not supported. Supported platforms are: Windows, Linux and MacOS.");
                Environment.Exit(-1);
                return;
            }

            // ***

            Console.CancelKeyPress += Console_CancelKeyPress;
            AppDomain.CurrentDomain.ProcessExit  += CurrentDomain_ProcessExit;
            AppDomain.CurrentDomain.DomainUnload += CurrentDomain_ProcessExit;

            Parser parser = new Parser(settings =>
            {
                settings.AutoHelp       = true;
                settings.AutoVersion    = true;
                settings.EnableDashDash = true;
                settings.HelpWriter     = null;
            });

            ParserResult <Options> result = parser.ParseArguments <Options>(args);

            result.MapResult(ParsedOptions, errors => ParsedErrors(result, errors));
        }
Exemple #28
0
        public static async Task <int> Run(this Parser parser, string[] args, params Type[] jobTypes)
        {
            Dictionary <Type, Type> dict = new Dictionary <Type, Type>();

            foreach (var jobType in jobTypes)
            {
                if (jobType.TryGetClosedGenericType(typeof(IUtility <>), out Type genericType))
                {
                    Type optionType = genericType.GetGenericArguments().First();
                    dict.Add(optionType, jobType);
                }
            }
            ParserResult <Object> parserResult = parser.ParseArguments(args, dict.Keys.ToArray());

            return(await parserResult.MapResult <object, Task <int> >(async opt => await RunAsync(opt, dict), err => Task.FromResult(1)));
        }
Exemple #29
0
        public static T Parse <T>(T defaults, string[] args, out int exitCode) where T : CommandLineOptions
        {
            T options = defaults;

            // parse command line: we can't use the simple form of this because we need to display
            // help ourselves as the library just prints help to the console which we don't see
            ParserResult <T> result = Parser.Default.ParseArguments <T>(args);

            exitCode = result.MapResult(success =>
            {
                options = success;
                return(0);
            },
                                        errors => HandleCommandLineErrors(result, errors));
            return(options);
        }
        public static int Execute(this ParserResult <object> options, IServiceProvider provider)
        {
            int Execute <T1, T2>(T2 o) where T1 : ICommand <T2>
            {
                return(provider.GetRequiredService <T1>().Execute(o));
            };

            // #3: Execute the correct command based on the arguments
            return(options.MapResult(
                       (GetDocumentsCommand.Options o) => Execute <GetDocumentsCommand, GetDocumentsCommand.Options>(o),
                       (CreateIndexCommand.Options o) => Execute <CreateIndexCommand, CreateIndexCommand.Options>(o),
                       (DeleteIndexCommand.Options o) => Execute <DeleteIndexCommand, DeleteIndexCommand.Options>(o),
                       (IndexExistsCommand.Options o) => Execute <IndexExistsCommand, IndexExistsCommand.Options>(o),
                       (UpdateDocumentsCommand.Options o) => Execute <UpdateDocumentsCommand, UpdateDocumentsCommand.Options>(o),
                       errs => 1
                       ));
        }