# This file is part of cloud-init. See LICENSE file for license information.

"""Base NoCloud KVM instance."""

import copy
import os
import socket
import subprocess
import time
import uuid

from ..instances import Instance
from cloudinit.atomic_helper import write_json
from cloudinit import util as c_util
from tests.cloud_tests import LOG, util

# This domain contains reverse lookups for hostnames that are used.
# The primary reason is so sudo will return quickly when it attempts
# to look up the hostname.  i9n is just short for 'integration'.
# see also bug 1730744 for why we had to do this.
CI_DOMAIN = "i9n.cloud-init.io"


class NoCloudKVMInstance(Instance):
    """NoCloud KVM backed instance."""

    platform_name = "nocloud-kvm"

    def __init__(self, platform, name, image_path, properties, config,
                 features, user_data, meta_data):
        """Set up instance.

        @param platform: platform object
        @param name: image path
        @param image_path: path to disk image to boot.
        @param properties: dictionary of properties
        @param config: dictionary of configuration values
        @param features: dictionary of supported feature flags
        """
        super(NoCloudKVMInstance, self).__init__(
            platform, name, properties, config, features
        )

        self.user_data = user_data
        if meta_data:
            meta_data = copy.deepcopy(meta_data)
        else:
            meta_data = {}

        if 'instance-id' in meta_data:
            iid = meta_data['instance-id']
        else:
            iid = str(uuid.uuid1())
            meta_data['instance-id'] = iid

        self.instance_id = iid
        self.ssh_key_file = os.path.join(
            platform.config['data_dir'], platform.config['private_key'])
        self.ssh_pubkey_file = os.path.join(
            platform.config['data_dir'], platform.config['public_key'])

        self.ssh_pubkey = None
        if self.ssh_pubkey_file:
            with open(self.ssh_pubkey_file, "r") as fp:
                self.ssh_pubkey = fp.read().rstrip('\n')

            if not meta_data.get('public-keys'):
                meta_data['public-keys'] = []
            meta_data['public-keys'].append(self.ssh_pubkey)

        self.ssh_ip = '127.0.0.1'
        self.ssh_port = None
        self.pid = None
        self.pid_file = None
        self.console_file = None
        self.disk = image_path
        self.cache_mode = platform.config.get('cache_mode',
                                              'cache=none,aio=native')
        self.meta_data = meta_data

    def shutdown(self, wait=True):
        """Shutdown instance."""

        if self.pid:
            # This relies on _execute which uses sudo over ssh.  The ssh
            # connection would get killed before sudo exited, so ignore errors.
            cmd = ['shutdown', 'now']
            try:
                self._execute(cmd)
            except util.InTargetExecuteError:
                pass
            self._ssh_close()

            if wait:
                LOG.debug("Executed shutdown. waiting on pid %s to end",
                          self.pid)
                time_for_shutdown = 120
                give_up_at = time.time() + time_for_shutdown
                pid_file_path = '/proc/%s' % self.pid
                msg = ("pid %s did not exit in %s seconds after shutdown." %
                       (self.pid, time_for_shutdown))
                while True:
                    if not os.path.exists(pid_file_path):
                        break
                    if time.time() > give_up_at:
                        raise util.PlatformError("shutdown", msg)
                self.pid = None

    def destroy(self):
        """Clean up instance."""
        if self.pid:
            try:
                c_util.subp(['kill', '-9', self.pid])
            except c_util.ProcessExecutionError:
                pass

        if self.pid_file:
            try:
                os.remove(self.pid_file)
            except Exception:
                pass

        self.pid = None
        self._ssh_close()

        super(NoCloudKVMInstance, self).destroy()

    def _execute(self, command, stdin=None, env=None):
        env_args = []
        if env:
            env_args = ['env'] + ["%s=%s" for k, v in env.items()]

        return self._ssh(['sudo'] + env_args + list(command), stdin=stdin)

    def generate_seed(self, tmpdir):
        """Generate nocloud seed from user-data"""
        seed_file = os.path.join(tmpdir, '%s_seed.img' % self.name)
        user_data_file = os.path.join(tmpdir, '%s_user_data' % self.name)
        meta_data_file = os.path.join(tmpdir, '%s_meta_data' % self.name)

        with open(user_data_file, "w") as ud_file:
            ud_file.write(self.user_data)

        # meta-data can be yaml, but more easily pretty printed with json
        write_json(meta_data_file, self.meta_data)
        c_util.subp(['cloud-localds', seed_file, user_data_file,
                     meta_data_file])

        return seed_file

    def get_free_port(self):
        """Get a free port assigned by the kernel."""
        s = socket.socket()
        s.bind(('', 0))
        num = s.getsockname()[1]
        s.close()
        return num

    def start(self, wait=True, wait_for_cloud_init=False):
        """Start instance."""
        tmpdir = self.platform.config['data_dir']
        seed = self.generate_seed(tmpdir)
        self.pid_file = os.path.join(tmpdir, '%s.pid' % self.name)
        self.console_file = os.path.join(tmpdir, '%s-console.log' % self.name)
        self.ssh_port = self.get_free_port()

        cmd = ['./tools/xkvm',
               '--disk', '%s,%s' % (self.disk, self.cache_mode),
               '--disk', '%s' % seed,
               '--netdev', ','.join(['user',
                                     'hostfwd=tcp::%s-:22' % self.ssh_port,
                                     'dnssearch=%s' % CI_DOMAIN]),
               '--', '-pidfile', self.pid_file, '-vnc', 'none',
               '-m', '2G', '-smp', '2', '-nographic', '-name', self.name,
               '-serial', 'file:' + self.console_file]
        subprocess.Popen(cmd,
                         close_fds=True,
                         stdin=subprocess.PIPE,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)

        while not os.path.exists(self.pid_file):
            time.sleep(1)

        with open(self.pid_file, 'r') as pid_f:
            self.pid = pid_f.readlines()[0].strip()

        if wait:
            self._wait_for_system(wait_for_cloud_init)

    def console_log(self):
        if not self.console_file:
            return b''
        with open(self.console_file, "rb") as fp:
            return fp.read()

# vi: ts=4 expandtab