788 lines
23 KiB
Python
788 lines
23 KiB
Python
# 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(stream=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 >= 2:
|
|
log_level = logging.DEBUG
|
|
elif 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)
|