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

#

# ai_get_manifest - AI Service Choosing Engine

#

"""

    ai_get_manifest - Obtains AI manifest from AI server

"""

from email.parser import Parser

from errno import EEXIST, ENOENT

import getopt

import gettext

import httplib

import os

import socket

from subprocess import Popen, PIPE

import re

import sys

import tempfile

import time

import traceback

import urllib

from solaris_install import _, system_temp_path

VERSION_FILE = '/usr/share/auto_install/version'

# constants for generating temporary files with unique names for SMF profiles

SC_PREFIX = 'profile_'

SC_EXTENSION = '.xml'

AI_MANIFEST_ATTACHMENT_NAME = 'manifest.xml'  # named as MIME attachment

class AILog:

    """

        Class AILog: Logging service

        Description: Provides logging capabilities for AI service choosing

                     and AI service discovery engines.

    """

    # list of implemented logging levels

    AI_DBGLVL_NONE = 0

    AI_DBGLVL_EMERG = 1

    AI_DBGLVL_ERR = 2

    AI_DBGLVL_WARN = 3

    AI_DBGLVL_INFO = 4

    def __init__(self, logid="AI", logfile=system_temp_path("ai_sd_log"),

                 debuglevel=AI_DBGLVL_WARN):

        self.log_file = logfile

        self.logid = logid

        self.dbg_lvl_current = debuglevel

        self.fh_log = None

        # list of prefixes displayed for particular logging levels

        self.log_prefix = {AILog.AI_DBGLVL_EMERG: "!",

            AILog.AI_DBGLVL_ERR: "E", AILog.AI_DBGLVL_WARN: "W",

            AILog.AI_DBGLVL_INFO: "I"}

        # default logging level

        self.dbg_lvl_default = AILog.AI_DBGLVL_INFO

        # if provided, open log file in append mode

        if self.log_file is not None:

            try:

                self.fh_log = open(self.log_file, "a+")

            except IOError:

                self.fh_log = None

    def set_debug_level(self, level):

        """

            Set default logging level

                level - new logging level

        """

        if level in self.log_prefix:

            self.dbg_lvl_current = level

    def get_debug_level(self):

        """Return current debug level"""

        return self.dbg_lvl_current

    def post(self, level, msg_format, * msg_args):

        """

            Post logging message

                level - logging level

                msg - message to be logged

                msg_args - message parameters

        """

        if level not in self.log_prefix:

            return

        if level > self.dbg_lvl_current:

            return

        timestamp = time.strftime("%m/%d %H:%M:%S", time.gmtime())

        log_msg = "<%s_%s %s> " % (self.logid, self.log_prefix[level],

                                   timestamp)

        if len(msg_args) == 0:

            log_msg += msg_format

        else:

            log_msg += msg_format % msg_args

        # post message to console

        print log_msg

        # post message to file

        if self.fh_log is not None:

            self.fh_log.write(log_msg + '\n')

        return

#

# AI service choosing logging service

#

AIGM_LOG = AILog("AISC")

def ai_exec_cmd(cmd):

    """     Description: Executes provided command using subprocess.Popen()

                         method and captures its stdout & stderr.

                         stderr is captured for debugging purposes

            Parameters:

                cmd - Command to be executed

            Returns:

                captured stdout from 'cmd'

                return code - 0..success, -1..failure

    """

    AIGM_LOG.post(AILog.AI_DBGLVL_INFO, "cmd:" + cmd)

    try:

        cmd_popen = Popen(cmd, shell=True, stdout=PIPE)

        (cmd_stdout, cmd_stderr) = cmd_popen.communicate()

    except OSError:

        AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                      "Popen() raised OSError exception")

        return None, -1

    except ValueError:

        AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                      "Popen() raised ValueError exception")

        return None, -1

    # capture output of stderr for debugging purposes

    if cmd_stderr is not None:

        AIGM_LOG.post(AILog.AI_DBGLVL_WARN,

                      " stderr: %s", cmd_stderr)

    # check if child process terminated successfully

    if cmd_popen.returncode != 0:

        AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                      "Command failed: ret=%d", cmd_popen.returncode)

        return None, -1

    return cmd_stdout, 0

class AICriteria:

    """ Class: AICriteria - base class for holding/manipulating AI criteria

    """

    def __init__(self, criteria=None):

        self.criteria = criteria

    def get(self):

        """ return criteria value

        """

        return self.criteria

    def is_known(self):

        """ check if information requried by criteria is available

        """

        return self.criteria is not None

class AICriteriaHostname(AICriteria):

    """ Class: AICriteriaHostname - class for obtaining/manipulating 'hostname'

        criteria

    """

    def __init__(self):

        AICriteria.__init__(self, socket.gethostname())

class AICriteriaArch(AICriteria):

    """ Class: AICriteriaArch class - class for obtaining/manipulating

        'architecture' criteria

    """

    client_arch = None

    def __init__(self):

        if AICriteriaArch.client_arch:

            AICriteria.__init__(self, AICriteriaArch.client_arch)

            return

        cmd = "/usr/bin/uname -m"

        client_arch, ret = ai_exec_cmd(cmd)

        if ret != 0 or client_arch == "":

            AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                          "Could not obtain machine architecture")

            AICriteriaArch.client_arch = None

        else:

            AICriteriaArch.client_arch = client_arch.strip()

        AICriteria.__init__(self, AICriteriaArch.client_arch)

class AICriteriaPlatform(AICriteria):

    """ Class: AICriteriaPlatform class - class for obtaining/manipulating

        'platform' criteria

    """

    client_platform = None

    def __init__(self):

        if AICriteriaPlatform.client_platform:

            AICriteria.__init__(self,

                                 AICriteriaPlatform.client_platform)

            return

        cmd = "/usr/bin/uname -i"

        AICriteriaPlatform.client_platform, ret = ai_exec_cmd(cmd)

        if ret != 0 or AICriteriaPlatform.client_platform == "":

            AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                          "Could not obtain machine platform")

        else:

            AICriteriaPlatform.client_platform = \

                AICriteriaPlatform.client_platform.strip()

        AICriteria.__init__(self, AICriteriaPlatform.client_platform)

class AICriteriaCPU(AICriteria):

    """ Class: AICriteriaCPU - class for obtaining/manipulating

        'processor type' criteria

    """

    client_cpu = None

    def __init__(self):

        if AICriteriaCPU.client_cpu:

            AICriteria.__init__(self, AICriteriaCPU.client_cpu)

            return

        cmd = "/usr/bin/uname -p"

        AICriteriaCPU.client_cpu, ret = ai_exec_cmd(cmd)

        if ret != 0 or AICriteriaCPU.client_cpu == "":

            AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                          "Could not obtain processor type")

        else:

            AICriteriaCPU.client_cpu = \

                AICriteriaCPU.client_cpu.strip()

        AICriteria.__init__(self, AICriteriaCPU.client_cpu)

class AICriteriaMemSize(AICriteria):

    """ Class: AICriteriaMemSize class - class for obtaining/manipulating

        'physical memory size' criteria, value is in MB

    """

    client_mem_size = None

    client_mem_size_initialized = False

    def __init__(self):

        if AICriteriaMemSize.client_mem_size_initialized:

            AICriteria.__init__(self,

                                 AICriteriaMemSize.client_mem_size)

            return

        AICriteriaMemSize.client_mem_size_initialized = True

        cmd = "/usr/sbin/prtconf -vp | /usr/bin/grep '^Memory size: '"

        client_mem_info, ret = ai_exec_cmd(cmd)

        if ret != 0 or client_mem_info == "":

            AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                          "Could not obtain memory size")

            AICriteriaMemSize.client_mem_size = None

            AICriteria.__init__(self)

            return

        (client_mem_size, client_mem_unit) = client_mem_info.split()[2:]

        client_mem_size = long(client_mem_size)

        AIGM_LOG.post(AILog.AI_DBGLVL_INFO,

                      "prtconf(1M) reported: %ld %s", client_mem_size,

                      client_mem_unit)

        if client_mem_size == 0 or client_mem_unit == "":

            AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                          "Could not obtain memory size")

            AICriteriaMemSize.client_mem_size = None

            AICriteria.__init__(self)

            return

        if client_mem_unit == "Kilobytes":

            client_mem_size /= 1024

        elif client_mem_unit == "Gigabytes":

            client_mem_size *= 1024

        elif client_mem_unit == "Terabytes":

            client_mem_size *= 1024 * 1024

        elif client_mem_unit != "Megabytes":

            AIGM_LOG.post(AILog.AI_DBGLVL_WARN,

                          "Unknown mem size units %s", client_mem_unit)

            client_mem_size = 0

        AICriteriaMemSize.client_mem_size = repr(client_mem_size).rstrip('L')

        AICriteria.__init__(self, AICriteriaMemSize.client_mem_size)

class AICriteriaNetworkInterface(AICriteria):

    """ Class: AICriteriaNetworkInterface class - class for

        obtaining/manipulating information about network interface -

        this criteria is currently private and not exposed to the server

    """

    network_iface = None

    ifconfig_iface_info = None

    network_iface_initialized = False

    def __init__(self):

        AICriteria.__init__(self)

        # initialize class variables only once

        if AICriteriaNetworkInterface.network_iface_initialized:

            return

        AICriteriaNetworkInterface.network_iface_initialized = True

        #

        # Obtain network interface name, which will be queried in next

        # step in order to obtain required network parameters

        #

        # Search for the first interface, which is UP - omit loopback

        # interfaces. Then use ifconfig for query the information about

        # that interface and store the result.

        #

        cmd = "/usr/sbin/ifconfig -au | /usr/bin/grep '[0-9]:' " \

            "| /usr/bin/grep -v 'LOOPBACK'"

        AICriteriaNetworkInterface.network_iface, ret = ai_exec_cmd(cmd)

        if ret != 0:

            AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                          "Could not obtain name of valid network interface")

            AICriteriaNetworkInterface.network_iface = None

        else:

            AICriteriaNetworkInterface.network_iface = \

                AICriteriaNetworkInterface.network_iface.split(':')[0]

            AIGM_LOG.post(AILog.AI_DBGLVL_INFO,

                          "Network interface obtained: %s",

                          AICriteriaNetworkInterface.network_iface)

            #

            # Collect all available information about network interface

            #

            cmd = "/usr/sbin/ifconfig %s" % \

                AICriteriaNetworkInterface.network_iface

            AICriteriaNetworkInterface.ifconfig_iface_info, ret = \

                ai_exec_cmd(cmd)

            if ret != 0 or \

               AICriteriaNetworkInterface.ifconfig_iface_info == "":

                AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                              "Could not obtain information about "

                              "network interface %s",

                              AICriteriaNetworkInterface.network_iface)

                AICriteriaNetworkInterface.ifconfig_iface_info = None

class AICriteriaMAC(AICriteriaNetworkInterface):

    """ Class: AICriteriaMAC - class for obtaining/manipulating

        information about client MAC address

    """

    client_mac = None

    client_mac_initialized = False

    def __init__(self):

        AICriteriaNetworkInterface.__init__(self)

        # initialize class variables only once

        if AICriteriaMAC.client_mac_initialized:

            AICriteria.__init__(self, AICriteriaMAC.client_mac)

            return

        AICriteriaMAC.client_mac_initialized = True

        if AICriteriaNetworkInterface.ifconfig_iface_info is None:

            AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                          "Could not obtain MAC address")

        else:

            AICriteriaMAC.client_mac = AICriteriaNetworkInterface. \

                ifconfig_iface_info.split("ether", 1)

            if len(AICriteriaMAC.client_mac) < 2:

                AIGM_LOG.post(AILog.AI_DBGLVL_ERR,

                              "Could not obtain client MAC address")

                AICriteriaMAC.client_mac = None

            else:

                AICriteriaMAC.client_mac = AICriteriaMAC.\

                    client_mac[1].strip().split()[0].strip()

                #

                # remove ':' and pad with '0's

                #

                # This step makes sure that the criteria are

                # passed to the server in the format which

                # server can understand. This is just an interim

                # solution.

                #

                # For longer term, all criteria should be

                # passed to the server in native format letting

                # the server side control the process of

                # conversion.

                #

                client_mac_parts = \

                    AICriteriaMAC.client_mac.split(":")

                AICriteriaMAC.client_mac = "%s%s%s%s%s%s" % \

                    (client_mac_parts[0].zfill(2),

                     client_mac_parts[1].zfill(2),

                     client_mac_parts[2].zfill(2),

                     client_mac_parts[3].zfill(2),

                     client_mac_parts[4].zfill(2),

                     client_mac_parts[5].zfill(2))

                AIGM_LOG.post(AILog.AI_DBGLVL_INFO,

                              "Client MAC address: %s",

                              AICriteriaMAC.client_mac)

        AICriteria.__init__(self, AICriteriaMAC.client_mac)

class AICriteriaIP(AICriteriaNetworkInterface):

    """ Class: AICriteriaIP class - class for obtaining/manipulating

        information about client IP address

    """

    client_ip = None

    client_ip_string = None

    client_ip_initialized = False

    def __init__(self):

        AICriteriaNetworkInterface.__init__(self)

        # initialize class variables only once