#!/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.

#

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

'''

from collections import Iterable

import copy

import os

import platform

import re

import traceback

from bootmgmt.bootinfo import SystemFirmware

from operator import attrgetter

import osol_install.errsvc as errsvc

import osol_install.liberrsvc as liberrsvc

from solaris_install import gpt_firmware_check

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, \

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

    Filesystem, DatasetOptions, PoolOptions

from solaris_install.target.physical import Disk, Iscsi, GPTPartition, \

    Partition, Slice, InsufficientSpaceError, NoPartitionSlotsFree, \

    NoGPTPartitionSlotsFree

from solaris_install.target.shadow.physical import ShadowPhysical

from solaris_install.target.size import Size

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

def is_iterable(obj):  # move to common?

    return isinstance(obj, Iterable)

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, dry_run=self.dry_run)

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

        self._discovered = None

        self._wipe_disk = False

        self._discovered_disks = list()

        self._discovered_zpools = list()

        self._discovered_zpool_map = dict()

        self._remaining_zpool_map = dict()

        self._cpu = platform.processor()

        self._gpt_capable = gpt_firmware_check()

        self._firmware = SystemFirmware.get().fw_name

        self._reset_maps()

    @property

    def cpu(self):

        return self._cpu

    @property

    def gpt_capable(self):

        return self._gpt_capable

    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 _pretty_print_disk(self, disk):

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

        if is_iterable(disk):

            ret_str = ""

            for _disk in disk:

                if len(ret_str) != 0:

                    ret_str += ", "

                ret_str += self._pretty_print_disk(_disk)

        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)

        # Handle options children

        for options in fs.children:

            new_options = self._handle_options(options)

            if new_options is not None:

                new_fs.insert_children(new_options)

        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)

        # Handle options children

        for options in zvol.children:

            new_options = self._handle_options(options)

            if new_options is not None:

                new_zvol.insert_children(new_options)

        return new_zvol

    def _handle_options(self, options):

        '''Create Zpool or Dataset Options object

        '''

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

            str(options))

        new_options = copy.copy(options)

        return new_options

    def _handle_pool_options(self, pool_options):

        '''Create PoolOptions object

        '''

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

            str(pool_options))

        new_pool_options = copy.copy(pool_options)

        # Handle options children

        for options in pool_options.children:

            new_options = self._handle_options(options)

            if new_options is not None:

                new_pool_options.insert_children(new_options)

        return new_pool_options

    def _handle_dataset_options(self, dataset_options):

        '''Create DatasetOption object

        '''

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

            str(dataset_options))

        new_dataset_options = copy.copy(dataset_options)

        # Handle options children

        for options in dataset_options.children:

            new_options = self._handle_options(options)

            if new_options is not None:

                new_dataset_options.insert_children(new_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

        # Handle options children

        for options in be.children:

            new_options = self._handle_options(options)

            if new_options is not None:

                new_be.insert_children(new_options)

        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 '%s'" % (new_pool_options, new_zpool.name))

                        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 to zpool")

                        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