Python asyncio 模块，Server() 实例源码

def start_server(self):
        """
        Starts the listening server.

        :return: Server object if successful, otherwise None.
        :rtype: asyncio.Server
        """

        nlog.info("Creating server listing on '{}:{}'...".format(self.host, self.port))
        try:
            self.server = await asyncio.start_server(self.create_connection,
                                                     self.host,
                                                     self.port)
            nlog.info(self.log_prefix + "Success created server listing on '{}:{}'...".format(self.host, self.port))

        except:
            self.startup_exception_info = sys.exc_info()
            nlog.exception(self.log_prefix + "Error opening server listening on '{}:{}'...".format(self.host, self.port))

        self.started_semaphore.release()
        return self.server

def start(self) -> None:
        '''
        Start socket server which will stream movie
        '''
        self._logger.info('Server starting at = %s:%d', self.host, self.port)
        self._server = await asyncio.start_server(self._handle_client, self.host, self.port)

def close(self):
        """
        Called by SocketShark to indicate that the backend should stop
        accepting connections.
        """
        # Stop the underlying asyncio.Server from accepting new connections.
        if self.server:
            self.server.server.close()

def __init__(self, host, port, connections, loop=None):
        self.host = host  #: Listening host
        self.port = port  #: Listening port
        self.loop = loop or event_loop.get()  #: Event loop onto which the listener is running.
        self.server = None  #: class:`asyncio.Server` instance used by the listener.
        self.connections = connections  #: Dictionary containing all connections.

        asyncio.run_coroutine_threadsafe(self.start_server(), self.loop)

        self.started_semaphore = asyncio.Semaphore(0)

        self.startup_exception_info = None

def start(path, chain=None, loop=None):
    '''
    :returns: initialized server
    :rtype: asyncio.Server
    '''
    if loop is None:
        loop = asyncio.get_event_loop()
    rpc = RPCServer(chain)
    server = loop.run_until_complete(asyncio.start_unix_server(
        connection_handler(rpc.execute),
        path,
        loop=loop,
        limit=MAXIMUM_REQUEST_BYTES,
    ))
    return server

def run_until_interrupt(server, loop=None):
    logger = logging.getLogger('evm.rpc.ipc')
    if loop is None:
        loop = asyncio.get_event_loop()
    try:
        loop.run_forever()
    except KeyboardInterrupt:
        logger.debug('Server closed with Keyboard Interrupt')
    finally:
        loop.close()

def __init__(self, host: str, port: int, filename):
        self._logger = logging.getLogger(self.__class__.__name__)
        self.host = host
        self.port = port
        self.filename = filename

        self._server = None # type: asyncio.Server
        self._sessions = {}

def stop(self) -> None:
        '''
        Stop server and all sessions
        '''
        self._logger.info('Server stopping')

        self._server.close()
        await self._server.wait_closed()

        # Because dict cannot be changed during iteration
        # we have to convert keys to list
        for session_id in list(self._sessions.keys()):
            self._logger.info('Terminating session = %s', session_id)
            await self._killSession(session_id)

def __init__(self):
        self.server: asyncio.Server = None
        self.clients: Dict[asyncio.Task, Tuple[asyncio.StreamReader, asyncio.StreamWriter]] = {}