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

#

""" boot.py -- Installs and configures boot loader and boot menu

    onto physical systems and installation images.

"""

import abc

import array

import fcntl

import linecache

import os

import platform

import stat

import struct

import tempfile

from grp import getgrnam

from pwd import getpwnam

from shutil import move, copyfile, rmtree

from bootmgmt import bootconfig, BootmgmtUnsupportedPropertyError

from bootmgmt.bootconfig import BootConfig, DiskBootConfig, ODDBootConfig, \

    SolarisDiskBootInstance, SolarisODDBootInstance, ChainDiskBootInstance

from bootmgmt.bootloader import BootLoader

from solaris_install.boot.boot_spec import BootMods, BootEntry

from solaris_install.data_object import ObjectNotFoundError

from solaris_install.data_object.data_dict import DataObjectDict

from solaris_install.engine import InstallEngine

from solaris_install.engine.checkpoint import AbstractCheckpoint as Checkpoint

from solaris_install.logger import INSTALL_LOGGER_NAME as ILN

from solaris_install.target import Target

from solaris_install.target.logical import be_list, BE, Zpool

from solaris_install.target.physical import Disk, Slice

from solaris_install.transfer.media_transfer import get_image_grub_title

BOOT_ENV = "boot-env"

# Character boot device paths eg. c0t0d0s0

DEVS = "devs"

class BootMenu(Checkpoint):

    """ Abstract class for BootMenu checkpoint

    """

    __metaclass__ = abc.ABCMeta

    DEFAULT_TIMEOUT = 30

    def __init__(self, name):

        """ Constructor for class

        """

        super(BootMenu, self).__init__(name)

        self.arch = platform.processor()

        self.boot_entry_list = list()

        self.boot_timeout = BootMenu.DEFAULT_TIMEOUT

        self.boot_mods = None

        self.boot_title = None

        # Used for string token substitution of pybootgmmt return data

        self.boot_tokens = dict()

        self.config = None

        self.doc = InstallEngine.get_instance().data_object_cache

        self.img_info_path = None

        self.rel_file_title = None

    def get_progress_estimate(self):

        """ Returns an estimate of the time this checkpoint will

            take to complete.

        """

        return 5

    @abc.abstractmethod

    def build_default_entries(self):

        """ This method is required to be implemented by all subclasses.

            Standard, pre-defined boot menu entries get created by

            subclass implementors of this method.

        """

        raise NotImplementedError

    @abc.abstractmethod

    def build_custom_entries(self):

        """ This method is required to be implemented by all subclasses.

            Custom entries specified in the boot_mods section of the

            XML manifest get created by subclass implementors of this method.

        """

        raise NotImplementedError

    @abc.abstractmethod

    def _get_rel_file_path(self):

        """ This method is required to be implemented by all subclasses.

            Returns file system path to the release file.

        """

        raise NotImplementedError

    def parse_doc(self, dry_run=False):

        """ Parse data object cache for values required by the checkpoint

            execution.

        """

        # Break doc parsing down into 2 specific parts as the target

        # configuration in the doc differs between DC (for ISO images)

        # and and live system installation.

        self._parse_doc_target(dry_run)

        self._parse_doc_boot_mods()

    def _parse_doc_boot_mods(self):

        """ Parses data object cache (DOC) BootMods tree for configuration of

            the checkpoint.

        """

        try:

            # Check and retrieve the optional manifest

            # specific boot configurations.

            boot_mods = self.doc.get_descendants(class_type=BootMods)

            if len(boot_mods) < 1:

                return

            self.boot_mods = boot_mods[0]

        except ObjectNotFoundError as err:

            raise RuntimeError("Error retrieving BootMods from the DOC: " + \

                str(err))

        if self.boot_mods.title and len(self.boot_mods.title) > 0:

            self.logger.info("Setting boot title prefix from manifest value: \

                             '%s'" % self.boot_mods.title)

            self.boot_title = self.boot_mods.title

        if self.boot_mods.timeout is not None:

            self.logger.info("Setting boot timeout from manifest value: %d" \

                             % self.boot_mods.timeout)

            self.boot_timeout = self.boot_mods.timeout

        try:

            self.boot_entry_list = self.boot_mods.get_children(

                class_type=BootEntry)

        except ObjectNotFoundError:

            # the manifest does not contain any custom boot entries

            self.logger.debug("No custom boot entries found in the DOC")

    @abc.abstractmethod

    def _parse_doc_target(self, dry_run=False):

        """ This method is required to be implemented by all subclasses.

            Additional class specific parsing to determine the boot

            configuration's target paths or devices get performed by

            subclass implementors this method.

            Input:

                None

            Output:

                None

        """

        raise NotImplementedError

    @abc.abstractmethod

    def init_boot_config(self, autogen=True):

        """ This method is required to be implemented by all subclasses.

            Input:

                None

            Output:

                None

        """

        raise NotImplementedError

    @abc.abstractmethod

    def install_boot_loader(self, dry_run=False):

        """ This method is required to be implemented by all subclasses.

            Input:

                dry_run

                - If True, the set of files that constitute the boot

                  configuration is written to a temporary directory (and not to

                  the official location(s)) When files are written to a

                  temporary directory, the list and format of the files written

                  is returned (see Output)

            Output:

                None

        """

        raise NotImplementedError

    def _handle_boot_config_list(self, boot_config_list, dry_run):

        """ Method that checks returned tuple list from commit_boot_config()

            and copies over content as appropriate to their targets.

        """

        for boot_config in boot_config_list:

            # boot-config elements can be either tuples or lists of tuples.

            # Cast tuples into a list for consistent iteration loop below.

            if not isinstance(boot_config, list):

                boot_config = [boot_config]

            for config_set in boot_config:

                ftype = config_set[0]

                if ftype == BootConfig.OUTPUT_TYPE_FILE:

                    self._handle_file_type(config_set, dry_run)

                elif ftype in [BootConfig.OUTPUT_TYPE_BIOS_ELTORITO]:

                # UEFI - add handlers for the following when supported:

                #              BootConfig.OUTPUT_TYPE_UEFI_ELTORITO

                #              BootConfig.OUTPUT_TYPE_HSFS_BOOTBLK

                    self._handle_iso_boot_image_type(config_set, dry_run)

                else:

                    raise RuntimeError("Unrecognized boot loader " \

                                       "file type: %s" % ftype)

    def _handle_file_type(self, config, dry_run):

        """ Method that copies generic file types to their appropriate targets.

        """

        ftype, src, objref, dest, uid, gid, mode = config

        # Copy from 'src' to 'dest' and set uid:gid + mode

        if src is None:

            raise RuntimeError("No source path defined for boot" \

                               "file")

        if dest is None:

            raise RuntimeError("No destination path defined for boot" \

                               "file")

        # XXX The 'dest' field, I believe, should be prepended with the

        # string token '%(systemroot)s' but it currently appears not to

        # be the case sometimes, and instead specifies an absolute path

        # such as '/boot/grub/menu.lst'

        # Check for a leading slash and prepend if necessary

        if os.path.isabs(dest):

            dest = '%(' + BootConfig.TOKEN_SYSTEMROOT + ')s' + dest

        real_dest = dest % (self.boot_tokens)

        par_dir = os.path.abspath(os.path.join(real_dest, os.path.pardir))

        if dry_run is True:

            os.unlink(src)

            return

        try:

            if not os.path.exists(par_dir):

                self.logger.debug("Creating boot configuration folder: %s" \

                                  % par_dir)

                os.makedirs(par_dir)

            self.logger.debug("Moving boot configuration file: \n" \

                              "%s -> %s" % (src, real_dest))

            move(src, real_dest)

            if uid is None:

                uid = -1

            if gid is None:

                gid = -1

            self.logger.debug("Setting ownership of %s to: %s:%s" \

                              % (real_dest, uid, gid))

            os.chown(real_dest,

                     getpwnam(uid).pw_uid,

                     getgrnam(gid).gr_gid)

            if mode:

                self.logger.debug("Setting permissions of %s to: %d" \

                                  % (real_dest, mode))

                os.chmod(real_dest, mode)

        except OSError as err:

            raise RuntimeError("Error copying boot configuration files to " \

                                 "target: %s" % str(err))

    def execute(self, dry_run=False):

        """ Primary execution method used by the Checkpoint parent class

        """

        self.parse_doc(dry_run)

        self.init_boot_config()

        self.build_default_entries()

        self.build_custom_entries()

        self.install_boot_loader(dry_run)

class SystemBootMenu(BootMenu):

    """ Class for SystemBootMenu checkpoint. Suitable for automatic boot loader

        and boot menu configuration for install applications that install onto

        a physical system device such as gui-install, text install and AI

    """

    def __init__(self, name):

        """ Constructor for class

        """

        super(SystemBootMenu, self).__init__(name)

        # Dictionary for quick lookup of paramaters needed to configure and

        # install the boot loader.

        self.boot_target = dict()

        self.boot_target[BOOT_ENV] = None

        self.boot_target[DEVS] = list()

        self.img_info_title = None

        # Filesystem name of the target boot environment eg.

        # rpool/ROOT/solaris-11-XYZ

        self.target_bootfs = None

        # Convenience reference to the SolarisDiskBootInstance for boot target

        self.target_boot_instance = None

        # Mountpoint of pool toplevel dataset

        self.pool_tld_mount = None

    def init_boot_config(self, autogen=True):

        """ Instantiates the appropriate bootmgmt.bootConfig subclass object

            for this class

        """

        bc_flags = [bootconfig.BootConfig.BCF_CREATE]

        if autogen:

            bc_flags.append(bootconfig.BootConfig.BCF_AUTOGEN)

        bc_flags = tuple(bc_flags)

        target_be = self.boot_target[BOOT_ENV]

        # If the BE is unmounted for some reason we need to go and mount it.

        if target_be.mountpoint == None:

            tmp_be_mp = tempfile.mkdtemp(dir="/system/volatile",

                                         prefix="be_mount_%s_" \

                                         % (target_be.name))

            self.logger.debug("Mounting BE %s at: %s" % \

                               (target_be.name, tmp_be_mp))

            target_be.mount(tmp_be_mp, dry_run=False)

        # Note that 'platform' tuple is not supplied here since we want to

        # go with the running system arch/firmware, which bootmgmt defaults to.

        self.config = DiskBootConfig(bc_flags,

                                     rpname=target_be.parent.name,

                                     tldpath=self.pool_tld_mount,

                                     zfspath=target_be.mountpoint)

        # Apply boot timeout property to boot loader.

        try:

            self.config.boot_loader.setprop('timeout',

                                            self.boot_timeout)

        except BootmgmtUnsupportedPropertyError:

            self.logger.warning("Boot loader type %s does not support the \

                                'timeout' property. Ignoring." \

                                % self.config.boot_loader.name)

    def execute(self, dry_run=False):

        """ Primary execution method used by the Checkpoint parent class

        """

        # UEFI The divergent code paths for sparc and X86 is a temporary

        # workaround for the lack of sparc support in the bootmgmt module.

        # When this is addressed, I expect to revert to just calling the

        # parent class method.

        if self.arch == 'sparc':

            # For sparc, generate a manual menu.lst and copy the bootlst

            # binary into the boot dataset.

            self.parse_doc(dry_run)

            # Check to make sure that a non-dry run attempt is not

            # executed on a live system

            if self.boot_target[BOOT_ENV].mountpoint == '/' and \

                not dry_run:

                raise RuntimeError("Boot checkpoint can not be executed on" \

                                     "live systems except with dry run mode")

            self._set_bootfs_pool_prop(dry_run)

            self._install_sparc_bootblk(dry_run)

            self._set_sparc_prom_boot_device(dry_run)

            self._create_sparc_boot_menu(dry_run)

            self._copy_sparc_bootlst(dry_run)

        else:

            super(SystemBootMenu, self).execute(dry_run)

    def _set_bootfs_pool_prop(self, dry_run):

        """ Set the bootfs property on the boot pool, activating the BE.

            XXX: This should really be ultimately handled by pybootmgmt

        """

        pool = self.boot_target[BOOT_ENV].parent

        self.logger.debug("Setting bootfs zpool property on %s to %s" \

                          % (pool.name, self.target_bootfs))

        pool.set("bootfs", self.target_bootfs, dry_run)

    def _get_x86_console(self):

        """

            Determine X86 console device. Adapted from libict_pymod

            Returns console device found in bootenv.rc, from devprop command,

            or default 'text'.

        """

        osconsole = None

        bootvars = self.target_boot_instance.boot_vars

        osconsole = bootvars.getprop('output-device')

        if osconsole is not None:

            return osconsole

        # get console setting from devprop via. 'console'

        osconsole = self._get_dev_property(propname='console')

        if osconsole is None:

            # get console setting from devprop via. 'output-device'

            osconsole = self._get_dev_property(

                propname='output-device')

            if osconsole == 'screen':

                osconsole = 'text'

        # Set default console value to text

        if osconsole is None or osconsole == '':

            osconsole = 'text'

        return osconsole

    def _get_dev_property(self, propname):

        """

            Internal helper method.

            Retrieves the value of propname reported by devprop(1M)

            Returns: A string value associated with propname or None

        """

        propname_val = None

        cmd = ["/usr/sbin/devprop", "-s", propname]

        p = Popen.check_call(cmd,

            stdout=Popen.STORE,

            stderr=Popen.STORE,

            logger=ILN)

        if p.returncode != 0:

            raise RuntimeError('Error getting device property: %s' \

                               'Exit status=%s' % (cmd, p.stderr))

        result = p.stdout.strip()

        if len(result) > 0:

            propname_val = result

            self.logger.debug("Found device property value for " \

                              "%s: '%s'" % (propname, propname_val))

        else:

            self.logger.debug("No device property value found for %s" \

                             % propname)

        return propname_val

    def _create_sparc_boot_menu(self, dry_run):

        """ Create a boot menu.lst file on a SPARC system.

        """

        # Attempt to create the path to where the menu.lst file will reside

        boot_menu_path = os.path.join(self.pool_tld_mount, 'boot')

        if dry_run:

            # Override boot_menu_path to temporary storage

            temp_dir = tempfile.mkdtemp(dir="/tmp", prefix="sparc_boot_menu_")

            boot_menu_path = os.path.join(temp_dir,

                boot_menu_path.strip(os.path.sep))

        boot_menu = os.path.join(boot_menu_path, 'menu.lst')

        sparc_title_line = 'title %s\n' % self.boot_title

        bootfs_line = 'bootfs ' + self.target_bootfs + '\n'

        self.logger.debug("Creating SPARC boot menu file: %s" \

                          % boot_menu)

        if not os.path.isdir(boot_menu_path):

            os.makedirs(boot_menu_path, 0755)

        try:

            with open(boot_menu, 'w') as menu_lst:

                menu_lst.write(sparc_title_line)

                menu_lst.write(bootfs_line)

            os.chmod(boot_menu,

                     stat.S_IREAD | stat.S_IWRITE | \

                     stat.S_IRGRP | stat.S_IROTH)

            # Requires root privilige so bypass on dry_run

            if not dry_run:

                os.chown(boot_menu, 0, 3)  # chown root:sys

        except IOError, msg:

            raise RuntimeError(msg)

        if dry_run:

            rmtree(temp_dir)

    def _copy_sparc_bootlst(self, dry_run):

        """ Copy the bootlst file on a SPARC system.

            On SPARC systems a bootlst file is maintained at:

            /platform/`uname -m`/bootlst

            It needs to be copied to:

            <rootpool>/platform/`uname -m`/bootlst

        """

        bootlst_src = os.path.join(self.boot_target[BOOT_ENV].mountpoint,

            'platform', platform.machine(),

            'bootlst')

        # Copy file bootlst from basedir to the rootpool

        bootlst_dir = os.path.join(self.pool_tld_mount,

                                   'platform', platform.machine())

        if dry_run:

            # Override bootlst_dir to temporary storage

            temp_dir = tempfile.mkdtemp(dir="/tmp", prefix="sparc_bootlst_")

            bootlst_dir = os.path.join(temp_dir,

                                       bootlst_dir.strip(os.path.sep))

        bootlst_dst = os.path.join(bootlst_dir, 'bootlst')

        self.logger.debug("Copying SPARC bootlst file: %s" \

                          % bootlst_src)

        # Create the destination directory if it does not already exist.

        if not os.path.isdir(bootlst_dir):

            os.makedirs(bootlst_dir, 0755)

        # Copy the bootlst

        copyfile(bootlst_src, bootlst_dst)

        os.chmod(bootlst_dst,

                 stat.S_IREAD | stat.S_IWRITE | \

                 stat.S_IRGRP | stat.S_IROTH)

        # Requires root privilige so bypass on dry_run

        if dry_run:

            rmtree(bootlst_dir)

        else:

            os.chown(bootlst_dst, 0, 3)  # chown root:sys

    def _install_sparc_bootblk(self, dry_run):

        """ Runs installboot(1M) command on SPARC architectures to

            install the zfs bootblock program.

        """

        # This method is only supported on SPARC platforms.

        if self.arch != 'sparc':

            raise RuntimeError("Can not install SPARC bootblk on a non-" \

                                 "SPARC architecture system")

        boot_devs = list()

        boot_devs = [os.path.join('/dev/rdsk', dev) \

            for dev in self.boot_target[DEVS]]

        if len(boot_devs) < 1:

            raise RuntimeError("No devices to install SPARC bootblk onto!")

        self.logger.info("Installing SPARC bootblk to root pool devices: %s" \

                          % str(boot_devs))

        bootblk_src = os.path.join(self.boot_target[BOOT_ENV].mountpoint,

                                   'platform', platform.machine(),

                                   'lib', 'fs', 'zfs', 'bootblk')

        sub_cmd = ["/usr/sbin/installboot", "-F", "zfs", bootblk_src]