simplify ALTS client

examples/python/data_transmission/alts_client.py

@@ -1,4 +1,4 @@
-# Copyright 2019 gRPC authors.
+# Copyright 2020 gRPC authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,107 +11,24 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""The example of four ways of data transmission using gRPC in Python."""
+"""The example of using ALTS credentials to setup gRPC client."""
 
 import time
 import grpc
 
+import client
 import demo_pb2_grpc
 import demo_pb2
 
 SERVER_ADDRESS = "localhost:23333"
-CLIENT_ID = 1
-
-# 中文注释和英文翻译
-# Note that this example was contributed by an external user using Chinese comments.
-# In all cases, the Chinese comment text is translated to English just below it.
-
-
-# 一元模式(在一次调用中, 客户端只能向服务器传输一次请求数据, 服务器也只能返回一次响应)
-# unary-unary(In a single call, the client can only send request once, and the server can
-# only respond once.)
-def simple_method(stub):
-    print("--------------Call SimpleMethod Begin--------------")
-    request = demo_pb2.Request(client_id=CLIENT_ID,
-                               request_data="called by Python client")
-    response = stub.SimpleMethod(request)
-    print("resp from server(%d), the message=%s" %
-          (response.server_id, response.response_data))
-    print("--------------Call SimpleMethod Over---------------")
-
-
-# 客户端流模式（在一次调用中, 客户端可以多次向服务器传输数据, 但是服务器只能返回一次响应）
-# stream-unary (In a single call, the client can transfer data to the server several times,
-# but the server can only return a response once.)
-def client_streaming_method(stub):
-    print("--------------Call ClientStreamingMethod Begin--------------")
-
-    # 创建一个生成器
-    # create a generator
-    def request_messages():
-        for i in range(5):
-            request = demo_pb2.Request(
-                client_id=CLIENT_ID,
-                request_data=("called by Python client, message:%d" % i))
-            yield request
-
-    response = stub.ClientStreamingMethod(request_messages())
-    print("resp from server(%d), the message=%s" %
-          (response.server_id, response.response_data))
-    print("--------------Call ClientStreamingMethod Over---------------")
-
-
-# 服务端流模式（在一次调用中, 客户端只能一次向服务器传输数据, 但是服务器可以多次返回响应）
-# unary-stream (In a single call, the client can only transmit data to the server at one time,
-# but the server can return the response many times.)
-def server_streaming_method(stub):
-    print("--------------Call ServerStreamingMethod Begin--------------")
-    request = demo_pb2.Request(client_id=CLIENT_ID,
-                               request_data="called by Python client")
-    response_iterator = stub.ServerStreamingMethod(request)
-    for response in response_iterator:
-        print("recv from server(%d), message=%s" %
-              (response.server_id, response.response_data))
-
-    print("--------------Call ServerStreamingMethod Over---------------")
-
-
-# 双向流模式 (在一次调用中, 客户端和服务器都可以向对方多次收发数据)
-# stream-stream (In a single call, both client and server can send and receive data
-# to each other multiple times.)
-def bidirectional_streaming_method(stub):
-    print(
-        "--------------Call BidirectionalStreamingMethod Begin---------------")
-
-    # 创建一个生成器
-    # create a generator
-    def request_messages():
-        for i in range(5):
-            request = demo_pb2.Request(
-                client_id=CLIENT_ID,
-                request_data=("called by Python client, message: %d" % i))
-            yield request
-            time.sleep(1)
-
-    response_iterator = stub.BidirectionalStreamingMethod(request_messages())
-    for response in response_iterator:
-        print("recv from server(%d), message=%s" %
-              (response.server_id, response.response_data))
-
-    print("--------------Call BidirectionalStreamingMethod Over---------------")
-
 
 def main():
     with grpc.secure_channel(SERVER_ADDRESS, credentials=grpc.alts_channel_credentials()) as channel:
         stub = demo_pb2_grpc.GRPCDemoStub(channel)
-
-        simple_method(stub)
-
-        client_streaming_method(stub)
-
-        server_streaming_method(stub)
-
-        bidirectional_streaming_method(stub)
+        client.simple_method(stub)
+        client.client_streaming_method(stub)
+        client.server_streaming_method(stub)
+        client.bidirectional_streaming_method(stub)
 
 
 if __name__ == '__main__':

examples/python/data_transmission/alts_server.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""The example of four ways of data transmission using gRPC in Python."""
+"""The example of using ALTS credentials to setup gRPC server in python."""
 
 from threading import Thread
 from concurrent import futures
@@ -19,95 +19,18 @@ from concurrent import futures
 import grpc
 import demo_pb2_grpc
 import demo_pb2
+import server
 
 SERVER_ADDRESS = 'localhost:23333'
-SERVER_ID = 1
-
-
-class DemoServer(demo_pb2_grpc.GRPCDemoServicer):
-
-    # 一元模式(在一次调用中, 客户端只能向服务器传输一次请求数据, 服务器也只能返回一次响应)
-    # unary-unary(In a single call, the client can only send request once, and the server can
-    # only respond once.)
-    def SimpleMethod(self, request, context):
-        print("SimpleMethod called by client(%d) the message: %s" %
-              (request.client_id, request.request_data))
-        response = demo_pb2.Response(
-            server_id=SERVER_ID,
-            response_data="Python server SimpleMethod Ok!!!!")
-        return response
-
-    # 客户端流模式（在一次调用中, 客户端可以多次向服务器传输数据, 但是服务器只能返回一次响应）
-    # stream-unary (In a single call, the client can transfer data to the server several times,
-    # but the server can only return a response once.)
-    def ClientStreamingMethod(self, request_iterator, context):
-        print("ClientStreamingMethod called by client...")
-        for request in request_iterator:
-            print("recv from client(%d), message= %s" %
-                  (request.client_id, request.request_data))
-        response = demo_pb2.Response(
-            server_id=SERVER_ID,
-            response_data="Python server ClientStreamingMethod ok")
-        return response
-
-    # 服务端流模式（在一次调用中, 客户端只能一次向服务器传输数据, 但是服务器可以多次返回响应）
-    # unary-stream (In a single call, the client can only transmit data to the server at one time,
-    # but the server can return the response many times.)
-    def ServerStreamingMethod(self, request, context):
-        print("ServerStreamingMethod called by client(%d), message= %s" %
-              (request.client_id, request.request_data))
-
-        # 创建一个生成器
-        # create a generator
-        def response_messages():
-            for i in range(5):
-                response = demo_pb2.Response(
-                    server_id=SERVER_ID,
-                    response_data=("send by Python server, message=%d" % i))
-                yield response
-
-        return response_messages()
-
-    # 双向流模式 (在一次调用中, 客户端和服务器都可以向对方多次收发数据)
-    # stream-stream (In a single call, both client and server can send and receive data
-    # to each other multiple times.)
-    def BidirectionalStreamingMethod(self, request_iterator, context):
-        print("BidirectionalStreamingMethod called by client...")
-
-        # 开启一个子线程去接收数据
-        # Open a sub thread to receive data
-        def parse_request():
-            for request in request_iterator:
-                print("recv from client(%d), message= %s" %
-                      (request.client_id, request.request_data))
-
-        t = Thread(target=parse_request)
-        t.start()
-
-        for i in range(5):
-            yield demo_pb2.Response(
-                server_id=SERVER_ID,
-                response_data=("send by Python server, message= %d" % i))
-
-        t.join()
 
 
 def main():
-    server = grpc.server(futures.ThreadPoolExecutor())
-
-    demo_pb2_grpc.add_GRPCDemoServicer_to_server(DemoServer(), server)
-
-    server.add_secure_port(SERVER_ADDRESS, server_credentials=grpc.alts_server_credentials())
+    svr = grpc.server(futures.ThreadPoolExecutor())
+    demo_pb2_grpc.add_GRPCDemoServicer_to_server(server.DemoServer(), svr)
+    svr.add_secure_port(SERVER_ADDRESS, server_credentials=grpc.alts_server_credentials())
     print("------------------start Python GRPC server with ALTS encryption")
-    server.start()
-    server.wait_for_termination()
-
-    # If raise Error:
-    #   AttributeError: '_Server' object has no attribute 'wait_for_termination'
-    # You can use the following code instead:
-    # import time
-    # while 1:
-    #     time.sleep(10)
+    svr.start()
+    svr.wait_for_termination()
 
 
 if __name__ == '__main__':