sysvinit service module (#34962)
* sysvinit service module Signed-off-by: Adam Miller <admiller@redhat.com>
This commit is contained in:
Adam Miller
GitHub
parent
46d35d8919
commit
cc61c86049
2 changed files with 377 additions and 2 deletions
|
|
@ -39,13 +39,17 @@ from ansible.module_utils.six import PY2, b
|
|||
from ansible.module_utils._text import to_bytes, to_text
|
||||
|
||||
|
||||
def sysv_is_enabled(name):
|
||||
def sysv_is_enabled(name, runlevel=None):
|
||||
'''
|
||||
This function will check if the service name supplied
|
||||
is enabled in any of the sysv runlevels
|
||||
|
||||
:arg name: name of the service to test for
|
||||
:kw runlevel: runlevel to check (default: None)
|
||||
'''
|
||||
if runlevel:
|
||||
return bool(glob.glob('/etc/rc%s.d/S??%s' % (runlevel, name)))
|
||||
else:
|
||||
return bool(glob.glob('/etc/rc?.d/S??%s' % name))
|
||||
|
||||
|
||||
|
|
@ -74,6 +78,27 @@ def sysv_exists(name):
|
|||
return os.path.exists(get_sysv_script(name))
|
||||
|
||||
|
||||
def get_ps(module, pattern):
|
||||
'''
|
||||
Last resort to find a service by trying to match pattern to programs in memory
|
||||
'''
|
||||
found = False
|
||||
if platform.system() == 'SunOS':
|
||||
flags = '-ef'
|
||||
else:
|
||||
flags = 'auxww'
|
||||
psbin = module.get_bin_path('ps', True)
|
||||
|
||||
(rc, psout, pserr) = module.run_command([psbin, flags])
|
||||
if rc == 0:
|
||||
for line in psout.splitlines():
|
||||
if pattern in line:
|
||||
# FIXME: should add logic to prevent matching 'self', though that should be extreemly rare
|
||||
found = True
|
||||
break
|
||||
return found
|
||||
|
||||
|
||||
def fail_if_missing(module, found, service, msg=''):
|
||||
'''
|
||||
This function will return an error or exit gracefully depending on check mode status
|
||||
|
|
|
|||
350
lib/ansible/modules/system/sysvinit.py
Normal file
350
lib/ansible/modules/system/sysvinit.py
Normal file
|
|
@ -0,0 +1,350 @@
|
|||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
# (c) 2017, Brian Coca <bcoca@ansible.com>
|
||||
# (c) 2017, Adam Miller <admiller@redhat.com>
|
||||
# (c) 2017 Ansible Project
|
||||
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
|
||||
|
||||
from __future__ import absolute_import, division, print_function
|
||||
__metaclass__ = type
|
||||
|
||||
ANSIBLE_METADATA = {
|
||||
'metadata_version': '1.1',
|
||||
'status': ['preview'],
|
||||
'supported_by': 'core'
|
||||
}
|
||||
|
||||
DOCUMENTATION = '''
|
||||
module: sysvinit
|
||||
author:
|
||||
- "Ansible Core Team"
|
||||
version_added: "2.6"
|
||||
short_description: Manage SysV services.
|
||||
description:
|
||||
- Controls services on target hosts that use the SysV init system.
|
||||
options:
|
||||
name:
|
||||
required: true
|
||||
description:
|
||||
- Name of the service.
|
||||
aliases: ['service']
|
||||
state:
|
||||
choices: [ 'started', 'stopped', 'restarted', 'reloaded' ]
|
||||
description:
|
||||
- C(started)/C(stopped) are idempotent actions that will not run commands unless necessary.
|
||||
Not all init scripts support C(restarted) nor C(reloaded) natively, so these will both trigger a stop and start as needed.
|
||||
enabled:
|
||||
type: bool
|
||||
description:
|
||||
- Whether the service should start on boot. B(At least one of state and enabled are required.)
|
||||
sleep:
|
||||
default: 1
|
||||
description:
|
||||
- If the service is being C(restarted) or C(reloaded) then sleep this many seconds between the stop and start command.
|
||||
This helps to workaround badly behaving services.
|
||||
pattern:
|
||||
description:
|
||||
- A substring to look for as would be found in the output of the I(ps) command as a stand-in for a status result.
|
||||
- If the string is found, the service will be assumed to be running.
|
||||
- "This option is mainly for use with init scripts that don't support the 'status' option."
|
||||
runlevels:
|
||||
description:
|
||||
- The runlevels this script should be enabled/disabled from.
|
||||
- Use this to override the defaults set by the package or init script itself.
|
||||
arguments:
|
||||
description:
|
||||
- Additional arguments provided on the command line that some init scripts accept.
|
||||
aliases: [ 'args' ]
|
||||
daemonize:
|
||||
type: bool
|
||||
description:
|
||||
- Have the module daemonize as the service itself might not do so properly.
|
||||
- This is useful with badly written init scripts or deamons, which
|
||||
commonly manifests as the task hanging as it is still holding the
|
||||
tty or the service dying when the task is over as the connection
|
||||
closes the session.
|
||||
default: no
|
||||
notes:
|
||||
- One option other than name is required.
|
||||
requirements:
|
||||
- That the service managed has a corresponding init script.
|
||||
'''
|
||||
|
||||
EXAMPLES = '''
|
||||
- name: make sure apache2 is started
|
||||
sysvinit:
|
||||
name: apache2
|
||||
state: started
|
||||
enabled: yes
|
||||
|
||||
- name: make sure apache2 is started on runlevels 3 and 5
|
||||
sysvinit:
|
||||
name: apache2
|
||||
state: started
|
||||
enabled: yes
|
||||
runlevels:
|
||||
- 3
|
||||
- 5
|
||||
'''
|
||||
|
||||
RETURN = '''
|
||||
results:
|
||||
description: results from actions taken
|
||||
returned: always
|
||||
type: complex
|
||||
contains:
|
||||
"attempts": 1
|
||||
"changed": true
|
||||
"name": "apache2"
|
||||
"status": {
|
||||
"enabled": {
|
||||
"changed": true,
|
||||
"rc": 0,
|
||||
"stderr": "",
|
||||
"stdout": ""
|
||||
},
|
||||
"stopped": {
|
||||
"changed": true,
|
||||
"rc": 0,
|
||||
"stderr": "",
|
||||
"stdout": "Stopping web server: apache2.\n"
|
||||
}
|
||||
}
|
||||
'''
|
||||
|
||||
import re
|
||||
from time import sleep
|
||||
from ansible.module_utils.basic import AnsibleModule
|
||||
from ansible.module_utils.service import sysv_is_enabled, get_sysv_script, sysv_exists, fail_if_missing, get_ps, daemonize
|
||||
|
||||
|
||||
def main():
|
||||
|
||||
module = AnsibleModule(
|
||||
argument_spec=dict(
|
||||
name=dict(required=True, type='str', aliases=['service']),
|
||||
state=dict(choices=['started', 'stopped', 'restarted', 'reloaded'], type='str'),
|
||||
enabled=dict(type='bool'),
|
||||
sleep=dict(type='int', default=1),
|
||||
pattern=dict(type='str'),
|
||||
arguments=dict(type='str', aliases=['args']),
|
||||
runlevels=dict(type='list'),
|
||||
daemonize=dict(type='bool', default=False),
|
||||
),
|
||||
supports_check_mode=True,
|
||||
required_one_of=[['state', 'enabled']],
|
||||
)
|
||||
|
||||
name = module.params['name']
|
||||
action = module.params['state']
|
||||
enabled = module.params['enabled']
|
||||
runlevels = module.params['runlevels']
|
||||
pattern = module.params['pattern']
|
||||
sleep_for = module.params['sleep']
|
||||
rc = 0
|
||||
out = err = ''
|
||||
result = {
|
||||
'name': name,
|
||||
'changed': False,
|
||||
'status': {}
|
||||
}
|
||||
|
||||
# ensure service exists, get script name
|
||||
fail_if_missing(module, sysv_exists(name), name)
|
||||
script = get_sysv_script(name)
|
||||
|
||||
# locate binaries for service management
|
||||
paths = ['/sbin', '/usr/sbin', '/bin', '/usr/bin']
|
||||
binaries = ['chkconfig', ' update-rc.d', 'insserv', 'service']
|
||||
|
||||
# Keeps track of the service status for various runlevels because we can
|
||||
# operate on multiple runlevels at once
|
||||
runlevel_status = {}
|
||||
|
||||
location = {}
|
||||
for binary in binaries:
|
||||
location[binary] = module.get_bin_path(binary, opt_dirs=paths)
|
||||
|
||||
# figure out enable status
|
||||
if runlevels:
|
||||
for rl in runlevels:
|
||||
runlevel_status.setdefault(rl, {})
|
||||
runlevel_status[rl]["enabled"] = sysv_is_enabled(name, runlevel=rl)
|
||||
else:
|
||||
runlevel_status["enabled"] = sysv_is_enabled(name)
|
||||
|
||||
# figure out started status, everyone does it different!
|
||||
is_started = False
|
||||
|
||||
# user knows other methods fail and supplied pattern
|
||||
if pattern:
|
||||
is_started = get_ps(module, pattern)
|
||||
else:
|
||||
worked = False
|
||||
if location.get('service'):
|
||||
# standard tool that has been 'destandarized' by reimplementation in other OS/distros
|
||||
cmd = '%s %s status' % (location['service'], name)
|
||||
elif script:
|
||||
# maybe script implements status (not LSB)
|
||||
cmd = '%s status' % script
|
||||
else:
|
||||
module.fail_json(msg="Unable to determine service status")
|
||||
|
||||
(rc, out, err) = module.run_command(cmd)
|
||||
if not rc == -1:
|
||||
# special case
|
||||
if name == 'iptables' and "ACCEPT" in out:
|
||||
worked = True
|
||||
is_started = True
|
||||
|
||||
# check output messages, messy but sadly more reliable than rc
|
||||
if not worked and out.count('\n') <= 1:
|
||||
|
||||
cleanout = out.lower().replace(name.lower(), '')
|
||||
|
||||
for stopped in ['stop', 'is dead ', 'dead but ', 'could not access pid file', 'inactive']:
|
||||
if stopped in cleanout:
|
||||
worked = True
|
||||
break
|
||||
|
||||
if not worked:
|
||||
for started_status in ['run', 'start', 'active']:
|
||||
if started_status in cleanout and "not " not in cleanout:
|
||||
is_started = True
|
||||
worked = True
|
||||
break
|
||||
|
||||
# hope rc is not lying to us, use often used 'bad' returns
|
||||
if not worked and rc in [1, 2, 3, 4, 69]:
|
||||
worked = True
|
||||
|
||||
if not worked:
|
||||
# hail mary
|
||||
if rc == 0:
|
||||
worked = True
|
||||
# ps for luck, can only assure positive match
|
||||
elif get_ps(module, name):
|
||||
is_started = True
|
||||
worked = True
|
||||
module.warn("Used ps output to match service name and determine it is up, this is very unreliable")
|
||||
|
||||
if not worked:
|
||||
module.warn("Unable to determine if service is up, assuming it is down")
|
||||
|
||||
###########################################################################
|
||||
# BEGIN: Enable/Disable
|
||||
result['status'].setdefault('enabled', {})
|
||||
result['status']['enabled']['changed'] = False
|
||||
result['status']['enabled']['rc'] = None
|
||||
result['status']['enabled']['stdout'] = None
|
||||
result['status']['enabled']['stderr'] = None
|
||||
if runlevels:
|
||||
result['status']['enabled']['runlevels'] = runlevels
|
||||
for rl in runlevels:
|
||||
if enabled != runlevel_status[rl]["enabled"]:
|
||||
result['changed'] = True
|
||||
result['status']['enabled']['changed'] = True
|
||||
|
||||
if not module.check_mode and result['changed']:
|
||||
# Perform enable/disable here
|
||||
if enabled:
|
||||
if location.get('update-rc.d'):
|
||||
(rc, out, err) = module.run_command("%s %s enable %s" % (location['update-rc.d'], name, ' '.join(runlevels)))
|
||||
elif location.get('chkconfig'):
|
||||
(rc, out, err) = module.run_command("%s --level %s %s on" % (location['chkconfig'], ''.join(runlevels), name))
|
||||
else:
|
||||
if location.get('update-rc.d'):
|
||||
(rc, out, err) = module.run_command("%s %s disable %s" % (location['update-rc.d'], name, ' '.join(runlevels)))
|
||||
elif location.get('chkconfig'):
|
||||
(rc, out, err) = module.run_command("%s --level %s %s off" % (location['chkconfig'], ''.join(runlevels), name))
|
||||
else:
|
||||
if enabled != runlevel_status["enabled"]:
|
||||
result['changed'] = True
|
||||
result['status']['enabled']['changed'] = True
|
||||
|
||||
if not module.check_mode and result['changed']:
|
||||
# Perform enable/disable here
|
||||
if enabled:
|
||||
if location.get('update-rc.d'):
|
||||
(rc, out, err) = module.run_command("%s %s enable" % (location['update-rc.d'], name))
|
||||
elif location.get('chkconfig'):
|
||||
(rc, out, err) = module.run_command("%s %s on" % (location['chkconfig'], name))
|
||||
else:
|
||||
if location.get('update-rc.d'):
|
||||
(rc, out, err) = module.run_command("%s %s disable" % (location['update-rc.d'], name))
|
||||
elif location.get('chkconfig'):
|
||||
(rc, out, err) = module.run_command("%s %s off" % (location['chkconfig'], name))
|
||||
|
||||
# Assigned above, might be useful is something goes sideways
|
||||
if not module.check_mode and result['status']['enabled']['changed']:
|
||||
result['status']['enabled']['rc'] = rc
|
||||
result['status']['enabled']['stdout'] = out
|
||||
result['status']['enabled']['stderr'] = err
|
||||
rc, out, err = None, None, None
|
||||
|
||||
if "illegal runlevel specified" in result['status']['enabled']['stderr']:
|
||||
module.fail_json(msg="Illegal runlevel specified for enable operation on service %s" % name, **result)
|
||||
# END: Enable/Disable
|
||||
###########################################################################
|
||||
|
||||
###########################################################################
|
||||
# BEGIN: state
|
||||
result['status'].setdefault(module.params['state'], {})
|
||||
result['status'][module.params['state']]['changed'] = False
|
||||
result['status'][module.params['state']]['rc'] = None
|
||||
result['status'][module.params['state']]['stdout'] = None
|
||||
result['status'][module.params['state']]['stderr'] = None
|
||||
if action:
|
||||
action = re.sub(r'p?ed$', '', action.lower())
|
||||
|
||||
def runme(doit):
|
||||
|
||||
cmd = "%s %s %s %s" % (script, doit, name, module.params['arguments'])
|
||||
# how to run
|
||||
if module.params['daemonize']:
|
||||
(rc, out, err) = daemonize(cmd)
|
||||
else:
|
||||
(rc, out, err) = module.run_command(cmd)
|
||||
# FIXME: ERRORS
|
||||
|
||||
if rc != 0:
|
||||
module.fail_json(msg="Failed to %s service: %s" % (action, name))
|
||||
|
||||
return (rc, out, err)
|
||||
|
||||
if action == 'restart':
|
||||
result['changed'] = True
|
||||
result['status'][module.params['state']]['changed'] = True
|
||||
if not module.check_mode:
|
||||
|
||||
# cannot rely on existing 'restart' in init script
|
||||
for dothis in ['stop', 'start']:
|
||||
(rc, out, err) = runme(dothis)
|
||||
if sleep_for:
|
||||
sleep(sleep_for)
|
||||
|
||||
elif is_started != (action == 'start'):
|
||||
result['changed'] = True
|
||||
result['status'][module.params['state']]['changed'] = True
|
||||
if not module.check_mode:
|
||||
rc, out, err = runme(action)
|
||||
|
||||
elif is_started == (action == 'stop'):
|
||||
result['changed'] = True
|
||||
result['status'][module.params['state']]['changed'] = True
|
||||
if not module.check_mode:
|
||||
rc, out, err = runme(action)
|
||||
|
||||
if not module.check_mode and result['status'][module.params['state']]['changed']:
|
||||
result['status'][module.params['state']]['rc'] = rc
|
||||
result['status'][module.params['state']]['stdout'] = out
|
||||
result['status'][module.params['state']]['stderr'] = err
|
||||
rc, out, err = None, None, None
|
||||
# END: state
|
||||
###########################################################################
|
||||
|
||||
module.exit_json(**result)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Loading…
Reference in a new issue