def recv(self, x=512, timeout_secs=10.0):
# FIXME: Don't know how many bytes to expect here,
# using 512 bytes -- will this fly if there's another event right
# after it? Or is each event guaranteed to be put in a USB packet of
# its own?
try:
data_array = self.pyusb_dev.read(
USB_ENDPOINT_HCI_EVT, 512, int(timeout_secs * 1000.0))
except usb.core.USBError as e:
if e.errno == errno.ETIMEDOUT:
return None
else:
raise e
data = ''.join([chr(c) for c in data_array]) # Ugh.. array return val
data = "\4" + data # Prepend H4 'Event' packet indicator
scapy_packet = HCI_Hdr(data)
LOG.debug("recv %s" % scapy_packet.lastlayer().summary())
LOG.debug("recv bytes: " + binascii.hexlify(data))
return scapy_packet
python类ETIMEDOUT的实例源码
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def test_send_cmd_recv_rsp_transport_error(self, device, err, exc):
device.chipset.transport.read.side_effect = [
ACK(), self.reg_rsp('00 00 00'), # ReadRegister
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('33'), # RFConfiguration
ACK(), IOError(err, "test"), # InCommunicateThru
]
target = nfc.clf.RemoteTarget('106A')
with pytest.raises(exc):
device.send_cmd_recv_rsp(target, b'123', 1.0)
assert device.chipset.transport.write.mock_calls == [call(_) for _ in [
CMD('06 6302 6303 6305'), # ReadRegister
CMD('08 630200 630300 630540'), # WriteRegister
CMD('32 020a0b0f'), # RFConfiguration
CMD('42 313233'), # InCommunicateThru
] + ([ACK()] if err == errno.ETIMEDOUT else [])]
def test_listen_tta_as_tt4_rcvd_deselect(self, device):
device.chipset.transport.read.side_effect = [
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('8D 00 E0 80'), # TgInitAsTarget
ACK(), RSP('91 00'), # TgResponseToInitiator
ACK(), RSP('89 00 C03233'), # TgGetInitiatorCommand
ACK(), RSP('91 00'), # TgResponseToInitiator
ACK(), IOError(errno.ETIMEDOUT, ""), # TgInitAsTarget
]
target = nfc.clf.LocalTarget('106A')
target.sens_res = HEX("4400")
target.sel_res = HEX("20")
target.sdd_res = HEX("08010203")
assert device.listen_tta(target, 1.0) is None
assert device.chipset.transport.read.call_count == 12
device.chipset.transport.write.assert_any_call(CMD('90 0578807002'))
def test_listen_dep_ioerror_timeout_after_psl(self, device):
atr_req = 'D400 30313233343536373839 00000000'
atr_res = 'D501 d0d1d2d3d4d5d6d7d8d9 0000000800'
psl_req = 'D404 00 12 03'
device.chipset.transport.read.side_effect = [
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('8D 05 11' + atr_req), # TgInitAsTarget
ACK(), RSP('91 00'), # TgResponseToInitiator
ACK(), RSP('89 00 06' + psl_req), # TgGetInitiatorCommand
ACK(), self.reg_rsp('FD'), # ReadRegister
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('91 00'), # TgResponseToInitiator
ACK(), self.reg_rsp('FD'), # ReadRegister
ACK(), RSP('09 00'), # WriteRegister
ACK(), IOError(errno.ETIMEDOUT, ""), # TgGetInitiatorCommand
]
target = nfc.clf.LocalTarget()
target.sensf_res = HEX("01 01fe010203040506 0000000000000000 0000")
target.sens_res = HEX("0101")
target.sel_res = HEX("40")
target.sdd_res = HEX("08010203")
target.atr_res = HEX(atr_res)
assert device.listen_dep(target, 1.0) is None
assert device.chipset.transport.read.call_count == 20
def test_listen_dep_ioerror_timeout_after_atr(self, device):
atr_req = 'D400 30313233343536373839 00000000'
atr_res = 'D501 d0d1d2d3d4d5d6d7d8d9 0000000800'
device.chipset.transport.read.side_effect = [
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('8D 05 11' + atr_req), # TgInitAsTarget
ACK(), RSP('91 00'), # TgResponseToInitiator
ACK(), IOError(errno.ETIMEDOUT, ""), # TgGetInitiatorCommand
]
target = nfc.clf.LocalTarget()
target.sensf_res = HEX("01 01fe010203040506 0000000000000000 0000")
target.sens_res = HEX("0101")
target.sel_res = HEX("40")
target.sdd_res = HEX("08010203")
target.atr_res = HEX(atr_res)
assert device.listen_dep(target, 1.0) is None
assert device.chipset.transport.read.call_count == 8
def test_listen_dep_not_atr_and_then_ioerror(self, device):
atr_req = 'D4FF 30313233343536373839 00000000'
atr_res = 'D501 d0d1d2d3d4d5d6d7d8d9 0000000800'
device.chipset.transport.read.side_effect = [
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('8D 05 11' + atr_req), # TgInitAsTarget
ACK(), IOError(errno.ETIMEDOUT, ""), # TgInitAsTarget
ACK(), IOError(errno.EIO, ""), # TgInitAsTarget
]
target = nfc.clf.LocalTarget()
target.sensf_res = HEX("01 01fe010203040506 0000000000000000 0000")
target.sens_res = HEX("0101")
target.sel_res = HEX("40")
target.sdd_res = HEX("08010203")
target.atr_res = HEX(atr_res)
with pytest.raises(IOError):
device.listen_dep(target, 1.0)
assert device.chipset.transport.read.call_count == 8
def test_listen_dep_ioerror_timeout_after_atr(self, device):
atr_req = 'D400 30313233343536373839 00000000'
atr_res = 'D501 d0d1d2d3d4d5d6d7d8d9 0000000800'
device.chipset.transport.read.side_effect = [
ACK(), RSP('19'), # ResetMode
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('33'), # RFConfiguration
ACK(), RSP('13'), # SetParameters
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('8D 05 11' + atr_req), # TgInitAsTarget
ACK(), RSP('93 00'), # TgSetGeneralBytes
ACK(), IOError(errno.ETIMEDOUT, ""), # TgGetInitiatorCommand
]
target = nfc.clf.LocalTarget()
target.sensf_res = HEX("01 01fe010203040506 0000000000000000 0000")
target.sens_res = HEX("0101")
target.sel_res = HEX("40")
target.sdd_res = HEX("08010203")
target.atr_res = HEX(atr_res)
assert device.listen_dep(target, 1.0) is None
assert device.chipset.transport.read.call_count == 16
def test_listen_dep_not_atr_and_then_ioerror(self, device):
atr_req = 'D4FF 30313233343536373839 00000000'
atr_res = 'D501 d0d1d2d3d4d5d6d7d8d9 0000000800'
device.chipset.transport.read.side_effect = [
ACK(), RSP('19'), # ResetMode
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('33'), # RFConfiguration
ACK(), RSP('13'), # SetParameters
ACK(), RSP('09 00'), # WriteRegister
ACK(), RSP('8D 05 11' + atr_req), # TgInitAsTarget
ACK(), IOError(errno.ETIMEDOUT, ""), # TgInitAsTarget
ACK(), IOError(errno.EIO, ""), # TgInitAsTarget
]
target = nfc.clf.LocalTarget()
target.sensf_res = HEX("01 01fe010203040506 0000000000000000 0000")
target.sens_res = HEX("0101")
target.sel_res = HEX("40")
target.sdd_res = HEX("08010203")
target.atr_res = HEX(atr_res)
with pytest.raises(IOError):
device.listen_dep(target, 1.0)
assert device.chipset.transport.read.call_count == 16
def read(self, timeout):
if self.tty is not None:
self.tty.timeout = max(timeout/1E3, 0.05)
frame = bytearray(self.tty.read(6))
if frame is None or len(frame) == 0:
raise IOError(errno.ETIMEDOUT, os.strerror(errno.ETIMEDOUT))
if frame.startswith(b"\x00\x00\xff\x00\xff\x00"):
log.log(logging.DEBUG-1, "<<< %s", str(frame).encode("hex"))
return frame
LEN = frame[3]
if LEN == 0xFF:
frame += self.tty.read(3)
LEN = frame[5] << 8 | frame[6]
frame += self.tty.read(LEN + 1)
log.log(logging.DEBUG-1, "<<< %s", hexlify(frame))
return frame
def read(self, timeout=0):
if self.usb_inp is not None:
try:
ep_addr = self.usb_inp.getAddress()
frame = self.usb_dev.bulkRead(ep_addr, 300, timeout)
except libusb.USBErrorTimeout:
raise IOError(errno.ETIMEDOUT, os.strerror(errno.ETIMEDOUT))
except libusb.USBErrorNoDevice:
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
except libusb.USBError as error:
log.error("%r", error)
raise IOError(errno.EIO, os.strerror(errno.EIO))
if len(frame) == 0:
log.error("bulk read returned zero data")
raise IOError(errno.EIO, os.strerror(errno.EIO))
frame = bytearray(frame)
log.log(logging.DEBUG-1, "<<< %s", hexlify(frame))
return frame
def test_selector_raises_timeout_error_on_interrupt_over_time(self):
selectors2._DEFAULT_SELECTOR = None
mock_socket = mock.Mock()
mock_socket.fileno.return_value = 1
def slow_interrupting_select(*args, **kwargs):
time.sleep(0.2)
error = OSError()
error.errno = errno.EINTR
raise error
patch_select_module(self, select=slow_interrupting_select)
selector = self.make_selector()
selector.register(mock_socket, selectors2.EVENT_READ)
try:
selector.select(timeout=0.1)
except OSError as e:
self.assertEqual(e.errno, errno.ETIMEDOUT)
else:
self.fail('Didn\'t raise an OSError')
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def test_connect_ex_error(self):
with support.transient_internet(REMOTE_HOST):
s = ssl.wrap_socket(socket.socket(socket.AF_INET),
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=REMOTE_ROOT_CERT)
try:
rc = s.connect_ex((REMOTE_HOST, 444))
# Issue #19919: Windows machines or VMs hosted on Windows
# machines sometimes return EWOULDBLOCK.
errors = (
errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.ETIMEDOUT,
errno.EWOULDBLOCK,
)
self.assertIn(rc, errors)
finally:
s.close()
def test_connect_ex_error(self):
with support.transient_internet(REMOTE_HOST):
s = ssl.wrap_socket(socket.socket(socket.AF_INET),
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=REMOTE_ROOT_CERT)
try:
rc = s.connect_ex((REMOTE_HOST, 444))
# Issue #19919: Windows machines or VMs hosted on Windows
# machines sometimes return EWOULDBLOCK.
errors = (
errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.ETIMEDOUT,
errno.EWOULDBLOCK,
)
self.assertIn(rc, errors)
finally:
s.close()
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def poll(self, bufsize=1024):
""" Returns the next received packet as a tuple (command, payload)
If there are no packets pending, returns None
"""
# Attempt to load data from USB and push it into the incoming buffer
while not self.incoming:
try:
raw = self._read(bufsize)
except usb.core.USBError as e:
# The only acceptable USB errors are timeout errors
# (when the device hasn't sent us any new data)
if e.errno != errno.ETIMEDOUT:
raise e
break
else:
self._process_raw(raw)
# Return the oldest packet or None
return self.incoming.pop(0) if self.incoming else None
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def _on_remote_read(self):
# handle all remote read events
self._update_activity()
data = None
try:
data = self._remote_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if self._is_local:
data = self._encryptor.decrypt(data)
else:
data = self._encryptor.encrypt(data)
try:
self._write_to_sock(data, self._local_sock)
except Exception as e:
logging.error(e)
if self._config['verbose']:
traceback.print_exc()
# TODO use logging when debug completed
self.destroy()
def _handle_bt_error(self, bt_error):
assert isinstance(bt_error, IOError)
#'timed out' is caused by the wait_for_connection loop
if isinstance(bt_error, socket.timeout):
pass
#'resource unavailable' is when data cannot be read because there is nothing in the buffer
elif bt_error.errno == errno.EAGAIN:
pass
#'connection reset' is caused when the client disconnects
elif bt_error.errno == errno.ECONNRESET:
self._client_connected = False
if self.when_client_disconnects:
self.when_client_disconnects()
#'conection timeout' is caused when the server can no longer connect to read from the client
# (perhaps the client has gone out of range)
elif bt_error.errno == errno.ETIMEDOUT:
self._client_connected = False
if self.when_client_disconnects:
self.when_client_disconnects()
else:
raise bt_error
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def test_connect_ex_error(self):
with support.transient_internet(REMOTE_HOST):
s = ssl.wrap_socket(socket.socket(socket.AF_INET),
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=REMOTE_ROOT_CERT)
try:
rc = s.connect_ex((REMOTE_HOST, 444))
# Issue #19919: Windows machines or VMs hosted on Windows
# machines sometimes return EWOULDBLOCK.
errors = (
errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.ETIMEDOUT,
errno.EWOULDBLOCK,
)
self.assertIn(rc, errors)
finally:
s.close()
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def _get_ip(self):
if self._ex_ip:
return self._ex_ip
s = socket.socket()
if ':' in self.tracker:
domain, port_str = self.tracker.split(':')
tracker_tuple = (domain, int(port_str))
else:
tracker_tuple = (self.tracker, 80)
try:
s.connect(tracker_tuple)
except socket.error as e:
if e.errno == errno.ECONNREFUSED or e.errno == errno.ETIMEDOUT:
raise TrackerUnavailable
else:
raise
self._ex_ip = s.getsockname()[0]
return self._ex_ip
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
self._update_activity()
if not self._local_sock:
return
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
if not data:
return
self._server.server_transfer_ul += len(data)
#TODO ============================================================
if self._stage == STAGE_STREAM:
self._write_to_sock(data, self._remote_sock)
return
def _on_local_read(self):
# handle all local read events and dispatch them to methods for
# each stage
if not self._local_sock:
return
is_local = self._is_local
data = None
try:
data = self._local_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
self._update_activity(len(data))
if not is_local:
data = self._encryptor.decrypt(data)
if not data:
return
if self._stage == STAGE_STREAM:
if self._is_local:
data = self._encryptor.encrypt(data)
self._write_to_sock(data, self._remote_sock)
return
elif is_local and self._stage == STAGE_INIT:
# TODO check auth method
self._write_to_sock(b'\x05\00', self._local_sock)
self._stage = STAGE_ADDR
return
elif self._stage == STAGE_CONNECTING:
self._handle_stage_connecting(data)
elif (is_local and self._stage == STAGE_ADDR) or \
(not is_local and self._stage == STAGE_INIT):
self._handle_stage_addr(data)
def _on_remote_read(self):
# handle all remote read events
data = None
try:
data = self._remote_sock.recv(BUF_SIZE)
except (OSError, IOError) as e:
if eventloop.errno_from_exception(e) in \
(errno.ETIMEDOUT, errno.EAGAIN, errno.EWOULDBLOCK):
return
if not data:
self.destroy()
return
self._update_activity(len(data))
if self._is_local:
data = self._encryptor.decrypt(data)
else:
data = self._encryptor.encrypt(data)
try:
self._write_to_sock(data, self._local_sock)
except Exception as e:
shell.print_exception(e)
if self._config['verbose']:
traceback.print_exc()
# TODO use logging when debug completed
self.destroy()
def wait_for(test, timeout=1.0, raise_on_error=True, rate=100,
timeout_msg="timeout expired", body=None):
"""
Waits until some condition evaluates to true.
@param test: zero param function to be evaluated
@param timeout: max amount of time to wait. negative/inf for indefinitely
@param raise_on_error: raise or just return False
@param rate: the rate at which to check
@param timout_msg: message to supply to the timeout exception
@param body: optional function to execute while waiting
"""
end_time = rospy.get_time() + timeout
rate = rospy.Rate(rate)
notimeout = (timeout < 0.0) or timeout == float("inf")
while not test():
if rospy.is_shutdown():
if raise_on_error:
raise OSError(errno.ESHUTDOWN, "ROS Shutdown")
return False
elif (not notimeout) and (rospy.get_time() >= end_time):
if raise_on_error:
raise OSError(errno.ETIMEDOUT, timeout_msg)
return False
if callable(body):
body()
rate.sleep()
return True
