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:
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 __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,
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)
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
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)
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 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())
