static void Main(string[] args) { CloudAdmin admin = new CloudAdmin(); admin.SetPrompt("cloudb> "); admin.Interrupted += new EventHandler(CloudAdminInterrupted); Options options = new Options(); admin.RegisterOptions(options); ICommandLineParser parser = new GnuParser(options); CommandLine commandLine = null; try { commandLine = parser.Parse(args); } catch (Exception e) { System.Console.Error.WriteLine("Error while parsing arguments: {0}", e.Message); Environment.Exit(1); } admin.HandleCommandLine(commandLine); try { admin.Run(); } catch (Exception) { admin.Shutdown(); } }
/// <exception cref="System.Exception"/> public static void Main(string[] argv) { CommandLine cliParser = new GnuParser().Parse(opts, argv); if (cliParser.HasOption("put")) { string path = cliParser.GetOptionValue("put"); if (path != null && path.Length > 0) { if (cliParser.HasOption(EntityDataType)) { PutTimelineDataInJSONFile(path, EntityDataType); return; } else { if (cliParser.HasOption(DomainDataType)) { PutTimelineDataInJSONFile(path, DomainDataType); return; } } } } PrintUsage(); }
public virtual int Mknode(string[] args) { Options mknodeOption = new Options(); CommandLineParser parser = new GnuParser(); try { CommandLine line = parser.Parse(mknodeOption, args); IList <string> argsList = line.GetArgList(); if (argsList.Count != 2) { return(UsageError("mknode requires exactly one path argument", MknodeUsage)); } if (!ValidatePath(argsList[1])) { return(-1); } try { registry.Mknode(args[1], false); return(0); } catch (Exception e) { syserr.WriteLine(AnalyzeException("mknode", e, argsList)); } return(-1); } catch (ParseException exp) { return(UsageError("Invalid syntax " + exp.ToString(), MknodeUsage)); } }
/// <exception cref="System.Exception"/> public static void Main(string[] args) { CommandLine cmd = new GnuParser().Parse(opts, args); if (cmd.HasOption("help")) { new HelpFormatter().PrintHelp("Usage: hbgen [OPTIONS]", opts); return; } // defaults Type specClass = typeof(HamletSpec); Type implClass = typeof(HamletImpl); string outputClass = "HamletTmp"; string outputPackage = implClass.Assembly.GetName(); if (cmd.HasOption("spec-class")) { specClass = Sharpen.Runtime.GetType(cmd.GetOptionValue("spec-class")); } if (cmd.HasOption("impl-class")) { implClass = Sharpen.Runtime.GetType(cmd.GetOptionValue("impl-class")); } if (cmd.HasOption("output-class")) { outputClass = cmd.GetOptionValue("output-class"); } if (cmd.HasOption("output-package")) { outputPackage = cmd.GetOptionValue("output-package"); } new HamletGen().Generate(specClass, implClass, outputClass, outputPackage); }
internal static IDictionary <URI, IList <Path> > GetNameNodePathsToMove(Configuration conf, params string[] args) { Options opts = BuildCliOptions(); CommandLineParser parser = new GnuParser(); CommandLine commandLine = parser.Parse(opts, args, true); return(GetNameNodePaths(commandLine, conf)); }
public void Parse(string[] args) { ParseHelp(args); Servers = new List<TeamCityServer>(); var commandLine = new GnuParser().Parse(_options, args); ComPort = commandLine.GetOptionValue(Port); Console.WriteLine("Using port: " + ComPort); RunTimeMinutes = int.Parse(commandLine.GetOptionValue(RunTime)); Console.WriteLine(String.Format("Running for {0} minutes", RunTimeMinutes)); ParseServers(args); }
public void Parse(string[] args) { ParseHelp(args); Servers = new List <TeamCityServer>(); var commandLine = new GnuParser().Parse(_options, args); ComPort = commandLine.GetOptionValue(Port); Console.WriteLine("Using port: " + ComPort); RunTimeMinutes = int.Parse(commandLine.GetOptionValue(RunTime)); Console.WriteLine(String.Format("Running for {0} minutes", RunTimeMinutes)); ParseServers(args); }
/// <summary>Parses arguments and fills out the member variables.</summary> /// <param name="args">Command-line arguments.</param> /// <returns> /// true on successful parse; false to indicate that the /// program should exit. /// </returns> private bool ParseArguments(string[] args) { Options options = MakeOptions(); CommandLine cli; try { CommandLineParser parser = new GnuParser(); cli = parser.Parse(options, args); } catch (ParseException e) { Log.Warn("options parsing failed: " + e.Message); new HelpFormatter().PrintHelp("...", options); return(false); } if (cli.HasOption("help")) { new HelpFormatter().PrintHelp("...", options); return(false); } if (cli.GetArgs().Length > 0) { foreach (string arg in cli.GetArgs()) { Log.Error("Unrecognized option: " + arg); new HelpFormatter().PrintHelp("...", options); return(false); } } // HDFS numDataNodes = IntArgument(cli, "datanodes", 1); nameNodePort = IntArgument(cli, "nnport", 0); if (cli.HasOption("format")) { dfsOpts = HdfsServerConstants.StartupOption.Format; format = true; } else { dfsOpts = HdfsServerConstants.StartupOption.Regular; format = false; } // Runner writeDetails = cli.GetOptionValue("writeDetails"); writeConfig = cli.GetOptionValue("writeConfig"); // General conf = new HdfsConfiguration(); UpdateConfiguration(conf, cli.GetOptionValues("D")); return(true); }
/// <summary>Parses arguments and fills out the member variables.</summary> /// <param name="args">Command-line arguments.</param> /// <returns> /// true on successful parse; false to indicate that the program should /// exit. /// </returns> private bool ParseArguments(string[] args) { Options options = MakeOptions(); CommandLine cli; try { CommandLineParser parser = new GnuParser(); cli = parser.Parse(options, args); } catch (ParseException e) { Log.Warn("options parsing failed: " + e.Message); new HelpFormatter().PrintHelp("...", options); return(false); } if (cli.HasOption("help")) { new HelpFormatter().PrintHelp("...", options); return(false); } if (cli.GetArgs().Length > 0) { foreach (string arg in cli.GetArgs()) { System.Console.Error.WriteLine("Unrecognized option: " + arg); new HelpFormatter().PrintHelp("...", options); return(false); } } // MR noMR = cli.HasOption("nomr"); numNodeManagers = IntArgument(cli, "nodemanagers", 1); rmPort = IntArgument(cli, "rmport", 0); jhsPort = IntArgument(cli, "jhsport", 0); fs = cli.GetOptionValue("namenode"); // HDFS noDFS = cli.HasOption("nodfs"); numDataNodes = IntArgument(cli, "datanodes", 1); nnPort = IntArgument(cli, "nnport", 0); dfsOpts = cli.HasOption("format") ? HdfsServerConstants.StartupOption.Format : HdfsServerConstants.StartupOption .Regular; // Runner writeDetails = cli.GetOptionValue("writeDetails"); writeConfig = cli.GetOptionValue("writeConfig"); // General conf = new JobConf(); UpdateConfiguration(conf, cli.GetOptionValues("D")); return(true); }
/// <exception cref="System.Exception"/> public override int Run(string[] args) { Options opts = new Options(); opts.AddOption("lnl", ListLabelsCmd, false, "List cluster node-label collection"); opts.AddOption("h", HelpCmd, false, "Displays help for all commands."); opts.AddOption("dnl", DirectlyAccessNodeLabelStore, false, "Directly access node label store, " + "with this option, all node label related operations" + " will NOT connect RM. Instead, they will" + " access/modify stored node labels directly." + " By default, it is false (access via RM)." + " AND PLEASE NOTE: if you configured " + YarnConfiguration.FsNodeLabelsStoreRootDir + " to a local directory" + " (instead of NFS or HDFS), this option will only work" + " when the command run on the machine where RM is running." + " Also, this option is UNSTABLE, could be removed in future" + " releases."); int exitCode = -1; CommandLine parsedCli = null; try { parsedCli = new GnuParser().Parse(opts, args); } catch (MissingArgumentException) { sysout.WriteLine("Missing argument for options"); PrintUsage(opts); return(exitCode); } if (parsedCli.HasOption(DirectlyAccessNodeLabelStore)) { accessLocal = true; } if (parsedCli.HasOption(ListLabelsCmd)) { PrintClusterNodeLabels(); } else { if (parsedCli.HasOption(HelpCmd)) { PrintUsage(opts); return(0); } else { syserr.WriteLine("Invalid Command Usage : "); PrintUsage(opts); } } return(0); }
private void ParseHelp(string[] args) { var options = new Options(); options.AddOption(_helpOption); options.AddOption(OptionBuilder.Factory.Create(Port)); options.AddOption(OptionBuilder.Factory.Create(RunTime)); options.AddOption(OptionBuilder.Factory.Create(Server)); var commandLine = new GnuParser().Parse(options, args); if (commandLine.HasOption(Help) || args.Length == 0) { ShowHelp(); } }
public virtual int Resolve(string[] args) { Options resolveOption = new Options(); CommandLineParser parser = new GnuParser(); try { CommandLine line = parser.Parse(resolveOption, args); IList <string> argsList = line.GetArgList(); if (argsList.Count != 2) { return(UsageError("resolve requires exactly one path argument", ResolveUsage)); } if (!ValidatePath(argsList[1])) { return(-1); } try { ServiceRecord record = registry.Resolve(argsList[1]); foreach (Endpoint endpoint in record.external) { sysout.WriteLine(" Endpoint(ProtocolType=" + endpoint.protocolType + ", Api=" + endpoint .api + ");" + " Addresses(AddressType=" + endpoint.addressType + ") are: "); foreach (IDictionary <string, string> address in endpoint.addresses) { sysout.WriteLine("[ "); foreach (KeyValuePair <string, string> entry in address) { sysout.Write("\t" + entry.Key + ":" + entry.Value); } sysout.WriteLine("\n]"); } sysout.WriteLine(); } return(0); } catch (Exception e) { syserr.WriteLine(AnalyzeException("resolve", e, argsList)); } return(-1); } catch (ParseException exp) { return(UsageError("Invalid syntax " + exp, ResolveUsage)); } }
private void ParseServers(string[] args) { var parser = new GnuParser(); var serverOptions = new Options(); serverOptions.AddOption(_serverOption); for (int i = 0; i < args.Length; i++) { if (args[i] != "-" + Server || i + 1 >= args.Length) { continue; } var currentLine = parser.Parse(serverOptions, new[] { args[i], args[i + 1] }); AddServer(currentLine.GetOptionValues(Server)); } }
/// <summary> /// Parse the user-specified options, get the generic options, and modify /// configuration accordingly /// </summary> /// <param name="opts">Options to use for parsing args.</param> /// <param name="conf">Configuration to be modified</param> /// <param name="args">User-specified arguments</param> /// <exception cref="System.IO.IOException"/> private void ParseGeneralOptions(Options opts, Configuration conf, string[] args) { opts = BuildGeneralOptions(opts); CommandLineParser parser = new GnuParser(); try { commandLine = parser.Parse(opts, PreProcessForWindows(args), true); ProcessGeneralOptions(conf, commandLine); } catch (ParseException e) { Log.Warn("options parsing failed: " + e.Message); HelpFormatter formatter = new HelpFormatter(); formatter.PrintHelp("general options are: ", opts); } }
/// <summary>parse args</summary> /// <exception cref="System.ArgumentException"/> private static CommandLine ParseArgs(Options opts, params string[] args) { OptionBuilder.WithArgName("NameNode|DataNode"); OptionBuilder.HasArg(); OptionBuilder.WithDescription("specify jmx service (NameNode by default)"); Option jmx_service = OptionBuilder.Create("service"); OptionBuilder.WithArgName("mbean server"); OptionBuilder.HasArg(); OptionBuilder.WithDescription("specify mbean server (localhost by default)"); Option jmx_server = OptionBuilder.Create("server"); OptionBuilder.WithDescription("print help"); Option jmx_help = OptionBuilder.Create("help"); OptionBuilder.WithArgName("mbean server port"); OptionBuilder.HasArg(); OptionBuilder.WithDescription("specify mbean server port, " + "if missing - it will try to connect to MBean Server in the same VM" ); Option jmx_port = OptionBuilder.Create("port"); OptionBuilder.WithArgName("VM's connector url"); OptionBuilder.HasArg(); OptionBuilder.WithDescription("connect to the VM on the same machine;" + "\n use:\n jstat -J-Djstat.showUnsupported=true -snap <vmpid> | " + "grep sun.management.JMXConnectorServer.address\n " + "to find the url"); Option jmx_localVM = OptionBuilder.Create("localVM"); opts.AddOption(jmx_server); opts.AddOption(jmx_help); opts.AddOption(jmx_service); opts.AddOption(jmx_port); opts.AddOption(jmx_localVM); CommandLine commandLine = null; CommandLineParser parser = new GnuParser(); try { commandLine = parser.Parse(opts, args, true); } catch (ParseException e) { PrintUsage(opts); throw new ArgumentException("invalid args: " + e.Message); } return(commandLine); }
private MyOptions(string[] args) { try { Options opts = BuildOptions(); CommandLineParser parser = new GnuParser(); CommandLine line = parser.Parse(opts, args, true); ProcessOptions(line, opts); ValidateOptions(); } catch (ParseException e) { System.Console.Error.WriteLine(e.Message); System.Console.Error.WriteLine("Try \"--help\" option for details."); failed = true; } }
/// <exception cref="System.Exception"/> public override int Run(string[] args) { Options opts = new Options(); opts.AddOption(StatusCmd, true, "List queue information about given queue."); opts.AddOption(HelpCmd, false, "Displays help for all commands."); opts.GetOption(StatusCmd).SetArgName("Queue Name"); CommandLine cliParser = null; try { cliParser = new GnuParser().Parse(opts, args); } catch (MissingArgumentException) { sysout.WriteLine("Missing argument for options"); PrintUsage(opts); return(-1); } if (cliParser.HasOption(StatusCmd)) { if (args.Length != 2) { PrintUsage(opts); return(-1); } return(ListQueue(cliParser.GetOptionValue(StatusCmd))); } else { if (cliParser.HasOption(HelpCmd)) { PrintUsage(opts); return(0); } else { syserr.WriteLine("Invalid Command Usage : "); PrintUsage(opts); return(-1); } } }
public MyOptions(string[] args) { // hard coded constants seed = Runtime.NanoTime(); try { Options opts = BuildOptions(); CommandLineParser parser = new GnuParser(); CommandLine line = parser.Parse(opts, args, true); ProcessOptions(line, opts); ValidateOptions(); } catch (ParseException e) { System.Console.Out.WriteLine(e.Message); System.Console.Out.WriteLine("Try \"--help\" option for details."); SetStopProceed(); } }
public MyOptions(string[] args) { // special variable only for unit testing. // un-exposed parameters. seed = Runtime.NanoTime(); try { Options opts = BuildOptions(); CommandLineParser parser = new GnuParser(); CommandLine line = parser.Parse(opts, args, true); ProcessOptions(line, opts); ValidateOptions(); } catch (ParseException e) { System.Console.Out.WriteLine(e.Message); System.Console.Out.WriteLine("Try \"--help\" option for details."); SetStopProceed(); } }
/// <exception cref="Org.Apache.Commons.Cli.ParseException"/> public virtual bool Init(string[] args) { Options opts = new Options(); opts.AddOption("appname", true, "Application Name. Default value - UnmanagedAM"); opts.AddOption("priority", true, "Application Priority. Default 0"); opts.AddOption("queue", true, "RM Queue in which this application is to be submitted" ); opts.AddOption("master_memory", true, "Amount of memory in MB to be requested to run the application master" ); opts.AddOption("cmd", true, "command to start unmanaged AM (required)"); opts.AddOption("classpath", true, "additional classpath"); opts.AddOption("help", false, "Print usage"); CommandLine cliParser = new GnuParser().Parse(opts, args); if (args.Length == 0) { PrintUsage(opts); throw new ArgumentException("No args specified for client to initialize"); } if (cliParser.HasOption("help")) { PrintUsage(opts); return(false); } appName = cliParser.GetOptionValue("appname", "UnmanagedAM"); amPriority = System.Convert.ToInt32(cliParser.GetOptionValue("priority", "0")); amQueue = cliParser.GetOptionValue("queue", "default"); classpath = cliParser.GetOptionValue("classpath", null); amCmd = cliParser.GetOptionValue("cmd"); if (amCmd == null) { PrintUsage(opts); throw new ArgumentException("No cmd specified for application master"); } YarnConfiguration yarnConf = new YarnConfiguration(conf); rmClient = YarnClient.CreateYarnClient(); rmClient.Init(yarnConf); return(true); }
public virtual int Rm(string[] args) { Option recursive = OptionBuilder.Create("r"); Options rmOption = new Options(); rmOption.AddOption(recursive); bool recursiveOpt = false; CommandLineParser parser = new GnuParser(); try { CommandLine line = parser.Parse(rmOption, args); IList <string> argsList = line.GetArgList(); if (argsList.Count != 2) { return(UsageError("RM requires exactly one path argument", RmUsage)); } if (!ValidatePath(argsList[1])) { return(-1); } try { if (line.HasOption("r")) { recursiveOpt = true; } registry.Delete(argsList[1], recursiveOpt); return(0); } catch (Exception e) { syserr.WriteLine(AnalyzeException("rm", e, argsList)); } return(-1); } catch (ParseException exp) { return(UsageError("Invalid syntax " + exp.ToString(), RmUsage)); } }
public virtual int Ls(string[] args) { Options lsOption = new Options(); CommandLineParser parser = new GnuParser(); try { CommandLine line = parser.Parse(lsOption, args); IList <string> argsList = line.GetArgList(); if (argsList.Count != 2) { return(UsageError("ls requires exactly one path argument", LsUsage)); } if (!ValidatePath(argsList[1])) { return(-1); } try { IList <string> children = registry.List(argsList[1]); foreach (string child in children) { sysout.WriteLine(child); } return(0); } catch (Exception e) { syserr.WriteLine(AnalyzeException("ls", e, argsList)); } return(-1); } catch (ParseException exp) { return(UsageError("Invalid syntax " + exp, LsUsage)); } }
private static int Main(string[] args) { string nodeConfig = null, netConfig = null; string hostArg = null, portArg = null; StringWriter wout = new StringWriter(); Options options = GetOptions(); CommandLine commandLine = null; bool failed = false; bool isService = false; try { ICommandLineParser parser = new GnuParser(options); commandLine = parser.Parse(args); nodeConfig = commandLine.GetOptionValue("nodeconfig", "./node.conf"); netConfig = commandLine.GetOptionValue("netconfig", "./network.conf"); hostArg = commandLine.GetOptionValue("host"); portArg = commandLine.GetOptionValue("port"); } catch (ParseException) { wout.WriteLine("Error parsing arguments."); failed = true; } if (commandLine != null) { if (commandLine.HasOption("install")) { try { Install(commandLine); Console.Out.WriteLine("Service installed succesfully."); return(0); } catch (Exception e) { Console.Error.WriteLine("Error installing service: " + e.Message); #if DEBUG Console.Error.WriteLine(e.StackTrace); #endif return(1); } } if (commandLine.HasOption("uninstall")) { try { Uninstall(); Console.Out.WriteLine("Service uninstalled succesfully."); return(0); } catch (Exception e) { Console.Error.WriteLine("Error uninstalling service: " + e.Message); #if DEBUG Console.Error.WriteLine(e.StackTrace); #endif return(1); } } isService = commandLine.HasOption("service"); } if (isService) { MachineNodeService mnodeService = new MachineNodeService(commandLine); try { if (Environment.UserInteractive) { mnodeService.Start(args); Console.Out.WriteLine("Press any key to stop..."); Console.Read(); mnodeService.Stop(); } else { ServiceBase.Run(mnodeService); } } catch (Exception) { return(1); } return(0); } AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(OnUnhandledException); SetEventHandlers(); ProductInfo libInfo = ProductInfo.GetProductInfo(typeof(TcpAdminService)); ProductInfo nodeInfo = ProductInfo.GetProductInfo(typeof(MachineNode)); Console.Out.WriteLine("{0} {1} ( {2} )", nodeInfo.Title, nodeInfo.Version, nodeInfo.Copyright); Console.Out.WriteLine(nodeInfo.Description); Console.Out.WriteLine(); Console.Out.WriteLine("{0} {1} ( {2} )", libInfo.Title, libInfo.Version, libInfo.Copyright); // Check arguments that can be null, if (netConfig == null) { wout.WriteLine("Error, no network configuration given."); failed = true; } else if (nodeConfig == null) { wout.WriteLine("Error, no node configuration file given."); failed = true; } //if (portArg == null) { // wout.WriteLine("Error, no port address given."); // failed = true; //} if (!failed) { //TODO: support for remote (eg. HTTP, FTP, TCP/IP) configurations) nodeConfig = NormalizeFilePath(nodeConfig); netConfig = NormalizeFilePath(netConfig); if (!File.Exists(nodeConfig)) { wout.WriteLine("Error, node configuration file not found ({0}).", nodeConfig); failed = true; } else if (!File.Exists(netConfig)) { wout.WriteLine("Error, node configuration file not found ({0}).", netConfig); failed = true; } } wout.Flush(); // If failed, if (failed) { HelpFormatter formatter = new HelpFormatter(); if (!IsConsoleRedirected()) { formatter.Width = Console.WindowWidth; } formatter.CommandLineSyntax = "mnode"; formatter.Options = options; formatter.PrintHelp(); Console.Out.WriteLine(); Console.Out.WriteLine(wout.ToString()); return(1); } try { #if DEBUG Console.Out.WriteLine("Retrieving node configuration from {0}", nodeConfig); #endif // Get the node configuration file, ConfigSource nodeConfigSource = new ConfigSource(); using (FileStream fin = new FileStream(nodeConfig, FileMode.Open, FileAccess.Read, FileShare.None)) { //TODO: make it configurable ... nodeConfigSource.LoadProperties(new BufferedStream(fin)); } #if DEBUG Console.Out.WriteLine("Retrieving network configuration from {0}", netConfig); #endif // Parse the network configuration string, NetworkConfigSource netConfigSource; using (FileStream stream = new FileStream(netConfig, FileMode.Open, FileAccess.Read, FileShare.None)) { netConfigSource = new NetworkConfigSource(); //TODO: make it configurable ... netConfigSource.LoadProperties(stream); } string password = nodeConfigSource.GetString("network_password", null); if (password == null) { Console.Out.WriteLine("Error: couldn't determine the network password."); return(1); } // configure the loggers Logger.Init(nodeConfigSource); //TODO: support also IPv6 // The base path, IPAddress host = null; if (hostArg != null) { IPAddress[] addresses = Dns.GetHostAddresses(hostArg); for (int i = 0; i < addresses.Length; i++) { IPAddress address = addresses[i]; if (address.AddressFamily == AddressFamily.InterNetwork) { host = address; break; } } } else { host = IPAddress.Loopback; } if (host == null) { Console.Out.WriteLine("Error: couldn't determine the host address."); return(1); } int port = DefaultPort; if (!String.IsNullOrEmpty(portArg)) { if (!Int32.TryParse(portArg, out port)) { Console.Out.WriteLine("Error: couldn't parse port argument: " + portArg); return(1); } } string storage = commandLine.GetOptionValue("storage", null); IServiceFactory serviceFactory = GetServiceFactory(storage, nodeConfigSource); Console.Out.WriteLine("Machine Node, " + host + " : " + port); service = new TcpAdminService(serviceFactory, host, port, password); service.Config = netConfigSource; service.Start(); Console.Out.WriteLine(); Console.Out.WriteLine(); Console.Out.WriteLine("Press CTRL+C to quit..."); waitHandle = new AutoResetEvent(false); waitHandle.WaitOne(); } catch (Exception e) { Console.Out.WriteLine(e.Message); Console.Out.WriteLine(e.StackTrace); return(1); } finally { if (service != null) { service.Dispose(); } } return(0); }
private void ParseServers(string[] args) { var parser = new GnuParser(); var serverOptions = new Options(); serverOptions.AddOption(_serverOption); for (int i = 0; i < args.Length; i++) { if (args[i] != "-" + Server || i + 1 >= args.Length) continue; var currentLine = parser.Parse(serverOptions, new[] {args[i], args[i + 1]}); AddServer(currentLine.GetOptionValues(Server)); } }
/// <exception cref="System.Exception"/> public virtual int Run(string[] args) { Options opts = new Options(); opts.AddOption(HelpCmd, false, "Displays help for all commands."); Option appIdOpt = new Option(ApplicationIdOption, true, "ApplicationId (required)" ); appIdOpt.SetRequired(true); opts.AddOption(appIdOpt); opts.AddOption(ContainerIdOption, true, "ContainerId (must be specified if node address is specified)" ); opts.AddOption(NodeAddressOption, true, "NodeAddress in the format " + "nodename:port (must be specified if container id is specified)" ); opts.AddOption(AppOwnerOption, true, "AppOwner (assumed to be current user if not specified)" ); opts.GetOption(ApplicationIdOption).SetArgName("Application ID"); opts.GetOption(ContainerIdOption).SetArgName("Container ID"); opts.GetOption(NodeAddressOption).SetArgName("Node Address"); opts.GetOption(AppOwnerOption).SetArgName("Application Owner"); Options printOpts = new Options(); printOpts.AddOption(opts.GetOption(HelpCmd)); printOpts.AddOption(opts.GetOption(ContainerIdOption)); printOpts.AddOption(opts.GetOption(NodeAddressOption)); printOpts.AddOption(opts.GetOption(AppOwnerOption)); if (args.Length < 1) { PrintHelpMessage(printOpts); return(-1); } if (args[0].Equals("-help")) { PrintHelpMessage(printOpts); return(0); } CommandLineParser parser = new GnuParser(); string appIdStr = null; string containerIdStr = null; string nodeAddress = null; string appOwner = null; try { CommandLine commandLine = parser.Parse(opts, args, true); appIdStr = commandLine.GetOptionValue(ApplicationIdOption); containerIdStr = commandLine.GetOptionValue(ContainerIdOption); nodeAddress = commandLine.GetOptionValue(NodeAddressOption); appOwner = commandLine.GetOptionValue(AppOwnerOption); } catch (ParseException e) { System.Console.Error.WriteLine("options parsing failed: " + e.Message); PrintHelpMessage(printOpts); return(-1); } if (appIdStr == null) { System.Console.Error.WriteLine("ApplicationId cannot be null!"); PrintHelpMessage(printOpts); return(-1); } ApplicationId appId = null; try { appId = ConverterUtils.ToApplicationId(appIdStr); } catch (Exception) { System.Console.Error.WriteLine("Invalid ApplicationId specified"); return(-1); } try { int resultCode = VerifyApplicationState(appId); if (resultCode != 0) { System.Console.Out.WriteLine("Logs are not avaiable right now."); return(resultCode); } } catch (Exception) { System.Console.Error.WriteLine("Unable to get ApplicationState." + " Attempting to fetch logs directly from the filesystem." ); } LogCLIHelpers logCliHelper = new LogCLIHelpers(); logCliHelper.SetConf(GetConf()); if (appOwner == null || appOwner.IsEmpty()) { appOwner = UserGroupInformation.GetCurrentUser().GetShortUserName(); } int resultCode_1 = 0; if (containerIdStr == null && nodeAddress == null) { resultCode_1 = logCliHelper.DumpAllContainersLogs(appId, appOwner, System.Console.Out ); } else { if ((containerIdStr == null && nodeAddress != null) || (containerIdStr != null && nodeAddress == null)) { System.Console.Out.WriteLine("ContainerId or NodeAddress cannot be null!"); PrintHelpMessage(printOpts); resultCode_1 = -1; } else { resultCode_1 = logCliHelper.DumpAContainersLogs(appIdStr, containerIdStr, nodeAddress , appOwner); } } return(resultCode_1); }
public virtual int Bind(string[] args) { Option rest = OptionBuilder.Create("rest"); Option webui = OptionBuilder.Create("webui"); Option inet = OptionBuilder.Create("inet"); Option port = OptionBuilder.Create("p"); Option host = OptionBuilder.Create("h"); Option apiOpt = OptionBuilder.Create("api"); Options inetOption = new Options(); inetOption.AddOption(inet); inetOption.AddOption(port); inetOption.AddOption(host); inetOption.AddOption(apiOpt); Options webuiOpt = new Options(); webuiOpt.AddOption(webui); webuiOpt.AddOption(apiOpt); Options restOpt = new Options(); restOpt.AddOption(rest); restOpt.AddOption(apiOpt); CommandLineParser parser = new GnuParser(); ServiceRecord sr = new ServiceRecord(); CommandLine line; if (args.Length <= 1) { return(UsageError("Invalid syntax ", BindUsage)); } if (args[1].Equals("-inet")) { int portNum; string hostName; string api; try { line = parser.Parse(inetOption, args); } catch (ParseException exp) { return(UsageError("Invalid syntax " + exp.Message, BindUsage)); } if (line.HasOption("inet") && line.HasOption("p") && line.HasOption("h") && line. HasOption("api")) { try { portNum = System.Convert.ToInt32(line.GetOptionValue("p")); } catch (FormatException exp) { return(UsageError("Invalid Port - int required" + exp.Message, BindUsage)); } hostName = line.GetOptionValue("h"); api = line.GetOptionValue("api"); sr.AddExternalEndpoint(RegistryTypeUtils.InetAddrEndpoint(api, ProtocolTypes.ProtocolHadoopIpc , hostName, portNum)); } else { return(UsageError("Missing options: must have host, port and api", BindUsage)); } } else { if (args[1].Equals("-webui")) { try { line = parser.Parse(webuiOpt, args); } catch (ParseException exp) { return(UsageError("Invalid syntax " + exp.Message, BindUsage)); } if (line.HasOption("webui") && line.HasOption("api")) { URI theUri; try { theUri = new URI(line.GetOptionValue("webui")); } catch (URISyntaxException e) { return(UsageError("Invalid URI: " + e.Message, BindUsage)); } sr.AddExternalEndpoint(RegistryTypeUtils.WebEndpoint(line.GetOptionValue("api"), theUri)); } else { return(UsageError("Missing options: must have value for uri and api", BindUsage)); } } else { if (args[1].Equals("-rest")) { try { line = parser.Parse(restOpt, args); } catch (ParseException exp) { return(UsageError("Invalid syntax " + exp.Message, BindUsage)); } if (line.HasOption("rest") && line.HasOption("api")) { URI theUri = null; try { theUri = new URI(line.GetOptionValue("rest")); } catch (URISyntaxException e) { return(UsageError("Invalid URI: " + e.Message, BindUsage)); } sr.AddExternalEndpoint(RegistryTypeUtils.RestEndpoint(line.GetOptionValue("api"), theUri)); } else { return(UsageError("Missing options: must have value for uri and api", BindUsage)); } } else { return(UsageError("Invalid syntax", BindUsage)); } } } IList <string> argsList = line.GetArgList(); if (argsList.Count != 2) { return(UsageError("bind requires exactly one path argument", BindUsage)); } if (!ValidatePath(argsList[1])) { return(-1); } try { registry.Bind(argsList[1], sr, BindFlags.Overwrite); return(0); } catch (Exception e) { syserr.WriteLine(AnalyzeException("bind", e, argsList)); } return(-1); }
public ArgumentParser(string[] arguments) { _Parser = new GnuParser(); var options = new Options(); options.AddOption(OptionBuilder.Factory .IsRequired() .WithLongOpt("database") .HasArg() .Create(OptionDatabase)); options.AddOption(OptionBuilder.Factory .WithLongOpt("scriptCreate") .WithArgName(OptionScriptCreate) .Create(OptionScriptCreate)); options.AddOption(OptionBuilder.Factory .WithLongOpt("scriptIndividual") .Create(OptionScriptIndividual)); options.AddOption(OptionBuilder.Factory .WithLongOpt("schemaVersion") .Create(OptionSchemaVersion)); options.AddOption(OptionBuilder.Factory .WithLongOpt("createDatabase") .Create(OptionCreateDatabase)); options.AddOption(OptionBuilder.Factory .WithLongOpt("resetDatabase") .Create(OptionResetDatabase)); options.AddOption(OptionBuilder.Factory .WithLongOpt("noWait") .Create(OptionNoWait)); options.AddOption(OptionBuilder.Factory .WithLongOpt("setDirectoryBase") .HasArg() .Create(OptionSetDirectoryBase)); options.AddOption(OptionBuilder.Factory .WithLongOpt("setConnectionString") .HasArg() .Create(OptionSetConnectionString)); options.AddOption(OptionBuilder.Factory .WithLongOpt("tableData") .HasArgs(2) .Create(OptionTableData)); options.AddOption(OptionBuilder.Factory .WithLongOpt(OptionCreateSchemaLogTable) .Create(OptionCreateSchemaLogTable)); options.AddOption(OptionBuilder.Factory .WithLongOpt("update") .HasOptionalArg() .Create(OptionUpdateDatabase)); options.AddOption(OptionBuilder.Factory .WithLongOpt("runScript") .HasArg() .Create(OptionRunScript)); options.AddOption(OptionBuilder.Factory .WithLongOpt("backup") .HasArg() .Create(OptionBackup)); options.AddOption(OptionBuilder.Factory .WithLongOpt("restore") .HasArg() .Create(OptionRestore)); options.AddOption(OptionBuilder.Factory .WithLongOpt("generateUpdate") .HasArg() .Create(OptionGenerateUpdate)); options.AddOption(OptionBuilder.Factory .WithLongOpt("markSchemaChangesWithLatestVersion") .Create(OptionMarkSchemaChangesWithLatestVersion)); _Line = _Parser.Parse(options, arguments); }
/// <exception cref="System.Exception"/> public override int Run(string[] args) { Options opts = new Options(); string title = null; if (args.Length > 0 && Sharpen.Runtime.EqualsIgnoreCase(args[0], Application)) { title = Application; opts.AddOption(StatusCmd, true, "Prints the status of the application."); opts.AddOption(ListCmd, false, "List applications. " + "Supports optional use of -appTypes to filter applications " + "based on application type, " + "and -appStates to filter applications based on application state." ); opts.AddOption(KillCmd, true, "Kills the application."); opts.AddOption(MoveToQueueCmd, true, "Moves the application to a " + "different queue." ); opts.AddOption(QueueCmd, true, "Works with the movetoqueue command to" + " specify which queue to move an application to." ); opts.AddOption(HelpCmd, false, "Displays help for all commands."); Option appTypeOpt = new Option(AppTypeCmd, true, "Works with -list to " + "filter applications based on " + "input comma-separated list of application types."); appTypeOpt.SetValueSeparator(','); appTypeOpt.SetArgs(Option.UnlimitedValues); appTypeOpt.SetArgName("Types"); opts.AddOption(appTypeOpt); Option appStateOpt = new Option(AppStateCmd, true, "Works with -list " + "to filter applications based on input comma-separated list of " + "application states. " + GetAllValidApplicationStates()); appStateOpt.SetValueSeparator(','); appStateOpt.SetArgs(Option.UnlimitedValues); appStateOpt.SetArgName("States"); opts.AddOption(appStateOpt); opts.GetOption(KillCmd).SetArgName("Application ID"); opts.GetOption(MoveToQueueCmd).SetArgName("Application ID"); opts.GetOption(QueueCmd).SetArgName("Queue Name"); opts.GetOption(StatusCmd).SetArgName("Application ID"); } else { if (args.Length > 0 && Sharpen.Runtime.EqualsIgnoreCase(args[0], ApplicationAttempt )) { title = ApplicationAttempt; opts.AddOption(StatusCmd, true, "Prints the status of the application attempt."); opts.AddOption(ListCmd, true, "List application attempts for aplication."); opts.AddOption(HelpCmd, false, "Displays help for all commands."); opts.GetOption(StatusCmd).SetArgName("Application Attempt ID"); opts.GetOption(ListCmd).SetArgName("Application ID"); } else { if (args.Length > 0 && Sharpen.Runtime.EqualsIgnoreCase(args[0], Container)) { title = Container; opts.AddOption(StatusCmd, true, "Prints the status of the container."); opts.AddOption(ListCmd, true, "List containers for application attempt."); opts.AddOption(HelpCmd, false, "Displays help for all commands."); opts.GetOption(StatusCmd).SetArgName("Container ID"); opts.GetOption(ListCmd).SetArgName("Application Attempt ID"); } } } int exitCode = -1; CommandLine cliParser = null; try { cliParser = new GnuParser().Parse(opts, args); } catch (MissingArgumentException) { sysout.WriteLine("Missing argument for options"); PrintUsage(title, opts); return(exitCode); } if (cliParser.HasOption(StatusCmd)) { if (args.Length != 3) { PrintUsage(title, opts); return(exitCode); } if (Sharpen.Runtime.EqualsIgnoreCase(args[0], Application)) { exitCode = PrintApplicationReport(cliParser.GetOptionValue(StatusCmd)); } else { if (Sharpen.Runtime.EqualsIgnoreCase(args[0], ApplicationAttempt)) { exitCode = PrintApplicationAttemptReport(cliParser.GetOptionValue(StatusCmd)); } else { if (Sharpen.Runtime.EqualsIgnoreCase(args[0], Container)) { exitCode = PrintContainerReport(cliParser.GetOptionValue(StatusCmd)); } } } return(exitCode); } else { if (cliParser.HasOption(ListCmd)) { if (Sharpen.Runtime.EqualsIgnoreCase(args[0], Application)) { allAppStates = false; ICollection <string> appTypes = new HashSet <string>(); if (cliParser.HasOption(AppTypeCmd)) { string[] types = cliParser.GetOptionValues(AppTypeCmd); if (types != null) { foreach (string type in types) { if (!type.Trim().IsEmpty()) { appTypes.AddItem(StringUtils.ToUpperCase(type).Trim()); } } } } EnumSet <YarnApplicationState> appStates = EnumSet.NoneOf <YarnApplicationState>(); if (cliParser.HasOption(AppStateCmd)) { string[] states = cliParser.GetOptionValues(AppStateCmd); if (states != null) { foreach (string state in states) { if (!state.Trim().IsEmpty()) { if (Sharpen.Runtime.EqualsIgnoreCase(state.Trim(), AllstatesOption)) { allAppStates = true; break; } try { appStates.AddItem(YarnApplicationState.ValueOf(StringUtils.ToUpperCase(state).Trim ())); } catch (ArgumentException) { sysout.WriteLine("The application state " + state + " is invalid."); sysout.WriteLine(GetAllValidApplicationStates()); return(exitCode); } } } } } ListApplications(appTypes, appStates); } else { if (Sharpen.Runtime.EqualsIgnoreCase(args[0], ApplicationAttempt)) { if (args.Length != 3) { PrintUsage(title, opts); return(exitCode); } ListApplicationAttempts(cliParser.GetOptionValue(ListCmd)); } else { if (Sharpen.Runtime.EqualsIgnoreCase(args[0], Container)) { if (args.Length != 3) { PrintUsage(title, opts); return(exitCode); } ListContainers(cliParser.GetOptionValue(ListCmd)); } } } } else { if (cliParser.HasOption(KillCmd)) { if (args.Length != 3) { PrintUsage(title, opts); return(exitCode); } try { KillApplication(cliParser.GetOptionValue(KillCmd)); } catch (ApplicationNotFoundException) { return(exitCode); } } else { if (cliParser.HasOption(MoveToQueueCmd)) { if (!cliParser.HasOption(QueueCmd)) { PrintUsage(title, opts); return(exitCode); } MoveApplicationAcrossQueues(cliParser.GetOptionValue(MoveToQueueCmd), cliParser.GetOptionValue (QueueCmd)); } else { if (cliParser.HasOption(HelpCmd)) { PrintUsage(title, opts); return(0); } else { syserr.WriteLine("Invalid Command Usage : "); PrintUsage(title, opts); } } } } } return(0); }
/// <exception cref="System.Exception"/> public override int Run(string[] args) { Options opts = new Options(); opts.AddOption(HelpCmd, false, "Displays help for all commands."); opts.AddOption(StatusCmd, true, "Prints the status report of the node."); opts.AddOption(ListCmd, false, "List all running nodes. " + "Supports optional use of -states to filter nodes " + "based on node state, all -all to list all nodes."); Option nodeStateOpt = new Option(NodeStateCmd, true, "Works with -list to filter nodes based on input comma-separated list of node states." ); nodeStateOpt.SetValueSeparator(','); nodeStateOpt.SetArgs(Option.UnlimitedValues); nodeStateOpt.SetArgName("States"); opts.AddOption(nodeStateOpt); Option allOpt = new Option(NodeAll, false, "Works with -list to list all nodes."); opts.AddOption(allOpt); opts.GetOption(StatusCmd).SetArgName("NodeId"); int exitCode = -1; CommandLine cliParser = null; try { cliParser = new GnuParser().Parse(opts, args); } catch (MissingArgumentException) { sysout.WriteLine("Missing argument for options"); PrintUsage(opts); return(exitCode); } if (cliParser.HasOption("status")) { if (args.Length != 2) { PrintUsage(opts); return(exitCode); } PrintNodeStatus(cliParser.GetOptionValue("status")); } else { if (cliParser.HasOption("list")) { ICollection <NodeState> nodeStates = new HashSet <NodeState>(); if (cliParser.HasOption(NodeAll)) { foreach (NodeState state in NodeState.Values()) { nodeStates.AddItem(state); } } else { if (cliParser.HasOption(NodeStateCmd)) { string[] types = cliParser.GetOptionValues(NodeStateCmd); if (types != null) { foreach (string type in types) { if (!type.Trim().IsEmpty()) { nodeStates.AddItem(NodeState.ValueOf(StringUtils.ToUpperCase(type.Trim()))); } } } } else { nodeStates.AddItem(NodeState.Running); } } ListClusterNodes(nodeStates); } else { if (cliParser.HasOption(HelpCmd)) { PrintUsage(opts); return(0); } else { syserr.WriteLine("Invalid Command Usage : "); PrintUsage(opts); } } } return(0); }
/// <summary>Parse command line options</summary> /// <param name="args">Parsed command line options</param> /// <returns>Whether the init was successful to run the client</returns> /// <exception cref="Org.Apache.Commons.Cli.ParseException"/> public virtual bool Init(string[] args) { CommandLine cliParser = new GnuParser().Parse(opts, args); if (args.Length == 0) { throw new ArgumentException("No args specified for client to initialize"); } if (cliParser.HasOption("log_properties")) { string log4jPath = cliParser.GetOptionValue("log_properties"); try { Log4jPropertyHelper.UpdateLog4jConfiguration(typeof(Org.Apache.Hadoop.Yarn.Applications.Distributedshell.Client ), log4jPath); } catch (Exception e) { Log.Warn("Can not set up custom log4j properties. " + e); } } if (cliParser.HasOption("help")) { PrintUsage(); return(false); } if (cliParser.HasOption("debug")) { debugFlag = true; } if (cliParser.HasOption("keep_containers_across_application_attempts")) { Log.Info("keep_containers_across_application_attempts"); keepContainers = true; } appName = cliParser.GetOptionValue("appname", "DistributedShell"); amPriority = System.Convert.ToInt32(cliParser.GetOptionValue("priority", "0")); amQueue = cliParser.GetOptionValue("queue", "default"); amMemory = System.Convert.ToInt32(cliParser.GetOptionValue("master_memory", "10") ); amVCores = System.Convert.ToInt32(cliParser.GetOptionValue("master_vcores", "1")); if (amMemory < 0) { throw new ArgumentException("Invalid memory specified for application master, exiting." + " Specified memory=" + amMemory); } if (amVCores < 0) { throw new ArgumentException("Invalid virtual cores specified for application master, exiting." + " Specified virtual cores=" + amVCores); } if (!cliParser.HasOption("jar")) { throw new ArgumentException("No jar file specified for application master"); } appMasterJar = cliParser.GetOptionValue("jar"); if (!cliParser.HasOption("shell_command") && !cliParser.HasOption("shell_script")) { throw new ArgumentException("No shell command or shell script specified to be executed by application master" ); } else { if (cliParser.HasOption("shell_command") && cliParser.HasOption("shell_script")) { throw new ArgumentException("Can not specify shell_command option " + "and shell_script option at the same time" ); } else { if (cliParser.HasOption("shell_command")) { shellCommand = cliParser.GetOptionValue("shell_command"); } else { shellScriptPath = cliParser.GetOptionValue("shell_script"); } } } if (cliParser.HasOption("shell_args")) { shellArgs = cliParser.GetOptionValues("shell_args"); } if (cliParser.HasOption("shell_env")) { string[] envs = cliParser.GetOptionValues("shell_env"); foreach (string env in envs) { env = env.Trim(); int index = env.IndexOf('='); if (index == -1) { shellEnv[env] = string.Empty; continue; } string key = Sharpen.Runtime.Substring(env, 0, index); string val = string.Empty; if (index < (env.Length - 1)) { val = Sharpen.Runtime.Substring(env, index + 1); } shellEnv[key] = val; } } shellCmdPriority = System.Convert.ToInt32(cliParser.GetOptionValue("shell_cmd_priority" , "0")); containerMemory = System.Convert.ToInt32(cliParser.GetOptionValue("container_memory" , "10")); containerVirtualCores = System.Convert.ToInt32(cliParser.GetOptionValue("container_vcores" , "1")); numContainers = System.Convert.ToInt32(cliParser.GetOptionValue("num_containers", "1")); if (containerMemory < 0 || containerVirtualCores < 0 || numContainers < 1) { throw new ArgumentException("Invalid no. of containers or container memory/vcores specified," + " exiting." + " Specified containerMemory=" + containerMemory + ", containerVirtualCores=" + containerVirtualCores + ", numContainer=" + numContainers); } nodeLabelExpression = cliParser.GetOptionValue("node_label_expression", null); clientTimeout = System.Convert.ToInt32(cliParser.GetOptionValue("timeout", "600000" )); attemptFailuresValidityInterval = long.Parse(cliParser.GetOptionValue("attempt_failures_validity_interval" , "-1")); log4jPropFile = cliParser.GetOptionValue("log_properties", string.Empty); // Get timeline domain options if (cliParser.HasOption("domain")) { domainId = cliParser.GetOptionValue("domain"); toCreateDomain = cliParser.HasOption("create"); if (cliParser.HasOption("view_acls")) { viewACLs = cliParser.GetOptionValue("view_acls"); } if (cliParser.HasOption("modify_acls")) { modifyACLs = cliParser.GetOptionValue("modify_acls"); } } return(true); }