# vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright (C) 2012 Yahoo! Inc. All Rights Reserved. # # Copyright 2011 OpenStack LLC. # All Rights Reserved. # # Licensed 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. import distutils.version import json import netifaces import os import platform import random import re import socket import sys import termcolor from devstack import colorlog from devstack import exceptions as excp from devstack import log as logging from devstack import settings from devstack import shell as sh from devstack import version # The pattern will match either a comment to the EOL, or a # token to be subbed. The replacer will check which it got and # act accordingly. Note that we need the MULTILINE flag # for the comment checks to work in a string containing newlines PARAM_SUB_REGEX = re.compile(r"#.*$|%([\w\d]+?)%", re.MULTILINE) EXT_COMPONENT = re.compile(r"^\s*([\w-]+)(?:\((.*)\))?\s*$") MONTY_PYTHON_TEXT_RE = re.compile("([a-z0-9A-Z\?!.,'\"]+)") LOG = logging.getLogger("devstack.util") DEF_IP = "127.0.0.1" IP_LOOKER = '8.8.8.8' DEF_IP_VERSION = settings.IPV4 PRIVATE_OCTS = [] ALL_NUMS = re.compile(r"^\d+$") START_NUMS = re.compile(r"^(\d+)(\D+)") STAR_VERSION = 0 #thx cowsay COWS = dict() COWS['happy'] = r''' {header} \ {ear}__{ear} \ ({eye}{eye})\_______ (__)\ )\/\ ||----w | || || ''' COWS['unhappy'] = r''' {header} \ || || \ __ ||-----mm|| \ ( )/_________)// ({eye}{eye})/ {ear}--{ear} ''' def configure_logging(verbosity_level=1, dry_run=False): # Debug by default root_logger = logging.getLogger().logger root_logger.setLevel(logging.DEBUG) # Set our pretty logger console_logger = logging.StreamHandler(sys.stdout) console_format = '%(levelname)s: @%(name)s : %(message)s' if sh.in_terminal(): console_logger.setFormatter(colorlog.TermFormatter(console_format)) else: console_logger.setFormatter(logging.Formatter(console_format)) root_logger.addHandler(console_logger) # Adjust logging verbose level based on the command line switch. log_level = logging.INFO if verbosity_level >= 3: log_level = logging.DEBUG elif verbosity_level == 2 or dry_run: log_level = logging.AUDIT root_logger.setLevel(log_level) def load_template(component, template_name): full_pth = sh.joinpths(settings.STACK_TEMPLATE_DIR, component, template_name) contents = sh.load_file(full_pth) return (full_pth, contents) def execute_template(*cmds, **kargs): params_replacements = kargs.pop('params', None) ignore_missing = kargs.pop('ignore_missing', False) cmd_results = list() for cmdinfo in cmds: cmd_to_run_templ = cmdinfo["cmd"] cmd_to_run = param_replace_list(cmd_to_run_templ, params_replacements, ignore_missing) stdin_templ = cmdinfo.get('stdin') stdin = None if stdin_templ: stdin_full = param_replace_list(stdin_templ, params_replacements, ignore_missing) stdin = joinlinesep(*stdin_full) exec_result = sh.execute(*cmd_to_run, run_as_root=cmdinfo.get('run_as_root', False), process_input=stdin, ignore_exit_code=cmdinfo.get('ignore_failure', False), **kargs) cmd_results.append(exec_result) return cmd_results def to_bytes(text): byte_val = 0 if not text: return byte_val if text[-1].upper() == 'G': byte_val = int(text[:-1]) * 1024 ** 3 elif text[-1].upper() == 'M': byte_val = int(text[:-1]) * 1024 ** 2 elif text[-1].upper() == 'K': byte_val = int(text[:-1]) * 1024 elif text[-1].upper() == 'B': byte_val = int(text[:-1]) else: byte_val = int(text) return byte_val def import_module(module_name): try: __import__(module_name) return sys.modules.get(module_name, None) except ImportError: return None def load_json(fn): data = sh.load_file(fn) lines = data.splitlines() new_lines = list() for line in lines: if line.lstrip().startswith('#'): continue new_lines.append(line) data = joinlinesep(*new_lines) return json.loads(data) def versionize(input_version): segments = input_version.split(".") cleaned_segments = list() for piece in segments: piece = piece.strip() if len(piece) == 0: msg = "Disallowed empty version segment found" raise ValueError(msg) piece = piece.strip("*") if len(piece) == 0: cleaned_segments.append(STAR_VERSION) elif ALL_NUMS.match(piece): cleaned_segments.append(int(piece)) else: piece_match = START_NUMS.match(piece) if not piece_match: msg = "Unknown version identifier %s" % (piece) raise ValueError(msg) else: cleaned_segments.append(int(piece_match.group(1))) if not cleaned_segments: msg = "Disallowed empty version found" raise ValueError(msg) num_parts = [str(p) for p in cleaned_segments] return distutils.version.LooseVersion(".".join(num_parts)) def sort_versions(versions, descending=True): if not versions: return list() version_cleaned = list() for v in versions: version_cleaned.append(versionize(v)) versions_sorted = sorted(version_cleaned) if not descending: versions_sorted.reverse() return versions_sorted def get_host_ip(): """ Returns the actual ip of the local machine. This code figures out what source address would be used if some traffic were to be sent out to some well known address on the Internet. In this case, a private address is used, but the specific address does not matter much. No traffic is actually sent. """ ip = None try: csock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) csock.connect((IP_LOOKER, 80)) (addr, _) = csock.getsockname() csock.close() ip = addr except socket.error: pass #attempt to find it if not ip: interfaces = get_interfaces() for (_, net_info) in interfaces.items(): ip_info = net_info.get(DEF_IP_VERSION) if ip_info: a_ip = ip_info.get('addr') or "" first_oct = a_ip.split(".")[0] if first_oct and first_oct not in PRIVATE_OCTS: ip = a_ip break #just return a localhost version then if not ip: ip = DEF_IP return ip def is_interface(intfc): if intfc in get_interfaces(): return True return False def get_interfaces(): interfaces = dict() for intfc in netifaces.interfaces(): interface_info = dict() interface_addresses = netifaces.ifaddresses(intfc) ip6 = interface_addresses.get(netifaces.AF_INET6) if ip6 and len(ip6): #just take the first interface_info[settings.IPV6] = ip6[0] ip4 = interface_addresses.get(netifaces.AF_INET) if ip4 and len(ip4): #just take the first interface_info[settings.IPV4] = ip4[0] #there are others but this is good for now interfaces[intfc] = interface_info return interfaces def determine_distro(): plt = platform.platform() #ensure its a linux distro (distname, _, _) = platform.linux_distribution() if not distname: return (None, plt) #attempt to match it to our platforms found_os = None for (known_os, pattern) in settings.KNOWN_DISTROS.items(): if pattern.search(plt): found_os = known_os break return (found_os, plt) def extract_pip_list(fns, distro, all_pips=None): if not all_pips: all_pips = dict() for fn in fns: js = load_json(fn) distro_pips = js.get(distro) if distro_pips: all_pips.update(distro_pips) return all_pips def extract_pkg_list(fns, distro, all_pkgs=None): if not all_pkgs: all_pkgs = dict() for fn in fns: js = load_json(fn) distro_pkgs = js.get(distro) if distro_pkgs: all_pkgs.update(distro_pkgs) return all_pkgs def get_components_order(components): if not components: return dict() #deep copy so components isn't messed with all_components = dict() for (name, deps) in components.items(): all_components[name] = set(deps) #figure out which ones have no one depending on them no_deps_components = set() for (name, deps) in all_components.items(): referenced = False for (_name, _deps) in all_components.items(): if _name == name: continue else: if name in _deps: referenced = True break if not referenced: no_deps_components.add(name) if not no_deps_components: msg = "Components specifed have no root components, there is most likely a dependency cycle!" raise excp.DependencyException(msg) #now we have to do a quick check to ensure no component is causing a cycle for (root, deps) in all_components.items(): #DFS down through the "roots" deps and there deps and so on and #ensure that nobody is referencing the "root" component name, #that would mean there is a cycle if a dependency of the "root" is. active_deps = list(deps) checked_deps = dict() while len(active_deps): dep = active_deps.pop() itsdeps = all_components.get(dep) checked_deps[dep] = True if root in itsdeps: msg = "Circular dependency between component %s and component %s!" % (root, dep) raise excp.DependencyException(msg) else: for d in itsdeps: if d not in checked_deps and d not in active_deps: active_deps.append(d) #now form the order #basically a topological sorting #https://en.wikipedia.org/wiki/Topological_sorting ordering = list() no_edges = set(no_deps_components) while len(no_edges): node = no_edges.pop() ordering.append(node) its_deps = all_components.get(node) while len(its_deps): name = its_deps.pop() referenced = False for (_name, _deps) in all_components.items(): if _name == name: continue else: if name in _deps: referenced = True break if not referenced: no_edges.add(name) #should now be no edges else something bad happended for (_, deps) in all_components.items(): if len(deps): msg = "Your specified components have at least one cycle!" raise excp.DependencyException(msg) #reverse so its in the right order for us since we just determined #the pkgs that have no one depending on them (which should be installed #last and those that have incoming edges that packages are depending on need #to go first, but those were inserted last), so this reverse fixes that ordering.reverse() return ordering def joinlinesep(*pieces): return os.linesep.join(pieces) def service_enabled(name, components, empty_true=True): if not components and empty_true: return True if not components: return False if name in components: return True return False def param_replace_list(values, replacements, ignore_missing=False): new_values = list() if not values: return new_values for v in values: if v is not None: new_values.append(param_replace(str(v), replacements, ignore_missing)) return new_values def find_params(text): params_found = set() if not text: return params_found def finder(match): org_txt = match.group(0) # Check if it's a comment, if so just return what it was and ignore # any tokens that were there if org_txt.startswith("#"): return org_txt param_name = match.group(1) if param_name not in params_found: params_found.add(param_name) return org_txt PARAM_SUB_REGEX.sub(finder, text) return params_found def param_replace(text, replacements, ignore_missing=False): if not replacements: replacements = dict() if not text: return "" if ignore_missing: LOG.debug("Performing parameter replacements (ignoring missing) on text [%s]" % (text)) else: LOG.debug("Performing parameter replacements (not ignoring missing) on text [%s]" % (text)) possible_params = find_params(text) LOG.debug("Possible replacements are [%s]" % (", ".join(possible_params))) def replacer(match): org_txt = match.group(0) param_name = match.group(1) # Check if it's a comment, if so just return what it was and ignore # any tokens that were there if org_txt.startswith('#'): LOG.debug("Ignoring comment line") return org_txt replacer = replacements.get(param_name) if replacer is None and ignore_missing: replacer = org_txt elif replacer is None and not ignore_missing: msg = "No replacement found for parameter %s" % (org_txt) raise excp.NoReplacementException(msg) else: replacer = str(replacer) LOG.debug("Replacing [%s] with [%s]" % (org_txt, replacer)) return replacer replaced_text = PARAM_SUB_REGEX.sub(replacer, text) LOG.debug("Replacement/s resulted in text [%s]" % (replaced_text)) return replaced_text def _get_welcome_stack(): possibles = list() #thank you figlet ;) possibles.append(r''' ___ ____ _____ _ _ ____ _____ _ ____ _ __ / _ \| _ \| ____| \ | / ___|_ _|/ \ / ___| |/ / | | | | |_) | _| | \| \___ \ | | / _ \| | | ' / | |_| | __/| |___| |\ |___) || |/ ___ \ |___| . \ \___/|_| |_____|_| \_|____/ |_/_/ \_\____|_|\_\ ''') possibles.append(r''' ___ ___ ___ _ _ ___ _____ _ ___ _ __ / _ \| _ \ __| \| / __|_ _/_\ / __| |/ / | (_) | _/ _|| .` \__ \ | |/ _ \ (__| ' < \___/|_| |___|_|\_|___/ |_/_/ \_\___|_|\_\ ''') possibles.append(r''' ____ ___ ____ _ _ ____ ___ ____ ____ _ _ | | |__] |___ |\ | [__ | |__| | |_/ |__| | |___ | \| ___] | | | |___ | \_ ''') possibles.append(r''' _ ___ ___ _ _ __ ___ _ __ _ _ / \| o \ __|| \| |/ _||_ _|/ \ / _|| |// ( o ) _/ _| | \\ |\_ \ | || o ( (_ | ( \_/|_| |___||_|\_||__/ |_||_n_|\__||_|\\ ''') possibles.append(r''' _ ___ ___ _ __ ___ _____ _ __ _ ,' \ / o |/ _/ / |/ /,' _//_ _/.' \ ,'_/ / //7 / o |/ _,'/ _/ / || /_\ `. / / / o // /_ / ,' |_,'/_/ /___//_/|_//___,' /_/ /_n_/ |__//_/\\ ''') possibles.append(r''' _____ ___ ___ _ _ ___ _____ _____ ___ _ _ ( _ )( _`\ ( _`\ ( ) ( )( _`\(_ _)( _ )( _`\ ( ) ( ) | ( ) || |_) )| (_(_)| `\| || (_(_) | | | (_) || ( (_)| |/'/' | | | || ,__/'| _)_ | , ` |`\__ \ | | | _ || | _ | , < | (_) || | | (_( )| |`\ |( )_) | | | | | | || (_( )| |\`\ (_____)(_) (____/'(_) (_)`\____) (_) (_) (_)(____/'(_) (_) ''') return random.choice(possibles).strip("\n\r") def center_text(text, fill, max_len): centered_str = '{0:{fill}{align}{size}}'.format(text, fill=fill, align="^", size=max_len) return centered_str def _welcome_slang(): potentials = list() potentials.append("And now for something completely different!") return random.choice(potentials).strip("\n\r") def color_text(text, color, bold=False, underline=False, blink=False, always_color=False): text_attrs = list() if bold: text_attrs.append('bold') if underline: text_attrs.append('underline') if blink: text_attrs.append('blink') if sh.in_terminal() or always_color: return termcolor.colored(text, color, attrs=text_attrs) else: return text def _color_blob(text, text_color): def replacer(match): contents = match.group(1) return color_text(contents, text_color) return MONTY_PYTHON_TEXT_RE.sub(replacer, text) def _goodbye_header(worked): #cowsay headers potentials_oks = list() potentials_oks.append(r''' ___________ / You shine \ | out like | | a shaft | | of gold | | when all | | around is | \ dark. / ----------- ''') potentials_oks.append(r''' ______________________________ < I'm a lumberjack and I'm OK. > ------------------------------ ''') potentials_oks.append(r''' ____________________ / Australia! \ | Australia! | | Australia! | \ We love you, amen. / -------------------- ''') potentials_oks.append(r''' ______________ / Say no more, \ | Nudge nudge | \ wink wink. / -------------- ''') potentials_oks.append(r''' ________________ / And there was \ \ much rejoicing / ---------------- ''') potentials_oks.append(r''' __________ < Success! > ----------''') potentials_fails = list() potentials_fails.append(r''' __________ < Failure! > ---------- ''') potentials_fails.append(r''' ___________ < Run away! > ----------- ''') potentials_fails.append(r''' ______________________ / NOBODY expects the \ \ Spanish Inquisition! / ---------------------- ''') potentials_fails.append(r''' ______________________ / Spam spam spam spam \ \ baked beans and spam / ---------------------- ''') potentials_fails.append(r''' ____________________ / Brave Sir Robin \ \ ran away. / -------------------- ''') potentials_fails.append(r''' _______________________ < Message for you, sir. > ----------------------- ''') potentials_fails.append(r''' ____________________ / We are the knights \ \ who say.... NI! / -------------------- ''') potentials_fails.append(r''' ____________________ / Now go away or I \ | shall taunt you a | \ second time. / -------------------- ''') potentials_fails.append(r''' ____________________ / It's time for the \ | penguin on top of | | your television to | \ explode. / -------------------- ''') potentials_fails.append(r''' _____________________ / We were in the nick \ | of time. You were | \ in great peril. / --------------------- ''') potentials_fails.append(r''' ___________________ / I know a dead \ | parrot when I see | | one, and I'm | | looking at one | \ right now. / ------------------- ''') potentials_fails.append(r''' _________________ / Welcome to the \ | National Cheese | \ Emporium / ----------------- ''') potentials_fails.append(r''' ______________________ / What is the airspeed \ | velocity of an | \ unladen swallow? / ---------------------- ''') potentials_fails.append(r''' ______________________ / Now stand aside, \ \ worthy adversary. / ---------------------- ''') potentials_fails.append(r''' ___________________ / Okay, we'll call \ \ it a draw. / ------------------- ''') potentials_fails.append(r''' _______________ / She turned me \ \ into a newt! / --------------- ''') potentials_fails.append(r''' ___________________ < Fetchez la vache! > ------------------- ''') potentials_fails.append(r''' __________________________ / We'd better not risk \ | another frontal assault, | \ that rabbit's dynamite. / -------------------------- ''') potentials_fails.append(r''' ______________________ / This is supposed to \ | be a happy occasion. | | Let's not bicker and | | argue about who | \ killed who. / ---------------------- ''') potentials_fails.append(r''' _______________________ < You have been borked. > ----------------------- ''') potentials_fails.append(r''' __________________ / We used to dream \ | of living in a | \ corridor! / ------------------- ''') if not worked: msg = random.choice(potentials_fails).strip("\n\r") colored_msg = _color_blob(msg, 'red') else: msg = random.choice(potentials_oks).strip("\n\r") colored_msg = _color_blob(msg, 'green') return colored_msg def goodbye(worked): if worked: cow = COWS['happy'] eye_fmt = color_text('o', 'green') ear = color_text("^", 'green') else: cow = COWS['unhappy'] eye_fmt = color_text("o", 'red') ear = color_text("v", 'red') cow = cow.strip("\n\r") header = _goodbye_header(worked) msg = cow.format(eye=eye_fmt, ear=ear, header=header) print(msg) def parse_components(components): if not components: return dict() adjusted_components = dict() for c in components: mtch = EXT_COMPONENT.match(c) if mtch: component_name = mtch.group(1).lower().strip() if component_name in settings.COMPONENT_NAMES: component_opts = mtch.group(2) components_opts_cleaned = None if component_opts: components_opts_cleaned = list() sp_component_opts = component_opts.split(",") for co in sp_component_opts: cleaned_opt = co.strip() if cleaned_opt: components_opts_cleaned.append(cleaned_opt) adjusted_components[component_name] = components_opts_cleaned return adjusted_components def welcome(ident): lower = "| %s %s |" % (ident, version.version_string()) welcome_header = _get_welcome_stack() max_line_len = len(max(welcome_header.splitlines(), key=len)) footer = color_text(settings.PROG_NICE_NAME, 'green') footer += ": " footer += color_text(lower, 'blue', True) uncolored_footer = (settings.PROG_NICE_NAME + ": " + lower) if max_line_len - len(uncolored_footer) > 0: #this format string will center the uncolored text which #we will then replace with the color text equivalent centered_str = center_text(uncolored_footer, " ", max_line_len) footer = centered_str.replace(uncolored_footer, footer) print(welcome_header) print(footer) real_max = max(max_line_len, len(uncolored_footer)) slang = center_text(_welcome_slang(), ' ', real_max) print(color_text(slang, 'magenta', bold=True)) return ("-", real_max)