# Copyright 2011 Justin Santa Barbara

# All Rights Reserved.

#

# Copyright (c) 2013, 2015, 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.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 solaris_install.target.size import Size

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_states

from nova.console import type as ctype

from nova import conductor

from nova import context as nova_context

from nova import exception

from nova.i18n import _

from nova.image import glance

from nova.network import neutronv2

from nova.objects import flavor as flavor_obj

from nova.openstack.common import fileutils

from nova.openstack.common import jsonutils

from nova.openstack.common import log as logging

from nova.openstack.common import loopingcall

from nova.openstack.common import processutils

from nova.openstack.common import strutils

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)

CONF.import_opt('vncserver_proxyclient_address', 'nova.vnc')

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.NOSTATE,

    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

VNC_CONSOLE_BASE_FMRI = 'svc:/application/openstack/nova/zone-vnc-console'

# Required in order to create a zone VNC console SMF service instance

VNC_SERVER_PATH = '/usr/bin/vncserver'

XTERM_PATH = '/usr/bin/xterm'

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._fc_hbas = None

        self._fc_wwnns = None

        self._fc_wwpns = None

        self._host_stats = {}

        self._initiator = None

        self._install_engine = None

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

        self._rad_connection = None

        self._uname = os.uname()

        self._validated_archives = list()

        self._volume_api = volume.API()

    @property

    def rad_connection(self):

        if self._rad_connection is None:

            self._rad_connection = rad.connect.connect_unix()

        else:

            # taken from rad.connect.RadConnection.__repr__ to look for a

            # closed connection

            if self._rad_connection._closed is not None:

                # the RAD connection has been lost.  Reconnect to RAD

                self._rad_connection = rad.connect.connect_unix()

        return self._rad_connection

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

        """

        try:

            self._kstat_control = self.rad_connection.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 cleanup_host(self, host):

        """Clean up anything that is necessary for the driver gracefully stop,

        including ending remote sessions. This is optional.

        """

        pass

    def _get_fc_hbas(self):

        """Get Fibre Channel HBA information."""

        if self._fc_hbas:

            return self._fc_hbas

        out = None

        try:

            out, err = utils.execute('/usr/sbin/fcinfo', 'hba-port')

        except processutils.ProcessExecutionError as err:

            return []

        if out is None:

            raise RuntimeError(_("Cannot find any Fibre Channel HBAs"))

        hbas = []

        hba = {}

        for line in out.splitlines():

            line = line.strip()

            # Collect the following hba-port data:

            # 1: Port WWN

            # 2: State (online|offline)

            # 3: Node WWN

            if line.startswith("HBA Port WWN:"):

                # New HBA port entry

                hba = {}

                wwpn = line.split()[-1]

                hba['port_name'] = wwpn

                continue

            elif line.startswith("Port Mode:"):

                mode = line.split()[-1]

                # Skip Target mode ports

                if mode != 'Initiator':

                    break

            elif line.startswith("State:"):

                state = line.split()[-1]

                hba['port_state'] = state

                continue

            elif line.startswith("Node WWN:"):

                wwnn = line.split()[-1]

                hba['node_name'] = wwnn

                continue

            if len(hba) == 3:

                hbas.append(hba)

                hba = {}

        self._fc_hbas = hbas

        return self._fc_hbas

    def _get_fc_wwnns(self):

        """Get Fibre Channel WWNNs from the system, if any."""

        hbas = self._get_fc_hbas()

        wwnns = []

        for hba in hbas:

            if hba['port_state'] == 'online':

                wwnn = hba['node_name']

                wwnns.append(wwnn)

        return wwnns

    def _get_fc_wwpns(self):

        """Get Fibre Channel WWPNs from the system, if any."""

        hbas = self._get_fc_hbas()

        wwpns = []

        for hba in hbas:

            if hba['port_state'] == 'online':

                wwpn = hba['port_name']

                wwpns.append(wwpn)

        return wwpns

    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_auto_install_state(self, zone_name):

        """Returns the SMF state of the auto-installer service,

           or None if auto-installer service is non-existent

        """

        try:

            out, err = utils.execute('/usr/sbin/zlogin', '-S', zone_name,

                                     '/usr/bin/svcs', '-H', '-o', 'state',

                                     'auto-installer:default')

            return out.strip()

        except processutils.ProcessExecutionError as err:

            # No auto-installer instance most likely.

            return None

    def _get_zone_by_name(self, name):

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

        try:

            zone = self.rad_connection.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 strutils.string_to_bytes("%sB" % 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,