| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.hadoop.registry.cli; |
| |
| import static org.apache.hadoop.registry.client.binding.RegistryTypeUtils.*; |
| |
| import java.io.Closeable; |
| import java.io.IOException; |
| import java.io.PrintStream; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.List; |
| import java.util.Map; |
| |
| import com.google.common.base.Preconditions; |
| import org.apache.commons.cli.CommandLine; |
| import org.apache.commons.cli.CommandLineParser; |
| import org.apache.commons.cli.GnuParser; |
| import org.apache.commons.cli.Option; |
| import org.apache.commons.cli.OptionBuilder; |
| import org.apache.commons.cli.Options; |
| import org.apache.commons.cli.ParseException; |
| import org.apache.hadoop.conf.Configuration; |
| import org.apache.hadoop.conf.Configured; |
| import org.apache.hadoop.fs.PathNotFoundException; |
| import org.apache.hadoop.security.AccessControlException; |
| import org.apache.hadoop.service.ServiceOperations; |
| import org.apache.hadoop.util.ExitUtil; |
| import org.apache.hadoop.util.Tool; |
| import org.apache.hadoop.util.ToolRunner; |
| import org.apache.hadoop.registry.client.api.BindFlags; |
| import org.apache.hadoop.registry.client.api.RegistryOperations; |
| import org.apache.hadoop.registry.client.api.RegistryOperationsFactory; |
| import org.apache.hadoop.registry.client.exceptions.AuthenticationFailedException; |
| import org.apache.hadoop.registry.client.exceptions.InvalidPathnameException; |
| import org.apache.hadoop.registry.client.exceptions.InvalidRecordException; |
| import org.apache.hadoop.registry.client.exceptions.NoPathPermissionsException; |
| import org.apache.hadoop.registry.client.exceptions.NoRecordException; |
| import org.apache.hadoop.registry.client.types.Endpoint; |
| import org.apache.hadoop.registry.client.types.ProtocolTypes; |
| import org.apache.hadoop.registry.client.types.ServiceRecord; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * Command line for registry operations. |
| */ |
| public class RegistryCli extends Configured implements Tool, Closeable { |
| private static final Logger LOG = |
| LoggerFactory.getLogger(RegistryCli.class); |
| protected final PrintStream sysout; |
| protected final PrintStream syserr; |
| |
| |
| private RegistryOperations registry; |
| |
| private static final String LS_USAGE = "ls pathName"; |
| private static final String RESOLVE_USAGE = "resolve pathName"; |
| private static final String BIND_USAGE = |
| "bind -inet -api apiName -p portNumber -h hostName pathName" + "\n" |
| + "bind -webui uriString -api apiName pathName" + "\n" |
| + "bind -rest uriString -api apiName pathName"; |
| private static final String MKNODE_USAGE = "mknode directoryName"; |
| private static final String RM_USAGE = "rm pathName"; |
| private static final String USAGE = |
| "\n" + LS_USAGE + "\n" + RESOLVE_USAGE + "\n" + BIND_USAGE + "\n" + |
| MKNODE_USAGE + "\n" + RM_USAGE; |
| |
| |
| public RegistryCli(PrintStream sysout, PrintStream syserr) { |
| Configuration conf = new Configuration(); |
| super.setConf(conf); |
| registry = RegistryOperationsFactory.createInstance(conf); |
| registry.start(); |
| this.sysout = sysout; |
| this.syserr = syserr; |
| } |
| |
| public RegistryCli(RegistryOperations reg, |
| Configuration conf, |
| PrintStream sysout, |
| PrintStream syserr) { |
| super(conf); |
| Preconditions.checkArgument(reg != null, "Null registry"); |
| registry = reg; |
| this.sysout = sysout; |
| this.syserr = syserr; |
| } |
| |
| @SuppressWarnings("UseOfSystemOutOrSystemErr") |
| public static void main(String[] args) throws Exception { |
| int res = -1; |
| try (RegistryCli cli = new RegistryCli(System.out, System.err)) { |
| res = ToolRunner.run(cli, args); |
| } catch (Exception e) { |
| ExitUtil.terminate(res, e); |
| } |
| ExitUtil.terminate(res); |
| } |
| |
| /** |
| * Close the object by stopping the registry. |
| * <p> |
| * <i>Important:</i> |
| * <p> |
| * After this call is made, no operations may be made of this |
| * object, <i>or of a YARN registry instance used when constructing |
| * this object. </i> |
| * @throws IOException |
| */ |
| @Override |
| public void close() throws IOException { |
| ServiceOperations.stopQuietly(registry); |
| registry = null; |
| } |
| |
| private int usageError(String err, String usage) { |
| syserr.println("Error: " + err); |
| syserr.println("Usage: " + usage); |
| return -1; |
| } |
| |
| private boolean validatePath(String path) { |
| if (!path.startsWith("/")) { |
| syserr.println("Path must start with /; given path was: " + path); |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| public int run(String[] args) throws Exception { |
| Preconditions.checkArgument(getConf() != null, "null configuration"); |
| if (args.length > 0) { |
| switch (args[0]) { |
| case "ls": |
| return ls(args); |
| case "resolve": |
| return resolve(args); |
| case "bind": |
| return bind(args); |
| case "mknode": |
| return mknode(args); |
| case "rm": |
| return rm(args); |
| default: |
| return usageError("Invalid command: " + args[0], USAGE); |
| } |
| } |
| return usageError("No command arg passed.", USAGE); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public int ls(String[] args) { |
| |
| Options lsOption = new Options(); |
| CommandLineParser parser = new GnuParser(); |
| try { |
| CommandLine line = parser.parse(lsOption, args); |
| |
| List<String> argsList = line.getArgList(); |
| if (argsList.size() != 2) { |
| return usageError("ls requires exactly one path argument", LS_USAGE); |
| } |
| if (!validatePath(argsList.get(1))) { |
| return -1; |
| } |
| |
| try { |
| List<String> children = registry.list(argsList.get(1)); |
| for (String child : children) { |
| sysout.println(child); |
| } |
| return 0; |
| |
| } catch (Exception e) { |
| syserr.println(analyzeException("ls", e, argsList)); |
| } |
| return -1; |
| } catch (ParseException exp) { |
| return usageError("Invalid syntax " + exp, LS_USAGE); |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| public int resolve(String[] args) { |
| Options resolveOption = new Options(); |
| CommandLineParser parser = new GnuParser(); |
| try { |
| CommandLine line = parser.parse(resolveOption, args); |
| |
| List<String> argsList = line.getArgList(); |
| if (argsList.size() != 2) { |
| return usageError("resolve requires exactly one path argument", |
| RESOLVE_USAGE); |
| } |
| if (!validatePath(argsList.get(1))) { |
| return -1; |
| } |
| |
| try { |
| ServiceRecord record = registry.resolve(argsList.get(1)); |
| |
| for (Endpoint endpoint : record.external) { |
| sysout.println(" Endpoint(ProtocolType=" |
| + endpoint.protocolType + ", Api=" |
| + endpoint.api + ");" |
| + " Addresses(AddressType=" |
| + endpoint.addressType + ") are: "); |
| |
| for (Map<String, String> address : endpoint.addresses) { |
| sysout.println("[ "); |
| for (Map.Entry<String, String> entry : address.entrySet()) { |
| sysout.print("\t" + entry.getKey() |
| + ":" + entry.getValue()); |
| } |
| |
| sysout.println("\n]"); |
| } |
| sysout.println(); |
| } |
| return 0; |
| } catch (Exception e) { |
| syserr.println(analyzeException("resolve", e, argsList)); |
| } |
| return -1; |
| } catch (ParseException exp) { |
| return usageError("Invalid syntax " + exp, RESOLVE_USAGE); |
| } |
| |
| } |
| |
| public int bind(String[] args) { |
| Option rest = OptionBuilder.withArgName("rest") |
| .hasArg() |
| .withDescription("rest Option") |
| .create("rest"); |
| Option webui = OptionBuilder.withArgName("webui") |
| .hasArg() |
| .withDescription("webui Option") |
| .create("webui"); |
| Option inet = OptionBuilder.withArgName("inet") |
| .withDescription("inet Option") |
| .create("inet"); |
| Option port = OptionBuilder.withArgName("port") |
| .hasArg() |
| .withDescription("port to listen on [9999]") |
| .create("p"); |
| Option host = OptionBuilder.withArgName("host") |
| .hasArg() |
| .withDescription("host name") |
| .create("h"); |
| Option apiOpt = OptionBuilder.withArgName("api") |
| .hasArg() |
| .withDescription("api") |
| .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 ", BIND_USAGE); |
| } |
| 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.getMessage(), BIND_USAGE); |
| } |
| if (line.hasOption("inet") && line.hasOption("p") && |
| line.hasOption("h") && line.hasOption("api")) { |
| try { |
| portNum = Integer.parseInt(line.getOptionValue("p")); |
| } catch (NumberFormatException exp) { |
| return usageError("Invalid Port - int required" + exp.getMessage(), |
| BIND_USAGE); |
| } |
| hostName = line.getOptionValue("h"); |
| api = line.getOptionValue("api"); |
| sr.addExternalEndpoint( |
| inetAddrEndpoint(api, ProtocolTypes.PROTOCOL_HADOOP_IPC, hostName, |
| portNum)); |
| |
| } else { |
| return usageError("Missing options: must have host, port and api", |
| BIND_USAGE); |
| } |
| |
| } else if (args[1].equals("-webui")) { |
| try { |
| line = parser.parse(webuiOpt, args); |
| } catch (ParseException exp) { |
| return usageError("Invalid syntax " + exp.getMessage(), BIND_USAGE); |
| } |
| if (line.hasOption("webui") && line.hasOption("api")) { |
| URI theUri; |
| try { |
| theUri = new URI(line.getOptionValue("webui")); |
| } catch (URISyntaxException e) { |
| return usageError("Invalid URI: " + e.getMessage(), BIND_USAGE); |
| } |
| sr.addExternalEndpoint(webEndpoint(line.getOptionValue("api"), theUri)); |
| |
| } else { |
| return usageError("Missing options: must have value for uri and api", |
| BIND_USAGE); |
| } |
| } else if (args[1].equals("-rest")) { |
| try { |
| line = parser.parse(restOpt, args); |
| } catch (ParseException exp) { |
| return usageError("Invalid syntax " + exp.getMessage(), BIND_USAGE); |
| } |
| 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.getMessage(), BIND_USAGE); |
| } |
| sr.addExternalEndpoint( |
| restEndpoint(line.getOptionValue("api"), theUri)); |
| |
| } else { |
| return usageError("Missing options: must have value for uri and api", |
| BIND_USAGE); |
| } |
| |
| } else { |
| return usageError("Invalid syntax", BIND_USAGE); |
| } |
| @SuppressWarnings("unchecked") |
| List<String> argsList = line.getArgList(); |
| if (argsList.size() != 2) { |
| return usageError("bind requires exactly one path argument", BIND_USAGE); |
| } |
| if (!validatePath(argsList.get(1))) { |
| return -1; |
| } |
| |
| try { |
| registry.bind(argsList.get(1), sr, BindFlags.OVERWRITE); |
| return 0; |
| } catch (Exception e) { |
| syserr.println(analyzeException("bind", e, argsList)); |
| } |
| |
| return -1; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public int mknode(String[] args) { |
| Options mknodeOption = new Options(); |
| CommandLineParser parser = new GnuParser(); |
| try { |
| CommandLine line = parser.parse(mknodeOption, args); |
| |
| List<String> argsList = line.getArgList(); |
| if (argsList.size() != 2) { |
| return usageError("mknode requires exactly one path argument", |
| MKNODE_USAGE); |
| } |
| if (!validatePath(argsList.get(1))) { |
| return -1; |
| } |
| |
| try { |
| registry.mknode(args[1], false); |
| return 0; |
| } catch (Exception e) { |
| syserr.println(analyzeException("mknode", e, argsList)); |
| } |
| return -1; |
| } catch (ParseException exp) { |
| return usageError("Invalid syntax " + exp.toString(), MKNODE_USAGE); |
| } |
| } |
| |
| |
| @SuppressWarnings("unchecked") |
| public int rm(String[] args) { |
| Option recursive = OptionBuilder.withArgName("recursive") |
| .withDescription("delete recursively") |
| .create("r"); |
| |
| Options rmOption = new Options(); |
| rmOption.addOption(recursive); |
| |
| boolean recursiveOpt = false; |
| |
| CommandLineParser parser = new GnuParser(); |
| try { |
| CommandLine line = parser.parse(rmOption, args); |
| |
| List<String> argsList = line.getArgList(); |
| if (argsList.size() != 2) { |
| return usageError("RM requires exactly one path argument", RM_USAGE); |
| } |
| if (!validatePath(argsList.get(1))) { |
| return -1; |
| } |
| |
| try { |
| if (line.hasOption("r")) { |
| recursiveOpt = true; |
| } |
| |
| registry.delete(argsList.get(1), recursiveOpt); |
| return 0; |
| } catch (Exception e) { |
| syserr.println(analyzeException("rm", e, argsList)); |
| } |
| return -1; |
| } catch (ParseException exp) { |
| return usageError("Invalid syntax " + exp.toString(), RM_USAGE); |
| } |
| } |
| |
| /** |
| * Given an exception and a possibly empty argument list, generate |
| * a diagnostics string for use in error messages |
| * @param operation the operation that failed |
| * @param e exception |
| * @param argsList arguments list |
| * @return a string intended for the user |
| */ |
| String analyzeException(String operation, |
| Exception e, |
| List<String> argsList) { |
| |
| String pathArg = !argsList.isEmpty() ? argsList.get(1) : "(none)"; |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Operation {} on path {} failed with exception {}", |
| operation, pathArg, e, e); |
| } |
| if (e instanceof InvalidPathnameException) { |
| return "InvalidPath :" + pathArg + ": " + e; |
| } |
| if (e instanceof PathNotFoundException) { |
| return "Path not found: " + pathArg; |
| } |
| if (e instanceof NoRecordException) { |
| return "No service record at path " + pathArg; |
| } |
| if (e instanceof AuthenticationFailedException) { |
| return "Failed to authenticate to registry : " + e; |
| } |
| if (e instanceof NoPathPermissionsException) { |
| return "No Permission to path: " + pathArg + ": " + e; |
| } |
| if (e instanceof AccessControlException) { |
| return "No Permission to path: " + pathArg + ": " + e; |
| } |
| if (e instanceof InvalidRecordException) { |
| return "Unable to read record at: " + pathArg + ": " + e; |
| } |
| if (e instanceof IOException) { |
| return "IO Exception when accessing path :" + pathArg + ": " + e; |
| } |
| // something else went very wrong here |
| return "Exception " + e; |
| |
| } |
| } |
