def run(self): acceptors = [] for sock in self.sockets: s = GreenSocket(family_or_realsock=sock) s.setblocking(1) hfun = partial(self.handle, s) acceptor = eventlet.spawn(eventlet.serve, s, hfun, self.worker_connections) acceptors.append(acceptor) while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s", self) break eventlet.sleep(1.0) self.notify() try: with eventlet.Timeout(self.cfg.graceful_timeout) as t: [a.wait() for a in acceptors] except eventlet.Timeout as te: if te != t: raise [a.kill() for a in acceptors]
def run(self): acceptors = [] for sock in self.sockets: gsock = GreenSocket(sock) gsock.setblocking(1) hfun = partial(self.handle, gsock) acceptor = eventlet.spawn(_eventlet_serve, gsock, hfun, self.worker_connections) acceptors.append(acceptor) eventlet.sleep(0.0) while self.alive: self.notify() eventlet.sleep(1.0) self.notify() try: with eventlet.Timeout(self.cfg.graceful_timeout) as t: [a.kill(eventlet.StopServe()) for a in acceptors] [a.wait() for a in acceptors] except eventlet.Timeout as te: if te != t: raise [a.kill() for a in acceptors]
class EventletWorker(AsyncWorker): @classmethod def setup(cls): import eventlet if eventlet.version_info < (0,9,7): raise RuntimeError("You need eventlet >= 0.9.7") eventlet.monkey_patch(os=False) def init_process(self): hubs.use_hub() super(EventletWorker, self).init_process() def timeout_ctx(self): return eventlet.Timeout(self.cfg.keepalive, False) def run(self): self.socket = GreenSocket(family_or_realsock=self.socket.sock) self.socket.setblocking(1) self.acceptor = eventlet.spawn(eventlet.serve, self.socket, self.handle, self.worker_connections) while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s", self) break eventlet.sleep(1.0) self.notify() with eventlet.Timeout(self.timeout, False): eventlet.kill(self.acceptor, eventlet.StopServe)
class EventletWorker(AsyncWorker): @classmethod def setup(cls): import eventlet if eventlet.version_info < (0, 9, 7): raise RuntimeError("You need eventlet >= 0.9.7") eventlet.monkey_patch(os=False) def init_process(self): hubs.use_hub() super(EventletWorker, self).init_process() def timeout_ctx(self): return eventlet.Timeout(self.cfg.keepalive, False) def run(self): self.socket = GreenSocket(family_or_realsock=self.socket.sock) self.socket.setblocking(1) self.acceptor = eventlet.spawn(eventlet.serve, self.socket, self.handle, self.worker_connections) while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s" % self) break eventlet.sleep(1.0) self.notify() with eventlet.Timeout(self.timeout, False): eventlet.kill(self.acceptor, eventlet.StopServe)
def run(self): acceptors = [] for sock in self.sockets: gsock = GreenSocket(sock) gsock.setblocking(1) hfun = partial(self.handle, gsock) acceptor = eventlet.spawn(_eventlet_serve, gsock, hfun, self.worker_connections) acceptors.append(acceptor) eventlet.sleep(0.0) while self.alive: self.notify() eventlet.sleep(1.0) self.notify() try: with eventlet.Timeout(self.cfg.graceful_timeout) as t: for a in acceptors: a.kill(eventlet.StopServe()) for a in acceptors: a.wait() except eventlet.Timeout as te: if te != t: raise for a in acceptors: a.kill()
def __init__( self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, *args, **kw ): if not isinstance(sock, GreenSocket): sock = GreenSocket(sock) self.act_non_blocking = sock.act_non_blocking if six.PY2: # On Python 2 SSLSocket constructor queries the timeout, it'd break without # this assignment self._timeout = sock.gettimeout() # nonblocking socket handshaking on connect got disabled so let's pretend it's disabled # even when it's on super(GreenSSLSocket, self).__init__( sock.fd, keyfile, certfile, server_side, cert_reqs, ssl_version, ca_certs, do_handshake_on_connect and six.PY2, *args, **kw ) # the superclass initializer trashes the methods so we remove # the local-object versions of them and let the actual class # methods shine through # Note: This for Python 2 try: for fn in orig_socket._delegate_methods: delattr(self, fn) except AttributeError: pass if six.PY3: # Python 3 SSLSocket construction process overwrites the timeout so restore it self._timeout = sock.gettimeout() # it also sets timeout to None internally apparently (tested with 3.4.2) _original_sslsocket.settimeout(self, 0.0) assert _original_sslsocket.gettimeout(self) == 0.0 # see note above about handshaking self.do_handshake_on_connect = do_handshake_on_connect if do_handshake_on_connect and self._connected: self.do_handshake()
class EventletWorker(AsyncWorker): @classmethod def setup(cls): import eventlet if eventlet.version_info < (0,9,7): raise RuntimeError("You need eventlet >= 0.9.7") eventlet.monkey_patch(os=False) def init_process(self): hubs.use_hub() super(EventletWorker, self).init_process() def timeout_ctx(self): return eventlet.Timeout(self.cfg.keepalive, False) def acceptor(self, pool): try: while self.alive: try: client, addr = self.socket.accept() pool.spawn_n(self.handle, client, addr) except socket.error, e: if e[0] not in (errno.EAGAIN, errno.ECONNABORTED): raise if pool.running() > self.worker_connections: continue try: hubs.trampoline(self.socket.fileno(), read=True, timeout=self.timeout) except eventlet.Timeout: pass except eventlet.StopServer: pool.waitall() def run(self): self.socket = GreenSocket(family_or_realsock=self.socket.sock) self.socket.setblocking(1) pool = eventlet.GreenPool(self.worker_connections) acceptor = eventlet.spawn(self.acceptor, pool) try: while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s" % self) server.stop() break eventlet.sleep(0.1) except KeyboardInterrupt: pass with eventlet.Timeout(self.timeout, False): eventlet.kill(acceptor, eventlet.StopServe)
def run(self): self.socket = GreenSocket(family_or_realsock=self.socket.sock) self.socket.setblocking(1) self.acceptor = eventlet.spawn(eventlet.serve, self.socket, server.handle, int(config.get("MAX_CONNECTIONS"))) while True: eventlet.sleep(0.1) with eventlet.Timeout(30, False): eventlet.kill(self.acceptor, eventlet.StopServe)
def __init__(self, sock, *args, **kw): if not isinstance(sock, GreenSocket): sock = GreenSocket(sock) self.act_non_blocking = sock.act_non_blocking self._timeout = sock.gettimeout() super(GreenSSLSocket, self).__init__(sock.fd, *args, **kw) # the superclass initializer trashes the methods so... for fn in orig_socket._delegate_methods: delattr(self, fn)
def open_socket(self): try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #self.sock = GreenSocket(family_or_realsock=s) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock = GreenSocket(s) self.sock.setblocking(1) self.sock.bind((self.host, self.port)) self.sock.listen(50) except socket.error: if self.sock: self.close_socket() sys.exit(1)
class Listen(object): def __init__(self): self.host = config.get("HOST") self.port = int(config.get("PORT")) self.backlog = int(config.get("BACKLOG")) self.sock = None hubs.use_hub() # def open_socket(self): # s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # self.sock = GreenSocket(s) # self.sock.bind((self.host, self.port)) # self.sock.listen(self.backlog) def open_socket(self): try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #self.sock = GreenSocket(family_or_realsock=s) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock = GreenSocket(s) self.sock.setblocking(1) self.sock.bind((self.host, self.port)) self.sock.listen(50) except socket.error: if self.sock: self.close_socket() sys.exit(1) def close_socket(self): if self.sock: self.sock.close() sys.exit(1)
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, *args, **kw): if not isinstance(sock, GreenSocket): sock = GreenSocket(sock) self.act_non_blocking = sock.act_non_blocking if six.PY2: # On Python 2 SSLSocket constructor queries the timeout, it'd break without # this assignment self._timeout = sock.gettimeout() # nonblocking socket handshaking on connect got disabled so let's pretend it's disabled # even when it's on super(GreenSSLSocket, self).__init__(sock.fd, keyfile, certfile, server_side, cert_reqs, ssl_version, ca_certs, do_handshake_on_connect and six.PY2, *args, **kw) # the superclass initializer trashes the methods so we remove # the local-object versions of them and let the actual class # methods shine through # Note: This for Python 2 try: for fn in orig_socket._delegate_methods: delattr(self, fn) except AttributeError: pass if six.PY3: # Python 3 SSLSocket construction process overwrites the timeout so restore it self._timeout = sock.gettimeout() # it also sets timeout to None internally apparently (tested with 3.4.2) _original_sslsocket.settimeout(self, 0.0) assert _original_sslsocket.gettimeout(self) == 0.0 # see note above about handshaking self.do_handshake_on_connect = do_handshake_on_connect if do_handshake_on_connect and self._connected: self.do_handshake()
def __init__(self, sock, *args, **kw): if not isinstance(sock, GreenSocket): sock = GreenSocket(sock) self.act_non_blocking = sock.act_non_blocking self._timeout = sock.gettimeout() super(GreenSSLSocket, self).__init__(sock.fd, *args, **kw) # the superclass initializer trashes the methods so we remove # the local-object versions of them and let the actual class # methods shine through try: for fn in orig_socket._delegate_methods: delattr(self, fn) except AttributeError: pass
class Worker(object): def __init__(self, sock): self.socket = sock def init_worker(self): hubs.use_hub() def run(self): self.socket = GreenSocket(family_or_realsock=self.socket.sock) self.socket.setblocking(1) self.acceptor = eventlet.spawn(eventlet.serve, self.socket, server.handle, int(config.get("MAX_CONNECTIONS"))) while True: eventlet.sleep(0.1) with eventlet.Timeout(30, False): eventlet.kill(self.acceptor, eventlet.StopServe)
def __new__(cls, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, *args, **kw): if _is_under_py_3_7: return super(GreenSSLSocket, cls).__new__(cls) else: if not isinstance(sock, GreenSocket): sock = GreenSocket(sock) with _original_ssl_context(): ret = _original_wrap_socket( sock=sock.fd, keyfile=keyfile, certfile=certfile, server_side=server_side, cert_reqs=cert_reqs, ssl_version=ssl_version, ca_certs=ca_certs, do_handshake_on_connect=False, *args, **kw ) ret.keyfile = keyfile ret.certfile = certfile ret.cert_reqs = cert_reqs ret.ssl_version = ssl_version ret.ca_certs = ca_certs ret.__class__ = GreenSSLSocket return ret
def run(self): self.socket = GreenSocket(family_or_realsock=self.socket.sock) self.socket.setblocking(1) self.acceptor = eventlet.spawn(eventlet.serve, self.socket, self.handle, self.worker_connections) while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s" % self) break eventlet.sleep(1.0) self.notify() with eventlet.Timeout(self.timeout, False): eventlet.kill(self.acceptor, eventlet.StopServe)
def run(self): acceptors = [] for sock in self.sockets: s = GreenSocket(family_or_realsock=sock) s.setblocking(1) hfun = partial(self.handle, s) acceptor = eventlet.spawn(eventlet.serve, s, hfun, self.worker_connections) while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s", self) break eventlet.sleep(1.0) self.notify() with eventlet.Timeout(self.cfg.graceful_timeout, False): [eventlet.kill(a, eventlet.StopServe) for a in acceptors]
def run(self): self.socket = GreenSocket(family_or_realsock=self.socket.sock) self.socket.setblocking(1) self.acceptor = eventlet.spawn(eventlet.serve, self.socket, self.handle, self.worker_connections) while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s" % self) break eventlet.sleep(0.1) self.notify() with eventlet.Timeout(self.timeout, False): eventlet.kill(self.acceptor, eventlet.StopServe)
def __new__(cls, sock=None, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, *args, **kw): if _is_under_py_3_7: return super(GreenSSLSocket, cls).__new__(cls) else: if not isinstance(sock, GreenSocket): sock = GreenSocket(sock) with _original_ssl_context(): context = kw.get('_context') if context: ret = _original_sslsocket._create( sock=sock.fd, server_side=server_side, do_handshake_on_connect=False, suppress_ragged_eofs=kw.get('suppress_ragged_eofs', True), server_hostname=kw.get('server_hostname'), context=context, session=kw.get('session'), ) else: ret = _original_wrap_socket( sock=sock.fd, keyfile=keyfile, certfile=certfile, server_side=server_side, cert_reqs=cert_reqs, ssl_version=ssl_version, ca_certs=ca_certs, do_handshake_on_connect=False, ) ret.keyfile = keyfile ret.certfile = certfile ret.cert_reqs = cert_reqs ret.ssl_version = ssl_version ret.ca_certs = ca_certs ret.__class__ = GreenSSLSocket return ret
def run(self): self.socket = GreenSocket(family_or_realsock=self.socket.sock) self.socket.setblocking(1) pool = eventlet.GreenPool(self.worker_connections) acceptor = eventlet.spawn(self.acceptor, pool) try: while self.alive: self.notify() if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s" % self) server.stop() break eventlet.sleep(0.1) except KeyboardInterrupt: pass with eventlet.Timeout(self.timeout, False): eventlet.kill(acceptor, eventlet.StopServe)
def unwrap(self): return GreenSocket( self._call_trampolining(super(GreenSSLSocket, self).unwrap))
def _dark_green_pipe(): s1, s2 = socket.socketpair() s1.setblocking(True) s2.setblocking(True) return s1, GreenSocket(s2)
def unwrap(self): return GreenSocket(super(GreenSSLSocket, self).unwrap())