diff --git a/coordination/znode b/coordination/znode new file mode 100644 index 00000000000..4e9dec4ce49 --- /dev/null +++ b/coordination/znode @@ -0,0 +1,210 @@ +#!/usr/bin/python +DOCUMENTATION = """ +--- +module: znode +short_description: Create, delete, retrieve, and update znodes using ZooKeeper. +options: + hosts: + description: + - A list of ZooKeeper servers (format '[server]:[port]'). + default: localhost:2181 + required: true + path: + description: + - The path of the znode. + required: true + value: + description: + - The value assigned to the znode. + default: None + required: false + op: + description: + - An operation to perform. Mutually exclusive with state. + default: None + required: false + state: + description: + - The state to enforce. Mutually exclusive with op. + default: None + required: false + timeout: + description: + - The amount of time to wait for a node to appear. + default: 300 + required: false +requirements: + - kazoo >= 2.1 +--- +""" + +EXAMPLES = """ +# Creating or updating a znode with a given value +- action: znode hosts=localhost:2181 name=/mypath value=myvalue state=present + +# Getting the value and stat structure for a znode +- action: znode hosts=localhost:2181 name=/mypath op=get + +# Listing a particular znode's children +- action: znode hosts=localhost:2181 name=/zookeeper op=list + +# Waiting 20 seconds for a znode to appear at path /mypath +- action: znode hosts=localhost:2181 name=/mypath op=wait timeout=20 + +# Deleting a znode at path /mypath +- action: znode hosts=localhost:2181 name=/mypath state=absent +""" + +try: + from kazoo.client import KazooClient + from kazoo.exceptions import NoNodeError, ZookeeperError + from kazoo.handlers.threading import KazooTimeoutError + KAZOO_INSTALLED = True +except ImportError: + KAZOO_INSTALLED = False + + +def main(): + module = AnsibleModule( + argument_spec=dict( + hosts=dict(required=True, type='str'), + name=dict(required=True, type='str'), + value=dict(required=False, default=None, type='str'), + op=dict(required=False, default=None, choices=['get', 'wait', 'list']), + state=dict(choices=['present', 'absent']), + timeout=dict(required=False, default=300, type='int') + ), + supports_check_mode=False + ) + + if not KAZOO_INSTALLED: + module.fail_json(msg='kazoo >= 2.1 is required to use this module. Use pip to install it.') + + check = check_params(module.params) + if not check['success']: + module.fail_json(msg=check['msg']) + + zoo = KazooCommandProxy(module) + try: + zoo.start() + except KazooTimeoutError: + module.fail_json(msg='The connection to the ZooKeeper ensemble timed out.') + + command_dict = { + 'op': { + 'get': zoo.get, + 'list': zoo.list, + 'wait': zoo.wait + }, + 'state': { + 'present': zoo.present, + 'absent': zoo.absent + } + } + + command_type = 'op' if 'op' in module.params and module.params['op'] is not None else 'state' + method = module.params[command_type] + result, result_dict = command_dict[command_type][method]() + zoo.shutdown() + + if result: + module.exit_json(**result_dict) + else: + module.fail_json(**result_dict) + + +def check_params(params): + if not params['state'] and not params['op']: + return {'success': False, 'msg': 'Please define an operation (op) or a state.'} + + if params['state'] and params['op']: + return {'success': False, 'msg': 'Please choose an operation (op) or a state, but not both.'} + + return {'success': True} + + +class KazooCommandProxy(): + def __init__(self, module): + self.module = module + self.zk = KazooClient(module.params['hosts']) + + def absent(self): + return self._absent(self.module.params['name']) + + def exists(self, znode): + return self.zk.exists(znode) + + def list(self): + children = self.zk.get_children(self.module.params['name']) + return True, {'count': len(children), 'items': children, 'msg': 'Retrieved znodes in path.', + 'znode': self.module.params['name']} + + def present(self): + return self._present(self.module.params['name'], self.module.params['value']) + + def get(self): + return self._get(self.module.params['name']) + + def shutdown(self): + self.zk.stop() + self.zk.close() + + def start(self): + self.zk.start() + + def wait(self): + return self._wait(self.module.params['name'], self.module.params['timeout']) + + def _absent(self, znode): + if self.exists(znode): + self.zk.delete(znode) + return True, {'changed': True, 'msg': 'The znode was deleted.'} + else: + return True, {'changed': False, 'msg': 'The znode does not exist.'} + + def _get(self, path): + if self.exists(path): + value, zstat = self.zk.get(path) + stat_dict = {} + for i in dir(zstat): + if not i.startswith('_'): + attr = getattr(zstat, i) + if type(attr) in (int, str): + stat_dict[i] = attr + result = True, {'msg': 'The node was retrieved.', 'znode': path, 'value': value, + 'stat': stat_dict} + else: + result = False, {'msg': 'The requested node does not exist.'} + + return result + + def _present(self, path, value): + if self.exists(path): + (current_value, zstat) = self.zk.get(path) + if value != current_value: + self.zk.set(path, value) + return True, {'changed': True, 'msg': 'Updated the znode value.', 'znode': path, + 'value': value} + else: + return True, {'changed': False, 'msg': 'No changes were necessary.', 'znode': path, 'value': value} + else: + self.zk.create(path, value, makepath=True) + return True, {'changed': True, 'msg': 'Created a new znode.', 'znode': path, 'value': value} + + def _wait(self, path, timeout, interval=5): + lim = time.time() + timeout + + while time.time() < lim: + if self.exists(path): + return True, {'msg': 'The node appeared before the configured timeout.', + 'znode': path, 'timeout': timeout} + else: + time.sleep(interval) + + return False, {'msg': 'The node did not appear before the operation timed out.', 'timeout': timeout, + 'znode': path} + +from ansible.module_utils.basic import * + +main() +