Source Code for Module linspector.lib.config.hostgroups

  1   
  2 -class HostGroupException(Exception): 
  3 -    def __init__(self, msg): 
  4          self.msg = msg 
  5           
  6 -    def __str__(self): 
  7          return repr(self.msg) 
  8       
  9 -class HostGroupMissingArgumentException(HostGroupException): 
 10 -    def __init__(self, missingArgument, hostgroupName): 
 11          super(HostGroupMissingArgumentException, self).__init__("no " + missingArgument + " defined for Hostgroup " + hostgroupName) 
 12   
 13 -class HostGroup: 
 14 -    def __init__(self, name, **kwargs): 
 15          self.name = name 
 16          tmp = "members" 
 17          self.members = [] 
 18          if not tmp in kwargs: 
 19              raise HostGroupMissingArgumentException(tmp, name) 
 20          self.add_members(kwargs[tmp]) 
 21           
 22          tmp = "hosts" 
 23          self.hosts = [] 
 24          if not tmp in kwargs: 
 25              raise HostGroupMissingArgumentException(tmp, name) 
 26          self.add_hosts(kwargs[tmp]) 
 27           
 28          tmp = "services" 
 29          self.services = [] 
 30          if not tmp in kwargs: 
 31              raise HostGroupMissingArgumentException(tmp, name) 
 32          self.add_services(kwargs[tmp]) 
 33           
 34          self.parents = [] 
 35          tmp = "parents" 
 36          if tmp in kwargs: 
 37              self.add_parents(kwargs[tmp]) 
 38           
 39          tmp = "processors" 
 40          self.processors = [] 
 41          if tmp in kwargs: 
 42              self.add_processors(kwargs[tmp]) 
 43           
 44 -    def _to_config_dict(self, configDict): 
 45          me = {} 
 46          me["members"] = [member.nameid for member in self.get_members()] 
 47          me["hosts"] = self.hosts 
 48          me["parents"] = [hg.get_name() for hg in self.get_parents()] 
 49          #TODO implement delegation 
 50          #me["services"] = [service._to_config_dict(configDict) for service in self.get_services()] 
 51          #me["processors"] = [processor._to_config_dict(configDict) for processor in self.get_processors()] 
 52          configDict["hostgroups"][self.get_name()] = me 
 53   
 54 -    def __add_internal(self, l, item): 
 55          if isinstance(item, list): 
 56              l.extend(item) 
 57          else: 
 58              l.append(item) 
 59       
 60 -    def add_members(self, member): 
 61          self.__add_internal(self.get_members(), member) 
 62               
 63 -    def add_hosts(self, host): 
 64          self.__add_internal(self.get_hosts(), host) 
 65       
 66 -    def add_processors(self, processor): 
 67          self.__add_internal(self.get_processors(), processor) 
 68            
 69 -    def add_parents(self, parent): 
 70          self.__add_internal(self.get_parents(), parent) 
 71   
 72 -    def add_services(self, services): 
 73          self.__add_internal(self.get_services(), services) 
 74       
 75 -    def get_parents(self): 
 76          return self.parents 
 77            
 78 -    def get_processors(self): 
 79          return self.processors 
 80       
 81 -    def get_services(self): 
 82          return self.services 
 83       
 84 -    def get_hosts(self): 
 85          return self.hosts 
 86       
 87 -    def get_name(self): 
 88          return self.name 
 89       
 90 -    def get_members(self): 
 91          return self.members  
 92   
 93 -    def __str__(self): 
 94          ret = "HostGroup: " + self.name + " threshold: " + str(self.threshold) + " parent: " + self.parent + "\n" 
 95          ret += "members: {\n" 
 96          for itm in self.members: 
 97              ret += str(itm) + "\n" 
 98          ret += "}\n" 
 99          ret += "hosts: {\n" 
100          for itm in self.hosts: 
101              ret += str(itm) + "\n" 
102          ret += "}\n" 
103          ret += "services: {\n" 
104          for itm in self.services: 
105              ret += str(itm) + "\n" 
106          ret += "}\n" 
107          return ret 
108   
109   
110 -class HostGroupService: 
111 -    def __init__(self, services, periods): 
112          self.services = services 
113          self.periods = periods 
114   
115 -    def __str__(self): 
116          return "HostgroupService { " + str([str(s) for s in self.services]) + ", " + str([p.name for p in self.periods]) + "}" 
117   
118   
119 -def parseHostGroupList(hostgroups, hosts, members, periods, services, log): 
120      parsedHostGroups = [] 
121      for hgname, hgValues in hostgroups.items(): 
122          hostGroup = HostGroup(hgname) 
123          hostGroup.members = [m for m in members if m.nameid in hgValues['members']] 
124          hostGroup.hosts = [h for h in hosts if h.name in hgValues['hosts']] 
125          hostGroup.threshold = hgValues['threshold'] 
126          if 'parent' in hgValues: 
127              hostGroup.parent = hgValues['parent'] 
128          hostGroup.services = [] 
129          for serviceName, servicePeriods in hgValues['services'].items(): 
130              services = [] 
131              for host in hosts: 
132                  service = host.getHostServiceByName(serviceName) 
133                  if service is not None:  
134                      services.append(service) 
135                  else: 
136                      log.w("could not find HostService(" + str(serviceName) + ") for host " + host.name) 
137              hostGroupPeriods = [p for p in periods if p.name in servicePeriods] 
138              hostGroup.services.append(HostGroupService(services, hostGroupPeriods)) 
139          parsedHostGroups.append(hostGroup) 
140      return parsedHostGroups 
141