diff options
Diffstat (limited to 'pyipmi/bmc.py')
| -rw-r--r-- | pyipmi/bmc.py | 567 |
1 files changed, 567 insertions, 0 deletions
diff --git a/pyipmi/bmc.py b/pyipmi/bmc.py new file mode 100644 index 0000000..cda3c9b --- /dev/null +++ b/pyipmi/bmc.py @@ -0,0 +1,567 @@ +# Copyright (c) 2012, Calxeda Inc. +# +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of Calxeda Inc. nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF +# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +# DAMAGE. + + +"""Stuff about BMC's""" + +__all__ = ['BMC', 'BMCInfo', 'BMCGuid', 'BMCEnables', 'LanBMC'] + +class BMCResult(object): + """superclass for BMC result objects + + Sets attribute names from a dict passed to init, and allows comparison + with other results based on dict equality. + """ + def __init__(self, **entries): + """each kwarg's value to an attribute of the same name""" + self.__dict__.update(entries) + + def __eq__(self, other): + """BMCInfo's are equivalent if their attributes are the same""" + return self.__dict__ == other.__dict__ + + +class BMCInfo(BMCResult): + """Describes a BMC info record result + + "bmc info" is just the ipmitool name - this is really "get device id" + """ + device_id = None + device_revision = None + firmware_revision = None + ipmi_version = None + is_chassis_device = None + is_bridge = None + is_ipmb_event_generator = None + is_ipmb_event_receiver = None + is_fru_inventory_device = None + is_sel_device = None + is_sdr_repository_device = None + is_sensor_device = None + manufacturer_id = None + product_id = None + device_available = None + aux_firmware_revision_info = None + +class BMCGuid(BMCResult): + """Result record for bmc guid command + + this is really "get device guid" - bmc guid is the ipmitool command name. + """ + system_guid = None + time_stamp = None + +class BMCEnables(BMCResult): + """Result record for get command enables + + The names for the attributes here come from the command line syntax for ipmitool + """ + recv_msg_intr = None + event_msg_intr = None + event_msg = None + system_event_log = None + oem0 = None + oem1 = None + oem2 = None + +class BMCResetResult(BMCResult): + """Result record for bmc reset command""" + pass + +class BMC(object): + """A BMC - what you're talking to when you're talking IPMI + + I think this should ultimately be the interface for all commands issued + from IPMI.. or maybe just commands "about the bmc". This needs to be + resolved! + """ + def __init__(self, handle_class, tool_class, command_list): + """ + Arguments: + handle_class -- class to use for Handles created + tool_class -- class to use for the Tool for each handle + command_list -- the list of commands available for this BMC + """ + self.handle = handle_class(self, tool_class, command_list) + + def info(self): + """Get the BMC's info""" + return self.handle.get_device_id() + + def selftest(self): + """Get BMC self test results""" + return self.handle.selftest() + + def bmc_reset(self, type='warm'): + return self.handle.bmc_reset(type=type) + + def guid(self): + """Get the BMC's guid""" + return self.handle.get_system_guid() + + def sdr_list(self): + """Get a list of SDR's for the BMC""" + return self.handle.get_sdr_list() + + def enables(self): + """Return a BMCEnables object for the BMC""" + return self.handle.get_command_enables() + + def set_chassis_power(self, mode): + return self.handle.chassis_control(mode=mode) + + def set_chassis_policy(self, state): + return self.handle.chassis_policy(state=state) + + def get_chassis_status(self): + return self.handle.chassis_status() + + def update_socman(self, filename, partition, tftp_addr): + return self.update_firmware(filename, partition, '3', tftp_addr) + + def update_firmware(self, filename, partition, image_type, tftp_addr): + return self.handle.fw_download(filename=filename, partition=partition, + image_type=image_type, + tftp_addr=tftp_addr) + + + def retrieve_firmware(self, filename, partition, image_type, tftp_addr): + return self.handle.fw_upload(filename=filename, partition=partition, + image_type=image_type, + tftp_addr=tftp_addr) + + def register_firmware_read(self, filename, partition, image_type): + return self.handle.fw_register_read(filename=filename, + partition=partition, + image_type=image_type) + + def register_firmware_write(self, filename, partition, image_type): + return self.handle.fw_register_write(filename=filename, + partition=partition, + image_type=image_type) + + def activate_firmware(self, partition): + return self.handle.fw_activate(partition=partition) + + def invalidate_firmware(self, partition): + return self.handle.fw_invalidate(partition=partition) + + def set_firmware_flags(self, partition, flags): + return self.handle.fw_flags(partition=partition, flags=flags) + + def get_firmware_status(self, tftp_handle): + return self.handle.fw_status(tftp_handle=tftp_handle) + + def check_firmware(self, partition): + return self.handle.fw_check(partition=partition) + + def cancel_firmware(self, job_id): + return self.handle.fw_cancel(job_id=job_id) + + def update_raw_firmware(self, filename, offset, size, tftp_addr): + return self.handle.fw_put(filename=filename, offset=offset, + size=size, tftp_addr=tftp_addr) + + def retrieve_raw_firmware(self, filename, offset, size, tftp_addr): + return self.handle.fw_get(filename=filename, offset=offset, + size=size, tftp_addr=tftp_addr) + + def get_firmware_info(self): + return self.handle.fw_info() + + def reset_firmware(self): + return self.handle.fw_reset() + + def set_firmware_version(self, version): + return self.handle.fw_version(version=version) + + def get_sel_time(self): + """Get the time for the SEL""" + return self.handle.get_sel_time() + + def set_sel_time(self, time): + """Set the time for the SEL""" + return self.handle.set_sel_time(time=time) + + def sel_info(self): + """Get SEL info""" + return self.handle.sel_info() + + def sel_alloc_info(self): + """Get SEL alloc info""" + return self.handle.sel_alloc_info() + + def sel_add(self, *records): + """Add records to the SEL""" + return self.handle.sel_add(records=records) + + def sel_get(self, *record_ids): + """Get SEL Records""" + return self.handle.sel_get(record_ids=record_ids) + + def sel_list(self): + """List SEL entries""" + return self.handle.sel_list() + + def sel_clear(self): + """Clear the SEL""" + return self.handle.sel_clear() + + def set_sol_config_param(self, param, value): + """Set SOL Configuration Parameter""" + return self.handle.set_sol_config_params(param=param, value=value) + + def get_sol_config_params(self, *params): + """Get SOL Configuration Parameters""" + return self.handle.get_sol_config_params(params=params) + + def activate_payload(self): + """Activate an SOL session""" + return self.handle.activate_payload() + + def deactivate_payload(self): + """Deactivate an SOL session""" + return self.handle.deactivate_payload() + + def dcmi_get_capabilities(self): + return self.handle.dcmi_get_capabilities() + + def dcmi_set_asset_tag(self, tag): + return self.handle.dcmi_set_asset_tag(tag=tag) + + def dcmi_get_asset_tag(self): + return self.handle.dcmi_get_asset_tag() + + def dcmi_get_controller_id(self): + return self.handle.dcmi_get_controller_id() + + def dcmi_set_controller_id(self, controller): + return self.handle.dcmi_set_controller_id(controller=controller) + + def dcmi_get_sensor_info(self): + return self.handle.dcmi_get_sensor_info() + + def dcmi_get_power_statistics(self): + return self.handle.dcmi_get_power_statistics() + + def dcmi_get_power_limit(self): + return self.handle.dcmi_get_power_limit() + + def dcmi_set_power_limit(self): + return self.handle.dcmi_set_power_limit() + + def dcmi_power_limit_requested(self, limit, exception=None): + return self.handle.dcmi_power_limit_requested(limit=limit, exception=exception) + + def dcmi_correction_time_limit(self, time_limit, exception=None): + return self.handle.dcmi_correction_time_limit(time_limit=time_limit, exception=exception) + + def dcmi_statistics_sampling_period(self, period, exception=None): + return self.handle.dcmi_statistics_sampling_period(period=period, exception=exception) + + + def dcmi_activate_power_limit(self, action): + if action != "activate" and action != "deactivate": + raise Exception("Invalid argument to dcmi_activate_power_limit: %s" % action) + return self.handle.dcmi_activate_power_limit(action=action) + + def pef_get_info(self): + return self.handle.pef_get_info() + + def pef_get_status(self): + return self.handle.pef_get_status() + + def pef_get_policies(self): + return self.handle.pef_get_policies() + + def pef_list_entries(self): + return self.handle.pef_list_entries() + + def pef_config_get_info(self): + return self.handle.pef_config_info() + + def pef_checkout(self, section=None, filename=None, key=None): + return self.handle.pef_checkout(section=section, filename=filename, + key=key) + + def pef_commit(self, section=None, filename=None, key_value_pair=None): + return self.handle.pef_commit(section=section, filename=filename, + key_value_pair=key_value_pair) + + def pef_diff(self, section=None, filename=None, key=None): + return self.handle.pef_diff(section=section, filename=filename, + key=key) + + def pef_list_sections(self): + return self.handle.pef_list_sections() + + def generate_generic_event(self, event_type): + return self.handle.generic_event(event_type=event_type) + + def generate_sensor_event(self, sensor_id, state): + return self.handle.assert_sensor_event(sensor_id=sensor_id, + state=state) + + def get_watchdog_status(self): + return self.handle.watchdog_get() + + def reset_watchdog(self): + return self.handle.watchdog_reset() + + def disable_watchdog(self): + return self.handle.watchdog_off() + + def fru_get_inventory(self): + return self.handle.fru_print() + + def fru_read(self, fru_id, filename): + return self.handle.fru_read(fru_id=fru_id, filename=filename) + + def fru_write(self, fru_id, filename): + return self.handle.fru_write(fru_id=fru_id, filename=filename) + + def fru_upg_e_key(self, fru_id, filename): + return self.handle.fru_upg_e_key(fru_id=fru_id, filename=filename) + + def fru_show(self, filename): + return self.handle.fru_show(filename=filename) + + def lan_print(self, channel=''): + return self.handle.lan_print(channel=channel) + + def lan_set(self, channel, command, param): + return self.handle.lan_set(channel=channel, command=command, + param=param) + + def channel_info(self): + return self.handle.channel_info() + + def channel_get_access(self, channel, userid=""): + return self.handle.channel_get_access(channel=channel, userid=userid) + + def channel_set_access(self, channel, userid, callin=None, ipmi=None, + link=None, priv_level=None): + return self.handle.channel_set_access(channel=channel, userid=userid, + callin=callin, ipmi=ipmi, + link=link, priv_level=priv_level) + + def channel_get_ciphers(self, mode='ipmi'): + return self.handle.channel_get_ciphers(mode=mode) + + def user_list(self, channel=None): + return self.handle.user_list(channel=channel) + + def user_set_name(self, userid, name): + return self.handle.user_set_name(userid=userid, name=name) + + def user_set_password(self, userid, password=None): + return self.handle.user_set_password(userid=userid, password=password) + + def user_enable(self, userid): + return self.handle.user_enable(userid=userid) + + def user_disable(self, userid): + return self.handle.user_disable(userid=userid) + + def user_priv(self, userid, priv_level, channel=None): + return self.handle.user_priv(userid=userid, priv_level=priv_level, + channel=channel) + # + # fabric commands + # + + def fabric_update_config(self): + return self.handle.fabric_updateconfig() + + def fabric_get_node_id(self): + return self.handle.fabric_getnodeid() + + def fabric_get_ip_addr(self, nodeid="", iface=""): + return self.handle.fabric_getipaddr(nodeid=nodeid, iface=iface) + + def fabric_get_mac_addr(self, nodeid="", iface=0): + return self.handle.fabric_getmacaddr(nodeid=nodeid, iface=iface) + + def fabric_get_linkspeed(self, link=None, actual=None): + return self.handle.fabric_getlinkspeed(link=link, actual=actual) + + def fabric_get_linkstats(self, filename=None, tftp_addr=None, link=None): + return self.handle.fabric_getlinkstats( + filename=filename, + tftp_addr=tftp_addr, + link=link + ) + + def fabric_get_linkmap(self, filename, tftp_addr=None): + return self.handle.fabric_getlinkmap(filename=filename, + tftp_addr=tftp_addr) + + def fabric_get_routingtable(self, filename, tftp_addr=None): + return self.handle.fabric_getroutingtable(filename=filename, + tftp_addr=tftp_addr) + + def fabric_get_depthchart(self, filename, tftp_addr=None): + return self.handle.fabric_getdepthchart(filename=filename, + tftp_addr=tftp_addr) + + def fabric_add_macaddr(self, iface, macaddr, nodeid=None): + return self.handle.fabric_addmacaddr(nodeid=nodeid, iface=iface, macaddr=macaddr) + + def fabric_rm_macaddr(self, iface, macaddr, nodeid=None): + return self.handle.fabric_rmmacaddr(nodeid=nodeid, iface=iface, macaddr=macaddr) + + # + # fabric config commands + # + + def fabric_config_update_config(self): + return self.handle.fabric_config_updateconfig() + + def fabric_config_get_ip_info(self, filename, tftp_addr=None): + return self.handle.fabric_config_getipinfo(filename=filename, + tftp_addr=tftp_addr) + + def fabric_config_get_mac_addresses(self, filename, tftp_addr=None): + return self.handle.fabric_config_getmacaddresses(filename=filename, + tftp_addr=tftp_addr) + + def fabric_config_get_uplink_info(self, filename, tftp_addr=None): + return self.handle.fabric_config_getuplinkinfo(filename=filename, + tftp_addr=tftp_addr) + + def fabric_config_get_ip_src(self): + return self.handle.fabric_config_getipsrc() + + def fabric_config_set_ip_src(self, ipsrc_mode): + return self.handle.fabric_config_setipsrc(ipsrc_mode=ipsrc_mode) + + def fabric_config_factory_default(self): + return self.handle.fabric_config_factory_default() + + def fabric_config_get_ip_addr_base(self): + return self.handle.fabric_config_get_ipaddr_base() + + def fabric_config_get_linkspeed(self): + return self.handle.fabric_config_getlinkspeed() + + def fabric_config_set_linkspeed(self, linkspeed): + return self.handle.fabric_config_setlinkspeed(linkspeed=linkspeed) + + def fabric_config_get_linkspeed_policy(self): + return self.handle.fabric_config_getlinkspeedpolicy() + + def fabric_config_set_linkspeed_policy(self, ls_policy): + return self.handle.fabric_config_setlinkspeedpolicy(ls_policy=ls_policy) + + def fabric_config_get_uplink(self, iface=0): + return self.handle.fabric_config_getuplink(iface=iface) + + def fabric_config_set_uplink(self, uplink=0, iface=0): + return self.handle.fabric_config_setuplink(uplink=uplink, iface=iface) + + def fabric_config_get_link_users_factor(self): + return self.handle.fabric_config_getlinkusersfactor() + + def fabric_config_set_link_users_factor(self, lu_factor): + return self.handle.fabric_config_setlinkusersfactor(lu_factor=lu_factor) + + def set_bootdev(self, device, options=None): + return self.handle.bootdev_set(device=device, options=options) + + def get_bootdev(self): + return self.handle.bootdev_get() + + def get_bootparam(self, param): + return self.handle.bootparam_get(param=param) + + def mc_reset(self, mode): + return self.handle.mc_reset(mode=mode) + + def mem_read(self, length, address, fmt=None): + return self.handle.data_memread(length=length, addr=address, + fmt=fmt) + + def mem_write(self, length, address, value): + return self.handle.data_memwrite(length=length, addr=address, + value=value) + + def cdb_read(self, length, cid, fmt=None): + return self.handle.data_cdbread(length=length, cid=cid, + fmt=fmt) + + def cdb_write(self, length, cid, value): + return self.handle.data_cdbwrite(length=length, cid=cid, + value=value) + + def get_info_basic(self): + return self.handle.info_basic() + + def get_info_card(self): + return self.handle.info_card() + + # + # fabric info commands + # + + def fabric_info_get_routing_table(self, filename, tftp_addr=None): + return self.handle.fabric_info_getroutingtable(filename=filename, + tftp_addr=tftp_addr) + + def fabric_info_get_link_map(self, filename, tftp_addr=None): + return self.handle.fabric_info_getlinkmap(filename=filename, + tftp_addr=tftp_addr) + + def fabric_info_get_depth_chart(self, filename, tftp_addr=None): + return self.handle.fabric_info_getdepthchart(filename=filename, + tftp_addr=tftp_addr) + +class LanBMC(BMC): + """A BMC that's accessed over the LAN""" + def __init__(self, + hostname, + username=None, + password=None, + authtype=None, + level=None, + port=623, + interface='lan', + **kwargs): + + self.params = { + 'hostname' : hostname, + 'username' : username, + 'password' : password, + 'authtype' : authtype, + 'level' : level, + 'port' : port, + 'interface' : interface + } + + super(LanBMC, self).__init__(**kwargs) |