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

#

'''System Configuration Interactive (SCI) Tool'''

import gettext

import atexit

import curses

import locale

import logging

from optparse import OptionParser

import os

import shutil

import signal

import sys

from solaris_install import engine

from solaris_install.data_object import DataObject

from solaris_install.data_object.data_dict import DataObjectDict

from solaris_install import Popen, CalledProcessError

from solaris_install.engine import InstallEngine, RollbackError

from solaris_install.getconsole import get_console, SERIAL_CONSOLE

from solaris_install.ict.apply_sysconfig import APPLY_SYSCONFIG_DICT, \

    APPLY_SYSCONFIG_PROFILE_KEY

#

# Determine whether LC_MESSAGES environment variable needs to be set

# or not.  This must be done before the gettext.translation() call so the

# correct localized messages are used.

#

console_type = get_console()

#

# If running from a serial console, translation will be enabled.

# If running on a physical console, translation will

# be disabled by setting LC_MESSAGES to C

#

if console_type != SERIAL_CONSOLE:

    os.environ["LC_MESSAGES"] = "C"

_ = gettext.translation("sysconfig", "/usr/share/locale",

                        fallback=True).ugettext

SCI_HELP = "/usr/share/sysconfig/help"

COMMA = ","

DASH_G = "-g"

SUPPORT_ERR = "system is the only supported grouping for configure " \

                "and unconfigure"

SUBCOMMANDS = "unconfigure, configure, create-profile"

# system configuration groups

# hostname

SC_GROUP_IDENTITY = 'identity'

# networking

SC_GROUP_NETWORK = "network"

# naming services

SC_GROUP_NS = 'naming_services'

# keyboard layout

SC_GROUP_KBD = 'kbd_layout'

# date and time

SC_GROUP_DATETIME = 'date_time'

# timezone and locale

SC_GROUP_LOCATION = 'location'

# user and root account

SC_GROUP_USERS = 'users'

# pseudo-group - includes all available groups

SC_GROUP_SYSTEM = 'system'

# list of configuration groups

SC_ALL_GROUPS = [SC_GROUP_IDENTITY, SC_GROUP_NETWORK, SC_GROUP_NS,

                 SC_GROUP_KBD, SC_GROUP_LOCATION, SC_GROUP_DATETIME,

                 SC_GROUP_USERS]

# all valid configuration groups including 'system' pseudo-group

SC_VALID_GROUPS = SC_ALL_GROUPS + [SC_GROUP_SYSTEM]

SMF_REPOSITORY = "etc/svc/repository.db"

CUSTOM_PROFILE_DIR = "etc/svc/profile/sc"

def get_sc_options_from_doc():

    '''Obtains list of sysconfig CLI options from Data Object Cache'''

    doc = InstallEngine.get_instance().doc.persistent

    sc_options = doc.get_first_child(name=SC_OPTIONS_LABEL)

    if sc_options is not None:

        return sc_options.options

    else:

        return None

def configure_group(group=None):

    '''Returns True if specified group is to be configured,

    otherwise returns False'''

    sc_options = get_sc_options_from_doc()

    # if list of groups can't be obtained, assume everything

    # is to be configured

    if sc_options is None:

        return True

    elif group in sc_options.grouping:

        return True

    else:

        return False

from solaris_install.logger import FileHandler, INSTALL_LOGGER_NAME

from solaris_install.sysconfig.date_time import DateTimeScreen

from solaris_install.sysconfig.network_nic_configure import NICConfigure

from solaris_install.sysconfig.network_nic_select import NICSelect

from solaris_install.sysconfig.network_type import NetworkTypeScreen

from solaris_install.sysconfig.profile import ConfigProfile, SMFConfig, \

                                              SMFInstance, SMFPropertyGroup, \

                                              SMFProperty

from solaris_install.sysconfig.nameservice import NSDNSChooser, NSAltChooser, \

                                                  NSDomain, \

                                                  NSDNSServer, NSDNSSearch, \

                                                  NSLDAPProfile, \

                                                  NSLDAPProxyBindChooser, \

                                                  NSLDAPProxyBindInfo, \

                                                  NSNISAuto, NSNISIP

from solaris_install.sysconfig.summary import SummaryScreen

from solaris_install.sysconfig.timezone import TimeZone

from solaris_install.sysconfig.users import UserScreen

from solaris_install.sysconfig.welcome import WelcomeScreen

import terminalui

from terminalui import LOG_LEVEL_INPUT, LOG_NAME_INPUT

from terminalui.action import Action

from terminalui.base_screen import BaseScreen

from terminalui.help_screen import HelpScreen

from terminalui.i18n import get_encoding, set_wrap_on_whitespace

from terminalui.main_window import MainWindow

from terminalui.screen_list import ScreenList

SU_OK = 0

SU_FATAL_ERR = 1

# profile names

# profile configuring svc:/milestone/config:default service

CONFIG_PROFILE = "enable_sci.xml"

# profile configuring svc:/milestone/unconfig milestone

UNCONFIG_PROFILE = "unconfig.xml"

# directories

# temporary directory

VOLATILE_PATH = "/system/volatile"

# smf site-profile directory

PROFILE_PATH = "/etc/svc/profile/site"

# temporary profiles

TMP_CONFIG_PROFILE = os.path.join(VOLATILE_PATH, CONFIG_PROFILE)

TMP_UNCONFIG_PROFILE = os.path.join(VOLATILE_PATH, UNCONFIG_PROFILE)

# destination for profile configuring svc:/milestone/config:default service

CONFIG_PROFILE_DEST = os.path.join(PROFILE_PATH, CONFIG_PROFILE)

# destination for profile configuring svc:/milestone/unconfig milestone

UNCONFIG_PROFILE_DEST = os.path.join(PROFILE_PATH, UNCONFIG_PROFILE)

# default locations

DEFAULT_SC_LOCATION = os.path.join(VOLATILE_PATH, "profile",

                                   DEFAULT_SC_PROFILE)

DEFAULT_LOG_LOCATION = "/var/tmp/install/sysconfig.log"

DEFAULT_LOG_LEVEL = "info"

LOG_FORMAT = ("%(asctime)s - %(levelname)-8s: "

              "%(filename)s:%(lineno)d %(message)s")

LOGGER = None

XSLT_FILE = os.environ.get('SC_XSLT',

                           '/usr/share/sysconfig/xslt/doc2sc_profile.xslt')

SC_FILE = DEFAULT_SC_LOCATION

GENERATE_SC_PROFILE_CHKPOINT = 'generate-sc-profile'

# sysconfig subcommands

CONFIGURE = "configure"

UNCONFIGURE = "unconfigure"

CREATE_PROFILE = "create-profile"

SVCADM = "/usr/sbin/svcadm"

SVCPROP = "/usr/bin/svcprop"

SVCCFG = "/usr/sbin/svccfg"

SYSTEM = "system"

# Commands for the console

CTSTAT = "/usr/bin/ctstat"

SVCPROP = "/usr/bin/svcprop"

CONSOLE_LOGIN = "svc:/system/console-login:default"

TTY = "/usr/bin/tty"

CONSOLE = "/dev/console"

ALT_ROOT_ENV_VAR = "_UNCONFIG_ALT_ROOT"

# DOC label for SysConfig options 

SC_OPTIONS_LABEL = "sc_options"

class SysConfigOptions(DataObject):

    '''System Configuration options'''

    def __init__(self, options=None):

        super(SysConfigOptions, self).__init__(SC_OPTIONS_LABEL)

        self.options = options

    def to_xml(self):

        return None

    @classmethod

    def can_handle(cls, element):

        return False

    @classmethod

    def from_xml(cls, element):

        return None

# Public functions for consumers of sysconfig

def get_all_screens(main_win):

    '''Initializes a full set of configuration screens'''

    result = []

    result.append(NetworkTypeScreen(main_win, True))

    result.append(NICSelect(main_win))

    result.append(NICConfigure(main_win))

    _append_nameservice_screens(result, main_win)

    result.append(TimeZone(main_win, screen=TimeZone.REGIONS))

    result.append(TimeZone(main_win, screen=TimeZone.LOCATIONS))

    result.append(TimeZone(main_win))

    result.append(DateTimeScreen(main_win))

    result.append(UserScreen(main_win))

    return result

def get_screens_from_groups(main_win):

    '''Initializes subset of configuration screens matching list of specified

    configuration groups'''

    result = []

    # hostname

    if configure_group(SC_GROUP_IDENTITY):

        result.append(NetworkTypeScreen(main_win,

                                        configure_group(SC_GROUP_NETWORK)))

    # network

    if configure_group(SC_GROUP_NETWORK):

        result.append(NICSelect(main_win))

        result.append(NICConfigure(main_win))

    # name services

    if configure_group(SC_GROUP_NS):

        _append_nameservice_screens(result, main_win)

    # timezone

    if configure_group(SC_GROUP_LOCATION):

        result.append(TimeZone(main_win, screen=TimeZone.REGIONS))

        result.append(TimeZone(main_win, screen=TimeZone.LOCATIONS))

        result.append(TimeZone(main_win))

    # date and time

    if configure_group(SC_GROUP_DATETIME):

        result.append(DateTimeScreen(main_win))

    # initial user

    if configure_group(SC_GROUP_USERS):

        result.append(UserScreen(main_win))

    return result

def _append_nameservice_screens(result, main_win):

    ''' Initialize and append all name service screens '''

    result.append(NSDNSChooser(main_win))

    result.append(NSAltChooser(main_win))

    result.append(NSDomain(main_win))

    result.append(NSDNSServer(main_win))

    result.append(NSDNSSearch(main_win))

    result.append(NSLDAPProfile(main_win))

    result.append(NSLDAPProxyBindChooser(main_win))

    result.append(NSLDAPProxyBindInfo(main_win))

    result.append(NSNISAuto(main_win))

    result.append(NSNISIP(main_win))

def register_checkpoint(sc_profile=SC_FILE, xslt=XSLT_FILE):

    '''Registers the GENERATE_SC_PROFILE_CHKPOINT checkpoint with the engine.

    Also adds config_profile to InstallEngine.doc.persistent'''

    eng = InstallEngine.get_instance()

    sc_kwargs = {'xslt_file': xslt}

    sc_args = [sc_profile]

    eng.register_checkpoint(GENERATE_SC_PROFILE_CHKPOINT,

                            "solaris_install/manifest/writer",

                            "ManifestWriter", args=sc_args, kwargs=sc_kwargs)

    # Add profile location to the ApplySysconfig checkpoint's data dict.

    # Try to find the ApplySysconfig data dict from the DOC in case it

    # already exists.

    as_doc_dict = None

    as_doc_dict = eng.doc.volatile.get_first_child(name=APPLY_SYSCONFIG_DICT)

    if as_doc_dict is None:

        # Initialize new dictionary in DOC

        as_dict = {APPLY_SYSCONFIG_PROFILE_KEY: sc_profile}

        as_doc_dict = DataObjectDict(APPLY_SYSCONFIG_DICT, as_dict)

        eng.doc.volatile.insert_children(as_doc_dict)

    else:

        # Add to existing dictionary in DOC

        as_doc_dict.data_dict[APPLY_SYSCONFIG_PROFILE_KEY] = sc_profile

    eng.doc.persistent.insert_children([ConfigProfile()])

def vararg_callback(option, opt_str, value, parser):

    '''Callback function to parse the -g option. Multiple groups are

    allowed to be specified.

    '''

    value = list()

    def floatable(arg_str):

        '''Checks for a float variable'''

        try:

            float(arg_str)

            return True

        except ValueError:

            return False

    for arg in parser.rargs:

        if arg[:2] == "--" and len(arg) > 2:

            break

        if arg[:1] == "-" and len(arg) > 1 and not floatable(arg):

            break

        # Strip off the comma separating the groups if it's there

        # and check that the user hasn't specified the same grouping

        # more than once. If they have, only keep one.

        if arg.strip(",") not in value:

            value.append(arg.strip(","))

    del parser.rargs[:len(value)]

    setattr(parser.values, option.dest, value)

def create_config_profiles(sub_cmd, options):

    ''' Create two separate SMF profiles configuring milestone/config and

    milestone/unconfig services. Place them in /etc/svc/profile/site

    directory.

    '''

    # Remove any old profile files.

    if os.path.exists(TMP_CONFIG_PROFILE):

        os.unlink(TMP_CONFIG_PROFILE)

    if os.path.exists(TMP_UNCONFIG_PROFILE):

        os.unlink(TMP_UNCONFIG_PROFILE)

    # create profile configuring milestone/config service

    fhdl = open(TMP_CONFIG_PROFILE, "w")

    # Header and DTD

    fhdl.writelines("<?xml version='1.0'?>\n")

    fhdl.writelines("<!DOCTYPE service_bundle SYSTEM "

                    "'/usr/share/lib/xml/dtd/service_bundle.dtd.1'>\n")

    fhdl.writelines("<service_bundle type=\"profile\" "

                    "name=\"config_profile\">\n")

    fhdl.writelines("<service name=\"milestone/config\" version=\"1\" "

                    "type=\"service\">\n")

    fhdl.writelines("<instance name=\"default\" enabled=\"true\">\n")

    # sysconfig property group

    fhdl.writelines("<property_group name=\"sysconfig\" "

                    "type=\"application\">\n")

    # interactive_config property

    # Set to true if no profiles were provided in reconfiguration scenario.

    # Othwerwise set it to false.

    if sub_cmd == CONFIGURE and not options.profile:

        fhdl.writelines("<propval name=\"interactive_config\" type=\"boolean\""

                        " value=\"true\"/>\n")

    else:

        fhdl.writelines("<propval name=\"interactive_config\" type=\"boolean\""

                        " value=\"false\"/>\n")

    # config_group from -g option

    fhdl.writelines("<propval name=\"config_groups\" type=\"astring\""

                    " value=\"")

    for grp in options.grouping:

        fhdl.writelines("%s " % grp)

    fhdl.writelines("\"/>\n")

    # configure flag

    # Set to true in reconfiguration scenario, otherwise set to false.

    if sub_cmd == CONFIGURE:

        fhdl.writelines("<propval name=\"configure\" type=\"boolean\" "

                        "value=\"true\"/>\n")

    else:

        fhdl.writelines("<propval name=\"configure\" type=\"boolean\" "

                        "value=\"false\"/>\n")

    fhdl.writelines("</property_group>\n")

    fhdl.writelines("</instance>\n")

    fhdl.writelines("</service>\n")

    fhdl.writelines("</service_bundle>\n")

    fhdl.close()

    profile = CONFIG_PROFILE_DEST

    if options.alt_root:

        profile = options.alt_root + profile

    # Move file to target destination

    shutil.move(TMP_CONFIG_PROFILE, profile)

    # create profile configuring milestone/unconfig milestone

    fhdl = open(TMP_UNCONFIG_PROFILE, "w")

    # Header and DTD

    fhdl.writelines("<?xml version='1.0'?>\n")

    fhdl.writelines("<!DOCTYPE service_bundle SYSTEM "

                    "'/usr/share/lib/xml/dtd/service_bundle.dtd.1'>\n")

    fhdl.writelines("<service_bundle type=\"profile\" "

                    "name=\"unconfig_profile\">\n")

    # unconfig milestone

    fhdl.writelines("<service name=\"milestone/unconfig\" version=\"1\" "

                    "type=\"service\">\n")

    # configuration property group

    fhdl.writelines("<property_group name=\"sysconfig\" "

                    "type=\"application\">\n")

    # shutdown property default is false, true if -s was specified.

    if options.shutdown:

        fhdl.writelines("<propval name=\"shutdown\" type=\"boolean\" "

                        "value=\"true\"/>\n")

    else:

        fhdl.writelines("<propval name=\"shutdown\" type=\"boolean\" "

                        "value=\"false\"/>\n")

    # destructive property default is false, true if --destructive

    # was specified.

    if options.destructive:

        fhdl.writelines("<propval name=\"destructive_unconfig\" "

                        "type=\"boolean\" value=\"true\"/>\n")

    else:   

        fhdl.writelines("<propval name=\"destructive_unconfig\" "

                        "type=\"boolean\" value=\"false\"/>\n")

    # unconfig_groups from -g option

    fhdl.writelines("<propval name=\"unconfig_groups\" type=\"astring\" "

                    "value=\"")

    for grp in options.grouping:

        fhdl.writelines("%s " % grp)

    fhdl.writelines("\"/>\n")

    # unconfigure flag, always true

    fhdl.writelines("<propval name=\"unconfigure\" type=\"boolean\" "

                    "value=\"true\"/>\n")

    fhdl.writelines("</property_group>\n")

    fhdl.writelines("</service>\n")

    fhdl.writelines("</service_bundle>\n")

    fhdl.close()

    profile = UNCONFIG_PROFILE_DEST

    if options.alt_root:

        profile = options.alt_root + profile

    # Move file to target destination

    shutil.move(TMP_UNCONFIG_PROFILE, profile)

def profile_is_valid(profile_name):

    '''Validate system configuration profile:

        - profile has to have .xml extension,

          otherwise smf(5) refuses to apply it

        - profile has to syntactically validate using 'svccfg apply -n'

        Return: True if profile is valid, otherwise False

    '''

    # Check if profile contains .xml suffix.

    if not profile_name.endswith(".xml"):