def test_contact_custom_macros(self):
"""
Test on-demand macros with custom variables for contacts
:return:
"""
self.print_header()
mr = self.get_mr()
contact = self._sched.contacts.find_by_name("test_macro_contact")
data = [contact]
# Parse custom macro to get contact custom variables based upon a fixed value
# contact has a custom variable defined as _custom1 = value
dummy_call = "special_macro!$_CONTACTCUSTOM1$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing value' == com
# Parse custom macro to get service custom variables based upon another macro
# host has a custom variable defined as _custom2 = $CONTACTNAME$
dummy_call = "special_macro!$_CONTACTCUSTOM2$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing test_macro_contact' == com
def test_service_custom_macros(self):
"""
Test on-demand macros with custom variables for services
:return:
"""
self.print_header()
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
# Get the second service
svc2 = self.arbiter.conf.services.find_srv_by_name_and_hostname(
"test_host_0", "test_another_service")
data = [hst, svc2]
# Parse custom macro to get service custom variables based upon a fixed value
# special_macro is defined as: $USER1$/nothing $ARG1$
dummy_call = "special_macro!$_SERVICECUSTOM1$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing value' == com
# Parse custom macro to get service custom variables based upon another macro
dummy_call = "special_macro!$_SERVICECUSTOM2$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing test_host_0' == com
def test_unicode_macro(self):
"""
Call the resolver with a unicode content
:return:
"""
self.print_header()
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
hst.state = 'UP'
hst.output = u'Père Noël'
dummy_call = "special_macro!$HOSTOUTPUT$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
# Output is correctly restitued
assert u'plugins/nothing Père Noël' == com
hst.output = 'Père Noël'
dummy_call = "special_macro!$HOSTOUTPUT$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
# Output is correctly restitued
assert u'plugins/nothing P\xe8re No\xebl' == com
def test_resource_file(self):
"""
Test macros defined in configuration files
:return:
"""
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
# $USER1$ macro is defined as 'plugins' in the configuration file
dummy_call = "special_macro!$USER1$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert 'plugins/nothing plugins' == macros_command
# $PLUGINSDIR$ macro is defined as $USER1$ in the configuration file
dummy_call = "special_macro!$PLUGINSDIR$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert 'plugins/nothing plugins' == macros_command
# $INTERESTINGVARIABLE$ macro is defined as 'interesting_value' in the configuration file
dummy_call = "special_macro!$INTERESTINGVARIABLE$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert 'plugins/nothing interesting_value' == macros_command
# Look for multiple = in lines, should split the first
# and keep others in the macro value
dummy_call = "special_macro!$ANOTHERVALUE$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert 'plugins/nothing first=second' == macros_command
def test_host_custom_macros(self):
"""
Test on-demand macros with custom variables for hosts
:return:
"""
hst = self._scheduler.hosts.find_by_name("test_macro_host")
# The host has custom variables, thus we may use them in a macro
assert hst.customs is not []
assert '_CUSTOM1' in hst.customs
assert '_CUSTOM2' in hst.customs
# Force declare an integer customs variable
hst.customs['_CUSTOM3'] = 10
print((hst.customs))
data = [hst]
# Parse custom macro to get host custom variables based upon a fixed value
# host has a custom variable defined as _custom1 = value
dummy_call = "special_macro!$_HOSTCUSTOM1$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert 'plugins/nothing value' == macros_command
# Parse custom macro to get host custom variables based upon another macro
# host has a custom variable defined as _custom2 = $HOSTNAME$
dummy_call = "special_macro!$_HOSTCUSTOM2$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert 'plugins/nothing test_macro_host' == macros_command
# Parse custom macro to get host custom variables based upon another macro
# host has a custom variable defined as _custom2 = $HOSTNAME$
dummy_call = "special_macro!$_HOSTCUSTOM3$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
print(("Command: %s" % macros_command))
assert 'plugins/nothing 10' == macros_command
def test_host_macros(self):
"""Test host macros
:return:
"""
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
# First group name
dummy_call = "special_macro!$HOSTGROUPNAME$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert macros_command == 'plugins/nothing allhosts'
# All group names
dummy_call = "special_macro!$HOSTGROUPNAMES$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert macros_command == 'plugins/nothing allhosts,hostgroup_01,up'
# First group alias
dummy_call = "special_macro!$HOSTGROUPALIAS$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert macros_command == 'plugins/nothing All Hosts'
# All group aliases
dummy_call = "special_macro!$HOSTGROUPALIASES$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert macros_command == 'plugins/nothing All Hosts,All Up Hosts,hostgroup_alias_01'
def __init__(self, params=None, parsing=True):
if params is None:
params = {}
# At deserialization, thoses are dict
# TODO: Separate parsing instance from recreated ones
if 'check_command' in params and isinstance(params['check_command'],
dict):
# We recreate the object
self.check_command = CommandCall(params['check_command'])
# And remove prop, to prevent from being overridden
del params['check_command']
super(CheckModulation, self).__init__(params, parsing=parsing)
def test_args_macro(self):
"""
Test ARGn macros
:return:
"""
self.print_header()
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
# command_with_args is defined with 5 arguments as:
# $PLUGINSDIR$/command -H $HOSTADDRESS$ -t 9 -u -c $ARG1$ -a $ARG2$ $ARG3$ $ARG4$ and the last is $ARG5$.
# No arguments are provided - will be valued as empty strings
dummy_call = "command_with_args"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert com == \
'plugins/command -H 127.0.0.1 -t 9 -u -c ' \
'-a and the last is .'
# Extra arguments are provided - will be ignored
dummy_call = "command_with_args!arg_1!arg_2!arg_3!arg_4!arg_5!extra argument"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert com == \
'plugins/command -H 127.0.0.1 -t 9 -u -c arg_1 ' \
'-a arg_2 arg_3 arg_4 and the last is arg_5.'
# All arguments are provided
dummy_call = "command_with_args!arg_1!arg_2!arg_3!arg_4!arg_5"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert com == \
'plugins/command -H 127.0.0.1 -t 9 -u -c arg_1 ' \
'-a arg_2 arg_3 arg_4 and the last is arg_5.'
def test_illegal_macro_output_chars(self):
""" Check output macros are cleaned from illegal macro characters
$HOSTOUTPUT$, $HOSTPERFDATA$, $HOSTACKAUTHOR$, $HOSTACKCOMMENT$,
$SERVICEOUTPUT$, $SERVICEPERFDATA$, $SERVICEACKAUTHOR$, $SERVICEACKCOMMENT$
"""
self.print_header()
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
illegal_macro_output_chars = \
self._sched.conf.illegal_macro_output_chars
print "Illegal macros caracters:", illegal_macro_output_chars
hst.output = 'fake output'
dummy_call = "special_macro!$HOSTOUTPUT$"
for c in illegal_macro_output_chars:
hst.output = 'fake output' + c
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
print com
assert 'plugins/nothing fake output' == com
def test_command(self):
t = {'command_name': 'check_command_test',
'command_line': '/tmp/dummy_command.sh $ARG1$ $ARG2$',
'poller_tag': 'DMZ'
}
c = Command(t)
self.assertEqual('check_command_test', c.command_name)
b = c.get_initial_status_brok()
self.assertEqual('initial_command_status', b.type)
# now create a commands packs
cs = Commands([c])
dummy_call = "check_command_test!titi!toto"
cc = CommandCall(cs, dummy_call)
self.assertEqual(True, cc.is_valid())
self.assertEqual(c, cc.command)
self.assertEqual('DMZ', cc.poller_tag)
def test_unicode_macro(self):
"""
Call the resolver with a unicode content
:return:
"""
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
hst.state = 'UP'
hst.output = u"На берегу пустынных волн"
dummy_call = "special_macro!$HOSTOUTPUT$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
# Output is correctly restitued
assert u'plugins/nothing На берегу пустынных волн' == macros_command
hst.state = 'UP'
hst.output = 'Père Noël'
dummy_call = "special_macro!$HOSTOUTPUT$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
# Output is correctly restitued
assert u'plugins/nothing Père Noël' == macros_command
hst.state = 'UP'
hst.output = 'Père Noël'
dummy_call = "special_macro!$HOSTOUTPUT$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
# Output is correctly restitued
assert u'plugins/nothing Père Noël' == macros_command
def test_command(self):
t = {
'command_name': 'check_command_test',
'command_line': '/tmp/dummy_command.sh $ARG1$ $ARG2$',
'poller_tag': 'DMZ'
}
c = Command(t)
self.assertEqual('check_command_test', c.command_name)
b = c.get_initial_status_brok()
self.assertEqual('initial_command_status', b.type)
# now create a commands packs
cs = Commands([c])
dummy_call = "check_command_test!titi!toto"
cc = CommandCall(cs, dummy_call)
self.assertEqual(True, cc.is_valid())
self.assertEqual(c, cc.command)
self.assertEqual('DMZ', cc.poller_tag)
def test_special_macros_realm(self):
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = svc.get_data_for_checks()
hst.state = 'UP'
dummy_call = "special_macro!$HOSTREALM$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing Default', com)
def test_hostadressX_macros(self):
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = hst.get_data_for_checks()
# Ok sample host call
dummy_call = "special_macro!$HOSTADDRESS6$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing ::1', com)
def test_commands_pack(self):
""" Test commands pack build
:return: None
"""
t = {
'command_name': 'check_command_test',
'command_line': '/tmp/dummy_command.sh $ARG1$ $ARG2$',
'module_type': 'nrpe-booster',
'poller_tag': 'DMZ',
'reactionner_tag': 'REAC'
}
c = Command(t)
# now create a commands packs
cs = Commands([c])
dummy_call = "check_command_test!titi!toto"
cc = CommandCall({"commands": cs, "call": dummy_call})
assert True == cc.is_valid()
assert c == cc.command
assert 'DMZ' == cc.poller_tag
assert 'REAC' == cc.reactionner_tag
def test_resource_file(self):
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = svc.get_data_for_checks()
dummy_call = "special_macro!$USER1$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
self.assertEqual('plugins/nothing plugins', com)
dummy_call = "special_macro!$INTERESTINGVARIABLE$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print "CUCU", com
self.assertEqual('plugins/nothing interestingvalue', com)
# Look for multiple = in lines, should split the first
# and keep others in the macro value
dummy_call = "special_macro!$ANOTHERVALUE$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print "CUCU", com
self.assertEqual('plugins/nothing blabla=toto', com)
def test_commands_pack(self):
""" Test commands pack build
:return: None
"""
t = {
'command_name': 'check_command_test',
'command_line': '/tmp/dummy_command.sh $ARG1$ $ARG2$',
'module_type': 'nrpe-booster',
'poller_tag': 'DMZ',
'reactionner_tag': 'REAC'
}
c = Command(t)
# now create a commands packs
cs = Commands([c])
dummy_call = "check_command_test!titi!toto"
cc = CommandCall({"commands": cs, "call": dummy_call})
assert True == cc.is_valid()
assert c == cc.command
assert 'DMZ' == cc.poller_tag
assert 'REAC' == cc.reactionner_tag
def __init__(self, params=None, parsing=True):
if params is None:
params = {}
# At deserialization, thoses are dict
# TODO: Separate parsing instance from recreated ones
if 'check_command' in params and isinstance(params['check_command'], dict):
# We recreate the object
self.check_command = CommandCall(params['check_command'])
# And remove prop, to prevent from being overridden
del params['check_command']
super(CheckModulation, self).__init__(params, parsing=parsing)
def test_ondemand_macros(self):
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = hst.get_data_for_checks()
hst.state = 'UP'
svc.state = 'UNKNOWN'
# Ok sample host call
dummy_call = "special_macro!$HOSTSTATE:test_host_0$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing UP', com)
# Call with a void host name, means : myhost
data = hst.get_data_for_checks()
dummy_call = "special_macro!$HOSTSTATE:$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing UP', com)
# Now with a service, for our implicit host state
data = svc.get_data_for_checks()
dummy_call = "special_macro!$HOSTSTATE:test_host_0$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing UP', com)
# Now with a service, for our implicit host state
data = svc.get_data_for_checks()
dummy_call = "special_macro!$HOSTSTATE:$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing UP', com)
# Now prepare another service
svc2 = self.sched.services.find_srv_by_name_and_hostname(
"test_host_0", "test_another_service")
svc2.output = 'you should not pass'
# Now call this data from our previous service
data = svc.get_data_for_checks()
dummy_call = "special_macro!$SERVICEOUTPUT:test_host_0:test_another_service$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing you should not pass', com)
# Ok now with a host implicit way
data = svc.get_data_for_checks()
dummy_call = "special_macro!$SERVICEOUTPUT::test_another_service$"
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing you should not pass', com)
def test_host_custom_macros(self):
"""
Test on-demand macros with custom variables for hosts
:return:
"""
self.print_header()
mr = self.get_mr()
hst = self._sched.hosts.find_by_name("test_macro_host")
# The host has custom variables, thus we may use them in a macro
assert hst.customs is not []
assert '_CUSTOM1' in hst.customs
assert '_CUSTOM2' in hst.customs
data = [hst]
# Parse custom macro to get host custom variables based upon a fixed value
# host has a custom variable defined as _custom1 = value
dummy_call = "special_macro!$_HOSTCUSTOM1$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing value' == com
# Parse custom macro to get host custom variables based upon another macro
# host has a custom variable defined as _custom2 = $HOSTNAME$
dummy_call = "special_macro!$_HOSTCUSTOM2$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing test_macro_host' == com
def __init__(self, params=None, parsing=True):
if params is None:
params = {}
# At deserialization, thoses are dict
# TODO: Separate parsing instance from recreated ones
for prop in ['service_notification_commands', 'host_notification_commands']:
if prop in params and isinstance(params[prop], list) and params[prop] \
and isinstance(params[prop][0], dict):
new_list = [CommandCall(elem, parsing=parsing) for elem in params[prop]]
# We recreate the object
setattr(self, prop, new_list)
# And remove prop, to prevent from being overridden
del params[prop]
super(NotificationWay, self).__init__(params, parsing=parsing)
def test_illegal_macro_output_chars(self):
"$HOSTOUTPUT$, $HOSTPERFDATA$, $HOSTACKAUTHOR$, $HOSTACKCOMMENT$, $SERVICEOUTPUT$, $SERVICEPERFDATA$, $SERVICEACKAUTHOR$, and $SERVICEACKCOMMENT$ "
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = svc.get_data_for_checks()
illegal_macro_output_chars = self.sched.conf.illegal_macro_output_chars
print "Illegal macros caracters:", illegal_macro_output_chars
hst.output = 'monculcestdupoulet'
dummy_call = "special_macro!$HOSTOUTPUT$"
for c in illegal_macro_output_chars:
hst.output = 'monculcestdupoulet' + c
cc = CommandCall(self.conf.commands, dummy_call)
com = mr.resolve_command(cc, data)
print com
self.assertEqual('plugins/nothing monculcestdupoulet', com)
def test_escape_macro(self):
"""
Call the resolver with an empty macro ($$)
:return:
"""
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
hst.state = 'UP'
dummy_call = "special_macro!$$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
# Not a macro but $$ is transformed as $
assert 'plugins/nothing $' == macros_command
def test_hostadressX_macros(self):
"""
Host addresses macros
:return:
"""
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
# Ok sample host call
dummy_call = "special_macro!$HOSTADDRESS$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert 'plugins/nothing 127.0.0.1' == macros_command
def test_special_macros_realm(self):
"""
Call the resolver with a special macro HOSTREALM
:return:
"""
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
hst.state = 'UP'
dummy_call = "special_macro!$HOSTREALM$"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
# Macro raised the default realm (All)
assert 'plugins/nothing All' == macros_command
def create_commandcall(prop, commands, command):
"""
Create commandCall object with command
:param prop: property
:type prop: str
:param commands: all commands
:type commands: alignak.objects.command.Commands
:param command: a command object
:type command: str
:return: a commandCall object
:rtype: object
"""
comandcall = dict(commands=commands, call=command)
if hasattr(prop, 'enable_environment_macros'):
comandcall['enable_environment_macros'] = prop.enable_environment_macros
if hasattr(prop, 'poller_tag'):
comandcall['poller_tag'] = prop.poller_tag
elif hasattr(prop, 'reactionner_tag'):
comandcall['reactionner_tag'] = prop.reactionner_tag
return CommandCall(comandcall)
def create_commandcall(prop, commands, command):
"""
Create CommandCall object with command
:param prop: property
:type prop: str
:param commands: all commands
:type commands: alignak.objects.command.Commands
:param command: a command object
:type command: str
:return: a commandCall object
:rtype: alignak.objects.commandcallitem.CommandCall
"""
cc = {'commands': commands, 'call': command}
if hasattr(prop, 'enable_environment_macros'):
cc['enable_environment_macros'] = prop.enable_environment_macros
if hasattr(prop, 'poller_tag'):
cc['poller_tag'] = prop.poller_tag
elif hasattr(prop, 'reactionner_tag'):
cc['reactionner_tag'] = prop.reactionner_tag
return CommandCall(cc)
class CheckModulation(Item):
"""CheckModulation class is simply a modulation of the check command (of a Host/Service)
during a check_period.
"""
my_type = 'checkmodulation'
properties = Item.properties.copy()
properties.update({
'checkmodulation_name':
StringProp(fill_brok=['full_status']),
'check_command':
StringProp(fill_brok=['full_status']),
'check_period':
StringProp(brok_transformation=to_name_if_possible,
fill_brok=['full_status']),
})
running_properties = Item.running_properties.copy()
special_properties = ('check_period', )
macros = {}
def __init__(self, params=None, parsing=True):
if params is None:
params = {}
# At deserialization, thoses are dict
# TODO: Separate parsing instance from recreated ones
if 'check_command' in params and isinstance(params['check_command'],
dict):
# We recreate the object
self.check_command = CommandCall(params['check_command'])
# And remove prop, to prevent from being overridden
del params['check_command']
super(CheckModulation, self).__init__(params, parsing=parsing)
def serialize(self):
res = super(CheckModulation, self).serialize()
res['check_command'] = self.check_command.serialize()
return res
def get_name(self):
"""Accessor to checkmodulation_name attribute
:return: check modulation name
:rtype: str
"""
if hasattr(self, 'checkmodulation_name'):
return self.checkmodulation_name
return 'Unnamed'
def get_check_command(self, timeperiods, t_to_go):
"""Get the check_command if we are in the check period modulation
:param t_to_go: time to check if we are in the timeperiod
:type t_to_go:
:return: A check command if we are in the check period, None otherwise
:rtype: alignak.objects.command.Command
"""
if not self.check_period or timeperiods[
self.check_period].is_time_valid(t_to_go):
return self.check_command
return None
def is_correct(self):
"""Check if this object configuration is correct ::
* Check our own specific properties
* Call our parent class is_correct checker
:return: True if the configuration is correct, otherwise False
:rtype: bool
"""
state = True
# Internal checks before executing inherited function...
if not hasattr(self, 'check_command'):
msg = "[checkmodulation::%s] do not have any check_command defined" % (
self.get_name())
self.configuration_errors.append(msg)
state = False
else:
if self.check_command is None:
msg = "[checkmodulation::%s] a check_command is missing" % (
self.get_name())
self.configuration_errors.append(msg)
state = False
if not self.check_command.is_valid():
msg = "[checkmodulation::%s] a check_command is invalid" % (
self.get_name())
self.configuration_errors.append(msg)
state = False
# Ok just put None as check_period, means 24x7
if not hasattr(self, 'check_period'):
self.check_period = None
return super(CheckModulation, self).is_correct() and state
class CheckModulation(Item):
"""CheckModulation class is simply a modulation of the check command (of a Host/Service)
during a check_period.
"""
my_type = 'checkmodulation'
properties = Item.properties.copy()
properties.update({
'checkmodulation_name':
StringProp(fill_brok=['full_status']),
'check_command':
StringProp(fill_brok=['full_status']),
'check_period':
StringProp(brok_transformation=to_name_if_possible, fill_brok=['full_status']),
})
running_properties = Item.running_properties.copy()
special_properties = ('check_period',)
macros = {}
def __init__(self, params=None, parsing=True):
if params is None:
params = {}
# At deserialization, thoses are dict
# TODO: Separate parsing instance from recreated ones
if 'check_command' in params and isinstance(params['check_command'], dict):
# We recreate the object
self.check_command = CommandCall(params['check_command'])
# And remove prop, to prevent from being overridden
del params['check_command']
super(CheckModulation, self).__init__(params, parsing=parsing)
def serialize(self):
res = super(CheckModulation, self).serialize()
res['check_command'] = None
if getattr(self, 'check_command', None):
res['check_command'] = self.check_command.serialize()
return res
def get_name(self):
"""Accessor to checkmodulation_name attribute
:return: check modulation name
:rtype: str
"""
if hasattr(self, 'checkmodulation_name'):
return self.checkmodulation_name
return 'Unnamed'
def get_check_command(self, timeperiods, t_to_go):
"""Get the check_command if we are in the check period modulation
:param t_to_go: time to check if we are in the timeperiod
:type t_to_go:
:return: A check command if we are in the check period, None otherwise
:rtype: alignak.objects.command.Command
"""
if not self.check_period or timeperiods[self.check_period].is_time_valid(t_to_go):
return self.check_command
return None
def is_correct(self):
"""Check if this object configuration is correct ::
* Check our own specific properties
* Call our parent class is_correct checker
:return: True if the configuration is correct, otherwise False
:rtype: bool
"""
state = True
# Internal checks before executing inherited function...
if not hasattr(self, 'check_command'):
msg = "[checkmodulation::%s] do not have any check_command defined" % (
self.get_name()
)
self.add_error(msg)
state = False
else:
if self.check_command is None:
msg = "[checkmodulation::%s] a check_command is missing" % (self.get_name())
self.add_error(msg)
state = False
if self.check_command and not self.check_command.is_valid():
msg = "[checkmodulation::%s] a check_command is invalid" % (self.get_name())
self.add_error(msg)
state = False
# Ok just put None as check_period, means 24x7
if not hasattr(self, 'check_period'):
self.check_period = None
return super(CheckModulation, self).is_correct() and state
def test_args_macro(self):
"""
Test ARGn macros
:return:
"""
print("Initial test macros: %d - %s" %
(len(self._scheduler.pushed_conf.__class__.macros),
self._scheduler.pushed_conf.__class__.macros))
print(" - : %s" %
(self._scheduler.pushed_conf.__class__.properties['$USER1$']))
print(" - : %s" % (self._scheduler.pushed_conf.properties['$USER1$']))
print(" - : %s" %
(getattr(self._scheduler.pushed_conf, '$USER1$', None)))
for key in self._scheduler.pushed_conf.__class__.macros:
key = self._scheduler.pushed_conf.__class__.macros[key]
if key:
value = getattr(self._scheduler.pushed_conf.properties, key,
'')
print(" - %s : %s" %
(key, self._scheduler.pushed_conf.properties[key]))
if value:
print("- %s = %s" % (key, value))
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
# command_with_args is defined with 5 arguments as:
# $PLUGINSDIR$/command -H $HOSTADDRESS$ -t 9 -u -c $ARG1$
# -a $ARG2$ $ARG3$ $ARG4$ and the last is $ARG5$.
# No arguments are provided - will be valued as empty strings
dummy_call = "command_with_args"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
# todo: Test problem is here!
# Whereas we should get:
assert macros_command == 'plugins/command -H 127.0.0.1 -t 9 -u -c -a and the last is .'
# We get:
# assert macros_command == '/var/lib/shinken/libexec/command -H 127.0.0.1 -t 9 -u -c -a and the last is .'
# Outside the test env, everything is ok ! Because some tests executed before the macro
# do not have the correct value!
# Extra arguments are provided - will be ignored
dummy_call = "command_with_args!arg_1!arg_2!arg_3!arg_4!arg_5!extra argument"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert macros_command == 'plugins/command -H 127.0.0.1 -t 9 -u -c arg_1 ' \
'-a arg_2 arg_3 arg_4 and the last is arg_5.'
# All arguments are provided
dummy_call = "command_with_args!arg_1!arg_2!arg_3!arg_4!arg_5"
cc = CommandCall({
"commands": self._arbiter.conf.commands,
"call": dummy_call
})
macros_command = self.mr.resolve_command(
cc, data, self._scheduler.macromodulations,
self._scheduler.timeperiods)
assert macros_command == 'plugins/command -H 127.0.0.1 -t 9 -u -c arg_1 ' \
'-a arg_2 arg_3 arg_4 and the last is arg_5.'
def test_datetime_macros(self):
""" Test date / time macros: SHORTDATETIME, LONGDATETIME, DATE, TIME, ...
:return:
"""
self.print_header()
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
hst.state = 'UP'
# Long and short datetime
dummy_call = "special_macro!$LONGDATETIME$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
dummy_call = "special_macro!$SHORTDATETIME$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
dummy_call = "special_macro!$DATE$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
dummy_call = "special_macro!$TIME$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
dummy_call = "special_macro!$TIMET$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
# Do not check that the output of these macro is correct
# because there is no specific macro code for those functions ;)
# Process and event start time
dummy_call = "special_macro!$PROCESSSTARTTIME$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing n/a' == com
dummy_call = "special_macro!$EVENTSTARTTIME$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing n/a' == com
def test_summary_macros(self):
""" Test summary macros: TOTALHOSTSUP, TOTALHOSTDOWN, ...
:return:
"""
self.print_header()
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
hst.state = 'UP'
# Number of hosts UP / DOWN / UNREACHABLE
dummy_call = "special_macro!$TOTALHOSTSUP$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 3' == com
# Now my host is DOWN and not yet handled
hst.state = 'DOWN'
hst.is_problem = True
hst.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALHOSTSDOWN$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
dummy_call = "special_macro!$TOTALHOSTSDOWNUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Now my host is DOWN but handled
hst.problem_has_been_acknowledged = True
dummy_call = "special_macro!$TOTALHOSTSDOWNUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Now my host is UNREACHABLE and not yet handled
hst.state = 'UNREACHABLE'
hst.is_problem = True
hst.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALHOSTSUNREACHABLE$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
dummy_call = "special_macro!$TOTALHOSTSUNREACHABLEUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Now my host is UNREACHABLE but handled
hst.problem_has_been_acknowledged = True
dummy_call = "special_macro!$TOTALHOSTSUNREACHABLEUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Now my host is DOWN and not yet handled
hst.state = 'DOWN'
hst.is_problem = True
hst.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALHOSTPROBLEMS$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
dummy_call = "special_macro!$TOTALHOSTPROBLEMSUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Now my host is UP and no more a problem
hst.state = 'UP'
hst.is_problem = False
hst.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALHOSTPROBLEMS$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
dummy_call = "special_macro!$TOTALHOSTPROBLEMSUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Number of services OK / WARNING / CRITICAL / UNKNOWN
dummy_call = "special_macro!$TOTALSERVICESOK$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 2' == com
# Now my service is WARNING and not handled
svc.state = 'WARNING'
svc.is_problem = True
svc.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALSERVICESWARNING$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
dummy_call = "special_macro!$TOTALSERVICESWARNINGUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Now my service problem is handled
svc.problem_has_been_acknowledged = True
dummy_call = "special_macro!$TOTALSERVICESWARNINGUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Now my service is CRITICAL and not handled
svc.state = 'CRITICAL'
svc.is_problem = True
svc.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALSERVICESCRITICAL$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
dummy_call = "special_macro!$TOTALSERVICESCRITICALUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Now my service problem is handled
svc.problem_has_been_acknowledged = True
dummy_call = "special_macro!$TOTALSERVICESCRITICALUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Now my service is UNKNOWN and not handled
svc.state = 'UNKNOWN'
svc.is_problem = True
svc.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALSERVICESUNKNOWN$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
dummy_call = "special_macro!$TOTALSERVICESUNKNOWNUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Now my service problem is handled
svc.problem_has_been_acknowledged = True
dummy_call = "special_macro!$TOTALSERVICESUNKNOWNUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Now my service is WARNING and not handled
svc.state = 'WARNING'
svc.is_problem = True
svc.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALSERVICEPROBLEMS$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
dummy_call = "special_macro!$TOTALSERVICEPROBLEMSUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Now my service is OK and no more a problem
svc.state = 'OK'
svc.is_problem = False
svc.problem_has_been_acknowledged = False
dummy_call = "special_macro!$TOTALSERVICEPROBLEMS$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
dummy_call = "special_macro!$TOTALSERVICEPROBLEMSUNHANDLED$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
def test_ondemand_macros(self):
"""Test on-demand macros
:return:
"""
self.print_header()
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
hst.state = 'UP'
svc.state = 'UNKNOWN'
# Get another service
svc2 = self._sched.conf.services.find_srv_by_name_and_hostname(
"test_host_0", "test_another_service")
svc2.output = 'you should not pass'
# Request a not existing macro
dummy_call = "special_macro!$HOSTXXX:test_host_0$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing' == com
# Request a specific host state
dummy_call = "special_macro!$HOSTSTATE:test_host_0$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing UP' == com
# Call with a void host name, means : myhost
data = [hst]
dummy_call = "special_macro!$HOSTSTATE:$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing UP' == com
# Now with a service, for our implicit host state
data = [hst, svc]
dummy_call = "special_macro!$HOSTSTATE:test_host_0$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing UP' == com
# Now with a service, for our implicit host state (missing host ...)
data = [hst, svc]
dummy_call = "special_macro!$HOSTSTATE:$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing UP' == com
# Now call this data from our previous service - get service state
data = [hst, svc2]
dummy_call = "special_macro!$SERVICESTATE:test_host_0:test_another_service$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing OK' == com
# Now call this data from our previous service - get service output
data = [hst, svc2]
dummy_call = "special_macro!$SERVICEOUTPUT:test_host_0:test_another_service$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing you should not pass' == com
# Ok now with a host implicit way
svc2.output = 'you should not pass'
data = [hst, svc2]
dummy_call = "special_macro!$SERVICEOUTPUT::test_another_service$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing you should not pass' == com
def test_host_count_services_macros(self):
"""Test services count for an hostmacros
:return:
"""
self.print_header()
mr = self.get_mr()
(svc, hst) = self.get_hst_svc()
data = [hst, svc]
hst.state = 'UP'
# Get another service
svc2 = self._sched.conf.services.find_srv_by_name_and_hostname(
"test_host_0", "test_another_service")
svc2.output = 'you should not pass'
# Total
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICES$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 2' == com
# Services states
svc.state_id = 0
svc.state = 'OK'
svc2.state_id = 1
svc2.state = 'WARNING'
# Ok
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESOK$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Warning
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESWARNING$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Critical
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESCRITICAL$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Unknown
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESUNKNOWN$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Unreachable
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESUNREACHABLE$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Change states
svc.state_id = 2
svc.state = 'CRITICAL'
svc2.state_id = 3
svc2.state = 'UNKNOWN'
# Ok
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESOK$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Warning
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESWARNING$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com
# Critical
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESCRITICAL$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Unknown
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESUNKNOWN$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 1' == com
# Unreachable
svc.output = 'you should not pass'
data = [hst, svc]
dummy_call = "special_macro!$TOTALHOSTSERVICESUNREACHABLE$"
cc = CommandCall({
"commands": self.arbiter.conf.commands,
"call": dummy_call
})
com = mr.resolve_command(cc, data, self._sched.macromodulations,
self._sched.timeperiods)
assert 'plugins/nothing 0' == com