def get_grpc_server(user_model,
seldon_metrics,
annotations={},
trace_interceptor=None):
seldon_model = SeldonModelGRPC(user_model, seldon_metrics)
options = []
if ANNOTATION_GRPC_MAX_MSG_SIZE in annotations:
max_msg = int(annotations[ANNOTATION_GRPC_MAX_MSG_SIZE])
logger.info("Setting grpc max message and receive length to %d",
max_msg)
options.append(("grpc.max_message_length", max_msg))
options.append(("grpc.max_send_message_length", max_msg))
options.append(("grpc.max_receive_message_length", max_msg))
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
options=options)
if trace_interceptor:
from grpc_opentracing.grpcext import intercept_server
server = intercept_server(server, trace_interceptor)
prediction_pb2_grpc.add_GenericServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_ModelServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_TransformerServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_OutputTransformerServicer_to_server(
seldon_model, server)
prediction_pb2_grpc.add_CombinerServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_RouterServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_SeldonServicer_to_server(seldon_model, server)
return server
def serve():
config = Config(
config={
"sampler": {
"type": "const",
"param": 1
},
"logging": True
},
service_name="chat-server",
)
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_server_interceptor(tracer,
log_payloads=True)
redis_opentracing.init_tracing(tracer_interceptor)
redis_client = Redis()
kafka_producer = KafkaProducer(
bootstrap_servers="127.0.0.1:9092",
value_serializer=lambda v: json.dumps(v).encode("utf-8"),
)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
chat_pb2_grpc.add_ChatServicer_to_server(
ChatServicer(tracer, redis_client, kafka_producer), server)
server.add_insecure_port("[::]:50051")
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def serve():
"""Read in key and cert and start's serving the server."""
Configuration.tracer = init_jaeger_tracer("stub_api")
# read in key and certificate
with open("certs/tls.key", "rb") as f:
private_key = f.read()
with open("certs/tls.crt", "rb") as f:
certificate_chain = f.read()
# create server credentials
server_credentials = grpc.ssl_server_credentials(
((private_key, certificate_chain), ))
tracer_interceptor = open_tracing_server_interceptor(Configuration.tracer)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
stub_pb2_grpc.add_StubServicer_to_server(
StubServicer(Configuration.tracer), server)
server.add_secure_port(f"[::]:{Configuration.GRPC_PORT}",
server_credentials)
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
Configuration.tracer.close()
def serve():
parser = argparse.ArgumentParser()
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
args = parser.parse_args()
config = Config(config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
},
service_name='trivial-server')
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_server_interceptor(
tracer, log_payloads=args.log_payloads)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
command_line_pb2.add_CommandLineServicer_to_server(CommandLine(), server)
server.add_insecure_port('[::]:50051')
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
time.sleep(2)
tracer.close()
time.sleep(2)
def serve():
config = get_config('account-server')
tracer = config.initialize_tracer()
tracer_interceptor = open_tracing_server_interceptor(tracer,
log_payloads=True)
server = grpc.server(ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
add_AccountServicer_to_server(Account(), server)
server.add_insecure_port('[::]:50051')
server.start()
wait_for_termination()
server.stop(0)
tracer.close()
def __init__(self,
client_interceptors,
server_interceptors,
handler=Handler()):
self.handler = handler
self._server_pool = logging_pool.pool(2)
self._server = grpcext.intercept_server(grpc.server(self._server_pool),
*server_interceptors)
port = self._server.add_insecure_port('[::]:0')
self._server.add_generic_rpc_handlers(
(_GenericHandler(self.handler), ))
self._server.start()
self.channel = grpcext.intercept_channel(
grpc.insecure_channel('localhost:%d' % port), *client_interceptors)
def get_grpc_server(user_model,
seldon_metrics,
annotations={},
trace_interceptor=None,
num_threads=1):
seldon_model = SeldonModelGRPC(user_model, seldon_metrics)
options = [
("grpc.so_reuseport", 1),
]
if ANNOTATION_GRPC_MAX_MSG_SIZE in annotations:
max_msg = int(annotations[ANNOTATION_GRPC_MAX_MSG_SIZE])
logger.info("Setting grpc max message and receive length to %d",
max_msg)
options.append(("grpc.max_message_length", max_msg))
options.append(("grpc.max_send_message_length", max_msg))
options.append(("grpc.max_receive_message_length", max_msg))
server = grpc.server(futures.ThreadPoolExecutor(max_workers=num_threads),
options=options)
if trace_interceptor:
from grpc_opentracing.grpcext import intercept_server
server = intercept_server(server, trace_interceptor)
prediction_pb2_grpc.add_GenericServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_ModelServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_TransformerServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_OutputTransformerServicer_to_server(
seldon_model, server)
prediction_pb2_grpc.add_CombinerServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_RouterServicer_to_server(seldon_model, server)
prediction_pb2_grpc.add_SeldonServicer_to_server(seldon_model, server)
SERVICE_NAMES = (
prediction_pb2.DESCRIPTOR.services_by_name["Generic"].full_name,
prediction_pb2.DESCRIPTOR.services_by_name["Model"].full_name,
prediction_pb2.DESCRIPTOR.services_by_name["Router"].full_name,
prediction_pb2.DESCRIPTOR.services_by_name["Transformer"].full_name,
prediction_pb2.DESCRIPTOR.services_by_name["OutputTransformer"].
full_name,
prediction_pb2.DESCRIPTOR.services_by_name["Combiner"].full_name,
prediction_pb2.DESCRIPTOR.services_by_name["Seldon"].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
return server
def serve():
grpc_server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
tracer_interceptor = open_tracing_server_interceptor(tracer)
grpc_server = intercept_server(grpc_server, tracer_interceptor)
hello_pb2_grpc.add_HelloServerServicer_to_server(Greeter(), grpc_server)
grpc_server.add_insecure_port('[::]:50051')
grpc_server.start()
# grpc_server.wait_for_termination()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
grpc_server.stop(0)
tracer.close()
def get_grpc_server(user_model, debug=False, annotations={}, trace_interceptor=None):
seldon_model = SeldonTransformerGRPC(user_model)
options = []
if ANNOTATION_GRPC_MAX_MSG_SIZE in annotations:
max_msg = int(annotations[ANNOTATION_GRPC_MAX_MSG_SIZE])
logger.info("Setting grpc max message to %d", max_msg)
options.append(('grpc.max_message_length', max_msg))
server = grpc.server(futures.ThreadPoolExecutor(
max_workers=10), options=options)
if trace_interceptor:
from grpc_opentracing.grpcext import intercept_server
server = intercept_server(server, trace_interceptor)
prediction_pb2_grpc.add_ModelServicer_to_server(seldon_model, server)
return server
def serve():
parser = argparse.ArgumentParser()
parser.add_argument(
'--log_payloads',
action='store_true',
help='log request/response objects to open-tracing spans')
parser.add_argument(
'--include_grpc_tags',
action='store_true',
help='set gRPC-specific tags on spans')
args = parser.parse_args()
config = Config(
config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
},
service_name='store-server')
tracer = config.initialize_tracer()
span_decorator = None
if args.include_grpc_tags:
span_decorator = StoreSpanDecorator()
tracer_interceptor = open_tracing_server_interceptor(
tracer, log_payloads=args.log_payloads, span_decorator=span_decorator)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = intercept_server(server, tracer_interceptor)
store_pb2.add_StoreServicer_to_server(Store(), server)
server.add_insecure_port('[::]:50051')
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
time.sleep(2)
tracer.close()
time.sleep(2)
def serve(self):
config = Config(
config={ # usually read from some yaml config
'sampler': {
'type': 'const', # 全部
'param': 1, # 1 开启全部采样 0 表示关闭全部采样
},
'local_agent': {
'reporting_host': '192.168.0.14',
'reporting_port': '6831',
},
'logging': True,
},
service_name='order-srv',
validate=True,
)
tracer = config.initialize_tracer()
self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=40))
tracing_interceptor = open_tracing_server_interceptor(tracer)
self.server = intercept_server(self.server, tracing_interceptor)
order_pb2_grpc.add_OrderServicer_to_server(OrderService(), self.server)
health_servicer = health.HealthServicer()
health_pb2_grpc.add_HealthServicer_to_server(health_servicer,
self.server)
self.server.add_insecure_port(f'[::]:{self.SERVICE_PORT}')
signal.signal(signal.SIGINT, self.onExit)
signal.signal(signal.SIGTERM, self.onExit)
logger.info("Start Order Service at {}:{}".format(
self.SERVICE_HOST, self.SERVICE_PORT))
self.server.start()
self.register()
#监听超时订单消息
consumer = PushConsumer("mxshop_order")
consumer.set_name_server_address(
f"{settings.RocketMQ_HOST}:{settings.RocketMQ_PORT}")
consumer.subscribe("order_timeout", order_timeout)
consumer.start()
self.server.wait_for_termination()
consumer.shutdown()
def intercept_grpc_server(server, tracer):
tracer_interceptor = open_tracing_server_interceptor(tracer)
new_server = intercept_server(server, tracer_interceptor)
return new_server
def _enable_trace(self, server, tracer):
from grpc_opentracing import open_tracing_server_interceptor
from grpc_opentracing.grpcext import intercept_server
tracer_interceptor = open_tracing_server_interceptor(tracer)
return intercept_server(server, tracer_interceptor)
