def create_servers(self, loop: asyncio.AbstractEventLoop) -> List[Any]: assert self._handler is None self._handler = self.app.make_handler(loop = loop) loop.run_until_complete(self.app.startup()) ret = [] if not self.ssl_only: ret.append(loop.create_server(self._handler, self.host, self.port, ssl = None)) if self.ssl_context is not None: ret.append(loop.create_server(self._handler, self.host, (self.port if self.ssl_only else 443), ssl = self.ssl_context)) return ret
def initialize(loop: asyncio.AbstractEventLoop, port: int, username: str, password: str, dbcon: DBConnection, active_monitor_manager: ActiveMonitorManager) -> None: """Initialize the webmgmt listener.""" stats.set('num_calls', 0, 'WEBMGMT') app = web.Application(loop=loop, logger=log.logger, middlewares=[ middleware.logging_middleware_factory, middleware.error_handler_middleware_factory, middleware.basic_auth_middleware_factory, ]) app['username'] = username app['password'] = password app['dbcon'] = dbcon app['active_monitor_manager'] = active_monitor_manager setup_routes(app) aiohttp_jinja2.setup( app, loader=jinja2.PackageLoader('irisett.webmgmt', 'templates'), filters={ 'timestamp': jinja_filters.timestamp }, ) listener = loop.create_server(app.make_handler(), '0.0.0.0', port) asyncio.ensure_future(listener) log.msg('Webmgmt listening on port %s' % port)
def create_server(self, loop: asyncio.AbstractEventLoop = None, host='0.0.0.0', port=2775): factory = loop.create_server(lambda: SmppProtocol(app=self), host=host, port=port) server = loop.run_until_complete(factory) return server
def create_server(host: str="", port: int=8000, loop: asyncio.AbstractEventLoop=None): """ Creates server sockets bound to a specific address:port supporting the protocols provided :param port: local port to bind :param host: local host to bind :param loop: asyncio event loop :return: """ loop = loop or asyncio.get_event_loop() server = loop.create_server(Server, host=host, port=port, reuse_address=True) log = make_logger() log.info("Server Created on {}:{}".format(host, port)) return server
def initialize(loop: asyncio.AbstractEventLoop, port: int, username: str, password: str, dbcon: DBConnection, active_monitor_manager: ActiveMonitorManager) -> None: """Initialize the webapi listener.""" stats.set('num_calls', 0, 'WEBAPI') app = web.Application(loop=loop, logger=log.logger, middlewares=[ middleware.logging_middleware_factory, middleware.error_handler_middleware_factory, middleware.basic_auth_middleware_factory, ]) app['username'] = username app['password'] = password app['dbcon'] = dbcon app['active_monitor_manager'] = active_monitor_manager setup_routes(app) listener = loop.create_server(app.make_handler(), '0.0.0.0', port) loop.create_task(listener) log.msg('Webapi listening on port %s' % port)
def serve_main_app(config: Config, loop: asyncio.AbstractEventLoop = None): setup_logging(config.verbose) loop = loop or asyncio.get_event_loop() if isinstance(config.app_factory, Application): app = config.app_factory else: app = config.app_factory(loop=loop) modify_main_app(app, config) loop.run_until_complete(check_port_open(config.main_port, loop)) handler = app.make_handler( logger=dft_logger, access_log_format='%r %s %b', loop=loop, ) co = asyncio.gather(loop.create_server(handler, HOST, config.main_port, backlog=128), app.startup(), loop=loop) server, startup_res = loop.run_until_complete(co) try: loop.run_forever() except KeyboardInterrupt: # pragma: no cover pass finally: server.close() loop.run_until_complete(server.wait_closed()) loop.run_until_complete(app.shutdown()) try: loop.run_until_complete(handler.shutdown(0.1)) except asyncio.TimeoutError: pass loop.run_until_complete(app.cleanup()) loop.close()
def serve_main_app(config: Config, tty_path: Optional[str], loop: asyncio.AbstractEventLoop = None): with set_tty(tty_path): setup_logging(config.verbose) # imports the factory. This gives users a chance to register alternative event loops config.app_factory loop = loop or asyncio.get_event_loop() app = config.load_app(loop) modify_main_app(app, config) loop.run_until_complete(check_port_open(config.main_port, loop)) handler = app.make_handler( logger=dft_logger, access_log_format='%r %s %b', loop=loop, ) loop.run_until_complete(app.startup()) server = loop.run_until_complete( loop.create_server(handler, HOST, config.main_port, backlog=128)) try: loop.run_forever() except KeyboardInterrupt: # pragma: no cover pass finally: server.close() loop.run_until_complete(server.wait_closed()) loop.run_until_complete(app.shutdown()) with contextlib.suppress(asyncio.TimeoutError, KeyboardInterrupt): loop.run_until_complete(handler.shutdown(0.1)) with contextlib.suppress(KeyboardInterrupt): loop.run_until_complete(app.cleanup()) with contextlib.suppress(KeyboardInterrupt): loop.close()
def run_single( app: Type[ASGIFramework], config: Config, *, loop: asyncio.AbstractEventLoop, sock: Optional[socket] = None, is_child: bool = False, ) -> None: """Create a server to run the app on given the options. Arguments: app: The ASGI Framework to run. config: The configuration that defines the server. loop: Asyncio loop to create the server in, if None, take default one. """ if loop is None: warnings.warn( 'Event loop is not specified, this can cause unexpected errors') loop = asyncio.get_event_loop() if config.pid_path is not None and not is_child: _write_pid_file(config.pid_path) loop.set_debug(config.debug) if hasattr(app, 'startup'): loop.run_until_complete(app.startup()) # type: ignore if sock is not None: create_server = loop.create_server( lambda: Server(app, loop, config), ssl=config.ssl, sock=sock, reuse_port=is_child, ) elif config.file_descriptor is not None: sock = socket_fromfd(config.file_descriptor, AF_UNIX, SOCK_STREAM) create_server = loop.create_server( lambda: Server(app, loop, config), ssl=config.ssl, sock=sock, ) elif config.unix_domain is not None: create_server = loop.create_unix_server( lambda: Server(app, loop, config), config.unix_domain, ssl=config.ssl, ) else: create_server = loop.create_server( lambda: Server(app, loop, config), host=config.host, port=config.port, ssl=config.ssl, reuse_port=is_child, ) server = loop.run_until_complete(create_server) if platform.system() == 'Windows': loop.create_task(_windows_signal_support()) try: loop.add_signal_handler(signal.SIGINT, _raise_shutdown) loop.add_signal_handler(signal.SIGTERM, _raise_shutdown) except NotImplementedError: pass # Unix only reload_ = False try: if config.use_reloader: loop.run_until_complete(_observe_changes()) reload_ = True else: loop.run_forever() except (SystemExit, KeyboardInterrupt): pass finally: server.close() loop.run_until_complete(server.wait_closed()) loop.run_until_complete(loop.shutdown_asyncgens()) try: loop.remove_signal_handler(signal.SIGINT) loop.remove_signal_handler(signal.SIGTERM) except NotImplementedError: pass # Unix only if hasattr(app, 'cleanup'): loop.run_until_complete(app.cleanup()) # type: ignore loop.close() if reload_: # Restart this process (only safe for dev/debug) os.execv(sys.executable, [sys.executable] + sys.argv)
def create_servers(self, loop: asyncio.AbstractEventLoop) -> List[Any]: return [loop.create_server(self._protocol, self.host, self.port, ssl = self.ssl_context)]