CODEWITHSUNDEEP
pythonpython-3.xgrpc
Samarendra
Samarendra

Reputation: 780

Grpc python client server streaming not working as expected

a simple grpc server client, client send a int and server streams int's back.

client is reading the messages one by one but server is running the generator function immediately for all responses.

server code: 

import test_pb2_grpc as pb_grpc
import test_pb2 as pb2
import time
import grpc
from concurrent import futures

class test_servcie(pb_grpc.TestServicer):

    def Produce(self, request, context):
        for i in range(request.val):
            print("request came")
            rs = pb2.Rs()
            rs.st = i + 1
            yield rs



    def serve():


        server = 
        grpc.server(futures.ThreadPoolExecutor(max_workers=10))
        pb_grpc.add_TestServicer_to_server(test_servcie(), server)
        server.add_insecure_port('[::]:50051')
        print("service started")
        server.start()
        try:
            while True:
                time.sleep(3600)
        except KeyboardInterrupt:
            server.stop(0)


if __name__ == '__main__':
    serve()

client code:

import grpc
import test_pb2_grpc as pb_grpc
import test_pb2 as pb
def test():
    channel = grpc.insecure_channel(
    '{host}:{port}'.format(host="localhost", port=50051))

    stub = pb_grpc.TestStub(channel=channel)

    req = pb.Rq()
    req.val = 20
    for s in stub.Produce(req):
        print(s.st)
        import time
        time.sleep(10)

test()

proto file: syntax = "proto3";

service Test {
    rpc Produce (Rq) returns (stream Rs);
}

message Rq{
    int32 val = 1;
}
message Rs{
    int32 st = 1;
}

after starting the server when i run the client, server side generator started running and completed immediately it looped for the range. what i expected is it will one by one as client calls but that is not the case. is this an expected behaviour. my client is still printing the values but the sever is already completed the function.

Upvotes: 3

Views: 4402

Answers (1)

Nathaniel Manista At Google
Nathaniel Manista At Google

Reputation: 2562

Yes, this behavior is expected. gRPC features flow control between the two sides of an RPC (so that generating messages too fast on one side won't exhaust memory on the other side) but there's also an allowance for a small amount of buffering (so that a reasonably small amount of data may be sent by one side before the other side explicitly asks for it). In your case the twenty messages sent from server to client all fit within this small allowance. The service-side gRPC Python runtime is calling your service-side Produce method, consuming its entire output of twenty messages, and sending all those messages across the network to your client, where they are locally held by the invocation-side gRPC Python runtime until your invocation-side test function asks for them.

If you want to see the effects of flow control in action, try using huge messages (one megabyte in size or so) or altering the size of the allowance (I think this is done with a channel argument but those are an advanced and relatively-unsupported feature so this is left as an exercise).

Upvotes: 4

Related Questions