#!/usr/bin/python
# Security Hardening script during node join
import logging
import os
import time
import sys
import syslog
import isi.hardening.util as util
import errno


JOIN_PATH = "/var/log"
LOG_FILE = os.path.join(JOIN_PATH, "hardening_join.log")
logger = logging.getLogger("hardening_join")
MAX_RETRIES = 10

def main():
    if util.is_cluster_hardened() and not os.path.isfile(util.HARDENING_INFO_PATH):
        if not os.path.isfile("/etc/ifs/isi_hardening_join_already_ran"):
            open("/etc/ifs/isi_hardening_join_already_ran", 'a').close()
        else:
            return 0
        retry = MAX_RETRIES
        while retry: 
            try:
                logger.setLevel(logging.DEBUG)
                fh = logging.FileHandler(LOG_FILE, 'a')
                fh.setLevel(logging.DEBUG)
                logger.addHandler(fh)
                break
            except EnvironmentError, e:
                syslog.syslog(syslog.LOG_NOTICE,
                              "Error during logging "
                              "in hardening-upgrade script, %s %d" % (e, (MAX_RETRIES - retry+1)))
                if retry == 1:
                    syslog.syslog(syslog.LOG_NOTICE, "Error: Exiting from hardening-upgrade script")
                    return 1
                time.sleep(5)
                retry = retry - 1
         

        try:
            os.chmod(LOG_FILE, 0640)
        except OSError, e:
            # log chmod errors and continue
            syslog.syslog(syslog.LOG_NOTICE,
                          "Error chmod'ing %s (errno: %d)" % (LOG_FILE, e.errno))

        logger.info("Calling Hardening Engine Components now...")

        CHE_ces_cmd = "python " + util.CHE_BIN_PATH + "/check_expected_state.py -n " \
                       + util.NON_H_JOIN_CONFIG_PATH + " >> /dev/null 2>&1 "
        CHE_apply_cmd = "python " + util.CHE_BIN_PATH + "/apply.py -n " \
                       + util.NON_H_JOIN_CONFIG_PATH + " >> /dev/null 2>&1 "

        try:
            CHE_ces_ret = os.system(CHE_ces_cmd)
            if CHE_ces_ret == 0:
                logger.info("%s: Check Expected State completed successfully"
                            % time.ctime())
                success = True
            else:
                logger.error("%s: Check Expected State failed" %
                             time.ctime())
                success = False
        except Exception, e:
            success = False
            logger.error("%s: Error during Check Expected State run %s (errno: %d)" %
                        (time.ctime(), LOG_FILE, e.errno))

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

        if success:
            try:
                CHE_apply_ret = os.system(CHE_apply_cmd)
                if CHE_apply_ret != 0:
                    logger.error("%s: Error during Hardening Engine Apply run" %
                                 time.ctime())
                    success = False
                else:
                    logger.info("%s: Hardening Engine Apply completed successfully" %
                    time.ctime())
                    success = True
            except Exception, e:
                success = False
                logger.error("%s: Error during Hardening Engine Apply %s (errno: %d)" %
                             (time.ctime(), LOG_FILE, e.errno))

        if success:
            logger.info("%s: Hardening completed successfully during join" %
                         time.ctime())
            return 0
        else:
            logger.error("%s: Hardening Upgrade failed during node join" %
                         time.ctime())
            return 1
    else:
        logger.info("No Hardening needed at the time of join.")
        return 0

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

