Esempio n. 1
0
        public void ApplyTo(ConsoleCommand command)
        {
            command.HasOption("e=", "Endpoint url used for requests.", v => Endpoint = v);

            Credentials = new ApiCredentialParameters();
            Credentials.ApplyTo(command);
        }
Esempio n. 2
0
 public void AddXmlRpcLogin(ConsoleCommand command)
 {
     command.HasOption("rpc=",
                       "Url of wordpress XML-RPC endpoint (example: http://joeblogstest.alexjamesbrown.com/xmlrpc.php)",
                       v => XmlRpcUrl = v);
     command.HasOption("u=", "Username", v => Username = v);
     command.HasOption("p=", "Password", v => Password = v);
 }
        public void ApplyTo(ConsoleCommand command)
        {
            FindAndLoadCredentialsIfAvailable();

            if (string.IsNullOrEmpty(Username))
            {
                ApplyWithoutCheckingFile(command);
            }
            else
            {
                command.HasOption("u=", string.Format("Username (default is {0})", Username), v => Username = v);
                command.HasOption("s=", string.Format("Secret key (default is for {0})", Username), v => Secret = v);
            }
        }
Esempio n. 4
0
        static int Main(string[] args)
        {
            #if x64
            if (!Environment.Is64BitProcess)
                throw new Exception("This runner is expected to run 64bit");
            #endif

            var commands = new ConsoleCommand[]
                               {
                                   new RunAloneCommand(),
                                   new RunSatelliteCommand(),
                               };

            return ConsoleCommandDispatcher.DispatchCommand(commands, args, Console.Out);
        }
 private static bool CommandMatchesArgument(ConsoleCommand command, string arg)
 {
     if (String.IsNullOrEmpty(arg))
     {
         return(false);
     }
     if (arg.Equals(command.Command, StringComparison.OrdinalIgnoreCase))
     {
         return(true);
     }
     else if (command.Aliases != null && command.Aliases.Count > 0)
     {
         foreach (string alias in command.Aliases)
         {
             if (arg.Equals(alias, StringComparison.OrdinalIgnoreCase))
             {
                 return(true);
             }
         }
     }
     return(false);
 }
        public static int DispatchCommand(IEnumerable <ConsoleCommand> commands, string[] arguments, TextWriter consoleOut, bool skipExeInExpectedUsage = false)
        {
            ConsoleCommand selectedCommand = null;

            TextWriter console = consoleOut;

            IEnumerable <ConsoleCommand> consoleCommands = commands as ConsoleCommand[] ?? commands.ToArray();

            foreach (var command in consoleCommands)
            {
                ValidateConsoleCommand(command);
            }

            try
            {
                List <string> remainingArguments;

                if (consoleCommands.Count() == 1)
                {
                    selectedCommand = consoleCommands.First();

                    if (arguments.Any() && (arguments.First().ToLower() == selectedCommand.Command.ToLower()))
                    {
                        remainingArguments = selectedCommand.GetActualOptions().Parse(arguments.Skip(1));
                    }
                    else
                    {
                        remainingArguments = selectedCommand.GetActualOptions().Parse(arguments);
                    }
                }
                else
                {
                    if (!arguments.Any())
                    {
                        throw new ConsoleHelpAsException("No arguments specified.");
                    }

                    if (arguments[0].Equals("help", StringComparison.InvariantCultureIgnoreCase))
                    {
                        selectedCommand = GetMatchingCommand(consoleCommands, arguments.Skip(1).FirstOrDefault());

                        if (selectedCommand == null)
                        {
                            ConsoleHelp.ShowSummaryOfCommands(consoleCommands, console);
                        }
                        else
                        {
                            ConsoleHelp.ShowCommandHelp(selectedCommand, console, skipExeInExpectedUsage);
                        }

                        return(-1);
                    }

                    selectedCommand = GetMatchingCommand(consoleCommands, arguments.First());

                    if (selectedCommand == null)
                    {
                        throw new ConsoleHelpAsException("Command name not recognized.");
                    }

                    remainingArguments = selectedCommand.GetActualOptions().Parse(arguments.Skip(1));
                }

                selectedCommand.CheckRequiredArguments();

                CheckRemainingArguments(remainingArguments, selectedCommand.RemainingArgumentsCount);

                var preResult = selectedCommand.OverrideAfterHandlingArgumentsBeforeRun(remainingArguments.ToArray());

                if (preResult.HasValue)
                {
                    return(preResult.Value);
                }

                ConsoleHelp.ShowParsedCommand(selectedCommand, console);

                return(selectedCommand.Run(remainingArguments.ToArray()));
            }
            catch (ConsoleHelpAsException e)
            {
                return(DealWithException(e, console, skipExeInExpectedUsage, selectedCommand, consoleCommands));
            }
            catch (NDesk.Options.OptionException e)
            {
                return(DealWithException(e, console, skipExeInExpectedUsage, selectedCommand, consoleCommands));
            }
        }
 public static int DispatchCommand(ConsoleCommand command, string[] arguments, TextWriter consoleOut)
 {
     return(DispatchCommand(new [] { command }, arguments, consoleOut));
 }
        private static int DealWithException(Exception e, TextWriter console, bool skipExeInExpectedUsage, ConsoleCommand selectedCommand, IEnumerable <ConsoleCommand> commands)
        {
            if (selectedCommand != null)
            {
                console.WriteLine();
                console.WriteLine(e.Message);
                ConsoleHelp.ShowCommandHelp(selectedCommand, console, skipExeInExpectedUsage);
            }
            else
            {
                ConsoleHelp.ShowSummaryOfCommands(commands, console);
            }

            return(-1);
        }
 public void ApplyWithoutCheckingFile(ConsoleCommand command)
 {
     command.HasRequiredOption("u=", "Username", v => Username = v);
     command.HasRequiredOption("s=", "Secret key", v => Secret = v);
 }
Esempio n. 10
0
        public static int DispatchCommand(IEnumerable <ConsoleCommand> commands, string[] arguments, TextWriter consoleOut)
        {
            ConsoleCommand selectedCommand = null;

            TextWriter console = consoleOut;

            try
            {
                List <string> remainingArguments;

                if (commands.Count() == 1)
                {
                    selectedCommand = commands.First();

                    CheckCommandProperty(selectedCommand);

                    if (arguments.Count() > 0 && arguments.First().ToLower() == selectedCommand.Command.ToLower())
                    {
                        remainingArguments = selectedCommand.Options.Parse(arguments.Skip(1));
                    }
                    else
                    {
                        remainingArguments = selectedCommand.Options.Parse(arguments);
                    }
                }
                else
                {
                    if (arguments.Count() < 1)
                    {
                        throw new ConsoleHelpAsException("No arguments specified.");
                    }

                    foreach (var possibleCommand in commands)
                    {
                        CheckCommandProperty(possibleCommand);

                        if (arguments.First().ToLower() == possibleCommand.Command.ToLower())
                        {
                            selectedCommand = possibleCommand;

                            break;
                        }
                    }

                    if (selectedCommand == null)
                    {
                        throw new ConsoleHelpAsException("Command name not recognized.");
                    }

                    remainingArguments = selectedCommand.Options.Parse(arguments.Skip(1));
                }

                CheckRequiredArguments(selectedCommand);

                CheckRemainingArguments(remainingArguments, selectedCommand.RemainingArgumentsCount);

                ConsoleHelp.ShowParsedCommand(selectedCommand, console);

                return(selectedCommand.Run(remainingArguments.ToArray()));
            }
            catch (Exception e)
            {
                if (!ConsoleHelpAsException.WriterErrorMessage(e, console))
                {
                    throw;
                }

                console.WriteLine();

                if (selectedCommand != null)
                {
                    if (e is ConsoleHelpAsException || e is NDesk.Options.OptionException)
                    {
                        ConsoleHelp.ShowCommandHelp(selectedCommand, console);
                    }
                }
                else
                {
                    ConsoleHelp.ShowSummaryOfCommands(commands, console);
                }

                return(-1);
            }
        }
 private static void ValidateConsoleCommand(ConsoleCommand command)
 {
     if (string.IsNullOrEmpty(command.Command))
     {
         throw new InvalidOperationException(String.Format(
             "Command {0} did not call IsCommand in its constructor to indicate its name and description.",
             command.GetType().Name));
     }
 }
 public static int DispatchCommand(ConsoleCommand command, string[] arguments, TextWriter consoleOut)
 {
     return DispatchCommand(new [] {command}, arguments, consoleOut);
 }
        private static int DealWithException(Exception e, TextWriter console, bool skipExeInExpectedUsage, ConsoleCommand selectedCommand, IEnumerable<ConsoleCommand> commands)
        {
            if (selectedCommand != null)
            {
                console.WriteLine();
                console.WriteLine(e.Message);
                ConsoleHelp.ShowCommandHelp(selectedCommand, console, skipExeInExpectedUsage);
            }
            else
            {
                ConsoleHelp.ShowSummaryOfCommands(commands, console);
            }

            return -1;
        }
Esempio n. 14
0
        private static (ConsoleCommand, string[], int?) GetSelectedCommand(IEnumerable <ConsoleCommand> commands, string[] arguments, TextWriter consoleOut, bool skipExeInExpectedUsage = false)
        {
            ConsoleCommand selectedCommand = null;
            List <string>  remainingArguments;

            TextWriter console = consoleOut;

            foreach (var command in commands)
            {
                ValidateConsoleCommand(command);
            }

            try
            {
                if (commands.Count() == 1)
                {
                    selectedCommand = commands.First();

                    if (arguments.Count() > 0 && CommandMatchesArgument(selectedCommand, arguments.First()))
                    {
                        remainingArguments = selectedCommand.GetActualOptions().Parse(arguments.Skip(1));
                    }
                    else
                    {
                        remainingArguments = selectedCommand.GetActualOptions().Parse(arguments);
                    }
                }
                else
                {
                    if (arguments.Count() < 1)
                    {
                        throw new ConsoleHelpAsException("No arguments specified.");
                    }

                    if (arguments[0].Equals("help", StringComparison.InvariantCultureIgnoreCase))
                    {
                        selectedCommand = GetMatchingCommand(commands, arguments.Skip(1).FirstOrDefault());

                        if (selectedCommand == null)
                        {
                            ConsoleHelp.ShowSummaryOfCommands(commands, console);
                        }
                        else
                        {
                            ConsoleHelp.ShowCommandHelp(selectedCommand, console, skipExeInExpectedUsage);
                        }

                        return(null, null, -1);
                    }

                    selectedCommand = GetMatchingCommand(commands, arguments.First());

                    if (selectedCommand == null)
                    {
                        throw new ConsoleHelpAsException("Command name not recognized.");
                    }

                    remainingArguments = selectedCommand.GetActualOptions().Parse(arguments.Skip(1));
                }

                selectedCommand.CheckRequiredArguments();

                CheckRemainingArguments(remainingArguments, selectedCommand.RemainingArgumentsCountMin, selectedCommand.RemainingArgumentsCountMax);

                var preResult = selectedCommand.OverrideAfterHandlingArgumentsBeforeRun(remainingArguments.ToArray());

                if (preResult.HasValue)
                {
                    return(null, null, preResult);
                }

                ConsoleHelp.ShowParsedCommand(selectedCommand, console);
                return(selectedCommand, remainingArguments.ToArray(), null);
            }
            catch (ConsoleHelpAsException e)
            {
                return(null, null, DealWithException(e, console, skipExeInExpectedUsage, selectedCommand, commands));
            }
            catch (Mono.Options.OptionException e)
            {
                return(null, null, DealWithException(e, console, skipExeInExpectedUsage, selectedCommand, commands));
            }
        }
Esempio n. 15
0
 public static Task <int> DispatchCommandAsync(ConsoleCommand command, string[] arguments, TextWriter consoleOut)
 {
     return(DispatchCommandAsync(new[] { command }, arguments, consoleOut));
 }