#!/usr/bin/python
# Security Hardening upgrade script
import logging
import os
import re
import time
import sys
import syslog
import isi.hardening.util as util
import errno
from isi.app.lib import safelockfile

import isi.config as iconf
from isi.app.lib import safelockfile
import isi.sys.version as sysver
import isi.app.lib.upgrade_api as uapi

IFS_BACKUP_PATH = "/ifs/.ifsvar/tmp"
LOG_FILE = os.path.join(IFS_BACKUP_PATH, "hardening-upgrade.log")
HARD_UPGRADE_FILE = os.path.join(IFS_BACKUP_PATH, "hardening-upgraded")
logger = logging.getLogger("hardening_upgrade")
HTTPD_CONF= "/usr/local/apache2/conf/httpd.conf"
WEBUI_CONF = "/etc/mcp/templates/webui_httpd.conf"
DELTA = 2

def update_httpd_config():
    conf_fname = HTTPD_CONF

    conf_file = open(conf_fname)
    conf = conf_file.readlines()
    conf_file.close()

    lockfile = safelockfile('/tmp/apache2.py.lock', 'w')
    config = open(conf_fname + '.isi', "w")

    token_re = re.compile(r'^Listen\s+.*')
    found = False
    for line in conf:
        line = line.rstrip()
        tokens = token_re.findall(line)
        if tokens:
            if found == True:
                print "SKIP: " + line
                continue
            print "Found : " +line
            line = "Listen 80";
            found = True
        config.write('%s\n' % line)

    config.flush()
    os.fsync(config.fileno())
    config.close()

    os.chmod(conf_fname + '.isi', 0640)
    os.rename(conf_fname + '.isi', conf_fname)
    lockfile.close()

"""
    Lower versions of OneFS are if in hardened will have mod_proxy
    Module unloaded as a part of STIG item isi_WA00520_A22. This breaks the
    WebHDFS post Kanagawa release, this function reverts the change done and
    re-loads mod_proxy module.
    @Bug: 230896
"""
def load_mod_proxy():
    conf_fname = WEBUI_CONF
    conf_file = open(conf_fname)
    old_conf = conf_file.readlines()
    conf_file.close()
    lockfile = safelockfile('/tmp/apache2.py.lock', 'w')
    pattern = "LoadModule proxy_module modules/mod_proxy.so"
    search_ptrn = "LoadModule proxy_fcgi_module modules/mod_proxy_fcgi.so"
    if pattern + "\n" in old_conf:
        return
    config = open(conf_fname + '.isi', "w")
    for line in old_conf:
        if search_ptrn == line.rstrip():
            config.write('%s\n' % pattern)
        config.write('%s' % line)
    config.close()
    os.rename(conf_fname + '.isi', conf_fname)
    lockfile.close()

def main():
    NodeID = "Node %d" % iconf.getNode()['node id']
    try:
        logger.setLevel(logging.DEBUG)
        fh = logging.FileHandler(LOG_FILE, 'a')
        fh.setLevel(logging.DEBUG)
        logger.addHandler(fh)
    except EnvironmentError, e:
                syslog.syslog(syslog.LOG_NOTICE,
                              "Error initializing logging "
                              "in hardening-upgrade script, %s" % e)

    if os.path.isfile("/ifs/.ifsvar/cluster_hardened"):
	logger.info("%s: Found hardening preupgrade check flag" % NodeID)
        clusterwide_command = False
        if not os.path.isfile("/etc/ifs/isi_hardening_upgrade_already_ran"):
            open("/etc/ifs/isi_hardening_upgrade_already_ran", 'a').close()
            logger.info("%s: Created /etc/ifs/isi_hardening_upgrade_already_ran" %NodeID)
        else:
	    logger.info("%s: hardening-upgrade has already run on this node. Continuing." % NodeID)
            return 0

        try:
            update_httpd_config()
        except Exception, e:
            syslog.syslog(syslog.LOG_ERR,
                          "Error during updating the"
                          " httpd config file"
                          " %s:%s" % (HTTPD_CONF,str(e)))
            return 1
        try:
            from_version = uapi.upgrading_from_ver()
            if from_version < sysver.KANAGAWA_VERSION:
                logger.info("Running Upgrade from Pre-kanagawa release")
                load_mod_proxy()
            else:
                logger.info("Running Upgrade from lower build of kanagawa release")
        except Exception, e:
            syslog.syslog(syslog.LOG_ERR,
                          "Error during updating the"
                          " webui_httpd.conf file"
                          " %s:%s" % (WEBUI_CONF, str(e)))
        try:
            os.chmod(LOG_FILE, 0640)
        except OSError, e:
            syslog.syslog(syslog.LOG_NOTICE,
                          "Error chmod'ing %s (errno: %d)" \
                          % (LOG_FILE, e.errno))

        node_time = time.time()

        # We need to block all other nodes from continuing until
        # we've finished the upgrade
        try:
            sentry = safelockfile(HARD_UPGRADE_FILE, 'w')
        except EnvironmentError, e:
            logger.error("%s: %s: Error during locking in hardening-upgrade" \
                         " script, %s" % (NodeID, time.ctime(), e))
            return 1

        logger.info("%s: Calling Hardening Engine Components now..." %NodeID)
        try:
        #If HARDENING_ENGINE_UPGRADE_FILE is not present then
        # 1) Create HARDENING_ENGINE_UPGRADE_FILE
        # 2) Call run_clusterwide_command().
        # So only one node in cluster will execute this function
            if not os.path.isfile(util.HARDENING_ENGINE_UPGRADE_FILE):

                logger.info("%s: %s: %s is not present" %
                    (NodeID, time.ctime(), util.HARDENING_ENGINE_UPGRADE_FILE ))

                util.execute_command("rm -rf /ifs/.ifsvar/CHE");

                if not os.path.exists(util.CHE_BASE_PATH):
                    os.mkdir(util.CHE_BASE_PATH)
                    logger.info("%s: %s: %s is created" %
                        (NodeID, time.ctime(), util.CHE_BASE_PATH ))
                if not os.path.isdir(util.CHE_CLI_DIR):
                    try:
                        os.makedirs(util.CHE_CLI_DIR)
                        os.chmod(util.CHE_CLI_DIR, 0777)
                    except OSError, excpt:
                        print str(excpt)
                        return 1

                open(util.HARDENING_ENGINE_UPGRADE_FILE, 'a').close()

                logger.info("%s: %s: %s is created" %
                    (NodeID, time.ctime(), util.HARDENING_ENGINE_UPGRADE_FILE ))
                clusterwide_command = True
                CHE_ces_cmd = "python " + util.CHE_BIN_PATH \
                    + "/check_expected_state.py -n " \
                    + util.H_UPGRADE_CONFIG_PATH + " -u " + " -o upgrade" + " >> /dev/null 2>&1 "
                CHE_apply_cmd = "python " + util.CHE_BIN_PATH + "/apply.py -n " \
                    + util.H_UPGRADE_CONFIG_PATH + " -u " + " >> /dev/null 2>&1 "
            else:
                CHE_ces_cmd = "python " + util.CHE_BIN_PATH + "/check_expected_state.py -n " \
                    + util.H_UPGRADE_CONFIG_PATH + " -o upgrade" + " >> /dev/null 2>&1 "
                #Get Hardening File mod_time
                file_mod_time = os.stat(util.HARDENING_ENGINE_UPGRADE_FILE).st_mtime

                #Get node waiting time, file mod time delta
                waiting_delta = round((int(node_time) - file_mod_time)/60, 2)

                #waiting_delta is greater than DELTA then it is Rolling Upgrade
                #else it is simulteneous upgrade
                if waiting_delta > DELTA:
                    logger.info("%s: %s: Rolling Upgrade" % (NodeID, time.ctime()))
                    logger.info("%s : Node_time : %s , File_mode_Time %s, Waiting Delta %s" %
                        (NodeID, node_time, file_mod_time, waiting_delta))
                    CHE_apply_cmd = "python " + util.CHE_BIN_PATH + "/apply.py -n " \
                        + util.H_UPGRADE_CONFIG_PATH + " -u " + " >> /dev/null 2>&1 "
                    #This is to change the file modification time.
                    cmd = "touch " + util.HARDENING_ENGINE_UPGRADE_FILE
                    util.execute_command(cmd)
                else:
                    logger.info("%s: %s: Simulteneous Upgrade" % (NodeID, time.ctime()))
                    logger.info("%s : Node_time : %s , File_mode_Time %s, Waiting Delta %s" %
                        (NodeID, node_time, file_mod_time, waiting_delta))
                    CHE_apply_cmd = "python " + util.CHE_BIN_PATH + "/apply.py -n " \
                        + util.H_UPGRADE_CONFIG_PATH + " >> /dev/null 2>&1 "

            sentry.close()
            success = True
            try:
                if os.path.isfile("/var/log/boxend.log"):
                    os.chmod("/var/log/boxend.log", 0640)
                logger.info("%s: %s: Calling Check Expected State" %
                    (NodeID, time.ctime()))
                logger.info("%s: %s: Running check expected command: %s" %
                    (NodeID, time.ctime(), CHE_ces_cmd))
                CHE_ces_ret = util.execute_command(CHE_ces_cmd)
                if CHE_ces_ret == 0:
                    logger.info("%s: %s: Check Expected State completed successfully" %
                        (NodeID, time.ctime()))
                    success = True
                else:
                    logger.error("%s: %s: Check Expected State failed" %
                        (NodeID, time.ctime()))
                    success = False
            except Exception, e:
                success = False
                logger.error("%s: %s: Error during Check Expected State run %s (errno: %d)" %
                             NodeID, (time.ctime(), LOG_FILE, e.errno))

            # If Check Expected State succeeded with no conflicts
            # Proceed to apply

            if success:
                try:
                    if not os.path.isfile(util.NODE_INFO_PATH):
                        open(util.NODE_INFO_PATH, 'a').close()
                    logger.info("%s: %s: Calling CHE Apply" %
                        (NodeID, time.ctime()))
                    logger.info("%s: %s: Running Hardening Engine Apply command: %s" %
                        (NodeID, time.ctime(), CHE_apply_cmd))
                    CHE_apply_ret = util.execute_command(CHE_apply_cmd)
                    if CHE_apply_ret != 0:
                        logger.error("%s: %s: Error during Hardening Engine Apply run" %
                        (NodeID, time.ctime()))
                        success = False
                    else:
                        logger.info("%s: %s: Hardening Engine Apply completed successfully" %
                        (NodeID, time.ctime()))
                        success = True
                except Exception, e:
                    success = False
                    logger.error("%s: %s: Error during Hardening Engine Apply %s (errno: %d)" %
                                 (NodeID, time.ctime(), LOG_FILE, e.errno))

            # isi auth command fails due to some issue at bootime
            if success and clusterwide_command:
                util.execute_command("/usr/libdata/patchmgr/bg-hardening-upgrade &")

        except Exception, e:
            success = False
            logger.error("%s: %s: Error during Hardening Upgrade %s (errno: %d)" %
                         (NodeID, time.ctime(), LOG_FILE, e.errno))
            sentry.close()
        if success:
            logger.info("%s: %s: Hardening Upgrade completed successfully" %
                         (NodeID, time.ctime()))
            return 0
        else:
            logger.error("%s: %s: Hardening Upgrade failed" %
                         (NodeID, time.ctime()))
            return 1
    else:
        logger.info("%s: No hardening preupgrade flag found: no hardening upgrade is necessary." %NodeID)
        return 0

if __name__ == "__main__":
    try:
        sys.exit(main())
    except Exception, e:
        syslog.syslog(syslog.LOG_ERR,
                      "Error running hardening-upgrade script, %s" % e)



