Example #1
0
 def test_decode_byte34_rsp(self):
     m = pyipmi.msgs.sensor.GetSensorEventEnableRsp()
     decode_message(m, '\x00\xc0\xaa\xbb')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.enabled.event_message, 1)
     self.assertEqual(m.byte3, 0xaa)
     self.assertEqual(m.byte4, 0xbb)
Example #2
0
def test_get_shelf_address_info_rsp():
    m = pyipmi.msgs.picmg.GetShelfAddressInfoRsp()
    decode_message(m, b'\x00\x00\x01\x02')
    eq_(m.completion_code, 0x00)
    eq_(m.picmg_identifier, 0x00)
    eq_(m.shelf_address[0], 0x01)
    eq_(m.shelf_address[1], 0x02)
Example #3
0
def test_deviceid_object_with_aux():
    m = pyipmi.msgs.bmc.GetDeviceIdRsp()
    decode_message(m,
    '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04')

    d = DeviceId(m)
    eq_(d.aux, [1,2,3,4])
Example #4
0
def test_getsensoreventenable_decode_byte34_rsp():
    m = pyipmi.msgs.sensor.GetSensorEventEnableRsp()
    decode_message(m, '\x00\xc0\xaa\xbb')
    eq_(m.completion_code, 0x00)
    eq_(m.enabled.event_message, 1)
    eq_(m.byte3, 0xaa)
    eq_(m.byte4, 0xbb)
Example #5
0
def test_getmessage_decode_with_data_rsp():
        m = pyipmi.msgs.bmc.GetMessageRsp()
        decode_message(m, '\x00\x21\xaa\xff\xff\xee')
        eq_(m.completion_code, 0x00)
        eq_(m.channel_number.channel_number, 1)
        eq_(m.channel_number.privilege_level, 2)
        eq_(m.data, array('B', b'\xaa\xff\xff\xee'))
def test_getmessage_decode_with_data_rsp():
    m = pyipmi.msgs.device_messaging.GetMessageRsp()
    decode_message(m, b'\x00\x21\xaa\xff\xff\xee')
    eq_(m.completion_code, 0x00)
    eq_(m.channel.number, 1)
    eq_(m.channel.privilege_level, 2)
    eq_(m.data, array('B', [0xaa, 0xff, 0xff, 0xee]))
Example #7
0
 def test_decode_rsp(self):
     m = pyipmi.msgs.bmc.ReadEventMessageBufferRsp()
     decode_message(m, '\x00\x00\x01\x02\x03\x04\x05\x06\x07'\
             '\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.event_data, array('B', '\x00\x01\x02\x03\x04'\
             '\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f'))
def test_readeventmessagebuffer_decode_rsp():
    m = pyipmi.msgs.device_messaging.ReadEventMessageBufferRsp()
    decode_message(m, b'\x00\x00\x01\x02\x03\x04\x05\x06\x07'
                   b'\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f')
    eq_(m.completion_code, 0x00)
    eq_(m.event_data, array('B', b'\x00\x01\x02\x03\x04'
        b'\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f'))
Example #9
0
	def test_decode_with_data_rsp(self):
		m = pyipmi.msgs.bmc.GetMessageRsp()
		decode_message(m, '\x00\x21\xaa\xff\xff\xee')
		self.assertEqual(m.completion_code, 0x00)
		self.assertEqual(m.channel_number.channel_number, 1)
		self.assertEqual(m.channel_number.privilege_level, 2)
		self.assertEqual(m.data, array('B', '\xaa\xff\xff\xee'))
Example #10
0
 def test_get_shelf_address_info_rsp(self):
     m = pyipmi.msgs.picmg.GetShelfAddressInfoRsp()
     decode_message(m, "\x00\x00\x01\x02")
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.picmg_identifier, 0x00)
     self.assertEqual(m.shelf_address[0], 0x01)
     self.assertEqual(m.shelf_address[1], 0x02)
Example #11
0
    def send_and_receive(self, msg):
        """Sends an IPMI request message and waits for its response.

        `msg` is a IPMI Message containing both the request and response.
        """

        log().debug('IPMI Request [%s]', msg)

        retries = 0
        while retries < self.max_retries:
            try:
                rx_data = self._send_and_receive_raw(msg.target, msg.lun,
                        msg.netfn, chr(msg.cmdid) + encode_message(msg))
                break
            except TimeoutError:
                pass

            retries += 1

        else:
            raise TimeoutError()

        msg = create_message(msg.cmdid, msg.netfn + 1)
        decode_message(msg, rx_data[5:-1])

        log().debug('IPMI Response [%s])', msg)

        return msg
Example #12
0
 def test_decode_rsp_local_control_state(self):
     m = pyipmi.msgs.picmg.GetFruLedStateRsp()
     decode_message(m, '\x00\x00\x01\xff\x00\x02')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.led_states.local_avail, 1)
     self.assertEqual(m.local_function, 0xff)
     self.assertEqual(m.local_on_duration, 0)
     self.assertEqual(m.local_color, 2)
Example #13
0
 def test_decode_rsp(self):
     m = pyipmi.msgs.sdr.GetSdrRepositoryAllocationInfoRsp()
     decode_message(m,'\x00\x11\x22\x33\x44\x55\x66\x77\x88\xaa')
     eq_(m.completion_code, 0x00)
     eq_(m.number_of_units, 0x2211)
     eq_(m.unit_size, 0x4433)
     eq_(m.free_units, 0x6655)
     eq_(m.largest_free_block, 0x8877)
     eq_(m.maximum_record_size, 0xaa)
Example #14
0
 def test_decode_event_message_full_set_rsp(self):
     m = pyipmi.msgs.bmc.GetMessageFlagsRsp()
     decode_message(m, '\x00\x02')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.flag.oem_2, 0)
     self.assertEqual(m.flag.oem_1, 0)
     self.assertEqual(m.flag.oem_0, 0)
     self.assertEqual(m.flag.watchdog_pretimeout_interrupt_occurred, 0)
     self.assertEqual(m.flag.event_message_buffer_full, 1)
     self.assertEqual(m.flag.receive_message_available, 0)
Example #15
0
def test_getdevicesdrinfo_encode_rsp():
    m = pyipmi.msgs.sensor.GetDeviceSdrInfoRsp()
    decode_message(m, '\x00\x03\x05')
    eq_(m.completion_code, 0x00)
    eq_(m.number_of_sensors, 3)
    eq_(m.flags.lun0_has_sensors, 1)
    eq_(m.flags.lun1_has_sensors, 0)
    eq_(m.flags.lun2_has_sensors, 1)
    eq_(m.flags.lun3_has_sensors, 0)
    eq_(m.flags.dynamic_population, 0)
def test_getmessageflags_decode_event_message_full_set_rsp():
    m = pyipmi.msgs.device_messaging.GetMessageFlagsRsp()
    decode_message(m, b'\x00\x02')
    eq_(m.completion_code, 0x00)
    eq_(m.flag.oem_2, 0)
    eq_(m.flag.oem_1, 0)
    eq_(m.flag.oem_0, 0)
    eq_(m.flag.watchdog_pretimeout_interrupt_occurred, 0)
    eq_(m.flag.event_message_buffer_full, 1)
    eq_(m.flag.receive_message_available, 0)
Example #17
0
 def test_encode_rsp(self):
     m = pyipmi.msgs.sensor.GetDeviceSdrInfoRsp()
     decode_message(m, '\x00\x03\x05')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.number_of_sensors, 3)
     self.assertEqual(m.flags.lun0_has_sensors, 1)
     self.assertEqual(m.flags.lun1_has_sensors, 0)
     self.assertEqual(m.flags.lun2_has_sensors, 1)
     self.assertEqual(m.flags.lun3_has_sensors, 0)
     self.assertEqual(m.flags.dynamic_population, 0)
Example #18
0
 def test_encode_rsp_with_timestamp(self):
     m = pyipmi.msgs.sensor.GetDeviceSdrInfoRsp()
     decode_message(m, '\x00\x12\x01\xaa\xbb\xcc\xdd')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.number_of_sensors, 0x12)
     self.assertEqual(m.flags.lun0_has_sensors, 1)
     self.assertEqual(m.flags.lun1_has_sensors, 0)
     self.assertEqual(m.flags.lun2_has_sensors, 0)
     self.assertEqual(m.flags.lun3_has_sensors, 0)
     self.assertEqual(m.flags.dynamic_population, 0)
     self.assertEqual(m.sensor_population_change, 0xddccbbaa)
def test_getbmcglobalenables_decode_oem_2_enabled_rsp():
    m = pyipmi.msgs.device_messaging.GetBmcGlobalEnablesRsp()
    decode_message(m, b'\x00\x80')
    eq_(m.completion_code, 0x00)
    eq_(m.enables.oem_2, 1)
    eq_(m.enables.oem_1, 0)
    eq_(m.enables.oem_0, 0)
    eq_(m.enables.system_event_logging, 0)
    eq_(m.enables.event_message_buffer, 0)
    eq_(m.enables.event_message_buffer_full_interrupt, 0)
    eq_(m.enables.receive_message_queue_interrupt, 0)
Example #20
0
 def test_decode_oem_0_enabled_rsp(self):
     m = pyipmi.msgs.bmc.GetBmcGlobalEnablesRsp()
     decode_message(m, '\x00\x20')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.enables.oem_2, 0)
     self.assertEqual(m.enables.oem_1, 0)
     self.assertEqual(m.enables.oem_0, 1)
     self.assertEqual(m.enables.system_event_logging, 0)
     self.assertEqual(m.enables.event_message_buffer, 0)
     self.assertEqual(m.enables.event_message_buffer_full_interrupt, 0)
     self.assertEqual(m.enables.receive_message_queue_interrupt, 0)
Example #21
0
def test_get_address_info_mtca_rsp():
    m = pyipmi.msgs.picmg.GetAddressInfoRsp()
    decode_message(m, b'\x00\x00\x01\x02\x03\x04\x05\x06\x07')
    eq_(m.completion_code, 0x00)
    eq_(m.picmg_identifier, 0x00)
    eq_(m.hardware_address, 0x01)
    eq_(m.ipmb_0_address, 0x02)
    eq_(m.ipmb_1_address, 0x03)
    eq_(m.fru_id, 0x04)
    eq_(m.site_id, 0x05)
    eq_(m.site_type, 0x06)
    eq_(m.carrier_number, 0x07)
Example #22
0
 def test_get_address_info_mtca_rsp(self):
     m = pyipmi.msgs.picmg.GetAddressInfoRsp()
     decode_message(m, "\x00\x00\x01\x02\x03\x04\x05\x06\x07")
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.picmg_identifier, 0x00)
     self.assertEqual(m.hardware_address, 0x01)
     self.assertEqual(m.ipmb_0_address, 0x02)
     self.assertEqual(m.ipmb_1_address, 0x03)
     self.assertEqual(m.fru_id, 0x04)
     self.assertEqual(m.site_id, 0x05)
     self.assertEqual(m.site_type, 0x06)
     self.assertEqual(m.carrier_number, 0x07)
Example #23
0
def test_get_address_info_picmg_2_9_rsp():
    m = pyipmi.msgs.picmg.GetAddressInfoRsp()
    decode_message(m, '\x00\x00\x01\x02\x03')
    eq_(m.completion_code, 0x00)
    eq_(m.picmg_identifier, 0x00)
    eq_(m.hardware_address, 0x01)
    eq_(m.ipmb_0_address, 0x02)
    eq_(m.ipmb_1_address, 0x03)
    eq_(m.fru_id, None)
    eq_(m.site_id, None)
    eq_(m.site_type, None)
    eq_(m.carrier_number, None)
Example #24
0
 def test_decode_rsp_override_mode(self):
     m = pyipmi.msgs.picmg.GetFruLedStateRsp()
     decode_message(m, '\x00\x00\x03\xff\x00\x03\xff\x00\x03')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.led_states.local_avail, 1)
     self.assertEqual(m.local_function, 0xff)
     self.assertEqual(m.local_on_duration, 0)
     self.assertEqual(m.local_color, 3)
     self.assertEqual(m.led_states.override_en, 1)
     self.assertEqual(m.override_function, 0xff)
     self.assertEqual(m.override_on_duration, 0)
     self.assertEqual(m.override_color, 3)
     self.assertEqual(m.led_states.lamp_test_en, 0)
Example #25
0
    def send_and_receive(self, req):
        log().debug('IPMI Request [%s]', req)

        req_data = (chr(req.cmdid))
        req_data += encode_message(req)

        rsp_data = self.send_and_receive_raw(req.target, req.lun, req.netfn,
                req_data)

        rsp = create_message(req.cmdid, req.netfn + 1)
        decode_message(rsp, rsp_data.tostring())
        log().debug('IPMI Response [%s])', rsp)

        return rsp
Example #26
0
 def test_decode_rsp_only_lamp_test_mode(self):
     m = pyipmi.msgs.picmg.GetFruLedStateRsp()
     decode_message(m, "\x00\x00\x04\xff\x00\x02\xff\x00\x02\x7f")
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.led_states.local_avail, 0)
     self.assertEqual(m.local_function, 0xFF)
     self.assertEqual(m.local_on_duration, 0)
     self.assertEqual(m.local_color, 2)
     self.assertEqual(m.led_states.override_en, 0)
     self.assertEqual(m.override_function, 0xFF)
     self.assertEqual(m.override_on_duration, 0)
     self.assertEqual(m.override_color, 2)
     self.assertEqual(m.led_states.lamp_test_en, 1)
     self.assertEqual(m.lamp_test_duration, 0x7F)
Example #27
0
def test_decode_rsp_only_lamp_test_mode():
    m = pyipmi.msgs.picmg.GetFruLedStateRsp()
    decode_message(m, b'\x00\x00\x04\xff\x00\x02\xff\x00\x02\x7f')
    eq_(m.completion_code, 0x00)
    eq_(m.led_states.local_avail, 0)
    eq_(m.local_function, 0xff)
    eq_(m.local_on_duration, 0)
    eq_(m.local_color, 2)
    eq_(m.led_states.override_en, 0)
    eq_(m.override_function, 0xff)
    eq_(m.override_on_duration, 0)
    eq_(m.override_color, 2)
    eq_(m.led_states.lamp_test_en, 1)
    eq_(m.lamp_test_duration, 0x7f)
Example #28
0
def test_getselftestresults_decode_test_fail_corrupted_sdr_rsp():
    m = pyipmi.msgs.bmc.GetSelftestResultsRsp()
    decode_message(m, b'\x00\x57\x40')
    eq_(m.completion_code, 0x00)
    eq_(m.result, 0x57)
    eq_(int(m.status), 0x40)
    eq_(m.status.cannot_access_sel_device, 0)
    eq_(m.status.cannot_access_sdr_device, 1)
    eq_(m.status.cannot_access_bmc_fru_device, 0)
    eq_(m.status.ipmb_signal_lines_do_not_respond, 0)
    eq_(m.status.sdr_repository_empty, 0)
    eq_(m.status.internal_use_area_corrupted, 0)
    eq_(m.status.controller_bootblock_corrupted, 0)
    eq_(m.status.controller_firmware_corrupted, 0)
Example #29
0
def test_deviceid_object():
    m = pyipmi.msgs.bmc.GetDeviceIdRsp()
    decode_message(m, '\x00\x12\x84\x05\x67\x51\x55\x12\x34\x56\x44\x55')

    d = DeviceId(m)
    eq_(d.device_id, 18)
    eq_(d.revision, 4)
    eq_(d.provides_sdrs, True)
    eq_(str(d.fw_revision), '5.67')
    eq_(str(d.ipmi_version), '1.5')
    eq_(d.manufacturer_id, 5649426)
    eq_(d.product_id, 21828)

    eq_(d.aux, None)
Example #30
0
 def test_decode_rsp(self):
     m = pyipmi.msgs.sdr.GetSdrRepositoryInfoRsp()
     decode_message(m,'\x00\x51\x00\x11\x55\xaa\x11\x22\x33\x44\x55\x66\x77\x88\xaa')
     eq_(m.completion_code,  0x00)
     eq_(m.sdr_version,  0x51)
     eq_(m.record_count,  0x1100)
     eq_(m.free_space,  0xaa55)
     eq_(m.most_recent_addition, 0x44332211)
     eq_(m.most_recent_erase, 0x88776655)
     eq_(m.operation_support.get_sdr_repository_allocation_command, 0)
     eq_(m.operation_support.reserve_sdr_repository_command, 1)
     eq_(m.operation_support.partial_add_sdr_command, 0)
     eq_(m.operation_support.delete_sdr_command, 1)
     eq_(m.operation_support.sdr_repository_update_type, 1)
     eq_(m.operation_support.overflow_flag, 1)
Example #31
0
def test_clearsdrrepository_decode_rsp():
    m = pyipmi.msgs.sdr.ClearSdrRepositoryRsp()
    decode_message(m, b'\x00\x11')
    eq_(m.completion_code, 0x00)
    eq_(m.status.erase_in_progress, 0x1)
Example #32
0
def test_Lan_set_lan_info_ipv4_valid():
    lan_obj = pyipmi.lan.Lan()

    # create fake response
    req = pyipmi.msgs.lan.GetLanConfigurationParametersReq()
    req.command.channel_number = 1
    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_SET_IN_PROGRESS
    req.set_selector = 0
    req.block_selector = 0
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    rsp.completion_code = 0

    mock_send_recv = MagicMock()
    mock_send_recv.return_value = [rsp]
    lan_obj._lan_send_and_recv = mock_send_recv

    # create fake lan_info
    # IPv6/IPv4 all enable
    # IPv4 source : dhcp
    # IPv4 address: 192.168.1.105
    # IPv4 subnet mask: 255.255.255.0
    # IPv4 default gateway: 192.168.1.1
    rsp_org_list = []
    test_lan_info = pyipmi.lan.LanInfo()
    req = pyipmi.msgs.lan.GetLanConfigurationParametersReq()
    req.command.channel_number = 1

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IPV6_IPV4_ADDRESSING_ENABLES
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x02')
    rsp_org_list.append(rsp)

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\xc0\xa8\x01\x69')
    rsp_org_list.append(rsp)

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS_SOURCE
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x02')
    rsp_org_list.append(rsp)

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_SUBNET_MASK
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\xff\xff\xff\x00')
    rsp_org_list.append(rsp)

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_DEFAULT_GATEWAY_ADDRESS
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\xc0\xa8\x01\x01')
    rsp_org_list.append(rsp)

    for rsp in rsp_org_list:
        req_obj = rsp.req_obj
        test_lan_info.refresh_info(rsp)

    mock_get_lan_info = MagicMock()
    mock_get_lan_info.return_value = test_lan_info
    lan_obj.get_lan_info = mock_get_lan_info

    # test case 1: disable ipv4
    lan_obj.set_lan_info(channel=1, ipv4_enable=False)
    args = mock_send_recv.call_args.args
    reqs = args[0]
    param_req_map = { req.parameter_selector: req  for req in reqs }
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_IPV6_IPV4_ADDRESSING_ENABLES in param_req_map.keys())
    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_IPV6_IPV4_ADDRESSING_ENABLES]
    eq_(test_req.ipv6_ipv4_addressing_enables, pyipmi.lan.LanInfo.FIELD_IPV6_IPV4_ADDRESSING_ENABLES_INV["ipv6_addr_enable_only"])

    # test case 2: enable ipv4, addr_src is dhcp
    lan_obj.set_lan_info(channel=1, ipv4_enable=True, addr_src='dhcp')
    args = mock_send_recv.call_args.args
    reqs = args[0]
    param_req_map = { req.parameter_selector: req  for req in reqs }
    eq_(len(reqs), 1)
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS_SOURCE in param_req_map.keys())
    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS_SOURCE]
    eq_(test_req.ipv4_address_source.src, pyipmi.lan.LanInfo.FIELD_IP_ADDRESS_SOURCE_INV["dhcp"])

    # test case 3: enable ipv4, settings ip_addr: 192.168.1.104, but others remain the same.
    lan_obj.set_lan_info(channel=1, ipv4_enable=True, addr=ipaddress.IPv4Address("192.168.1.104"))
    args = mock_send_recv.call_args.args
    reqs = args[0]
    param_req_map = { req.parameter_selector: req  for req in reqs }
    eq_(len(reqs), 4)
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS_SOURCE in param_req_map.keys())
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS in param_req_map.keys())
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_SUBNET_MASK in param_req_map.keys())
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_DEFAULT_GATEWAY_ADDRESS in param_req_map.keys())

    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS_SOURCE]
    eq_(test_req.ipv4_address_source.src, pyipmi.lan.LanInfo.FIELD_IP_ADDRESS_SOURCE_INV["static_addr_by_manual"])
    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS]
    eq_(test_req.ipv4_address, int(ipaddress.IPv4Address("192.168.1.104")))
    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_SUBNET_MASK]
    eq_(test_req.ipv4_subnet_mask, int(ipaddress.IPv4Address("255.255.255.0")))
    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_DEFAULT_GATEWAY_ADDRESS]
    eq_(test_req.ipv4_default_gateway_address, int(ipaddress.IPv4Address("192.168.1.1")))
Example #33
0
def test_getsensorhysteresis_decode_rsp():
    m = pyipmi.msgs.sensor.GetSensorHysteresisRsp()
    decode_message(m, '\x00\xaa\xbb')
    eq_(m.completion_code, 0x00)
    eq_(m.positive_going_hysteresis, 0xaa)
    eq_(m.negative_going_hysteresis, 0xbb)
Example #34
0
 def test_decode_rsp_with_cc(self):
     m = pyipmi.msgs.bmc.GetDeviceIdRsp()
     decode_message(m, '\xc0')
     self.assertEqual(m.completion_code, 0xc0)
Example #35
0
 def test_decode_no_data_rsp(self):
     m = pyipmi.msgs.bmc.GetMessageRsp()
     decode_message(m, '\x00\x21')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.channel_number.channel_number, 1)
     self.assertEqual(m.channel_number.privilege_level, 2)
Example #36
0
 def test_decode_rsp_with_cc(self):
     m = pyipmi.msgs.fru.ReadFruDataRsp()
     decode_message(m, '\xc0')
     self.assertEqual(m.completion_code, 0xc0)
Example #37
0
def test_getselentry_decode_invalid_rsp():
    m = pyipmi.msgs.sel.GetSelEntryRsp()
    decode_message(m, '\x00\x01')
Example #38
0
def test_addsdr_decode_rsp():
    m = pyipmi.msgs.sdr.AddSdrRsp()
    decode_message(m, b'\x00\x11\x22')
    eq_(m.completion_code, 0x00)
    eq_(m.record_id, 0x2211)
Example #39
0
 def test_decode_scanning_enabled_rsp(self):
     m = pyipmi.msgs.sensor.GetSensorEventEnableRsp()
     decode_message(m, '\x00\x40')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.enabled.event_message, 0)
     self.assertEqual(m.enabled.sensor_scanning, 1)
Example #40
0
def test_getmessage_decode_no_data_rsp():
    m = pyipmi.msgs.device_messaging.GetMessageRsp()
    decode_message(m, b'\x00\x21')
    eq_(m.completion_code, 0x00)
    eq_(m.channel.number, 1)
    eq_(m.channel.privilege_level, 2)
Example #41
0
def test_reservesdrrepository_decode_rsp():
    m = pyipmi.msgs.sdr.ReserveSdrRepositoryRsp()
    decode_message(m, b'\x00\x11\x22')
    eq_(m.completion_code, 0x00)
    eq_(m.reservation_id, 0x2211)
Example #42
0
def test_enablemessagechannelreceive_decode_channel1_enabled_rsp():
    m = pyipmi.msgs.device_messaging.EnableMessageChannelReceiveRsp()
    decode_message(m, b'\x00\x01\x01')
    eq_(m.completion_code, 0x00)
    eq_(m.channel.number, 1)
    eq_(m.channel.state, 1)
Example #43
0
def test_LanInfo():
    test_fields_1 = {
            "set_in_progress": None,
            "ipv4_address": None,
            "ipv4_address_source": None,
            "ipv4_subnet_mask": None,
            "ipv4_default_gateway_address": None,
            "ipv6_ipv4_addressing_enables": None,
            "ipv6_static_selector": None,
            "ipv6_static_address_source": None,
            "ipv6_static_address": None,
            "ipv6_static_prefix_length": None,
            "ipv6_static_address_status": None,
            "ipv6_dynamic_selector": None,
            "ipv6_dynamic_address_source": None,
            "ipv6_dynamic_address": None,
            "ipv6_dynamic_prefix_length": None,
            "ipv6_dynamic_address_status": None,
            "ipv6_cur_selector": None,
            "ipv6_cur_address_source": None,
            "ipv6_cur_address": None,
            "ipv6_cur_prefix_length": None,
            "ipv6_cur_address_status": None,
    }
    lan_info = pyipmi.lan.LanInfo()
    for k, v in test_fields_1.items():
        actual_v = getattr(lan_info, k)
        eq_(v, actual_v)

    req = pyipmi.msgs.lan.GetLanConfigurationParametersReq()
    req.command.channel_number = 1
    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_SET_IN_PROGRESS
    req.set_selector = 0
    req.block_selector = 0
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x01')
    lan_info.refresh_info(rsp)
    eq_(lan_info.set_in_progress, "set_in_progress")
    decode_message(rsp, b'\x00\x11\x02')
    lan_info.refresh_info(rsp)
    eq_(lan_info.set_in_progress, "commit_write")

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\xc0\xa8\x01\x69')
    lan_info.refresh_info(rsp)
    eq_(lan_info.ipv4_address, ipaddress.IPv4Address(3232235881))

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IP_ADDRESS_SOURCE
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x01')
    lan_info.refresh_info(rsp)
    eq_(lan_info.ipv4_address_source, "static_addr_by_manual")

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_SUBNET_MASK
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\xff\xff\xff\x00')
    lan_info.refresh_info(rsp)
    eq_(lan_info.ipv4_subnet_mask, ipaddress.IPv4Address(4294967040))

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_DEFAULT_GATEWAY_ADDRESS
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\xc0\xa8\x01\x01')
    lan_info.refresh_info(rsp)
    eq_(lan_info.ipv4_default_gateway_address, ipaddress.IPv4Address(3232235777))

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IPV6_IPV4_ADDRESSING_ENABLES
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x02')
    lan_info.refresh_info(rsp)
    eq_(lan_info.ipv6_ipv4_addressing_enables, "ipv6_ipv4_addr_enabled")

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IPV6_STATIC_ADDRESSES
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x00\x80\x20\x01\x00\x01\x00\x01\xab\xcd\x00\x00\x00\x00\x00\x22\x00\x01\x40\x00')
    lan_info.refresh_info(rsp)
    eq_(lan_info.ipv6_static_selector, 0)
    eq_(lan_info.ipv6_static_address_source, "ipv6_static_addr")
    eq_(lan_info.ipv6_static_address, ipaddress.IPv6Address(42540488241206025506885414467810754561))
    eq_(lan_info.ipv6_static_prefix_length, 64)
    eq_(lan_info.ipv6_static_address_status , "active")

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IPV6_DYNAMIC_ADDRESS
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x00\x01\xfd\x00\x00\x00\x00\x00\x00\x00\x02\xe0\xe8\xff\xfe\x90\x31\x09\x40\x00')
    lan_info.refresh_info(rsp)
    eq_(lan_info.ipv6_dynamic_selector, 0)
    eq_(lan_info.ipv6_dynamic_address_source, "SLAAC")
    eq_(lan_info.ipv6_dynamic_address, ipaddress.IPv6Address(336294682933583715844870608019971387657))
    eq_(lan_info.ipv6_dynamic_prefix_length, 64)
    eq_(lan_info.ipv6_dynamic_address_status , "active")

    # test combine
    lan_info._refresh_ipv6_info()
    eq_(lan_info.ipv6_cur_selector, 0)
    eq_(lan_info.ipv6_cur_address_source, "ipv6_static_addr")
    eq_(lan_info.ipv6_cur_address, ipaddress.IPv6Address(42540488241206025506885414467810754561))
    eq_(lan_info.ipv6_cur_prefix_length, 64)
    eq_(lan_info.ipv6_cur_address_status , "active")

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IPV6_STATIC_ADDRESSES
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x00\x00\x20\x01\x00\x01\x00\x01\xab\xcd\x00\x00\x00\x00\x00\x22\x00\x01\x40\x00')
    lan_info.refresh_info(rsp)
    lan_info._refresh_ipv6_info()
    eq_(lan_info.ipv6_cur_selector, 0)
    eq_(lan_info.ipv6_cur_address_source, "SLAAC")
    eq_(lan_info.ipv6_cur_address, ipaddress.IPv6Address(336294682933583715844870608019971387657))
    eq_(lan_info.ipv6_cur_prefix_length, 64)
    eq_(lan_info.ipv6_cur_address_status , "active")
Example #44
0
 def test_decode_rsp(self):
     m = pyipmi.msgs.sensor.GetSensorHysteresisRsp()
     decode_message(m, '\x00\xaa\xbb')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.positive_going_hysteresis, 0xaa)
     self.assertEqual(m.negative_going_hysteresis, 0xbb)
Example #45
0
 def test_decode_rsp(self):
     m = pyipmi.msgs.sensor.GetDeviceSdrRsp()
     decode_message(m, '\x00\x01\x23\xaa\xbb')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.next_record_id, 0x2301)
     self.assertEqual(m.record_data, array('B', [0xaa, 0xbb]))
Example #46
0
 def test_decode_byte3_rsp(self):
     m = pyipmi.msgs.sensor.GetSensorEventEnableRsp()
     decode_message(m, '\x00\xc0\xaa')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.enabled.event_message, 1)
     self.assertEqual(m.byte3, 0xaa)
Example #47
0
def test_getsdr_decode_rsp():
    m = pyipmi.msgs.sdr.GetSdrRsp()
    decode_message(m, b'\x00\x11\x22\x33\x44\x55\x66')
    eq_(m.completion_code, 0x00)
    eq_(m.next_record_id, 0x2211)
    eq_(m.record_data, array('B', [0x33, 0x44, 0x55, 0x66]))
Example #48
0
 def test_decode_valid_rsp(self):
     m = pyipmi.msgs.fru.ReadFruDataRsp()
     decode_message(m, '\x00\x05\x01\x02\x03\x04\x05')
     self.assertEqual(m.completion_code, 0)
     self.assertEqual(m.count, 5)
     self.assertEqual(m.data, array('B', '\x01\x02\x03\x04\x05'))
Example #49
0
def test_activatefirmwarereq_decode_valid_req_wo_optional():
    m = pyipmi.msgs.hpm.ActivateFirmwareReq()
    decode_message(m, b'\x00')
    eq_(m.picmg_identifier, 0)
    eq_(m.rollback_override_policy, None)
Example #50
0
def test_masterwriteread_decode_rsp():
    m = pyipmi.msgs.device_messaging.MasterWriteReadRsp()
    decode_message(m, b'\x00\x11\x22\x33\x44')
    eq_(m.completion_code, 0x00)
    eq_(m.data, array('B', [0x11, 0x22, 0x33, 0x44]))
Example #51
0
def test_getchassisstatus_decode_valid_optional_byte_rsp():
    m = pyipmi.msgs.chassis.GetChassisStatusRsp()
    decode_message(m, '\x00\x00\x00\00\xaa')
    eq_(m.completion_code, 0x00)
    eq_(m.front_panel_button_capabilities, 0xaa)
Example #52
0
def test_getsensoreventenable_decode_scanning_enabled_rsp():
    m = pyipmi.msgs.sensor.GetSensorEventEnableRsp()
    decode_message(m, '\x00\x40')
    eq_(m.completion_code, 0x00)
    eq_(m.enabled.event_message, 0)
    eq_(m.enabled.sensor_scanning, 1)
Example #53
0
def test_getselentry_decode_rsp_with_cc():
    m = pyipmi.msgs.sel.GetSelEntryRsp()
    decode_message(m, '\xc0')
    eq_(m.completion_code, 0xc0)
Example #54
0
def test_getsensoreventenable_decode_byte3_rsp():
    m = pyipmi.msgs.sensor.GetSensorEventEnableRsp()
    decode_message(m, '\x00\xc0\xaa')
    eq_(m.completion_code, 0x00)
    eq_(m.enabled.event_message, 1)
    eq_(m.byte3, 0xaa)
Example #55
0
def test_getselentry_decode_valid_rsp():
    m = pyipmi.msgs.sel.GetSelEntryRsp()
    decode_message(m, '\x00\x02\x01\x01\x02\x03\x04')
    eq_(m.completion_code, 0x00)
    eq_(m.next_record_id, 0x0102)
    eq_(m.record_data, array('B', [1, 2, 3, 4]))
Example #56
0
def test_rearmsensorevents_decode_rsp():
    m = pyipmi.msgs.sensor.RearmSensorEventsRsp()
    decode_message(m, '\x00')
    eq_(m.completion_code, 0x00)
Example #57
0
 def test_decode_channel1_enabled_rsp(self):
     m = pyipmi.msgs.bmc.EnableMessageChannelReceiveRsp()
     decode_message(m, '\x00\x01\x01')
     self.assertEqual(m.completion_code, 0x00)
     self.assertEqual(m.channel.number, 1)
     self.assertEqual(m.channel.state, 1)
Example #58
0
def test_getdevicesdr_decode_rsp():
    m = pyipmi.msgs.sensor.GetDeviceSdrRsp()
    decode_message(m, '\x00\x01\x23\xaa\xbb')
    eq_(m.completion_code, 0x00)
    eq_(m.next_record_id, 0x2301)
    eq_(m.record_data, array('B', [0xaa, 0xbb]))
Example #59
0
 def test_decode_rsp(self):
     m = pyipmi.msgs.sensor.RearmSensorEventsRsp()
     decode_message(m, '\x00')
     self.assertEqual(m.completion_code, 0x00)
Example #60
0
def test_Lan_set_lan_info_ipv6_valid():
    lan_obj = pyipmi.lan.Lan()

    # create fake response
    req = pyipmi.msgs.lan.GetLanConfigurationParametersReq()
    req.command.channel_number = 1
    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_SET_IN_PROGRESS
    req.set_selector = 0
    req.block_selector = 0
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    rsp.completion_code = 0

    mock_send_recv = MagicMock()
    mock_send_recv.return_value = [rsp]
    lan_obj._lan_send_and_recv = mock_send_recv

    # create fake lan_info
    # IPv6/IPv4 all enable
    # IPv6 source : DHCPv6
    # IPv6 static addr: 0x00 .. 
    # IPv6 dynamic addr: fd00::2e0:e8ff:fe90:3109
    # IPv6 prefix: 64
    # IPv6 selector: 0
    rsp_org_list = []
    test_lan_info = pyipmi.lan.LanInfo()
    req = pyipmi.msgs.lan.GetLanConfigurationParametersReq()
    req.command.channel_number = 1

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IPV6_IPV4_ADDRESSING_ENABLES
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x02')
    rsp_org_list.append(rsp)

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IPV6_STATIC_ADDRESSES
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x01\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
    rsp_org_list.append(rsp)

    req.parameter_selector = pyipmi.msgs.lan.LAN_PARAMETER_IPV6_DYNAMIC_ADDRESS
    rsp = pyipmi.msgs.lan.GetLanConfigurationParametersRsp(req_obj=req)
    decode_message(rsp, b'\x00\x11\x00\x01\xfd\x00\x00\x00\x00\x00\x00\x00\x02\xe0\xe8\xff\xfe\x90\x31\x09\x40\x00')
    rsp_org_list.append(rsp)

    for rsp in rsp_org_list:
        req_obj = rsp.req_obj
        test_lan_info.refresh_info(rsp)

    mock_get_lan_info = MagicMock()
    mock_get_lan_info.return_value = test_lan_info
    lan_obj.get_lan_info = mock_get_lan_info


    # test case 1: disable ipv6
    lan_obj.set_lan_info(channel=1, ipv6_enable=False)
    args = mock_send_recv.call_args.args
    reqs = args[0]
    param_req_map = { req.parameter_selector: req  for req in reqs }
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_IPV6_IPV4_ADDRESSING_ENABLES in param_req_map.keys())
    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_IPV6_IPV4_ADDRESSING_ENABLES]
    eq_(test_req.ipv6_ipv4_addressing_enables, pyipmi.lan.LanInfo.FIELD_IPV6_IPV4_ADDRESSING_ENABLES_INV["ipv6_addr_disabled"])

    # test case 2: enable ipv6, addr_src is dhcpv6
    lan_obj.set_lan_info(channel=1, ipv6_enable=True, v6_addr_src='ipv6_dynamic')
    args = mock_send_recv.call_args.args
    reqs = args[0]
    param_req_map = { req.parameter_selector: req  for req in reqs }
    eq_(len(reqs), 1)
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_IPV6_STATIC_ADDRESSES in param_req_map.keys())
    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_IPV6_STATIC_ADDRESSES]
    eq_(test_req.ipv6_static_address_source.src, 0)
    eq_(test_req.ipv6_static_address_source.enable, 0)
    eq_(test_req.ipv6_static_address, 0)
    eq_(test_req.ipv6_static_prefix_length, 0)
    eq_(test_req.ipv6_static_address_status, 0)

    # test case 3: enable ipv6, settings ip_addr: fd00::2e0:e8ff:fe90:3109, but others remain the same.
    lan_obj.set_lan_info(
            channel=1, 
            ipv6_enable=True, 
            v6_addr_src="ipv6_static_addr", 
            v6_addr=ipaddress.IPv6Address("fd00::2e0:e8ff:fe90:3109"),
            v6_prefix_length=64
    )
    args = mock_send_recv.call_args.args
    reqs = args[0]
    param_req_map = { req.parameter_selector: req  for req in reqs }
    eq_(len(reqs), 1)
    ok_(pyipmi.msgs.lan.LAN_PARAMETER_IPV6_STATIC_ADDRESSES in param_req_map.keys())
    test_req = param_req_map[pyipmi.msgs.lan.LAN_PARAMETER_IPV6_STATIC_ADDRESSES]
    eq_(test_req.ipv6_static_address_source.src, pyipmi.lan.LanInfo.FIELD_IPV6_ADDRESS_SOURCE_INV["ipv6_static_addr"])
    eq_(test_req.ipv6_static_address_source.enable, 1)
    eq_(test_req.ipv6_static_address, int(ipaddress.IPv6Address("fd00::2e0:e8ff:fe90:3109")))
    eq_(test_req.ipv6_static_prefix_length, 64)