copilot.py

#!/usr/bin/env python2

import urwid
import inspect
import sys
import os
import traceback
import shutil
import time
import logging
import argparse

import ceph_ansible_copilot

from ceph_ansible_copilot.utils import (PluginMgr, restore_ansible_cfg,
                                        SSHConfig)

from ceph_ansible_copilot.ui import (UI_Welcome,
                                     UI_Environment,
                                     UI_Host_Definition,
                                     UI_Credentials,
                                     UI_Host_Validation,
                                     UI_Network,
                                     UI_Commit,
                                     UI_Deploy,
                                     UI_Finish,
                                     Breadcrumbs,
                                     ProgressOverlay)

from ceph_ansible_copilot.ui.palette import palette

CEPH_ANSIBLE_ROOT = '/usr/share/ceph-ansible'


def unknown_input(key):

    if key == 'esc':
        raise urwid.ExitMainLoop


class Settings(object):

    def __repr__(self):
        items = [(attr, getattr(self, attr))
                 for attr in self.__dict__ if not attr.startswith('_')]
        s = '\n'
        for attr, value in items:
            if isinstance(value, Settings):
                s += '{}:\n'.format(attr)
                sub_items = repr(value).split("\n")
                for i in sub_items[:-1]:
                    s += '- {}\n'.format(i)
            else:
                s += '{}: {}\n'.format(attr, value)
        return s


class Config(Settings):

    # TODO : read a config file to set up defaults
    # and merge with a saved config

    def __init__(self):
        self.defaults = Settings()
        self.defaults.osd_objectstore = 'filestore'
        self.defaults.sw_src = 'RH CDN'
        self.defaults.dmcrypt = 'standard'
        self.defaults.playbook = '/usr/share/ceph-ansible/site.yml'

        self.hosts = None


def get_ui_sections():
    sections = {}

    for name, obj in inspect.getmembers(sys.modules[__name__],
                                        inspect.isclass):
        if name.startswith('UI_'):
            ui_class = getattr(sys.modules[__name__], name)
            if "seq_no" in ui_class.__dict__:
                seq_no = ui_class.seq_no
            else:
                seq_no = ui_class.lineno()
            sections[seq_no] = (ui_class, ui_class.title)

    return sections


class App(object):
    """
    Main control logic object. It constructs the interface from the other
    classes
    """

    def __init__(self):

        pgm = '{} v{}'.format(
                         os.path.splitext(os.path.basename(__file__))[0],
                         ceph_ansible_copilot.__version__)

        banner = urwid.Columns([
            urwid.Text(("title", pgm),
                       align='left'),
            urwid.Text(("title", "[{}]".format(opts.mode)),
                       align='right')
        ])

        self.title = urwid.AttrMap(banner, "title")

        self.timestamp = None
        self.file_timestamp = None
        self.log = None
        self.pagenum = 0
        self.page = []      # list of UI pages/views
        self.pb_active = False
        self.pb_complete = 0
        self.pb = None
        self.debug = None           # used to check state during debugging

        self.plugin_mgr = None
        self.ssh = None

        self.msg = None
        self.msg_text = None
        self.left_pane = None
        self.right_pane = None
        self.top = None

        self.loop = None
        self.cfg = Config()
        self.opts = opts
        self.hosts = dict()

        if opts.playbook:
            self.playbook = opts.playbook
        else:
            self.playbook = self.cfg.defaults.playbook

        self.ansible_cfg = os.path.join(CEPH_ANSIBLE_ROOT, 'ansible.cfg')
        self.ansible_cfg_bkup = '{}_bak'.format(self.ansible_cfg)

    def refresh_ui(self, left=None, right=None):
        if not left:
            left = self.left_pane.breadcrumbs
        if not right:
            right = self.page[self.pagenum].render_page

        body = urwid.Columns([('fixed',
                               Breadcrumbs.breadcrumb_width,
                               left),
                              right])

        self.top = urwid.Frame(body,
                               header=self.title,
                               footer=self.msg)

    def next_page(self):
        if self.pagenum < len(self.page) - 1:
            self.pagenum += 1

        copilot.left_pane.update()
        self.msg_text = self.page[self.pagenum].hint
        self.show_message(self.msg_text)

        new_page = self.page[self.pagenum]
        new_page.refresh()

        copilot.refresh_ui(left=self.left_pane.breadcrumbs,
                           right=new_page.render_page)

        self.loop.widget = self.top

    def execute_plugins(self):

        self.cfg.hosts = self.hosts
        self.cfg.ceph_version = opts.ceph_version
        self.cfg.cluster_name = opts.cluster_name

        self.log.info("Configuration options supplied:")
        self.log.info(self.cfg)

        self.log.info("End of options")

        plugin_status = {
            "successful": 0,
            "failed": 0
        }

        num_plugins = len(self.plugin_mgr.plugins)
        if num_plugins > 0:
            self.log.info("Plugin execution starting..")

        srtd_names = sorted(self.plugin_mgr.plugins.keys())

        plugins = self.plugin_mgr.plugins

        for plugin_name in srtd_names:
            mod = plugins[plugin_name].module
            yml_file = mod.yml_file

            try:
                self.log.info("Plugin: {}".format(plugin_name))
                plugin_data = mod.plugin_main(self.cfg)

                plugins[plugin_name].executed = True

            except BaseException as error:
                # Use BaseException as a catch-all from the plugins
                plugin_status['failed'] += 1
                self.log.error("Plugin '{}' failed : "
                               "{}".format(plugin_name,
                                           sys.exc_info()[0]))
                self.log.debug(traceback.format_exc())
                break
            else:
                plugin_status['successful'] += 1
                if isinstance(plugin_data, tuple):
                    f_type, contents = plugin_data
                    if contents:
                        self.write_yml(yml_file, contents, f_type)
                        self.log.info("Plugin updated {}".format(yml_file))
                    else:
                        self.log.info("Plugin - no data written to "
                                      "{}".format(yml_file))
                elif not plugin_data:
                    self.log.info("backup and update handled by plugin")

        skipped = num_plugins - (plugin_status['successful'] +
                                 plugin_status['failed'])

        self.log.info("{} plugin(s) sucessful, "
                      "{} failed, "
                      "{} skipped".format(plugin_status['successful'],
                                          plugin_status['failed'],
                                          skipped))

        return plugin_status

    def write_yml(self, yml_file, contents, file_type='yml'):
        self.bkup_yml(yml_file)
        contents.insert(0, ' ')
        contents.insert(0, "# created by copilot - only overrides from"
                           " defaults shown {}".format(self.file_timestamp))
        if file_type == 'yml':
            contents.insert(0, '---')

        # unbuffered write
        with open(yml_file, 'w', 0) as f:
            f.write("\n".join(contents))

        # read it back
        with open(yml_file, 'r') as f:
            contents = f.readlines()

    def bkup_yml(self, yml_file):

        if os.path.exists(yml_file):
            yml_file_bkup = '{}_{}'.format(yml_file,
                                           self.timestamp)
            shutil.copy2(yml_file, yml_file_bkup)
            self.log.info("YML file {}, copied to {}".format(yml_file,
                                                             yml_file_bkup))
        else:
            self.log.warning("Existing file {}, not found".format(yml_file))

    def show_message(self, msg_text, immediate=False):
        self.msg_text = msg_text
        msg = msg_text.lower()
        if msg.startswith('error'):
            attr = 'error_message'
        elif msg.startswith('warning'):
            attr = 'warning message'
        else:
            attr = 'message'
        self.msg.set_attr_map({None: attr})
        self.msg.base_widget.set_text(self.msg_text)

        if immediate:
            self.loop.draw_screen()

    def progress_bar(self, complete=0):
        if not self.pb_active:
            # turn on a progress bar
            self.pb_active = True

            self.pb = ProgressOverlay(bottom_w=self.top, complete=complete)
            self.loop.widget = self.pb
            self.loop.draw_screen()
        else:
            # turn the progress bar off
            self.pb_active = False
            self.pb = None
            self.loop.widget = self.top
            self.loop.draw_screen()

    def progress_bar_update(self, stats):
        if self.pb_active:
            task_state = stats['task_state']
            done = sum([task_state[item] for item in task_state])
            self.loop.widget = self.pb.update(done)
            self.loop.draw_screen()

        else:
            return

    def setup(self):

        self.ssh = SSHConfig()
        if not self.ssh.configured:
            print("Unable to access/create ssh keys")
            sys.exit(4)

        self.file_timestamp = time.ctime()
        self.timestamp = int(time.time())
        self.log = setup_logging()
        self.log.info("{} (v{}) starting at "
                      "{}".format(os.path.basename(__file__),
                                  ceph_ansible_copilot.__version__,
                                  self.file_timestamp))

        self._setup_dirs()

        self.plugin_mgr = PluginMgr(logger=self.log)
        self.log.info("{} plugin(s) "
                      "loaded".format(len(self.plugin_mgr.plugins)))

        for plugin_name in self.plugin_mgr.plugins:
            mod = self.plugin_mgr.plugins[plugin_name].module
            self.log.info("- {}".format(mod.__file__[:-1]))     # *.pyc -> *.py

        self.init_UI()

        self.loop = urwid.MainLoop(copilot.top,
                                   palette,
                                   unhandled_input=unknown_input)

    def _setup_dirs(self):

        group_vars = '/etc/ansible/group_vars'
        ceph_ansible_vars = os.path.join(CEPH_ANSIBLE_ROOT, 'group_vars')
        if os.path.exists(group_vars):
            if os.path.realpath(group_vars) == ceph_ansible_vars:
                self.log.info("ceph-ansible group_vars is linked to ansible's"
                              " directory - no change needed")
            else:
                raise EnvironmentError("group_vars already exists, but doesn't"
                                       " point to ceph-ansible group_vars")
        else:
            # Doesn't exists, so create the symlink to ceph-ansible's dir
            if os.path.exists(ceph_ansible_vars):
                os.symlink(ceph_ansible_vars, group_vars)
                self.log.info("Created symlink to ceph-ansible group_vars")
            else:
                raise EnvironmentError("ceph-ansible group_vars not found. Is "
                                       "ceph-ansible installed?")

    def check_keys(self):
        keys_dir = os.path.join(os.path.expanduser('~'), 'ceph-ansible-keys')
        if os.path.exists(keys_dir):
            self.log.info("Ansible keys directory is ready, no action needed")
        else:
            os.mkdir(keys_dir)
            self.log.info("Ansible keys directory created")

    def init_UI(self):
        ui_elements = get_ui_sections()
        section_names = []
        for idx in sorted(ui_elements):
            (page_class, page_title) = ui_elements[idx]
            section_names.append(page_title)
            self.page.append(page_class(self))

        self.left_pane = Breadcrumbs(self, section_names)
        self.right_pane = self.page[self.pagenum]
        self.msg_text = self.page[self.pagenum].hint

        self.msg = urwid.AttrMap(
                     urwid.Text(self.msg_text), 'message')

        self.refresh_ui(left=self.left_pane,
                        right=self.right_pane.render_page)
        return

    def cleanup(self):

        # if we had a site_yml plugin run it again in delete mode
        # to remove the additional include_vars tasks
        if self.plugin_mgr.plugins['site_yml'].executed:
            self.log.info("running site_yml again to remove "
                          "the include_vars task for all.yml")
            mod = self.plugin_mgr.plugins['site_yml'].module
            mod.plugin_main(config=self.cfg, mode='delete')

        # if we have a _bak version of the ansible.cfg, restore it to it's
        # previous state
        restore_ansible_cfg()


def setup_logging():

    log_path = '/var/log/ceph-ansible-copilot.log'
    logger = logging.getLogger("copilot")
    logger.setLevel(logging.DEBUG)
    file_handler = logging.FileHandler(log_path, mode='w')

    file_format = logging.Formatter(
        '%(asctime)s [%(levelname)-8s] %(message)s')

    file_handler.setFormatter(file_format)
    file_handler.setLevel(logging.DEBUG)
    logger.addHandler(file_handler)

    return logger


def parse_cli_options():

    modes = ['dev', 'prod']                     # 1st entry is the default!
    copilot_version = ceph_ansible_copilot.__version__

    parser = argparse.ArgumentParser(description="ceph-ansible copilot")

    parser.add_argument("--mode", "-m", type=str, choices=modes,
                        default=modes[0],
                        help="type of cluster to be deployed "
                             "(default is {})".format(modes[0]))

    parser.add_argument("--cluster-name", "-n", type=str,
                        default='ceph',
                        help="cluster name override (default is 'ceph')")

    parser.add_argument("--playbook", "-P", type=str,
                        help="playbook to use for deployment ")

    parser.add_argument("--ceph-version", "-c", type=int,
                        default=12, choices=[10, 12],
                        help="ceph version to install")

    parser.add_argument('--version', action='version',
                        version='{} {}'.format(parser.prog,
                                               copilot_version))

    args = parser.parse_args()
    return args


if __name__ == "__main__":

    opts = parse_cli_options()

    # check that the cwd is /usr/share/ceph-ansible to pick up the correct
    # environment (cfg, plugins, actions etc)
    if os.getcwd() != CEPH_ANSIBLE_ROOT:
        print("-> copilot must be started from the {} "
              "directory".format(CEPH_ANSIBLE_ROOT))
        sys.exit(4)

    if opts.playbook:
        if not os.path.exists(opts.playbook):
            print("-> playbook file not found. Is it fully qualified?")
            sys.exit(4)

    copilot = App()
    copilot.setup()
    copilot.loop.run()
    copilot.cleanup()

    print("--- DEBUG STUFF ---")
    print("Config:")
    print(copilot.cfg)
    selected_hosts = [host_name for host_name in copilot.hosts
                      if copilot.hosts[host_name].selected is True]

    print("Selected hosts are: {}".format(selected_hosts))