Source Code for Module linspector.lib.config.hostgroups

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