include/grpcpp/impl/codegen/async_generic_service.h

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #ifndef GRPCPP_IMPL_CODEGEN_ASYNC_GENERIC_SERVICE_H
  20 #define GRPCPP_IMPL_CODEGEN_ASYNC_GENERIC_SERVICE_H
  21
  22 // IWYU pragma: private, include <grpcpp/generic/async_generic_service.h>
  23
  24 #include <grpc/impl/codegen/port_platform.h>
  25
  26 #include <grpcpp/impl/codegen/async_stream.h>
  27 #include <grpcpp/impl/codegen/byte_buffer.h>
  28 #include <grpcpp/impl/codegen/server_callback.h>
  29 #include <grpcpp/impl/codegen/server_callback_handlers.h>
  30
  31 struct grpc_server;
  32
  33 namespace grpc {
  34
  35 typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer>
  36     GenericServerAsyncReaderWriter;
  37 typedef ServerAsyncResponseWriter<ByteBuffer> GenericServerAsyncResponseWriter;
  38 typedef ServerAsyncReader<ByteBuffer, ByteBuffer> GenericServerAsyncReader;
  39 typedef ServerAsyncWriter<ByteBuffer> GenericServerAsyncWriter;
  40
  41 class GenericServerContext final : public ServerContext {
  42  public:
  43   const std::string& method() const { return method_; }
  44   const std::string& host() const { return host_; }
  45
  46  private:
  47   friend class ServerInterface;
  48
  49   std::string method_;
  50   std::string host_;
  51 };
  52
  53 // A generic service at the server side accepts all RPC methods and hosts. It is
  54 // typically used in proxies. The generic service can be registered to a server
  55 // which also has other services.
  56 // Sample usage:
  57 //   ServerBuilder builder;
  58 //   auto cq = builder.AddCompletionQueue();
  59 //   AsyncGenericService generic_service;
  60 //   builder.RegisterAsyncGenericService(&generic_service);
  61 //   auto server = builder.BuildAndStart();
  62 //
  63 //   // request a new call
  64 //   GenericServerContext context;
  65 //   GenericServerAsyncReaderWriter stream;
  66 //   generic_service.RequestCall(&context, &stream, cq.get(), cq.get(), tag);
  67 //
  68 // When tag is retrieved from cq->Next(), context.method() can be used to look
  69 // at the method and the RPC can be handled accordingly.
  70 class AsyncGenericService final {
  71  public:
  72   AsyncGenericService() : server_(nullptr) {}
  73
  74   void RequestCall(GenericServerContext* ctx,
  75                    GenericServerAsyncReaderWriter* reader_writer,
  76                    ::grpc::CompletionQueue* call_cq,
  77                    ::grpc::ServerCompletionQueue* notification_cq, void* tag);
  78
  79  private:
  80   friend class grpc::Server;
  81   grpc::Server* server_;
  82 };
  83
  84 /// \a ServerGenericBidiReactor is the reactor class for bidi streaming RPCs
  85 /// invoked on a CallbackGenericService. It is just a ServerBidi reactor with
  86 /// ByteBuffer arguments.
  87 using ServerGenericBidiReactor = ServerBidiReactor<ByteBuffer, ByteBuffer>;
  88
  89 class GenericCallbackServerContext final : public grpc::CallbackServerContext {
  90  public:
  91   const std::string& method() const { return method_; }
  92   const std::string& host() const { return host_; }
  93
  94  private:
  95   friend class ::grpc::Server;
  96
  97   std::string method_;
  98   std::string host_;
  99 };
 100
 101 /// \a CallbackGenericService is the base class for generic services implemented
 102 /// using the callback API and registered through the ServerBuilder using
 103 /// RegisterCallbackGenericService.
 104 class CallbackGenericService {
 105  public:
 106   CallbackGenericService() {}
 107   virtual ~CallbackGenericService() {}
 108
 109   /// The "method handler" for the generic API. This function should be
 110   /// overridden to provide a ServerGenericBidiReactor that implements the
 111   /// application-level interface for this RPC. Unimplemented by default.
 112   virtual ServerGenericBidiReactor* CreateReactor(
 113       GenericCallbackServerContext* /*ctx*/) {
 114     class Reactor : public ServerGenericBidiReactor {
 115      public:
 116       Reactor() { this->Finish(Status(StatusCode::UNIMPLEMENTED, "")); }
 117       void OnDone() override { delete this; }
 118     };
 119     return new Reactor;
 120   }
 121
 122  private:
 123   friend class grpc::Server;
 124
 125   internal::CallbackBidiHandler<ByteBuffer, ByteBuffer>* Handler() {
 126     return new internal::CallbackBidiHandler<ByteBuffer, ByteBuffer>(
 127         [this](::grpc::CallbackServerContext* ctx) {
 128           return CreateReactor(static_cast<GenericCallbackServerContext*>(ctx));
 129         });
 130   }
 131
 132   grpc::Server* server_{nullptr};
 133 };
 134
 135 }  // namespace grpc
 136
 137 #endif  // GRPCPP_IMPL_CODEGEN_ASYNC_GENERIC_SERVICE_H