You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
283 lines
9.4 KiB
283 lines
9.4 KiB
# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details.
|
|
"""TCP/SSL server"""
|
|
|
|
from contextlib import closing
|
|
|
|
import sys
|
|
|
|
from _socket import error as SocketError
|
|
from _socket import SOL_SOCKET
|
|
from _socket import SO_REUSEADDR
|
|
from _socket import AF_INET
|
|
from _socket import SOCK_DGRAM
|
|
|
|
from gevent.baseserver import BaseServer
|
|
from gevent.socket import EWOULDBLOCK
|
|
from gevent.socket import socket as GeventSocket
|
|
from gevent._compat import PYPY, PY3
|
|
|
|
__all__ = ['StreamServer', 'DatagramServer']
|
|
|
|
|
|
if sys.platform == 'win32':
|
|
# SO_REUSEADDR on Windows does not mean the same thing as on *nix (issue #217)
|
|
DEFAULT_REUSE_ADDR = None
|
|
else:
|
|
DEFAULT_REUSE_ADDR = 1
|
|
|
|
|
|
if PY3:
|
|
# sockets and SSL sockets are context managers on Python 3
|
|
def _closing_socket(sock):
|
|
return sock
|
|
else:
|
|
# but they are not guaranteed to be so on Python 2
|
|
_closing_socket = closing
|
|
|
|
|
|
class StreamServer(BaseServer):
|
|
"""
|
|
A generic TCP server.
|
|
|
|
Accepts connections on a listening socket and spawns user-provided
|
|
*handle* function for each connection with 2 arguments: the client
|
|
socket and the client address.
|
|
|
|
Note that although the errors in a successfully spawned handler
|
|
will not affect the server or other connections, the errors raised
|
|
by :func:`accept` and *spawn* cause the server to stop accepting
|
|
for a short amount of time. The exact period depends on the values
|
|
of :attr:`min_delay` and :attr:`max_delay` attributes.
|
|
|
|
The delay starts with :attr:`min_delay` and doubles with each
|
|
successive error until it reaches :attr:`max_delay`. A successful
|
|
:func:`accept` resets the delay to :attr:`min_delay` again.
|
|
|
|
See :class:`~gevent.baseserver.BaseServer` for information on defining the *handle*
|
|
function and important restrictions on it.
|
|
|
|
**SSL Support**
|
|
|
|
The server can optionally work in SSL mode when given the correct
|
|
keyword arguments. (That is, the presence of any keyword arguments
|
|
will trigger SSL mode.) On Python 2.7.9 and later (any Python
|
|
version that supports the :class:`ssl.SSLContext`), this can be
|
|
done with a configured ``SSLContext``. On any Python version, it
|
|
can be done by passing the appropriate arguments for
|
|
:func:`ssl.wrap_socket`.
|
|
|
|
The incoming socket will be wrapped into an SSL socket before
|
|
being passed to the *handle* function.
|
|
|
|
If the *ssl_context* keyword argument is present, it should
|
|
contain an :class:`ssl.SSLContext`. The remaining keyword
|
|
arguments are passed to the :meth:`ssl.SSLContext.wrap_socket`
|
|
method of that object. Depending on the Python version, supported arguments
|
|
may include:
|
|
|
|
- server_hostname
|
|
- suppress_ragged_eofs
|
|
- do_handshake_on_connect
|
|
|
|
.. caution:: When using an SSLContext, it should either be
|
|
imported from :mod:`gevent.ssl`, or the process needs to be monkey-patched.
|
|
If the process is not monkey-patched and you pass the standard library
|
|
SSLContext, the resulting client sockets will not cooperate with gevent.
|
|
|
|
Otherwise, keyword arguments are assumed to apply to :func:`ssl.wrap_socket`.
|
|
These keyword arguments may include:
|
|
|
|
- keyfile
|
|
- certfile
|
|
- cert_reqs
|
|
- ssl_version
|
|
- ca_certs
|
|
- suppress_ragged_eofs
|
|
- do_handshake_on_connect
|
|
- ciphers
|
|
|
|
.. versionchanged:: 1.2a2
|
|
Add support for the *ssl_context* keyword argument.
|
|
|
|
"""
|
|
# the default backlog to use if none was provided in __init__
|
|
backlog = 256
|
|
|
|
reuse_addr = DEFAULT_REUSE_ADDR
|
|
|
|
def __init__(self, listener, handle=None, backlog=None, spawn='default', **ssl_args):
|
|
BaseServer.__init__(self, listener, handle=handle, spawn=spawn)
|
|
try:
|
|
if ssl_args:
|
|
ssl_args.setdefault('server_side', True)
|
|
if 'ssl_context' in ssl_args:
|
|
ssl_context = ssl_args.pop('ssl_context')
|
|
self.wrap_socket = ssl_context.wrap_socket
|
|
self.ssl_args = ssl_args
|
|
else:
|
|
from gevent.ssl import wrap_socket
|
|
self.wrap_socket = wrap_socket
|
|
self.ssl_args = ssl_args
|
|
else:
|
|
self.ssl_args = None
|
|
if backlog is not None:
|
|
if hasattr(self, 'socket'):
|
|
raise TypeError('backlog must be None when a socket instance is passed')
|
|
self.backlog = backlog
|
|
except:
|
|
self.close()
|
|
raise
|
|
|
|
@property
|
|
def ssl_enabled(self):
|
|
return self.ssl_args is not None
|
|
|
|
def set_listener(self, listener):
|
|
BaseServer.set_listener(self, listener)
|
|
try:
|
|
self.socket = self.socket._sock
|
|
except AttributeError:
|
|
pass
|
|
|
|
def init_socket(self):
|
|
if not hasattr(self, 'socket'):
|
|
# FIXME: clean up the socket lifetime
|
|
# pylint:disable=attribute-defined-outside-init
|
|
self.socket = self.get_listener(self.address, self.backlog, self.family)
|
|
self.address = self.socket.getsockname()
|
|
if self.ssl_args:
|
|
self._handle = self.wrap_socket_and_handle
|
|
else:
|
|
self._handle = self.handle
|
|
|
|
@classmethod
|
|
def get_listener(cls, address, backlog=None, family=None):
|
|
if backlog is None:
|
|
backlog = cls.backlog
|
|
return _tcp_listener(address, backlog=backlog, reuse_addr=cls.reuse_addr, family=family)
|
|
|
|
if PY3:
|
|
|
|
def do_read(self):
|
|
sock = self.socket
|
|
try:
|
|
fd, address = sock._accept()
|
|
except BlockingIOError: # python 2: pylint: disable=undefined-variable
|
|
if not sock.timeout:
|
|
return
|
|
raise
|
|
|
|
sock = GeventSocket(sock.family, sock.type, sock.proto, fileno=fd)
|
|
# XXX Python issue #7995?
|
|
return sock, address
|
|
|
|
else:
|
|
|
|
def do_read(self):
|
|
try:
|
|
client_socket, address = self.socket.accept()
|
|
except SocketError as err:
|
|
if err.args[0] == EWOULDBLOCK:
|
|
return
|
|
raise
|
|
# XXX: When would this not be the case? In Python 3 it makes sense
|
|
# because we're using the low-level _accept method,
|
|
# but not in Python 2.
|
|
if not isinstance(client_socket, GeventSocket):
|
|
# This leads to a leak of the watchers in client_socket
|
|
sockobj = GeventSocket(_sock=client_socket)
|
|
if PYPY:
|
|
client_socket._drop()
|
|
else:
|
|
sockobj = client_socket
|
|
return sockobj, address
|
|
|
|
def do_close(self, sock, *args):
|
|
# pylint:disable=arguments-differ
|
|
sock.close()
|
|
|
|
def wrap_socket_and_handle(self, client_socket, address):
|
|
# used in case of ssl sockets
|
|
with _closing_socket(self.wrap_socket(client_socket, **self.ssl_args)) as ssl_socket:
|
|
return self.handle(ssl_socket, address)
|
|
|
|
|
|
class DatagramServer(BaseServer):
|
|
"""A UDP server"""
|
|
|
|
reuse_addr = DEFAULT_REUSE_ADDR
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
# The raw (non-gevent) socket, if possible
|
|
self._socket = None
|
|
BaseServer.__init__(self, *args, **kwargs)
|
|
from gevent.lock import Semaphore
|
|
self._writelock = Semaphore()
|
|
|
|
def init_socket(self):
|
|
if not hasattr(self, 'socket'):
|
|
# FIXME: clean up the socket lifetime
|
|
# pylint:disable=attribute-defined-outside-init
|
|
self.socket = self.get_listener(self.address, self.family)
|
|
self.address = self.socket.getsockname()
|
|
self._socket = self.socket
|
|
try:
|
|
self._socket = self._socket._sock
|
|
except AttributeError:
|
|
pass
|
|
|
|
@classmethod
|
|
def get_listener(cls, address, family=None):
|
|
return _udp_socket(address, reuse_addr=cls.reuse_addr, family=family)
|
|
|
|
def do_read(self):
|
|
try:
|
|
data, address = self._socket.recvfrom(8192)
|
|
except SocketError as err:
|
|
if err.args[0] == EWOULDBLOCK:
|
|
return
|
|
raise
|
|
return data, address
|
|
|
|
def sendto(self, *args):
|
|
self._writelock.acquire()
|
|
try:
|
|
self.socket.sendto(*args)
|
|
finally:
|
|
self._writelock.release()
|
|
|
|
|
|
def _tcp_listener(address, backlog=50, reuse_addr=None, family=AF_INET):
|
|
"""A shortcut to create a TCP socket, bind it and put it into listening state."""
|
|
sock = GeventSocket(family=family)
|
|
if reuse_addr is not None:
|
|
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, reuse_addr)
|
|
try:
|
|
sock.bind(address)
|
|
except SocketError as ex:
|
|
strerror = getattr(ex, 'strerror', None)
|
|
if strerror is not None:
|
|
ex.strerror = strerror + ': ' + repr(address)
|
|
raise
|
|
sock.listen(backlog)
|
|
sock.setblocking(0)
|
|
return sock
|
|
|
|
|
|
def _udp_socket(address, backlog=50, reuse_addr=None, family=AF_INET):
|
|
# backlog argument for compat with tcp_listener
|
|
# pylint:disable=unused-argument
|
|
|
|
# we want gevent.socket.socket here
|
|
sock = GeventSocket(family=family, type=SOCK_DGRAM)
|
|
if reuse_addr is not None:
|
|
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, reuse_addr)
|
|
try:
|
|
sock.bind(address)
|
|
except SocketError as ex:
|
|
strerror = getattr(ex, 'strerror', None)
|
|
if strerror is not None:
|
|
ex.strerror = strerror + ': ' + repr(address)
|
|
raise
|
|
return sock
|