# 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.

from devstack import component as comp
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 utils

#id
TYPE = settings.HORIZON
LOG = logging.getLogger("devstack.components.horizon")

#actual dir names
ROOT_HORIZON = 'horizon'
HORIZON_NAME = 'horizon'
ROOT_DASH = 'openstack-dashboard'
DASH_NAME = 'dashboard'

#config files messed with
HORIZON_PY_CONF = "horizon_settings.py"
HORIZON_PY_CONF_TGT = ['local', 'local_settings.py']
HORIZON_APACHE_CONF = '000-default'

#http://wiki.apache.org/httpd/DistrosDefaultLayout
#TODO: maybe this should be a subclass that handles these differences
APACHE_CONF_TARGETS = {
    settings.UBUNTU11: '/etc/apache2/sites-enabled/000-default',
    #ensure runs after wsgi.conf
    settings.RHEL6: '/etc/httpd/conf.d/wsgi-horizon-000-default.conf',
    settings.FEDORA16: '/etc/httpd/conf.d/wsgi-horizon-000-default.conf',
}
CONFIGS = [HORIZON_PY_CONF, HORIZON_APACHE_CONF]

#db sync that needs to happen for horizon
DB_SYNC_CMD = ['python', 'manage.py', 'syncdb']

#special apache directory (TODO describe more about this)
BLACKHOLE_DIR = '.blackhole'

#hopefully this will be distro independent ??
#of course they aren't!
#TODO: maybe this should be a subclass that handles these differences
APACHE_SVC_NAME = {
    settings.RHEL6: 'httpd',
    settings.UBUNTU11: 'apache2',
}
APACHE_RESTART_CMD = ['service', '%SERVICE%', 'restart']
APACHE_START_CMD = ['service', '%SERVICE%', 'start']
APACHE_STOP_CMD = ['service', '%SERVICE%', 'stop']
APACHE_STATUS_CMD = ['service', '%SERVICE%', 'status']

#rhel fixups
#TODO: maybe this should be a subclass that handles these differences
RHEL_FIXUPS = {
    'SOCKET_CONF': "/etc/httpd/conf.d/wsgi-socket-prefix.conf",
    'HTTPD_CONF': '/etc/httpd/conf/httpd.conf',
}

#users which apache may not like starting as
BAD_APACHE_USERS = ['root']

#apache logs will go here
LOGS_DIR = "logs"

#the pkg json files horizon requires for installation
REQ_PKGS = ['general.json', 'horizon.json']

#pip files that horizon requires
REQ_PIPS = ['general.json', 'horizon.json']


class HorizonUninstaller(comp.PythonUninstallComponent):
    def __init__(self, *args, **kargs):
        comp.PythonUninstallComponent.__init__(self, TYPE, *args, **kargs)


class HorizonInstaller(comp.PythonInstallComponent):
    def __init__(self, *args, **kargs):
        comp.PythonInstallComponent.__init__(self, TYPE, *args, **kargs)
        self.horizon_dir = sh.joinpths(self.appdir, ROOT_HORIZON)
        self.dash_dir = sh.joinpths(self.appdir, ROOT_DASH)
        self.log_dir = sh.joinpths(self.component_root, LOGS_DIR)

    def _get_download_locations(self):
        places = list()
        places.append({
            'uri': ("git", "horizon_repo"),
            'branch': ("git", "horizon_branch"),
        })
        return places

    def verify(self):
        self._check_ug()

    def _get_symlinks(self):
        links = dict()
        for fn in self._get_config_files():
            source_fn = self._get_target_config_name(fn)
            links[source_fn] = sh.joinpths("/", "etc", "horizon", fn)
        src = self._get_target_config_name(HORIZON_APACHE_CONF)
        links[src] = APACHE_CONF_TARGETS[self.distro]
        if settings.QUANTUM_CLIENT in self.instances:
            #TODO remove this junk, blah, puke that we have to do this
            qc = self.instances[settings.QUANTUM_CLIENT]
            src_pth = sh.joinpths(qc.appdir, 'quantum')
            if sh.isdir(src_pth):
                links[src_pth] = sh.joinpths(self.dash_dir, 'quantum')
        return links

    def _check_ug(self):
        (user, group) = self._get_apache_user_group()
        if not sh.user_exists(user):
            msg = "No user named %s exists on this system!" % (user)
            raise excp.ConfigException(msg)
        if not sh.group_exists(group):
            msg = "No group named %s exists on this system!" % (group)
            raise excp.ConfigException(msg)
        if user in BAD_APACHE_USERS:
            msg = "You may want to adjust your configuration, (user=%s, group=%s) will not work with apache!" % (user, group)
            raise excp.ConfigException(msg)

    def _get_pkgs(self):
        return list(REQ_PKGS)

    def _get_pips(self):
        return list(REQ_PIPS)

    def _get_target_config_name(self, config_name):
        if config_name == HORIZON_PY_CONF:
            return sh.joinpths(self.dash_dir, *HORIZON_PY_CONF_TGT)
        else:
            return comp.PythonInstallComponent._get_target_config_name(self, config_name)

    def _get_python_directories(self):
        py_dirs = dict()
        py_dirs[HORIZON_NAME] = self.horizon_dir
        py_dirs[DASH_NAME] = self.dash_dir
        return py_dirs

    def _get_config_files(self):
        return list(CONFIGS)

    def _setup_blackhole(self):
        #create an empty directory that apache uses as docroot
        self.tracewriter.make_dir(sh.joinpths(self.appdir, BLACKHOLE_DIR))

    def _sync_db(self):
        #Initialize the horizon database (it stores sessions and notices shown to users).
        #The user system is external (keystone).
        LOG.info("Initializing the horizon database.")
        sh.execute(*DB_SYNC_CMD, cwd=self.dash_dir)

    def _fake_quantum(self):
        #Horizon currently imports quantum even if you aren't using it.
        #Instead of installing quantum we can create a simple module
        #that will pass the initial imports.
        if settings.QUANTUM_CLIENT in self.instances:
            return
        else:
            #Make the fake quantum
            quantum_dir = sh.joinpths(self.dash_dir, 'quantum')
            self.tracewriter.make_dir(quantum_dir)
            self.tracewriter.touch_file(sh.joinpths(quantum_dir, '__init__.py'))
            self.tracewriter.touch_file(sh.joinpths(quantum_dir, 'client.py'))

    def _ensure_db_access(self):
        # ../openstack-dashboard/local needs to be writeable by the runtime user
        # since currently its storing the sql-lite databases there (TODO fix that)
        path = sh.joinpths(self.dash_dir, 'local')
        if sh.isdir(path):
            (user, group) = self._get_apache_user_group()
            LOG.debug("Changing ownership (recursively) of %s so that it can be used by %s - %s",
                path, user, group)
            uid = sh.getuid(user)
            gid = sh.getgid(group)
            sh.chown_r(path, uid, gid)

    def pre_install(self):
        comp.PythonInstallComponent.pre_install(self)
        self.tracewriter.make_dir(self.log_dir)

    def _config_fixups(self):
        #currently just handling rhel fixups
        #TODO: maybe this should be a subclass that handles these differences
        if self.distro != settings.RHEL6:
            return
        #it seems like to get this to work
        #we need to do some conf.d/conf work which sort of sucks
        (user, group) = self._get_apache_user_group()
        socket_fn = RHEL_FIXUPS.get("SOCKET_CONF")
        self.tracewriter.file_touched(socket_fn)
        #not recorded since we aren't really creating this
        httpd_fn = RHEL_FIXUPS.get("HTTPD_CONF")
        with sh.Rooted(True):
            #fix the socket prefix to someplace we can use
            fc = "WSGISocketPrefix %s" % (sh.joinpths(self.log_dir, "wsgi-socket"))
            sh.write_file(socket_fn, fc)
            #now adjust the run user and group
            fc = sh.load_file(httpd_fn)
            lines = fc.splitlines()
            new_lines = list()
            for line in lines:
                if line.startswith("User "):
                    line = "User %s" % (user)
                if line.startswith("Group "):
                    line = "Group %s" % (group)
                new_lines.append(line)
            fc = utils.joinlinesep(*new_lines)
            sh.write_file(httpd_fn, fc)

    def post_install(self):
        comp.PythonInstallComponent.post_install(self)
        self._fake_quantum()
        self._sync_db()
        self._setup_blackhole()
        self._ensure_db_access()
        self._config_fixups()

    def _get_apache_user_group(self):
        user = self.cfg.get('horizon', 'apache_user')
        if not user:
            user = sh.getuser()
        group = self.cfg.get('horizon', 'apache_group')
        if not group:
            group = sh.getgroupname()
        return (user, group)

    def _get_param_map(self, config_fn):
        #this dict will be used to fill in the configuration
        #params with actual values
        mp = dict()
        if config_fn == HORIZON_APACHE_CONF:
            (user, group) = self._get_apache_user_group()
            mp['USER'] = user
            mp['GROUP'] = group
            mp['HORIZON_DIR'] = self.appdir
            mp['HORIZON_PORT'] = self.cfg.get('horizon', 'port')
            mp['ACCESS_LOG'] = sh.joinpths(self.log_dir, "access.log")
            mp['ERROR_LOG'] = sh.joinpths(self.log_dir, "error.log")
        else:
            #Enable quantum in dashboard, if requested
            mp['QUANTUM_ENABLED'] = "%s" % (settings.QUANTUM_CLIENT in self.instances)
            mp['OPENSTACK_HOST'] = self.cfg.get('host', 'ip')
        return mp


class HorizonRuntime(comp.EmptyRuntime):
    def __init__(self, *args, **kargs):
        comp.EmptyRuntime.__init__(self, TYPE, *args, **kargs)

    def start(self):
        curr_status = self.status()
        if curr_status == comp.STATUS_STARTED:
            return self.restart()
        else:
            mp = dict()
            mp['SERVICE'] = APACHE_SVC_NAME[self.distro]
            cmds = list()
            cmds.append({
                'cmd': APACHE_START_CMD,
                'run_as_root': True,
            })
            utils.execute_template(*cmds,
                    check_exit_code=True,
                    params=mp)
            return 1

    def restart(self):
        mp = dict()
        mp['SERVICE'] = APACHE_SVC_NAME[self.distro]
        cmds = list()
        cmds.append({
            'cmd': APACHE_RESTART_CMD,
            'run_as_root': True,
        })
        utils.execute_template(*cmds,
                            check_exit_code=True,
                            params=mp)
        return 1

    def stop(self):
        curr_status = self.status()
        if curr_status != comp.STATUS_STOPPED:
            mp = dict()
            mp['SERVICE'] = APACHE_SVC_NAME[self.distro]
            cmds = list()
            cmds.append({
                'cmd': APACHE_STOP_CMD,
                'run_as_root': True,
            })
            utils.execute_template(*cmds,
                                check_exit_code=True,
                                params=mp)
            return 1
        return 0

    def status(self):
        mp = dict()
        mp['SERVICE'] = APACHE_SVC_NAME[self.distro]
        cmds = list()
        cmds.append({
            'cmd': APACHE_STATUS_CMD,
            'run_as_root': True,
        })
        run_result = utils.execute_template(*cmds,
                            check_exit_code=False,
                            params=mp)
        if not run_result or not run_result[0]:
            return comp.STATUS_UNKNOWN
        (sysout, stderr) = run_result[0]
        combined = str(sysout) + str(stderr)
        combined = combined.lower()
        if sysout.find("is running") != -1:
            return comp.STATUS_STARTED
        elif sysout.find("not running") != -1 or sysout.find("stopped") != -1:
            return comp.STATUS_STOPPED
        else:
            return comp.STATUS_UNKNOWN