Broadcasting in gRPC: Server to Client Communication

When establishing a gRPC connection, it's often necessary to broadcast events or updates from the server to connected clients. To achieve this, various approaches can be employed.

Stream Observables

One common approach is to utilize server-side streams. Each connected client establishes its own stream with the server. However, subscribing to other server-client streams directly is not feasible.

Long-Polling

An alternative option is to implement a long-polling approach. This involves having clients continuously poll the server at regular intervals, checking for new updates. Upon receiving an update, the client will receive a response and wait for the next polling interval.

Example Implementation

Here's an example of how you might implement long-polling using gRPC:

Server-Side Code

import threading

class UpdaterServer:
    def __init__(self):
        self.condition = threading.Condition()
        self.updates = []

    def post_update(self, update):
        with self.condition:
            self.updates.append(updates)
            self.condition.notify_all()

    def GetUpdates(self, req, context):
        with self.condition:
            while self.updates[req.last_received_update   1:] == []:
                self.condition.wait()
            new_updates = self.updates[req.last_received_update   1:]
            return GetUpdatesResponse(
                updates=new_updates,
                update_index=req.last_received_update   len(new_updates),
            )

Client-Side Code (Separate Thread)

from threading import Event

def handle_updates(updates):
    pass

event = Event()
request = GetUpdatesRequest(last_received_update=-1)

while not event.is_set():
    try:
        stub = UpdaterStub(channel)
        response = stub.GetUpdates(request, timeout=60*10)
        handle_updates(response.updates)
        request.last_received_update = response.update_index
    except grpc.FutureTimeoutError:
        pass

By implementing this approach, connected clients can retrieve updates from the server in a continuous fashion.