3 # Reboot specified nodes
9 import errno, time, traceback
14 from subprocess import PIPE, Popen
15 import pcucontrol.transports.ssh.pxssh as pxssh
16 import pcucontrol.transports.ssh.pexpect as pexpect
21 # Use our versions of telnetlib and pyssh
22 sys.path.insert(0, os.path.dirname(sys.argv[0]))
23 import pcucontrol.transports.telnetlib as telnetlib
24 sys.path.insert(0, os.path.dirname(sys.argv[0]) + "/pyssh")
25 import pcucontrol.transports.pyssh as pyssh
27 # Event class ID from pcu events
28 #NODE_POWER_CONTROL = 3
31 #MONITOR_USER_ID = 11142
37 class ExceptionNoTransport(Exception): pass
38 class ExceptionNotFound(Exception): pass
39 class ExceptionPassword(Exception): pass
40 class ExceptionTimeout(Exception): pass
41 class ExceptionPrompt(Exception): pass
42 class ExceptionSequence(Exception): pass
43 class ExceptionReset(Exception): pass
44 class ExceptionPort(Exception): pass
45 class ExceptionUsername(Exception): pass
49 # PCU has model, host, preferred-port, user, passwd,
51 # This is an object derived directly form the PLCAPI DB fields
53 def __init__(self, plc_pcu_dict):
54 for field in ['username', 'password', 'site_id',
57 'node_ids', 'ports', ]:
58 if field in plc_pcu_dict:
59 if type(u"") == type(plc_pcu_dict[field]):
60 # NOTE: if is a unicode string, convert it.
61 self.__setattr__(field, str(plc_pcu_dict[field]))
63 self.__setattr__(field, plc_pcu_dict[field])
65 raise Exception("No such field %s in PCU object" % field)
67 # These are the convenience functions build around the PCU object.
69 def __init__(self, plc_pcu_dict):
70 PCU.__init__(self, plc_pcu_dict)
71 self.host = self.pcu_name()
74 if self.hostname is not None and self.hostname is not "":
76 elif self.ip is not None and self.ip is not "":
81 def nodeidToPort(self, node_id):
82 if node_id in self.node_ids:
83 for i in range(0, len(self.node_ids)):
84 if node_id == self.node_ids[i]:
87 raise Exception("No such Node ID: %d" % node_id)
89 # This class captures the observed pcu records from FindBadPCUs.py
91 def __init__(self, pcu_record_dict):
92 for field in ['port_status',
95 if field in pcu_record_dict:
97 self.__setattr__("reboot_str", pcu_record_dict[field])
99 self.__setattr__(field, pcu_record_dict[field])
101 # raise Exception("No such field %s in pcu record dict" % field)
126 def __init__(self, type, verbose):
128 self.verbose = verbose
129 self.transport = None
131 def open(self, host, username=None, password=None, prompt="User Name"):
134 if self.type == self.TELNET:
135 transport = telnetlib.Telnet(host, timeout=self.TELNET_TIMEOUT)
136 transport.set_debuglevel(self.verbose)
137 if username is not None:
138 self.transport = transport
139 self.ifThenSend(prompt, username, ExceptionUsername)
141 elif self.type == self.SSH:
142 if username is not None:
143 transport = pyssh.Ssh(username, host)
144 transport.set_debuglevel(self.verbose)
146 # TODO: have an ssh set_debuglevel() also...
148 raise Exception("Username cannot be None for ssh transport.")
149 elif self.type == self.HTTP:
150 # NOTE: this does not work for all web-based services...
151 self.url = "http://%s:%d/" % (host,80)
152 uri = "%s:%d" % (host,80)
155 authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm()
156 authinfo.add_password (None, uri, username, password)
157 authhandler = urllib2.HTTPBasicAuthHandler( authinfo )
159 transport = urllib2.build_opener(authhandler)
161 raise Exception("Unknown transport type: %s" % self.type)
163 self.transport = transport
167 if self.type == self.TELNET:
168 self.transport.close()
169 elif self.type == self.SSH:
170 self.transport.close()
171 elif self.type == self.HTTP:
174 raise Exception("Unknown transport type %s" % self.type)
175 self.transport = None
177 def write(self, msg):
178 return self.send(msg)
181 if self.transport == None:
182 raise ExceptionNoTransport("transport object is type None")
184 return self.transport.write(msg)
186 def sendPassword(self, password, prompt=None):
187 if self.type == self.TELNET:
189 self.ifThenSend("Password", password, ExceptionPassword)
191 self.ifThenSend(prompt, password, ExceptionPassword)
192 elif self.type == self.SSH:
193 self.ifThenSend("password:", password, ExceptionPassword)
194 elif self.type == self.HTTP:
197 raise Exception("Unknown transport type: %s" % self.type)
199 def sendHTTP(self, resource, data):
201 print "POSTing '%s' to %s" % (data,self.url + resource)
204 f = self.transport.open(self.url + resource ,data)
209 except urllib2.URLError,err:
210 print 'Could not open http connection', err
211 return "http transport error"
215 def ifThenSend(self, expected, buffer, ErrorClass=ExceptionPrompt):
217 if self.transport != None:
218 output = self.transport.read_until(expected, self.TELNET_TIMEOUT)
219 if output.find(expected) == -1:
220 print "OUTPUT: --%s--" % output
221 raise ErrorClass, "'%s' not found" % expected
223 self.transport.write(buffer + "\r\n")
225 raise ExceptionNoTransport("transport object is type None")
227 def ifElse(self, expected, ErrorClass):
229 self.transport.read_until(expected, self.TELNET_TIMEOUT)
231 raise ErrorClass("Could not find '%s' within timeout" % expected)
233 class PCUControl(PCUModel,PCURecord):
236 There are three cases:
237 1) the pcu_record passed below includes port_status from an
239 2) the external probe failed, and the values are empty
240 3) this call is made independent of port_status.
242 In the first case, the first open port is used.
243 In the third case, the ports are tried in sequence.
245 In this way, the port_status value serves only as an optimization,
246 because closed ports are avoided. The supported_ports value should
247 order ports by their preferred usage.
252 def __init__(self, plc_pcu_record, verbose, ignored=None):
253 PCUModel.__init__(self, plc_pcu_record)
254 PCURecord.__init__(self, plc_pcu_record)
256 def reboot(self, node_port, dryrun):
259 # There are two sources of potential ports. Those that are open and
260 # those that are part of the PCU's supported_ports.
261 # I think we should start with supported_ports and then filter that
264 port_list = self.supported_ports
266 if hasattr(self, 'port_status') and self.port_status:
267 # get out the open ports
268 port_list = filter(lambda x: self.port_status[x] == "open" , self.port_status.keys())
269 port_list = [ int(x) for x in port_list ]
270 # take only the open ports that are supported_ports
271 port_list = filter(lambda x: x in self.supported_ports, port_list)
273 raise ExceptionPort("No Open Port: No transport from open ports")
277 ret = "No implementation for open ports on selected PCU model"
278 for port in port_list:
279 if port not in Transport.porttypemap:
282 type = Transport.porttypemap[port]
283 self.transport = Transport(type, verbose)
285 print "checking for run_%s" % type
286 if hasattr(self, "run_%s" % type):
287 print "found run_%s" % type
288 fxn = getattr(self, "run_%s" % type)
289 ret = self.catcherror(fxn, node_port, dryrun)
290 if ret == 0: # NOTE: success!, so stop
297 def run(self, node_port, dryrun):
298 """ This function is to be defined by the specific PCU instance. """
299 raise Exception("This function is not implemented")
302 #def reboot(self, node_port, dryrun):
304 def catcherror(self, function, node_port, dryrun):
306 return function(node_port, dryrun)
307 except ExceptionNotFound, err:
308 return "error: " + str(err)
309 except ExceptionPassword, err:
310 return "Password exception: " + str(err)
311 except ExceptionTimeout, err:
312 return "Timeout exception: " + str(err)
313 except ExceptionUsername, err:
314 return "No username prompt: " + str(err)
315 except ExceptionSequence, err:
316 return "Sequence error: " + str(err)
317 except ExceptionPrompt, err:
318 return "Prompt exception: " + str(err)
319 except ExceptionNoTransport, err:
320 return "No Transport: " + str(err)
321 except ExceptionPort, err:
322 return "No ports exception: " + str(err)
323 except socket.error, err:
324 return "socket error: timeout: " + str(err)
325 except urllib2.HTTPError, err:
326 return "HTTPError: " + str(err)
327 except urllib2.URLError, err:
328 return "URLError: " + str(err)
329 except EOFError, err:
330 self.transport.close()
332 traceback.print_exc()
333 return "EOF connection reset" + str(err)
334 except Exception, err:
335 #from monitor.common import email_exception
336 #email_exception(self.host)
339 from pcucontrol.util import command
340 from pcucontrol.models import *
343 if pcu['hostname'] is not None and pcu['hostname'] is not "":
344 return pcu['hostname']
345 elif pcu['ip'] is not None and pcu['ip'] is not "":
350 class Unknown(PCUControl):
351 supported_ports = [22,23,80,443,5869,9100,16992]
353 def model_to_object(modelname):
354 if modelname is None:
356 if "AMT" in modelname:
358 elif "BayTech" in modelname:
360 elif "HPiLO" in modelname:
362 elif "IPAL" in modelname:
364 elif "APC" in modelname:
366 elif "DRAC" in modelname:
368 elif "WTI" in modelname:
370 elif "ePowerSwitch" in modelname:
371 return ePowerSwitchNew
372 elif "IPMI" in modelname:
374 elif "BlackBoxPSMaverick" in modelname:
375 return BlackBoxPSMaverick
376 elif "PM211MIP" in modelname:
378 elif "ManualPCU" in modelname:
381 print "UNKNOWN model %s"%modelname
384 def reboot_api(node, pcu):
388 modelname = pcu['model']
390 # get object instance
391 instance = eval('%s(pcu, verbose)' % modelname)
393 i = pcu['node_ids'].index(node['node_id'])
396 rb_ret = instance.reboot(p, False)
398 rb_ret = "No modelname in PCU record."
399 # TODO: how to handle the weird, georgetown pcus, the drac faults, and ilo faults
400 except Exception, err:
401 rb_ret = "Exception Model(%s): " % modelname
406 def convert_oldmodelname_to_newmodelname(oldmodelname, pcu_id):
408 update = { 'AP79xx' : 'APCControl13p13',
409 'Masterswitch' : 'APCControl13p13',
410 'DS4-RPC' : 'BayTech',
411 'IP-41x_IP-81x' : 'IPAL',
414 'ePowerSwitch' : 'ePowerSwitchOld',
417 'PM211-MIP' : 'PM211MIP',
418 'AMT2.5' : 'IntelAMT',
419 'AMT3.0' : 'IntelAMT',
420 'WTI_IPS-4' : 'WTIIPS4',
421 'unknown' : 'ManualPCU',
424 'bbsemaverick' : 'BlackBoxPSMaverick',
425 'manualadmin' : 'ManualPCU',
428 if oldmodelname in update:
429 newmodelname = update[oldmodelname]
431 newmodelname = oldmodelname
433 if pcu_id in [1102,1163,1055,1111,1231,1113,1127,1128,1148]:
434 newmodelname = 'APCControl12p3'
435 elif pcu_id in [1110,86]:
436 newmodelname = 'APCControl1p4'
437 elif pcu_id in [1221,1225,1220,1192]:
438 newmodelname = 'APCControl121p3'
439 elif pcu_id in [1173,1240,47,1363,1405,1401,1372,1371]:
440 newmodelname = 'APCControl121p1'
441 elif pcu_id in [1056,1237,1052,1209,1002,1008,1013,1022]:
442 newmodelname = 'BayTechCtrlC'
444 newmodelname = 'BayTechRPC3NC'
445 elif pcu_id in [1057]:
446 newmodelname = 'BayTechCtrlCUnibe'
447 elif pcu_id in [1012]:
448 newmodelname = 'BayTechRPC16'
449 elif pcu_id in [1089, 1071, 1046, 1035, 1118]:
450 newmodelname = 'ePowerSwitchNew'
454 def reboot_test_new(nodename, values, verbose, dryrun):
456 if 'plc_pcu_stats' in values:
457 values.update(values['plc_pcu_stats'])
460 #modelname = convert_oldmodelname_to_newmodelname(values['model'], values['pcu_id'])
461 modelname = values['model']
463 object = eval('%s(values, verbose)' % modelname)
464 rb_ret = object.reboot(values[nodename], dryrun)
467 # TODO: how to handle the weird, georgetown pcus, the drac faults, and ilo faults
468 except ExceptionPort, err:
470 except NameError, err:
476 print "this does not work."
478 if __name__ == '__main__':