Différences

Ci-dessous, les différences entre deux révisions de la page.

--- prog:protobuf [2018/08/18 15:57] – Distinction entre proto2 et proto3 root
+++ prog:protobuf [2018/09/22 22:59] (Version actuelle) – [Protocol Buffers] : ajout de "Emplacement du .pb.* généré" root
@@ Ligne 1: / Ligne 1: @@
-====Protocol Buffers====
+=====Protocol Buffers=====
-===Cas simple===
+====Cas simple====
 Le format de base est simple. [[https://developers.google.com/protocol-buffers/docs/proto|Language Guide Proto 2 | Protocol Buffers ]], [[https://developers.google.com/protocol-buffers/docs/proto3|Language Guide Proto 3 | Protocol Buffers ]]
@@ Ligne 21: / Ligne 21: @@
 </code>
-===Import===
+====Import====
 Il est possible de créer des structures plus complexes avec des sous niveaux et d'importer les messages d'autres fichiers.
@@ Ligne 51: / Ligne 51: @@
 </code>
-===Évolutions===
+====Subtilités====
+===Emplacement du .pb.* généré===
+Si le fichier ''.proto'' est dans un sous dossier, cela dépend le fichier est dans un ''-I''.
+Généré dans le dossier ''tests/pattern/abstract_factory'' :
+  /usr/bin/protoc --cpp_out=tests -I tests tests/pattern/abstract_factory/abstract_factory.proto
+Généré dans ''tests'' :
+  /usr/bin/protoc --cpp_out=tests -I tests/pattern/abstract_factory tests/pattern/abstract_factory/abstract_factory.proto
+====Évolutions====
   * proto2 :
     * Il faut toujours mettre ''optional'' pour les champs non répétés. Il est déconseillé d'utiliser un champ ''required'' car un champ peut évoluer et devenir ''optional'' au profit d'un autre. Ces deux champs ont disparu dans ''proto3'' et ''optional'' est appliqué.
@@ Ligne 104: / Ligne 114: @@
 </code>
+===Serveur===
+Il faut implémenter une classe héritant la classe de service.
+<code cpp>
+class GreeterImpl : public llgc::protobuf::test::Greeter::Service
+{
+  // La méthode par défaut renvoie UNIMPLEMENTED.
+  // À chaque fois qu'un client appelle cette méthode,
+  // le serveur lance un thread pour exécuter la fonction Talk.
+  // Il peut y avoir en simultanée autant de threads que de clients.
+  // Tant que cette méthode n'est pas terminée, la connexion avec le
+  // client reste active.
+  // Tous les threads travaillent sur la même instance de la classe.
+  ::grpc::Status Talk(::grpc::ServerContext* context,
+  ::grpc::ServerReaderWriter< ::llgc::protobuf::test::Rpc,
+  ::llgc::protobuf::test::Rpc>* stream) override
+  {
+    ::llgc::protobuf::test::Rpc message;
+    // Tant que le client n'a pas fermé la connexion, on reste dans
+    // l'attente de ces messages.
+    while (stream->Read(&message))
+    {
+      // Ici, on répond au message.
+      stream->Write(message);
+      // La réponse est facultative. Ça dépend de ce que la
+      // fonction doit faire.
+    }
+    // Fermeture de la connexion à l'initiative du serveur.
+    // Dans notre cas précis, le client a déjà terminé puisque
+    // stream->Read s'est interrompu.
+    return grpc::Status::OK;
+  }
+}
+// Pour instancier le serveur
+GreeterImpl service;
+// Le builder n'a besoin d'exister que jusqu'à la commande BuildAndStart.
+ServerBuilder builder;
+builder.AddListeningPort("0.0.0.0:1234", grpc::InsecureServerCredentials());
+builder.RegisterService(&service);
+// La variable service doit exister tant que l'instance du serveur existe.
+std::unique_ptr<Server> server(builder.BuildAndStart());
+// Lancement du serveur. Fonction bloquante.
+// Peut être lancée dans un thread.
+server->Wait();
+// Pour arrêter le serveur (depuis un autre thread que celui
+// ayant lancé la méthode Wait).
+server->Shutdown();
+</code>
+===Client===
+<code cpp>
+// Création du client.
+std::shared_ptr<grpc::Channel> channel =
+  grpc::CreateChannel("localhost:1234",
+  grpc::InsecureChannelCredentials());
+std::unique_ptr<llgc::protobuf::test::Greeter::Stub> stub =
+  llgc::protobuf::test::Greeter::NewStub(channel);
+grpc::ClientContext context;
+std::shared_ptr<grpc::ClientReaderWriter<::llgc::protobuf::test::Rpc,
+  ::llgc::protobuf::test::Rpc> > stream = stub->Talk(&context);
+// Communication avec le serveur.
+::llgc::protobuf::test::Rpc message;
+// Envoie un message au serveur.
+stream->Write(message);
+// Ferme la communication avec le serveur dans le sens client vers serveur.
+stream->WritesDone();
+// Attente de la réponse de façon bloquante.
+stream->Read(&message);
+// Pour arrêter un Read bloquant, il faut lancer depuis un autre thread
+context.TryCancel();
+// Ferme la communication.
+// L'appel à Finish fait que la fonction stream->Read coté serveur
+// va échouer mais ne sera plus bloquante.
+if (!stream->Finish().ok())
+  std::cout << "Erreur" << std::endl;
+</code>