def recv(self, buflen):
if self.act_non_blocking:
return self.fd.recv(buflen)
buf = self.recvbuffer
if buf:
chunk, self.recvbuffer = buf[:buflen], buf[buflen:]
return chunk
fd = self.fd
bytes = recv_func(fd, buflen)
if self.gettimeout():
end = time.time()+self.gettimeout()
else:
end = None
timeout = None
while bytes is None:
try:
if end:
timeout = end - time.time()
trampoline(fd, read=True, timeout=timeout, timeout_exc=socket.timeout)
except socket.timeout:
raise
except socket.error, e:
if e[0] == errno.EPIPE:
bytes = ''
else:
raise
else:
bytes = recv_func(fd, buflen)
def fake_select(r, w, e, timeout):
"""This is to cooperate with people who are trying to do blocking
reads with a timeout. This only works if r, w, and e aren't
bigger than len 1, and if either r or w is populated.
Install this with wrap_select_with_coroutine_select,
which makes the global select.select into fake_select.
"""
from eventlet import api
assert len(r) <= 1
assert len(w) <= 1
assert len(e) <= 1
if w and r:
raise RuntimeError("fake_select doesn't know how to do that yet")
try:
if r:
api.trampoline(r[0], read=True, timeout=timeout)
return r, [], []
else:
api.trampoline(w[0], write=True, timeout=timeout)
return [], w, []
except api.TimeoutError, e:
return [], [], []
def iterator():
global c, starttime
if not starttime:
starttime = time.time()
tt0 = time.time()
deltas = 0.0
c += 1
l.write("connections %r %.3fs\n" % (c, time.time() - starttime))
sd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # any udp socket
try:
for i in range(howmany):
t0 = time.time()
if evserver:
yield environ['x-wsgiorg.fdevent.readable'](sd, timeout)
else: # spawning
try:
api.trampoline(sd, read=True, timeout=timeout)
except api.TimeoutError:
pass
#time.sleep(timeout) #api.sleep(timeout)
delta = (time.time()-t0-timeout)
deltas += delta
l.write('%i\n' % (delta* 1000.0))
yield payload
except GeneratorExit:
pass
sd.close()
tt1 = time.time()
tt = tt1-tt0
l.write('total time %.3f, deltas=%.3f drift=%.3f\n' % (tt, deltas, tt-(howmany*timeout)-deltas))
c -= 1
def new_read(fd, *args, **kw):
from eventlet import api
try:
api.trampoline(fd, read=True)
except socket.error, e:
if e[0] == errno.EPIPE:
return ""
else:
raise
def go():
desc = eventlet.connect(('127.0.0.1', bound_port))
try:
api.trampoline(desc, read=True, timeout=0.1)
except api.TimeoutError:
assert False, "Timed out"
server.close()
desc.close()
done[0] = True
def go():
desc = eventlet.connect(('127.0.0.1', bound_port))
try:
api.trampoline(desc, read=True, timeout=0.1)
except api.TimeoutError:
assert False, "Timed out"
server.close()
desc.close()
done[0] = True
def connect_ex(self, address):
if self.act_non_blocking:
return self.fd.connect_ex(address)
fd = self.fd
if self.gettimeout() is None:
while not socket_connect(fd, address):
try:
trampoline(fd, write=True, timeout_exc=socket.timeout)
except socket.error, ex:
return ex[0]
def read_pipe_and_die(the_pipe, server_coro):
try:
api.trampoline(the_pipe, read=True)
os.read(the_pipe, 1)
except socket.error:
pass
try:
os.close(the_pipe)
except socket.error:
pass
api.switch(server_coro, exc=ExitChild)
def accept(self):
if self.act_non_blocking:
return self.fd.accept()
fd = self.fd
while True:
res = socket_accept(fd)
if res is not None:
client, addr = res
set_nonblocking(client)
return type(self)(client), addr
trampoline(fd, read=True, timeout=self.gettimeout(), timeout_exc=socket.timeout)
def run(self):
while True:
timeout = self.sleep_timeout()
if timeout > 0:
try:
api.trampoline(self.r, read=True, timeout=timeout)
os.read(self.r, 1024)
except api.TimeoutError, e:
pass
while self.events and self.next_event() <= (time.time() + self.accuracy):
event = self.events.pop(0)
self.eventhandler(event)
def go():
client = util.tcp_socket()
desc = greenio.GreenSocket(client)
desc.connect(('127.0.0.1', bound_port))
try:
api.trampoline(desc, read=True, write=True, timeout=0.1)
except api.TimeoutError:
assert False, "Timed out"
server.close()
client.close()
def go():
client = util.tcp_socket()
desc = greenio.GreenSocket(client)
desc.connect(('127.0.0.1', bound_port))
try:
api.trampoline(desc, read=True, write=True, timeout=0.1)
except api.TimeoutError:
assert False, "Timed out"
server.close()
client.close()
def test_001_trampoline_timeout(self):
server = api.tcp_listener(('0.0.0.0', 0))
bound_port = server.getsockname()[1]
try:
desc = greenio.GreenSocket(util.tcp_socket())
desc.connect(('127.0.0.1', bound_port))
api.trampoline(desc, read=True, write=False, timeout=0.1)
except api.TimeoutError:
pass # test passed
else:
assert False, "Didn't timeout"
check_hub()
def test_001_trampoline_timeout(self):
server = api.tcp_listener(('0.0.0.0', 0))
bound_port = server.getsockname()[1]
try:
desc = greenio.GreenSocket(util.tcp_socket())
desc.connect(('127.0.0.1', bound_port))
api.trampoline(desc, read=True, write=False, timeout=0.1)
except api.TimeoutError:
pass # test passed
else:
assert False, "Didn't timeout"
check_hub()
def connect(self, address):
if self.act_non_blocking:
return self.fd.connect(address)
fd = self.fd
if self.gettimeout() is None:
while not socket_connect(fd, address):
trampoline(fd, write=True, timeout_exc=socket.timeout)
else:
end = time.time() + self.gettimeout()
while True:
if socket_connect(fd, address):
return
if time.time() >= end:
raise socket.timeout
trampoline(fd, write=True, timeout=end-time.time(), timeout_exc=socket.timeout)
def test_001_trampoline_timeout(self):
server_sock = eventlet.listen(('127.0.0.1', 0))
bound_port = server_sock.getsockname()[1]
def server(sock):
client, addr = sock.accept()
api.sleep(0.1)
server_evt = spawn(server, server_sock)
api.sleep(0)
try:
desc = eventlet.connect(('127.0.0.1', bound_port))
api.trampoline(desc, read=True, write=False, timeout=0.001)
except api.TimeoutError:
pass # test passed
else:
assert False, "Didn't timeout"
server_evt.wait()
check_hub()
def test_001_trampoline_timeout(self):
from eventlet import coros
server_sock = eventlet.listen(('127.0.0.1', 0))
bound_port = server_sock.getsockname()[1]
def server(sock):
client, addr = sock.accept()
api.sleep(0.1)
server_evt = spawn(server, server_sock)
api.sleep(0)
try:
desc = eventlet.connect(('127.0.0.1', bound_port))
api.trampoline(desc, read=True, write=False, timeout=0.001)
except api.TimeoutError:
pass # test passed
else:
assert False, "Didn't timeout"
server_evt.wait()
check_hub()
def _process(self):
while True:
ret = api.trampoline(self.client.Connection._sock, read=True)
if ret:
self._handle_message(ret)
api.call_after_global(0, self._g_run.greenlet.switch)
else:
# this semaphore stops the message queue greenlet from
# switching into us whilst we're trying to read data
self._semaphore.acquire()
self.client.Process(1)
self._semaphore.release()
def recv_into(self, *args):
if not self.act_non_blocking:
trampoline(self.fd, read=True, timeout=self.gettimeout(), timeout_exc=socket.timeout)
return self.fd.recv_into(*args)
def sendall(self, data):
fd = self.fd
tail = self.send(data)
while tail < len(data):
trampoline(self.fd, write=True, timeout_exc=socket.timeout)
tail += self.send(data[tail:])
def sendto(self, *args):
trampoline(self.fd, write=True, timeout_exc=socket.timeout)
return self.fd.sendto(*args)
fd = self.fd
if self.gettimeout() is None:
while not socket_connect(fd, address):
try:
trampoline(fd, write=True, timeout_exc=socket.timeout)
except socket.error, ex:
return ex[0]
else:
end = time.time() + self.gettimeout()
while True:
if socket_connect(fd, address):
return 0
if time.time() >= end:
raise socket.timeout
try:
trampoline(fd, write=True, timeout=end-time.time(), timeout_exc=socket.timeout)
except socket.error, ex:
return ex[0]
def dup(self, *args, **kw):
sock = self.fd.dup(*args, **kw)
set_nonblocking(sock)
newsock = type(self)(sock)
newsock.settimeout(self.timeout)
return newsock
def fileno(self, *args, **kw):
fn = self.fileno = self.fd.fileno
return fn(*args, **kw)
def getpeername(self, *args, **kw):
def new_write(fd, *args, **kw):
from eventlet import api
api.trampoline(fd, write=True)
return __original_write__(fd, *args, **kw)
