pacemaker

#!/usr/bin/python
# -*- coding: utf-8 -*-

# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>, and others
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

import re
import crmsh.parse
from crmsh.xmlutil import xml_equals
from crmsh.cibconfig import cib_factory
from lxml.etree import tostring as xmltostring
from lxml import etree

DOCUMENTATION = '''
---
module: command
version_added: historical
short_description: Executes a command on a remote node
description:
     - The M(command) module takes the command name followed by a list of
       space-delimited arguments.
     - The given command will be executed on all selected nodes. It will not be
       processed through the shell, so variables like C($HOME) and operations
       like C("<"), C(">"), C("|"), and C("&") will not work (use the M(shell)
       module if you need these features).
options:
  free_form:
    description:
      - the command module takes a free form command to run
    required: true
    default: null
    aliases: []
notes:
    -  If you want to run a command through the shell (say you are using C(<),
       C(>), C(|), etc), you actually want the M(shell) module instead. The
       M(command) module is much more secure as it's not affected by the user's
       environment.
author: Michael DeHaan
'''

EXAMPLES = '''
# Example from Ansible Playbooks
- command: /sbin/shutdown -t now

# Run the command if the specified file does not exist
- command: /usr/bin/make_database.sh arg1 arg2
'''


REX = re.compile(
    r"""([^ ]+)(=(['"])((?:\\.|(?!\3).)*)\3|)""",
    re.DOTALL | re.VERBOSE)


cmd_xmlres_map = {
    "location": "rsc_location",
}

debug = []


class BaseParser(object):
    id_name = None
    id = None
    partial_compare = False
    module = None
    no_delete = False
    crmsh = False
    resource = True

    def __init__(self, args, module=None):
        if module:
            self.module = module
        if self.crmsh:
            #debug.append("crmsh prim: %s" % args[0])
            # See https://github.com/ClusterLabs/crmsh/commit/5b11db312101b2b798017fef9e7539fd5fb8585a
            if hasattr(crmsh.parse,'CliParser'):
                clip = crmsh.parse.CliParser()
            else:
                clip = crmsh.parse

            # initialize cib
            cib_factory.get_cib()
            self.cib = clip.parse(' '.join(args))
            self.command = args[0]
            self.args = args
            self.id = self.cib.get('id')
            #debug.append("id: %s" % self.id)
        else:
            self.cib = self.parse(args)
            self.command = self.cib["command"]
            self.args = args
            if self.id_name:
                self.id = self.cib[self.id_name]

    def parse(self, args):
        raise NotImplementedError()

    def is_same(self, cib):
        if self.crmsh:
            return xml_equals(self.cib, cib)

        obj_key = list(cib)
        for key, value in self.cib.items():
            if key not in obj_key:
                return False
            if value != cib.get(key):
                return False
            obj_key.remove(key)
        if len(obj_key) and not self.partial_compare:
            return False
        return True

class PrimitiveParser(BaseParser):
    id_name = "rsc"
    crmsh = True


class MonitorParser(BaseParser):
    id_name = "rsc"

    def parse(self, args):
        ret = dict(
            command=args.pop(0),
            rsc=args.pop(0),
            interval=args.pop(0),
            )
        return ret


class GroupParser(BaseParser):
    id_name = "name"
    crmsh = True


class CloneParser(BaseParser):
    id_name = "name"
    crmsh = True


class MsParser(CloneParser):
    id_name = "name"


class RscTemplateParser(PrimitiveParser):
    id_name = "name"


class LocationParser(BaseParser):
    id_name = "id"
    crmsh = True
    resource = False


class ColocationParser(BaseParser):
    id_name = "id"
    resource = False

    def parse(self, args):
        ret = dict(
            command=args.pop(0),
            id=args.pop(0),
            score=args.pop(0),
            rsc=args[:],
            )
        return ret


class OrderParser(BaseParser):
    id_name = "id"
    resource = False

    def parse(self, args):
        ret = dict(
            command=args.pop(0),
            id=args.pop(0),
            kind_or_score=args.pop(0),
            rsc=args[:],
            )
        return ret


class PropertyParser(BaseParser):
    partial_compare = True
    no_delete = True

    def parse(self, args):
        ret = dict(
            command=args.pop(0),
            )
        if args[0].startswith("$id"):
            args.pop(0)

        if args[0].startswith("cib-bootstrap-options:"):
            args.pop(0)

        while (args):
            arg = args.pop(0)
            if '=' not in arg:
                self.module.fail_json(
                    rc=258,
                    msg="no key-value :%s" % arg)
            key, value = arg.split("=")

            if key == "":
                self.module.fail_json(
                    rc=258,
                    msg="no key in key=value option")
            if value == "":
                self.module.fail_json(
                    rc=258,
                    msg="no value in key=value option (key=%s)" % key)
            ret[key] = value

        return ret


class RscDefaultsParser(PropertyParser):
    partial_compare = True
    no_delete = True
    def parse(self, args):
        return {
            "command": args.pop(0)
        }


class FencingTopologyParser(BaseParser):
    partial_compare = True
    no_delete = True

    def parse(self, args):
        ret = dict(
            command=args.pop(0),
            )
        if not args[0].endswith(":"):
            ret["stonith_resources"] = args
            return ret

        newnode = None
        newfence = None
        while(args):
            arg = args.pop(0)
            if arg.endswith(":"):
                if newnode:
                    ret[newnode] = newfence
                newnode = arg
                newfence = []
            else:
                newfence.append(arg)
        if newnode:
            ret[newnode] = newfence

        return ret


def splitter(args):
    ret = []
    for a, b, c, d in REX.findall(args):
        if len(b) == 0:
            ret.append(a)
        else:
            ret.append(a+b)
    return ret


class CIBParser(object):

    cib_parser_class = {
        'primitive': PrimitiveParser,
        'monitor': MonitorParser,
        'group': GroupParser,
        'clone': CloneParser,
        'ms': MsParser,
        'rsc_template': RscTemplateParser,
        'location': LocationParser,
        'colocation': ColocationParser,
        'order': OrderParser,
        'property': PropertyParser,
        'rsc_defaults': RscDefaultsParser,
        'fencing_topology': FencingTopologyParser,
        }

    def __init__(self, module):
        self.module = module

    def parse_cib(self, args):
        if args[0] in self.cib_parser_class:
            return self.cib_parser_class[args[0]](args[:], module=self.module)
        return None

    def parse_cibs(self, lines):
        cibs = []
        #debug.append("all lines: \n%s" % "\n".join(lines))
        new_line = ""
        for line in lines:
            new_line += line.strip()
            if new_line.endswith('\\'):
                new_line = new_line.rstrip('\\')
            else:
                if len(new_line) == 0:
                    continue
                args = splitter(new_line)
                #debug.append("new cib to parse: %s" % args[0])
                cib = self.parse_cib(args)
                if cib:
                    cibs.append(cib)
                new_line = ""
        return cibs


def main():

    module = AnsibleModule(
        argument_spec={
            'resource': dict(default=None),
            'state': dict(default='present', choices=['present', 'absent']),
            'action': dict(default='resource', choices=['prepare', 'resource', 'commit']),
            'shadow': dict(default=None),
            'ignore_target_role': dict(default=True, type='bool'),
            'ignore_is_managed': dict(default=True, type='bool'),
        },
        supports_check_mode=True
    )

    state = module.params['state']
    action = module.params['action']
    shadow = module.params['shadow']
    resource = module.params['resource']
    ignore_target_role = module.params['ignore_target_role']
    ignore_is_managed = module.params['ignore_is_managed']
    
    # Action 'prepare': Create a new shadow copy of the running config
    if action == "prepare":
        if shadow == None:
            module.fail_json(rc=256, msg="parameter 'shadow' is required for action 'prepare'")
        rc, out, err = module.run_command(["crm", "cib", "new", shadow, "--force"])
        if rc:
            module.fail_json(rc=256, msg="crm command failed", out=out,
                             err=err)
        module.exit_json(changed=False)

    # Action 'commit': Apply shadow copy as new config
    if action == "commit":
        if shadow == None:
            module.fail_json(rc=256, msg="parameter 'shadow' is required for action 'commit'")
        rc, out, err = module.run_command(["crm", "cib", "commit", shadow])
        if rc:
            module.fail_json(rc=256, msg="crm command 'crm cib commit %s' failed" % shadow, out=out,
                             err=err)
        rc, out, err = module.run_command(["crm", "cib", "delete", shadow])
        if rc:
            module.exit_json(changed=False, warnings=["Could not delete shadow config '%s'" % shadow])
        module.exit_json(changed=False)

    if action != "resource":
        module.fail_json(rc=256, msg="unexpected action: '%s'" % action)

    if resource == None:
        module.fail_json(rc=256, msg="parameter 'resource' is required for action 'prepare'")

    args = splitter(module.params['resource'].rstrip())

    parser = CIBParser(module)
    new = parser.parse_cib(args)

    crm_base = [ "crm" ]

    # if shadow is set, we do all operations on the given shadow copy of the config
    if shadow != None:
        crm_base = crm_base + [ "-c", shadow ]

    crm_args = crm_base + [ "configure", "show"]
    rc, out, err = module.run_command(crm_args)

    if rc:
        module.fail_json(rc=256, msg="crm configure show failed", out=out,
                         err=err)

    is_same = None
    old_cib = None
    for cur in parser.parse_cibs(out.splitlines()):
        #debug.append("old command: %s, id: %s" % (cur.command, cur.id))

        if new.command != cur.command:
            continue
        if new.id != cur.id:
            continue
        old_cib = cur.cib
        if cur.crmsh and (ignore_target_role or ignore_is_managed):
            if ignore_target_role:
                for target in old_cib.xpath("//meta_attributes/nvpair[@name='target-role']"):
                    target.getparent().remove(target)
            if ignore_is_managed:
                for managed in old_cib.xpath("//meta_attributes/nvpair[@name='is-managed']"):
                    managed.getparent().remove(managed)
            for meta in old_cib.xpath("//meta_attributes"):
                if len(meta.getchildren()) == 0:
                    meta.getparent().remove(meta)
        is_same = new.is_same(old_cib)
        break

    need_delete = False
    need_append = False
    if state == 'absent':
        if is_same is None:
            module.exit_json(args=" ".join(args), changed=False)
        elif is_same:
            if new.id is None:
                module.fail_json(rc=256, msg="can't delete %s" % new.command)
            need_delete = True
    else:
        if is_same:
            module.exit_json(args=" ".join(args), debug=debug, changed=False)
        elif is_same is False and not new.no_delete:
            need_delete = True
        need_append = True

    crm_config_commands = []
    if need_delete:
        debug.append("deleting %s" % new.id)
        if new.resource:
            crm_config_commands.append(["resource", "stop", new.id])
        crm_config_commands.append(["configure", "delete", new.id])
    if need_append:
        crm_config_commands.append(["configure"] + args)
    if not module.check_mode:
        for command in crm_config_commands:
            #debug.append("running crm -F -w %s" % command)
            rc, out, err = module.run_command(crm_base + ["-F", "-w"] + command)
            if rc:
                module.fail_json(rc=256, msg="crm -F -w %s failed" %
                                 ' '.join(command), out=out, err=err)

    if new.crmsh:
        module.exit_json(
            args=" ".join(args), cur=" ".join(cur.args),
            old=xmltostring(old_cib, pretty_print=True) if old_cib is not None else None,
            new=xmltostring(new.cib, pretty_print=True), debug=debug, changed=True)
    else:
        module.exit_json(args=" ".join(args), old=old_cib, new=new.cib, debug=debug,
                         changed=True)


# import module snippets
from ansible.module_utils.basic import *  # noqa

main()