def creater_server():
"""
server = creater_server()
print("start...")
server.start()
time.sleep(20)
print(f"stop...{server._state}")
server.stop(True)
# server = creater_server()
# print(f"start...{server._state}")
# server.start()
# time.sleep(10)
# print("stop...")
# server.stop(True)
"""
logger.info('Create gRPC Server...')
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
sentiment_analysis_pb2_grpc.add_SentimentAnalysisServicer_to_server(
SentimentAnalysis(), server)
SERVICE_NAMES = (
sentiment_analysis_pb2.DESCRIPTOR.
services_by_name['SentimentAnalysis'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port('[::]:50051')
return server
async def serve(
host: Optional[str] = None,
port: int = 50051,
):
# fmt: on
"""Serve."""
# server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
server = grpc.aio.server()
pb2_grpc.add_DeeplServicer_to_server(DeeplService(), server)
service_names = (
pb2.DESCRIPTOR.services_by_name['Deepl'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(service_names, server)
# server.add_insecure_port('[::]:50051')
try:
if host is None:
# server.add_insecure_port(f"[::]:{port}")
host = "::1"
server.add_insecure_port(f"[{host}]:{port}")
except Exception as exc:
logger.error(exc)
raise SystemExit(1)
await server.start()
# print(f" running at [::]:{port}")
logger.info(f" running at [{host}]:{port}")
try:
await server.wait_for_termination()
except Exception as exc: # signal no longer needed?
logger.info("Interrupted")
raise SystemExit(0) from exc
def run_server(shared_img):
"""
Runs the gRPC server that receives the requests
and updates the shared image with the most recent request
Args:
shared_img: shared image that should be updated by
the server with the most recent request
"""
logging.basicConfig(level=logging.DEBUG)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=_MAX_WORKERS))
vis_grpc.add_VisualizationServiceServicer_to_server(
VisualizationServiceImpl(shared_img), server)
service_names = (vis.DESCRIPTOR.services_by_name[_SERVICE_NAME].full_name,
grpc_reflect.SERVICE_NAME)
grpc_reflect.enable_server_reflection(service_names, server)
server.add_insecure_port(f'[::]:{_PORT}')
server.start()
logging.info('Server started at [::]:%s', _PORT)
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def grpc_serve():
# the +5 you see below re: max_workers is a hack to avoid thread starvation
# working on a proper workaround
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=multiprocessing.cpu_count() +
5))
# Add the application servicer to the server.
whereami_pb2_grpc.add_WhereamiServicer_to_server(WhereamigRPC(), server)
# Create a health check servicer. We use the non-blocking implementation
# to avoid thread starvation.
health_servicer = health.HealthServicer(
experimental_non_blocking=True,
experimental_thread_pool=futures.ThreadPoolExecutor(max_workers=1))
health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server)
# Create a tuple of all of the services we want to export via reflection.
services = tuple(
service.full_name
for service in whereami_pb2.DESCRIPTOR.services_by_name.values()) + (
reflection.SERVICE_NAME, health.SERVICE_NAME)
# Add the reflection service to the server.
reflection.enable_server_reflection(services, server)
server.add_insecure_port('[::]:9090')
server.start()
# Mark all services as healthy.
overall_server_health = ""
for service in services + (overall_server_health, ):
health_servicer.set(service, health_pb2.HealthCheckResponse.SERVING)
# Park the main application thread.
server.wait_for_termination()
def serve(config):
logging.basicConfig(
level=logging.INFO,
format=
'%(asctime)s.%(msecs)03d %(levelname)s: %(funcName)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
logging.info('loading model')
init_prototype(config)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=int(
config['service']['max workers']), ),
options=[('grpc.max_send_message_length',
MAX_MSG_LENGTH),
('grpc.max_message_length', MAX_MSG_LENGTH),
('grpc.max_receive_message_length',
MAX_MSG_LENGTH)],
interceptors=(PromServerInterceptor(), ))
add_ProcessorServiceServicer_to_server(ProcessorService(), server)
SERVICE_NAMES = (
DESCRIPTOR.services_by_name['ProcessorService'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port(config['service']['port'])
start_http_server(int(config['service']['prom port']))
server.start()
logging.info("Server running on port {}".format(config['service']['port']))
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def serve():
# We need to build a health service to work with go-plugin
health = HealthServicer()
health.set(
"plugin", health_pb2.HealthCheckResponse.ServingStatus.Value('SERVING'))
# Start the server.
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
health_pb2_grpc.add_HealthServicer_to_server(health, server)
cli_plugin_pb2_grpc.add_CLIServicer_to_server(mine(), server)
SERVICE_NAMES = (
cli_plugin_pb2.DESCRIPTOR.services_by_name['CLI'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port(f'{plugin_host}:{plugin_port}')
server.start()
sys.stdout.write(
f"{go_plugin_version}|{app_protocol_version}|tcp|{plugin_host}:{plugin_port}|grpc\n"
)
sys.stdout.flush()
try:
server.wait_for_termination()
except KeyboardInterrupt:
server.stop(0)
def serve():
port = 50051
if len(sys.argv) >= 2:
port = int(sys.argv[-1])
print("Serving grpc on %s" % (sys.argv[1:]))
if "grpcs" in sys.argv:
sc = get_server_cred()
else:
sc = None
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
SERVICE_NAMES = (
helloworld_pb2.DESCRIPTOR.services_by_name['Greeter'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
if sc:
server.add_secure_port('[::]:%s' % port, sc)
else:
server.add_insecure_port('[::]:%s' % port)
print("Listen on [::]:%s" % port)
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except:
server.stop(0)
def cli(log_level, host, port):
"""Vision Filter Visualizer
View filtered and unfiltered SSL Vision data. Adjust filter
parameters and view filter statistics.
"""
if log_level:
log = structlog.get_logger("vision_filter")
log.setLevel(log_level)
log = structlog.get_logger()
log.info("Creating visualizer instance")
visualizer = Visualizer()
log.info("Creating visualizer grpc server", host=host, port=port)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
filter_visualizer_pb2_grpc.add_FilterVisualizerServicer_to_server(
FilterVisualizer(visualizer), server)
SERVICE_NAMES = (
filter_visualizer_pb2.DESCRIPTOR.services_by_name["FilterVisualizer"].
full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port(f"{host}:{port}")
server.start()
log.info("Starting pyglet app loop")
pyglet.app.run()
server.stop(None)
def serve(port: int, hostname: str):
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=multiprocessing.cpu_count()))
# Add the application servicer to the server.
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(hostname),
server)
# Create a health check servicer. We use the non-blocking implementation
# to avoid thread starvation.
health_servicer = health.HealthServicer(
experimental_non_blocking=True,
experimental_thread_pool=futures.ThreadPoolExecutor(max_workers=1))
health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server)
# Create a tuple of all of the services we want to export via reflection.
services = tuple(
service.full_name
for service in helloworld_pb2.DESCRIPTOR.services_by_name.values()) + (
reflection.SERVICE_NAME, health.SERVICE_NAME)
# Add the reflection service to the server.
reflection.enable_server_reflection(services, server)
server.add_insecure_port(f"[::]:{port}")
server.start()
# Mark all services as healthy.
overall_server_health = ""
for service in services + (overall_server_health, ):
health_servicer.set(service, health_pb2.HealthCheckResponse.SERVING)
# Park the main application thread.
server.wait_for_termination()
def serve():
CONFIG = os.getenv("TG_CONFIG")
with open(CONFIG, "r") as f:
config = json.loads(f.read())
config = {
user:
Credentials(cred["consumer_key"], cred["consumer_secret"],
cred["access_token_key"], cred["access_token_secret"])
for user, cred in config.items()
}
server = grpc.server(futures.ThreadPoolExecutor(max_workers=16))
servicer = TweetGateway(config)
tweet_gateway_pb2_grpc.add_TweetGatewayServicer_to_server(servicer, server)
SERVICE_NAMES = (
tweet_gateway_pb2.DESCRIPTOR.services_by_name["TweetGateway"].
full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port("0.0.0.0:31337")
server.start()
server.wait_for_termination()
def serve(args):
listening_add = args.address
listening_port = args.port
global DEFECTIVE
#Importing the defective session registry if defective flag is set
if args.defective:
DEFECTIVE = True
from defective_session_registry import SessionRegistryManager
else:
from session_registry import SessionRegistryManager
manager_address = '{}:{}'.format(listening_add, listening_port)
session_registry_manager = SessionRegistryManager(manager_address)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
machine_manager_pb2_grpc.add_MachineManagerServicer_to_server(
_MachineManager(session_registry_manager), server)
machine_discovery_pb2_grpc.add_MachineDiscoveryServicer_to_server(
_MachineDiscovery(session_registry_manager), server)
SERVICE_NAMES = (
machine_manager_pb2.DESCRIPTOR.services_by_name['MachineManager'].
full_name,
machine_discovery_pb2.DESCRIPTOR.services_by_name['MachineDiscovery'].
full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port(manager_address)
server.start()
LOGGER.info("Server started, listening on address {} and port {}".format(
listening_add, listening_port))
try:
while True:
time.sleep(SLEEP_TIME)
except KeyboardInterrupt:
LOGGER.info("\nIssued to shut down")
LOGGER.debug("Acquiring session registry global lock")
#Acquiring lock to write on session registry
with session_registry_manager.global_lock:
LOGGER.debug("Session registry global lock acquired")
session_registry_manager.shutting_down = True
#Shutdown all active sessions servers
for session_id in session_registry_manager.registry.keys():
LOGGER.debug("Acquiring lock for session {}".format(session_id))
with session_registry_manager.registry[session_id].lock:
LOGGER.debug("Lock for session {} acquired".format(session_id))
if (session_registry_manager.registry[session_id].address):
utils.shutdown_cartesi_machine_server(
session_id,
session_registry_manager.registry[session_id].address)
shutdown_event = server.stop(0)
LOGGER.info("Waiting for server to stop")
shutdown_event.wait()
LOGGER.info("Server stopped")
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) # XXX: grpc doesn't support ProcessPoolExecutor.
hannanum_server.add_to_server(hannanum_server.HannanumService(), server)
kkma_server.add_to_server(kkma_server.KkmaService(), server)
komoran_server.add_to_server(komoran_server.KomoranService(), server)
mecab_server.add_to_server(mecab_server.MecabService(), server)
okt_server.add_to_server(okt_server.OktService(), server)
SERVICE_NAMES = (
reflection.SERVICE_NAME,
hannanum_server.SERVICE_NAME,
kkma_server.SERVICE_NAME,
komoran_server.SERVICE_NAME,
mecab_server.SERVICE_NAME,
okt_server.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port("[::]:50051")
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def serve(argv):
server_info.log_server_info()
sentry.init(FLAGS.sentry)
sm = storage.StorageManager()
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
interceptors=(psi, ))
registry_pb2_grpc.add_UserServiceServicer_to_server(
user_server.UserServiceServicer(storage_manager=sm), server)
registry_pb2_grpc.add_MaintenanceServiceServicer_to_server(
maintenance_server.MaintenanceServiceServicer(storage_manager=sm),
server)
registry_pb2_grpc.add_AssetServiceServicer_to_server(
asset_server.AssetServiceServicer(storage_manager=sm), server)
registry_pb2_grpc.add_ScheduleServiceServicer_to_server(
schedule_server.ScheduleServiceServicer(storage_manager=sm), server)
SERVICE_NAMES = (
registry_pb2.DESCRIPTOR.services_by_name['UserService'].full_name,
registry_pb2.DESCRIPTOR.services_by_name['MaintenanceService'].
full_name,
registry_pb2.DESCRIPTOR.services_by_name['AssetService'].full_name,
registry_pb2.DESCRIPTOR.services_by_name['ScheduleService'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port(FLAGS.listen_addr)
logging.info('Monolithic Server listening to: {0}'.format(
FLAGS.listen_addr))
server.start()
server.wait_for_termination()
def start_server():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
post_pb2_grpc.add_PostsServicer_to_server(PostsServicer(), server)
conversation_pb2_grpc.add_ConversationsServicer_to_server(
ConversationsServicer(), server)
topic_pb2_grpc.add_TopicsServicer_to_server(TopicsServicer(), server)
SERVICE_NAMES = (
post_pb2.DESCRIPTOR.services_by_name['Posts'].full_name,
conversation_pb2.DESCRIPTOR.services_by_name['Conversations'].
full_name,
topic_pb2.DESCRIPTOR.services_by_name['Topics'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port('[::]:50051')
server.start()
print('Prototype Server running ...')
try:
# need an infinite loop since the above
# code is non blocking, and if I don't do this
# the program will exit
while True:
time.sleep(60 * 60 * 60)
except KeyboardInterrupt:
server.stop(0)
print('Prototype Server Stopped ...')
def serve():
conf = config.get_global()
# Enable logging configuration
if conf.get('SET_LOGGING', True):
set_logger()
server_interceptor = _ServerInterceptor()
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=conf['MAX_WORKERS']),
interceptors=(server_interceptor,),
# options=_get_grpc_options(conf)
)
server, service_names = _init_services(server)
service_names_str = '\n\t - '.join(service_names)
_LOGGER.debug(f'Loaded Services: \n\t - {service_names_str}')
reflection.enable_server_reflection(service_names, server)
server.add_insecure_port(f'[::]:{conf["PORT"]}')
_LOGGER.info(f'Start gRPC Server ({config.get_service()}): '
f'port={conf["PORT"]}, max_workers={conf["MAX_WORKERS"]}')
server.start()
server.wait_for_termination()
async def async_setup(self):
"""Wait for the GRPC server to start"""
self._grpc_server = grpc.aio.server(options=[
('grpc.max_send_message_length', -1),
('grpc.max_receive_message_length', -1),
])
jina_pb2_grpc.add_JinaSingleDataRequestRPCServicer_to_server(
self, self._grpc_server)
jina_pb2_grpc.add_JinaDataRequestRPCServicer_to_server(
self, self._grpc_server)
jina_pb2_grpc.add_JinaControlRequestRPCServicer_to_server(
self, self._grpc_server)
jina_pb2_grpc.add_JinaDiscoverEndpointsRPCServicer_to_server(
self, self._grpc_server)
service_names = (
jina_pb2.DESCRIPTOR.services_by_name['JinaSingleDataRequestRPC'].
full_name,
jina_pb2.DESCRIPTOR.services_by_name['JinaDataRequestRPC'].
full_name,
jina_pb2.DESCRIPTOR.services_by_name['JinaControlRequestRPC'].
full_name,
jina_pb2.DESCRIPTOR.services_by_name['JinaDiscoverEndpointsRPC'].
full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(service_names, self._grpc_server)
bind_addr = f'0.0.0.0:{self.args.port}'
self._grpc_server.add_insecure_port(bind_addr)
self.logger.debug(f'start listening on {bind_addr}')
await self._grpc_server.start()
def _serve_single(
address: str,
add_services: t.Callable[[grpc.Server], None],
threads: int,
reflection_services: t.Iterable[str] = tuple(),
worker_id: int = 1,
):
"""Helper function to start a server for a single process.
Args:
address: Complete address consisting of hostname and port (e.g., `127.0.0.1:8000`)
add_services: Function to inject the gRPC services into the server instance.
threads: Number of workers for the ThreadPoolExecutor.
reflection_services: Name of all services this server offers.
"""
server = grpc.server(futures.ThreadPoolExecutor(max_workers=threads))
add_services(server)
if reflection_services:
reflection.enable_server_reflection(
[*reflection_services, reflection.SERVICE_NAME], server)
server.add_insecure_port(address)
server.start()
print(f"Worker {worker_id} serving on '{address}'.")
server.wait_for_termination()
def setUp(self):
self._server = test_common.test_server()
reflection.enable_server_reflection(_SERVICE_NAMES, self._server)
port = self._server.add_insecure_port('[::]:0')
self._server.start()
channel = grpc.insecure_channel('localhost:%d' % port)
self._stub = reflection_pb2_grpc.ServerReflectionStub(channel)
def setUp(self):
self._server = test_common.test_server()
reflection.enable_server_reflection(_SERVICE_NAMES, self._server)
port = self._server.add_insecure_port('[::]:0')
self._server.start()
channel = grpc.insecure_channel('localhost:%d' % port)
self._stub = reflection_pb2_grpc.ServerReflectionStub(channel)
def setup_reflection(self) -> None:
service_names = [
user_pb2.DESCRIPTOR.services_by_name["Users"].
full_name, # type: ignore
]
reflection.enable_server_reflection(service_names=service_names,
server=self.server)
async def setUp(self):
self._server = aio.server()
reflection.enable_server_reflection(_SERVICE_NAMES, self._server)
port = self._server.add_insecure_port('[::]:0')
await self._server.start()
self._channel = aio.insecure_channel('localhost:%d' % port)
self._stub = reflection_pb2_grpc.ServerReflectionStub(self._channel)
async def _async_setup_server(self):
request_handler = RequestHandler(self.metrics_registry, self.name)
self.streamer = RequestStreamer(
args=self.args,
request_handler=request_handler.handle_request(
graph=self._topology_graph,
connection_pool=self._connection_pool),
result_handler=request_handler.handle_result(),
)
self.streamer.Call = self.streamer.stream
jina_pb2_grpc.add_JinaRPCServicer_to_server(self.streamer, self.server)
jina_pb2_grpc.add_JinaGatewayDryRunRPCServicer_to_server(
self, self.server)
jina_pb2_grpc.add_JinaInfoRPCServicer_to_server(self, self.server)
service_names = (
jina_pb2.DESCRIPTOR.services_by_name['JinaRPC'].full_name,
jina_pb2.DESCRIPTOR.services_by_name['JinaGatewayDryRunRPC'].
full_name,
jina_pb2.DESCRIPTOR.services_by_name['JinaInfoRPC'].full_name,
reflection.SERVICE_NAME,
)
# Mark all services as healthy.
health_pb2_grpc.add_HealthServicer_to_server(self._health_servicer,
self.server)
for service in service_names:
self._health_servicer.set(service,
health_pb2.HealthCheckResponse.SERVING)
reflection.enable_server_reflection(service_names, self.server)
bind_addr = f'{__default_host__}:{self.args.port}'
if self.args.ssl_keyfile and self.args.ssl_certfile:
with open(self.args.ssl_keyfile, 'rb') as f:
private_key = f.read()
with open(self.args.ssl_certfile, 'rb') as f:
certificate_chain = f.read()
server_credentials = grpc.ssl_server_credentials(((
private_key,
certificate_chain,
), ))
self.server.add_secure_port(bind_addr, server_credentials)
elif (
self.args.ssl_keyfile != self.args.ssl_certfile
): # if we have only ssl_keyfile and not ssl_certfile or vice versa
raise ValueError(
f"you can't pass a ssl_keyfile without a ssl_certfile and vice versa"
)
else:
self.server.add_insecure_port(bind_addr)
self.logger.debug(f'start server bound to {bind_addr}')
await self.server.start()
def setUp(self):
server_pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY)
self._server = grpc.server(server_pool)
reflection.enable_server_reflection(_SERVICE_NAMES, self._server)
port = self._server.add_insecure_port('[::]:0')
self._server.start()
channel = grpc.insecure_channel('localhost:%d' % port)
self._stub = reflection_pb2_grpc.ServerReflectionStub(channel)
def setUp(self):
server_pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY)
self._server = grpc.server(server_pool)
reflection.enable_server_reflection(_SERVICE_NAMES, self._server)
port = self._server.add_insecure_port('[::]:0')
self._server.start()
channel = grpc.insecure_channel('localhost:%d' % port)
self._stub = reflection_pb2_grpc.ServerReflectionStub(channel)
def main():
server = grpc.server(futures.ThreadPoolExecutor())
reflection.enable_server_reflection(
(service_pb2.DESCRIPTOR.services_by_name['MyApp'].full_name, ), server)
app = MyApp()
service_pb2_grpc.add_MyAppServicer_to_server(app, server)
server.add_insecure_port(f'[::]:{app_port}')
server.start()
server.wait_for_termination()
def _add_features_processing_service_servicer_to_server(server: grpc.Server):
add_TweetFeaturesServiceServicer_to_server(TweetFeaturesService(), server)
# the reflection service will be aware of "StorageService" and "ServerReflection" services.
service_names = (
TweetFeaturesService_pb2.DESCRIPTOR.services_by_name['TweetFeaturesService'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(service_names, server)
logger.info("Activate reflection on server for services: {}".format(service_names))
async def start():
server = grpc.aio.server()
reflection.enable_server_reflection(
(service_pb2.DESCRIPTOR.services_by_name['MyApp'].full_name, ),
server)
app = MyApp()
service_pb2_grpc.add_MyAppServicer_to_server(app, server)
server.add_insecure_port(f'[::]:{app_port}')
await server.start()
await server.wait_for_termination()
def _mount_services(self):
transfer_service = TransferService(self.workflow, self.queue,
self.queue_executor)
transfer_service_api.service_pb2_grpc.add_TransferServiceServicer_to_server(
transfer_service, self.grpc_server)
services = tuple(
service.full_name for service in transfer_service_api.service_pb2.
DESCRIPTOR.services_by_name.values()) + (reflection.SERVICE_NAME, )
reflection.enable_server_reflection(services, self.grpc_server)
def start_yatai_service_grpc_server(db_url, repo_base_url, grpc_port, ui_port,
with_ui):
track_server('yatai-service-grpc-server')
yatai_service = get_yatai_service(db_url=db_url,
repo_base_url=repo_base_url)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
add_YataiServicer_to_server(yatai_service, server)
debug_mode = config().getboolean('core', 'debug')
if debug_mode:
try:
logger.debug('Enabling gRPC server reflection for debugging')
from grpc_reflection.v1alpha import reflection
from bentoml.proto import yatai_service_pb2
SERVICE_NAMES = (
yatai_service_pb2.DESCRIPTOR.services_by_name['Yatai'].
full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
except ImportError:
logger.debug(
'Failed enabling gRPC server reflection, missing required package: '
'"pip install grpcio-reflection"')
server.add_insecure_port(f'[::]:{grpc_port}')
server.start()
if with_ui:
web_ui_log_path = os.path.join(
config("logging").get("BASE_LOG_DIR"),
config('logging').get("yatai_web_server_log_filename"),
)
ensure_node_available_or_raise()
yatai_grpc_server_addess = f'localhost:{grpc_port}'
async_start_yatai_service_web_ui(yatai_grpc_server_addess, ui_port,
web_ui_log_path, debug_mode)
# We don't import _echo function from click_utils because of circular dep
click.echo(
f'* Starting BentoML YataiService gRPC Server\n'
f'* Debug mode: { "on" if debug_mode else "off"}\n'
f'* Web UI: {f"running on http://127.0.0.1:{ui_port}" if with_ui else "off"}\n'
f'* Running on 127.0.0.1:{grpc_port} (Press CTRL+C to quit)\n'
f'* Usage: `bentoml config set yatai_service.url=127.0.0.1:{grpc_port}`\n'
f'* Help and instructions: '
f'https://docs.bentoml.org/en/latest/concepts/yatai_service.html\n'
f'{f"* Web server log can be found here: {web_ui_log_path}" if with_ui else ""}'
)
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
logger.info("Terminating YataiService gRPC server..")
server.stop(grace=None)
def __connect(self):
print("attempting to connect to coreData")
# If the service is already registered, then exit
if self.state == State.Connected:
print("state reported as connected; thread closing")
return
# Get a registration and print the details.
# If the address was not received, then exit
while True:
try:
reg = self.__register(self._opts.standalone.coreAddress,
self._opts.service.name,
self._opts.service.aliases,
self._opts.service.peerGroups, self._env)
break
except:
pass
print("registration details:")
print("id=" + str(reg.id) + "; address=" + str(reg.address) +
"; fingerprint=" + reg.fingerprint)
if reg.address == "":
print("registration address not received")
return
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
intrigue_pb2_grpc.add_CabalServicer_to_server(serv.CabalServicer(),
server)
self.mu.acquire()
try:
self._registration = reg
self._con = connection(reg.address, server, False)
self.state = State.Connected
finally:
self.mu.release()
# Connect to server
if self._con._address == "":
raise Exception("connection.connect.noAddress")
reflection.enable_server_reflection(self._opts.service.name,
self._con._server)
server.add_insecure_port(self._con._address)
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except:
server.stop(0)
print("connected; coreAddress=(" + reg.address + ")")
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
keyval_pb2_grpc.add_KeyValueServicer_to_server(KeyValueServicer(), server)
SERVICE_NAMES = (
keyval_pb2.DESCRIPTOR.services_by_name['KeyValue'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port('localhost:%s' % PORT_NO)
server.start()
server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
SERVICE_NAMES = (
helloworld_pb2.DESCRIPTOR.services_by_name['Greeter'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port('[::]:50051')
server.start()
server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
SERVICE_NAMES = (
helloworld_pb2.DESCRIPTOR.services_by_name['Greeter'].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(SERVICE_NAMES, server)
server.add_insecure_port('[::]:50051')
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
greeter = Greeter()
helloworld_pb2_grpc.add_GreeterServicer_to_server(greeter, server)
server.add_insecure_port(listen_address)
reflection.enable_server_reflection(["helloworld.Greeter"], server)
server.start()
channel = grpc.insecure_channel('localhost:%d' % 50051)
reflection_pb2_grpc.ServerReflectionStub(channel)
try:
print("Server started, listening on: {}".format(listen_address))
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)