# Copyright (c) 2010 OpenStack Foundation
# 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.

"""XVP (Xenserver VNC Proxy) driver."""

import os
import signal

import jinja2
from oslo_concurrency import processutils
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import excutils

from nova import context
from nova import db
from nova.i18n import _, _LE
from nova import paths
from nova import utils


xvp_opts = [
    cfg.StrOpt('console_xvp_conf_template',
               default=paths.basedir_def('nova/console/xvp.conf.template'),
               help='XVP conf template'),
    cfg.StrOpt('console_xvp_conf',
               default='/etc/xvp.conf',
               help='Generated XVP conf file'),
    cfg.StrOpt('console_xvp_pid',
               default='/var/run/xvp.pid',
               help='XVP master process pid file'),
    cfg.StrOpt('console_xvp_log',
               default='/var/log/xvp.log',
               help='XVP log file'),
    cfg.IntOpt('console_xvp_multiplex_port',
               default=5900,
               help='Port for XVP to multiplex VNC connections on'),
    ]

CONF = cfg.CONF
CONF.register_opts(xvp_opts)
CONF.import_opt('host', 'nova.netconf')
LOG = logging.getLogger(__name__)


class XVPConsoleProxy(object):
    """Sets up XVP config, and manages XVP daemon."""

    def __init__(self):
        self.xvpconf_template = open(CONF.console_xvp_conf_template).read()
        self.host = CONF.host  # default, set by manager.
        super(XVPConsoleProxy, self).__init__()

    @property
    def console_type(self):
        return 'vnc+xvp'

    def get_port(self, context):
        """Get available port for consoles that need one."""
        # TODO(mdragon): implement port selection for non multiplex ports,
        #               we are not using that, but someone else may want
        #               it.
        return CONF.console_xvp_multiplex_port

    def setup_console(self, context, console):
        """Sets up actual proxies."""
        self._rebuild_xvp_conf(context.elevated())

    def teardown_console(self, context, console):
        """Tears down actual proxies."""
        self._rebuild_xvp_conf(context.elevated())

    def init_host(self):
        """Start up any config'ed consoles on start."""
        ctxt = context.get_admin_context()
        self._rebuild_xvp_conf(ctxt)

    def fix_pool_password(self, password):
        """Trim password to length, and encode."""
        return self._xvp_encrypt(password, is_pool_password=True)

    def fix_console_password(self, password):
        """Trim password to length, and encode."""
        return self._xvp_encrypt(password)

    def _rebuild_xvp_conf(self, context):
        LOG.debug('Rebuilding xvp conf')
        pools = [pool for pool in
                 db.console_pool_get_all_by_host_type(context, self.host,
                                                       self.console_type)
                  if pool['consoles']]
        if not pools:
            LOG.debug('No console pools!')
            self._xvp_stop()
            return
        conf_data = {'multiplex_port': CONF.console_xvp_multiplex_port,
                     'pools': pools}
        tmpl_path, tmpl_file = os.path.split(CONF.injected_network_template)
        env = jinja2.Environment(loader=jinja2.FileSystemLoader(tmpl_path))
        env.filters['pass_encode'] = self.fix_console_password
        template = env.get_template(tmpl_file)
        self._write_conf(template.render(conf_data))
        self._xvp_restart()

    def _write_conf(self, config):
        try:
            LOG.debug('Re-wrote %s', CONF.console_xvp_conf)
            with open(CONF.console_xvp_conf, 'w') as cfile:
                cfile.write(config)
        except IOError:
            with excutils.save_and_reraise_exception():
                LOG.exception(_LE("Failed to write configuration file"))

    def _xvp_stop(self):
        LOG.debug('Stopping xvp')
        pid = self._xvp_pid()
        if not pid:
            return
        try:
            os.kill(pid, signal.SIGTERM)
        except OSError:
            # if it's already not running, no problem.
            pass

    def _xvp_start(self):
        if self._xvp_check_running():
            return
        LOG.debug('Starting xvp')
        try:
            utils.execute('xvp',
                          '-p', CONF.console_xvp_pid,
                          '-c', CONF.console_xvp_conf,
                          '-l', CONF.console_xvp_log)
        except processutils.ProcessExecutionError as err:
            LOG.error(_LE('Error starting xvp: %s'), err)

    def _xvp_restart(self):
        LOG.debug('Restarting xvp')
        if not self._xvp_check_running():
            LOG.debug('xvp not running...')
            self._xvp_start()
        else:
            pid = self._xvp_pid()
            os.kill(pid, signal.SIGUSR1)

    def _xvp_pid(self):
        try:
            with open(CONF.console_xvp_pid, 'r') as pidfile:
                pid = int(pidfile.read())
        except IOError:
            return None
        except ValueError:
            return None
        return pid

    def _xvp_check_running(self):
        pid = self._xvp_pid()
        if not pid:
            return False
        try:
            os.kill(pid, 0)
        except OSError:
            return False
        return True

    def _xvp_encrypt(self, password, is_pool_password=False):
        """Call xvp to obfuscate passwords for config file.

        Args:
            - password: the password to encode, max 8 char for vm passwords,
                        and 16 chars for pool passwords. passwords will
                        be trimmed to max len before encoding.
            - is_pool_password: True if this is the XenServer api password
                                False if it's a VM console password
              (xvp uses different keys and max lengths for pool passwords)

        Note that xvp's obfuscation should not be considered 'real' encryption.
        It simply DES encrypts the passwords with static keys plainly viewable
        in the xvp source code.

        """
        maxlen = 8
        flag = '-e'
        if is_pool_password:
            maxlen = 16
            flag = '-x'
        # xvp will blow up on passwords that are too long (mdragon)
        password = password[:maxlen]
        out, err = utils.execute('xvp', flag, process_input=password)
        if err:
            raise processutils.ProcessExecutionError(_("Failed to run xvp."))
        return out.strip()
