#!/usr/bin/env python
"""
name: pacenotify.py
description: receive cluster based messages via the alert mechanism and present
             a type of output for monitoring to parse and create alerts

Copyright 2017 Rackspace

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import os
import sys
import logging
import argparse
import subprocess
# python2 = ConfigParser, python3 = configparser
try:
    import ConfigParser as configparser
except:
    import configparser
# python-lxml is already required by pcs
import lxml.etree as etree

__version__ = "0.1.1"


class PaceNotify(object):
    """PaceNotify Class - receive messages from the cluster via alerts"""

    def __init__(self, args):
        """Standard initialization"""
        # internal defaults
        self.debug = False
        self.configfile = '/etc/pacewatcher.conf'
        self.logfile = '/var/log/pacewatcher/pacewatcher.log'

        # override via cmdline, cannot change config w/o restart
        if args.configfile:
            self.configfile = args.configfile
        # this will read the config, then apply cmdline args over it
        self.init_config(args)

        # these are placed into the env by Pacemaker when it alerts
        self.CRM_alert_desc = os.environ.get('CRM_alert_desc')
        self.CRM_alert_interval = os.environ.get('CRM_alert_interval')
        self.CRM_alert_kind = os.environ.get('CRM_alert_kind')
        self.CRM_alert_node = os.environ.get('CRM_alert_node')
        self.CRM_alert_rsc = os.environ.get('CRM_alert_rsc')
        self.CRM_alert_target_rc = os.environ.get('CRM_alert_target_rc')
        self.CRM_alert_task = os.environ.get('CRM_alert_task')
        self.CRM_alert_version = os.environ.get('CRM_alert_version')

        # we need to set this up now, as the logger needs a static node name
        self.localnode = self.local_node()
        # initialize our logger object
        self.logger = self.init_logger(self.logfile)

        # Get this resource for it's 'monitor' op 'on-fail'
        self.monitor_op = self._rsrc_opval(self.CRM_alert_rsc,
                                           'monitor', 'on-fail')
        self.logger.debug("Resource {} monitor op: {}".format(
                          self.CRM_alert_rsc, self.monitor_op))

        # respects the DEBUG flag in the object
        self.logger.debug("__init__ complete")

    def init_logger(self, logfile):
        """Logging format: same as syslog
        ex: Feb 01 12:34:56 mynode mydaemon: INFO mymessage
        """
        FMT = ('%(asctime)s {} %(name)s: %(levelname)s %(message)s'
               .format(self.localnode))
        logger = logging.getLogger('pacenotify')
        # default is append, another daemon writes to the log - explicit
        loghdl = logging.FileHandler(logfile, 'a')
        logfmt = logging.Formatter(fmt=FMT, datefmt='%b %e %H:%M:%S')
        loghdl.setFormatter(logfmt)
        logger.addHandler(loghdl)
        if self.debug:
            logger.setLevel(logging.DEBUG)
        else:
            logger.setLevel(logging.INFO)
        return logger

    def init_config(self, args):
        """Read in the given configfile"""
        # a missing config is not fatal, internal defaults used
        try:
            config = configparser.ConfigParser()
            config.read(self.configfile)

            # global to all daemons
            if config.has_option('pacewatcher', 'logfile'):
                self.logfile = config.get('pacewatcher', 'logfile')
            # unique to this daemon
            if config.has_option('pacenotify', 'debug'):
                self.timer = config.getboolean('pacenotify', 'debug')
        except:
            pass

        # this needs to be writable by 'hacluster'
        if args.logfile:
            self.logfile = args.logfile
        # this is for debug logging
        if args.debug:
            self.debug = args.debug

    def run_cmd(self, args):
        """Run any given command and return it's output"""
        try:
            p = subprocess.Popen(
                args,
                stdin=None,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                close_fds=True,
                universal_newlines=True
            )
            output, stderror = p.communicate(None)
            retval = p.returncode
        except OSError as e:
            # when p.communicate() fails neither variable is defined
            output = ''
            retval = 1
            if self.debug:
                print(e.strerror)

        return output, retval

    def _rsrc_opval(self, rsrc, opname, opkey):
        """Run cibadmin with xpath to get an op's key value"""
        opxpath = ('//primitive[@id="{}"]/operations/op[@name="{}"]'.format(
                   rsrc, opname))
        xml, retcode = self.run_cmd(["cibadmin", "--query", "--xpath",
                                     opxpath])

        # Ex: <op name="monitor" on-fail="ignore" ..."/>
        if retcode != 0:
            return ""
        try:
            oproot = etree.fromstring(xml)
            return oproot.get(opkey)
        except etree.XMLSyntaxError:
            return ""

    def local_node(self):
        """Return the cluster local node name of this machine"""
        node, retcode = self.run_cmd(["crm_node", "-n"])

        if retcode != 0:
            # we cannot use self.logger.critical() here as it uses
            # the 'node' variable we're trying to determine
            return "(unknown)"
        else:
            return node.strip()

    def alert_type(self):
        """Determine what type of alert is being"""
        self.logger.debug('CRM_alert_kind={}'.format(self.CRM_alert_kind))

        if self.CRM_alert_version is None:
            raise RuntimeError("Pacenotify.py needs to be run by Pacemaker"
                               " version 1.1.15 or later")

        if self.CRM_alert_kind == "node":
            self.node_msg()
        elif self.CRM_alert_kind == "fencing":
            self.fence_msg()
        elif self.CRM_alert_kind == "resource":
            if self.CRM_alert_desc != "Cancelled":
                self.resource_msg()
        else:
            self.other_msg()

    def resource_msg(self):
        """Format and then log resource based alerts"""
        msg = '{} {} {} {}'.format(self.CRM_alert_rsc,
                                   self.CRM_alert_task,
                                   self.CRM_alert_desc,
                                   self.CRM_alert_target_rc)

        # Decision tree how to log priority
        if self.CRM_alert_desc != "ok":
            if self.monitor_op != "ignore":
                self.logger.critical(msg)
            else:
                self.logger.warning(msg)
        else:
            if self.CRM_alert_task == "stop":
                self.logger.warning(msg)
            else:
                self.logger.info(msg)

    def fence_msg(self):
        """Format and then log fencing based alerts"""
        msg = '{}'.format(self.CRM_alert_desc)
        self.logger.critical(msg)

    def node_msg(self):
        """Format and then log node based alerts"""
        msg = 'Node {} is now {}'.format(self.CRM_alert_node,
                                         self.CRM_alert_desc)
        if self.CRM_alert_desc == "lost":
            self.logger.critical(msg)
        else:
            self.logger.info(msg)

    def other_msg(self):
        """Format and then log none standard alerts"""
        msg = 'Unhandled {} alert'.format(self.CRM_alert_kind)
        if self.monitor_op != "ignore":
            self.logger.critical(msg)
        else:
            self.logger.warning(msg)


def parse_args():
    """Argument parsing routine"""
    parser = argparse.ArgumentParser(description='PaceNotify')
    parser.add_argument('--version',
                        action='version',
                        version=__version__,
                        help='Display the version')
    parser.add_argument('-c',
                        '--configfile',
                        required=False,
                        dest='configfile',
                        help='Configuration file to read')
    parser.add_argument('-l',
                        '--logfile',
                        required=False,
                        dest='logfile',
                        help='Name of logfile to write')
    parser.add_argument('-d',
                        '--debug',
                        action='store_true',
                        required=False,
                        dest='debug',
                        help='Log messages with DEBUG level or higher')
    return parser.parse_args()


if __name__ == '__main__':
    """Main entry point for PaceNotify"""
    args = parse_args()
    try:
        pnote = PaceNotify(args)
        pnote.alert_type()
    except Exception as e:
        print(e)
        sys.exit(1)
