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

# Copyright (c) 2012 OpenStack LLC.

# All Rights Reserved.

#

# Copyright (c) 2014, 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.

"""

Drivers for Solaris ZFS operations in local and iSCSI modes

"""

import abc

import fcntl

import os

import subprocess

import time

from oslo_concurrency import processutils

from oslo_config import cfg

from oslo_log import log as logging

import paramiko

from cinder import exception

from cinder.i18n import _, _LE, _LI

from cinder.image import image_utils

from cinder.volume import driver

from cinder.volume.drivers.san.san import SanDriver

import rad.client as radc

import rad.connect as radcon

from solaris_install.target.size import Size

LOG = logging.getLogger(__name__)

solaris_zfs_opts = [

    cfg.StrOpt('zfs_volume_base',

               default='rpool/cinder',

               help='The base dataset for ZFS volumes.'),

    cfg.StrOpt('zfs_target_group',

               default='tgt-grp',

               help='iSCSI target group name.'), ]

def connect_tls(host, port=12302, locale=None, ca_certs=None):

    """Connect to a RAD instance over TLS.

    Arguments:

    host     string, target host

    port     int, target port (RAD_PORT_TLS = 12302)

    locale   string, locale

    ca_certs string, path to file containing CA certificates

    Returns:

    RadConnection: a connection to RAD

    """

    # We don't want SSL 2.0, SSL 3.0 nor TLS 1.0 in RAD

    context = SSL.Context(SSL.SSLv23_METHOD)

    context.set_options(SSL.OP_NO_SSLv2)

    context.set_options(SSL.OP_NO_SSLv3)

    context.set_options(SSL.OP_NO_TLSv1)

    if ca_certs is not None:

        context.set_verify(SSL.VERIFY_PEER, _tls_verify_cb)

        context.load_verify_locations(ca_certs)

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    sock = SSL.Connection(context, sock)

    sock.connect((host, port))

    sock.do_handshake()

    return radcon.RadConnection(sock, locale=locale)

class ZFSVolumeDriver(SanDriver):

    """OpenStack Cinder ZFS volume driver for generic ZFS volumes.

    Version history:

        1.0.0 - Initial driver with basic functionalities in Havana

        1.1.0 - Support SAN for the remote storage nodes access in Juno

        1.1.1 - Add support for the volume backup

        1.1.2 - Add support for the volume migration

        1.2.0 - Add support for the volume management in Kilo

        1.2.1 - Enable the connect_tls by importing eventlet.green.socket

        1.2.2 - Introduce the ZFS RAD for volume migration enhancement

        1.2.3 - Replace volume-specific targets with one shared target in

                the ZFSISCSIDriver

    """

    protocol = 'local'

    def __init__(self, *args, **kwargs):

        super(ZFSVolumeDriver, self).__init__(execute=self.solaris_execute,

                                              *args, **kwargs)

        self.configuration.append_config_values(solaris_zfs_opts)

        self.run_local = self.configuration.san_is_local

        self.hostname = socket.gethostname()

    def solaris_execute(self, *cmd, **kwargs):

        """Execute the command locally or remotely."""

        if self.run_local:

            return processutils.execute(*cmd, **kwargs)

        else:

            return super(ZFSVolumeDriver, self)._run_ssh(cmd,

                                                         check_exit_code=True)

    def check_for_setup_error(self):

        """Check the setup error."""

        pass

    def create_volume(self, volume):

        """Create a volume."""

        size = '%sG' % volume['size']

        zfs_volume = self._get_zfs_volume_name(volume['name'])

        # Create a ZFS volume

        cmd = ['/usr/sbin/zfs', 'create', '-V', size, zfs_volume]

        self._execute(*cmd)

        LOG.debug(_("Created ZFS volume '%s'") % volume['name'])

    def create_volume_from_snapshot(self, volume, snapshot):

        """Create a cloned volume from a snapshot."""

        if volume['size'] != snapshot['volume_size']:

            exception_message = (_("Could not create volume '%s' because "

                                   "its volume size of '%s' is different "

                                   "from that of the snapshot, '%s'.")

                                 % (volume['name'], volume['size'],

                                    snapshot['volume_size']))

            raise exception.InvalidInput(reason=exception_message)

        # Create a ZFS clone

        zfs_snapshot = self._get_zfs_snap_name(snapshot)

        zfs_volume = self._get_zfs_volume_name(volume['name'])

        cmd = ['/usr/sbin/zfs', 'clone', zfs_snapshot, zfs_volume]

        self._execute(*cmd)

        LOG.debug(_("Created cloned volume '%s'") % volume['name'])

    def create_cloned_volume(self, volume, src_vref):

        """Create a clone of the specified volume."""

        if volume['size'] != src_vref['size']:

            exception_message = (_("Could not clone volume '%s' because "

                                   "its volume size of '%s' is different "

                                   "from that of the source volume, '%s'.")

                                 % (volume['name'], volume['size'],

                                    src_vref['size']))

            raise exception.VolumeBackendAPIException(data=exception_message)

        self._zfs_send_recv(src_vref,

                            self._get_zfs_volume_name(volume['name']))

        LOG.debug(_("Created cloned volume '%s' from source volume '%s'")

                  % (volume['name'], src_vref['name']))

    def delete_volume(self, volume):

        """Delete a volume.

        Firstly, the volume should be checked if it is a cloned one. If yes,

        its parent snapshot with prefix 'tmp-snapshot-' should be deleted as

        well after it is removed.

        """

        zvol = self._get_zvol_path(volume)

        try:

            (out, _err) = self._execute('/usr/bin/ls', zvol)

        except processutils.ProcessExecutionError:

            LOG.debug(_("The volume path '%s' doesn't exist") % zvol)

            return

        zfs_volume = self._get_zfs_volume_name(volume['name'])

        origin_snapshot = self._get_zfs_property('origin', zfs_volume)

        tmp_cloned_vol = False

        # Check if it is the temporary snapshot created for the cloned volume

        if origin_snapshot.startswith(self.configuration.zfs_volume_base):

            prop_type = self._get_zfs_property('type', origin_snapshot)

            tmp_snap_prefix = 'tmp-snapshot-%s' % volume['id']

            if prop_type == 'snapshot' and tmp_snap_prefix in origin_snapshot:

                tmp_cloned_vol = True

        cmd = ['/usr/sbin/zfs', 'destroy', zfs_volume]

        self._execute(*cmd)

        LOG.debug(_("Deleted volume '%s'") % volume['name'])

        if tmp_cloned_vol:

            self._execute('/usr/sbin/zfs', 'destroy', origin_snapshot)

            LOG.debug(_("Deleted parent snapshot '%s' of volume '%s'")

                      % (origin_snapshot, volume['name']))

    def create_snapshot(self, snapshot):

        """Create a snapshot."""

        cmd = ['/usr/sbin/zfs', 'snapshot', self._get_zfs_snap_name(snapshot)]

        self._execute(*cmd)

        LOG.debug(_("Created snapshot '%s'") % snapshot['name'])

    def delete_snapshot(self, snapshot):

        """Delete a snapshot."""

        cmd = ['/usr/sbin/zfs', 'destroy', self._get_zfs_snap_name(snapshot)]

        self._execute(*cmd)

        LOG.debug(_("Deleted snapshot '%s'") % snapshot['name'])

    def ensure_export(self, context, volume):

        """Synchronously recreate an export for a logical volume."""

        pass

        """Export the volume."""

        pass

    def remove_export(self, context, volume):

        """Remove an export for a volume."""

        pass

    def initialize_connection(self, volume, connector):

        """Initialize the connection and returns connection info."""

        volume_path = '%s/volume-%s' % (self.configuration.zfs_volume_base,

                                        volume['id'])

        properties = {}

        properties['device_path'] = self._get_zvol_path(volume)

        return {

            'driver_volume_type': 'local',

            'volume_path': volume_path,

            'data': properties

        }

    def terminate_connection(self, volume, connector, **kwargs):

        """Disconnection from the connector."""

        pass

    def attach_volume(self, context, volume, instance_uuid, host_name,

                      mountpoint):

        """Callback for volume attached to instance or host."""

        pass

    def detach_volume(self, context, volume, attachment):

        """ Callback for volume detached."""

        pass

    def get_volume_stats(self, refresh=False):

        """Get volume status."""

        if refresh:

            self._update_volume_stats()

        return self._stats

    def _get_zfs_property(self, prop, dataset):

        """Get the value of property for the dataset."""

        try:

            (out, _err) = self._execute('/usr/sbin/zfs', 'get', '-H', '-o',

                                        'value', prop, dataset)

            return out.rstrip()

        except processutils.ProcessExecutionError:

            LOG.info(_LI("Failed to get the property '%s' of the dataset '%s'")

                     % (prop, dataset))

            return None

    def _get_zfs_snap_name(self, snapshot):

        """Get the snapshot path."""

        return "%s/%s@%s" % (self.configuration.zfs_volume_base,

                             snapshot['volume_name'], snapshot['name'])

    def _get_zfs_volume_name(self, volume_name):

        """Add the pool name to get the ZFS volume."""

        return "%s/%s" % (self.configuration.zfs_volume_base,

                          volume_name)

    def _remote_piped_execute(self, cmd1, cmd2, ip, username, password):

        """Piped execute on a remote host."""

        LOG.debug(_("Piping cmd1='%s' into cmd='%s' on host '%s'") %

                  (' '.join(cmd1), ' '.join(cmd2), ip))

        client = paramiko.SSHClient()

        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

        client.connect(ip, username=username, password=password)

        cmd = ' '.join(cmd1) + '|' + ' '.join(cmd2)

        stdin, stdout, stderr = client.exec_command(cmd)

        channel = stdout.channel

        exit_status = channel.recv_exit_status()

        if exit_status != 0:

            LOG.error(_("_remote_piped_execute: failed to host '%s' with "

                        "stdout '%s' and stderr '%s'")

                      % (ip, stdout.read(), stderr.read()))

            msg = (_("Remote piped execution failed to host '%s'.") % ip)

            raise exception.VolumeBackendAPIException(data=msg)

    def _piped_execute(self, cmd1, cmd2):

        """Pipe output of cmd1 into cmd2."""

        LOG.debug(_("Piping cmd1='%s' into cmd2='%s'") %

                  (' '.join(cmd1), ' '.join(cmd2)))

        try:

            p1 = subprocess.Popen(cmd1, stdout=subprocess.PIPE,

                                  stderr=subprocess.PIPE)

        except:

            LOG.error(_LE("_piped_execute '%s' failed.") % (cmd1))

            raise

        # Set the pipe to be blocking because evenlet.green.subprocess uses

        # the non-blocking pipe.

        flags = fcntl.fcntl(p1.stdout, fcntl.F_GETFL) & (~os.O_NONBLOCK)

        fcntl.fcntl(p1.stdout, fcntl.F_SETFL, flags)

        p2 = subprocess.Popen(cmd2, stdin=p1.stdout,

                              stdout=subprocess.PIPE,

                              stderr=subprocess.PIPE)

        p1.stdout.close()

        stdout, stderr = p2.communicate()

        if p2.returncode:

            msg = (_("_piped_execute failed with the info '%s' and '%s'.") %

                   (stdout, stderr))

            raise exception.VolumeBackendAPIException(data=msg)

    def _zfs_send_recv(self, src, dst):

        """Replicate the ZFS dataset by calling zfs send/recv cmd"""

        src_snapshot = {'volume_name': src['name'],

                        'name': 'tmp-snapshot-%s' % src['id']}

        src_snapshot_name = self._get_zfs_snap_name(src_snapshot)

        prop_type = self._get_zfs_property('type', src_snapshot_name)

        # Delete the temporary snapshot if it already exists

        if prop_type == 'snapshot':

            self.delete_snapshot(src_snapshot)

        # Create a temporary snapshot of volume

        self.create_snapshot(src_snapshot)

        src_snapshot_name = self._get_zfs_snap_name(src_snapshot)

        cmd1 = ['/usr/sbin/zfs', 'send', src_snapshot_name]

        cmd2 = ['/usr/sbin/zfs', 'receive', dst]

        # Due to pipe injection protection in the ssh utils method,

        # cinder.utils.check_ssh_injection(), the piped commands must be passed

        # through via paramiko. These commands take no user defined input

        # other than the names of the zfs datasets which are already protected

        # against the special characters of concern.

        if not self.run_local:

            ip = self.configuration.san_ip

            username = self.configuration.san_login

            password = self.configuration.san_password

            self._remote_piped_execute(cmd1, cmd2, ip, username, password)

        else:

            self._piped_execute(cmd1, cmd2)

        # Delete the temporary src snapshot and dst snapshot

        self.delete_snapshot(src_snapshot)

        dst_snapshot_name = "%s@tmp-snapshot-%s" % (dst, src['id'])

        cmd = ['/usr/sbin/zfs', 'destroy', dst_snapshot_name]

        self._execute(*cmd)

    def _get_rc_connect(self, san_info=None):

        """Connect the RAD server."""

        if san_info is not None:

            san_ip = san_info.split(';')[0]

            san_login = san_info.split(';')[1]

            san_password = san_info.split(';')[2]

        else:

            san_ip = self.configuration.san_ip

            san_login = self.configuration.san_login

            san_password = self.configuration.san_password

        rc = connect_tls(san_ip)

        auth = rada.RadAuth(rc)

        auth.pam_login(san_login, san_password)

        return rc

    def _rad_zfs_send_recv(self, src, dst, dst_san_info=None):

        """Replicate the ZFS dataset stream."""

        src_snapshot = {'volume_name': src['name'],

                        'name': 'tmp-send-snapshot-%s' % src['id']}

        src_snapshot_name = self._get_zfs_snap_name(src_snapshot)

        prop_type = self._get_zfs_property('type', src_snapshot_name)

        # Delete the temporary snapshot if it already exists

        if prop_type == 'snapshot':

            self.delete_snapshot(src_snapshot)

        # Create the temporary snapshot of src volume

        self.create_snapshot(src_snapshot)

    def _get_zvol_path(self, volume):

        """Get the ZFS volume path."""

        return "/dev/zvol/rdsk/%s" % self._get_zfs_volume_name(volume['name'])

    def _update_volume_stats(self):

        """Retrieve volume status info."""

        LOG.debug(_("Updating volume status"))

        stats = {}

        backend_name = self.configuration.safe_get('volume_backend_name')

        stats["volume_backend_name"] = backend_name or self.__class__.__name__

        stats["storage_protocol"] = self.protocol

        stats["driver_version"] = self.version

        stats["vendor_name"] = 'Oracle'

        stats['QoS_support'] = False

        dataset = self.configuration.zfs_volume_base

        used_size = self._get_zfs_property('used', dataset)

        avail_size = self._get_zfs_property('avail', dataset)

        stats['total_capacity_gb'] = \

            (Size(used_size) + Size(avail_size)).get(Size.gb_units)

        stats['free_capacity_gb'] = Size(avail_size).get(Size.gb_units)

        stats['reserved_percentage'] = self.configuration.reserved_percentage

        stats['location_info'] =\

            ('ZFSVolumeDriver:%(hostname)s:%(zfs_volume_base)s:local' %

             {'hostname': self.hostname,

              'zfs_volume_base': self.configuration.zfs_volume_base})

        self._stats = stats

    def extend_volume(self, volume, new_size):

        """Extend an existing volume's size."""

        volsize_str = 'volsize=%sg' % new_size

        zfs_volume = self._get_zfs_volume_name(volume['name'])

        try:

            self._execute('/usr/sbin/zfs', 'set', volsize_str, zfs_volume)

        except Exception:

            msg = (_("Failed to extend volume size to %(new_size)s GB.")

                   % {'new_size': new_size})

            raise exception.VolumeBackendAPIException(data=msg)