#!/usr/bin/env python
#
# Copyright (c) 2014 Hewlett-Packard Development Company, L.P.
# Copyright (c) 2013 OpenStack Foundation
#
# 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 libvirt
import logging
import os
import uuid

from string import Template

from dwarf import config

CONF = config.Config()
LOG = logging.getLogger(__name__)

DOMAIN_NOSTATE = 0
DOMAIN_RUNNING = 1
DOMAIN_PAUSED = 2
DOMAIN_SHUTDOWN = 3
DOMAIN_CRASHED = 4
DOMAIN_SUSPENDED = 5

_LIBVIRT_DOMAIN_STATE = {
    libvirt.VIR_DOMAIN_NOSTATE: DOMAIN_NOSTATE,
    libvirt.VIR_DOMAIN_RUNNING: DOMAIN_RUNNING,
    libvirt.VIR_DOMAIN_BLOCKED: DOMAIN_RUNNING,
    libvirt.VIR_DOMAIN_PAUSED: DOMAIN_PAUSED,
    libvirt.VIR_DOMAIN_SHUTDOWN: DOMAIN_SHUTDOWN,
    libvirt.VIR_DOMAIN_SHUTOFF: DOMAIN_SHUTDOWN,
    libvirt.VIR_DOMAIN_CRASHED: DOMAIN_CRASHED,
    libvirt.VIR_DOMAIN_PMSUSPENDED: DOMAIN_SUSPENDED,
}


def _name(sid):
    return 'dwarf-%08x' % int(sid)


def _xml_snippet(name, enable):
    xml = {}
    if enable:
        xml['%s_begin' % name] = ''
        xml['%s_end' % name] = ''
    else:
        xml['%s_begin' % name] = '<!--'
        xml['%s_end' % name] = '-->'
    return xml


def _create_domain_xml(server, flavor, force=False):
    """
    Create a libvirt XML file for the domain
    """
    basepath = os.path.join(CONF.instances_dir, server['id'])
    xml_file = os.path.join(basepath, 'libvirt.xml')

    # Read the XML file if it exists already
    if not force and os.path.exists(xml_file):
        LOG.info('read existing libvirt.xml for server %s', server['id'])

        with open(xml_file, 'r') as fh:
            xml = fh.read()

    # Otherwise create it
    else:
        LOG.info('create libvirt.xml for server %s', server['id'])

        with open(os.path.join(os.path.dirname(__file__),
                               'libvirt-domain.xml'), 'r') as fh:
            xml_template = fh.read()

        xml_info = {
            'domain_type': CONF.libvirt_domain_type,
            'uuid': server['id'],
            'name': _name(server['int_id']),
            'memory': int(flavor['ram']) * 1024,
            'vcpus': flavor['vcpus'],
            'basepath': basepath,
            'mac_addr': server['mac_address'],
            'bridge': CONF.libvirt_bridge_name,
        }

        # Enable/disable the config drive
        config_drive = _xml_snippet('config_drive',
                                    (CONF.force_config_drive or
                                     server['config_drive'] == 'True'))
        xml_info.update(config_drive)

        xml = Template(xml_template).substitute(xml_info)
        with open(xml_file, 'w') as fh:
            fh.write(xml)

    return xml


def _create_net_xml():
    """
    Create a libvirt XML for the network bridge
    """
    with open(os.path.join(os.path.dirname(__file__),
                           'libvirt-net.xml'), 'r') as fh:
        xml_template = fh.read()

    xml_info = {
        'uuid': str(uuid.uuid4()),
        'network_name': CONF.libvirt_network_name,
        'bridge': CONF.libvirt_bridge_name,
        'ip': CONF.libvirt_bridge_ip,
        'dhcp_start': '.'.join(CONF.libvirt_bridge_ip.split('.')[0:3] + ['2']),
        'dhcp_end': '.'.join(CONF.libvirt_bridge_ip.split('.')[0:3] + ['254']),
    }

    return Template(xml_template).substitute(xml_info)


class Controller(object):

    def __init__(self):
        self.libvirt = None

    def _test_connect(self):
        """
        Test the connection to the libvirt daemon
        """
        try:
            self.libvirt.getLibVersion()
            return True
        except libvirt.libvirtError as e:
            if e.get_error_code() in (libvirt.VIR_ERR_SYSTEM_ERROR,
                                      libvirt.VIR_ERR_INTERNAL_ERROR):
                LOG.debug('Connection to libvirt broke')
                return False
            raise

    def _connect(self):
        """
        Open a connection to the libvirt daemon
        """
        if self.libvirt is None or not self._test_connect():
            uri = 'qemu:///system'
            LOG.debug('Connecting to libvirt (%s)', uri)
            self.libvirt = libvirt.open(uri)

    # -------------------------------------------------------------------------
    # Libvirt domain operations (private)

    def _create_domain(self, xml):
        """
        Create the libvirt domain and start it
        """
        domain = self.libvirt.defineXML(xml)
        domain.create()
        return domain

    def _get_domain(self, server):
        """
        Get the active server domain
        """
        try:
            domain = self.libvirt.lookupByName(_name(server['int_id']))
        except libvirt.libvirtError:
            return
        return domain

    def _destroy_domain(self, domain):
        """
        Destroy a libvirt domain
        """
        if domain is None:
            return

        try:
            domain.destroy()
        except libvirt.libvirtError as e:
            if e.get_error_code() == libvirt.VIR_ERR_OPERATION_INVALID:
                # Check if the instance is already shut down
                if self._info_domain(domain)['state'] == DOMAIN_SHUTDOWN:
                    return
            raise

    def _undefine_domain(self, domain):
        """
        Undefine a libvirt domain
        """
        if domain is None:
            return
        domain.undefine()

    def _start_domain(self, domain):
        """
        Start a libvirt domain
        """
        if domain is None:
            return
        if self._info_domain(domain)['state'] == DOMAIN_RUNNING:
            return

        domain.create()

    def _info_domain(self, domain):
        """
        Return the libvirt domain info
        """
        if domain is None:
            return

        info = dict(zip(['state', 'max_mem', 'memory', 'nr_virt_cpu',
                         'cpu_time'], domain.info()))
        # Normalize the domain state
        info['state'] = _LIBVIRT_DOMAIN_STATE[info['state']]
        return info

    def _shutdown_domain(self, domain, hard):
        """
        Shutdown a libvirt domain
        """
        if domain is None:
            return
        if self._info_domain(domain)['state'] != DOMAIN_RUNNING:
            return

        if hard:
            self._destroy_domain(domain)
        else:
            domain.shutdown()

    # -------------------------------------------------------------------------
    # Server operations (public)

    def create_server(self, server, flavor):
        """
        Create a server
        """
        LOG.info('create_server(server=%s, flavor=%s)', server, flavor)

        self._connect()
        xml = _create_domain_xml(server, flavor)
        self._create_domain(xml)

    def delete_server(self, server):
        """
        Delete a server
        """
        LOG.info('delete_server(server=%s)', server)

        self._connect()
        domain = self._get_domain(server)
        self._destroy_domain(domain)
        self._undefine_domain(domain)

    def start_server(self, server):
        """
        Start a server
        """
        LOG.info('start_server(server=%s)', server)

        self._connect()
        domain = self._get_domain(server)
        self._start_domain(domain)

    def stop_server(self, server, hard=False):
        """
        Stop a server
        """
        LOG.info('stop_server(server=%s, hard=%s)', server, hard)

        self._connect()
        domain = self._get_domain(server)
        self._shutdown_domain(domain, hard)

    def info_server(self, server):
        """
        Return the server info
        """
        LOG.info('info_server(server=%s)', server)

        self._connect()
        domain = self._get_domain(server)
        info = self._info_domain(domain)
        LOG.info('info = %s', info)
        return info

    def create_network(self):
        """
        Create the network
        """
        LOG.info('create_network()')

        self._connect()
        try:
            # Check if the network already exists
            net = self.libvirt.networkLookupByName(CONF.libvirt_network_name)
        except libvirt.libvirtError as e:
            if e.get_error_code() != libvirt.VIR_ERR_NO_NETWORK:
                # Unexpected error
                raise
            # Define the network
            xml = _create_net_xml()
            net = self.libvirt.networkDefineXML(xml)

        # Configure the network to automatically start on host boot
        net.setAutostart(1)

        # Create (start) the network
        if net.isActive() == 0:
            net.create()

    def get_dhcp_lease(self, server):
        """
        Get DHCP lease information
        """
        LOG.info('get_dhcp_lease(server=%s)', server)

        net = self.libvirt.networkLookupByName(CONF.libvirt_network_name)
        lease = net.DHCPLeases(mac=server['mac_address'])
        if len(lease) == 1:
            return {'ip': lease[0]['ipaddr']}
