mirror of
https://github.com/ansible-collections/community.general.git
synced 2025-04-23 02:41:25 -07:00
* refactor and test * require version >= 5.21.0 Prior to this version the status output was different * python version compatability * use exception classes from utils * modify monit to use 'status' output instead of 'summary' output The summary output is a fixed width table which truncates the contents and prevents us from parsing the actual status of the program. * add integration tests + fixes * remove unused handlers in monit integration test * fix lint * add '__metaclass__ = type' to integration python files * raise AttributeError * simplify status * lint: add type to parameter docs * remove lint ignore * move monit process config into main file * specify path to monit PID file * set config location based on os_family * create required directories * update aliases to set group and skips * add changelog * add author * add types to docs * add EPEL repo * custom vars for centos-6 * uninstall EPEL * support older versions * wait for status to change before exiting * use 'validate' to force status updates * handle 'execution failed' * better status output for errors * add more context to failure + standardize * don't check rc for validate * legacy string format support * add integration test for 'reloaded' and 'present' * don't wait after reload * lint * Revert "uninstall EPEL" This reverts commit4d548718d0. * make 'present' more robust * Apply suggestions from code review Co-authored-by: Andrew Klychkov <aaklychkov@mail.ru> * add license header * drop daemon.py and use python-daemon instead * skip python2.6 which is not supported by python-daemon * refactor test tasks for reuse * cleanup files after test * lint * start process before enabling monit This shouldn't be necessary but I'm adding it in the hopes it will make tests more robust. * retry task * attempt to rescue the task on failure * fix indentation * ignore check if rescue ran * restart monit instead of reload Co-authored-by: Andrew Klychkov <aaklychkov@mail.ru> (cherry picked from commit8de1c0c205) Co-authored-by: Simon Kelly <skelly@dimagi.com>
This commit is contained in:
patchback[bot]
GitHub
parent
f3e07723cd
commit
96a970475f
21 changed files with 698 additions and 127 deletions
|
|
@ -13,24 +13,29 @@ DOCUMENTATION = '''
|
|||
module: monit
|
||||
short_description: Manage the state of a program monitored via Monit
|
||||
description:
|
||||
- Manage the state of a program monitored via I(Monit)
|
||||
- Manage the state of a program monitored via I(Monit).
|
||||
options:
|
||||
name:
|
||||
description:
|
||||
- The name of the I(monit) program/process to manage
|
||||
- The name of the I(monit) program/process to manage.
|
||||
required: true
|
||||
type: str
|
||||
state:
|
||||
description:
|
||||
- The state of service
|
||||
- The state of service.
|
||||
required: true
|
||||
choices: [ "present", "started", "stopped", "restarted", "monitored", "unmonitored", "reloaded" ]
|
||||
type: str
|
||||
timeout:
|
||||
description:
|
||||
- If there are pending actions for the service monitored by monit, then Ansible will check
|
||||
for up to this many seconds to verify the requested action has been performed.
|
||||
Ansible will sleep for five seconds between each check.
|
||||
default: 300
|
||||
author: "Darryl Stoflet (@dstoflet)"
|
||||
type: int
|
||||
author:
|
||||
- Darryl Stoflet (@dstoflet)
|
||||
- Simon Kelly (@snopoke)
|
||||
'''
|
||||
|
||||
EXAMPLES = '''
|
||||
|
|
@ -43,7 +48,224 @@ EXAMPLES = '''
|
|||
import time
|
||||
import re
|
||||
|
||||
from collections import namedtuple
|
||||
|
||||
from ansible.module_utils.basic import AnsibleModule
|
||||
from ansible.module_utils.six import python_2_unicode_compatible
|
||||
|
||||
|
||||
STATE_COMMAND_MAP = {
|
||||
'stopped': 'stop',
|
||||
'started': 'start',
|
||||
'monitored': 'monitor',
|
||||
'unmonitored': 'unmonitor',
|
||||
'restarted': 'restart'
|
||||
}
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class StatusValue(namedtuple("Status", "value, is_pending")):
|
||||
MISSING = 'missing'
|
||||
OK = 'ok'
|
||||
NOT_MONITORED = 'not_monitored'
|
||||
INITIALIZING = 'initializing'
|
||||
DOES_NOT_EXIST = 'does_not_exist'
|
||||
EXECUTION_FAILED = 'execution_failed'
|
||||
ALL_STATUS = [
|
||||
MISSING, OK, NOT_MONITORED, INITIALIZING, DOES_NOT_EXIST, EXECUTION_FAILED
|
||||
]
|
||||
|
||||
def __new__(cls, value, is_pending=False):
|
||||
return super(StatusValue, cls).__new__(cls, value, is_pending)
|
||||
|
||||
def pending(self):
|
||||
return StatusValue(self.value, True)
|
||||
|
||||
def __getattr__(self, item):
|
||||
if item in ('is_%s' % status for status in self.ALL_STATUS):
|
||||
return self.value == getattr(self, item[3:].upper())
|
||||
raise AttributeError(item)
|
||||
|
||||
def __str__(self):
|
||||
return "%s%s" % (self.value, " (pending)" if self.is_pending else "")
|
||||
|
||||
|
||||
class Status(object):
|
||||
MISSING = StatusValue(StatusValue.MISSING)
|
||||
OK = StatusValue(StatusValue.OK)
|
||||
RUNNING = StatusValue(StatusValue.OK)
|
||||
NOT_MONITORED = StatusValue(StatusValue.NOT_MONITORED)
|
||||
INITIALIZING = StatusValue(StatusValue.INITIALIZING)
|
||||
DOES_NOT_EXIST = StatusValue(StatusValue.DOES_NOT_EXIST)
|
||||
EXECUTION_FAILED = StatusValue(StatusValue.EXECUTION_FAILED)
|
||||
|
||||
|
||||
class Monit(object):
|
||||
def __init__(self, module, monit_bin_path, service_name, timeout):
|
||||
self.module = module
|
||||
self.monit_bin_path = monit_bin_path
|
||||
self.process_name = service_name
|
||||
self.timeout = timeout
|
||||
|
||||
self._monit_version = None
|
||||
self._raw_version = None
|
||||
self._status_change_retry_count = 6
|
||||
|
||||
def monit_version(self):
|
||||
if self._monit_version is None:
|
||||
self._raw_version, version = self._get_monit_version()
|
||||
# Use only major and minor even if there are more these should be enough
|
||||
self._monit_version = version[0], version[1]
|
||||
return self._monit_version
|
||||
|
||||
def _get_monit_version(self):
|
||||
rc, out, err = self.module.run_command('%s -V' % self.monit_bin_path, check_rc=True)
|
||||
version_line = out.split('\n')[0]
|
||||
raw_version = re.search(r"([0-9]+\.){1,2}([0-9]+)?", version_line).group()
|
||||
return raw_version, tuple(map(int, raw_version.split('.')))
|
||||
|
||||
def exit_fail(self, msg, status=None, **kwargs):
|
||||
kwargs.update({
|
||||
'msg': msg,
|
||||
'monit_version': self._raw_version,
|
||||
'process_status': str(status) if status else None,
|
||||
})
|
||||
self.module.fail_json(**kwargs)
|
||||
|
||||
def exit_success(self, state):
|
||||
self.module.exit_json(changed=True, name=self.process_name, state=state)
|
||||
|
||||
@property
|
||||
def command_args(self):
|
||||
return "-B" if self.monit_version() > (5, 18) else ""
|
||||
|
||||
def get_status(self, validate=False):
|
||||
"""Return the status of the process in monit.
|
||||
|
||||
:@param validate: Force monit to re-check the status of the process
|
||||
"""
|
||||
monit_command = "validate" if validate else "status"
|
||||
check_rc = False if validate else True # 'validate' always has rc = 1
|
||||
command = ' '.join([self.monit_bin_path, monit_command, self.command_args, self.process_name])
|
||||
rc, out, err = self.module.run_command(command, check_rc=check_rc)
|
||||
return self._parse_status(out, err)
|
||||
|
||||
def _parse_status(self, output, err):
|
||||
if "Process '%s'" % self.process_name not in output:
|
||||
return Status.MISSING
|
||||
|
||||
status_val = re.findall(r"^\s*status\s*([\w\- ]+)", output, re.MULTILINE)
|
||||
if not status_val:
|
||||
self.exit_fail("Unable to find process status", stdout=output, stderr=err)
|
||||
|
||||
status_val = status_val[0].strip().upper()
|
||||
if ' | ' in status_val:
|
||||
status_val = status_val.split(' | ')[0]
|
||||
if ' - ' not in status_val:
|
||||
status_val = status_val.replace(' ', '_')
|
||||
return getattr(Status, status_val)
|
||||
else:
|
||||
status_val, substatus = status_val.split(' - ')
|
||||
action, state = substatus.split()
|
||||
if action in ['START', 'INITIALIZING', 'RESTART', 'MONITOR']:
|
||||
status = Status.OK
|
||||
else:
|
||||
status = Status.NOT_MONITORED
|
||||
|
||||
if state == 'pending':
|
||||
status = status.pending()
|
||||
return status
|
||||
|
||||
def is_process_present(self):
|
||||
rc, out, err = self.module.run_command('%s summary %s' % (self.monit_bin_path, self.command_args), check_rc=True)
|
||||
return bool(re.findall(r'\b%s\b' % self.process_name, out))
|
||||
|
||||
def is_process_running(self):
|
||||
return self.get_status().is_ok
|
||||
|
||||
def run_command(self, command):
|
||||
"""Runs a monit command, and returns the new status."""
|
||||
return self.module.run_command('%s %s %s' % (self.monit_bin_path, command, self.process_name), check_rc=True)
|
||||
|
||||
def wait_for_status_change(self, current_status):
|
||||
running_status = self.get_status()
|
||||
if running_status.value != current_status.value or current_status.value == StatusValue.EXECUTION_FAILED:
|
||||
return running_status
|
||||
|
||||
loop_count = 0
|
||||
while running_status.value == current_status.value:
|
||||
if loop_count >= self._status_change_retry_count:
|
||||
self.exit_fail('waited too long for monit to change state', running_status)
|
||||
|
||||
loop_count += 1
|
||||
time.sleep(0.5)
|
||||
validate = loop_count % 2 == 0 # force recheck of status every second try
|
||||
running_status = self.get_status(validate)
|
||||
return running_status
|
||||
|
||||
def wait_for_monit_to_stop_pending(self, current_status=None):
|
||||
"""Fails this run if there is no status or it's pending/initializing for timeout"""
|
||||
timeout_time = time.time() + self.timeout
|
||||
|
||||
if not current_status:
|
||||
current_status = self.get_status()
|
||||
waiting_status = [
|
||||
StatusValue.MISSING,
|
||||
StatusValue.INITIALIZING,
|
||||
StatusValue.DOES_NOT_EXIST,
|
||||
]
|
||||
while current_status.is_pending or (current_status.value in waiting_status):
|
||||
if time.time() >= timeout_time:
|
||||
self.exit_fail('waited too long for "pending", or "initiating" status to go away', current_status)
|
||||
|
||||
time.sleep(5)
|
||||
current_status = self.get_status(validate=True)
|
||||
return current_status
|
||||
|
||||
def reload(self):
|
||||
rc, out, err = self.module.run_command('%s reload' % self.monit_bin_path)
|
||||
if rc != 0:
|
||||
self.exit_fail('monit reload failed', stdout=out, stderr=err)
|
||||
self.exit_success(state='reloaded')
|
||||
|
||||
def present(self):
|
||||
self.run_command('reload')
|
||||
|
||||
timeout_time = time.time() + self.timeout
|
||||
while not self.is_process_present():
|
||||
if time.time() >= timeout_time:
|
||||
self.exit_fail('waited too long for process to become "present"')
|
||||
|
||||
time.sleep(5)
|
||||
|
||||
self.exit_success(state='present')
|
||||
|
||||
def change_state(self, state, expected_status, invert_expected=None):
|
||||
current_status = self.get_status()
|
||||
self.run_command(STATE_COMMAND_MAP[state])
|
||||
status = self.wait_for_status_change(current_status)
|
||||
status = self.wait_for_monit_to_stop_pending(status)
|
||||
status_match = status.value == expected_status.value
|
||||
if invert_expected:
|
||||
status_match = not status_match
|
||||
if status_match:
|
||||
self.exit_success(state=state)
|
||||
self.exit_fail('%s process not %s' % (self.process_name, state), status)
|
||||
|
||||
def stop(self):
|
||||
self.change_state('stopped', Status.NOT_MONITORED)
|
||||
|
||||
def unmonitor(self):
|
||||
self.change_state('unmonitored', Status.NOT_MONITORED)
|
||||
|
||||
def restart(self):
|
||||
self.change_state('restarted', Status.OK)
|
||||
|
||||
def start(self):
|
||||
self.change_state('started', Status.OK)
|
||||
|
||||
def monitor(self):
|
||||
self.change_state('monitored', Status.NOT_MONITORED, invert_expected=True)
|
||||
|
||||
|
||||
def main():
|
||||
|
|
@ -59,145 +281,52 @@ def main():
|
|||
state = module.params['state']
|
||||
timeout = module.params['timeout']
|
||||
|
||||
MONIT = module.get_bin_path('monit', True)
|
||||
monit = Monit(module, module.get_bin_path('monit', True), name, timeout)
|
||||
|
||||
def monit_version():
|
||||
rc, out, err = module.run_command('%s -V' % MONIT, check_rc=True)
|
||||
version_line = out.split('\n')[0]
|
||||
version = re.search(r"[0-9]+\.[0-9]+", version_line).group().split('.')
|
||||
# Use only major and minor even if there are more these should be enough
|
||||
return int(version[0]), int(version[1])
|
||||
|
||||
def is_version_higher_than_5_18():
|
||||
return (MONIT_MAJOR_VERSION, MONIT_MINOR_VERSION) > (5, 18)
|
||||
|
||||
def parse(parts):
|
||||
if is_version_higher_than_5_18():
|
||||
return parse_current(parts)
|
||||
else:
|
||||
return parse_older_versions(parts)
|
||||
|
||||
def parse_older_versions(parts):
|
||||
if len(parts) > 2 and parts[0].lower() == 'process' and parts[1] == "'%s'" % name:
|
||||
return ' '.join(parts[2:]).lower()
|
||||
else:
|
||||
return ''
|
||||
|
||||
def parse_current(parts):
|
||||
if len(parts) > 2 and parts[2].lower() == 'process' and parts[0] == name:
|
||||
return ''.join(parts[1]).lower()
|
||||
else:
|
||||
return ''
|
||||
|
||||
def get_status():
|
||||
"""Return the status of the process in monit, or the empty string if not present."""
|
||||
rc, out, err = module.run_command('%s %s' % (MONIT, SUMMARY_COMMAND), check_rc=True)
|
||||
for line in out.split('\n'):
|
||||
# Sample output lines:
|
||||
# Process 'name' Running
|
||||
# Process 'name' Running - restart pending
|
||||
parts = parse(line.split())
|
||||
if parts != '':
|
||||
return parts
|
||||
|
||||
return ''
|
||||
|
||||
def run_command(command):
|
||||
"""Runs a monit command, and returns the new status."""
|
||||
module.run_command('%s %s %s' % (MONIT, command, name), check_rc=True)
|
||||
return get_status()
|
||||
|
||||
def wait_for_monit_to_stop_pending():
|
||||
"""Fails this run if there is no status or it's pending/initializing for timeout"""
|
||||
timeout_time = time.time() + timeout
|
||||
sleep_time = 5
|
||||
|
||||
running_status = get_status()
|
||||
while running_status == '' or 'pending' in running_status or 'initializing' in running_status:
|
||||
if time.time() >= timeout_time:
|
||||
module.fail_json(
|
||||
msg='waited too long for "pending", or "initiating" status to go away ({0})'.format(
|
||||
running_status
|
||||
),
|
||||
state=state
|
||||
)
|
||||
|
||||
time.sleep(sleep_time)
|
||||
running_status = get_status()
|
||||
|
||||
MONIT_MAJOR_VERSION, MONIT_MINOR_VERSION = monit_version()
|
||||
|
||||
SUMMARY_COMMAND = ('summary', 'summary -B')[is_version_higher_than_5_18()]
|
||||
|
||||
if state == 'reloaded':
|
||||
def exit_if_check_mode():
|
||||
if module.check_mode:
|
||||
module.exit_json(changed=True)
|
||||
rc, out, err = module.run_command('%s reload' % MONIT)
|
||||
if rc != 0:
|
||||
module.fail_json(msg='monit reload failed', stdout=out, stderr=err)
|
||||
wait_for_monit_to_stop_pending()
|
||||
module.exit_json(changed=True, name=name, state=state)
|
||||
|
||||
present = get_status() != ''
|
||||
if state == 'reloaded':
|
||||
exit_if_check_mode()
|
||||
monit.reload()
|
||||
|
||||
present = monit.is_process_present()
|
||||
|
||||
if not present and not state == 'present':
|
||||
module.fail_json(msg='%s process not presently configured with monit' % name, name=name, state=state)
|
||||
module.fail_json(msg='%s process not presently configured with monit' % name, name=name)
|
||||
|
||||
if state == 'present':
|
||||
if not present:
|
||||
if module.check_mode:
|
||||
module.exit_json(changed=True)
|
||||
status = run_command('reload')
|
||||
if status == '':
|
||||
wait_for_monit_to_stop_pending()
|
||||
module.exit_json(changed=True, name=name, state=state)
|
||||
module.exit_json(changed=False, name=name, state=state)
|
||||
if present:
|
||||
module.exit_json(changed=False, name=name, state=state)
|
||||
exit_if_check_mode()
|
||||
monit.present()
|
||||
|
||||
wait_for_monit_to_stop_pending()
|
||||
running = 'running' in get_status()
|
||||
monit.wait_for_monit_to_stop_pending()
|
||||
running = monit.is_process_running()
|
||||
|
||||
if running and state in ['started', 'monitored']:
|
||||
module.exit_json(changed=False, name=name, state=state)
|
||||
|
||||
if running and state == 'stopped':
|
||||
if module.check_mode:
|
||||
module.exit_json(changed=True)
|
||||
status = run_command('stop')
|
||||
if status in ['not monitored'] or 'stop pending' in status:
|
||||
module.exit_json(changed=True, name=name, state=state)
|
||||
module.fail_json(msg='%s process not stopped' % name, status=status)
|
||||
exit_if_check_mode()
|
||||
monit.stop()
|
||||
|
||||
if running and state == 'unmonitored':
|
||||
if module.check_mode:
|
||||
module.exit_json(changed=True)
|
||||
status = run_command('unmonitor')
|
||||
if status in ['not monitored'] or 'unmonitor pending' in status:
|
||||
module.exit_json(changed=True, name=name, state=state)
|
||||
module.fail_json(msg='%s process not unmonitored' % name, status=status)
|
||||
exit_if_check_mode()
|
||||
monit.unmonitor()
|
||||
|
||||
elif state == 'restarted':
|
||||
if module.check_mode:
|
||||
module.exit_json(changed=True)
|
||||
status = run_command('restart')
|
||||
if status in ['initializing', 'running'] or 'restart pending' in status:
|
||||
module.exit_json(changed=True, name=name, state=state)
|
||||
module.fail_json(msg='%s process not restarted' % name, status=status)
|
||||
exit_if_check_mode()
|
||||
monit.restart()
|
||||
|
||||
elif not running and state == 'started':
|
||||
if module.check_mode:
|
||||
module.exit_json(changed=True)
|
||||
status = run_command('start')
|
||||
if status in ['initializing', 'running'] or 'start pending' in status:
|
||||
module.exit_json(changed=True, name=name, state=state)
|
||||
module.fail_json(msg='%s process not started' % name, status=status)
|
||||
exit_if_check_mode()
|
||||
monit.start()
|
||||
|
||||
elif not running and state == 'monitored':
|
||||
if module.check_mode:
|
||||
module.exit_json(changed=True)
|
||||
status = run_command('monitor')
|
||||
if status not in ['not monitored']:
|
||||
module.exit_json(changed=True, name=name, state=state)
|
||||
module.fail_json(msg='%s process not monitored' % name, status=status)
|
||||
exit_if_check_mode()
|
||||
monit.monitor()
|
||||
|
||||
module.exit_json(changed=False, name=name, state=state)
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue