# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright 2011 Justin Santa Barbara

# All Rights Reserved.

#

# Copyright (c) 2013, 2014, Oracle and/or its affiliates. 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.

"""

Driver for Solaris Zones (nee Containers):

"""

import glob

import os

import platform

import shutil

import tempfile

import uuid

import rad.bindings.com.oracle.solaris.rad.kstat as kstat

import rad.bindings.com.oracle.solaris.rad.zonesbridge as zonesbridge

import rad.bindings.com.oracle.solaris.rad.zonemgr as zonemgr

import rad.client

import rad.connect

from solaris_install.archive.checkpoints import InstantiateUnifiedArchive

from solaris_install.archive import LOGFILE as ARCHIVE_LOGFILE

from solaris_install.archive import UnifiedArchive

from solaris_install.engine import InstallEngine

from eventlet import greenthread

from lxml import etree

from oslo.config import cfg

from nova.compute import power_state

from nova.compute import task_states

from nova.compute import vm_mode

from nova import conductor

from nova import context as nova_context

from nova import exception

from nova.image import glance

from nova.network import quantumv2

from nova.openstack.common import fileutils

from nova.openstack.common import jsonutils

from nova.openstack.common import log as logging

from nova import paths

from nova import utils

from nova.virt import driver

from nova.virt import event as virtevent

from nova.virt import images

from nova.virt.solariszones import sysconfig

from nova import volume

solariszones_opts = [

    cfg.StrOpt('glancecache_dirname',

               default='$state_path/images',

               help='Default path to Glance cache for Solaris Zones.'),

    cfg.StrOpt('solariszones_snapshots_directory',

               default='$instances_path/snapshots',

               help='Location where solariszones driver will store snapshots '

                    'before uploading them to the Glance image service'),

]

CONF = cfg.CONF

CONF.register_opts(solariszones_opts)

LOG = logging.getLogger(__name__)

# These should match the strings returned by the zone_state_str()

# function in the (private) libzonecfg library. These values are in turn

# returned in the 'state' string of the Solaris Zones' RAD interface by

# the zonemgr(3RAD) provider.

ZONE_STATE_CONFIGURED = 'configured'

ZONE_STATE_INCOMPLETE = 'incomplete'

ZONE_STATE_UNAVAILABLE = 'unavailable'

ZONE_STATE_INSTALLED = 'installed'

ZONE_STATE_READY = 'ready'

ZONE_STATE_RUNNING = 'running'

ZONE_STATE_SHUTTING_DOWN = 'shutting_down'

ZONE_STATE_DOWN = 'down'

ZONE_STATE_MOUNTED = 'mounted'

# Mapping between zone state and Nova power_state.

SOLARISZONES_POWER_STATE = {

    ZONE_STATE_CONFIGURED:      power_state.NOSTATE,

    ZONE_STATE_INCOMPLETE:      power_state.BUILDING,

    ZONE_STATE_UNAVAILABLE:     power_state.NOSTATE,

    ZONE_STATE_INSTALLED:       power_state.SHUTDOWN,

    ZONE_STATE_READY:           power_state.RUNNING,

    ZONE_STATE_RUNNING:         power_state.RUNNING,

    ZONE_STATE_SHUTTING_DOWN:   power_state.RUNNING,

    ZONE_STATE_DOWN:            power_state.RUNNING,

    ZONE_STATE_MOUNTED:         power_state.NOSTATE

}

# Solaris Zones brands as defined in brands(5).

ZONE_BRAND_LABELED = 'labeled'

ZONE_BRAND_SOLARIS = 'solaris'

ZONE_BRAND_SOLARIS_KZ = 'solaris-kz'

ZONE_BRAND_SOLARIS10 = 'solaris10'

# Mapping between supported zone brands and the name of the corresponding

# brand template.

ZONE_BRAND_TEMPLATE = {

    ZONE_BRAND_SOLARIS:         'SYSdefault',

    ZONE_BRAND_SOLARIS_KZ:      'SYSsolaris-kz',

}

MAX_CONSOLE_BYTES = 102400

def lookup_resource_property(zone, resource, prop, filter=None):

    """Lookup specified property from specified Solaris Zone resource."""

    try:

        val = zone.getResourceProperties(zonemgr.Resource(resource, filter),

                                         [prop])

    except rad.client.ObjectError:

        return None

    except Exception:

        raise

    return val[0].value if val else None

def lookup_resource_property_value(zone, resource, prop, value):

    """Lookup specified property with value from specified Solaris Zone

       resource. Returns property if matching value is found, else None

    """

    try:

        resources = zone.getResources(zonemgr.Resource(resource))

        for resource in resources:

            for propertee in resource.properties:

                if propertee.name == prop and propertee.value == value:

                    return propertee

        else:

            return None

    except rad.client.ObjectError:

        return None

    except Exception:

        raise

class ZoneConfig(object):

    """ ZoneConfig - context manager for access zone configurations.

    Automatically opens the configuration for a zone and commits any changes

    before exiting

    """

    def __init__(self, zone):

        """ zone is a zonemgr object representing either a kernel zone or

        non-glboal zone.

        """

        self.zone = zone

        self.editing = False

    def __enter__(self):

        """ enables the editing of the zone.

        """

        try:

            self.zone.editConfig()

            self.editing = True

            return self

        except rad.client.ObjectError as err:

            LOG.error(_("Unable to initialize editing of instance '%s' via "

                        "zonemgr(3RAD): %s") % (self.zone.name, err))

            raise

    def __exit__(self, exc_type, exc_val, exc_tb):

        """ looks for any kind of exception before exiting.  If one is found,

        cancel any configuration changes and reraise the exception.  If not,

        commit the new configuration.

        """

        if exc_type is not None and self.editing:

            # We received some kind of exception.  Cancel the config and raise.

            self.zone.cancelConfig()

            raise

        else:

            # commit the config

            try:

                self.zone.commitConfig()

            except rad.client.ObjectError as err:

                LOG.error(_("Unable to commit the new configuration for "

                            "instance '%s' via zonemgr(3RAD): %s")

                          % (self.zone.name, err))

                raise

    def setprop(self, resource, prop, value):

        """ sets a property for an existing resource OR creates a new resource

        with the given property(s).

        """

        current = lookup_resource_property(self.zone, resource, prop)

        if current is not None and current == value:

            # the value is already set

            return

        try:

            if current is None:

                self.zone.addResource(zonemgr.Resource(

                    resource, [zonemgr.Property(prop, value)]))

            else:

                self.zone.setResourceProperties(

                    zonemgr.Resource(resource),

                    [zonemgr.Property(prop, value)])

        except rad.client.ObjectError as err:

            LOG.error(_("Unable to set '%s' property on '%s' resource for "

                        "instance '%s' via zonemgr(3RAD): %s")

                      % (prop, resource, self.zone.name, err))

            raise

    def addresource(self, resource, props=None):

        """ creates a new resource with an optional property list.

        """

        if props is None:

            props = []

        try:

            self.zone.addResource(zonemgr.Resource(resource, props))

        except rad.client.ObjectError as err:

            LOG.error(_("Unable to create new resource '%s' for instance '%s'"

                        "via zonemgr(3RAD): %s")

                      % (resource, self.zone.name, err))

            raise

    def removeresources(self, resource, props=None):

        """ removes resources whose properties include the optional property

            list specified in props.

        """

        if props is None:

            props = []

        try:

            self.zone.removeResources(zonemgr.Resource(resource, props))

        except rad.client.ObjectError as err:

            LOG.error(_("Unable to remove resource '%s' for instance '%s' via "

                        "zonemgr(3RAD): %s") % (resource, self.zone.name, err))

            raise

class SolarisZonesDriver(driver.ComputeDriver):

    """Solaris Zones Driver using the zonemgr(3RAD) and kstat(3RAD) providers.

    The interface to this class talks in terms of 'instances' (Amazon EC2 and

    internal Nova terminology), by which we mean 'running virtual machine'

    (XenAPI terminology) or domain (Xen or libvirt terminology).

    An instance has an ID, which is the identifier chosen by Nova to represent

    the instance further up the stack.  This is unfortunately also called a

    'name' elsewhere.  As far as this layer is concerned, 'instance ID' and

    'instance name' are synonyms.

    Note that the instance ID or name is not human-readable or

    customer-controlled -- it's an internal ID chosen by Nova.  At the

    nova.virt layer, instances do not have human-readable names at all -- such

    things are only known higher up the stack.

    Most virtualization platforms will also have their own identity schemes,

    to uniquely identify a VM or domain.  These IDs must stay internal to the

    platform-specific layer, and never escape the connection interface.  The

    platform-specific layer is responsible for keeping track of which instance

    ID maps to which platform-specific ID, and vice versa.

    Some methods here take an instance of nova.compute.service.Instance.  This

    is the data structure used by nova.compute to store details regarding an

    instance, and pass them into this layer.  This layer is responsible for

    translating that generic data structure into terms that are specific to the

    virtualization platform.

    """

    capabilities = {

        "has_imagecache": False,

        "supports_recreate": False,

    }

    def __init__(self, virtapi):

        self.virtapi = virtapi

        self._compute_event_callback = None

        self._conductor_api = conductor.API()

        self._host_stats = {}

        self._initiator = None

        self._install_engine = None

        self._pagesize = os.sysconf('SC_PAGESIZE')

        self._uname = os.uname()

        self._validated_archives = list()

        self._volume_api = volume.API()

    def _init_rad(self):

        """Connect to RAD providers for kernel statistics and Solaris

        Zones. By connecting to the local rad(1M) service through a

        UNIX domain socket, kernel statistics can be read via

        kstat(3RAD) and Solaris Zones can be configured and controlled

        via zonemgr(3RAD).

        """

        # TODO(dcomay): Arrange to call this in the event of losing the

        # connection to RAD.

        try:

            self._rad_instance = rad.connect.connect_unix()

            self._kstat_control = self._rad_instance.get_object(

                kstat.Control())

        except Exception as reason:

            msg = (_('Unable to connect to svc:/system/rad:local: %s')

                   % reason)

            raise exception.NovaException(msg)

    def init_host(self, host):

        """Initialize anything that is necessary for the driver to function,

        including catching up with currently running VM's on the given host."""

        # TODO(Vek): Need to pass context in for access to auth_token

        self._init_rad()

    def _get_iscsi_initiator(self):

        """ Return the iSCSI initiator node name IQN for this host """

        out, err = utils.execute('/usr/sbin/iscsiadm', 'list',

                                 'initiator-node')

        # Sample first line of command output:

        # Initiator node name: iqn.1986-03.com.sun:01:e00000000000.4f757217

        initiator_name_line = out.splitlines()[0]

        initiator_iqn = initiator_name_line.rsplit(' ', 1)[1]

        return initiator_iqn

    def _get_zone_by_name(self, name):

        """Return a Solaris Zones object via RAD by name."""

        try:

            zone = self._rad_instance.get_object(

                zonemgr.Zone(), rad.client.ADRGlobPattern({'name': name}))

        except rad.client.NotFoundError:

            return None

        except Exception:

            raise

        return zone

    def _get_state(self, zone):

        """Return the running state, one of the power_state codes."""

        return SOLARISZONES_POWER_STATE[zone.state]

    def _pages_to_kb(self, pages):

        """Convert a number of pages of memory into a total size in KBytes."""

        return (pages * self._pagesize) / 1024

    def _get_max_mem(self, zone):

        """Return the maximum memory in KBytes allowed."""

        max_mem = lookup_resource_property(zone, 'capped-memory', 'physical')

        if max_mem is not None:

            return utils.to_bytes(max_mem) / 1024

        # If physical property in capped-memory doesn't exist, this may

        # represent a non-global zone so just return the system's total

        # memory.

        return self._pages_to_kb(os.sysconf('SC_PHYS_PAGES'))

    def _get_mem(self, zone):

        """Return the memory in KBytes used by the domain."""

        # There isn't any way of determining this from the hypervisor

        # perspective in Solaris, so just return the _get_max_mem() value

        # for now.

        return self._get_max_mem(zone)

    def _get_num_cpu(self, zone):

        """Return the number of virtual CPUs for the domain.

        In the case of kernel zones, the number of virtual CPUs a zone

        ends up with depends on whether or not there were 'virtual-cpu'

        or 'dedicated-cpu' resources in the configuration or whether

        there was an assigned pool in the configuration. This algorithm

        attempts to emulate what the virtual platform code does to

        determine a number of virtual CPUs to use.

        """

        # If a 'virtual-cpu' resource exists, use the minimum number of

        # CPUs defined there.

        ncpus = lookup_resource_property(zone, 'virtual-cpu', 'ncpus')

        if ncpus is not None:

            min = ncpus.split('-', 1)[0]

            if min.isdigit():

                return int(min)

        # Otherwise if a 'dedicated-cpu' resource exists, use the maximum

        # number of CPUs defined there.

        ncpus = lookup_resource_property(zone, 'dedicated-cpu', 'ncpus')

        if ncpus is not None:

            max = ncpus.split('-', 1)[-1]

            if max.isdigit():

                return int(max)

        # Finally if neither resource exists but the zone was assigned a

        # pool in the configuration, the number of CPUs would be the size

        # of the processor set. Currently there's no way of easily

        # determining this so use the system's notion of the total number

        # of online CPUs.

        return os.sysconf('SC_NPROCESSORS_ONLN')

    def _get_kstat_by_name(self, kstat_class, module, instance, name):

        """Return Kstat snapshot data via RAD as a dictionary."""

        pattern = {

            'class':    kstat_class,

            'module':   module,

            'instance': instance,

            'name':     name

        }

        try:

            self._kstat_control.update()

            kstat_object = self._rad_instance.get_object(

                kstat.Kstat(), rad.client.ADRGlobPattern(pattern))

        except Exception as reason:

            LOG.warning(_("Unable to retrieve kstat object '%s:%s:%s' of "

                          "class '%s' via kstat(3RAD): %s")

                        % (module, instance, name, kstat_class, reason))

            return None

        kstat_data = {}

        for named in kstat_object.fresh_snapshot().data.NAMED:

            kstat_data[named.name] = getattr(named.value,

                                             str(named.value.discriminant))

        return kstat_data

    def _get_cpu_time(self, zone):

        """Return the CPU time used in nanoseconds."""

        if zone.id == -1:

            return 0

        kstat_data = self._get_kstat_by_name('zones', 'cpu', str(zone.id),

                                             'sys_zone_aggr')

        if kstat_data is None:

            return 0

        return kstat_data['cpu_nsec_kernel'] + kstat_data['cpu_nsec_user']

    def get_info(self, instance):

        """Get the current status of an instance, by name (not ID!)

        Returns a dict containing:

        :state:           the running state, one of the power_state codes

        :max_mem:         (int) the maximum memory in KBytes allowed

        :mem:             (int) the memory in KBytes used by the domain

        :num_cpu:         (int) the number of virtual CPUs for the domain

        :cpu_time:        (int) the CPU time used in nanoseconds

        """

        # TODO(Vek): Need to pass context in for access to auth_token

        name = instance['name']

        zone = self._get_zone_by_name(name)

        if zone is None:

            LOG.error(_("Unable to find instance '%s' via zonemgr(3RAD)")

                      % name)

            raise exception.InstanceNotFound(instance_id=name)

        return {

            'state':    self._get_state(zone),

            'max_mem':  self._get_max_mem(zone),

            'mem':      self._get_mem(zone),

            'num_cpu':  self._get_num_cpu(zone),

            'cpu_time': self._get_cpu_time(zone)

        }

    def get_num_instances(self):

        """Return the total number of virtual machines.

        Return the number of virtual machines that the hypervisor knows

        about.

        .. note::

            This implementation works for all drivers, but it is

            not particularly efficient. Maintainers of the virt drivers are

            encouraged to override this method with something more

            efficient.

        """

        return len(self.list_instances())

    def instance_exists(self, instance_id):

        """Checks existence of an instance on the host.

        :param instance_id: The ID / name of the instance to lookup

        Returns True if an instance with the supplied ID exists on

        the host, False otherwise.

        .. note::

            This implementation works for all drivers, but it is

            not particularly efficient. Maintainers of the virt drivers are

            encouraged to override this method with something more

            efficient.

        """

        return instance_id in self.list_instances()

    def _get_list_zone_object(self):

        """Return a list of all Solaris Zones objects via RAD."""

        return self._rad_instance.list_objects(zonemgr.Zone())

    def list_instances(self):

        """

        Return the names of all the instances known to the virtualization

        layer, as a list.

        """

        # TODO(Vek): Need to pass context in for access to auth_token

        instances_list = []

        for zone in self._get_list_zone_object():

            instances_list.append(self._rad_instance.get_object(zone).name)

        return instances_list

    def list_instance_uuids(self):

        """

        Return the UUIDS of all the instances known to the virtualization

        layer, as a list.

        """

        raise NotImplementedError()

    def _fetch_image(self, context, instance):

        """Fetch an image using Glance given the instance's image_ref."""

        glancecache_dirname = CONF.glancecache_dirname

        fileutils.ensure_tree(glancecache_dirname)

        image = ''.join([glancecache_dirname, '/', instance['image_ref']])

        if os.path.exists(image):

            LOG.debug(_("Using existing, cached Glance image: id %s")