#!/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)
        and not os.path.isfile("/etc/ifs/isi_hardening_upgrade_already_ran")):
        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
        try:
            # Acquire apply lock
            lock_status = util.acquire_lock('apply')

            if lock_status != 0:
                logger.error("Unable to acquire apply lock")
                return 1

            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 = util.execute_command(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 = util.execute_command(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


        except Exception as exception:
            logger.error("Exception occured in join process %s" % exception)

        finally:
            #realse lock
            util.release_lock()

    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)
