Coverage for src/zenossapi/routers/monitor.py: 94%

1# -*- coding: utf-8 -*- 

2 

3""" 

4Zenoss monitor_router 

5""" 

6 

7from zenossapi.apiclient import ZenossAPIClientError 

8from zenossapi.routers import ZenossRouter 

9 

10 

11class MonitorRouter(ZenossRouter): 

12 """ 

13 Class for interacting with the Zenoss monitor router 

14 """ 

15 

16 def __init__(self, url, headers, ssl_verify): 

17 super(MonitorRouter, self).__init__(url, headers, ssl_verify, 

18 'monitor_router', 'MonitorRouter') 

19 self.id = None 

20 

21 def __repr__(self): 

22 if self.id: 

23 identifier = self.id 

24 else: 

25 identifier = hex(id(self)) 

26 

27 return '<{0} object at {1}>'.format( 

28 type(self).__name__, identifier 

29 ) 

30 

31 def tree(self): 

32 """ 

33 Returns the full tree of hubs and collectors 

34 

35 Returns: 

36 list(dict): 

37 """ 

38 return self._router_request( 

39 self._make_request_data( 

40 'getTree', 

41 data=dict(id='') 

42 ) 

43 ) 

44 

45 def list_hubs(self): 

46 """ 

47 Returns the list of configured zenhubs 

48 

49 Returns: 

50 list(dict): 

51 """ 

52 hubs_data = self.tree() 

53 hubs = [] 

54 for hub in hubs_data: 

55 hubs.append(dict(name=hub['name'], uid=hub['uid'].replace('/zport/dmd/', '', 1))) 

56 

57 return hubs 

58 

59 def list_collectors(self): 

60 """ 

61 Returns the list of configured collectors 

62 

63 Returns: 

64 list(dict): 

65 """ 

66 hubs_data = self.tree() 

67 collectors = [] 

68 for hub in hubs_data: 

69 for collector in hub['children']: 

70 collectors.append( 

71 dict( 

72 name=collector['name'], 

73 devcount=collector['devcount'], 

74 hub=hub['name'], 

75 uid=collector['uid'].replace('/zport/dmd/', '', 1) 

76 ) 

77 ) 

78 

79 return collectors 

80 

81 def get_hubs(self): 

82 """ 

83 Get the configured hubs as objects 

84 

85 Returns: 

86 list(ZenossHub): 

87 """ 

88 hubs_data = self.tree() 

89 hubs = [] 

90 for hub in hubs_data: 

91 hubs.append( 

92 ZenossHub( 

93 self.api_url, 

94 self.api_headers, 

95 self.ssl_verify, 

96 hub 

97 ) 

98 ) 

99 

100 return hubs 

101 

102 def get_hub(self, name): 

103 """ 

104 Get a ZenossHub object 

105 

106 Arguments: 

107 name (str): Name of the hub to get 

108 

109 Returns: 

110 ZenossHub: 

111 """ 

112 hubs_data = self.tree() 

113 for hub in hubs_data: 

114 if hub['name'] == name: 

115 return ZenossHub( 

116 self.api_url, 

117 self.api_headers, 

118 self.ssl_verify, 

119 hub 

120 ) 

121 

122 return None 

123 

124 

125class ZenossHub(MonitorRouter): 

126 """ 

127 Class for Zenoss hub objects 

128 """ 

129 

130 def __init__(self, url, headers, ssl_verify, hub_data): 

131 super(ZenossHub, self).__init__(url, headers, ssl_verify) 

132 

133 self.uid = hub_data['uid'].replace('/zport/dmd/', '', 1) 

134 self.name = hub_data['name'] 

135 self.text = hub_data['text'] 

136 self.id = hub_data['id'] 

137 self.devcount = hub_data['devcount'] 

138 self.path = hub_data['path'] 

139 self.ccbacked = hub_data['ccbacked'] 

140 self.collectors = [] 

141 

142 for c in hub_data['children']: 

143 self.collectors.append(c['name']) 

144 

145 def get_collectors(self): 

146 """ 

147 Get the hub's collectors as objects. 

148 

149 Returns: 

150 list(ZenossCollector): 

151 """ 

152 collectors = [] 

153 for c in self.collectors: 

154 cinfo = self._router_request( 

155 self._make_request_data( 

156 'getInfo', 

157 data=dict( 

158 id=c 

159 ) 

160 ) 

161 ) 

162 collectors.append( 

163 ZenossCollector( 

164 self.api_url, 

165 self.api_headers, 

166 self.ssl_verify, 

167 cinfo['data'] 

168 ) 

169 ) 

170 

171 return collectors 

172 

173 def get_collector(self, name): 

174 """ 

175 Get a ZenossCollector object 

176 

177 Arguments: 

178 name (str): Name of the collector to get 

179 

180 Returns: 

181 ZenossCollector: 

182 """ 

183 if name in self.collectors: 

184 cinfo = self._router_request( 

185 self._make_request_data( 

186 'getInfo', 

187 data=dict( 

188 id=name 

189 ) 

190 ) 

191 ) 

192 return ZenossCollector( 

193 self.api_url, 

194 self.api_headers, 

195 self.ssl_verify, 

196 cinfo['data'] 

197 ) 

198 

199 return None 

200 

201 def add_collector(self, name, source=None, pool=None): 

202 """ 

203 Add a new collector to the hub. 

204 

205 Arguments: 

206 name (str): Name of the new collector 

207 source (str): Name of the existing collector to use as a template 

208 pool (str): The resource pool to place the collector in 

209 

210 Returns: 

211 ZenossCollector: 

212 """ 

213 if not source: 

214 raise ZenossAPIClientError("You must specify a collector to use as a template.") 

215 

216 if not pool: 

217 raise ZenossAPIClientError("You must specify a resource pool for the collector.") 

218 

219 collector_params = self._router_request( 

220 self._make_request_data( 

221 'addCollector', 

222 data=dict( 

223 id=name, 

224 sourceId=source, 

225 hubId=self.name, 

226 poolId=pool 

227 ) 

228 ) 

229 ) 

230 

231 collector_data = self._router_request( 

232 self._make_request_data( 

233 'getInfo', 

234 data=dict( 

235 id=name 

236 ) 

237 ) 

238 ) 

239 

240 return ZenossCollector( 

241 self.api_url, 

242 self.api_headers, 

243 self.ssl_verify, 

244 collector_data=collector_data['data'], 

245 collector_params=collector_params 

246 ) 

247 

248 

249class ZenossCollector(MonitorRouter): 

250 """ 

251 Class for Zenoss collector objects 

252 """ 

253 

254 def __init__(self, url, headers, ssl_verify, collector_data, collector_params=None): 

255 super(ZenossCollector, self).__init__(url, headers, ssl_verify) 

256 

257 self.uid = collector_data['uid'].replace('/zport/dmd/', '', 1) 

258 self.ccbacked = collector_data['ccbacked'] 

259 self.name = collector_data['name'] 

260 self.text = collector_data['text'] 

261 self.devcount = collector_data['devcount'] 

262 self.path = collector_data['path'] 

263 self.id = collector_data['id'] 

264 

265 if not collector_params: 

266 collector_params = self._router_request( 

267 self._make_request_data( 

268 'getCollector', 

269 data=dict( 

270 collectorString=self.name 

271 ) 

272 ) 

273 ) 

274 

275 self.configCycleInterval = collector_params['data']['configCycleInterval'] 

276 self.pingCycleInterval = collector_params['data']['pingCycleInterval'] 

277 self.discoveryNetworks = collector_params['data']['discoveryNetworks'] 

278 self.description = collector_params['data']['description'] 

279 self.modelerCycleInterval = collector_params['data']['modelerCycleInterval'] 

280 self.processCycleInterval = collector_params['data']['processCycleInterval'] 

281 self.meta_type = collector_params['data']['meta_type'] 

282 self.wmiqueryTimeout = collector_params['data']['wmiqueryTimeout'] 

283 self.statusCycleInterval = collector_params['data']['statusCycleInterval'] 

284 self.eventlogCycleInterval = collector_params['data']['eventlogCycleInterval'] 

285 self.wmibatchSize = collector_params['data']['wmibatchSize'] 

286 self.pingTimeOut = collector_params['data']['pingTimeOut'] 

287 self.winCycleInterval = collector_params['data']['winCycleInterval'] 

288 self.pingTries = collector_params['data']['pingTries'] 

289 self.inspector_type = collector_params['data']['inspector_type'] 

290 self.zenProcessParallelJobs = collector_params['data']['zenProcessParallelJobs']