#!/usr/bin/python
# Niijima SMB upgrade script

import os
import syslog
import time
import logging
import subprocess
import shutil

import sys

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

from ctypes import *
smb_upgrade_lib = cdll.LoadLibrary('/usr/lib/libisi_smb_upgrade.so')

IFS_LOG_PATH = "/ifs/.ifsvar/tmp"

BASE_NAME = "smb-zones-upgrade"
LOG_FILE = os.path.join(IFS_LOG_PATH, BASE_NAME + ".log")

SMB_UPGRADE_LOCK_FILE = os.path.join(IFS_LOG_PATH, BASE_NAME + ".lock")

class smb_upgrade:
    def __init__(self, logger, verbose, force):
        self.logger = logger
        self.verbose = verbose
        self.force = force

    def needs_upgrade(self):
        # Check if an upgrade is necessary
        nstat = sysver.Node_Status()
        pVer = nstat.get_previous_version()

        # This upgrade needs to run only if we're upgrading across NIIJIMA
        if pVer is not None and pVer < sysver.NIIJIMA_VERSION:
            return True

        return False

    def needs_rollback(self):
        # only rollback if we would upgrade
        return self.needs_upgrade()

    def upgrade(self, logger = None):
        ret = smb_upgrade_lib.smb_upgrade_niijima(c_char_p(LOG_FILE),
                                       c_bool(self.verbose),
                                       c_bool(self.force))
        if ret:
            raise Exception

    def rollback(self, logger = None):
        ret = smb_upgrade_lib.smb_rollback_niijima(c_char_p(LOG_FILE),
                                       c_bool(self.verbose),
                                       c_bool(self.force))
        if ret:
            raise Exception

def run_upgrade(name, logger, verbose, force):
    upgrade = name(logger, verbose, force)

    if not upgrade.needs_upgrade() and not force:
        return 0

    logger.info("Running smb upgrade")

    try:
        upgrade.upgrade(logger)
        logger.info("Successfully ran smb upgrade")
        return 0
    except Exception:
        syslog.syslog(syslog.LOG_ERR, "Error during smb upgrade - see " + LOG_FILE)
        logger.error("Error during smb upgrade - see " + LOG_FILE)
        return 1

def run_rollback(name, logger, verbose, force):
    upgrade = name(logger, verbose, force)

    if not upgrade.needs_rollback() and not force:
        return 0

    logger.info("Running smb rollback")

    try:
        upgrade.rollback(logger)
        logger.info("Successfully ran smb rollback")
        return 0
    except Exception:
        syslog.syslog(syslog.LOG_ERR, "Error during smb rollback - see " + LOG_FILE)
        logger.error("Error during smb rollback - see " + LOG_FILE)
        return 1

def setup_logger(verbose):
    lnn = "Node %d " % iconf.getNode()['node id']
    lfmt = lnn + "%(asctime)s - %(levelname)s - %(message)s"

    logger = logging.getLogger("niijima_smb_upgrade")
    logger.setLevel(logging.DEBUG)
    fh = logging.FileHandler(LOG_FILE, 'a')
    fh.setLevel(logging.DEBUG)
    fh.setFormatter(logging.Formatter(lfmt))
    logger.addHandler(fh)

    if verbose:
        ch = logging.StreamHandler(sys.stdout)
        ch.setFormatter(logging.Formatter(lfmt))
        logger.addHandler(ch)

    return logger

def main(argv):
    verbose = True
    force = False
    rollback = False
    help = False
    lock_file = None

    if len(argv) > 1:
        for i in range(1, len(argv)):
            if argv[i] == "-v":
                verbose = True
            elif argv[i] == "-f":
                force = True
            elif argv[i] == "-r":
                rollback = True
            elif argv[i] == "-h":
                help = True
            else:
                help = True

    if help:
        print \
            "Usage: " + argv[0] + " [-v|-f|-r|-h]\n" \
            "Upgrade SMB configuration to support per-zone settings\n" \
            "    -v:  Verbose output\n" \
            "    -f:  Force upgrade\n" \
            "    -r:  Do rollback\n" \
            "    -h:  Print usage message and exit"
        return 0

    # Set up a logger object
    logger = setup_logger(verbose)

    # We need to block all other nodes from continuing until we have finished
    # the upgrade or rollback
    try:
        lock_file = safelockfile(SMB_UPGRADE_LOCK_FILE, 'w')
    except EnvironmentError, e:
        syslog.syslog(syslog.LOG_NOTICE,
            "Error during smb upgrade - locking error, %s" % e)
        logger.error("Error during smb upgrade - locking error, %s" % e)
        return 1

    # Run the upgrade
    if not rollback:
        ret = run_upgrade(smb_upgrade, logger, verbose, force)
    else:
        ret = run_rollback(smb_upgrade, logger, verbose, force)

    lock_file.close()

    return ret

if __name__ == "__main__":
    sys.exit(main(sys.argv))
