# 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 cinderclient import exceptions as cinder_exception

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

from nova.volume.cinder import API

from nova.volume.cinder import cinderclient

from nova.volume.cinder import get_cinder_client_version

from nova.volume.cinder import translate_volume_exception

from nova.volume.cinder import _untranslate_volume_summary_view

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'

ROOTZPOOL_RESOURCE = 'rootzpool'

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 SolarisVolumeAPI(API):

    """ Extending the volume api to support additional cinder sub-commands

    """

    @translate_volume_exception

    def create(self, context, size, name, description, snapshot=None,

               image_id=None, volume_type=None, metadata=None,

               availability_zone=None, source_volume=None):

        """Clone the source volume by calling the cinderclient version of

        create with a source_volid argument

        :param context: the context for the clone

        :param size: size of the new volume, must be the same as the source

            volume

        :param name: display_name of the new volume

        :param description: display_description of the new volume

        :param snapshot: Snapshot object

        :param image_id: image_id to create the volume from

        :param volume_type: type of volume

        :param metadata: Additional metadata for the volume

        :param availability_zone: zone:host where the volume is to be created

        :param source_volume: Volume object

        Returns a volume object

        """

        if snapshot is not None:

            snapshot_id = snapshot['id']

        else:

            snapshot_id = None

        if source_volume is not None:

            source_volid = source_volume['id']

        else:

            source_volid = None

        kwargs = dict(snapshot_id=snapshot_id,

                      volume_type=volume_type,

                      user_id=context.user_id,

                      project_id=context.project_id,

                      availability_zone=availability_zone,

                      metadata=metadata,

                      imageRef=image_id,

                      source_volid=source_volid)

        version = get_cinder_client_version(context)

        if version == '1':

            kwargs['display_name'] = name

            kwargs['display_description'] = description

        elif version == '2':

            kwargs['name'] = name

            kwargs['description'] = description

        try:

            item = cinderclient(context).volumes.create(size, **kwargs)

            return _untranslate_volume_summary_view(context, item)

        except cinder_exception.OverLimit:

            raise exception.OverQuota(overs='volumes')

        except cinder_exception.BadRequest as err:

            raise exception.InvalidInput(reason=unicode(err))

    @translate_volume_exception

    def update(self, context, volume_id, fields):

        """Update the fields of a volume for example used to rename a volume

        via a call to cinderclient

        :param context: the context for the update

        :param volume_id: the id of the volume to update

        :param fields: a dictionary of of the name/value pairs to update

        """

        cinderclient(context).volumes.update(volume_id, **fields)

    @translate_volume_exception

    def extend(self, context, volume, newsize):

        """Extend the size of a cinder volume by calling the cinderclient

        :param context: the context for the extend

        :param volume: the volume object to extend

        :param newsize: the new size of the volume in GB

        """

        cinderclient(context).volumes.extend(volume, newsize)

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

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

        """creates a new resource with an optional property list, or set the

        property if the resource exists and ignore_exists is true.

        :param ignore_exists: If the resource exists, set the property for the

            resource.

        """

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

        self._volume_api = SolarisVolumeAPI()

        self._rootzpool_suffix = ROOTZPOOL_RESOURCE

    @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"))