def set_sensor_thresholds(self, sensor_number, lun=0, unr=None, ucr=None,
                unc=None, lnc=None, lcr=None, lnr=None):
        """Set the sensor thresholds that are not 'None'

        `sensor_number`
        `unr` for upper non-recoverable
        `ucr` for upper critical
        `unc` for upper non-critical
        `lnc` for lower non-critical
        `lcr` for lower critical
        `lnr` for lower non-recoverable
        """
        req = create_request_by_name('SetSensorThresholds')
        req.sensor_number = sensor_number
        req.lun = lun
        if unr is not None:
            req.set_mask.unr = 1
            req.threshold.unr = unr
        if ucr is not None:
            req.set_mask.ucr = 1
            req.threshold.ucr = ucr
        if unc is not None:
            req.set_mask.unc = 1
            req.threshold.unc = unc
        if lnc is not None:
            req.set_mask.lnc = 1
            req.threshold.lnc = lnc
        if lcr is not None:
            req.set_mask.lcr = 1
            req.threshold.lcr = lcr
        if lnr is not None:
            req.set_mask.lnr = 1
            req.threshold.lnr = lnr
        rsp = self.send_message(req)
        check_completion_code(rsp.completion_code)

 def get_led_state(self, fru_id, led_id):
     req = create_request_by_name('GetFruLedState')
     req.fru_id = fru_id
     req.led_id = led_id
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     return LedState(rsp)

    def _get_sdr_chunk(self, reservation_id, record_id, offset, length):
        print length
        req = create_request_by_name('GetSdr')
        req.reservation_id = reservation_id
        req.record_id = record_id
        req.offset = offset
        req.bytes_to_read = length
        retry = 5

        while True:
            retry -= 1
            if retry == 0:
                raise RetryError()
            rsp = self.send_message(req)
            if rsp.completion_code == constants.CC_OK:
                break
            elif rsp.completion_code == constants.CC_RES_CANCELED:
                req.reservation_id = self.reserve_sdr_repository()
                time.sleep(0.1)
                continue
            elif rsp.completion_code == constants.CC_TIMEOUT:
                time.sleep(0.1)
                continue
            elif rsp.completion_code == constants.CC_RESP_COULD_NOT_BE_PRV:
                time.sleep(0.1 * retry)
                continue
            else:
                check_completion_code(rsp.completion_code)

        return (rsp.next_record_id, rsp.data)

 def get_event_receiver(self):
     req = create_request_by_name('GetEventReceiver')
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     ipmb_address = rsp.event_receiver.ipmb_i2c_slave_address
     lun = rsp.event_receiver.lun
     return (ipmb_address, lun)

 def rearm_sensor_events(self, sensor_number):
     """Rearm sensor events for the given sensor number.
     """
     req = create_request_by_name('RearmSensorEvents')
     req.sensor_number = sensor_number
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)

 def _clear_sdr_repository(self, cmd, reservation_id):
     req = create_request_by_name('ClearSdrRepository')
     req.reservation_id = reservation_id
     req.cmd = cmd
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     return rsp.status.erase_in_progress

 def get_power_channel_status(self, starting_number):
     req = create_request_by_name('GetPowerChannelStatus')
     req.starting_power_channel_number = starting_number
     req.power_channel_count = 1
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     return PowerChannelStatus(rsp.data[0])

 def clear_fru_deactivation_lock(self, fru_id):
     req = create_request_by_name('SetFruActivationPolicy')
     req.fru_id = fru_id
     req.mask.deactivation_locked = 1
     req.set.deactivation_locked = 0
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)

 def set_lan_configuration_parameters(self, channel, parameter_selector, data):
     req = create_request_by_name('SetLanConfigurationParameters')
     req.command.channel_number = channel
     req.parameter_selector = parameter_selector
     req.data = data
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)

 def get_signaling_class(self, interface, channel):
     req = create_request_by_name('GetSignalingClass')
     req.channel_info.channel_number = channel
     req.channel_info.interface = interface
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     return rsp.channel_signaling.class_capability

    def set_sensor_thresholds(self, sensor_number, lun=0, unr=None, ucr=None,
                unc=None, lnc=None, lcr=None, lnr=None):
        """Set the sensor thresholds that are not 'None'

        `sensor_number`
        `unr` for upper non-recoverable
        `ucr` for upper critical
        `unc` for upper non-critical
        `lnc` for lower non-critical
        `lcr` for lower critical
        `lnr` for lower non-recoverable
        """
        req = create_request_by_name('SetSensorThresholds')
        req.sensor_number = sensor_number
        req.lun = lun

        thresholds = dict(unr=unr, ucr=ucr, unc=unc, lnc=lnc, lcr=lcr, lnr=lnr)

        for k, v in thresholds.items():
            if v is not None:
                setattr(req.set_mask, k, 1)
                setattr(req.threshold, k, v)

        rsp = self.send_message(req)
        check_completion_code(rsp.completion_code)

 def fru_control(self, fru_id, option):
     req = create_request_by_name('FruControl')
     req.fru_id = fru_id
     req.option = option
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     return rsp.rsp_data

 def get_component_property(self, component_id, property_id):
     req = create_request_by_name('GetComponentProperties')
     req.id = component_id
     req.selector = property_id
     rsp = self.send_message(req)
     self._check_completion_code(rsp)
     return ComponentProperty.create_from_id(property_id, rsp)

 def get_power_level(self, fru_id, power_type):
     req = create_request_by_name('GetPowerLevel')
     req.fru_id = fru_id
     req.power_type = power_type
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     return PowerLevel(rsp)

 def get_fan_level(self, fru_id):
     req = create_request_by_name('GetFanLevel')
     req.fru_id = fru_id
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     local_control_fan_level = None
     if rsp.data:
         local_control_fan_level = rsp.data[0]
     return (rsp.override_fan_level, local_control_fan_level)

    def sel_entries(self):
        """Generator which returns all SEL entries."""
        req = create_request_by_name('GetSelInfo')
        rsp = self.send_message(req)
        check_completion_code(rsp.completion_code)
        if rsp.entries == 0:
            return
        reservation_id = self.get_sel_reservation_id()
        next_record_id = 0
        while True:
            req = create_request_by_name('GetSelEntry')
            req.reservation_id = reservation_id
            req.record_id = next_record_id
            req.offset = 0
            self.max_req_len = 0xff # read entire record

            record_data = ByteBuffer()
            while True:
                req.length = self.max_req_len
                if (self.max_req_len != 0xff
                        and (req.offset + req.length) > 16):
                    req.length = 16 - req.offset

                rsp = self.send_message(req)
                if rsp.completion_code == constants.CC_CANT_RET_NUM_REQ_BYTES:
                    if self.max_req_len  == 0xff:
                        self.max_req_len = 16
                    else:
                        self.max_req_len -= 1
                    continue
                else:
                    check_completion_code(rsp.completion_code)

                record_data.append_array(rsp.record_data)
                req.offset = len(record_data)

                if len(record_data) >= 16:
                    break

            next_record_id = rsp.next_record_id

            yield SelEntry(record_data)
            if next_record_id == 0xffff:
                break

    def write_fru_data(self, data, offset=0, fru_id=0):
        req = create_request_by_name('WriteFruData')
        req.fru_id = fru_id

        for chunk in chunks(data, self.write_length):
            req.offset = offset
            req.data = chunk
            rsp = self.send_message(req)
            check_completion_code(rsp.completion_code)
            offset += len(chunk)

    def _get_device_sdr_chunk(self, reservation_id, record_id, offset, length):
        req = create_request_by_name('GetDeviceSdr')
        req.reservation_id = reservation_id
        req.record_id = record_id
        req.offset = offset
        req.bytes_to_read = length

        rsp = get_sdr_chunk_helper(self.send_message, req, \
                self.reserve_device_sdr_repository)

        return (rsp.next_record_id, rsp.record_data)

    def delete_sdr(self, record_id):
        """Deletes the sensor record specified by 'record_id'.
        """

        reservation_id = self.reserve_device_sdr_repository()
        req = create_request_by_name('DeleteSdr')
        req.reservation_id = reservation_id
        req.record_id = record_id
        rsp = self.send_message(req)
        check_completion_code(rsp.completion_code)
        return rsp.record_id

 def i2c_write_read(self, type, id, channel, address, count, data=None):
     req = create_request_by_name('MasterWriteRead')
     req.bus_id.type = type
     req.bus_id.id= id
     req.bus_id.channel = channel
     req.bus_id.slave_address = address
     req.read_count = count
     if data:
         req.data = data
     rsp = self.send_message(req)
     check_completion_code(rsp.completion_code)
     return rsp.data