# Copyright 2011 Justin Santa Barbara

# All Rights Reserved.

#

# Copyright (c) 2013, 2016, 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_1 as kstat

import rad.bindings.com.oracle.solaris.rad.zonemgr_1 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 import objects

from nova.objects import flavor as flavor_obj

from nova.openstack.common import excutils

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('live_migration_cipher',

               help='Cipher to use for encryption of memory traffic during '

                    'live migration. If not specified, a common encryption '

                    'algorithm will be negotiated. Options include: none or '

                    'the name of a supported OpenSSL cipher algorithm.'),

    cfg.StrOpt('solariszones_snapshots_directory',

               default='$instances_path/snapshots',

               help='Location to 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'

# The underlying Solaris Zones framework does not expose a specific

# version number, instead relying on feature tests to identify what is

# and what is not supported. A HYPERVISOR_VERSION is defined here for

# Nova's use but it generally should not be changed unless there is a

# incompatible change such as concerning kernel zone live migration.

HYPERVISOR_VERSION = '5.11'

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

def zonemgr_strerror(ex):

    """Format the payload from a zonemgr(3RAD) rad.client.ObjectError

    exception into a sensible error string that can be logged. Newlines

    are converted to a colon-space string to create a single line.

    If the exception was something other than rad.client.ObjectError,

    just return it as a string.

    """

    if not isinstance(ex, rad.client.ObjectError):

        return str(ex)

    payload = ex.get_payload()

    if payload.code == zonemgr.ErrorCode.NONE:

        return str(ex)

    error = [str(payload.code)]

    if payload.str is not None and payload.str != '':

        error.append(payload.str)

    if payload.stderr is not None and payload.stderr != '':

        stderr = payload.stderr.rstrip()

        error.append(stderr.replace('\n', ': '))

    result = ': '.join(error)

    return result

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-global 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 Exception as ex:

            reason = zonemgr_strerror(ex)

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

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

            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 Exception as ex:

                reason = zonemgr_strerror(ex)

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

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

                          % (self.zone.name, reason))

                # Last ditch effort to cleanup.

                self.zone.cancelConfig()

                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 Exception as ex:

            reason = zonemgr_strerror(ex)

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

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

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

            raise

        if props is None:

            props = []

        try:

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

        except Exception as ex:

            if isinstance(ex, rad.client.ObjectError):

                code = ex.get_payload().code

                if (ignore_exists and

                        code == zonemgr.ErrorCode.RESOURCE_ALREADY_EXISTS):

                    self.zone.setResourceProperties(zonemgr.Resource(

                        resource, None), props)

                    return

            reason = zonemgr_strerror(ex)

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

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

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

            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 Exception as ex:

            reason = zonemgr_strerror(ex)

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

                        "zonemgr(3RAD): %s")

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

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

    @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:

            return []

        if out is None:

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