Wie implementiert man gRPC-Server-zu-Client-Broadcasting mit Long-Polling?

gRPC-Server-zu-Client-Broadcasting

Bei gRPC entsteht eine häufige Herausforderung, wenn Ereignisse vom Server an mehrere verbundene Clients übertragen werden. Die gestellte Frage sucht nach Anleitung, wie dies mithilfe von Streams erreicht werden kann, insbesondere wenn der Server weiß, wer verbunden ist und wie er jeden Client ansprechen soll.

Verwenden Sie einen Long-Polling-Ansatz

Eine alternative Lösung zu Streams ist die Implementierung eines Long-Polling-Ansatzes. Bei dieser Technik senden Clients fortlaufend Anfragen an den Server, wodurch die Verbindung aufrechterhalten wird. Wenn auf dem Server ein Ereignis auftritt, werden alle wartenden Clients benachrichtigt und aufgefordert, den Vorgang zu beenden und eine neue Anfrage zu erstellen.

Codebeispiel für Long-Polling

Das Folgende Codebeispiel veranschaulicht, wie Long-Polling in Python implementiert werden kann:

.PROTO Definitions

<code class=".PROTO">service Updater {
    rpc GetUpdates(GetUpdatesRequest) returns (GetUpdatesResponse);
}

message GetUpdatesRequest {
    int64 last_received_update = 1;
}

message GetUpdatesResponse {
    repeated Update updates = 1;
    int64 update_index = 2;
}

message Update {
    // Your update structure
}</code>

Servercode

<code class="python">class UpdaterServer(UpdaterServicer):
    def __init__(self):
        self.condition = threading.Condition()
        self.updates = []

    def post_update(self, update):
        with self.condition:
            # Remove old updates after some time
            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:]
            response = GetUpdatesResponse()
            for update in new_updates:
                response.updates.add().CopyFrom(update)
            response.update_index = req.last_received_update + len(new_updates)
            return response</code>

Separater Thread im Client

<code class="python">request = GetUpdatesRequest()
request.last_received_update = -1
while True:
    stub = UpdaterStub(channel)
    try:
        response = stub.GetUpdates(request, timeout=60*10)
        handle_updates(response.updates)
        request.last_received_update = response.update_index
    except grpc.FutureTimeoutError:
        pass</code>

Dieses Beispiel zeigt, wie Clients Long-Polling verwenden können, um Updates ohne serverinitiierte Streams zu empfangen.

Das obige ist der detaillierte Inhalt vonWie implementiert man gRPC-Server-zu-Client-Broadcasting mit Long-Polling?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!