/usr/lib/python2.7/dist-packages/shinken/objects/discoveryrun.py is in shinken-common 1.4-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | #!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright (C) 2009-2012:
# Gabes Jean, naparuba@gmail.com
# Gerhard Lausser, Gerhard.Lausser@consol.de
# Gregory Starck, g.starck@gmail.com
# Hartmut Goebel, h.goebel@goebel-consult.de
#
# This file is part of Shinken.
#
# Shinken is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Shinken 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken. If not, see <http://www.gnu.org/licenses/>.
import re
from copy import copy
from item import Item, Items
from shinken.objects.matchingitem import MatchingItem
from shinken.property import StringProp
from shinken.eventhandler import EventHandler
from shinken.macroresolver import MacroResolver
class Discoveryrun(MatchingItem):
id = 1 # zero is always special in database, so we do not take risk here
my_type = 'discoveryrun'
properties = Item.properties.copy()
properties.update({
'discoveryrun_name': StringProp(),
'discoveryrun_command': StringProp(),
})
running_properties = Item.running_properties.copy()
running_properties.update({
'current_launch': StringProp(default=None),
})
# The init of a discovery will set the property of
# Discoveryrun.properties as in setattr, but all others
# will be in a list because we need to have all names
# and not lost all in __dict__
def __init__(self, params={}):
cls = self.__class__
# We have our own id of My Class type :)
# use set attr for going into the slots
# instead of __dict__ :)
setattr(self, 'id', cls.id)
cls.id += 1
self.matches = {} # for matching rules
self.not_matches = {} # for rules that should NOT match
# In my own property:
# -> in __dict__
# if not, in matches or not match (if key starts
# with a !, it's a not rule)
# -> in self.matches or self.not_matches
# in writing properties if start with + (means 'add this')
for key in params:
if key in cls.properties:
setattr(self, key, params[key])
else:
if key.startswith('!'):
key = key.split('!')[1]
self.not_matches[key] = params['!'+key]
else:
self.matches[key] = params[key]
# Then running prop :)
cls = self.__class__
# adding running properties like latency, dependency list, etc
for prop, entry in cls.running_properties.items():
# Copy is slow, so we check type
# Type with __iter__ are list or dict, or tuple.
# Item need it's own list, so qe copy
val = entry.default
if hasattr(val, '__iter__'):
setattr(self, prop, copy(val))
else:
setattr(self, prop, val)
# each instance to have his own running prop!
# Output name
def get_name(self):
try:
return self.discoveryrun_name
except AttributeError:
return "UnnamedDiscoveryRun"
# A Run that is first level means that it do not have
# any matching filter
def is_first_level(self):
return len(self.not_matches) + len(self.matches) == 0
# Get an eventhandler object and launch it
def launch(self, ctx=[], timeout=300):
m = MacroResolver()
cmd = m.resolve_command(self.discoveryrun_command, ctx)
self.current_launch = EventHandler(cmd, timeout=timeout)
self.current_launch.execute()
def check_finished(self):
max_output = 10 ** 9
#print "Max output", max_output
self.current_launch.check_finished(max_output)
# Look if the current launch is done or not
def is_finished(self):
if self.current_launch == None:
return True
if self.current_launch.status in ('done', 'timeout'):
return True
return False
# we use an EventHandler object, so we have output with a single line
# and longoutput with the rest. We just need to return all
def get_output(self):
return '\n'.join([self.current_launch.output, self.current_launch.long_output])
class Discoveryruns(Items):
name_property = "discoveryrun_name"
inner_class = Discoveryrun
def linkify(self, commands):
for r in self:
r.linkify_one_command_with_commands(commands, 'discoveryrun_command')
|