remove old library modules from ansible that are now folded into 1.1
This commit is contained in:
parent
cf0b33b12c
commit
c6817d6844
3 changed files with 0 additions and 1233 deletions
|
|
@ -1,187 +0,0 @@
|
|||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Ansible module to add authorized_keys for ssh logins.
|
||||
(c) 2012, Brad Olson <brado@movedbylight.com>
|
||||
|
||||
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/>.
|
||||
"""
|
||||
|
||||
DOCUMENTATION = '''
|
||||
---
|
||||
module: authorized_key
|
||||
short_description: Adds or removes an SSH authorized key
|
||||
description:
|
||||
- Adds or removes an SSH authorized key for a user from a remote host.
|
||||
version_added: "0.5"
|
||||
options:
|
||||
user:
|
||||
description:
|
||||
- Name of the user who should have access to the remote host
|
||||
required: true
|
||||
default: null
|
||||
aliases: []
|
||||
key:
|
||||
description:
|
||||
- the SSH public key, as a string
|
||||
required: true
|
||||
default: null
|
||||
state:
|
||||
description:
|
||||
- whether the given key should or should not be in the file
|
||||
required: false
|
||||
choices: [ "present", "absent" ]
|
||||
default: "present"
|
||||
examples:
|
||||
- code: 'authorized_key: user=charlie key="ssh-dss ASDF1234L+8BTwaRYr/rycsBF1D8e5pTxEsXHQs4iq+mZdyWqlW++L6pMiam1A8yweP+rKtgjK2httVS6GigVsuWWfOd7/sdWippefq74nppVUELHPKkaIOjJNN1zUHFoL/YMwAAAEBALnAsQN10TNGsRDe5arBsW8cTOjqLyYBcIqgPYTZW8zENErFxt7ij3fW3Jh/sCpnmy8rkS7FyK8ULX0PEy/2yDx8/5rXgMIICbRH/XaBy9Ud5bRBFVkEDu/r+rXP33wFPHjWjwvHAtfci1NRBAudQI/98DbcGQw5HmE89CjgZRo5ktkC5yu/8agEPocVjdHyZr7PaHfxZGUDGKtGRL2QzRYukCmWo1cZbMBHcI5FzImvTHS9/8B3SATjXMPgbfBuEeBwuBK5EjL+CtHY5bWs9kmYjmeo0KfUMH8hY4MAXDoKhQ7DhBPIrcjS5jPtoGxIREZjba67r6/P2XKXaCZH6Fc= charlie@example.org 2011-01-17"'
|
||||
description: "Example from Ansible Playbooks"
|
||||
- code: "authorized_key: user=charlie key='$FILE(/home/charlie/.ssh/id_rsa.pub)'"
|
||||
description: "Shorthand available in Ansible 0.8 and later"
|
||||
author: Brad Olson
|
||||
'''
|
||||
|
||||
# Makes sure the public key line is present or absent in the user's .ssh/authorized_keys.
|
||||
#
|
||||
# Arguments
|
||||
# =========
|
||||
# user = username
|
||||
# key = line to add to authorized_keys for user
|
||||
# state = absent|present (default: present)
|
||||
#
|
||||
# see example in examples/playbooks
|
||||
|
||||
import sys
|
||||
import os
|
||||
import pwd
|
||||
import os.path
|
||||
import tempfile
|
||||
import shutil
|
||||
|
||||
def keyfile(module, user, write=False):
|
||||
"""
|
||||
Calculate name of authorized keys file, optionally creating the
|
||||
directories and file, properly setting permissions.
|
||||
|
||||
:param str user: name of user in passwd file
|
||||
:param bool write: if True, write changes to authorized_keys file (creating directories if needed)
|
||||
:return: full path string to authorized_keys for user
|
||||
"""
|
||||
|
||||
try:
|
||||
user_entry = pwd.getpwnam(user)
|
||||
except KeyError, e:
|
||||
module.fail_json(msg="Failed to lookup user %s: %s" % (user, str(e)))
|
||||
homedir = user_entry.pw_dir
|
||||
sshdir = os.path.join(homedir, ".ssh")
|
||||
keysfile = os.path.join(sshdir, "authorized_keys")
|
||||
|
||||
if not write:
|
||||
return keysfile
|
||||
|
||||
uid = user_entry.pw_uid
|
||||
gid = user_entry.pw_gid
|
||||
|
||||
if not os.path.exists(sshdir):
|
||||
os.mkdir(sshdir, 0700)
|
||||
if module.selinux_enabled():
|
||||
module.set_default_selinux_context(sshdir, False)
|
||||
os.chown(sshdir, uid, gid)
|
||||
os.chmod(sshdir, 0700)
|
||||
|
||||
if not os.path.exists( keysfile):
|
||||
try:
|
||||
f = open(keysfile, "w") #touches file so we can set ownership and perms
|
||||
finally:
|
||||
f.close()
|
||||
if module.selinux_enabled():
|
||||
module.set_default_selinux_context(keysfile, False)
|
||||
|
||||
os.chown(keysfile, uid, gid)
|
||||
os.chmod(keysfile, 0600)
|
||||
return keysfile
|
||||
|
||||
def readkeys(filename):
|
||||
|
||||
if not os.path.isfile(filename):
|
||||
return []
|
||||
f = open(filename)
|
||||
keys = [line.rstrip() for line in f.readlines()]
|
||||
f.close()
|
||||
return keys
|
||||
|
||||
def writekeys(module, filename, keys):
|
||||
|
||||
fd, tmp_path = tempfile.mkstemp('', 'tmp', os.path.dirname(filename))
|
||||
f = open(tmp_path,"w")
|
||||
try:
|
||||
f.writelines( (key + "\n" for key in keys) )
|
||||
except IOError, e:
|
||||
module.fail_json(msg="Failed to write to file %s: %s" % (tmp_path, str(e)))
|
||||
f.close()
|
||||
module.atomic_replace(tmp_path, filename)
|
||||
|
||||
def enforce_state(module, params):
|
||||
"""
|
||||
Add or remove key.
|
||||
"""
|
||||
|
||||
user = params["user"]
|
||||
key = params["key"]
|
||||
state = params.get("state", "present")
|
||||
|
||||
key = key.split('\n')
|
||||
|
||||
# check current state -- just get the filename, don't create file
|
||||
params["keyfile"] = keyfile(module, user, write=False)
|
||||
keys = readkeys(params["keyfile"])
|
||||
|
||||
# Check our new keys, if any of them exist we'll continue.
|
||||
for new_key in key:
|
||||
present = new_key in keys
|
||||
# handle idempotent state=present
|
||||
if state=="present":
|
||||
if present:
|
||||
continue
|
||||
keys.append(new_key)
|
||||
writekeys(module, keyfile(module, user,write=True), keys)
|
||||
params['changed'] = True
|
||||
|
||||
elif state=="absent":
|
||||
if not present:
|
||||
continue
|
||||
keys.remove(new_key)
|
||||
writekeys(module, keyfile(module, user,write=True), keys)
|
||||
params['changed'] = True
|
||||
|
||||
return params
|
||||
|
||||
def main():
|
||||
|
||||
module = AnsibleModule(
|
||||
argument_spec = dict(
|
||||
user = dict(required=True),
|
||||
key = dict(required=True),
|
||||
state = dict(default='present', choices=['absent','present'])
|
||||
)
|
||||
)
|
||||
|
||||
results = enforce_state(module, module.params)
|
||||
module.exit_json(**results)
|
||||
|
||||
# this is magic, see lib/ansible/module_common.py
|
||||
#<<INCLUDE_ANSIBLE_MODULE_COMMON>>
|
||||
main()
|
||||
|
|
@ -1,187 +0,0 @@
|
|||
#!/usr/bin/python -tt
|
||||
# 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/>.
|
||||
|
||||
DOCUMENTATION = '''
|
||||
---
|
||||
module: ec2_create
|
||||
short_description: create an instance in ec2, return instanceid
|
||||
description:
|
||||
- creates ec2 instances and optionally waits for it to be 'running'
|
||||
version_added: "0.9"
|
||||
options:
|
||||
keypair:
|
||||
description:
|
||||
- keypair to use on the instance
|
||||
required: true
|
||||
default: null
|
||||
aliases: []
|
||||
group:
|
||||
description:
|
||||
- security group to use on the instance
|
||||
required: false
|
||||
default: 'default'
|
||||
aliases: []
|
||||
instance_type:
|
||||
description:
|
||||
- instance type to use for the instance
|
||||
required: true
|
||||
default: null
|
||||
aliases: []
|
||||
image:
|
||||
description:
|
||||
- emi (or ami) to use for the instance
|
||||
required: true
|
||||
default: null
|
||||
aliases: []
|
||||
kernel:
|
||||
description:
|
||||
- kernel eki to use for the instance
|
||||
required: false
|
||||
default: null
|
||||
aliases: []
|
||||
ramdisk:
|
||||
description:
|
||||
- ramdisk eri to use for the instance
|
||||
required: false
|
||||
default: null
|
||||
aliases: []
|
||||
wait:
|
||||
description:
|
||||
- wait for the instance to be in state 'running' before returning
|
||||
required: False
|
||||
default: False
|
||||
aliases: []
|
||||
ec2_url:
|
||||
description:
|
||||
- url to use to connect to ec2 or your cloud
|
||||
required: False
|
||||
default: null
|
||||
aliases: []
|
||||
ec2_secret_key:
|
||||
description:
|
||||
- ec2 secret key
|
||||
required: False
|
||||
default: null
|
||||
aliases: []
|
||||
ec2_access_key:
|
||||
description:
|
||||
- ec2 access key
|
||||
required: False
|
||||
default: null
|
||||
aliases: []
|
||||
|
||||
examples:
|
||||
- code: "local_action: ec2_create keypair=admin instance_type=m1.large image=emi-40603AD1 wait=true group=webserver"
|
||||
description: "Examples from Ansible Playbooks"
|
||||
- code:
|
||||
requirements: [ "euca2ools" ]
|
||||
author: Seth Vidal
|
||||
|
||||
'''
|
||||
|
||||
import euca2ools.commands.euca.runinstances
|
||||
import time
|
||||
|
||||
def _run(cmd):
|
||||
# returns (rc, stdout, stderr) from shell command
|
||||
process = subprocess.Popen(cmd, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE, shell=True)
|
||||
stdout, stderr = process.communicate()
|
||||
return (process.returncode, stdout, stderr)
|
||||
|
||||
|
||||
def main():
|
||||
module = AnsibleModule(
|
||||
argument_spec = dict(
|
||||
keypair = dict(required=True),
|
||||
group = dict(default='default'),
|
||||
instance_type = dict(aliases=['type']),
|
||||
image = dict(required=True),
|
||||
kernel = dict(),
|
||||
#count = dict(default='1'), # maybe someday
|
||||
ramdisk = dict(),
|
||||
wait = dict(choices=BOOLEANS, default=False),
|
||||
ec2_url = dict(aliases=['EC2_URL']),
|
||||
ec2_secret_key = dict(aliases=['EC2_SECRET_KEY']),
|
||||
ec2_access_key = dict(aliases=['EC2_ACCESS_KEY']),
|
||||
)
|
||||
)
|
||||
|
||||
keypair = module.params.get('keypair')
|
||||
group = module.params.get('group')
|
||||
instance_type = module.params.get('instance_type')
|
||||
image = module.params.get('image')
|
||||
#count = module.params.get('count')
|
||||
kernel = module.params.get('kernel')
|
||||
ramdisk = module.params.get('ramdisk')
|
||||
wait = module.params.get('wait')
|
||||
ec2_url = module.params.get('ec2_url')
|
||||
ec2_secret_key = module.params.get('ec2_secret_key')
|
||||
ec2_access_key = module.params.get('ec2_access_key')
|
||||
|
||||
if ec2_url:
|
||||
os.environ['EC2_URL'] = ec2_url
|
||||
if ec2_secret_key:
|
||||
os.environ['EC2_SECRET_KEY'] = ec2_secret_key
|
||||
if ec2_access_key:
|
||||
os.environ['EC2_ACCESS_KEY'] = ec2_access_key
|
||||
|
||||
|
||||
# yes I recognize how hacky this is - but it is easier than rewriting
|
||||
# all the try/except's myself.
|
||||
sys.argv.append(image)
|
||||
eri = euca2ools.commands.euca.runinstances.RunInstances()
|
||||
conn = eri.make_connection()
|
||||
res = eri.make_request_cli(conn, 'run_instances',
|
||||
image_id=image,
|
||||
min_count=1,
|
||||
max_count=1,
|
||||
key_name=keypair,
|
||||
security_groups=[group],
|
||||
instance_type=instance_type,
|
||||
kernel_id=kernel,
|
||||
ramdisk_id=ramdisk)
|
||||
|
||||
instids = [ i.id for i in res.instances ]
|
||||
|
||||
res_list = res.connection.get_all_instances(instids)
|
||||
this_res = res_list[0]
|
||||
if wait:
|
||||
# wait here until the instances are up
|
||||
num_running = 0
|
||||
while num_running != len(instids):
|
||||
res_list = res.connection.get_all_instances(instids)
|
||||
this_res = res_list[0]
|
||||
num_running = len([ i for i in this_res.instances if i.state=='running' ])
|
||||
time.sleep(2)
|
||||
|
||||
# there's only one - but maybe one day there could be more
|
||||
instances = []
|
||||
for inst in this_res.instances:
|
||||
d = {
|
||||
'id': inst.id,
|
||||
'public_ip': inst.ip_address,
|
||||
}
|
||||
instances.append(d)
|
||||
|
||||
result = {"changed": True,
|
||||
"instances": instances }
|
||||
module.exit_json(**result)
|
||||
|
||||
# this is magic, see lib/ansible/module_common.py
|
||||
#<<INCLUDE_ANSIBLE_MODULE_COMMON>>
|
||||
|
||||
main()
|
||||
859
library/nagios
859
library/nagios
|
|
@ -1,859 +0,0 @@
|
|||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# This file is largely copied from the Nagios module included in the
|
||||
# Func project. Original copyright follows:
|
||||
#
|
||||
# func-nagios - Schedule downtime and enables/disable notifications
|
||||
# Copyright 2011, Red Hat, Inc.
|
||||
# Tim Bielawa <tbielawa@redhat.com>
|
||||
#
|
||||
# This software may be freely redistributed under the terms of the GNU
|
||||
# general public license version 2.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
|
||||
DOCUMENTATION = '''
|
||||
---
|
||||
module: nagios
|
||||
short_description: Perform common tasks in Nagios related to downtime and notifications.
|
||||
description:
|
||||
- "The M(nagios) module has two basic functions: scheduling downtime and toggling alerts for services or hosts."
|
||||
- All actions require the I(host) parameter to be given explicitly. In playbooks you can use the C($inventory_hostname) variable to refer to the host the playbook is currently running on.
|
||||
- You can specify multiple services at once by separating them with commas, .e.g., C(services=httpd,nfs,puppet).
|
||||
- When specifying what service to handle there is a special service value, I(host), which will handle alerts/downtime for the I(host itself), e.g., C(service=host). This keyword may not be given with other services at the same time. I(Setting alerts/downtime for a host does not affect alerts/downtime for any of the services running on it.) To schedule downtime for all services on particular host use keyword "all", e.g., C(service=all).
|
||||
- When using the M(nagios) module you will need to specify your Nagios server using the C(delegate_to) parameter.
|
||||
version_added: 0.7
|
||||
options:
|
||||
action:
|
||||
description:
|
||||
- Action to take.
|
||||
required: true
|
||||
default: null
|
||||
choices: [ "downtime", "enable_alerts", "disable_alerts", "silence", "unsilence",
|
||||
"silence_nagios", "unsilence_nagios", "command" ]
|
||||
host:
|
||||
description:
|
||||
- Host to operate on in Nagios.
|
||||
required: false
|
||||
default: null
|
||||
cmdfile:
|
||||
description:
|
||||
- Path to the nagios I(command file) (FIFO pipe).
|
||||
- Only required if auto-detection fails.
|
||||
required: false
|
||||
default: auto-detected
|
||||
author:
|
||||
description:
|
||||
- Author to leave downtime comments as.
|
||||
- Only usable with the C(downtime) action.
|
||||
required: false
|
||||
default: Ansible
|
||||
minutes:
|
||||
description:
|
||||
- Minutes to schedule downtime for.
|
||||
- Only usable with the C(downtime) action.
|
||||
required: false
|
||||
default: 30
|
||||
services:
|
||||
description:
|
||||
- What to manage downtime/alerts for. Separate multiple services with commas.
|
||||
- C(service) is an alias for C(services).
|
||||
- B(Required) option when using the C(downtime), C(enable_alerts), and C(disable_alerts) actions.
|
||||
aliases: [ "service" ]
|
||||
required: true
|
||||
default: null
|
||||
command:
|
||||
description:
|
||||
- raw command to send to nagios
|
||||
- should not include the submitted time header or the line-feed
|
||||
- B(Required) option when using the C(command) action
|
||||
required: true
|
||||
default: null
|
||||
|
||||
author: Tim Bielawa
|
||||
requirements: [ "Nagios" ]
|
||||
examples:
|
||||
- description: set 30 minutes of apache downtime
|
||||
code: "nagios: action=downtime minutes=30 service=httpd host=$inventory_hostname"
|
||||
- description: schedule an hour of HOST downtime
|
||||
code: "nagios: action=downtime minutes=60 service=host host=$inventory_hostname"
|
||||
- description: schedule downtime for ALL services on HOST
|
||||
code: "nagios: action=downtime minutes=45 service=all host=$inventory_hostname"
|
||||
- description: schedule downtime for a few services
|
||||
code: "nagios: action=downtime services=frob,foobar,qeuz host=$inventory_hostname"
|
||||
- description: enable SMART disk alerts
|
||||
code: "nagios: action=enable_alerts service=smart host=$inventory_hostname"
|
||||
- description: "two services at once: disable httpd and nfs alerts"
|
||||
code: "nagios: action=disable_alerts service=httpd,nfs host=$inventory_hostname"
|
||||
- description: disable HOST alerts
|
||||
code: "nagios: action=disable_alerts service=host host=$inventory_hostname"
|
||||
- description: silence ALL alerts
|
||||
code: "nagios: action=silence host=$inventory_hostname"
|
||||
- description: unsilence all alerts
|
||||
code: "nagios: action=unsilence host=$inventory_hostname"
|
||||
- description: SHUT UP NAGIOS
|
||||
code: "nagios: action=silence_nagios"
|
||||
- description: ANNOY ME NAGIOS
|
||||
code: "nagios: action=unsilence_nagios"
|
||||
- description: command something
|
||||
code: "nagios: action=command command='DISABLE_FAILURE_PREDICTION'"
|
||||
'''
|
||||
|
||||
import ConfigParser
|
||||
import types
|
||||
import time
|
||||
import os.path
|
||||
|
||||
######################################################################
|
||||
|
||||
|
||||
def which_cmdfile():
|
||||
locations = [
|
||||
# rhel
|
||||
'/etc/nagios/nagios.cfg',
|
||||
# debian
|
||||
'/etc/nagios3/nagios.cfg',
|
||||
# older debian
|
||||
'/etc/nagios2/nagios.cfg',
|
||||
# bsd, solaris
|
||||
'/usr/local/etc/nagios/nagios.cfg',
|
||||
# groundwork it monitoring
|
||||
'/usr/local/groundwork/nagios/etc/nagios.cfg',
|
||||
# open monitoring distribution
|
||||
'/omd/sites/oppy/tmp/nagios/nagios.cfg',
|
||||
# ???
|
||||
'/usr/local/nagios/etc/nagios.cfg',
|
||||
'/usr/local/nagios/nagios.cfg',
|
||||
'/opt/nagios/etc/nagios.cfg',
|
||||
'/opt/nagios/nagios.cfg'
|
||||
]
|
||||
|
||||
for path in locations:
|
||||
if os.path.exists(path):
|
||||
for line in open(path):
|
||||
if line.startswith('command_file'):
|
||||
return line.split('=')[1].strip()
|
||||
|
||||
return None
|
||||
|
||||
######################################################################
|
||||
|
||||
|
||||
def main():
|
||||
ACTION_CHOICES = [
|
||||
'downtime',
|
||||
'silence',
|
||||
'unsilence',
|
||||
'enable_alerts',
|
||||
'disable_alerts',
|
||||
'silence_nagios',
|
||||
'unsilence_nagios',
|
||||
'command',
|
||||
]
|
||||
|
||||
module = AnsibleModule(
|
||||
argument_spec=dict(
|
||||
action=dict(required=True, default=None, choices=ACTION_CHOICES),
|
||||
author=dict(default='Ansible'),
|
||||
host=dict(required=False, default=None),
|
||||
minutes=dict(default=30),
|
||||
cmdfile=dict(default=which_cmdfile()),
|
||||
services=dict(default=None, aliases=['service']),
|
||||
command=dict(required=False, default=None),
|
||||
)
|
||||
)
|
||||
|
||||
action = module.params['action']
|
||||
minutes = module.params['minutes']
|
||||
services = module.params['services']
|
||||
cmdfile = module.params['cmdfile']
|
||||
command = module.params['command']
|
||||
|
||||
##################################################################
|
||||
# Required args per action:
|
||||
# downtime = (minutes, service, host)
|
||||
# (un)silence = (host)
|
||||
# (enable/disable)_alerts = (service, host)
|
||||
# command = command
|
||||
#
|
||||
# AnsibleModule will verify most stuff, we need to verify
|
||||
# 'minutes' and 'service' manually.
|
||||
|
||||
##################################################################
|
||||
if action not in ['command', 'silence_nagios', 'unsilence_nagios']:
|
||||
if not host:
|
||||
module.fail_json(msg='no host specified for action requiring one')
|
||||
######################################################################
|
||||
if action == 'downtime':
|
||||
# Make sure there's an actual service selected
|
||||
if not services:
|
||||
module.fail_json(msg='no service selected to set downtime for')
|
||||
# Make sure minutes is a number
|
||||
try:
|
||||
m = int(minutes)
|
||||
if not isinstance(m, types.IntType):
|
||||
module.fail_json(msg='minutes must be a number')
|
||||
except:
|
||||
module.fail_json(msg='invalid entry for minutes')
|
||||
|
||||
##################################################################
|
||||
if action in ['enable_alerts', 'disable_alerts']:
|
||||
if not services:
|
||||
module.fail_json(msg='a service is required when setting alerts')
|
||||
|
||||
if action in ['command']:
|
||||
if not command:
|
||||
module.fail_json(msg='no command passed for command action')
|
||||
##################################################################
|
||||
if not cmdfile:
|
||||
module.fail_json('unable to locate nagios.cfg')
|
||||
|
||||
##################################################################
|
||||
ansible_nagios = Nagios(module, **module.params)
|
||||
ansible_nagios.act()
|
||||
##################################################################
|
||||
|
||||
|
||||
######################################################################
|
||||
class Nagios(object):
|
||||
"""
|
||||
Perform common tasks in Nagios related to downtime and
|
||||
notifications.
|
||||
|
||||
The complete set of external commands Nagios handles is documented
|
||||
on their website:
|
||||
|
||||
http://old.nagios.org/developerinfo/externalcommands/commandlist.php
|
||||
|
||||
Note that in the case of `schedule_svc_downtime`,
|
||||
`enable_svc_notifications`, and `disable_svc_notifications`, the
|
||||
service argument should be passed as a list.
|
||||
"""
|
||||
|
||||
def __init__(self, module, **kwargs):
|
||||
self.module = module
|
||||
self.action = kwargs['action']
|
||||
self.author = kwargs['author']
|
||||
self.host = kwargs['host']
|
||||
self.minutes = int(kwargs['minutes'])
|
||||
self.cmdfile = kwargs['cmdfile']
|
||||
self.command = kwargs['command']
|
||||
|
||||
if (kwargs['services'] is None) or (kwargs['services'] == 'host') or (kwargs['services'] == 'all'):
|
||||
self.services = kwargs['services']
|
||||
else:
|
||||
self.services = kwargs['services'].split(',')
|
||||
|
||||
self.command_results = []
|
||||
|
||||
def _now(self):
|
||||
"""
|
||||
The time in seconds since 12:00:00AM Jan 1, 1970
|
||||
"""
|
||||
|
||||
return int(time.time())
|
||||
|
||||
def _write_command(self, cmd):
|
||||
"""
|
||||
Write the given command to the Nagios command file
|
||||
"""
|
||||
|
||||
try:
|
||||
fp = open(self.cmdfile, 'w')
|
||||
fp.write(cmd)
|
||||
fp.flush()
|
||||
fp.close()
|
||||
self.command_results.append(cmd.strip())
|
||||
except IOError:
|
||||
self.module.fail_json(msg='unable to write to nagios command file',
|
||||
cmdfile=self.cmdfile)
|
||||
|
||||
def _fmt_dt_str(self, cmd, host, duration, author=None,
|
||||
comment="Scheduling downtime", start=None,
|
||||
svc=None, fixed=1, trigger=0):
|
||||
"""
|
||||
Format an external-command downtime string.
|
||||
|
||||
cmd - Nagios command ID
|
||||
host - Host schedule downtime on
|
||||
duration - Minutes to schedule downtime for
|
||||
author - Name to file the downtime as
|
||||
comment - Reason for running this command (upgrade, reboot, etc)
|
||||
start - Start of downtime in seconds since 12:00AM Jan 1 1970
|
||||
Default is to use the entry time (now)
|
||||
svc - Service to schedule downtime for, omit when for host downtime
|
||||
fixed - Start now if 1, start when a problem is detected if 0
|
||||
trigger - Optional ID of event to start downtime from. Leave as 0 for
|
||||
fixed downtime.
|
||||
|
||||
Syntax: [submitted] COMMAND;<host_name>;[<service_description>]
|
||||
<start_time>;<end_time>;<fixed>;<trigger_id>;<duration>;<author>;
|
||||
<comment>
|
||||
"""
|
||||
|
||||
entry_time = self._now()
|
||||
if start is None:
|
||||
start = entry_time
|
||||
|
||||
hdr = "[%s] %s;%s;" % (entry_time, cmd, host)
|
||||
duration_s = (duration * 60)
|
||||
end = start + duration_s
|
||||
|
||||
if not author:
|
||||
author = self.author
|
||||
|
||||
if svc is not None:
|
||||
dt_args = [svc, str(start), str(end), str(fixed), str(trigger),
|
||||
str(duration_s), author, comment]
|
||||
else:
|
||||
# Downtime for a host if no svc specified
|
||||
dt_args = [str(start), str(end), str(fixed), str(trigger),
|
||||
str(duration_s), author, comment]
|
||||
|
||||
dt_arg_str = ";".join(dt_args)
|
||||
dt_str = hdr + dt_arg_str + "\n"
|
||||
|
||||
return dt_str
|
||||
|
||||
def _fmt_notif_str(self, cmd, host=None, svc=None):
|
||||
"""
|
||||
Format an external-command notification string.
|
||||
|
||||
cmd - Nagios command ID.
|
||||
host - Host to en/disable notifications on.. A value is not required
|
||||
for global downtime
|
||||
svc - Service to schedule downtime for. A value is not required
|
||||
for host downtime.
|
||||
|
||||
Syntax: [submitted] COMMAND;<host_name>[;<service_description>]
|
||||
"""
|
||||
|
||||
entry_time = self._now()
|
||||
notif_str = "[%s] %s" % (entry_time, cmd)
|
||||
if host is not None:
|
||||
notif_str += ";%s" % host
|
||||
|
||||
if svc is not None:
|
||||
notif_str += ";%s" % svc
|
||||
|
||||
notif_str += "\n"
|
||||
|
||||
return notif_str
|
||||
|
||||
def schedule_svc_downtime(self, host, services=[], minutes=30):
|
||||
"""
|
||||
This command is used to schedule downtime for a particular
|
||||
service.
|
||||
|
||||
During the specified downtime, Nagios will not send
|
||||
notifications out about the service.
|
||||
|
||||
Syntax: SCHEDULE_SVC_DOWNTIME;<host_name>;<service_description>
|
||||
<start_time>;<end_time>;<fixed>;<trigger_id>;<duration>;<author>;
|
||||
<comment>
|
||||
"""
|
||||
|
||||
cmd = "SCHEDULE_SVC_DOWNTIME"
|
||||
for service in services:
|
||||
dt_cmd_str = self._fmt_dt_str(cmd, host, minutes, svc=service)
|
||||
self._write_command(dt_cmd_str)
|
||||
|
||||
def schedule_host_downtime(self, host, minutes=30):
|
||||
"""
|
||||
This command is used to schedule downtime for a particular
|
||||
host.
|
||||
|
||||
During the specified downtime, Nagios will not send
|
||||
notifications out about the host.
|
||||
|
||||
Syntax: SCHEDULE_HOST_DOWNTIME;<host_name>;<start_time>;<end_time>;
|
||||
<fixed>;<trigger_id>;<duration>;<author>;<comment>
|
||||
"""
|
||||
|
||||
cmd = "SCHEDULE_HOST_DOWNTIME"
|
||||
dt_cmd_str = self._fmt_dt_str(cmd, host, minutes)
|
||||
self._write_command(dt_cmd_str)
|
||||
|
||||
def schedule_host_svc_downtime(self, host, minutes=30):
|
||||
"""
|
||||
This command is used to schedule downtime for
|
||||
all services associated with a particular host.
|
||||
|
||||
During the specified downtime, Nagios will not send
|
||||
notifications out about the host.
|
||||
|
||||
SCHEDULE_HOST_SVC_DOWNTIME;<host_name>;<start_time>;<end_time>;
|
||||
<fixed>;<trigger_id>;<duration>;<author>;<comment>
|
||||
"""
|
||||
|
||||
cmd = "SCHEDULE_HOST_SVC_DOWNTIME"
|
||||
dt_cmd_str = self._fmt_dt_str(cmd, host, minutes)
|
||||
self._write_command(dt_cmd_str)
|
||||
|
||||
def schedule_hostgroup_host_downtime(self, hostgroup, minutes=30):
|
||||
"""
|
||||
This command is used to schedule downtime for all hosts in a
|
||||
particular hostgroup.
|
||||
|
||||
During the specified downtime, Nagios will not send
|
||||
notifications out about the hosts.
|
||||
|
||||
Syntax: SCHEDULE_HOSTGROUP_HOST_DOWNTIME;<hostgroup_name>;<start_time>;
|
||||
<end_time>;<fixed>;<trigger_id>;<duration>;<author>;<comment>
|
||||
"""
|
||||
|
||||
cmd = "SCHEDULE_HOSTGROUP_HOST_DOWNTIME"
|
||||
dt_cmd_str = self._fmt_dt_str(cmd, hostgroup, minutes)
|
||||
self._write_command(dt_cmd_str)
|
||||
|
||||
def schedule_hostgroup_svc_downtime(self, hostgroup, minutes=30):
|
||||
"""
|
||||
This command is used to schedule downtime for all services in
|
||||
a particular hostgroup.
|
||||
|
||||
During the specified downtime, Nagios will not send
|
||||
notifications out about the services.
|
||||
|
||||
Note that scheduling downtime for services does not
|
||||
automatically schedule downtime for the hosts those services
|
||||
are associated with.
|
||||
|
||||
Syntax: SCHEDULE_HOSTGROUP_SVC_DOWNTIME;<hostgroup_name>;<start_time>;
|
||||
<end_time>;<fixed>;<trigger_id>;<duration>;<author>;<comment>
|
||||
"""
|
||||
|
||||
cmd = "SCHEDULE_HOSTGROUP_SVC_DOWNTIME"
|
||||
dt_cmd_str = self._fmt_dt_str(cmd, hostgroup, minutes)
|
||||
self._write_command(dt_cmd_str)
|
||||
|
||||
def schedule_servicegroup_host_downtime(self, servicegroup, minutes=30):
|
||||
"""
|
||||
This command is used to schedule downtime for all hosts in a
|
||||
particular servicegroup.
|
||||
|
||||
During the specified downtime, Nagios will not send
|
||||
notifications out about the hosts.
|
||||
|
||||
Syntax: SCHEDULE_SERVICEGROUP_HOST_DOWNTIME;<servicegroup_name>;
|
||||
<start_time>;<end_time>;<fixed>;<trigger_id>;<duration>;<author>;
|
||||
<comment>
|
||||
"""
|
||||
|
||||
cmd = "SCHEDULE_SERVICEGROUP_HOST_DOWNTIME"
|
||||
dt_cmd_str = self._fmt_dt_str(cmd, servicegroup, minutes)
|
||||
self._write_command(dt_cmd_str)
|
||||
|
||||
def schedule_servicegroup_svc_downtime(self, servicegroup, minutes=30):
|
||||
"""
|
||||
This command is used to schedule downtime for all services in
|
||||
a particular servicegroup.
|
||||
|
||||
During the specified downtime, Nagios will not send
|
||||
notifications out about the services.
|
||||
|
||||
Note that scheduling downtime for services does not
|
||||
automatically schedule downtime for the hosts those services
|
||||
are associated with.
|
||||
|
||||
Syntax: SCHEDULE_SERVICEGROUP_SVC_DOWNTIME;<servicegroup_name>;
|
||||
<start_time>;<end_time>;<fixed>;<trigger_id>;<duration>;<author>;
|
||||
<comment>
|
||||
"""
|
||||
|
||||
cmd = "SCHEDULE_SERVICEGROUP_SVC_DOWNTIME"
|
||||
dt_cmd_str = self._fmt_dt_str(cmd, servicegroup, minutes)
|
||||
self._write_command(dt_cmd_str)
|
||||
|
||||
def disable_host_svc_notifications(self, host):
|
||||
"""
|
||||
This command is used to prevent notifications from being sent
|
||||
out for all services on the specified host.
|
||||
|
||||
Note that this command does not disable notifications from
|
||||
being sent out about the host.
|
||||
|
||||
Syntax: DISABLE_HOST_SVC_NOTIFICATIONS;<host_name>
|
||||
"""
|
||||
|
||||
cmd = "DISABLE_HOST_SVC_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, host)
|
||||
self._write_command(notif_str)
|
||||
|
||||
def disable_host_notifications(self, host):
|
||||
"""
|
||||
This command is used to prevent notifications from being sent
|
||||
out for the specified host.
|
||||
|
||||
Note that this command does not disable notifications for
|
||||
services associated with this host.
|
||||
|
||||
Syntax: DISABLE_HOST_NOTIFICATIONS;<host_name>
|
||||
"""
|
||||
|
||||
cmd = "DISABLE_HOST_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, host)
|
||||
self._write_command(notif_str)
|
||||
|
||||
def disable_svc_notifications(self, host, services=[]):
|
||||
"""
|
||||
This command is used to prevent notifications from being sent
|
||||
out for the specified service.
|
||||
|
||||
Note that this command does not disable notifications from
|
||||
being sent out about the host.
|
||||
|
||||
Syntax: DISABLE_SVC_NOTIFICATIONS;<host_name>;<service_description>
|
||||
"""
|
||||
|
||||
cmd = "DISABLE_SVC_NOTIFICATIONS"
|
||||
for service in services:
|
||||
notif_str = self._fmt_notif_str(cmd, host, svc=service)
|
||||
self._write_command(notif_str)
|
||||
|
||||
def disable_servicegroup_host_notifications(self, servicegroup):
|
||||
"""
|
||||
This command is used to prevent notifications from being sent
|
||||
out for all hosts in the specified servicegroup.
|
||||
|
||||
Note that this command does not disable notifications for
|
||||
services associated with hosts in this service group.
|
||||
|
||||
Syntax: DISABLE_SERVICEGROUP_HOST_NOTIFICATIONS;<servicegroup_name>
|
||||
"""
|
||||
|
||||
cmd = "DISABLE_SERVICEGROUP_HOST_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, servicegroup)
|
||||
self._write_command(notif_str)
|
||||
|
||||
def disable_servicegroup_svc_notifications(self, servicegroup):
|
||||
"""
|
||||
This command is used to prevent notifications from being sent
|
||||
out for all services in the specified servicegroup.
|
||||
|
||||
Note that this does not prevent notifications from being sent
|
||||
out about the hosts in this servicegroup.
|
||||
|
||||
Syntax: DISABLE_SERVICEGROUP_SVC_NOTIFICATIONS;<servicegroup_name>
|
||||
"""
|
||||
|
||||
cmd = "DISABLE_SERVICEGROUP_SVC_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, servicegroup)
|
||||
self._write_command(notif_str)
|
||||
|
||||
def disable_hostgroup_host_notifications(self, hostgroup):
|
||||
"""
|
||||
Disables notifications for all hosts in a particular
|
||||
hostgroup.
|
||||
|
||||
Note that this does not disable notifications for the services
|
||||
associated with the hosts in the hostgroup - see the
|
||||
DISABLE_HOSTGROUP_SVC_NOTIFICATIONS command for that.
|
||||
|
||||
Syntax: DISABLE_HOSTGROUP_HOST_NOTIFICATIONS;<hostgroup_name>
|
||||
"""
|
||||
|
||||
cmd = "DISABLE_HOSTGROUP_HOST_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, hostgroup)
|
||||
self._write_command(notif_str)
|
||||
|
||||
def disable_hostgroup_svc_notifications(self, hostgroup):
|
||||
"""
|
||||
Disables notifications for all services associated with hosts
|
||||
in a particular hostgroup.
|
||||
|
||||
Note that this does not disable notifications for the hosts in
|
||||
the hostgroup - see the DISABLE_HOSTGROUP_HOST_NOTIFICATIONS
|
||||
command for that.
|
||||
|
||||
Syntax: DISABLE_HOSTGROUP_SVC_NOTIFICATIONS;<hostgroup_name>
|
||||
"""
|
||||
|
||||
cmd = "DISABLE_HOSTGROUP_SVC_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, hostgroup)
|
||||
self._write_command(notif_str)
|
||||
|
||||
def enable_host_notifications(self, host):
|
||||
"""
|
||||
Enables notifications for a particular host.
|
||||
|
||||
Note that this command does not enable notifications for
|
||||
services associated with this host.
|
||||
|
||||
Syntax: ENABLE_HOST_NOTIFICATIONS;<host_name>
|
||||
"""
|
||||
|
||||
cmd = "ENABLE_HOST_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, host)
|
||||
self._write_command(notif_str)
|
||||
|
||||
def enable_host_svc_notifications(self, host):
|
||||
"""
|
||||
Enables notifications for all services on the specified host.
|
||||
|
||||
Note that this does not enable notifications for the host.
|
||||
|
||||
Syntax: ENABLE_HOST_SVC_NOTIFICATIONS;<host_name>
|
||||
"""
|
||||
|
||||
cmd = "ENABLE_HOST_SVC_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, host)
|
||||
nagios_return = self._write_command(notif_str)
|
||||
|
||||
if nagios_return:
|
||||
return notif_str
|
||||
else:
|
||||
return "Fail: could not write to the command file"
|
||||
|
||||
def enable_svc_notifications(self, host, services=[]):
|
||||
"""
|
||||
Enables notifications for a particular service.
|
||||
|
||||
Note that this does not enable notifications for the host.
|
||||
|
||||
Syntax: ENABLE_SVC_NOTIFICATIONS;<host_name>;<service_description>
|
||||
"""
|
||||
|
||||
cmd = "ENABLE_SVC_NOTIFICATIONS"
|
||||
nagios_return = True
|
||||
return_str_list = []
|
||||
for service in services:
|
||||
notif_str = self._fmt_notif_str(cmd, host, svc=service)
|
||||
nagios_return = self._write_command(notif_str) and nagios_return
|
||||
return_str_list.append(notif_str)
|
||||
|
||||
if nagios_return:
|
||||
return return_str_list
|
||||
else:
|
||||
return "Fail: could not write to the command file"
|
||||
|
||||
def enable_hostgroup_host_notifications(self, hostgroup):
|
||||
"""
|
||||
Enables notifications for all hosts in a particular hostgroup.
|
||||
|
||||
Note that this command does not enable notifications for
|
||||
services associated with the hosts in this hostgroup.
|
||||
|
||||
Syntax: ENABLE_HOSTGROUP_HOST_NOTIFICATIONS;<hostgroup_name>
|
||||
"""
|
||||
|
||||
cmd = "ENABLE_HOSTGROUP_HOST_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, hostgroup)
|
||||
nagios_return = self._write_command(notif_str)
|
||||
|
||||
if nagios_return:
|
||||
return notif_str
|
||||
else:
|
||||
return "Fail: could not write to the command file"
|
||||
|
||||
def enable_hostgroup_svc_notifications(self, hostgroup):
|
||||
"""
|
||||
Enables notifications for all services that are associated
|
||||
with hosts in a particular hostgroup.
|
||||
|
||||
Note that this does not enable notifications for the hosts in
|
||||
this hostgroup.
|
||||
|
||||
Syntax: ENABLE_HOSTGROUP_SVC_NOTIFICATIONS;<hostgroup_name>
|
||||
"""
|
||||
|
||||
cmd = "ENABLE_HOSTGROUP_SVC_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, hostgroup)
|
||||
nagios_return = self._write_command(notif_str)
|
||||
|
||||
if nagios_return:
|
||||
return notif_str
|
||||
else:
|
||||
return "Fail: could not write to the command file"
|
||||
|
||||
def enable_servicegroup_host_notifications(self, servicegroup):
|
||||
"""
|
||||
Enables notifications for all hosts that have services that
|
||||
are members of a particular servicegroup.
|
||||
|
||||
Note that this command does not enable notifications for
|
||||
services associated with the hosts in this servicegroup.
|
||||
|
||||
Syntax: ENABLE_SERVICEGROUP_HOST_NOTIFICATIONS;<servicegroup_name>
|
||||
"""
|
||||
|
||||
cmd = "ENABLE_SERVICEGROUP_HOST_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, servicegroup)
|
||||
nagios_return = self._write_command(notif_str)
|
||||
|
||||
if nagios_return:
|
||||
return notif_str
|
||||
else:
|
||||
return "Fail: could not write to the command file"
|
||||
|
||||
def enable_servicegroup_svc_notifications(self, servicegroup):
|
||||
"""
|
||||
Enables notifications for all services that are members of a
|
||||
particular servicegroup.
|
||||
|
||||
Note that this does not enable notifications for the hosts in
|
||||
this servicegroup.
|
||||
|
||||
Syntax: ENABLE_SERVICEGROUP_SVC_NOTIFICATIONS;<servicegroup_name>
|
||||
"""
|
||||
|
||||
cmd = "ENABLE_SERVICEGROUP_SVC_NOTIFICATIONS"
|
||||
notif_str = self._fmt_notif_str(cmd, servicegroup)
|
||||
nagios_return = self._write_command(notif_str)
|
||||
|
||||
if nagios_return:
|
||||
return notif_str
|
||||
else:
|
||||
return "Fail: could not write to the command file"
|
||||
|
||||
def silence_host(self, host):
|
||||
"""
|
||||
This command is used to prevent notifications from being sent
|
||||
out for the host and all services on the specified host.
|
||||
|
||||
This is equivalent to calling disable_host_svc_notifications
|
||||
and disable_host_notifications.
|
||||
|
||||
Syntax: DISABLE_HOST_SVC_NOTIFICATIONS;<host_name>
|
||||
Syntax: DISABLE_HOST_NOTIFICATIONS;<host_name>
|
||||
"""
|
||||
|
||||
cmd = [
|
||||
"DISABLE_HOST_SVC_NOTIFICATIONS",
|
||||
"DISABLE_HOST_NOTIFICATIONS"
|
||||
]
|
||||
nagios_return = True
|
||||
return_str_list = []
|
||||
for c in cmd:
|
||||
notif_str = self._fmt_notif_str(c, host)
|
||||
nagios_return = self._write_command(notif_str) and nagios_return
|
||||
return_str_list.append(notif_str)
|
||||
|
||||
if nagios_return:
|
||||
return return_str_list
|
||||
else:
|
||||
return "Fail: could not write to the command file"
|
||||
|
||||
def unsilence_host(self, host):
|
||||
"""
|
||||
This command is used to enable notifications for the host and
|
||||
all services on the specified host.
|
||||
|
||||
This is equivalent to calling enable_host_svc_notifications
|
||||
and enable_host_notifications.
|
||||
|
||||
Syntax: ENABLE_HOST_SVC_NOTIFICATIONS;<host_name>
|
||||
Syntax: ENABLE_HOST_NOTIFICATIONS;<host_name>
|
||||
"""
|
||||
|
||||
cmd = [
|
||||
"ENABLE_HOST_SVC_NOTIFICATIONS",
|
||||
"ENABLE_HOST_NOTIFICATIONS"
|
||||
]
|
||||
nagios_return = True
|
||||
return_str_list = []
|
||||
for c in cmd:
|
||||
notif_str = self._fmt_notif_str(c, host)
|
||||
nagios_return = self._write_command(notif_str) and nagios_return
|
||||
return_str_list.append(notif_str)
|
||||
|
||||
if nagios_return:
|
||||
return return_str_list
|
||||
else:
|
||||
return "Fail: could not write to the command file"
|
||||
|
||||
def silence_nagios(self):
|
||||
"""
|
||||
This command is used to disable notifications for all hosts and services
|
||||
in nagios.
|
||||
|
||||
This is a 'SHUT UP, NAGIOS' command
|
||||
"""
|
||||
cmd = 'DISABLE_NOTIFICATIONS'
|
||||
self._write_command(self._fmt_notif_str(cmd))
|
||||
|
||||
def unsilence_nagios(self):
|
||||
"""
|
||||
This command is used to enable notifications for all hosts and services
|
||||
in nagios.
|
||||
|
||||
This is a 'OK, NAGIOS, GO'' command
|
||||
"""
|
||||
cmd = 'ENABLE_NOTIFICATIONS'
|
||||
self._write_command(self._fmt_notif_str(cmd))
|
||||
|
||||
def nagios_cmd(self, cmd):
|
||||
"""
|
||||
This sends an arbitrary command to nagios
|
||||
|
||||
It prepends the submitted time and appends a \n
|
||||
|
||||
You just have to provide the properly formatted command
|
||||
"""
|
||||
|
||||
pre = '[%s]' % int(time.time())
|
||||
|
||||
post = '\n'
|
||||
cmdstr = '%s %s %s' % (pre, cmd, post)
|
||||
self._write_command(cmdstr)
|
||||
|
||||
def act(self):
|
||||
"""
|
||||
Figure out what you want to do from ansible, and then do the
|
||||
needful (at the earliest).
|
||||
"""
|
||||
# host or service downtime?
|
||||
if self.action == 'downtime':
|
||||
if self.services == 'host':
|
||||
self.schedule_host_downtime(self.host, self.minutes)
|
||||
elif self.services == 'all':
|
||||
self.schedule_host_svc_downtime(self.host, self.minutes)
|
||||
else:
|
||||
self.schedule_svc_downtime(self.host,
|
||||
services=self.services,
|
||||
minutes=self.minutes)
|
||||
|
||||
# toggle the host AND service alerts
|
||||
elif self.action == 'silence':
|
||||
self.silence_host(self.host)
|
||||
|
||||
elif self.action == 'unsilence':
|
||||
self.unsilence_host(self.host)
|
||||
|
||||
# toggle host/svc alerts
|
||||
elif self.action == 'enable_alerts':
|
||||
if self.services == 'host':
|
||||
self.enable_host_notifications(self.host)
|
||||
else:
|
||||
self.enable_svc_notifications(self.host,
|
||||
services=self.services)
|
||||
|
||||
elif self.action == 'disable_alerts':
|
||||
if self.services == 'host':
|
||||
self.disable_host_notifications(self.host)
|
||||
else:
|
||||
self.disable_svc_notifications(self.host,
|
||||
services=self.services)
|
||||
elif self.action == 'silence_nagios':
|
||||
self.silence_nagios()
|
||||
|
||||
elif self.action == 'unsilence_nagios':
|
||||
self.unsilence_nagios()
|
||||
|
||||
elif self.action == 'command':
|
||||
self.nagios_cmd(self.command)
|
||||
|
||||
# wtf?
|
||||
else:
|
||||
self.module.fail_json(msg="unknown action specified: '%s'" % \
|
||||
self.action)
|
||||
|
||||
self.module.exit_json(nagios_commands=self.command_results,
|
||||
changed=True)
|
||||
|
||||
######################################################################
|
||||
# this is magic, see lib/ansible/module_common.py
|
||||
#<<INCLUDE_ANSIBLE_MODULE_COMMON>>
|
||||
main()
|
||||
Loading…
Add table
Add a link
Reference in a new issue