#!/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, Oracle and/or its affiliates. All rights reserved.

#

''' target_selection.py - Select Install Target(s)

'''

import copy

import os

import platform

import re

import traceback

from operator import attrgetter

import osol_install.errsvc as errsvc

from solaris_install.engine import InstallEngine

from solaris_install.engine.checkpoint import AbstractCheckpoint as Checkpoint

from solaris_install.target import Target, vdevs

from solaris_install.target.controller import TargetController, \

    DEFAULT_VDEV_NAME, SwapDumpGeneralError, SwapDumpSpaceError

from solaris_install.target.logical import Logical, Zpool, Vdev, BE, Zvol, \

    Filesystem, DatasetOptions, PoolOptions

from solaris_install.target.physical import Disk, Partition, Slice

from solaris_install.target.size import Size

DISK_RE = "c\d+(?:t\d+)?d\d+"

class SelectionError(Exception):

    '''Error generated when any selection problems occur'''

    def __init__(self, msg):

        Exception.__init__(self)

        self.msg = msg

    def __str__(self):

        return self.msg

class TargetSelection(Checkpoint):

    '''TargetSelection - Checkpoint to select install target.

       This checkpoint attempts to select the install target(s) based on

       the information provided in the discovered targets and the target

       information provided in the AI Manifest.

       If it's not possible to determine a selection, then a SelectionError

       exception will be raised, causing the installation to fail.

    '''

    RAIDZ_REDUNDANCY = ['raidz', 'raidz1', 'raidz2', 'raidz3']

    TOPLEVEL_REDUNDANCY = ['none', 'mirror']

    TOPLEVEL_REDUNDANCY.extend(RAIDZ_REDUNDANCY)

    INVALID_ROOT_VDEV = ['log', 'logmirror']

    PRESERVED = ['preserve', 'use_existing']

    def __init__(self, name, be_mountpoint="/a"):

        super(TargetSelection, self).__init__(name)

        # instance attributes

        self.be_mountpoint = be_mountpoint

        self.doc = InstallEngine.get_instance().data_object_cache

        self.dry_run = False

        # Initialize TargetController

        self.controller = TargetController(self.doc)

        # Cache of Discovered Tree, Disks  in the DOC, will be filled in later

        self._discovered = None

        self._discovered_disks = list()

        self._discovered_zpools = list()

        self._discovered_zpool_map = dict()

        self._remaining_zpool_map = dict()

        self.__reset_maps()

    def __reset_maps(self):

        '''Reset all local map information to default values

        '''

        # Whether swap/dump is to be created, noswap = Don't create swap

        self._nozpools = False

        self._noswap = False

        self._nodump = False

        # Cache of various information useful during parsing of manifest info

        self._root_pool = None     # Should be only one root pool

        self._be = None            # Should be only one BE

        self._is_generated_root_pool = False

        self._root_vdev = None     # Will only be set if we create a new rpool

                                   # due to none existing in manifest

        self._swap_zvol_map = dict()  # Map of zpool:swap to Zvol object

        self._dump_zvol = None   # Can only have one dump device

        self._no_logical_disks = list()  # List of disks with no zpool or vdev

        # Assuming only one target object per manifest.

        # If supporting more than one target, these will become lists

        # of dictionaries accessed via a target index.

        self._zpool_map = dict()   # Map of zpool names to Zpool object

        self._vdev_map = dict()    # Map of zpool:vdev names to Vdev objects

        self._vdev_added_map = dict()  # Map of zpool:vdev names we added

        self._zvol_map = dict()    # Map of zpool:zvols names to Zvol objects

        self._fs_map = dict()      # Map of zpool:datasets to Dataset objects

        self._pool_options = dict()  # Map of zpool names to PoolOption objects

        self._dataset_options = dict()  # Map of zpool names to DatasetOptions

        self._disk_map = dict()      # Map of disks to Disk objects

    def __find_disk(self, disk):

        '''Find a disk matching some criteria

           Disk can be identified in the following order of preference :

               1. disk.ctd (device name)

               2. disk.volid (volume name)

               3. disk.devid (device id)

               4. disk.devpath (device path)

               5. disk.receptacle (disk silk screen name)

               6. disk.is_boot_disk() (contains keyword "boot_disk")

               7. If None of the above are specified, a disk can be

                  identified via any/all of the three disk properties:

                    - dev_type

                    - dev_vendor

                    - dev_size

                  In this scenario, first matching disk will be returned.

        '''

        for discovered_disk in self._discovered_disks:

            # Attempt to match ctd/volid/devpath/devid first

            if discovered_disk.name_matches(disk):

                return discovered_disk

            # Attempt to match disk_prop.  Only match disk properties if all

            # ctd/volid/devpath/devid/receptacle are None, then attempt to

            # match on boot disk or one of the disk properties if specified

            if disk.ctd is None and disk.volid is None and \

               disk.devpath is None and disk.devid is None and \

               disk.receptacle is None:

                # Attempt to match disk_prop. Any of the properties

                # dev_type/dev_vendor/dev_size must been specified

                if discovered_disk.disk_prop is not None and \

                    disk.disk_prop is not None:

                    if discovered_disk.disk_prop.prop_matches(disk.disk_prop):

                        return discovered_disk

                # Attempt to match on boot_disk

                if disk.is_boot_disk() and discovered_disk.is_boot_disk():

                    return discovered_disk

        return None

    @staticmethod

    def __is_iterable(obj):

        '''Test if an object is iterable'''

        try:

            i = iter(obj)

            return True

        except TypeError:

            return False

    def __pretty_print_disk(self, disk):

        '''Print disk identifier rather than whole disk's str()'''

        if self.__is_iterable(disk):

            ret_str = ""

            for _disk in disk:

                if len(ret_str) != 0:

                    ret_str += ", "

                ret_str += self.__pretty_print_disk(_disk)

                return ret_str

        else:

            if isinstance(disk, Disk):

                if disk.ctd is not None:

                    return "%s" % disk.ctd

                if disk.volid is not None:

                    return "[volid='%s']" % disk.volid

                if disk.devpath is not None:

                    return "[devpath='%s']" % disk.devpath

                if disk.devid is not None:

                    return "[devid='%s']" % disk.devid

                if disk.receptacle is not None:

                    return "[receptacle='%s']" % disk.receptacle

                if disk.disk_prop is not None:

                    disk_props = list()

                    if disk.disk_prop.dev_type is not None:

                        disk_props.append(

                            "dev_type='%s'" % (disk.disk_prop.dev_type))

                    if disk.disk_prop.dev_vendor is not None:

                        disk_props.append(

                            "dev_vendor='%s'" % (disk.disk_prop.dev_vendor))

                    if disk.disk_prop.dev_chassis is not None:

                        disk_props.append(

                            "dev_chassis='%s'" %

                            (disk.disk_prop.dev_chassis))

                    if disk.disk_prop.dev_size is not None:

                        disk_props.append(

                            "dev_size='%s'" %

                            (str(disk.disk_prop.dev_size.sectors) +

                             Size.sector_units))

                    if disk_props:

                        disk_props_str = "[" + ",".join(disk_props) + "]"

                        return disk_props_str

                # All else fails, maybe looking for boot-disk?

                if disk.is_boot_disk():

                    return "[boot-disk]"

        return str(disk)

    def __handle_vdev(self, vdev):

        '''Create Vdev object

        '''

        self.logger.debug("Processing Vdev '%s', redundancy='%s'" %

            (vdev.name, vdev.redundancy))

        new_vdev = copy.copy(vdev)

        return new_vdev

    def __handle_filesystem(self, fs):

        '''Create Filesystem Object

        '''

        self.logger.debug("Processing Filesystem '%s', action='%s', "

            "mountpoint='%s'" % (fs.name, fs.action, fs.mountpoint))

        new_fs = copy.copy(fs)

        return new_fs

    def __handle_zvol(self, zvol):

        '''Create Zvol object

        '''

        self.logger.debug("Processing Zvol '%s', action='%s', use='%s'" %

            (zvol.name, zvol.action, zvol.use))

        new_zvol = copy.copy(zvol)

        return new_zvol

    def __handle_pool_options(self, pool_options):

        '''Create PoolOptions object

        '''

        self.logger.debug("Processing Pool Options '%s'" %

            (pool_options.options))

        new_pool_options = copy.copy(pool_options)

        return new_pool_options

    def __handle_dataset_options(self, dataset_options):

        '''Create DatasetOption object

        '''

        self.logger.debug("Processing Dataset Options '%s'" %

            (dataset_options.options))

        new_dataset_options = copy.copy(dataset_options)

        return new_dataset_options

    def __handle_be(self, be):

        '''Create BE object, set mountpoint to that passed in

           to target_selection init.

        '''

        self.logger.debug("Processing BE '%s'" % (be.name))

        new_be = copy.copy(be)

        new_be.mountpoint = self.be_mountpoint

        return new_be

    def __handle_zpool(self, zpool, logical):

        '''Process all zpool children, handling each child object type

           and returning Zpool object

        '''

        self.logger.debug("Processing Zpool '%s', action='%s', is_root='%s',"

            " mountpoint='%s'" % \

            (zpool.name, zpool.action, zpool.is_root, zpool.mountpoint))

        this_be = None

        if zpool.name in self._zpool_map:

            raise SelectionError("Zpool '%s' specified twice" % (zpool.name))

        vdev_count = 0

        new_zpool = copy.copy(zpool)

        logical.insert_children(new_zpool)

        for child in zpool.children:

            if isinstance(child, Vdev):

                new_vdev = self.__handle_vdev(child)

                if new_vdev is not None:

                    vdev_key = new_zpool.name + ":" + new_vdev.name

                    if vdev_key not in self._vdev_map:

                        self._vdev_map[vdev_key] = new_vdev

                        self.logger.debug("Adding Vdev '%s' to zpool" %

                            (new_vdev.name))

                        new_zpool.insert_children(new_vdev)

                        vdev_count += 1

                    else:

                        raise SelectionError(

                            "Vdev '%s' specified twice in zpool '%s'" % \

                            (new_vdev.name, new_zpool.name))

                else:

                    raise SelectionError("Failed to copy Vdev.")

            elif isinstance(child, Filesystem):

                new_fs = self.__handle_filesystem(child)

                if new_fs is not None:

                    if new_fs.action == "preserve" and \

                        new_zpool.action not in self.PRESERVED:

                        raise SelectionError("Filesystem '%s' cannot be "

                            "preserved in non-preserved zpool '%s'." % \

                            (new_fs.name, new_zpool.name))

                    fs_key = new_zpool.name + ":" + new_fs.name

                    # Filesystem name must be unique within each pool

                    if fs_key not in self._fs_map and \

                        fs_key not in self._zvol_map:

                        self._fs_map[fs_key] = new_fs

                        self.logger.debug("Adding Filesystem '%s' to zpool" %

                            (new_fs.name))

                        new_zpool.insert_children(new_fs)

                    else:

                        raise SelectionError(

                            "Filesystem '%s' specified twice in zpool '%s'" % \

                            (new_fs.name, new_zpool.name))

                else:

                    raise SelectionError("Failed to copy Filesystem.")

            elif isinstance(child, Zvol):

                new_zvol = self.__handle_zvol(child)

                if new_zvol is not None:

                    if new_zvol.action in self.PRESERVED and \

                        new_zpool.action not in self.PRESERVED:

                        raise SelectionError("Zvol '%s' cannot be "

                            "preserved in non-preserved zpool '%s'." % \

                            (new_zvol.name, zpool.name))

                    zvol_key = new_zpool.name + ":" + new_zvol.name

                    # Zvol name must be unique within each pool

                    if zvol_key not in self._zvol_map and \

                        zvol_key not in self._fs_map:

                        if new_zvol.use == "swap":

                            # Cannot specify Swap Zvol and noswap == true

                            if self._noswap:

                                if zpool.action in self.PRESERVED:

                                    raise SelectionError(

                                        "Swap zvol already exists and "

                                        "noswap specified in manifest.")

                                else:

                                    raise SelectionError(

                                        "Both swap zvol and noswap specified "

                                        "in manifest.")

                            self._swap_zvol_map[zvol_key] = new_zvol

                        elif new_zvol.use == "dump":

                            # Can only specify one Dump Zvol

                            if self._dump_zvol is not None:

                                raise SelectionError(

                                    "Dump zvol specified twice.")

                            # Cannot specify Dump Zvol and nodump == true

                            if self._nodump:

                                if zpool.action in self.PRESERVED:

                                    raise SelectionError(

                                        "Dump zvol already exists and "

                                        "nodump specified in manifest.")

                                else:

                                    raise SelectionError(

                                        "Both dump zvol and nodump specified "

                                        "in manifest.")

                            # Cannot delete a dump zvol

                            if new_zvol.action == "delete":

                                self.__raise_dump_zvol_deletion_exception()

                            self._dump_zvol = new_zvol

                        self._zvol_map[zvol_key] = new_zvol

                        self.logger.debug("Adding Zvol '%s' to zpool" %

                            (new_zvol.name))

                        new_zpool.insert_children(new_zvol)

                    else:

                        raise SelectionError(

                            "Zvol '%s' specified twice in zpool '%s'" % \

                            (new_zvol.name, new_zpool.name))

                else:

                    raise SelectionError("Failed to copy Zvol.")

            elif isinstance(child, PoolOptions):

                new_pool_options = self.__handle_pool_options(child)

                if new_pool_options is not None:

                    # Can only specify one pool_options per zpool

                    if new_zpool.name not in self._pool_options:

                        self._pool_options[new_zpool.name] = new_pool_options

                        self.logger.debug("Adding Pool Options '%s' to zpool"

                            % (new_pool_options.options))

                        new_zpool.insert_children(new_pool_options)

                    else:

                        raise SelectionError(

                            "More than one pool_options specified "

                            "zpool '%s'" % (new_zpool.name))

                else:

                    raise SelectionError("Failed to copy PoolOptions.")

            elif isinstance(child, DatasetOptions):

                # Validate only one dataset options

                new_dataset_options = self.__handle_dataset_options(child)

                if new_dataset_options is not None:

                    # Can only specify one dataset_options per zpool

                    if new_zpool.name not in self._dataset_options:

                        self._dataset_options[new_zpool.name] = \

                            new_dataset_options

                        self.logger.debug("Adding Dataset Options '%s' to "

                            "zpool" % (new_dataset_options.options))

                        new_zpool.insert_children(new_dataset_options)

                    else:

                        raise SelectionError(

                            "More than one dataset_options specified "

                            "in zpool '%s'" % (new_zpool.name))

                else:

                    raise SelectionError("Failed to copy DatasetOptions.")

            elif isinstance(child, BE):

                if not zpool.is_root:

                    raise SelectionError("BE cannot be part of non root "

                        "pool '%s'" % (zpool.name))

                new_be = self.__handle_be(child)

                if new_be is not None:

                    # BE can only be specified once in entire manifest

                    if self._be is None:

                        self._be = new_be

                        this_be = new_be

                        self.logger.debug("Adding BE '%s' to zpool" %

                            (new_be.name))

                        new_zpool.insert_children(new_be)

                    else:

                        if this_be is not None:

                            raise SelectionError(

                                "More than one BE specified in zpool '%s'" % \

                                (new_zpool.name))

                        else:

                            raise SelectionError(

                                "Only one BE element allowed per logical.")

                else:

                    raise SelectionError("Failed to copy BE.")

            else:

                raise SelectionError("Invalid zpool sub element")

        if vdev_count == 0:

            # Zpool specified in manifest but no vdevs were specified

            # Add a default vdev of type mirror to add any disks to later

            self.logger.debug("No Vdevs found in zpool '%s', adding mirror."

                % (new_zpool.name))

            new_vdev = new_zpool.add_vdev(DEFAULT_VDEV_NAME, "mirror")

            vdev_key = new_zpool.name + ":" + new_vdev.name

            self._vdev_map[vdev_key] = new_vdev

            self._vdev_added_map[vdev_key] = new_vdev

        return new_zpool

    def __handle_preserved_zpool(self, discovered_zpool, zpool):

        '''

            Process all zpool children, handling each child object type

            and returning Zpool object.

            Preserving a Zpool effectively means maintaining the physical

            device structure of a zpool, so you cannot add new physical

            devices via AI, you can however change what's contained on the

            zpool, e.g. create/delete filesystems/Zvols.

            Filesystems:

                - Create, must not already exist

                - Delete, must exist already

                - Preserve, nothing to do, but must exist already.

            Zvols:

                - Create, must not already exist

                - Delete, must exist already

                - Preserve, nothing to do, but must exist already.

                - use_existing, must exist, and usage must be changing

            BE's:

                - Can only be one BE, BE's are not copied from discovered

                  as there could be laods.

                - Ensure this BE does not exist already, if not specified

                  Ensure default created BE does not already exist.

            Dataset Options:

                - Not allowed in AI, user can do this manually, requires

                  parsing of string options and zfs knowledge of what options

                  can be applied post pool creation.

            Pool Options:

                - Not allowed in AI, user can do this manually, requires

                  parsing of string options and zfs knowledge of what options

                  can be applied post pool creation.

        '''

        self.logger.debug("Processing %s Zpool '%s', action='%s',"

            " is_root='%s', mountpoint='%s'" % (zpool.action, zpool.name,

            zpool.action, zpool.is_root, zpool.mountpoint))

        discovered_bes = self.__get_discovered_be(zpool)

        this_be = None

        discovered_zpool.action = zpool.action

        for child in zpool.children:

            if isinstance(child, Vdev):