| # 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. |
| |
| """ |
| A collection of helper functions used by the CLI and its Plugins. |
| """ |
| |
| import imp |
| import importlib |
| import ipaddress |
| import json |
| import os |
| import re |
| import textwrap |
| import urllib.parse |
| |
| from kazoo.client import KazooClient |
| |
| from cli.exceptions import CLIException |
| |
| |
| def import_modules(package_paths, module_type): |
| """ |
| Looks for python packages under `package_paths` and imports |
| them as modules. Returns a dictionary of the basename of the |
| `package_paths` to the imported modules. |
| """ |
| modules = {} |
| for package_path in package_paths: |
| # We put the imported module into the namespace of |
| # "mesos.<module_type>.<>" to keep it from cluttering up |
| # the import namespace elsewhere. |
| package_name = os.path.basename(package_path) |
| package_dir = os.path.dirname(package_path) |
| module_name = "cli." + module_type + "." + package_name |
| try: |
| module = importlib.import_module(module_name) |
| except Exception: |
| obj, filename, data = imp.find_module(package_name, [package_dir]) |
| module = imp.load_module(module_name, obj, filename, data) |
| modules[package_name] = module |
| |
| return modules |
| |
| |
| def get_module(modules, import_path): |
| """ |
| Given a modules dictionary returned by `import_modules()`, |
| return a reference to the module at `import_path` relative |
| to the base module. For example, get_module(modules, "example.stuff") |
| will return a reference to the "stuff" module inside the |
| imported "example" plugin. |
| """ |
| import_path = import_path.split('.') |
| try: |
| module = modules[import_path[0]] |
| if len(import_path) > 1: |
| module = getattr(module, ".".join(import_path[1:])) |
| except Exception as exception: |
| raise CLIException("Unable to get module: {error}" |
| .format(error=str(exception))) |
| |
| return module |
| |
| |
| def completions(comp_words, current_word, argv): |
| """ |
| Helps autocomplete by returning the appropriate |
| completion words under three conditions. |
| |
| 1) Returns `comp_words` if the completion word is |
| potentially in that list. |
| 2) Returns an empty list if there is no possible |
| completion. |
| 3) Returns `None` if the autocomplete is already done. |
| """ |
| comp_words += ["-h", "--help", "--version"] |
| |
| if not argv: |
| return comp_words |
| |
| if len(argv) == 1: |
| if argv[0] not in comp_words and current_word: |
| return comp_words |
| |
| if argv[0] in comp_words and current_word: |
| return comp_words |
| |
| if argv[0] not in comp_words and not current_word: |
| return [] |
| |
| if argv[0] in comp_words and not current_word: |
| return None |
| |
| if len(argv) > 1 and argv[0] not in comp_words: |
| return [] |
| |
| if len(argv) > 1 and argv[0] in comp_words: |
| return None |
| |
| raise CLIException("Unreachable") |
| |
| |
| def format_commands_help(cmds): |
| """ |
| Helps format plugin commands for display. |
| """ |
| longest_cmd_name = max(list(cmds.keys()), key=len) |
| |
| help_string = "" |
| for cmd in sorted(cmds.keys()): |
| # For the top-level entry point, `cmds` is a single-level |
| # dictionary with `short_help` as the values. For plugins, |
| # `cmds` is a two-level dictionary, where `short_help` is a |
| # field in each sub-dictionary. |
| short_help = cmds[cmd] |
| if isinstance(short_help, dict): |
| short_help = short_help["short_help"] |
| |
| num_spaces = len(longest_cmd_name) - len(cmd) + 2 |
| help_string += " %s%s%s\n" % (cmd, " " * num_spaces, short_help) |
| |
| return help_string |
| |
| |
| def format_subcommands_help(cmd): |
| """ |
| Helps format plugin subcommands for display. |
| """ |
| arguments = " ".join(cmd["arguments"]) |
| short_help = cmd["short_help"] |
| long_help = textwrap.dedent(cmd["long_help"].rstrip()) |
| long_help = " " + "\n ".join(long_help.lstrip().split('\n')) |
| flags = cmd["flags"] |
| flags["-h --help"] = "Show this screen." |
| flag_string = "" |
| |
| if list(flags.keys()) != 0: |
| longest_flag_name = max(list(flags.keys()), key=len) |
| for flag in sorted(flags.keys()): |
| num_spaces = len(longest_flag_name) - len(flag) + 2 |
| flag_string += " %s%s%s\n" % (flag, " " * num_spaces, flags[flag]) |
| flag_string = flag_string.rstrip() |
| |
| return (arguments, short_help, long_help, flag_string) |
| |
| |
| def join_plugin_paths(settings, config): |
| """ |
| Return all the plugin paths combined |
| from both settings and the config file. |
| """ |
| builtin_paths = settings.PLUGINS |
| |
| try: |
| config_paths = config.plugins() |
| except Exception as exception: |
| raise CLIException("Error: {error}.".format(error=str(exception))) |
| |
| return builtin_paths + config_paths |
| |
| |
| def sanitize_address(address): |
| """ |
| Sanitize an address, ensuring that it has a format recognizable by the CLI. |
| """ |
| # Try and parse the address to make sure it is parseable. |
| try: |
| parsed = urllib.parse.urlparse(address) |
| except Exception as exception: |
| raise CLIException("Unable to parse address: {error}" |
| .format(error=str(exception))) |
| |
| # Since we allow addresses to be specified without an |
| # explicit scheme, some fields in the parsed address may |
| # be missing. Patch it up to force an implicit HTTP scheme. |
| if parsed.scheme == "" and parsed.netloc == "": |
| address = "http://{addr}".format(addr=address) |
| elif parsed.scheme == "" and parsed.netloc != "": |
| address = "http:{addr}".format(addr=address) |
| |
| # Try and parse the address again to make sure it |
| # now has all the parts we expect and that they are valid. |
| try: |
| parsed = urllib.parse.urlparse(address) |
| except Exception as exception: |
| raise CLIException("Unable to parse address: {error}" |
| .format(error=str(exception))) |
| |
| # We only support HTTP and HTTPS schemes. |
| if parsed.scheme != "http" and parsed.scheme != "https": |
| raise CLIException("Invalid scheme '{scheme}' in address" |
| .format(scheme=parsed.scheme)) |
| |
| # There must be a hostname present. |
| if parsed.hostname == "": |
| raise CLIException("Missing hostname in address") |
| |
| # We do not support IPv6 in the hostname (yet). |
| try: |
| ipaddress.IPv6Address(parsed.hostname) |
| raise CLIException("IPv6 addresses are unsupported") |
| except Exception as exception: |
| pass |
| |
| valid_ip_v4_address = False |
| |
| # We either accept IPv4 addresses, or DNS names as the hostname. In the |
| # check below we try and parse the hostname as an IPv4 address, if this |
| # does not succeed, then we assume the hostname is formatted as a DNS name. |
| try: |
| ipaddress.IPv4Address(parsed.hostname) |
| valid_ip_v4_address = True |
| except Exception as exception: |
| pass |
| |
| # If we have an IPv4 address then we require a port to be specified. |
| if valid_ip_v4_address and parsed.port is None: |
| raise CLIException("Addresses formatted as IP must contain a port") |
| |
| # We allow ports for both IPv4 addresses and DNS |
| # names, but they must be in a specific range. |
| if parsed.port and (parsed.port < 0 or parsed.port > 65535): |
| raise CLIException("Port '{port}' is out of range" |
| .format(port=parsed.port)) |
| |
| return address |
| |
| |
| def zookeeper_resolve_leader(addresses, path): |
| """ |
| Resolve the leader using a znode path. ZooKeeper imposes a total |
| order on the elements of the queue, guaranteeing that the |
| oldest element of the queue is the first one. We can |
| thus return the first address we get from ZooKeeper. |
| """ |
| hosts = ",".join(addresses) |
| |
| try: |
| zk = KazooClient(hosts=hosts) |
| zk.start() |
| except Exception as exception: |
| raise CLIException("Unable to initialize Zookeeper Client: {error}" |
| .format(error=exception)) |
| |
| try: |
| children = zk.get_children(path) |
| except Exception as exception: |
| raise CLIException("Unable to get children of {zk_path}: {error}" |
| .format(zk_path=path, error=exception)) |
| |
| masters = sorted( |
| # 'json.info' is the prefix for master nodes. |
| child for child in children if child.startswith("json.info") |
| ) |
| |
| address = "" |
| for master in masters: |
| try: |
| node_path = "{path}/{node}".format(path=path, node=master) |
| json_data, _ = zk.get(node_path) |
| except Exception as exception: |
| raise CLIException("Unable to get the value of '{node}': {error}" |
| .format(node=node_path, error=exception)) |
| |
| try: |
| data = json.loads(json_data) |
| except Exception as exception: |
| raise CLIException("Could not load JSON from '{data}': {error}" |
| .format(data=data, error=str(exception))) |
| |
| if ("address" in data and "ip" in data["address"] and |
| "port" in data["address"]): |
| address = "{ip}:{port}".format(ip=data["address"]["ip"], |
| port=data["address"]["port"]) |
| break |
| |
| try: |
| zk.stop() |
| except Exception as exception: |
| raise CLIException("Unable to stop Zookeeper Client: {error}" |
| .format(error=exception)) |
| |
| if not address: |
| raise CLIException("Unable to resolve the leading" |
| " master using ZooKeeper") |
| return address |
| |
| |
| class Table(): |
| """ |
| Defines a custom table structure for printing to the terminal. |
| """ |
| def __init__(self, columns): |
| """ |
| Initialize a table with a list of column names |
| to act as headers for each column in the table. |
| """ |
| if not isinstance(columns, list): |
| raise CLIException("Column headers must be supplied as a list") |
| |
| for column in columns: |
| if re.search(r"(\s)\1{2,}", column): |
| raise CLIException("Column headers cannot have more" |
| " than one space between words") |
| |
| self.table = [columns] |
| self.padding = [len(column) for column in columns] |
| |
| def __getitem__(self, index): |
| return list(self.table[index]) |
| |
| def dimensions(self): |
| """ |
| Returns the dimensions of the table as (<num-rows>, <num-columns>). |
| """ |
| return (len(self.table), len(self.table[0])) |
| |
| def add_row(self, row): |
| """ |
| Add a row to the table. Input must be a list where each entry |
| corresponds to its respective column in order. |
| """ |
| if len(row) != len(self.table[0]): |
| raise CLIException("Number of entries and columns do not match!") |
| |
| # Adjust padding for each column. |
| for index, elem in enumerate(row): |
| if len(elem) > self.padding[index]: |
| self.padding[index] = len(elem) |
| |
| self.table.append(row) |
| |
| def __str__(self): |
| """ |
| Convert a table to string for printing. |
| """ |
| table_string = "" |
| for r_index, row in enumerate(self.table): |
| for index, entry in enumerate(row): |
| table_string += "%s%s" % \ |
| (entry, " " * (self.padding[index] - len(entry) + 2)) |
| |
| if r_index != len(self.table) - 1: |
| table_string += "\n" |
| |
| return table_string |
| |
| @staticmethod |
| def parse(string): |
| """ |
| Parse a string previously printed as a `Table` back into a `Table`. |
| """ |
| lines = string.split("\n") |
| |
| # Find the location and contents of column headers in the string. |
| # Assume only single spaces between words in column headers. |
| matches = re.finditer(r"([\w\d]+\s?[\w\d]+)+", lines[0]) |
| columns = [(m.start(), m.group()) for m in matches] |
| |
| # Build a table from the column header contents. |
| table = Table([c[1] for c in columns]) |
| |
| # Fill in the subsequent rows. |
| for line in lines[1:]: |
| row = [] |
| start_indices = [c[0] for c in columns] |
| |
| for i, start_index in enumerate(start_indices): |
| if i + 1 < len(start_indices): |
| column = line[start_index:start_indices[i + 1]] |
| else: |
| column = line[start_index:] |
| |
| row.append(str(column.strip())) |
| |
| table.add_row(row) |
| |
| return table |
