def serve():
# 启动 rpc 服务
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
# 下面这段是处理TSL用的 TSL >>>
with open('./ca/server.pem', 'rb') as f:
private_key = f.read()
with open('./ca/server.crt', 'rb') as f:
certificate_chain = f.read()
with open('./ca/ca.crt', 'rb') as f:
root_certificates = f.read()
server_credentials = grpc.ssl_server_credentials(
((private_key, certificate_chain), ), root_certificates, True)
server.add_secure_port('[::]:39901', server_credentials)
# 处理TSL结束 TSL <<<
# server.add_insecure_port('[::]:39901')
server.start()
print('grpc server start...!')
try:
while True:
time.sleep(60 * 60 * 24) # one day in seconds
except KeyboardInterrupt:
server.stop(0)
def serve_ssl():
print('Starting up grpc server (ssl)...', os.getpid())
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
private_key_file = 'self.key'
with open(private_key_file, 'rb') as f:
private_key = f.read()
cert_file = 'self.crt'
with open(cert_file, 'rb') as f:
cert_chain = f.read()
server_cred = grpc.ssl_server_credentials(((
private_key,
cert_chain,
), ))
server.add_secure_port('[::]:16506', server_cred)
server.start()
print('Started at', 'localhost:16506 (ssl)', os.getpid())
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
print('Stoping grpc server ', os.getpid(), 'localhost:50051')
server.stop(0)
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()
async def serve() -> None:
server = grpc.aio.server()
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
listen_addr = '[::]:50051'
server.add_insecure_port(listen_addr)
await server.start()
await server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port(f'[::]:{_PORT}')
print(f'Running gRPC server at port {_PORT}')
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)
server.add_insecure_port('[::]:9090')
server.start()
print("Python backend server started, listening on port 9090!")
server.wait_for_termination()
def serve():
print('--- Starting gRPC server')
server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
server.start()
server.wait_for_termination()
def sslServe():
with open('server.key', 'rb') as f:
private_key = f.read()
with open('server.crt', 'rb') as f:
certificate_chain = f.read()
server_credentials = grpc.ssl_server_credentials(((
private_key,
certificate_chain,
), ))
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
#service_pb2_grpc.add_ServerServicer_to_server(ServerServicer(), server)
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_secure_port('[::]:' + port, server_credentials)
server.start()
print("Server started")
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def serve(num):
server = grpc.server(futures.ThreadPoolExecutor(max_workers=2000), options=[('grpc.so_reuseport', 1)])
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(num), server)
server.add_insecure_port('[::]:50051')
server.start()
print(f"Server {num} started.")
server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:%s' % PORT)
server.start()
print 'Python gRPC server listening on: %s!' % PORT
time.sleep(DAY_IN_SECONDS)
def serve(workers: int):
server = grpc.server(futures.ThreadPoolExecutor(max_workers=workers))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
server.start()
print('run server port 50051')
server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
## server.add_insecure_port('[::]:22222')
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)
server.add_insecure_port(port)
server.start()
print("Listening on ", port)
server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
server.start()
print('Server started, you may start the client(s) now.')
server.wait_for_termination()
def serve():
# read in certificate
trusted_file = 'keys/ca.crt'
keyfile = 'keys/server.key'
certfile = 'keys/server.crt'
try:
with open(trusted_file, 'rb') as f:
trusted_certs = f.read()
with open(keyfile, 'rb') as f:
server_key = f.read()
with open(certfile, 'rb') as f:
server_cert = f.read()
except Exception as e:
log.error('failed-to-read-cert-keys', reason=e)
# create credentials
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server_cred = grpc.ssl_server_credentials([(server_key, server_cert)], trusted_certs)
server.add_secure_port('localhost:50051', server_cred)
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))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
port = os.getenv("PORT", "50051")
server.add_insecure_port('[::]:'+port)
server.start()
server.wait_for_termination()
async def serve():
server = grpc.aio.server()
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
listen_addr = '[::]:50051'
server.add_insecure_port(listen_addr)
logging.info("Starting server on %s", listen_addr)
await server.start()
await server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50054')
server.start()
print('gRPC 服务端已开启，端口为50054...')
server.wait_for_termination()
def _make_test_backend(self) -> Backend:
server = grpc.server(
concurrent.futures.ThreadPoolExecutor(max_workers=2))
backend = HelloWorldServicer()
helloworld_pb2_grpc.add_GreeterServicer_to_server(backend, server)
listen_port = server.add_insecure_port("[::1]:0")
server.start()
return Backend(server, backend, listen_port)
def main() -> None:
addr = "localhost:8001"
server = grpc.server(concurrent.futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(ErrorGreeter(), server)
print("listening for gRPC on {} ...".format(addr))
server.add_insecure_port(addr)
server.start()
server.wait_for_termination()
def _listening_server():
server = grpc.server(futures.ThreadPoolExecutor())
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
port = server.add_insecure_port(_SERVER_ADDRESS)
server.start()
try:
yield port
finally:
server.stop(0)
async def serve() -> None:
uds_addresses = ['unix:helloworld.sock', 'unix:///tmp/helloworld.sock']
server = grpc.aio.server()
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
for uds_address in uds_addresses:
server.add_insecure_port(uds_address)
logging.info('Server listening on: %s', uds_address)
await server.start()
await server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
server.start()
# server.wait_for_termination()
import time
while True:
time.sleep(100220)
def serve():
header_validator = RequestHeaderValidatorInterceptor(
'one-time-password', '42', grpc.StatusCode.UNAUTHENTICATED,
'Access denied!')
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
interceptors=(header_validator, ))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
server.start()
server.wait_for_termination()
def main():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
if True:
port = server.add_insecure_port('[::]:50051')
else:
port = server.add_insecure_port('[::]:0')
print('Listening port: {}'.format(port))
server.start()
server.wait_for_termination()
def serve():
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10),
interceptors=[ProcessInterceptor()],
)
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
server.start()
print("gRPC Service Hello world started")
server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) #DUDA PERSISTENTE CON RESPECTO AL NUMERO DE TRABAJADORES DEL HILO
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051') #PUERTO X //NO IMPORTA EL NUMERO
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))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), 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))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), 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))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
grpc_endpoint = '127.0.0.1:50051' if len(sys.argv) == 1 else sys.argv[1]
server.add_insecure_port(grpc_endpoint)
server.start()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
def serve():
# 启动 rpc 服务
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:5005')
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # one day in seconds
except KeyboardInterrupt:
server.stop(0)
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('[::]:50051')
server.start()
# gRPC starts a new thread to service requests. Just make the main thread
# sleep.
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(grace=0)
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():
header_validator = RequestHeaderValidatorInterceptor(
'one-time-password', '42', grpc.StatusCode.UNAUTHENTICATED,
'Access denied!')
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10),
interceptors=(header_validator,))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), 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))
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port('127.0.0.1:50051')
server.start()
p1 = multiprocessing.Process(target=child_client_call)
p1.start()
p1.join(timeout=60)
if p1.is_alive():
print('call timeout.')
pstack()
p1.terminate()
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)
def serve():
server = grpc.server(ThreadPoolExecutor(max_workers=10))
helloworld_pb2_grpc.add_GreeterServicer_to_server(
HelloServicer(), server)
address = '[::]:50051'
print('listen on {}'.format(address))
server.add_insecure_port(address)
def run(server):
print('create process pid = {}'.format(os.getpid()))
server.start()
while True:
try:
time.sleep(3600)
except KeyboardInterrupt:
break
server.stop(0)
print('master pid = {}'.format(os.getpid()))
ts = []
for i in range(4):
t = multiprocessing.Process(target=run, args=(server,))
t.start()
ts.append(t)
# see also https://github.com/grpc/grpc/issues/10084
# otherwise you be caught error
# E1128 13:49:24.647594000 4728202688 server.cc:1330]
# assertion failed: gpr_atm_acq_load(&server->shutdown_flag) || !server->listeners
server.start()
server.stop(0)
for t in ts:
t.join()
print('exit')
