#include <server_interface.h>
|
| virtual int | AddListeningPort (const std::string &addr, ServerCredentials *creds)=0 |
| |
| virtual int | max_receive_message_size () const =0 |
| |
| void | PerformOpsOnCall (internal::CallOpSetInterface *ops, internal::Call *call) override=0 |
| |
| virtual void | RegisterAsyncGenericService (AsyncGenericService *service)=0 |
| |
| virtual void | RegisterCallbackGenericService (CallbackGenericService *) |
| |
| virtual bool | RegisterService (const std::string *host, Service *service)=0 |
| |
| void | RequestAsyncCall (internal::RpcServiceMethod *method, grpc::ServerContext *context, internal::ServerAsyncStreamingInterface *stream, grpc::CompletionQueue *call_cq, grpc::ServerCompletionQueue *notification_cq, void *tag) |
| |
| template<class Message > |
| void | RequestAsyncCall (internal::RpcServiceMethod *method, grpc::ServerContext *context, internal::ServerAsyncStreamingInterface *stream, grpc::CompletionQueue *call_cq, grpc::ServerCompletionQueue *notification_cq, void *tag, Message *message) |
| |
| void | RequestAsyncGenericCall (GenericServerContext *context, internal::ServerAsyncStreamingInterface *stream, grpc::CompletionQueue *call_cq, grpc::ServerCompletionQueue *notification_cq, void *tag) |
| |
| virtual grpc_server * | server ()=0 |
| |
| virtual void | ShutdownInternal (gpr_timespec deadline)=0 |
| |
| virtual void | Start (grpc::ServerCompletionQueue **cqs, size_t num_cqs)=0 |
| |
◆ ~ServerInterface()
| grpc::ServerInterface::~ServerInterface |
( |
| ) |
|
|
inlineoverride |
◆ AddListeningPort()
Tries to bind server to the given addr.
It can be invoked multiple times.
- Parameters
-
| addr | The address to try to bind to the server (eg, localhost:1234, 192.168.1.1:31416, [::1]:27182, etc.). \params creds The credentials associated with the server. |
- Returns
- bound port number on success, 0 on failure.
- Warning
- It's an error to call this method on an already started server.
Implemented in grpc::Server.
◆ CallbackCQ()
◆ interceptor_creators()
◆ max_receive_message_size()
| virtual int grpc::ServerInterface::max_receive_message_size |
( |
| ) |
const |
|
protectedpure virtual |
◆ PerformOpsOnCall()
|
|
overrideprotectedpure virtual |
◆ RegisterAsyncGenericService()
| virtual void grpc::ServerInterface::RegisterAsyncGenericService |
( |
AsyncGenericService * |
service | ) |
|
|
protectedpure virtual |
Register a generic service. This call does not take ownership of the service. The service must exist for the lifetime of the Server instance.
Implemented in grpc::Server.
◆ RegisterCallbackGenericService()
Register a callback generic service. This call does not take ownership of the service. The service must exist for the lifetime of the Server instance. May not be abstract since this is a post-1.0 API addition.
Reimplemented in grpc::Server.
Definition at line 133 of file grpcpp/impl/codegen/server_interface.h.
◆ RegisterService()
| virtual bool grpc::ServerInterface::RegisterService |
( |
const std::string * |
host, |
|
|
Service * |
service |
|
) |
| |
|
protectedpure virtual |
Register a service. This call does not take ownership of the service. The service must exist for the lifetime of the Server instance.
Implemented in grpc::Server.
◆ RequestAsyncCall() [1/2]
◆ RequestAsyncCall() [2/2]
◆ RequestAsyncGenericCall()
◆ server()
◆ Shutdown() [1/2]
| void grpc::ServerInterface::Shutdown |
( |
| ) |
|
|
inline |
◆ Shutdown() [2/2]
template<class T >
| void grpc::ServerInterface::Shutdown |
( |
const T & |
deadline | ) |
|
|
inline |
Shutdown does the following things:
- Shutdown the server: deactivate all listening ports, mark it in "shutdown mode" so that further call Request's or incoming RPC matches are no longer allowed. Also return all Request'ed-but-not-yet-active calls as failed (!ok). This refers to calls that have been requested at the server by the server-side library or application code but that have not yet been matched to incoming RPCs from the client. Note that this would even include default calls added automatically by the gRPC C++ API without the user's input (e.g., "Unimplemented RPC method")
- Block until all rpc method handlers invoked automatically by the sync API finish.
- If all pending calls complete (and all their operations are retrieved by Next) before deadline expires, this finishes gracefully. Otherwise, forcefully cancel all pending calls associated with the server after deadline expires. In the case of the sync API, if the RPC function for a streaming call has already been started and takes a week to complete, the RPC function won't be forcefully terminated (since that would leave state corrupt and incomplete) and the method handler will just keep running (which will prevent the server from completing the "join" operation that it needs to do at shutdown time).
All completion queue associated with the server (for example, for async serving) must be shutdown after this method has returned: See ServerBuilder::AddCompletionQueue for details. They must also be drained (by repeated Next) after being shutdown.
- Parameters
-
| deadline | How long to wait until pending rpcs are forcefully terminated. |
Definition at line 98 of file grpcpp/impl/codegen/server_interface.h.
◆ ShutdownInternal()
| virtual void grpc::ServerInterface::ShutdownInternal |
( |
gpr_timespec |
deadline | ) |
|
|
protectedpure virtual |
◆ Start()
Start the server.
- Parameters
-
| cqs | Completion queues for handling asynchronous services. The caller is required to keep all completion queues live until the server is destroyed. |
| num_cqs | How many completion queues does cqs hold. |
Implemented in grpc::Server.
◆ Wait()
| virtual void grpc::ServerInterface::Wait |
( |
| ) |
|
|
pure virtual |
Block waiting for all work to complete.
- Warning
- The server must be either shutting down or some other thread must call Shutdown for this function to ever return.
Implemented in grpc::Server.
◆ grpc::Service
The documentation for this class was generated from the following file:
Public Member Functions inherited from grpc::internal::CallHook