1#!/usr/bin/python 2 3# sample 4# 5# A sample file that uses most of the python/OpenIPMI interface 6# 7# Author: MontaVista Software, Inc. 8# Corey Minyard <minyard@mvista.com> 9# source@mvista.com 10# 11# Copyright 2010 MontaVista Software Inc. 12# 13# This program is free software; you can redistribute it and/or 14# modify it under the terms of the GNU Lesser General Public License 15# as published by the Free Software Foundation; either version 2 of 16# the License, or (at your option) any later version. 17# 18# 19# THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 20# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 21# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 24# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 25# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 26# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 27# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 28# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29# 30# You should have received a copy of the GNU Lesser General Public 31# License along with this program; if not, write to the Free 32# Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 33# 34 35import sys 36import OpenIPMI 37 38# Used to count things waiting for shutdown 39stop_count = 1 40main_handler = None 41stop_list = {} 42 43class MC_Nameget: 44 def __init__(self): 45 self.name = None 46 pass 47 48 def mc_cb(self, mc): 49 self.name = mc.get_name() 50 pass 51 pass 52 53threshold_list = ("ln", "lc", "lr", "un", "uc", "ur") 54low_high = ("l", "h") 55act_deact = ("a", "d") 56 57class Handlers: 58 def __init__(self, name): 59 self.name = name 60 return 61 62 def event_cb(self, domain, event): 63 mcid = event.get_mc_id() 64 65 name = MC_Nameget() 66 mcid.to_mc(name) 67 name = name.name 68 data = event.get_data() 69 70 print ("Got event: " + name + " " + str(event.get_record_id()) + 71 " " + str(event.get_type()) + " " + str(event.get_timestamp())) 72 datastr = "" 73 for b in data: 74 datastr += " %2.2x" % b 75 pass 76 print " Data:" + datastr 77 return 78 79 def entity_presence_cb(self, entity, present, event): 80 print "Entity " + entity.get_name() + " presence is " + str(present) 81 82 if event: 83 self.event_cb(entity.get_domain(), event) 84 pass 85 return 86 87 def threshold_event_cb(self, sensor, event_spec, raw_set, raw, 88 value_set, value, event): 89 print "Sensor " + sensor.get_name() + " got event " + event_spec 90 if raw_set: 91 print " raw value = " + str(raw) 92 pass 93 if value_set: 94 print " value = " + str(value) 95 pass 96 if event: 97 entity = sensor.get_entity() 98 self.event_cb(entity.get_domain(), event) 99 pass 100 return 101 102 def discrete_event_cb(self, sensor, event_spec, severity, old_severity, 103 event): 104 print "Sensor " + sensor.get_name() + " got event " + event_spec 105 print " severity = " + str(severity) + " was = " + str(old_severity) 106 if event: 107 entity = sensor.get_entity() 108 self.event_cb(entity.get_domain(), event) 109 pass 110 return 111 112 def entity_sensor_update_cb(self, op, entity, sensor): 113 print op + " sensor " + sensor.get_name() 114 if ((op == "added") or (op == "changed")): 115 print " lun = " + str(sensor.get_lun()) 116 print " num = " + str(sensor.get_num()) 117 print " sensor_type_string = " + sensor.get_sensor_type_string() 118 print " sensor_type = " + str(sensor.get_sensor_type()) 119 print(" event_reading_type_string = " + 120 sensor.get_event_reading_type_string()) 121 print(" event_reading_type = " 122 + str(sensor.get_event_reading_type())) 123 print " entity_id = " + str(sensor.get_entity_id()) 124 print " entity_instance = " + str(sensor.get_entity_instance()) 125 print(" sensor_init_scanning = " + 126 str(sensor.get_sensor_init_scanning())) 127 print(" sensor_init_events = " 128 + str(sensor.get_sensor_init_events())) 129 print(" sensor_init_thresholds = " + 130 str(sensor.get_sensor_init_thresholds())) 131 print(" sensor_init_hysteresis = " + 132 str(sensor.get_sensor_init_hysteresis())) 133 print(" sensor_init_type = " + 134 str(sensor.get_sensor_init_type())) 135 print(" sensor_init_pu_events = " + 136 str(sensor.get_sensor_init_pu_events())) 137 print(" sensor_init_pu_scanning = " + 138 str(sensor.get_sensor_init_pu_scanning())) 139 print(" ignore_if_no_entity = " + 140 str(sensor.get_ignore_if_no_entity())) 141 print(" supports_auto_rearm = " + 142 str(sensor.get_supports_auto_rearm())) 143 print " event_support = " + str(sensor.get_event_support()) 144 print " sensor_direction = " + str(sensor.get_sensor_direction()) 145 print " oem1 = " + str(sensor.get_oem1()) 146 print " sensor_id = " + sensor.get_sensor_id() 147 148 if (sensor.get_event_reading_type() 149 == OpenIPMI.EVENT_READING_TYPE_THRESHOLD): 150 print " rate_unit_string = " + sensor.get_rate_unit_string() 151 print " rate_unit = " + str(sensor.get_rate_unit()) 152 print(" base_unit_string = " + 153 sensor.get_base_unit_string()) 154 print " base_unit = " + str(sensor.get_base_unit()) 155 print(" modifier_unit_string = " + 156 sensor.get_modifier_unit_string()) 157 print " modifier_unit = " + str(sensor.get_modifier_unit()) 158 print(" modifier_unit_use = " + 159 str(sensor.get_modifier_unit_use())) 160 print " percentage = " + str(sensor.get_percentage()) 161 print(" threshold_access = " + 162 str(sensor.get_threshold_access())) 163 print(" hysteresis_support = " + 164 str(sensor.get_hysteresis_support())) 165 166 val = [ 0.0 ] 167 if sensor.get_normal_min_specified(): 168 rv = sensor.get_normal_min(val) 169 if rv: 170 print "***Error getting normal min: " + rv 171 else: 172 print " normal_min = " + str(val[0]) 173 pass 174 pass 175 176 if sensor.get_normal_max_specified(): 177 rv = sensor.get_normal_max(val) 178 if rv: 179 print "***Error getting normal max: " + rv 180 else: 181 print " normal_max = " + str(val[0]) 182 pass 183 pass 184 185 if sensor.get_nominal_reading_specified(): 186 rv = sensor.get_nominal_reading(val) 187 if rv: 188 print "***Error getting nominal reading: " + str(rv) 189 else: 190 print " nominal_reading = " + str(val[0]) 191 pass 192 pass 193 194 rv = sensor.get_sensor_max(val) 195 if rv: 196 print "***Error getting sensor max: " + str(rv) 197 else: 198 print " sensor_max = " + str(val[0]) 199 pass 200 pass 201 202 rv = sensor.get_sensor_min(val) 203 if rv: 204 print "***Error getting sensor min: " + str(rv) 205 else: 206 print " sensor_min = " + str(val[0]) 207 pass 208 pass 209 210 rv = sensor.get_tolerance(128, val) 211 if rv == 0: 212 print " tolerance at 128 is " + str(val[0]) 213 pass 214 215 rv = sensor.get_accuracy(128, val) 216 if rv == 0: 217 print " accuracy at 128 is " + str(val[0]) 218 pass 219 220 for i in threshold_list: 221 supported = [ 0 ] 222 settable = [ 0 ] 223 readable = [ 0 ] 224 225 rv = sensor.threshold_reading_supported(i, supported) 226 if rv: 227 print("***Error getting supported for threshold %s: %s" 228 % (i, str(rv))) 229 pass 230 supported = supported[0] 231 232 if not supported: 233 continue 234 235 tstr = " Threshold '" + i + "' supported:" 236 237 rv = sensor.threshold_settable(i, settable) 238 if rv: 239 print("***Error getting settable for threshold %s: %s" 240 % (i, str(rv))) 241 pass 242 settable = settable[0] 243 if settable: 244 tstr += " settable" 245 pass 246 247 rv = sensor.threshold_readable(i, readable) 248 if rv: 249 print("***Error getting readable for threshold %s: %s" 250 % (i, str(rv))) 251 pass 252 readable = readable[0] 253 if readable: 254 tstr += " readable" 255 pass 256 print tstr 257 258 tstr = " Supports events:" 259 for j in low_high: 260 for k in act_deact: 261 e = i + j + k 262 s = [ 0 ] 263 rv = sensor.threshold_event_supported(e, s) 264 if rv: 265 print ("***Error getting ev support for event " 266 + e + ": " + str(rv)) 267 elif s[0]: 268 tstr += " " + e 269 pass 270 pass 271 pass 272 print tstr 273 pass 274 pass 275 else: 276 for i in range(0, 14): 277 a_supported = [ 0 ] 278 d_supported = [ 0 ] 279 readable = [ 0 ] 280 281 rv = sensor.discrete_event_readable(i, readable) 282 if rv: 283 print ("***Error getting readable for offset %d: %s" 284 % (i, str(rv))) 285 pass 286 readable = readable[0] 287 288 rv = sensor.discrete_event_supported(str(i) + "a", 289 a_supported) 290 if rv: 291 print ("***Error getting a supported for offset %d: %s" 292 % (i, str(rv))) 293 pass 294 a_supported = a_supported[0] 295 296 rv = sensor.discrete_event_supported(str(i) + "d", 297 d_supported) 298 if rv: 299 print ("***Error getting d supported for offset %s: %s" 300 % (i, str(rv))) 301 pass 302 d_supported = d_supported[0] 303 304 if readable or a_supported or d_supported: 305 s = sensor.reading_name_string(i) 306 tstr = " Offset %d (%s) supported:" % (i, s) 307 308 if readable: 309 tstr += " readable" 310 pass 311 if a_supported: 312 tstr += " assert" 313 pass 314 if d_supported: 315 tstr += " deassert" 316 pass 317 print tstr 318 pass 319 pass 320 pass 321 322 if op == "added": 323 rv = sensor.add_event_handler(self) 324 if rv: 325 print "***Unable to add event handler: " + str(rv) 326 pass 327 pass 328 pass 329 elif op == "deleted": 330 rv = sensor.remove_event_handler(self) 331 if rv: 332 print "***Unable to remove event handler: " + str(rv) 333 pass 334 pass 335 return 336 337 def control_get_val_cb(self, control, err, vals): 338 tstr = "Control %s err = %s, values = " % (control.get_name(),str(err)) 339 for v in vals: 340 tstr += " %d" % v 341 pass 342 print tstr 343 return 344 345 def control_get_light_cb(self, control, err, vals): 346 print("Control %s err = %s, light value = %s" 347 % (control.get_name(), str(err), vals)) 348 return 349 350 def control_get_id_cb(self, control, err, val): 351 tstr = ("Control %s err = %s, id value = " 352 % (control.get_name(), str(err))) 353 for v in vals: 354 tstr += " %2.2x" % v 355 pass 356 print tstr 357 return 358 359 def control_event_val_cb(self, control, event, num, valids, vals): 360 tstr = "Control " + control.get_name() + " event, values =" 361 for i in range(0, len(valids)): 362 if valids[i]: 363 v = "valid" 364 else: 365 v = "invalid" 366 pass 367 tstr += " (%s, %d)" % (v, vals[i]) 368 pass 369 print tstr 370 return 371 372 def entity_control_update_cb(self, op, entity, control): 373 use_setting = 0 374 375 print op + " control " + control.get_name() 376 if ((op == "added") or (op == "changed")): 377 t = control.get_type() 378 print " type = " + str(t) 379 print " entity_id = " + str(control.get_entity_id()) 380 print " entity_instance = " + str(control.get_entity_instance()) 381 print " settable = " + str(control.is_settable()) 382 print " readable = " + str(control.is_readable()) 383 print(" ignore_if_no_entity = " + 384 str(control.get_ignore_if_no_entity())) 385 print " control_id = " + str(control.get_control_id()) 386 print " has_events = " + str(control.has_events()) 387 num_vals = control.get_num_vals() 388 print " num_vals = " + str(num_vals) 389 390 if t == OpenIPMI.CONTROL_LIGHT: 391 use_setting = control.light_set_with_setting() 392 pass 393 394 if use_setting: 395 print " light controlled with setting" 396 tstr = " Colors: " 397 for i in range(0, OpenIPMI.CONTROL_NUM_COLORS): 398 if (control.light_is_color_supported(i)): 399 tstr += " " + OpenIPMI.color_string(i) + ("(%d)" % i) 400 pass 401 pass 402 print tstr 403 print(" light_has_local_control = " + 404 str(control.light_has_local_control())) 405 rv = control.ipmi_control_get_light(self) 406 if rv: 407 print "***Error getting light: " + str(rv) 408 pass 409 pass 410 elif t == OpenIPMI.CONTROL_IDENTIFIER: 411 print(" identifier_get_max_length = " + 412 str(control.identifier_get_max_length())) 413 rv = control.identifier_get_val(self) 414 if rv: 415 print "***Error getting control id: " + str(rv) 416 pass 417 pas 418 elif t == OpenIPMI.CONTROL_LIGHT: 419 for i in range(0, num_vals) : 420 n = control.get_num_light_values(i) 421 print " Light %d" % i 422 for j in range (0, n): 423 print " Value %d" % j 424 o = control.get_num_light_transitions(i, j) 425 for k in range (0, o): 426 tstr = " Transition %d:" & k 427 v = control.get_light_color(i, j, k) 428 tstr += " " + OpenIPMI.color_string(v) 429 v = control.get_light_color_time(i, j, k) 430 tstr += " time(" + str(v) + ")" 431 pass 432 pass 433 pass 434 pass 435 436 if op == "added": 437 rv = control.add_event_handler(self) 438 if rv: 439 print "***Error adding control event handler: " + str(rv) 440 pass 441 pass 442 pass 443 elif op == "deleted": 444 rv = control.remove_event_handler(self) 445 if rv: 446 print "***Error removing control event handler: " + str(rv) 447 pass 448 pass 449 return 450 451 def print_multirecord(self, node, indent): 452 name = [ "" ] 453 t = [ "" ] 454 value = [ "" ] 455 sub_node = [ None ] 456 457 i = 0 458 while True: 459 rv = node.get_field(i, name, t, value, sub_node) 460 if rv == OpenIPMI.einval: 461 return 462 i += 1 463 if rv: 464 continue 465 466 print "%s%s, %s, %s" % (indent, name[0], t[0], value[0]) 467 if t == "subnode": 468 self.print_multirecord(subnode[0], indent + " ") 469 pass 470 pass 471 return 472 473 def entity_fru_update_werr_cb(self, op, err, entity, fru): 474 print op + " fru for " + entity.get_name() 475 if (op == "error"): 476 print " error is " + str(err) 477 if ((op == "added") or (op == "changed")): 478 i = fru.str_to_index("internal_use_version") 479 if i == -1: 480 print "*** FRU string 'internal_use_version' was invalid" 481 else: 482 print " internal_use_version index is %d" % i 483 pass 484 i = fru.str_to_index("blah blah") 485 if i != -1: 486 print "*** FRU string 'blah blah' was valid" 487 pass 488 489 i = 0 490 j = [ 0 ] 491 k = j[0] 492 rv = fru.get(i, j) 493 while rv: 494 v = rv.split(" ", 2) 495 if len(v) > 2: 496 name = v[0] 497 t = v[1] 498 print " %s, %s, %s" % (name, t, v[2]) 499 pass 500 if j[0] != k: 501 if j[0] == -1: 502 i += 1 503 j = [ 0 ] 504 pass 505 pass 506 else: 507 i += 1 508 j = [ 0 ] 509 pass 510 511 k = j[0] 512 rv = fru.get(i, j) 513 pass 514 j = fru.get_num_multi_records() 515 print "%d multirecords" % j 516 for i in range(0, j): 517 name = [ "" ] 518 sub_node = [ None ] 519 rv = fru.multi_record_get_root_node(i, name, sub_node) 520 if rv: 521 print "Multirecord %d has no decoder" % i 522 continue 523 print "Multirecord %d (%s)" % (i, name[0]) 524 self.print_multirecord(sub_node[0], " ") 525 pass 526 pass 527 return 528 529 def entity_hot_swap_update_cb(self, entity, old_state, new_state, event): 530 print("Hot swap change for %s was %s now %s" 531 % (entity.get_name(), old_state, new_state)) 532 if event: 533 self.event_cb(entity.get_domain(), event) 534 pass 535 return 536 537 def entity_update_cb(self, op, domain, entity): 538 print op + " entity " + entity.get_name() 539 if ((op == "added") or (op == "changed")): 540 print " type = " + entity.get_type() 541 print " is_fru = " + str(entity.is_fru()) 542 print " entity_id = " + str(entity.get_entity_id()) 543 print " entity_instance = " + str(entity.get_entity_instance()) 544 print(" device_channel = " + 545 str(entity.get_entity_device_channel())) 546 print(" device_address = " + 547 str(entity.get_entity_device_address())) 548 print(" presence_sensor_always_there = " + 549 str(entity.get_presence_sensor_always_there())) 550 print " channel = " + str(entity.get_channel()) 551 print " lun = " + str(entity.get_lun()) 552 print " oem = " + str(entity.get_oem()) 553 print " access_address = " + str(entity.get_access_address()) 554 print " private_bus_id = " + str(entity.get_private_bus_id()) 555 print " device_type = " + str(entity.get_device_type()) 556 print " device_modifier = " + str(entity.get_device_modifier()) 557 print " slave_address = " + str(entity.get_slave_address()) 558 print " is_logical_fru = " + str(entity.get_is_logical_fru()) 559 print " fru_device_id = " + str(entity.get_fru_device_id()) 560 print(" ACPI_system_power_notify_required = " + 561 str(entity.get_ACPI_system_power_notify_required())) 562 print(" ACPI_device_power_notify_required = " + 563 str(entity.get_ACPI_device_power_notify_required())) 564 print(" controller_logs_init_agent_errors = " + 565 str(entity.get_controller_logs_init_agent_errors())) 566 print(" log_init_agent_errors_accessing = " + 567 str(entity.get_log_init_agent_errors_accessing())) 568 print " global_init = " + str(entity.get_global_init()) 569 print " chassis_device = " + str(entity.get_chassis_device()) 570 print " bridge = " + str(entity.get_bridge()) 571 print(" IPMB_event_generator = " + 572 str(entity.get_IPMB_event_generator())) 573 print(" IPMB_event_receiver = " + 574 str(entity.get_IPMB_event_receiver())) 575 print(" FRU_inventory_device = " + 576 str(entity.get_FRU_inventory_device())) 577 print " SEL_device = " + str(entity.get_SEL_device()) 578 print(" SDR_repository_device = " + 579 str(entity.get_SDR_repository_device())) 580 print " sensor_device = " + str(entity.get_sensor_device()) 581 print " address_span = " + str(entity.get_address_span()) 582 print " dlr_id = " + str(entity.get_dlr_id()) 583 print " present = " + str(entity.is_present()) 584 print " hot_swappable = " + str(entity.is_hot_swappable()) 585 if op == "added": 586 rv = entity.add_presence_handler(self) 587 if rv: 588 print "***Unable to add presence handler: " + str(rv) 589 pass 590 rv = entity.add_sensor_update_handler(self) 591 if rv: 592 print "***Unable to add sensor update handler: " + str(rv) 593 pass 594 rv = entity.add_control_update_handler(self) 595 if rv: 596 print "***Unable to add control update handler: " + str(rv) 597 pass 598 rv = entity.add_hot_swap_handler(self) 599 if rv: 600 print "***Unable to add hot-swap handler: " + str(rv) 601 pass 602 rv = entity.add_fru_update_werr_handler(self) 603 if rv: 604 print "***Unable to add fru handler: " + str(rv) 605 pass 606 pass 607 pass 608 elif op == "deleted": 609 rv = entity.remove_presence_handler(self) 610 if rv: 611 print "***Unable to remove presence handler: " + str(rv) 612 pass 613 rv = entity.remove_sensor_update_handler(self) 614 if rv: 615 print "***Unable to remove sensor update handler: " + str(rv) 616 pass 617 rv = entity.remove_control_update_handler(self) 618 if rv: 619 print "***Unable to remove control update handler: " + str(rv) 620 pass 621 rv = entity.remove_hot_swap_handler(self) 622 if rv: 623 print "***Unable to remove hot-swap handler: " + str(rv) 624 pass 625 rv = entity.remove_fru_update_werr_handler(self) 626 if rv: 627 print "***Unable to add fru handler: " + str(rv) 628 pass 629 pass 630 return 631 632 def mc_active_cb(self, mc, active): 633 print "MC " + mc.get_name() + " active set to " + str(active) 634 return 635 636 def mc_events_enable_cb(self, mc, err): 637 global stop_count, stop_list 638 print "Events enabled for " + mc.get_name() + " err = " + str(err) 639 stop_list["mc_set_events_enable"] = 0 640 stop_count -= 1 641 print str(stop_list) 642 if stop_count == 0: 643 domain = mc.get_domain() 644 domain.close(main_handler) 645 pass 646 return 647 648 def mc_reread_sel_cb(self, mc, err): 649 global stop_count, stop_list 650 domain = mc.get_domain() 651 652 print "SEL reread for " + mc.get_name() + " err = " + str(err) 653 stop_list["mc_reread_sel"] = 0 654 stop_count -= 1 655 print str(stop_list) 656 if stop_count == 0: 657 domain.close(main_handler) 658 pass 659 return 660 661 def mc_reread_sensors_cb(self, mc, err): 662 global stop_count, stop_list 663 domain = mc.get_domain() 664 665 print "Sensors reread for " + mc.get_name() + " err = " + str(err) 666 stop_list["mc_reread_sensors"] = 0 667 stop_count -= 1 668 print str(stop_list) 669 if stop_count == 0: 670 domain.close(main_handler) 671 pass 672 return 673 674 def mc_get_sel_time_cb(self, mc, err, time): 675 global stop_count, stop_list 676 domain = mc.get_domain() 677 678 print("SEL time for " + mc.get_name() + " is " + str(time) + ", err = " 679 + str(err)) 680 stop_list["mc_get_sel_time"] = 0 681 stop_count -= 1 682 print str(stop_list) 683 if stop_count == 0: 684 domain.close(main_handler) 685 pass 686 return 687 688 def mc_update_cb(self, op, domain, mc): 689 global stop_count, stop_list 690 print op + " MC " + mc.get_name() 691 if ((op == "added") or (op == "changed")): 692 print(" provides_device_sdrs = " + 693 str(mc.provides_device_sdrs())) 694 print " device_available = " + str(mc.device_available()) 695 print " chassis_support = " + str(mc.chassis_support()) 696 print " bridge_support = " + str(mc.bridge_support()) 697 print(" ipmb_event_generator_support = " + 698 str(mc.ipmb_event_generator_support())) 699 print(" ipmb_event_receiver_support = " + 700 str(mc.ipmb_event_receiver_support())) 701 print(" fru_inventory_support = " + 702 str(mc.fru_inventory_support())) 703 print(" sel_device_support = " + 704 str(mc.sel_device_support())) 705 print(" sdr_repository_support = " + 706 str(mc.sdr_repository_support())) 707 print(" sensor_device_support = " + 708 str(mc.sensor_device_support())) 709 print " device_id = " + str(mc.device_id()) 710 print " device_revision = " + str(mc.device_revision()) 711 print " major_fw_revision = " + str(mc.major_fw_revision()) 712 print " minor_fw_revision = " + str(mc.minor_fw_revision()) 713 print " major_version = " + str(mc.major_version()) 714 print " minor_version = " + str(mc.minor_version()) 715 print " manufacturer_id = " + str(mc.manufacturer_id()) 716 print " product_id = " + str(mc.product_id()) 717 print " aux_fw_revision = " + str(mc.aux_fw_revision()) 718 print " is_active = " + str(mc.is_active()) 719 print " get_events_enable = " + str(mc.get_events_enable()) 720 print " sel_count = " + str(mc.sel_count()) 721 print " sel_entries_used = " + str(mc.sel_entries_used()) 722 print(" sel_get_major_version = " + 723 str(mc.sel_get_major_version())) 724 print(" sel_get_minor_version = " + 725 str(mc.sel_get_minor_version())) 726 print(" sel_get_num_entries = " + 727 str(mc.sel_get_num_entries())) 728 print " sel_get_free_bytes = " + str(mc.sel_get_free_bytes()) 729 print " sel_get_overflow = " + str(mc.sel_get_overflow()) 730 print(" sel_get_supports_delete_sel = " + 731 str(mc.sel_get_supports_delete_sel())) 732 print(" sel_get_supports_partial_add_sel = " + 733 str(mc.sel_get_supports_partial_add_sel())) 734 print(" sel_get_supports_reserve_sel = " + 735 str(mc.sel_get_supports_reserve_sel())) 736 print(" sel_get_supports_get_sel_allocation = " + 737 str(mc.sel_get_supports_get_sel_allocation())) 738 print(" sel_get_last_addition_timestamp = " + 739 str(mc.sel_get_last_addition_timestamp())) 740 print(" get_sel_rescan_time = " + 741 str(mc.get_sel_rescan_time())) 742 743 stop_count += 2 744 stop_list["mc_set_events_enable"] = 1 745 rv = mc.set_events_enable(1, self) 746 if rv: 747 print "***Error enabling MC events: " + str(rv) 748 stop_count -= 1 749 pass 750 751 stop_count += 1 752 stop_list["mc_reread_sensors"] = 1 753 rv = mc.reread_sensors(self) 754 if rv: 755 print "***Error rereading MC sensors: " + str(rv) 756 stop_list["mc_reread_sensors"] = 0 757 stop_count -= 1 758 pass 759 760 mc.set_sel_rescan_time(5) 761 762 stop_count += 1 763 stop_list["mc_reread_sel"] = 1 764 rv = mc.reread_sel(self) 765 if rv: 766 print "***Error rereading MC SEL: " + str(rv) 767 stop_list["mc_reread_sel"] = 0 768 stop_count -= 1 769 pass 770 771 stop_count += 1 772 stop_list["mc_get_sel_time"] = 1 773 rv = mc.get_current_sel_time(self) 774 if rv: 775 print "***Error getting current MC SEL time: " + str(rv) 776 stop_count -= 1 777 pass 778 779 # Stop count for this incremented at first. 780 stop_list["mc_send_command"] = 1 781 rv = mc.send_command(0, 10, 0x43, 782 [ 0, 0, 0, 0, 0, 0xff ], self) 783 if rv: 784 print "***Unable to send mc command: " + str(rv) 785 stop_count -= 1 786 pass 787 788 if op == "added": 789 rv = mc.add_active_handler(self) 790 if rv: 791 print "***Unable to add active handler: " + str(rv) 792 pass 793 pass 794 pass 795 elif op == "deleted": 796 rv = mc.remove_active_handler(self) 797 if rv: 798 print "***Unable to remove active handler: " + str(rv) 799 pass 800 pass 801 return 802 803 def domain_addr_cmd_cb(self, domain, addr, lun, netfn, cmd, data): 804 print "Got message from " + domain.get_name() 805 print " addr = " + addr 806 print " lun=%d, netfn=%d, cmd=%d" % (lun, netfn, cmd) 807 tstr = " data:" 808 for b in data: 809 tstr += " %2.2x" % b 810 pass 811 print tstr 812 return 813 814 def mc_cmd_cb(self, mc, netfn, cmd, data): 815 global stop_count, stop_list 816 print "Got message from " + mc.get_name() 817 print " netfn=%d, cmd=%d" % (netfn, cmd) 818 tstr = " data:" 819 for b in data: 820 tstr += " %2.2x" % b 821 pass 822 print tstr 823 stop_list["mc_send_command"] = 0 824 stop_count -= 1 825 print str(stop_list) 826 if stop_count == 0: 827 mc.get_domain().close(main_handler) 828 pass 829 return 830 831 def conn_change_cb(self, domain, err, conn_num, port_num, still_connected): 832 print "Open done (%s): %s" % (self.name, domain.get_name()) 833 if self.name == "hello": 834 i = Handlers("goodbye") 835 rv = domain.add_connect_change_handler(i) 836 if rv: 837 print "Unable to add connect change handler: " + str(rv) 838 pass 839 rv = domain.remove_connect_change_handler(self) 840 if rv: 841 print "Unable to remove connect change handler: " + str(rv) 842 pass 843 844 rv = domain.add_entity_update_handler(i) 845 if rv: 846 print "Unable to add entity updated handler: " + str(rv) 847 pass 848 rv = domain.add_mc_update_handler(i) 849 if rv: 850 print "Unable to add mc updated handler: " + str(rv) 851 pass 852 853 rv = domain.send_command_addr("smi 15 ", 0, 6, 1, [], self) 854 if rv: 855 print "Unable to send domain command (1): " + str(rv) 856 pass 857 858 rv = domain.add_event_handler(self) 859 if rv: 860 print "Unable to add event handler: " + str(rv) 861 pass 862 else: 863 rv = domain.send_command_addr("ipmb 0 32", 0, 10, 0x43, 864 [ 0, 0, 0, 0, 0, 0xff ], self) 865 if rv: 866 print "Unable to send domain command (2): " + str(rv) 867 pass 868 pass 869 return 870 871 def domain_up_cb(self, domain): 872 global stop_count, stop_list 873 print "Domain up: " + domain.get_name() 874 print " type = " + domain.get_type() 875 print " sel_rescan_type = " + str(domain.get_sel_rescan_time()) 876 print " ipmb_rescan_type = " + str(domain.get_ipmb_rescan_time()) 877 domain.set_sel_rescan_time(5) 878 domain.set_ipmb_rescan_time(20) 879 domain.iterate_entities(self) 880 domain.iterate_mcs(self) 881 882 event = domain.first_event() 883 while event: 884 self.event_cb(domain, event) 885 event = domain.next_event(event) 886 pass 887 888 # stop count is incremented at domain startup, don't need another. 889 stop_count += 1 890 stop_list["mc_ipmb_mc_scan"] = 1 891 rv = domain.start_ipmb_mc_scan(0, 0x20, 0x20, self) 892 if rv: 893 print "Error starting IPMB scan: " + str(rv) 894 stop_count -= 1 895 pass 896 897 stop_list["domain_reread_sels"] = 1 898 rv = domain.reread_sels(self) 899 if rv: 900 print "Error starting IPMB scan: " + str(rv) 901 stop_count -= 1 902 pass 903 return 904 905 def domain_reread_sels_cb(self, domain, err): 906 global stop_count, stop_list 907 print "SEL rescan done for " + domain.get_name() + " err=" + str(err) 908 stop_list["domain_reread_sels"] = 0 909 stop_count -= 1 910 print str(stop_list) 911 if stop_count == 0: 912 domain.close(main_handler) 913 pass 914 return 915 916 def domain_close_done_cb(self): 917 self.name = "done" 918 return 919 920 def domain_ipmb_mc_scan_cb(self, domain, err): 921 global stop_count, stop_list 922 print "IPMB scan done for " + domain.get_name() + " err=" + str(err) 923 stop_list["mc_ipmb_mc_scan"] = 0 924 stop_count -= 1 925 print str(stop_list) 926 if stop_count == 0: 927 domain.close(main_handler) 928 pass 929 return 930 931 def entity_iter_entities_cb(self, relative, entity): 932 print " " + entity.get_name() 933 return 934 935 def entity_iter_sensors_cb(self, entity, sensor): 936 print "Sensor: " + sensor.get_name() 937 938 def entity_iter_controls_cb(self, entity, control): 939 print "Control: " + control.get_name() 940 941 def domain_iter_entity_cb(self, domain, entity): 942 print "Entity: " + entity.get_name() 943 if entity.is_child(): 944 print " Parents:" 945 entity.iterate_parents(self) 946 pass 947 if entity.is_parent(): 948 print " Children:" 949 entity.iterate_children(self) 950 pass 951 952 entity.iterate_sensors(self) 953 entity.iterate_controls(self) 954 return 955 956 def domain_iter_mc_cb(self, domain, mc): 957 print "MC: " + mc.get_name() 958 959 event = mc.first_event() 960 while event: 961 self.event_cb(mc.get_domain(), event) 962 event = mc.next_event(event) 963 pass 964 return 965 966 def log(self, level, log): 967 print level + ": " + log 968 return 969 970 pass 971 972OpenIPMI.enable_debug_malloc() 973rv = OpenIPMI.init() 974if (rv != 0): 975 print "OpenIPMI init failed: " + str(rv) 976 sys.exit(1) 977 978main_handler = Handlers("hello") 979 980OpenIPMI.set_log_handler(main_handler) 981 982a = OpenIPMI.open_domain2("test", sys.argv[1:], main_handler, main_handler) 983if not a: 984 print "open failed" 985 sys.exit(1) 986 pass 987del a 988 989while main_handler.name != "done": 990 OpenIPMI.wait_io(1000) 991 pass 992 993class DummyLogHandler: 994 def __init__(self): 995 pass 996 997 def log(self, level, log): 998 sys.stderr.write(level + ": " + log + "\n") 999 1000OpenIPMI.set_log_handler(DummyLogHandler()) 1001OpenIPMI.shutdown_everything() 1002print "done" 1003sys.exit(0) 1004 1005