#!/usr/bin/python2.6

#

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

#

'''Install Completion Tasks (ICT)

Each ICT is implemented as a method of class ict.

Guide to calling ICTs

The most efficient way to invoke ICTs is to create an ict class instance,

then to invoke the ICT methods of the ict class:

    - create an ict class instance, providing at least root target directory

    - call ICT as a method of the class instance just created

    - returned status is a tuple of exit status code and any other return

      information

    - logging is done by ICT, but you can return exit status to caller

    - logging service options are inherited from the environment

    - logging level can be set (second parameter) and overridden in environment

        LS_DBG_LVL=(1-4)

    - do not abort if an ICT fails (unless it is an untenable situation)

ICTs can also be invoked singly through a command line using function

exec_ict():

    python ict.py <ICT method> <target directory>  [<ICT-specific parameter>]

    Example command line:

        python ict.py ict_test /a  #runs test ICT

Guide to writing ICTs

- Locate ict class (line starts with "def ict")

- Within the ict class, find "end Install Completion Tasks"

- Add new ICT as method just before that

- ICTs are methods of the ict class

- ICTs have 'self' as 1st parameter - add other parameters as desired

- Create error return code(s)

- ICTs should return either status code, or a tuple with status code first

- See __init__ method for initialization of class members

- self.basedir is the root directory of the target

- for first line of ICT, use _register_task(inspect.currentframe())

    as a trace aid

- do not allow unhandled exceptions

- if a critical condition is encountered, log error and sys.exit()

    with error status

- as a last exception handler, instead of raising the exception,

    log the traceback,

    e.g.:

        except StandardError:

                prerror('Unexpected error doing something.')

                prerror(traceback.format_exc())

- use the module utility routines:

    prerror(string) - log error message

    _dbg_msg(string) - log output debugging message

    info_msg(string) - log informational message

    _cmd_out(cmd) - execute shell command, returning only exit status

    _cmd_status(cmd) - execute shell command, returning exit status and stdout

- place ICT comments just before or after def statement for module

   pydoc to generate documentation

Skeleton ICT:

from osol_install.ict import *

icto = ict('/a')

status = icto.<some ICT (class method)>(<parameters depend on ICT>)

ICT initial project tasks from Transfer Module (TM):

        Setting default keyboard layout TM

        Creating initial SMF repository TM

        Creating /etc/mnttab TM

        Cleanup unnecessary symbolic links and files from the alternate root.

        (clobber files) TM

'''

import errno

import os

import os.path

import sys

from stat import S_IREAD, \

     S_IWRITE, \

     S_IEXEC, \

     S_IRUSR, \

     S_IWUSR, \

     S_IRGRP, \

     S_IXGRP, \

     S_IROTH, \

     S_IXOTH, \

     S_ISLNK

import fcntl

import array

import struct

import shutil

import tempfile

import inspect

import filecmp

import traceback

import re

import platform

import signal

import commands

from pkg.cfgfiles import PasswordFile, UserattrFile

from osol_install.liblogsvc import LS_DBGLVL_ERR, \

LS_DBGLVL_INFO, \

init_log, \

write_dbg, \

write_log

ICTID = 'ICT'

(

ICT_INVALID_PARAMETER,

ICT_INVALID_PLATFORM,

ICT_NOT_MULTIBOOT,

ICT_ADD_FAILSAFE_MENU_FAILED,

ICT_KIOCLAYOUT_FAILED,

ICT_OPEN_KEYBOARD_DEVICE_FAILED,

ICT_KBD_LAYOUT_NAME_NOT_FOUND,

ICT_UPDATE_BOOTPROP_FAILED,

ICT_MKMENU_FAILED,

ICT_SPLASH_IMAGE_FAILURE,

ICT_REMOVE_LIVECD_COREADM_CONF_FAILURE,

ICT_SET_BOOT_ACTIVE_TEMP_FILE_FAILURE,

ICT_FDISK_FAILED,

ICT_UPDATE_DUMPADM_NODENAME_FAILED,

ICT_CONFIGURE_NWAM_FAILED,

ICT_ENABLE_NWAM_FAILED,

ICT_FIX_FAILSAFE_MENU_FAILED,

ICT_CREATE_SMF_REPO_FAILED,

ICT_CREATE_MNTTAB_FAILED,

ICT_PACKAGE_REMOVAL_FAILED,

ICT_DELETE_BOOT_PROPERTY_FAILURE,

ICT_GET_ROOTDEV_LIST_FAILED,

ICT_SETUP_DEV_NAMESPACE_FAILED,

ICT_UPDATE_ARCHIVE_FAILED,

ICT_COPY_SPLASH_XPM_FAILED,

ICT_SMF_CORRECT_SYS_PROFILE_FAILED,

ICT_REMOVE_BOOTPATH_FAILED,

ICT_ADD_SPLASH_IMAGE_FAILED,

ICT_SYSIDTOOL_ENTRIES_FAILED,

ICT_SYSIDTOOL_CP_STATE_FAILED,

ICT_SET_FLUSH_CONTENT_CACHE_ON_SUCCESS_FAILED,

ICT_FIX_GRUB_ENTRY_FAILED,

ICT_CREATE_SPARC_BOOT_MENU_FAILED,

ICT_COPY_SPARC_BOOTLST_FAILED,

ICT_CLOBBER_FILE_FAILED,

ICT_CLEANUP_FAILED,

ICT_REBUILD_PKG_INDEX_FAILED,

ICT_PKG_RESET_UUID_FAILED,

ICT_PKG_SEND_UUID_FAILED,

ICT_SET_SWAP_AS_DUMP_FAILED,

ICT_EXPLICIT_BOOTFS_FAILED,

ICT_ENABLE_HAPPY_FACE_BOOT_FAILED,

ICT_POPEN_FAILED,

ICT_REMOVE_LIVECD_ENVIRONMENT_FAILED,

ICT_SET_ROOT_PW_FAILED,

ICT_CREATE_NU_FAILED,

ICT_OPEN_PROM_DEVICE_FAILED,

ICT_IOCTL_PROM_FAILED,

ICT_SET_PART_ACTIVE_FAILED,

ICT_SVCCFG_FAILURE,

ICT_SET_AUTOHOME_FAILED,

ICT_COPY_CAPABILITY_FAILED,

ICT_APPLY_SYSCONFIG_FAILED,

ICT_GENERATE_SC_PROFILE_FAILED,

ICT_SETUP_RBAC_FAILED,

ICT_SETUP_SUDO_FAILED

) = range(200,256)

# Global variables

DEBUGLVL = LS_DBGLVL_ERR

CUR_ICT_FRAME = None  # frame info for debugging and tracing

MENU_LST_DEFAULT_TITLE = "OpenIndiana"

#Module functions - intended for local use, but usable by importers

def _register_task(fm):

    '''register current ICT for logging, debugging and tracing

    By convention, use as 1st executable line in ICT

    '''

    global CUR_ICT_FRAME

    CUR_ICT_FRAME = fm

    if CUR_ICT_FRAME != None:

        cf = inspect.getframeinfo(CUR_ICT_FRAME)

        write_log(ICTID, 'current task:' + cf[2] + '\n')

def prerror(msg):

    '''Log an error message to logging service and stderr

    '''

    msg1 = msg + "\n"

    write_dbg(ICTID, LS_DBGLVL_ERR, msg1)

def _move_in_updated_config_file(new, orig):

    '''move in new version of file to original file location,

    overwriting original

    side effect: deletes temporary file upon failure

    '''

    # if files are identical

    if os.path.exists(new) and os.path.exists(orig) and filecmp.cmp(new, orig):

        _delete_temporary_file(new)

        return True

    try:

        shutil.copyfile(new, orig)

        os.remove(new)

    except IOError:

        prerror('IO error - cannot move file ' + new + ' to ' + orig)

        prerror(traceback.format_exc())

        _delete_temporary_file(new)

        return False

    except StandardError:

        prerror('Unrecognized error - failure to move file ' + new +

                ' to ' + orig)

        prerror(traceback.format_exc())

        _delete_temporary_file(new)

        return False

    return True

def _cmd_out(cmd):

    '''execute a shell command and return output

    cmd - command to execute

    returns tuple:

            status = command exit status

            dfout = array of lines output to stdout, stderr by command

    '''

    _dbg_msg('_cmd_out: executing cmd=' + cmd)

    status = 0

    dfout = []

    '''Since Python ignores SIGPIPE, according to Python issue 1652,

    UNIX scripts in subprocesses will also ignore SIGPIPE.

    Workaround is to save original signal handler, restore default handler,

    launch script, restore original signal handler

    '''

    #save SIGPIPE signal handler

    orig_sigpipe = signal.getsignal(signal.SIGPIPE)

    #restore default signal handler for SIGPIPE

    signal.signal(signal.SIGPIPE, signal.SIG_DFL)

    try:

        fp = os.popen(cmd)

        if fp == None or fp == -1:

            return ICT_POPEN_FAILED, []

        for rline in fp:

            if rline and rline.endswith('\n'):

                rline = rline[:-1]

            dfout.append(rline)

            _dbg_msg('_cmd_out: stdout/stderr line=' + rline)

        status = fp.close()

    except StandardError:

        prerror('system error in launching shell cmd (' + cmd + ')')

        status = 1

    #restore original signal handler for SIGPIPE

    signal.signal(signal.SIGPIPE, orig_sigpipe)

    if status == None:

        status = 0

    if status != 0:

        write_log(ICTID, 'shell cmd (' + cmd + ') returned status ' +

                  str(status) + "\n")

    if DEBUGLVL >= LS_DBGLVL_INFO:

        print ICTID + ': _cmd_out status =', status, 'stdout/stderr=', dfout

    return status, dfout

def _cmd_status(cmd):

    '''execute a shell command using popen and return its exit status

    '''

    _dbg_msg('_cmd_status: executing cmd=' + cmd)

    exitstatus = None

    '''Since Python ignores SIGPIPE, according to Python issue 1652,

    UNIX scripts in subprocesses will also ignore SIGPIPE.

    Workaround is to save original signal handler, restore default handler,

    launch script, restore original signal handler

    '''

    #save SIGPIPE signal handler

    orig_sigpipe = signal.getsignal(signal.SIGPIPE)

    #restore default signal handler for SIGPIPE

    signal.signal(signal.SIGPIPE, signal.SIG_DFL)

    try:

        fp = os.popen(cmd)

        if fp == None or fp == -1:

            return ICT_POPEN_FAILED

        exitstatus = fp.close()

    except StandardError:

        prerror('unknown error in launching shell cmd (' + cmd + ')')

        prerror('Traceback:')

        prerror(traceback.format_exc())

        exitstatus = 1

    if exitstatus == None:

        exitstatus = 0

    # restore original signal handler for SIGPIPE

    signal.signal(signal.SIGPIPE, orig_sigpipe)

    _dbg_msg('_cmd_status: return exitstatus=' + str(exitstatus))

    return exitstatus

def info_msg(msg):

    '''

    send an informational message to logging service

    '''

    write_log(ICTID, msg + '\n')

#send informational debugging message to logging service, according to level

def _dbg_msg(msg):

    '''send informational debugging message to logging service,

    according to level

    '''

    if (DEBUGLVL >= LS_DBGLVL_INFO):

        write_dbg(ICTID, LS_DBGLVL_INFO, msg + '\n')

def _delete_temporary_file(filename):

    '''

    delete temporary file - suppress traceback on error

    '''

    try:

        os.unlink(filename)

    except StandardError:

        pass # ignore failure to delete temp file

class ICT(object):

    '''main class to support ICT

    ICT object must first be created and initialized

        basedir - root directory (only required parameter)

        debuglvl - debugging message level for liblogsvc

        bootenvrc - normal location of bootenv.rc

        autohome - normal location of autohome map

        loc_grubmenu - normal location of GRUB menu

        ai_sc_profile - SC profile generated by Automated Installer

        target_sc_profile = target SC profile

        sudoers - normal location of sudo configuration file

    class initializer will exit with error status if:

        - basedir is missing or empty

        - basedir is '/', in order to protect against accidental usage.

          For a live system this should be permitted.

    '''

    def __init__(self, basedir,

        debuglvl=-1,

        bootenvrc='/boot/solaris/bootenv.rc',

        autohome='/etc/auto_home',

        loc_grubmenu='/boot/grub/menu.lst',

        ai_sc_profile='/tmp/sc_manifest.xml',

        target_sc_profile='sc_profile.xml',

        sudoers='/etc/sudoers'):

        # determine whether we are doing AI install or slim install

        self.livecd_install = False

        self.auto_install = False

        self.text_install = False

        if os.access("/.livecd", os.R_OK):

            _dbg_msg('Determined to be doing Live CD install')

            self.livecd_install = True

        elif os.access("/.autoinstall", os.R_OK):

            _dbg_msg('Determined to be doing Automated Install')

            self.auto_install = True

        elif os.access("/.textinstall", os.R_OK):

            _dbg_msg("Determined to be doing Text Install")

            self.text_install = True

        if basedir == '':

            err_str = 'Base directory must be passed'

            prerror(err_str)

            raise ValueError(err_str)

        if basedir == '/':

            '''

            The code can be run on a live system but if we're not

            on a live system we should not support / for BASEDIR.

            '''

            if self.livecd_install or self.auto_install or self.text_install:

                err_str = 'Base directory cannot be root ' + \

                    '("/") during install'

                prerror(err_str)

                raise ValueError(err_str)

        self.basedir = basedir

        '''

        If we're running outside of an install we should not use

        the basedir here since that could be the mountpoint of a

        pool that we're creating the menu.lst file on.

        '''

        if self.livecd_install or self.auto_install or self.text_install:

            self.prependdir = basedir

        else:

            self.prependdir = ""

        self.bootenvrc = self.prependdir + bootenvrc

        #Is the current platform a SPARC system?

        self.is_sparc = (platform.platform().find('sparc') >= 0)

        global DEBUGLVL

        try:

            DEBUGLVL = int(os.getenv('LS_DBG_LVL', -1))

        except StandardError:

            prerror('Could not parse enviroment variable LS_DBG_LVL to ' +

                    'integer')

            DEBUGLVL = -1

        if DEBUGLVL == -1:

            DEBUGLVL = debuglvl

        if DEBUGLVL == -1:

            DEBUGLVL = LS_DBGLVL_ERR #default logging

        else:

            if DEBUGLVL != LS_DBGLVL_ERR and \

                init_log(DEBUGLVL) != 1: #set in logging service

                prerror('Setting logging service debug level to ' +

                    str(DEBUGLVL) + ' failed.')

        self.kbd_device = '/dev/kbd'

        self.kbd_layout_file = '/usr/share/lib/keytables/type_6/kbd_layouts'

        self.keyboard_layout = ''

        # determine whether we are installing to an iSCSI boot target

        self.iscsi_boot_install = False

        if os.access("/.iscsi_boot", os.R_OK):

            _dbg_msg('Determined to be doing iSCSI boot install')

            self.iscsi_boot_install = True

        #take root poolname from mnttab

        # Note there are TABs in the blow expression.

        # cmd = 'grep "^[^<TAB>]*<TAB>' + basedir +<TAB>' " /etc/mnttab | ' + \

        cmd = 'grep "^[^	]*	' + basedir + '	" /etc/mnttab | ' + \

              ' nawk \'{print $1}\' | sed \'s,/.*,,\''

        sts, rpa = _cmd_out(cmd)

        if len(rpa) == 0:

            prerror('Cannot determine root pool name. exit status=' +

                    str(sts) + ' command=' + cmd)

            sys.exit(ICT_GET_ROOTDEV_LIST_FAILED)

        self.rootpool = rpa[0]

        _dbg_msg('Root pool name discovered: ' + self.rootpool)

        if self.livecd_install or self.auto_install or self.text_install:

            #With the root pool pre-pended to /boot/grub/menu.lst

            self.grubmenu = '/' + self.rootpool + loc_grubmenu

            self.bootmenu_path_sparc = '/' + self.rootpool + '/boot'

        else:

            #With the basedir pre-pended to /boot/grub/menu.lst

            self.grubmenu = basedir + loc_grubmenu

            #With the basedir pre-pended for the SPARC boot menu

            self.bootmenu_path_sparc = basedir + '/boot'

        #/boot/menu.lst

        self.bootmenu_sparc = self.bootmenu_path_sparc + '/menu.lst'

        self.autohome = basedir + autohome

        self.sudoers = basedir + sudoers

        # System Configuration template used to assemble System Configuration

        # profile

        self.sc_template = '/usr/share/install/sc_template.xml'

        # path to System Configuration profile generated by Automated Installer

        self.ai_sc_profile = ai_sc_profile

        # name of target System Configuration profile

        self.sc_profile = target_sc_profile

    #support methods

    def _get_bootprop(self, property_id):

        '''support method - get property from bootenv.rc

        Parameter: property_id - bootenv.rc property ID

        The format of a line in bootenvrc is: