Comment implémenter la diffusion gRPC serveur-client avec une interrogation longue ?

Diffusion du serveur vers le client gRPC

Dans gRPC, un défi courant survient lors de la diffusion d'événements du serveur vers plusieurs clients connectés. La question présentée cherche à obtenir des conseils sur la manière d'y parvenir à l'aide de flux, en particulier lorsque le serveur sait qui est connecté et comment s'adresser à chaque client.

Utiliser une approche d'interrogation longue

Une solution alternative aux flux consiste à mettre en œuvre une approche d'interrogation longue. Cette technique implique que les clients envoient des requêtes continues au serveur, ce qui maintient la connexion active. Lorsqu'un événement se produit sur le serveur, il avertit tous les clients en attente, les invitant à mettre fin et à créer une nouvelle demande.

Exemple de code pour une interrogation longue

Ce qui suit Un exemple de code illustre comment l'interrogation longue peut être implémentée en Python :

Définitions .PROTO

<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>

Code du serveur

<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>

Thème séparé dans le 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>

Cet exemple montre comment les clients peuvent utiliser l'interrogation longue pour recevoir des mises à jour sans flux initiés par le serveur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!