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

#

""" controller.py, TargetController and related classes.

"""

import logging

import os

import platform

from copy import copy, deepcopy

from solaris_install import Popen

from solaris_install.data_object.simple import SimpleXmlHandlerBase

from solaris_install.logger import INSTALL_LOGGER_NAME

from solaris_install.target import Target

from solaris_install.target.libadm.const import V_ROOT

from solaris_install.target.logical import Logical, BE

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

from solaris_install.target.size import Size

LOGGER = None

# If install image size not available, use 4GB

FALLBACK_IMAGE_SIZE = Size("4" + Size.gb_units)

# Values for Swap and Dump calculations.  All values are in MB

MIN_SWAP_SIZE = 1024

MAX_SWAP_SIZE = (Size("4gb")).get(Size.mb_units)

MIN_DUMP_SIZE = 256

MAX_DUMP_SIZE = (Size("64gb")).get(Size.mb_units)

OVERHEAD = 1024

FUTURE_UPGRADE_SPACE = (Size("2gb")).get(Size.mb_units)

# Swap ZVOL is required if memory is below this

ZVOL_REQ_MEM = 900

VFSTAB_FILE = "etc/vfstab"

# "TargetController data" is an area in the DataObjectCache

# intended for the TargetController class's private use.  It

# is identified by a top-level <target> element, with the name

# "TargetController data", under the DOC's persistent tree.

# See TargetControllerBackupEntry class for more details.

DATA_AREA_NAME = "TargetController data"

DEFAULT_LOGICAL_NAME = "logical"

DEFAULT_ZPOOL_NAME = "rpool"

DEFAULT_VDEV_NAME = "vdev"

VDEV_REDUNDANCY_NONE = "none"

VDEV_REDUNDANCY_MIRROR = "mirror"

class BadDiskError(Exception):

    ''' General purpose error class for when TargetController is unable

        to access a disk.

    '''

    pass

class SubSizeDiskError(BadDiskError):

    ''' Specific exception sub-class for when a disk is below the

        minimum required size for installation.

    '''

    pass

class SwapDumpGeneralError(Exception):

    ''' General exception for errors computing swap and dump values.

    '''

    pass

class SwapDumpSpaceError(Exception):

    ''' Not enough space in the target disk for successful installation.

    '''

    pass

class TargetController(object):

    ''' The TargetController (TC) class is intended to be used by all the

        Install client apps for the purpose of selecting the disk

        or disks for the install.  It creates and sets up the

        "desired targets" area in the DataObjectCache (DOC) in the manner

        expected by the TargetInstantiation (TI) checkpoint, which

        will typically be run later.

        TC also calculates minimum and recommended sizes for the installation

        target, based on the passed-in image size and calculates sizes

        for swap and dump devices, if required.

        NB:

        Where TC methods accept Disk objects as parameters, these can

        be the actual Disk objects discovered by TargetDiscovery

        (TD), which the calling application will have retrieved from the

        "discovered targets" area of the DOC.  Or, they can be other

        Disk objects which represent the same disks as the "discovered

        targets".  In this case, TargetController will locate the

        corresponding Disks from "discovered targets" before processing

        them.

        Where TC methods return Disk objects, these will always be

        (possibly modified) copies of those discovered disks: TC takes

        in references to the "discovered targets", makes copies of those

        objects, places the copies in "desired targets" and returns the

        copies to the calling code.

        TC does not itself control changes to the partitioning layout

        of the selected disk(s) - this is done directly by the

        application by operating on the Disk objects returned from

        TC's methods.

        TC also maintains a backup of the previously selected disk(s),

        so that if the user makes changes to the partitioning layout

        of the selected disk(s); then changes the selected disk(s);

        and then changes back to the original disk(s), the previous

        partitioning layout that they configured will not be lost.

        APIs:

        from solaris_install.target.controller import TargetController, \

            BadDiskError, SwapDumpGeneralError, SwapDumpSpaceError

        target_controller = TargetController(doc, debug=False)

        disks = target_controller.initialize(

            image_size=FALLBACK_IMAGE_SIZE,

            no_initial_disk=False,

            no_initial_logical=False,

            install_mountpoint="/a",

            unique_zpool_name=False)

        logical = target_controller.apply_default_logical(

            logical=None,

            mountpoint="/a",

            redundancy="none",

            unique_zpool_name=True)

        disk = target_controller.select_initial_disk()

        disks = target_controller.select_disk(

            disks,

            use_whole_disk=False)

        disks = target_controller.add_disk(

            disks,

            use_whole_disk=False)

        disks = target_controller.reset_layout(

            disk=None,

            use_whole_disk=False)

        target_controller.apply_default_layout(

            disk,

            use_whole_disk,

            wipe_disk=False,

            in_zpool=DEFAULT_ZPOOL_NAME,

            in_vdev=DEFAULT_VDEV_NAME)

        swap_type, swap_size, dump_type, dump_size = \

            target_controller.calc_swap_dump_size(

                installation_size,

                available_size,

                swap_included=False)

        target_controller.setup_vfstab_for_swap(

            pool_name,

            basedir)

        min_size = target_controller.minimum_target_size

        rec_size = target_controller.recommended_target_size

        type = TargetController.SWAP_DUMP_ZVOL

        type = TargetController.SWAP_DUMP_NONE

    '''

    SWAP_DUMP_ZVOL = "ZVOL"

    SWAP_DUMP_NONE = "None"

    #--------------------------------------------------------------------------

    # Public methods

    def __init__(self, doc, debug=False, dry_run=False):

        ''' Initializer method.  Called by the constructor.

            Parameters:

            doc.  A reference to a DataObjectCache instance where

                TD places details of the "discovered targets" and

                where TC will create the "desired targets" area.

            debug=False.  If True, XML is generated for the backup

                area and will get written to logs.

            dry_run=False.  If True, certain actions will be prevented

                from running so the disks are not modified

            Returns: Nothing

            Raises: Nothing

        '''

        global LOGGER

        LOGGER = logging.getLogger(INSTALL_LOGGER_NAME)

        self._doc = doc

        self._debug = debug

        self._dry_run = dry_run

        self._discovered_root = None

        self._discovered_disks = None

        self._desired_root = None

        self._backup_area = None

        self._need_backup = False

        self._logical = None

        self._zpool = None

        self._vdev = None

        self._be = None

        self._image_size = None

        self._mem_size = None

        self._minimum_target_size = None

        self._recommended_target_size = None

        self._swap_dump_computed = False

        self._swap_type = TargetController.SWAP_DUMP_NONE

        self._swap_size = None

        self._dump_type = TargetController.SWAP_DUMP_NONE

        self._dump_size = None

        self._this_processor = platform.processor()

        super(TargetController, self).__init__()

    def initialize(self, image_size=FALLBACK_IMAGE_SIZE,

        no_initial_logical=False, no_initial_disk=False,

        install_mountpoint="/a", unique_zpool_name=False):

        ''' Creates the top-level structure for the "desired targets" area

            in the DOC and, optionally, selects an initial disk to be the

            target for this install.

            The TargetDiscovery checkpoint must have run successfully,

            saving details of the system's storage devices in the

            "discovered targets" area of the DOC, before initialize()

            is called, or an error is raised.

            Parameters:

            image_size=FALLBACK_IMAGE_SIZE.  If specified, must be a Size

                object.  TC will use this value to compute the minimum

                disk size that can be selected.

            no_initial_logical=False. If set to True, then initialize will

                not set up a default rpool structure. Will also ensure

                no default disk is selected.

            no_initial_disk=False.  If set to True, then initialize will

                not select an initial disk.  This may be useful for non-

                interactive installers, where they know before calling TC

                which disk(s) they will be installing on.

            install_mountpoint="/a". The mountpoint attribute of the

                created BE will be set to this value.

            unique_zpool_name=False If set to True, will ensure that the name

                of the pool will not match any existing zpools on the system.

            Returns: A list of the initially selected Disks.

            Raises: BadDiskError

        '''

        # Ensure that TD has already been successfully run by searching

        # for a <target name="discovered"> root node in the DOC. Save a

        # reference to this node for future use.

        self._discovered_root = self._doc.persistent.get_first_child(

            name=Target.DISCOVERED)

        if self._discovered_root is None:

            raise BadDiskError("No discovered targets available")

        self._image_size = image_size

        self._mem_size = _get_system_memory()

        # Reset these values to None so they get correctly recomputed

        self._minimum_target_size = None

        self._recommended_target_size = None

        # Clear out any previous "desired targets" from the DOC

        self._doc.persistent.delete_children(name=Target.DESIRED,

            class_type=Target)

        # Create a tree of DataObjects representing the initial

        # top-level nodes of the "desired targets" tree to be created

        # in the DOC.  The created tree will be similar to:

        #   <target name="desired">

        #       <!-- selected disks will be inserted here -->

        #       <logical>

        #           <zpool name="rpool" is_root="true">

        #               <vdev name="vdev"/>

        #               <be name="solaris" mountpoint="/a"/>

        #           </zpool>

        #       </logical>

        #   </target>

        self._desired_root = Target(Target.DESIRED)

        self._doc.persistent.insert_children(self._desired_root)

        # Return after creating Desired root node

        if no_initial_logical:

            return list()

        self._logical = self.apply_default_logical(

            mountpoint=install_mountpoint,

            unique_zpool_name=unique_zpool_name)

        self._desired_root.insert_children(self._logical)

        if no_initial_disk:

            return list()

        # select an initial disk and return it

        initial_disk = self.select_initial_disk()

        return_disks = self._add_disks([initial_disk], False)

        self._need_backup = True

        return return_disks

    def apply_default_logical(self, logical=None, mountpoint="/a",

        redundancy="none", unique_zpool_name=True):

        ''' Create a default logical layout for root pool.

            Only create logical element if not already done so, if not

            none it is assumed this logical contains no children.

            Optionally, ensure root pool name is unique and does not

            exist already.

        '''

        if logical is None:

            logical = Logical(DEFAULT_LOGICAL_NAME)

        self._zpool = logical.add_zpool(

            DEFAULT_ZPOOL_NAME, is_root=True)

        if unique_zpool_name:

            # Ensure this root pool name is unique

            if self._zpool.exists:

                self._zpool._name = self._get_unique_pool_name(self._zpool)

                LOGGER.warning("Default root zpool '%s' exists, Using '%s' " \

                    "instead." % (DEFAULT_ZPOOL_NAME, self._zpool._name))

        self._vdev = self._zpool.add_vdev(DEFAULT_VDEV_NAME, redundancy)

        self._be = BE()

        self._be.mountpoint = mountpoint

        self._zpool.insert_children(self._be)

        return logical

    def select_disk(self, disks, use_whole_disk=False):

        ''' Select one or more disks to be used for the install.

            If any disk(s) were previously selected, they will be

            replaced with the newly selected disks.

            Parameters:

            disks, either a single Disk object or a list of Disks

            use_whole_disk=False, specifies whether the selected

                disk(s) are to be used as entire disks or whether

                they will be divided into partitions

            Returns:

            A list containing the selected disk(s).

            Raises: BadDiskError

        '''

        # If initialize() has not already been called, call it.

        # In this situation we do not select an initial disk.

        if self._desired_root is None:

            self.initialize(no_initial_disk=True)

        # param disks can either be a singleton Disk object

        # or a tuple of Disk objects

        if isinstance(disks, Disk):

            disks = [disks]

        disks = self._get_corresponding_discovered_disks(disks)

        self._check_disks_are_suitable(disks)

        previous_disks = self._get_desired_disks()

        # Clear the previously selected disks (if any) from "desired targets"

        self._desired_root.delete_children(class_type=Disk,

            not_found_is_err=False)

        if self._need_backup:

            # Backup the previously selected disks

            self._backup_disks(previous_disks)

        return_disks = self._add_disks(disks, use_whole_disk)

        # If use_whole_disk=False on this call to select_disk(),

        # then we will need to back up the disk layout on the

        # next call to select_disk().  (If use_whole_disk=True, there

        # is no user-defined layout to back up.)

        if use_whole_disk == False:

            self._need_backup = True

        else:

            self._need_backup = False

        return return_disks

    def add_disk(self, disks, use_whole_disk=False):

        ''' Add one or more disks to the currently selected disks

            for this install.

            Parameters:

            disks, either a single Disk object or a list of Disks.

            use_whole_disk=False, specifies whether the selected

                disk(s) are to be used as entire disks or whether

                they will be divided into partitions

            Returns: A list containing the added disk(s).

            Raises: BadDiskError

        '''

        # If initialize() has not already been called, call it.

        # In this situation we do not select an initial disk.

        if self._desired_root is None:

            self.initialize(no_initial_disk=True)

        # param disks can either be a singleton Disk object

        # or a list of Disk objects

        if isinstance(disks, Disk):

            disks = [disks]

        disks = self._get_corresponding_discovered_disks(disks)

        self._check_disks_are_suitable(disks)

        # Check that disk(s) being added are not already in "desired targets"

        current_disks = self._get_desired_disks()

        if current_disks is not None:

            for current_disk in current_disks:

                for new_disk in disks:

                    if current_disk.name_matches(new_disk):

                        raise BadDiskError("Attempt to add same disk twice!")

        return_disks = self._add_disks(disks, use_whole_disk)

        return return_disks

    def reset_layout(self, disk=None, use_whole_disk=False):

        ''' Resets the partitioning layout of either all currently

            selected disks, or a specific disk, back to their

            original layout from "discovered targets". However

            for disks that have no usable partitions and/or slices

            the call to apply_default_layout will also reset the

            suggested layout before returning.

            Parameters:

            disk=None.  If not given, or None, then all the currently

                selected disks are reset.  Otherwise disk must be a

                single Disk object.

            use_whole_disk=False, specifies whether the selected

                disk(s) are to be used as entire disks or whether

                they will be divided into partitions

            Returns:

            A list containing the reset Disks.

            Raises:

            BadDiskError

        '''

        # Ensure initialize() has already been called.

        if self._desired_root is None:

            raise BadDiskError("No selected disks to reset!")

        current_disks = self._get_desired_disks()

        disks = list()

        if disk is None:

            # The user didn't say which disk(s) to reset.  So get from

            # the "discovered targets", the disks corresponding to

            # all the currently selected disks

            for current_disk in current_disks:

                for discovered_disk in self.discovered_disks:

                    if current_disk.name_matches(discovered_disk):

                        disks.append(discovered_disk)

        else:

            disks.append(disk)

        return_disks = list()

        for disk in disks:

            if disk.ctd not in \

                [disc_disk.ctd for disc_disk in self.discovered_disks]:

                raise BadDiskError(

                    "Trying to reset a disk not in discovered targets!")

            # find the disk in the descovered disks

            for disc_disk in self.discovered_disks:

                if disk.ctd == disc_disk.ctd:

                    break

            # remove equivalent disk from "desired targets"

            found = False

            for current_disk in current_disks:

                if disk.name_matches(current_disk):

                    self._desired_root.delete_children(children=current_disk,

                        not_found_is_err=True)

                    found = True

            if not found:

                raise BadDiskError("Trying to reset an unselected disk!")

            # re-insert a fresh copy of the disk, with the original

            # layout discovered by TD, into "desired targets". However

            # for disks that have no usable partitions and/or slices

            # the call to apply_default_layout will also reset the

            # suggested layout before returning.

            if disc_disk is not None:

                copy_disk = deepcopy(disc_disk)

                self.apply_default_layout(copy_disk, use_whole_disk, False)

                if self._fixup_disk(copy_disk, use_whole_disk):

                    self._desired_root.insert_children(copy_disk,

                        before=self._logical)

                return_disks.append(copy_disk)

        return return_disks