#!/usr/bin/python

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.

#

""" logical.py -- library containing class definitions for logical DOC objects,

including Zpool, Filesystem, and Zvol

"""

import logging

import os

from lxml import etree

from solaris_install import CalledProcessError, Popen

from solaris_install.data_object import DataObject, ParsingError

from solaris_install.data_object.data_dict import DataObjectDict

from solaris_install.logger import INSTALL_LOGGER_NAME as ILN

from solaris_install.target.size import Size

from solaris_install.target.shadow.logical import ShadowLogical

from solaris_install.target.shadow.zpool import ShadowZpool

from solaris_install.target.libbe.be import be_list, be_init, be_destroy, \

    be_activate, be_mount, be_unmount

from solaris_install.target.libnvpair import nvl

DUMPADM = "/usr/sbin/dumpadm"

LOFIADM = "/usr/sbin/lofiadm"

MKFILE = "/usr/sbin/mkfile"

MOUNT = "/usr/sbin/mount"

NEWFS = "/usr/sbin/newfs"

SWAP = "/usr/sbin/swap"

UMOUNT = "/usr/sbin/umount"

ZFS = "/usr/sbin/zfs"

ZPOOL = "/usr/sbin/zpool"

DEFAULT_BE_NAME = "solaris"

class Logical(DataObject):

    """ logical DOC node definition

    """

    def __init__(self, name):

        super(Logical, self).__init__(name)

        self.noswap = False

        self.nodump = False

        # shadow lists

        self._children = ShadowZpool(self)

    def to_xml(self):

        element = etree.Element("logical")

        element.set("noswap", str(self.noswap).lower())

        element.set("nodump", str(self.nodump).lower())

        return element

    @classmethod

    def can_handle(cls, element):

        """ Returns True if the element has the tag 'logical'

        """

        if element.tag == "logical":

            return True

        return False

    @classmethod

    def from_xml(cls, element):

        noswap = element.get("noswap")

        nodump = element.get("nodump")

        logical = Logical("logical")

        if noswap is not None:

            try:

                logical.noswap = {"true": True, "false": False}[noswap.lower()]

            except KeyError:

                raise ParsingError("Logical  element's noswap attribute " +

                                   "must be either 'true' or 'false'")

        if nodump is not None:

            try:

                logical.nodump = {"true": True, "false": False}[nodump.lower()]

            except KeyError:

                raise ParsingError("Logical  element's nodump attribute " +

                                   "must be either 'true' or 'false'")

        return logical

    def add_zpool(self, zpool_name, is_root=False, mountpoint=None):

        """ add_zpool() - method to create a Zpool object and add it as a child

        of the Logical object

        """

        # create a new Zpool object

        new_zpool = Zpool(zpool_name)

        new_zpool.is_root = is_root

        new_zpool.mountpoint = mountpoint

        # add the new Zpool object as a child

        self.insert_children(new_zpool)

        return new_zpool

    def delete_zpool(self, zpool):

        """ delete_zpool() - method to delete a specific Zpool object

        """

        self.delete_children(name=zpool.name, class_type=Zpool)

    def __copy__(self):

        """ method to override the parent's version of __copy__.

        We want the _children list to be a shadow list instead of a flat list

        """

        new_copy = super(Logical, self).__copy__()

        new_copy._children = ShadowZpool(new_copy)

        return new_copy

    def __repr__(self):

        return "Logical: noswap=%s; nodump=%s" % (self.noswap, self.nodump)

class Zpool(DataObject):

    """ zpool DOC node definition

    """

    def __init__(self, name, vdev_list=None, mountpoint=None):

        super(Zpool, self).__init__(name)

        self.action = "create"

        self.is_root = False

        self.mountpoint = mountpoint

        if not isinstance(vdev_list, list):

            # convert a string of vdev(s) into a list with one element

            self.vdev_list = [vdev_list]

        else:

            self.vdev_list = vdev_list

        # shadow lists

        self._children = ShadowLogical(self)

    def to_xml(self):

        element = etree.Element("zpool")

        element.set("name", self.name)

        element.set("action", self.action)

        element.set("is_root", str(self.is_root).lower())

        if self.mountpoint is not None:

            element.set("mountpoint", self.mountpoint)

        return element

    @classmethod

    def can_handle(cls, element):

        """ Returns True if element has:

        - the tag 'zpool'

        - a name attribute

        otherwise return False

        """

        if element.tag != "zpool":

            return False

        if element.get("name") is None:

            return False

        return True

    @classmethod

    def from_xml(cls, element):

        name = element.get("name")

        action = element.get("action")

        is_root = element.get("is_root")

        mountpoint = element.get("mountpoint")

        zpool = Zpool(name)

        if action is not None:

            zpool.action = action

        if is_root is not None:

            try:

                zpool.is_root = {"true": True, "false": False}[is_root.lower()]

            except KeyError:

                raise ParsingError("Zpool element's is_root attribute must " +

                                   "be either 'true' or 'false'")

        if mountpoint is not None:

            zpool.mountpoint = mountpoint

        return zpool

    @property

    def exists(self):

        """ property to check for the existance of the zpool

        """

        cmd = [ZPOOL, "list", self.name]

        p = Popen.check_call(cmd, stdout=Popen.STORE, stderr=Popen.STORE,

                             check_result=Popen.ANY)

        return p.returncode == 0

    @property

    def filesystems(self):

        """ method to return all filesystems which belong to the pool

        """

        filesystem_list = []

        # if the zpool doesn't yet exist, return an empty list

        if not self.exists:

            return filesystem_list

        cmd = [ZFS, "list", "-H", "-t", "filesystem", "-o", "name", "-r",

               self.name]

        p = Popen.check_call(cmd, stdout=Popen.STORE, stderr=Popen.STORE,

                             logger=ILN)

        for fs in p.stdout.splitlines():

            filesystem_list.append(Filesystem(fs))

        return filesystem_list

    def set(self, propname, propvalue, dry_run):

        """ method to set a property for the pool

        """

        cmd = [ZPOOL, "set", "%s=%s" % (propname, propvalue), self.name]

        if not dry_run:

            Popen.check_call(cmd, stdout=Popen.STORE, stderr=Popen.STORE,

                             logger=ILN)

    def get(self, propname="all"):

        """ get() - method to return a specific zpool property.

        propname - name of the property to return.  If the user does not

        specify a propname, return all pool properties

        """

        cmd = [ZPOOL, "get", propname, self.name]

        p = Popen.check_call(cmd, stdout=Popen.STORE, stderr=Popen.STORE,

                             logger=ILN)

        # construct a dictionary of properties

        prop_dict = dict()

        # skip the header line

        for line in p.stdout.splitlines()[1:]:

            # The output from zpool get is in four columns:

            # NAME PROPERTY VALUE SOURCE

            # We're only interested in the PROPERTY and VALUE columns

            _none, prop, value, _none = line.strip().split()

            prop_dict[prop] = value

        return prop_dict

    def create(self, dry_run, options=[]):

        """ method to create the zpool from the vdevs

        options - optional list of pool and/or dataset options to pass to the

        create flag

        """

        cmd = [ZPOOL, "create", "-f"]

        if self.is_root:

            cmd.append("-B")

        if options:

            cmd.extend(options)

        # add the mountpoint if specified

        if self.mountpoint is not None:

            cmd.append("-m")

            cmd.append(self.mountpoint)

        cmd.append(self.name)

        if None in self.vdev_list:

            raise RuntimeError("Invalid entry in vdev_list:  " + \

                               str(self.vdev_list))

        # add the vdev_list to the cmd to preserve the format Popen needs

        cmd += self.vdev_list

        if not dry_run:

            Popen.check_call(cmd, stdout=Popen.STORE, stderr=Popen.STORE,

                             logger=ILN)

    def destroy(self, dry_run, force=False):

        """ method to destroy the zpool

        """

        if self.exists:

            cmd = [ZPOOL, "destroy"]

            if force:

                cmd.append("-f")

            cmd.append(self.name)

            if not dry_run:

                Popen.check_call(cmd, stdout=Popen.STORE, stderr=Popen.STORE,

                                 logger=ILN)

    def add_vdev(self, label, redundancy):

        """ add_vdev() - method to create a Vdev object and add it as a child

        of the Zpool object

        """

        # No need to validate here because the schema has a list of valid

        # redundancy values already

        new_vdev = Vdev(label)

        new_vdev.redundancy = redundancy

        self.insert_children(new_vdev)

        return new_vdev

    def delete_vdev(self, vdev):

        """ delete_vdev() - method to delete a specific Vdev object

        """

        self.delete_children(name=vdev.name, class_type=Vdev)

    def add_filesystem(self, fs_name, mountpoint=None):

        """ add_filesystem - method to create a Filesystem object and add it as

        a child of the Zpool object

        """

        # create a new Filesystem object

        new_filesystem = Filesystem(fs_name)

        new_filesystem.mountpoint = mountpoint

        # add the new Filesystem object as a child

        self.insert_children(new_filesystem)

        return new_filesystem

    def delete_filesystem(self, filesystem):

        """ delete_filesystem() - method to delete a specific Filesystem object

        """

        self.delete_children(name=filesystem.name, class_type=Filesystem)

    def add_zvol(self, zvol_name, size="", size_units=Size.gb_units, use=None,

                 create_failure_ok=False):

        """ add_zvol - method to create a Zvol object and add it as a child of

        the Zpool object

        """

        # create a new Zvol object

        new_zvol = Zvol(zvol_name)

        # fix the size units to conform to ZFS syntax by removing the "b"

        # character from the units

        if size:

            if size == "max":

                new_zvol.size = size

            else:

                size_units = str(size_units).rstrip("bB")

                new_zvol.size = str(size) + size_units

        if use is not None:

            new_zvol.use = use

        new_zvol.create_failure_ok = create_failure_ok

        # add the new Zvol object as a child

        self.insert_children(new_zvol)

        return new_zvol

    def delete_zvol(self, zvol):

        """ delete_zvol() - method to delete a specific Zvol object

        """

        self.delete_children(name=zvol.name, class_type=Zvol)

    def __copy__(self):

        """ method to override the parent's version of __copy__.

        We want the _children list to be a shadow list instead of a flat list

        """

        new_copy = super(Zpool, self).__copy__()

        new_copy._children = ShadowLogical(new_copy)

        return new_copy

    def __repr__(self):

        s = "Zpool: name=%s; action=%s" % (self.name, self.action)

        s += "; is_root=%s" % self.is_root

        if self.mountpoint is not None:

            s += "; mountpoint=%s" % self.mountpoint

        if self.vdev_list is not None:

            s += "; vdev_list=" + str(self.vdev_list)

        return s

class Vdev(DataObject):

    """ vdev DOC node definition

    """

    def __init__(self, name):

        super(Vdev, self).__init__(name)

        self.redundancy = "mirror"

    def to_xml(self):

        element = etree.Element("vdev")

        element.set("name", self.name)

        element.set("redundancy", self.redundancy)

        return element

    @classmethod

    def can_handle(cls, element):

        if element.tag == "vdev":

            return True

        return False

    @classmethod

    def from_xml(cls, element):

        name = element.get("name")

        redundancy = element.get("redundancy")

        vdev = Vdev(name)

        if redundancy is not None:

            vdev.redundancy = redundancy

        return vdev

    def __repr__(self):

        return "Vdev: name=%s; redundancy=%s" % (self.name, self.redundancy)

class Filesystem(DataObject):

    """ Filesystem DOC node definition

    """

    def __init__(self, name):

        super(Filesystem, self).__init__(name)

        self.action = "create"

        self.mountpoint = None

        self.in_be = False

    @property

    def full_name(self):

        """ Keep a full_name attribute with the entire ZFS path for the

        filesystem.  This is done because Filesystem objects can be created via

        Zpool.add_filesystem, simple instantiation, or with the in_be attribute

        set.

        """

        if self.parent is not None:

            if self.in_be:

                # for in_be Filesystem objects, we need to get the BE and add

                # it instead of the parent

                be = self.parent.get_first_child(class_type=BE)

                return os.path.join(self.parent.name, "ROOT", be.name,

                                    self.name.lstrip("/"))

            else:

                return os.path.join(self.parent.name, self.name.lstrip("/"))

        else:

            return self.name

    def to_xml(self):

        element = etree.Element("filesystem")

        element.set("name", self.name)

        element.set("action", self.action)

        if self.mountpoint is not None:

            element.set("mountpoint", self.mountpoint)

        element.set("in_be", str(self.in_be).lower())

        return element

    @classmethod

    def can_handle(cls, element):

        """ Returns True if element has:

        - the tag 'filesystem'

        - a name attribute

        - an action attribute

        otherwise return False

        """

        if element.tag != "filesystem":

            return False

        if element.get("name") is None:

            return False

        return True

    @classmethod

    def from_xml(cls, element):

        name = element.get("name")

        action = element.get("action")

        mountpoint = element.get("mountpoint")

        in_be = element.get("in_be")

        filesystem = Filesystem(name)

        if action is not None:

            filesystem.action = action

        if mountpoint is not None:

            filesystem.mountpoint = mountpoint

        else:

            # Recursively strip the dataset_path until the mountpoint is

            # found.

            stripped_entries = []

            dataset_list = name.split("/")

            # add the parent's name (the zpool name) to the list

            dataset_list.insert(0, element.getparent().get("name"))

            while dataset_list:

                try:

                    test_dataset = Filesystem("/".join(dataset_list))

                    test_dataset_mp = test_dataset.get("mountpoint")

                except CalledProcessError:

                    # strip off the last element and save it for later

                    stripped_entries.append(dataset_list[-1])

                    dataset_list = dataset_list[:-1]

                    continue

                else:

                    # the mountpoint was found so add the stripped entries

                    # (in reverse) to generate the proper path.

                    filesystem.mountpoint = os.path.join(test_dataset_mp,

                        "/".join(reversed(stripped_entries)))

                    break

            else:

                # set the mountpoint to None

                filesystem.mountpoint = None

        if in_be is not None:

            try:

            except KeyError:

                raise ParsingError("Filesystem element's in_be attribute " +