class UnixClientServer: temp = None sock = None server = None channel = None async def __aenter__(self): self.temp = tempfile.mkdtemp() self.sock = os.path.join(self.temp, 'grpclib.sock') dummy_service = DummyService() self.server = Server([dummy_service]) await self.server.start(path=self.sock) self.channel = Channel(path=self.sock) dummy_stub = DummyServiceStub(self.channel) return dummy_service, dummy_stub async def __aexit__(self, *exc_info): self.server.close() await self.server.wait_closed() self.channel.close() if os.path.exists(self.sock): os.unlink(self.sock) if os.path.exists(self.temp): os.rmdir(self.temp)
class ClientServer: server = None channel = None def __init__(self, *, loop): self.loop = loop async def __aenter__(self): host = '127.0.0.1' with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind(('127.0.0.1', 0)) _, port = s.getsockname() dummy_service = DummyService() self.server = Server([dummy_service], loop=self.loop) await self.server.start(host, port) self.channel = Channel(host=host, port=port, loop=self.loop) dummy_stub = DummyServiceStub(self.channel) return dummy_service, dummy_stub async def __aexit__(self, *exc_info): self.server.close() await self.server.wait_closed() self.channel.close()
def main(): # setup judge judgeenv.load_env(cli=True) executors.load_executors() print('Running grpc judge server ...') logging.basicConfig( filename=judgeenv.log_file, level=logging.INFO, format='%(levelname)s %(asctime)s %(module)s %(message)s') for warning in judgeenv.startup_warnings: print(ansi_style('#ansi[Warning: %s](yellow)' % warning)) del judgeenv.startup_warnings print() judge = LocalJudge() loop = asyncio.get_event_loop() server = Server([DmojService(judge)], loop=loop) host, port = '127.0.0.1', 5001 loop.run_until_complete(server.start(host, port)) print('Serving on {}:{}'.format(host, port)) try: loop.run_forever() except KeyboardInterrupt: pass server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def channel_fixture(loop, port): services = [DummyService()] services = ServerReflection.extend(services) server = Server(services, loop=loop) loop.run_until_complete(server.start(port=port)) channel = Channel(port=port, loop=loop) try: yield channel finally: channel.close() server.close() loop.run_until_complete(server.wait_closed())
def run(self): loop = asyncio.get_event_loop() server = Server([BotNode()], loop=loop) host, port = '0.0.0.0', 50051 loop.run_until_complete(server.start(host, port)) logger.debug(f'Serving on {host}:{port}') try: loop.run_forever() except KeyboardInterrupt: pass server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def main(): loop = asyncio.get_event_loop() server = Server([Greeter()], loop=loop, codec=JSONCodec) host, port = '127.0.0.1', 50051 loop.run_until_complete(server.start(host, port)) print('Serving on {}:{}'.format(host, port)) try: loop.run_forever() except KeyboardInterrupt: pass server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def mainCode(): count = 0 loop = asyncio.get_event_loop() #server = Server([Emotion_recognizer(count)], loop=loop) server = Server([Emotion_recognizer()], loop=loop) host, port = '127.0.0.1', 50051 loop.run_until_complete(server.start(host, port)) print('Serving on {}:{}'.format(host, port)) try: loop.run_forever() except KeyboardInterrupt: pass server.close() loop.run_until_complete(server.wait_closed()) loop.close()
class ServerWire(Wire): """ .. wire:: harness.wires.grpclib.server.ServerWire :type: output :runtime: python :config: harness.grpc.Server :requirements: grpclib protobuf """ _config: grpc_pb2.Server server: Server def __init__(self, handlers: List["_Servable"]): self.handlers = handlers def configure(self, value: grpc_pb2.Server): assert isinstance(value, grpc_pb2.Server), type(value) self._config = value handlers = list(self.handlers) if not any(isinstance(h, Health) for h in handlers): handlers.append(Health()) handlers = ServerReflection.extend(handlers) self.server = Server(handlers) listen(self.server, RecvRequest, _recv_request) listen(self.server, SendTrailingMetadata, _send_trailing_metadata) async def __aenter__(self): await self.server.start(self._config.bind.host, self._config.bind.port) _log.info( "%s started: addr=%s:%d", self.__class__.__name__, self._config.bind.host, self._config.bind.port, ) def close(self): self.server.close() async def wait_closed(self): await self.server.wait_closed()
class ClientServer: server = None def __init__(self, *, loop): self.loop = loop async def __aenter__(self): host = '127.0.0.1' with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind(('127.0.0.1', 0)) _, port = s.getsockname() bombed = Bombed() self.server = Server([bombed], loop=self.loop) await self.server.start(host, port) channel = Channel(host=host, port=port, loop=self.loop) stub = BombedStub(channel) return bombed, stub async def __aexit__(self, *exc_info): self.server.close() await self.server.wait_closed()
class App: def __init__(self, debug=False): self.debug = debug if not self.debug: uvloop.install() self.loop = asyncio.get_event_loop() self.prepared = False self.proxyman = ProxyMan() def _init_config(self): self.config = { "GRPC_HOST": os.getenv("SS_GRPC_HOST", "127.0.0.1"), "GRPC_PORT": os.getenv("SS_GRPC_PORT", "5000"), "SENTRY_DSN": os.getenv("SS_SENTRY_DSN"), "API_ENDPOINT": os.getenv("SS_API_ENDPOINT"), "LOG_LEVEL": os.getenv("SS_LOG_LEVEL", "info"), "SYNC_TIME": int(os.getenv("SS_SYNC_TIME", 60)), "STREAM_DNS_SERVER": os.getenv("SS_STREAM_DNS_SERVER"), "METRICS_PORT": os.getenv("SS_METRICS_PORT"), "TIME_OUT_LIMIT": int(os.getenv("SS_TIME_OUT_LIMIT", 60)), "USER_TCP_CONN_LIMIT": int(os.getenv("SS_TCP_CONN_LIMIT", 60)), } self.grpc_host = self.config["GRPC_HOST"] self.grpc_port = self.config["GRPC_PORT"] self.log_level = self.config["LOG_LEVEL"] self.sync_time = self.config["SYNC_TIME"] self.sentry_dsn = self.config["SENTRY_DSN"] self.api_endpoint = self.config["API_ENDPOINT"] self.timeout_limit = self.config["TIME_OUT_LIMIT"] self.stream_dns_server = self.config["STREAM_DNS_SERVER"] self.user_tcp_conn_limit = self.config["USER_TCP_CONN_LIMIT"] self.metrics_port = self.config["METRICS_PORT"] self.use_sentry = True if self.sentry_dsn else False self.use_json = False if self.api_endpoint else True self.use_grpc = True if self.grpc_host and self.grpc_port else False def _init_logger(self): """ basic log config """ log_levels = { "CRITICAL": 50, "ERROR": 40, "WARNING": 30, "INFO": 20, "DEBUG": 10, } if self.debug: level = 10 else: level = log_levels.get(self.log_level.upper(), 10) logging.basicConfig( format="[%(levelname)s]%(asctime)s - %(filename)s - %(funcName)s " "line:%(lineno)d: - %(message)s", level=level, ) def _init_memory_db(self): for _, model in inspect.getmembers(models, inspect.isclass): if issubclass(model, BaseModel) and model != BaseModel: model.create_table() logging.info(f"正在创建{model}内存数据库") def _init_sentry(self): if not self.use_sentry: return sentry_sdk.init(dsn=self.sentry_dsn, integrations=[AioHttpIntegration()]) logging.info("Init Sentry Client...") def _prepare(self): if self.prepared: return self._init_config() self._init_logger() self._init_memory_db() self._init_sentry() self.loop.add_signal_handler(signal.SIGTERM, self.shutdown) self.prepared = True async def start_grpc_server(self): self.grpc_server = Server([AioShadowsocksServicer()], loop=self.loop) listen(self.grpc_server, RecvRequest, logging_grpc_request) await self.grpc_server.start(self.grpc_host, self.grpc_port) logging.info(f"Start grpc Server on {self.grpc_host}:{self.grpc_port}") async def start_metrics_server(self): app = web.Application() app.router.add_get("/metrics", aio.web.server_stats) runner = web.AppRunner(app) await runner.setup() self.metrics_server = web.TCPSite(runner, "0.0.0.0", self.metrics_port) await self.metrics_server.start() logging.info( f"Start Metrics Server At: http://0.0.0.0:{self.metrics_port}/metrics" ) def run(self): self._prepare() if self.use_json: self.loop.create_task(self.proxyman.start_ss_json_server()) else: self.loop.create_task( self.proxyman.start_remote_sync_server(self.api_endpoint, self.sync_time)) if self.use_grpc: self.loop.create_task(self.start_grpc_server()) if self.metrics_port: self.loop.create_task(self.start_metrics_server()) try: self.loop.run_forever() except KeyboardInterrupt: self.shutdown() def shutdown(self): logging.info("正在关闭所有ss server") self.proxyman.close_server() if self.use_grpc: self.grpc_server.close() logging.info(f"grpc server closed!") if self.metrics_port: self.loop.create_task(self.metrics_server.stop()) logging.info(f"metrics server closed!") self.loop.stop()
class App: def __init__(self, debug=False): if not debug: uvloop.install() self.loop = asyncio.get_event_loop() self.prepared = False def _init_config(self): self.config = { "GRPC_HOST": os.getenv("SS_GRPC_HOST"), "GRPC_PORT": os.getenv("SS_GRPC_PORT"), "SENTRY_DSN": os.getenv("SS_SENTRY_DSN"), "API_ENDPOINT": os.getenv("SS_API_ENDPOINT"), "LOG_LEVEL": os.getenv("SS_LOG_LEVEL", "info"), "SYNC_TIME": int(os.getenv("SS_SYNC_TIME", 60)), "TIME_OUT_LIMIT": int(os.getenv("SS_TIME_OUT_LIMIT", 60)), "USER_TCP_CONN_LIMIT": int(os.getenv("SS_TCP_CONN_LIMIT", 60)), } self.grpc_host = self.config["GRPC_HOST"] self.grpc_port = self.config["GRPC_PORT"] self.log_level = self.config["LOG_LEVEL"] self.sync_time = self.config["SYNC_TIME"] self.sentry_dsn = self.config["SENTRY_DSN"] self.api_endpoint = self.config["API_ENDPOINT"] self.timeout_limit = self.config["TIME_OUT_LIMIT"] self.user_tcp_conn_limit = self.config["USER_TCP_CONN_LIMIT"] self.use_json = False if self.api_endpoint else True self.use_grpc = True if self.grpc_host and self.grpc_port else False self.use_sentry = True if self.sentry_dsn else False def _init_logger(self): """ basic log config """ log_levels = { "CRITICAL": 50, "ERROR": 40, "WARNING": 30, "INFO": 20, "DEBUG": 10, } level = log_levels.get(self.log_level.upper(), 10) logging.basicConfig( format= "[%(levelname)s]%(asctime)s-%(name)s - %(funcName)s() - %(message)s", level=level, ) def _init_memory_db(self): from shadowsocks.mdb import BaseModel, models for _, model in inspect.getmembers(models, inspect.isclass): if issubclass(model, BaseModel) and model != BaseModel: model.create_table() logging.info(f"正在创建{model}内存数据库") def _init_sentry(self): if not self.use_sentry: return self.sentry_client = raven.Client(self.sentry_dsn, transport=AioHttpTransport) self.loop.set_exception_handler(self.__sentry_exception_handler) logging.info("Init Sentry Client...") def _prepare(self): if self.prepared: return self._init_config() self._init_logger() self._init_memory_db() self._init_sentry() self.loop.add_signal_handler(signal.SIGTERM, self.shutdown) self.prepared = True def __sentry_exception_handler(self, loop, context): try: raise context["exception"] except TimeoutError: logging.error(f"socket timeout msg: {context['message']}") except Exception: logging.error(f"unhandled error msg: {context['message']}") self.sentry_client.captureException(**context) async def start_grpc_server(self): from shadowsocks.services import AioShadowsocksServicer self.grpc_server = Server([AioShadowsocksServicer()], loop=self.loop) await self.grpc_server.start(self.grpc_host, self.grpc_port) logging.info(f"Start Grpc Server on {self.grpc_host}:{self.grpc_port}") def start_json_server(self): from shadowsocks.mdb import models models.User.create_or_update_from_json("userconfigs.json") models.User.init_user_servers() def start_remote_sync_server(self): from shadowsocks.mdb import models try: models.User.create_or_update_from_remote(self.api_endpoint) models.UserServer.flush_metrics_to_remote(self.api_endpoint) models.User.init_user_servers() except Exception as e: logging.warning(f"sync user error {e}") self.loop.call_later(self.sync_time, self.start_remote_sync_server) def shutdown(self): from shadowsocks.mdb import models models.UserServer.shutdown() if self.use_grpc: self.grpc_server.close() logging.info( f"Grpc Server on {self.grpc_host}:{self.grpc_port} Closed!") self.loop.stop() def run(self): self._prepare() if self.use_json: self.start_json_server() else: self.start_remote_sync_server() if self.use_grpc: self.loop.create_task(self.start_grpc_server()) try: self.loop.run_forever() except KeyboardInterrupt: logging.info("正在关闭所有ss server") self.shutdown()
class App: def __init__(self, debug=False): self.debug = debug if not self.debug: uvloop.install() self.loop = asyncio.get_event_loop() self.prepared = False self.proxyman = ProxyMan() def _init_config(self): self.config = { "GRPC_HOST": os.getenv("SS_GRPC_HOST", "127.0.0.1"), "GRPC_PORT": os.getenv("SS_GRPC_PORT", "5000"), "SENTRY_DSN": os.getenv("SS_SENTRY_DSN"), "API_ENDPOINT": os.getenv("SS_API_ENDPOINT"), "LOG_LEVEL": os.getenv("SS_LOG_LEVEL", "info"), "SYNC_TIME": int(os.getenv("SS_SYNC_TIME", 60)), "STREAM_DNS_SERVER": os.getenv("SS_STREAM_DNS_SERVER"), "ENABLE_METRICS": bool(os.getenv("SS_ENABLE_METRICS", True)), "METRICS_PORT": os.getenv("SS_GRPC_PORT", "9888"), "TIME_OUT_LIMIT": int(os.getenv("SS_TIME_OUT_LIMIT", 60)), "USER_TCP_CONN_LIMIT": int(os.getenv("SS_TCP_CONN_LIMIT", 60)), } self.grpc_host = self.config["GRPC_HOST"] self.grpc_port = self.config["GRPC_PORT"] self.log_level = self.config["LOG_LEVEL"] self.sync_time = self.config["SYNC_TIME"] self.sentry_dsn = self.config["SENTRY_DSN"] self.api_endpoint = self.config["API_ENDPOINT"] self.timeout_limit = self.config["TIME_OUT_LIMIT"] self.stream_dns_server = self.config["STREAM_DNS_SERVER"] self.user_tcp_conn_limit = self.config["USER_TCP_CONN_LIMIT"] self.enable_metrics = self.config["ENABLE_METRICS"] self.metrics_port = self.config["METRICS_PORT"] self.use_sentry = True if self.sentry_dsn else False self.use_json = False if self.api_endpoint else True self.use_grpc = True if self.grpc_host and self.grpc_port else False def _init_logger(self): """ basic log config """ log_levels = { "CRITICAL": 50, "ERROR": 40, "WARNING": 30, "INFO": 20, "DEBUG": 10, } if self.debug: level = 10 else: level = log_levels.get(self.log_level.upper(), 10) logging.basicConfig( format="[%(levelname)s]%(asctime)s - %(filename)s - %(funcName)s " "line:%(lineno)d: - %(message)s", level=level, ) def _init_memory_db(self): from shadowsocks.mdb import BaseModel, models for _, model in inspect.getmembers(models, inspect.isclass): if issubclass(model, BaseModel) and model != BaseModel: model.create_table() logging.info(f"正在创建{model}内存数据库") # def _init_sentry(self): # TODO 升级到最新的sentry-sdk # def sentry_exception_handler(loop, context): # try: # raise context["exception"] # except TimeoutError: # logging.error(f"socket timeout msg: {context['message']}") # except Exception: # logging.error(f"unhandled error msg: {context['message']}") # self.sentry_client.captureException(**context) # if not self.use_sentry: # return # self.sentry_client = raven.Client(self.sentry_dsn, transport=AioHttpTransport) # self.loop.set_exception_handler(sentry_exception_handler) # logging.info("Init Sentry Client...") def _prepare(self): if self.prepared: return self._init_config() self._init_logger() self._init_memory_db() # self._init_sentry() self.loop.add_signal_handler(signal.SIGTERM, self.shutdown) self.prepared = True async def start_grpc_server(self): from shadowsocks.services import AioShadowsocksServicer self.grpc_server = Server([AioShadowsocksServicer()], loop=self.loop) await self.grpc_server.start(self.grpc_host, self.grpc_port) logging.info(f"Start Grpc Server on {self.grpc_host}:{self.grpc_port}") async def start_metrics_server(self): app = web.Application() app.router.add_get("/metrics", aio.web.server_stats) runner = web.AppRunner(app) await runner.setup() self.metrics_server = web.TCPSite(runner, "0.0.0.0", self.metrics_port) await self.metrics_server.start() logging.info( f"Start Metrics Server At: http://0.0.0.0:{self.metrics_port}/metrics" ) def run(self): self._prepare() if self.use_json: self.loop.create_task(self.proxyman.start_ss_json_server()) else: self.loop.create_task( self.proxyman.start_remote_sync_server(self.api_endpoint, self.sync_time)) if self.use_grpc: self.loop.create_task(self.start_grpc_server()) if self.enable_metrics: self.loop.create_task(self.start_metrics_server()) try: self.loop.run_forever() except KeyboardInterrupt: logging.info("正在关闭所有ss server") self.shutdown() def shutdown(self): self.proxyman.close_server() if self.use_grpc: self.grpc_server.close() logging.info(f"grpc server closed!") if self.enable_metrics: self.loop.create_task(self.metrics_server.stop()) logging.info(f"metrics server closed!") pending = asyncio.all_tasks(self.loop) self.loop.run_until_complete(asyncio.gather(*pending)) self.loop.stop()
def main(): asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) loop = asyncio.get_event_loop() logging.basicConfig(level=os.getenv('LOG_LEVEL', logging.INFO)) logging.getLogger("asyncio").setLevel(logging.ERROR) logging.getLogger("aiohttp").setLevel(logging.ERROR) logging.getLogger("jaeger_tracing").setLevel(logging.ERROR) logger = logging.getLogger(__name__) ctx.logger = logger h = '0.0.0.0' # configuration config = os.getenv("CONFIG") if not config: raise EnvironmentError("no config file specified") if not os.path.exists(config): raise EnvironmentError("config file does not exist") logger.info("Reading configuration from {config}".format(**locals())) try: with open(config, "r") as cfg: config = ujson.load(cfg) except ValueError: raise EnvironmentError("could not parse config file") jsonschema.validate(config, schema) # tracer jport = os.getenv('JAEGER_AGENT_PORT') if jport: config = jaeger_client.Config(config={ 'sampler': { 'type': 'const', 'param': 1 }, 'logging': True, }, service_name='pyskull', validate=True) ctx.tracer = config.initialize_tracer() logger.info("jaeger started against {}:{}".format( os.getenv('JAEGER_AGENT_HOST'), jport)) # http api server runner = None api_port = os.environ['HTTP_PORT'] if api_port: from pyskull.http import routes, middlewares from aiohttp import web app = web.Application(middlewares=middlewares) app.add_routes(routes) runner = web.AppRunner(app) loop.run_until_complete(runner.setup()) site = web.TCPSite(runner, h, int(api_port)) loop.run_until_complete(site.start()) logger.info("HTTP API started on {h}:{api_port}".format(**locals())) # grpc server gapi = None gport = os.getenv('GRPC_PORT') if gport: from pyskull import grpc as g from grpclib.server import Server gapi = Server([g.Greeter()], loop=loop) loop.run_until_complete(gapi.start('0.0.0.0', 50051)) logger.info("gRPC started on {h}:{gport}".format(**locals())) # metrics server mserver = None metrics_port = os.environ['METRICS_PORT'] if metrics_port: mserver = MetricsServer() loop.run_until_complete(mserver.start(h, metrics_port)) logger.info("metrics started on {h}:{metrics_port}".format(**locals())) def killer(**kwargs): raise KeyboardInterrupt loop.add_signal_handler(signal.SIGINT, lambda: asyncio.ensure_future(killer())) loop.add_signal_handler(signal.SIGTERM, lambda: asyncio.ensure_future(killer())) try: loop.run_forever() except KeyboardInterrupt: logger.info('shutting down') cleanup = [] if runner: cleanup += [asyncio.ensure_future(runner.cleanup())] if gapi: gapi.close() cleanup += [asyncio.ensure_future(gapi.wait_closed())] if mserver: cleanup += [asyncio.ensure_future(mserver.stop())] loop.run_until_complete(asyncio.gather(*cleanup)) loop.close() # allow for tracer to flush if enabled if ctx.tracer: time.sleep(2) ctx.tracer.close()
class App: def __init__(self): uvloop.install() self.loop = asyncio.get_event_loop() self.loop.add_signal_handler(signal.SIGTERM, self.shutdown) self.config = { "API_ENDPOINT": os.getenv("SS_API_ENDPOINT"), "GRPC_HOST": os.getenv("SS_GRPC_HOST"), "GRPC_PORT": os.getenv("SS_GRPC_PORT"), "SYNC_TIME": int(os.getenv("SS_SYNC_TIME", 60)), "LOG_LEVEL": os.getenv("SS_LOG_LEVEL", "info"), } self.api_endpoint = self.config.get("API_ENDPOINT") self.grpc_host = self.config.get("GRPC_HOST") self.grpc_port = self.config.get("GRPC_PORT") self.use_json = False if self.api_endpoint else True self.use_grpc = True if self.grpc_host and self.grpc_port else False self._prepared = False def _init_logger_config(self): """ basic log config """ log_levels = { "CRITICAL": 50, "ERROR": 40, "WARNING": 30, "INFO": 20, "DEBUG": 10, } level = log_levels.get(self.config["LOG_LEVEL"].upper(), 10) logging.basicConfig( format= "[%(levelname)s]%(asctime)s-%(name)s - %(funcName)s() - %(message)s", level=level, ) def _init_memory_db(self): for _, model in inspect.getmembers(models, inspect.isclass): if issubclass(model, BaseModel) and model != BaseModel: model.create_table() logging.info(f"正在创建{model}临时数据库") def _prepare(self): if self._prepared: return self._init_logger_config() self._init_memory_db() self._prepared = True def start_json_server(self): models.User.create_or_update_from_json("userconfigs.json") models.User.init_user_servers() def start_remote_sync_server(self): try: models.User.create_or_update_from_remote() models.UserServer.flush_data_to_remote() models.User.init_user_servers() except Exception as e: logging.warning(f"sync user error {e}") self.loop.call_later(self.config["SYNC_TIME"], self.start_remote_sync_server) async def start_grpc_server(self): self.grpc_server = Server([AioShadowsocksServicer()], loop=self.loop) await self.grpc_server.start(self.grpc_host, self.grpc_port) logging.info(f"Start Grpc Server on {self.grpc_host}:{self.grpc_port}") def shutdown(self): models.UserServer.shutdown() if self.use_grpc: self.grpc_server.close() logging.info( f"Grpc Server on {self.grpc_host}:{self.grpc_port} Closed!") self.loop.stop() def run(self): self._prepare() if self.use_json: self.start_json_server() else: self.start_remote_sync_server() if self.use_grpc: self.loop.create_task(self.start_grpc_server()) try: self.loop.run_forever() except KeyboardInterrupt: logging.info("正在关闭所有ss server") self.shutdown()
p.add_argument('host', nargs='?', const=1, default=settings.GRPC_SERVER_HOST) p.add_argument('port', nargs='?', type=int, const=1, default=settings.GRPC_SERVER_PORT) args = p.parse_args() host = args.host port = args.port env = server = None loop = asyncio.get_event_loop() try: engine = loop.run_until_complete(init_engine()) server = Server([BillingService(engine=engine)], loop=asyncio.get_event_loop()) loop.run_until_complete(server.start(host, port)) stop = asyncio.Future() loop.add_signal_handler(signal.SIGTERM, stop.set_result, None) loop.run_until_complete(stop) except KeyboardInterrupt: pass finally: server.close() if server else None engine = loop.run_until_complete(engine.close()) loop.run_until_complete(server.wait_closed()) if server else None