Files
grpc/examples/python/flow_control/flow_control_server.py
Sreenithi Sridharan 7ff0c56ebd Added Python Example for Flow Control (#37044)
Have added the required client, server, proto and proto generated files.
The design of the example is as follows:

1. The client sends a bulk amount of data(approx. 2 KB in each
iteration) to the server in a streaming call.
2. The server applies back-pressure by delaying reading of the requests,
which makes the client pause sending requests after around 64KB
3. The client then resumes sending requests only after the server reads
a few requests and clears the buffer.

By adding print statements on data send/receive on both client and
server side, the client pausing/resuming requests can be seen clearly.
The client and server logs can be seen below:

**Client Logs**
```
Request 10: Sent 20000 bytes in total
Request 20: Sent 40000 bytes in total
Request 30: Sent 60000 bytes in total
Request 40: Sent 80000 bytes in total
Received 10 responses

Request 50: Sent 100000 bytes in total
Received 20 responses

Request 60: Sent 120000 bytes in total
Received 30 responses

Request 70: Sent 140000 bytes in total
Received 40 responses

Request 80: Sent 160000 bytes in total
Received 50 responses

Request 90: Sent 180000 bytes in total
Received 60 responses

Request 100: Sent 200000 bytes in total
Received 70 responses

Received 80 responses

Received 90 responses

Received 100 responses
```

**Server Logs**
```
Server started, listening on 50051
Request 10: Received 20000 bytes in total
Request 10: Sent 20000 bytes in total

Request 20: Received 40000 bytes in total
Request 20: Sent 40000 bytes in total

Request 30: Received 60000 bytes in total
Request 30: Sent 60000 bytes in total

Request 40: Received 80000 bytes in total
Request 40: Sent 80000 bytes in total

Request 50: Received 100000 bytes in total
Request 50: Sent 100000 bytes in total

Request 60: Received 120000 bytes in total
Request 60: Sent 120000 bytes in total

Request 70: Received 140000 bytes in total
Request 70: Sent 140000 bytes in total

Request 80: Received 160000 bytes in total
Request 80: Sent 160000 bytes in total

Request 90: Received 180000 bytes in total
Request 90: Sent 180000 bytes in total

Request 100: Received 200000 bytes in total
Request 100: Sent 200000 bytes in total
```
2024-07-02 21:49:39 -07:00

81 lines
2.5 KiB
Python

# Copyright 2024 gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# 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.
"""Example gRPC server that applies back-pressure on client"""
from concurrent import futures
import logging
import time
import grpc
import helloworld_pb2
import helloworld_pb2_grpc
import helpers
_PORT = "50051"
class Greeter(helloworld_pb2_grpc.GreeterServicer):
def SayHelloBidiStream(self, request_iterator, unused_context):
# Delay read on server side to apply back-pressure on client
time.sleep(5)
bytes_received = 0
# Read request from client on every iteration
for i, request in enumerate(request_iterator, start=1):
bytes_received += len(request.name)
if (i % 10) == 0:
print(
f"{helpers.get_current_time()} "
f"Request {i}: Received {bytes_received} bytes in total"
)
# Simulate server "work"
time.sleep(1)
# Send a response
msg = "Hello!"
yield helloworld_pb2.HelloReply(message=msg)
if (i % 10) == 0:
print(
f"{helpers.get_current_time()} "
f"Request {i}: Sent {bytes_received} bytes in total\n"
)
def serve():
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10),
# Setting server options to minimal, to allow low number of maximum
# bytes in the window.
# `bdp_probe` is set to 0(false) to disable resizing of window
options=[
("grpc.http2.max_frame_size", 16384),
("grpc.http2.bdp_probe", 0),
("grpc.max_concurrent_streams", 1),
],
)
helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
server.add_insecure_port("[::]:" + _PORT)
server.start()
print("Server started, listening on " + _PORT)
server.wait_for_termination()
if __name__ == "__main__":
logging.basicConfig()
serve()