#

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

#

'''

Installation engine for Text Installer

'''

import os

import logging

import commands

import datetime

import platform

import shutil

import subprocess as sp

import osol_install.tgt as tgt

from osol_install.libzoneinfo import tz_isvalid

from libbe_py import beUnmount

from osol_install.transfer_mod import tm_perform_transfer, tm_abort_transfer

from osol_install.transfer_defs import TM_ATTR_MECHANISM, \

    TM_PERFORM_CPIO, TM_CPIO_ACTION, TM_CPIO_ENTIRE, TM_CPIO_SRC_MNTPT, \

    TM_CPIO_DST_MNTPT, TM_UNPACK_ARCHIVE, TM_SUCCESS

from osol_install.install_utils import exec_cmd_outputs_to_log

from osol_install.profile.disk_info import PartitionInfo

from osol_install.profile.network_info import NetworkInfo

from osol_install.text_install import RELEASE

import osol_install.text_install.ti_install_utils as ti_utils 

#

# RTC command to run

#

RTC_CMD = "/usr/sbin/rtc"

#

# Program used for calling the C ICT functions.

# When all the C-based ICT functions are converted to Python (bug 6256),

# this can be removed.

#

ICT_PROG = "/opt/install-test/bin/ict_test"

# The following is defined for using the ICT program.  It can be removed

# once the ict_test program is not used.

CPIO_TRANSFER = "0"

# The following 2 values, ICT_USER_UID and ICT_USER_GID are defined

# in the ICT C APIs.  When those are ported to Python, these will

# probably be defined there.

ICT_USER_UID = "101"

ICT_USER_GID = "10"

INSTALL_FINISH_PROG = "/sbin/install-finish"

# Initial BE name

# definitions for ZFS pool

INSTALL_SNAPSHOT = "install"

INSTALLED_ROOT_DIR = "/a"

X86_BOOT_ARCHIVE_PATH = "/.cdrom/platform/i86pc/%s/boot_archive"

# these directories must be defined in this order, otherwise,

# "zfs unmount" fails

ZFS_SHARED_FS = ["/export/home", "/export"]

#

# Handle for accessing the InstallStatus class

#

INSTALL_STATUS = None

class InstallStatus(object):

    '''Stores information on the installation progress, and provides a

    hook for updating the screen.

    '''

    TI = "ti"

    TM = "tm"

    ICT = "ict"

    def __init__(self, screen, update_status_func, quit_event):

        '''screen and update_status_func are values passed in from

        the main app

        '''

        # Relative ratio used for computing the overall progress of the

        # installation.  All numbers must add up to 100%

        self.ratio = {InstallStatus.TI:0.05,

                      InstallStatus.TM:0.93,

                      InstallStatus.ICT:0.02}

        self.screen = screen

        self.update_status_func = update_status_func

        self.quit_event = quit_event

        self.previous_step_name = None

        self.step_percent_completed = 0

        self.previous_overall_progress = 0

    def update(self, step_name, percent_completed, message):

        '''Update the install status. Also checks the quit_event to see

        if the installation should be aborted.

        '''

        if self.quit_event.is_set():

            logging.debug("User selected to quit")

            raise ti_utils.InstallationError

        if (self.previous_step_name is None):

            self.previous_step_name = step_name

        elif (self.previous_step_name != step_name):

            self.previous_step_name = step_name

            self.step_percent_completed = self.previous_overall_progress

        overall_progress = (percent_completed * (self.ratio[step_name])) \

                           + self.step_percent_completed

        self.update_status_func(self.screen, overall_progress, message)

        self.previous_overall_progress = overall_progress

SYSID_FILE = "/etc/.sysIDtool.state"

SYSID_FILE_UMASK = 022

SYSID_FILE_CONTENT = [["1", "# System previously configured?"],

              ["1", "# Bootparams succeeded?"],

              ["1", "# System is on a network?"],

              ["1", "# Extended network information gathered?"],

              ["1", "# Autobinder succeeded?"],

              ["1", "# Network has subnets?"],

              ["1", "# root password prompted for?"],

              ["1", "# locale and term prompted for?"],

              ["1", "# security policy in place"],

              ["1", "# NFSv4 domain configured"],

              # term type must be the last entry

              ["sun", ""]]

def create_sysid_file():

    '''Create the /etc/.sysIDtool.state file'''

    try:

        with open(SYSID_FILE, "w") as sysid_file:

            for entry in SYSID_FILE_CONTENT:

                sysid_file.write(entry[0] + "\t" + entry[1] + "\n")

        # set the umask on the file

        os.chmod(SYSID_FILE, SYSID_FILE_UMASK)

    except IOError, ioe:

        logging.error("Unable to write to %s", SYSID_FILE)

        logging.exception(ioe)

        raise ti_utils.InstallationError

    except OSError, ose:

        logging.error("Unable to create %s", SYSID_FILE)

        logging.exception(ose)

        raise ti_utils.InstallationError

def transfer_mod_callback(percent, message):

    '''Callback for transfer module to indicate percentage complete.'''

    logging.debug("tm callback: %s: %s", percent, message)

    try:

        INSTALL_STATUS.update(InstallStatus.TM, percent, message)

    except ti_utils.InstallationError:

        # User selected to quit the transfer

        tm_abort_transfer()

def exec_cmd(cmd, description):

    ''' Execute the given command.

        Args:

            cmd: Command to execute.  The command and it's arguments

		 should be provided as a list, suitable for used

		 with subprocess.Popen(shell=False)

            description: Description to use for printing errors.

        Raises:

            InstallationError

    '''

    logging.debug("Executing: %s", " ".join(cmd))

    if exec_cmd_outputs_to_log(cmd, logging) != 0:

        logging.error("Failed to %s", description)

        raise ti_utils.InstallationError

def cleanup_existing_install_target(install_profile, inst_device):

    ''' If installer was restarted after the failure, it is necessary

        to destroy the pool previously created by the installer.

        If there is a root pool manually imported by the user with

        the same name which will be used by the installer

        for target root pool, we don't want to destroy user's data.

        So, we will log warning message and abort the installation.

    '''

    # Umount /var/run/boot_archive, which might be mounted by

    # previous x86 installations.

    # Error from this command is intentionally ignored, because the

    # previous invocation of the transfer module might or might not have

    # mounted on the mount point.

    if platform.processor() == "i386":

        with open("/dev/null", "w") as null_handle:

            sp.Popen(["/usr/sbin/umount", "-f", "/var/run/boot_archive"],

                     stdout=null_handle, stderr=null_handle)

    rootpool_name = install_profile.disk.get_install_root_pool()

    cmd = "/usr/sbin/zpool list " + rootpool_name

    logging.debug("Executing: %s", cmd)

    status = commands.getstatusoutput(cmd)[0]

    if status != 0:

        logging.debug("Root pool %s does not exist", rootpool_name)

        return   # rpool doesn't exist, no need to clean up

    # Check value of rpool's org.openindiana.caiman:install property

    # If it is busy, that means the pool is left over from an aborted install.

    # If the property doesn't exist or has another value, we assume

    # that the root pool contains valid Solaris instance.

    cmd = "/usr/sbin/zfs get -H -o value org.openindiana.caiman:install " + \

          rootpool_name

    logging.debug("Executing: %s", cmd)

    (status, pool_status) = commands.getstatusoutput(cmd)

    logging.debug("Return code: %s", status)

    logging.debug("Pool status: %s", pool_status)

    if (status != 0) or (pool_status != "busy"):

        logging.error("Root pool %s exists.", rootpool_name)

        logging.error("Installation can not proceed")

        raise ti_utils.InstallationError

    try:

        rpool = tgt.Zpool(rootpool_name, inst_device)

        tgt.release_zfs_root_pool(rpool)

        logging.debug("Completed release_zfs_root_pool")

    except TypeError, te:

        logging.error("Failed to release existing rpool.")

        logging.exception(te)

        raise ti_utils.InstallationError

    # clean up the target mount point

    exec_cmd(["/usr/bin/rm", "-rf", INSTALLED_ROOT_DIR + "/*"],

             "clean up existing mount point")

def do_ti(install_profile, swap_dump):

    '''Call the ti module to create the disk layout, create a zfs root

    pool, create zfs volumes for swap and dump, and to create a be.

    '''

    diskname = install_profile.disk.name

    logging.debug("Diskname: %s", diskname)

    mesg = "Preparing disk for %(release)s installation" % RELEASE

    try:

        (inst_device, inst_device_size) = \

             install_profile.disk.get_install_dev_name_and_size()

        # The installation size we provide already included the required

        # swap size

        (swap_type, swap_size, dump_type, dump_size) = \

            swap_dump.calc_swap_dump_size(ti_utils.get_minimum_size(swap_dump),

                                          inst_device_size, swap_included=True)

        tgt_disk = install_profile.disk.to_tgt()

        tgt.create_disk_target(tgt_disk, False)

        logging.debug("Completed create_disk_target")

        INSTALL_STATUS.update(InstallStatus.TI, 20, mesg)

        rootpool_name = install_profile.disk.get_install_root_pool()

        rpool = tgt.Zpool(rootpool_name, inst_device)

        tgt.create_zfs_root_pool(rpool)

        logging.debug("Completed create_zfs_root_pool")

        INSTALL_STATUS.update(InstallStatus.TI, 40, mesg)

        create_swap = False

        if (swap_type == ti_utils.SwapDump.ZVOL):

            create_swap = True

        create_dump = False

        if (dump_type == ti_utils.SwapDump.ZVOL):

            create_dump = True

        logging.debug("Create swap %s Swap size: %s", create_swap, swap_size)

        logging.debug("Create dump %s Dump size: %s", create_dump, dump_size)

        tgt.create_zfs_volume(rootpool_name, create_swap, swap_size,

                              create_dump, dump_size)

        logging.debug("Completed create swap and dump")

        INSTALL_STATUS.update(InstallStatus.TI, 70, mesg)

        zfs_datasets = ()

        for ds in reversed(ZFS_SHARED_FS): # must traverse it in reversed order

            zd = tgt.ZFSDataset(mountpoint=ds)

            zfs_datasets += (zd,)

        tgt.create_be_target(rootpool_name, INIT_BE_NAME, INSTALLED_ROOT_DIR,

                             zfs_datasets)

        logging.debug("Completed create_be_target")

        INSTALL_STATUS.update(InstallStatus.TI, 100, mesg)

    except TypeError, te:

        logging.error("Failed to initialize disk")

        logging.exception(te)

        raise ti_utils.InstallationError

def do_transfer():

    '''Call libtransfer to transfer the bits to the system via cpio.'''

    # transfer the bits

    tm_argslist = [(TM_ATTR_MECHANISM, TM_PERFORM_CPIO),

                   (TM_CPIO_ACTION, TM_CPIO_ENTIRE),

                   (TM_CPIO_SRC_MNTPT, "/"),

                   (TM_CPIO_DST_MNTPT, INSTALLED_ROOT_DIR)]

    # if it is running on x86, need to unpack the root archive from

    # the architecture that's not booted from.

    if platform.processor() == "i386":

        (status, inst_set) = commands.getstatusoutput("/bin/isainfo -k")

        if (status != 0):

            logging.error("Unable to determine instruction set.")

            raise ti_utils.InstallationError

        if (inst_set == "amd64"):

            # Running 64 bit kernel, need to unpack 32 bit archive

            tm_argslist.extend([(TM_UNPACK_ARCHIVE,

                               X86_BOOT_ARCHIVE_PATH % "")])

        else:

            # Running 32 bit kernel, need to unpack 64 bit archive

            tm_argslist.extend([(TM_UNPACK_ARCHIVE,

                               X86_BOOT_ARCHIVE_PATH % "amd64")])

    logging.debug("Going to call TM with this list: %s", tm_argslist)

    try:

        status = tm_perform_transfer(tm_argslist,

                                     callback=transfer_mod_callback)

    except Exception, ex:

        logging.exception(ex)

        status = 1

    if status != TM_SUCCESS:

        logging.error("Failed to transfer bits to the target")

        raise ti_utils.InstallationError

def do_ti_install(install_profile, screen, update_status_func, quit_event,

                       time_change_event):

    '''Installation engine for text installer.

       Raises InstallationError for any error occurred during install.

    '''

    #

    # The following information is needed for installation.

    # Make sure they are provided before even starting

    #

    # locale

    locale = install_profile.system.locale

    logging.debug("default locale: %s", locale)

    # timezone

    timezone = install_profile.system.tz_timezone

    logging.debug("time zone: %s", timezone)

    # hostname

    hostname = install_profile.system.hostname

    logging.debug("hostname: %s", hostname)

    ulogin = None 

    user_home_dir = ""

    root_user = install_profile.users[0]

    root_pass = root_user.password

    reg_user = install_profile.users[1]

    ureal_name = reg_user.real_name

    ulogin = reg_user.login_name

    upass = reg_user.password

    logging.debug("Root password: %s", root_pass)

    if ulogin:

        user_home_dir = "/export/home/" + ulogin

        ZFS_SHARED_FS.insert(0, user_home_dir)

        logging.debug("User real name: %s", ureal_name)

        logging.debug("User login: %s", ulogin)

        logging.debug("User password: %s", upass)

    (inst_device, inst_device_size) = \

              install_profile.disk.get_install_dev_name_and_size()

    logging.debug("Installation Device Name: %s", inst_device)

    logging.debug("Installation Device Size: %sMB", inst_device_size)

    swap_dump = ti_utils.SwapDump()

    min_inst_size = ti_utils.get_minimum_size(swap_dump)

    logging.debug("Minimum required size: %sMB", min_inst_size)

    if (inst_device_size < min_inst_size):

        logging.error("Size of device specified for installation "

                      "is too small")

        logging.error("Size of install device: %sMB", inst_device_size)

        logging.error("Minimum required size: %sMB", min_inst_size)

        raise ti_utils.InstallationError

    recommended_size = ti_utils.get_recommended_size(swap_dump)

    logging.debug("Recommended size: %sMB", recommended_size)

    if (inst_device_size < recommended_size):

        # Warn users that their install target size is not optimal

        # Just log the warning, but continue with the installation.

        logging.warning("Size of device specified for installation is "

                        "not optimal") 

        logging.warning("Size of install device: %sMB", inst_device_size)

        logging.warning("Recommended size: %sMB", recommended_size)

    # Validate the value specified for timezone

    if not tz_isvalid(timezone):

        logging.error("Timezone value specified (%s) is not valid", timezone)

        raise ti_utils.InstallationError

    # Compute the time to set here.  It will be set after the rtc

    # command is run, if on x86.

    install_time = datetime.datetime.now() + install_profile.system.time_offset

    if platform.processor() == "i386":

        #

        # At this time, the /usr/sbin/rtc command does not work in alternate

        # root.  It hard codes to use /etc/rtc_config.

        # Therefore, we set the value for rtc_config in the live environment

        # so it will get copied over to the alternate root.

        #

        exec_cmd([RTC_CMD, "-z", timezone], "set timezone")

        exec_cmd([RTC_CMD, "-c"], "set timezone")

    #

    # Set the system time to the time specified by the user

    # The value to set the time to is computed before the "rtc" commands.

    # This is required because rtc will mess up the computation of the

    # time to set.  The rtc command must be run before the command

    # to set time.  Otherwise, the time that we set will be overwritten

    # after running /usr/sbin/rtc.

    #

    cmd = ["/usr/bin/date", install_time.strftime("%m%d%H%M%y")]

    exec_cmd(cmd, "set system time")

    time_change_event.set()

    global INSTALL_STATUS

    INSTALL_STATUS = InstallStatus(screen, update_status_func, quit_event)

    rootpool_name = install_profile.disk.get_install_root_pool()

    cleanup_existing_install_target(install_profile, inst_device)

    do_ti(install_profile, swap_dump)

    do_transfer()

    ict_mesg = "Completing transfer process"

    INSTALL_STATUS.update(InstallStatus.ICT, 0, ict_mesg)

    # Save the timezone in the installed root's /etc/default/init file

    ti_utils.save_timezone_in_init(INSTALLED_ROOT_DIR, timezone)

    # If swap was created, add appropriate entry to <target>/etc/vfstab

    swap_device = swap_dump.get_swap_device(rootpool_name) 

    logging.debug("Swap device: %s", swap_device)

    ti_utils.setup_etc_vfstab_for_swap(swap_device, INSTALLED_ROOT_DIR)

    #

    # The /etc/.sysIDtool.state file needs to be written before calling

    # the ICTs, because it gets copied over by the ICTs into the installed

    # system.

    #

    create_sysid_file()

    try:

        run_ICTs(install_profile, hostname, ict_mesg, inst_device,

                 locale, root_pass, ulogin, upass, ureal_name,

                 rootpool_name)

    finally:

        post_install_cleanup(install_profile, rootpool_name)

    INSTALL_STATUS.update(InstallStatus.ICT, 100, ict_mesg)

def post_install_cleanup(install_profile, rootpool_name):

    '''Do final cleanup to prep system for first boot, such as resetting

    the ZFS dataset mountpoints

    '''

    # reset_zfs_mount_property

    # Setup mountpoint property back to "/" from "/a" for

    # /, /opt, /export, /export/home

    # make sure we are not in the alternate root.

    # Otherwise, be_unmount() fails

    os.chdir("/root")

    # since be_unmount() can not currently handle shared filesystems,

    # it's necesary to manually set their mountpoint to the appropriate value

    for fs in ZFS_SHARED_FS:

        exec_cmd(["/usr/sbin/zfs", "unmount", rootpool_name + fs],

                 "unmount " + rootpool_name + fs)

        exec_cmd(["/usr/sbin/zfs", "set", "mountpoint=" + fs,

                 rootpool_name + fs], "change mount point for " +

                 rootpool_name + fs)

    # Transfer the log file

    final_log_loc = INSTALLED_ROOT_DIR + install_profile.log_final

    logging.debug("Copying %s to %s", install_profile.log_location,

                  final_log_loc)

    try:

        shutil.copyfile(install_profile.log_location, final_log_loc)

    except (IOError, OSError), err: 

        logging.error("Failed to copy %s to %s", install_profile.log_location,

                      install_profile.log_final)