def poll(self, space, w_timeout=None):
if space.is_w(w_timeout, space.w_None):
timeout = -1
else:
# rationale for computing directly integer, instead
# of float + math.cell is that
# we have for free overflow check and noone really
# cares (since CPython does not try too hard to have
# a ceiling of value)
try:
# compute the integer
timeout = space.int_w(w_timeout)
except (OverflowError, ValueError):
raise OperationError(space.w_ValueError,
space.wrap("math range error"))
try:
retval = rpoll.poll(self.fddict, timeout)
except rpoll.PollError, e:
w_module = space.getbuiltinmodule('select')
w_errortype = space.getattr(w_module, space.wrap('error'))
message = e.get_msg()
raise OperationError(w_errortype,
space.newtuple([space.wrap(e.errno),
space.wrap(message)]))
def poll(self, space, w_timeout=None):
if space.is_w(w_timeout, space.w_None):
timeout = -1
else:
# rationale for computing directly integer, instead
# of float + math.cell is that
# we have for free overflow check and noone really
# cares (since CPython does not try too hard to have
# a ceiling of value)
try:
# compute the integer
timeout = space.int_w(w_timeout)
except (OverflowError, ValueError):
raise OperationError(space.w_ValueError,
space.wrap("math range error"))
try:
retval = rpoll.poll(self.fddict, timeout)
except rpoll.PollError, e:
w_module = space.getbuiltinmodule('select')
w_errortype = space.getattr(w_module, space.wrap('error'))
message = e.get_msg()
raise OperationError(
w_errortype,
space.newtuple([space.wrap(e.errno),
space.wrap(message)]))
def poll(self, space, w_timeout=None):
if space.is_w(w_timeout, space.w_None):
timeout = -1
else:
timeout = space.int_w(w_timeout)
try:
retval = rpoll.poll(self.fddict, timeout)
except rpoll.PollError, e:
w_module = space.getbuiltinmodule('select')
w_errortype = space.getattr(w_module, space.wrap('error'))
message = e.get_msg()
raise OperationError(w_errortype,
space.newtuple([space.wrap(e.errno),
space.wrap(message)]))
def poll(self, space, w_timeout=None):
if space.is_w(w_timeout, space.w_None):
timeout = -1
else:
timeout = space.int_w(w_timeout)
try:
retval = rpoll.poll(self.fddict, timeout)
except rpoll.PollError, e:
w_module = space.getbuiltinmodule('select')
w_errortype = space.getattr(w_module, space.wrap('error'))
message = e.get_msg()
raise OperationError(
w_errortype,
space.newtuple([space.wrap(e.errno),
space.wrap(message)]))
def check_socket_and_wait_for_timeout(space, w_sock, writing):
"""If the socket has a timeout, do a select()/poll() on the socket.
The argument writing indicates the direction.
Returns one of the possibilities in the timeout_state enum (above)."""
w_timeout = space.call_method(w_sock, "gettimeout")
if space.is_w(w_timeout, space.w_None):
return SOCKET_IS_BLOCKING
elif space.float_w(w_timeout) == 0.0:
return SOCKET_IS_NONBLOCKING
sock_timeout = space.float_w(w_timeout)
# guard against closed socket
try:
space.call_method(w_sock, "fileno")
except:
return SOCKET_HAS_BEEN_CLOSED
sock_fd = space.int_w(space.call_method(w_sock, "fileno"))
# see if the socket is ready
# Prefer poll, if available, since you can poll() any fd
# which can't be done with select().
if HAVE_RPOLL:
if writing:
fddict = {sock_fd: rpoll.POLLOUT}
else:
fddict = {sock_fd: rpoll.POLLIN}
# socket's timeout is in seconds, poll's timeout in ms
timeout = int(sock_timeout * 1000 + 0.5)
ready = rpoll.poll(fddict, timeout)
else:
if MAX_FD_SIZE is not None and sock_fd >= MAX_FD_SIZE:
return SOCKET_TOO_LARGE_FOR_SELECT
if writing:
r, w, e = rpoll.select([], [sock_fd], [], sock_timeout)
ready = w
else:
r, w, e = rpoll.select([sock_fd], [], [], sock_timeout)
ready = r
if ready:
return SOCKET_OPERATION_OK
else:
return SOCKET_HAS_TIMED_OUT
def check_socket_and_wait_for_timeout(space, w_sock, writing):
"""If the socket has a timeout, do a select()/poll() on the socket.
The argument writing indicates the direction.
Returns one of the possibilities in the timeout_state enum (above)."""
w_timeout = space.call_method(w_sock, "gettimeout")
if space.is_w(w_timeout, space.w_None):
return SOCKET_IS_BLOCKING
elif space.float_w(w_timeout) == 0.0:
return SOCKET_IS_NONBLOCKING
sock_timeout = space.float_w(w_timeout)
# guard against closed socket
try:
space.call_method(w_sock, "fileno")
except:
return SOCKET_HAS_BEEN_CLOSED
sock_fd = space.int_w(space.call_method(w_sock, "fileno"))
# see if the socket is ready
# Prefer poll, if available, since you can poll() any fd
# which can't be done with select().
if HAVE_RPOLL:
if writing:
fddict = {sock_fd: rpoll.POLLOUT}
else:
fddict = {sock_fd: rpoll.POLLIN}
# socket's timeout is in seconds, poll's timeout in ms
timeout = int(sock_timeout * 1000 + 0.5)
ready = rpoll.poll(fddict, timeout)
else:
if MAX_FD_SIZE is not None and sock_fd >= MAX_FD_SIZE:
return SOCKET_TOO_LARGE_FOR_SELECT
if writing:
r, w, e = rpoll.select([], [sock_fd], [], sock_timeout)
ready = w
else:
r, w, e = rpoll.select([sock_fd], [], [], sock_timeout)
ready = r
if ready:
return SOCKET_OPERATION_OK
else:
return SOCKET_HAS_TIMED_OUT
def poll(self, space, w_timeout=None):
if space.is_w(w_timeout, space.w_None):
timeout = -1
else:
# we want to be compatible with cpython and also accept things
# that can be casted to integer (I think)
try:
# compute the integer
timeout = space.int_w(space.int(w_timeout))
except (OverflowError, ValueError):
raise OperationError(space.w_ValueError,
space.wrap("math range error"))
try:
retval = rpoll.poll(self.fddict, timeout)
except rpoll.PollError, e:
w_errortype = space.fromcache(Cache).w_error
message = e.get_msg()
raise OperationError(w_errortype,
space.newtuple([space.wrap(e.errno),
space.wrap(message)]))
def poll(self, space, w_timeout=None):
if space.is_w(w_timeout, space.w_None):
timeout = -1
else:
# we want to be compatible with cpython and also accept things
# that can be casted to integer (I think)
try:
# compute the integer
timeout = space.int_w(space.int(w_timeout))
except (OverflowError, ValueError):
raise OperationError(space.w_ValueError,
space.wrap("math range error"))
try:
retval = rpoll.poll(self.fddict, timeout)
except rpoll.PollError, e:
w_errortype = space.fromcache(Cache).w_error
message = e.get_msg()
raise OperationError(w_errortype,
space.newtuple([space.wrap(e.errno),
space.wrap(message)]))
