#!/usr/bin/python
# Riptide NLM upgrade script

import logging
import os
import sys
import syslog
import getopt

CLI_PATH = "/usr/local/share/CLI/"
sys.path.append(CLI_PATH)

import isi.config as iconf
import isi.gconfig as gcfg
import isi.app.lib.upgrade_api as uapi
import isi.app.lib.cluster
from isi.app.lib import safelockfile
from isi.app.lib.confParser import ConfParser

NFS_DEFAULT_PATH = "/ifs/.ifsvar/modules/nfs"
LOG_FILE = os.path.join(NFS_DEFAULT_PATH, "riptide-nlm-upgrade.log")
NLM_UPGRADE_LOCKFILE = os.path.join(NFS_DEFAULT_PATH, "riptide-nlm-upgraded")
NLM_UPGRADED_FILE = os.path.join(NFS_DEFAULT_PATH, "riptide-nlm-upgrade-complete")

# sysctl.conf defines
SYSCTL_CONF = "/etc/mcp/override/sysctl.conf"
SYSCTL_WATCH = '/etc/mcp/sys/files/nlm-riptide-config-upgrade'
MAX_COMMIT_RETRIES = 100

logger = logging.getLogger("riptide_nlm_upgrade")

LWREG_PREFIX = 'registry.Services.lwio.Parameters.Drivers.nfs.nlm'
SYSCTL_PREFIX = 'sysctls.entries.'

NLM_LWREG_CONVERSION_DICT = {
    "vfs.nlm.quarantine_time":"QuarantineTimeSec",
    "vfs.nlm.granted_msg_delay":"GrantedMsgDelayUSec",
    "vfs.nlm.granted_msg_delay_count":"GrantedMsgDelayCount",
    "vfs.nlm.estale_retry_delay_count":"ESTALERetryDelayCount",
    "vfs.nlm.bind_resvport":"BindResvPort",
    "vfs.nlm.transient_error_disconnect":"TransientErrorDisconnect",
    "vfs.nlm.unlock_error_disconnect":"UnlockErrorDisconnect",
    "vfs.nlm.skip_access_checks":"SkipAccessChecks",
    "vfs.nlm.set_raddr_hint":"SetRaddrHint",
    "debug.nlm_rpc_timeo":"CallbackTimeout",
}


def add_config(main_cfg, name, value):
    if name in NLM_LWREG_CONVERSION_DICT.keys():
        try:
            value = long(value)
        except ValueError:
            pass
        try:
            main_cfg.write(LWREG_PREFIX+NLM_LWREG_CONVERSION_DICT[name], value)
        except TypeError:
            logger.error("Failed to migrate setting %s." % name)
        else:
            logger.info("Migrated setting %s." % name)


def sysctl_upgrade_conf(main_cfg):
    conf = ConfParser(SYSCTL_CONF)

    for sysctl in conf.values.iteritems():
        name = sysctl[0]
        value = sysctl[1]

        add_config(main_cfg, name, value)

    logger.info("Completed settings migration (1/2)")


def sysctl_upgrade_gc(main_cfg):
    old_sysctls = main_cfg.read(SYSCTL_PREFIX)

    for sysctl in old_sysctls:
        name = sysctl['name']
        value = sysctl['value']

        add_config(main_cfg, name, value)

    logger.info("Completed settings migration (2/2)")

def get_gcfg_ctx(tree):
    return gcfg.open(tree).ctx_new()

# Migrate sysctl.conf and gconfig sysctl tree to registry
def sysctl_upgrade():
    for x in xrange(MAX_COMMIT_RETRIES):
        try:
            main_cfg = get_gcfg_ctx(gcfg.gcfg_main)
            sysctl_upgrade_conf(main_cfg)
            sysctl_upgrade_gc(main_cfg)
            main_cfg.commit()
            break
        except gcfg.RecoverableCommitError:
            logger.info("Retrying sysctl upgrade commit (%d)." % x)
    # Ran out of retries
    else:
        raise RuntimeError("NLM upgrade could not commit gconfig")

def lock_sysctl_reset():
    sysctl_name = 'efs.advlock.failover.protection_level'
    default_lock_protection = '2'
    for store in ('conf', 'gcfg'):
        current_protection = isi.app.lib.cluster.cluster_get_sysctl(
            sysctl_name,
            store)
        if current_protection != default_lock_protection:
            isi.app.lib.cluster.cluster_set_sysctl(
                sysctl_name,
                default_lock_protection,
                store)
            logger.info('Reset lock protection level to default value of'
                        ' %s' % default_lock_protection)


def get_options():
    default_options = {'--incremental'    : False,
                       '--update-config'  : True,
                       '--force'          : False,
                       '--cleanup'        : False}

    try:
        opts = getopt.getopt(sys.argv[1:], '',
                             ['incremental',
                              'update-config',
                              'force',
                              'cleanup'])
        if (len(opts) and len(opts[0])):
            # If any options provided, all options default to false unless set
            options = {'--incremental'    : False,
                       '--update-config'  : False,
                       '--force'          : False,
                       '--cleanup'        : False}
            for opt in opts[0]:
                if opt[0] in options.keys():
                    options[opt[0]] = True
        else:
            options = default_options
    except Exception, e:
        logger.info("Couldn't determine arguments (%s), running with defaults" %
                    str(e))
        options = default_options

    # We should never get a cleanup call before running successfully at
    # least once. If this happens, run the upgrade to be safe.
    if (options.get('--cleanup', False)
        and not os.path.exists(NLM_UPGRADED_FILE)
        and not options.get('--force', False)):
        logger.warning("Received unexpected cleanup request, running upgrade "
                       "before cleaning.")
        options = default_options
        options['--cleanup'] = True

    return options


# Only drop our success file if this was the final script run
def should_drop_file(options):
    # Always drop on simultaneous upgrades
    if not options.get('--incremental', False):
        return True
    # There is a rolling upgrade still in progress, so we may need to update
    else:
        return False


def run_upgrade(options):
    success = True
    upgrade_funcs = []

    lock_sysctl_reset()
    if options.get('--update-config', True):
        try:
            sysctl_upgrade()
            msg = "Upgrade was successful"
            if should_drop_file(options):
                print >> file(NLM_UPGRADED_FILE, 'w'), msg
                os.chmod(NLM_UPGRADED_FILE, 0640)
            remove_sysctl_watch()
            logger.info("Upgrade was succesful")
        except RuntimeError, e:
            logger.error("Error upgrading nlm sysctls: %s" % str(e))
            success = False

    return success


def remove_sysctl_watch():
    try:
        os.remove(SYSCTL_WATCH)
        logger.info("Removed nlm sysctl watch %s" % SYSCTL_WATCH)
    except OSError, err:
        logger.error("Unable to delete nlm sysctl watch %s (%s)" % (SYSCTL_WATCH, str(err)))


def main():
    success = False
    wait_sentry = None
    feature = 'config'

    try:
        lnn = "Node %d -" % iconf.getNode()['node id']
        lfmt = lnn + "%(asctime)s - %(levelname)s - %(message)s"
        logger.setLevel(logging.INFO)
        fh = logging.FileHandler(LOG_FILE, 'a')
        fh.setLevel(logging.INFO)
        fh.setFormatter(logging.Formatter(lfmt))
        logger.addHandler(fh)

    except EnvironmentError, e:
        syslog.syslog(syslog.LOG_NOTICE,
                      "Error running nlm upgrade script: %s" % e)
        return 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("NLM upgrade started.")
    options = get_options()

    if options.get('--cleanup', False):
        remove_sysctl_watch()
        return 0

    if options.get('--incremental', False):
        # Already done with the upgrade, just bail out
        if (uapi.disk_enabled(uapi.RIPT_NLM)
            and not options.get('--force', False)):
            logger.info("NLM upgrade has already occurred successfully.")
            return 0

        # First, try to get the waiter lock for each relevant portion to be
        # upgraded. If someone is already in line don't bother, as we can't do
        # anything more than they will after they get a turn
        lockpath = os.path.join(NFS_DEFAULT_PATH,
                                'ript-nlm-upgraded.wait')

        if options.get('--update-config', False):
            try:
                wait_sentry = safelockfile(lockpath, 'w', blocking=False)
            except IOError, e:
                if (e.errno == os.errno.EACCES or
                    e.errno == os.errno.EAGAIN):
                    # Already taken care of, don't bother
                    logger.info("Config update already in progress")
                    options['--update-config'] = False
                else:
                    logger.error('Error while acquiring waiter lock: %s' % str(e))
                    return 1

        else:
            logger.info("No work to be done")
            return 0

    # Block on the worker lock
    try:
        sentry = safelockfile(NLM_UPGRADE_LOCKFILE, 'w')
    except EnvironmentError, e:
        syslog.syslog(syslog.LOG_NOTICE,
                      "Error running nlm upgrade script: %s" % e)
        if wait_sentry:
            wait_sentry.close()
        if sentry:
            sentry.close()
        return 1

    # Check if we're already done
    if (not options.get('--incremental', False)
        and os.path.exists(NLM_UPGRADED_FILE)
        and not options.get('--force', False)):
        logger.info("NLM upgrade has already occurred successfully.")
        remove_sysctl_watch()
        if wait_sentry:
            wait_sentry.close()
        if sentry:
            sentry.close()
        return 0

    if wait_sentry:
        wait_sentry.close()

    success = run_upgrade(options)

    if sentry:
        sentry.close()

    if success:
        return 0
    else:
        return 1


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