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 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 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)