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 serve():
print("grpcs-hello:", GRPC_LISTEN_ADDR)
loop = asyncio.get_event_loop()
server = Server([Hello()], loop=loop)
loop.run_until_complete(
server.start(
GRPC_LISTEN_ADDR.split(":")[0],
int(GRPC_LISTEN_ADDR.split(":")[1])))
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()
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()
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
