#!/usr/bin/env python # vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright (C) 2012 Yahoo! Inc. 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 sys import time import traceback from devstack import cfg from devstack import cfg_helpers from devstack import date from devstack import distro from devstack import env from devstack import env_rc from devstack import log as logging from devstack import opts from devstack import passwords from devstack import persona from devstack import settings from devstack import shell as sh from devstack import utils from devstack.progs import actions LOG = logging.getLogger("devstack.stack") # This is used to map an action to a useful string for # the welcome display _WELCOME_MAP = { settings.INSTALL: "INSTALLER", settings.UNINSTALL: "UNINSTALLER", settings.START: "STARTER", settings.STOP: "STOPPER", } _CFG_GROUPS = { cfg_helpers.make_id('passwords', None): 'Passwords', cfg_helpers.make_id('db', None): 'Database info', # Catch all cfg_helpers.make_id(None, None): 'Misc configs', } _CFG_ORDERING = sorted(_CFG_GROUPS.keys()) _CFG_ORDERING.reverse() def dump_config(config_cache): def item_format(key, value): return "\t%s=%s" % (str(key), str(value)) def map_print(mp): for key in sorted(mp.keys()): value = mp.get(key) LOG.info(item_format(key, value)) # First partition into our groups partitions = dict() for name in _CFG_ORDERING: partitions[name] = dict() # Now put the config cached values into there partitions for (k, v) in config_cache.items(): for name in _CFG_ORDERING: entries = partitions[name] if k.startswith(name): entries[k] = v break # Now print them.. for name in _CFG_ORDERING: nice_name = _CFG_GROUPS.get(name) LOG.info(nice_name + ":") entries = partitions.get(name) if entries: map_print(entries) def load_rc_files(): fns = [settings.OSRC_FN] for fn in fns: try: LOG.debug("Attempting to load rc file at [%s] which has your environment settings." % (fn)) am_loaded = env_rc.RcReader().load(fn) LOG.debug("Loaded [%s] settings from rc file [%s]" % (am_loaded, fn)) except IOError: LOG.warn('Error reading rc file located at [%s]. Skipping loading it.' % (fn)) return len(fns) def load_verify_persona(fn, dist): instance = persona.Persona.load_file(fn) instance.verify(dist) return instance def setup_root(root_dir): if not sh.isdir(root_dir): sh.mkdir(root_dir) def run(args): action = args.pop("action", '').strip().lower() if not (action in settings.ACTIONS): print(utils.color_text("No valid action specified!", "red")) return False loaded_rcs = False root_dir = args.pop("dir") if not root_dir: load_rc_files() loaded_rcs = True root_dir = env.get_key(env_rc.INSTALL_ROOT) if not root_dir: print(utils.color_text("No root directory specified!", "red")) return False root_dir = sh.abspth(root_dir) setup_root(root_dir) persona_fn = args.pop('persona_fn') if not persona_fn or not sh.isfile(persona_fn): print(utils.color_text("No valid persona file name specified!", "red")) return False persona_fn = sh.abspth(persona_fn) # Welcome! (repeat_string, line_max_len) = utils.welcome(_WELCOME_MAP.get(action)) print(utils.center_text("Action Runner", repeat_string, line_max_len)) # !! # Here on out we should be using the logger (and not print)!! # !! # If we didn't load them before, load them now if not loaded_rcs: load_rc_files() loaded_rcs = True # Stash the dryrun value (if any) into the global configuration sh.set_dryrun(args.get('dryrun', False)) # Params for the runner... dist = distro.Distro.get_current() persona_inst = load_verify_persona(persona_fn, dist) config = cfg.get_config() pw_gen = passwords.PasswordGenerator(config, args.get('prompt_for_passwords', True)) pkg_cls = dist.get_packager_factory() pkg_manager = pkg_cls(dist, args.get('keep_old', False)) runner = actions.ActionRunner(dist, action, config, pw_gen, pkg_manager, **args) LOG.info("Starting action %r on %s for distro: %r" % (action, date.rcf8222date(), dist.name)) LOG.info("Using persona: %r" % (persona_fn)) LOG.info("In root directory: %r" % (root_dir)) start_time = time.time() runner.run(persona_inst, root_dir) end_time = time.time() LOG.info("It took (%s) to complete action [%s]" % (utils.format_secs_taken((end_time - start_time)), action)) LOG.info("After action [%s] your settings which were created or read are:" % (action)) dump_config(config.configs_fetched) return True def main(): # Do this first so people can see the help message... args = opts.parse() prog_name = sys.argv[0] # Configure logging utils.configure_logging(args['verbosity'], args['dryrun']) LOG.debug("Command line options %s" % (args)) # Will need root to setup openstack if not sh.got_root(): rest_args = sys.argv[1:] print("This program requires a user with sudo access.") msg = "Perhaps you should try %s %s" % \ (utils.color_text("sudo %s" % (prog_name), "red", True), " ".join(rest_args)) print(msg) return 1 try: # Drop to usermode sh.user_mode(False) started_ok = run(args) if not started_ok: me = utils.color_text(prog_name, "red", True) me += " " + utils.color_text('--help', 'red') print("Perhaps you should try %s" % (me)) return 1 else: utils.goodbye(True) return 0 except Exception: utils.goodbye(False) traceback.print_exc(file=sys.stdout) return 1 if __name__ == "__main__": sys.exit(main())