server.h File Reference

Type-safe method-model server (handler side) for VLink RPC. More...

#include <functional>
#include <memory>
#include <string>
#include "./impl/server_impl.h"
#include "./node.h"
#include "./internal/server-inl.h"

Include dependency graph for server.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	vlink::Server< ReqT, RespT, SecT >
	Type-safe server for the VLink method (RPC) communication model. More...
class	vlink::SecurityServer< ReqT, RespT >
	Convenience alias for Server with message security enabled. More...

Namespaces
namespace	vlink

Detailed Description

Type-safe method-model server (handler side) for VLink RPC.

Server<ReqT, RespT, SecT> is the handler side of the VLink method model. It registers a callback that is invoked for each incoming request and optionally fills a response.

Method Model Overview

Client<Req,Resp>                                       Server<Req,Resp>
    |                   Transport Back-end                   |
    |-- invoke(req) -------> |                               |
    |   serialize(req)       |-- request delivery ---------> |
    |                        |                               |--> callback(req, resp)
    |                        | <-- reply(resp) ------------- |
    |   deserialize(resp)    | <-- response delivery ------- |
    |<-- resp ----------------                               |

Three Listen Modes

Method	When to use
listen(ReqCallback)	Fire-and-forget.
listen(ReqRespCallback)	Synchronous reply inside the callback.
listen_for_reply(ReqAsyncRespCallback)	Async reply via reply().

Synchronous Reply Example

Server<Req, Resp> server("dds://my_service");
server.listen([](const Req& req, Resp& resp) {
    resp.result = process(req);       // fill resp inside callback
});

Asynchronous Reply Example

Server<Req, Resp> server("dds://my_service");
uint64_t saved_req_id = 0;
server.listen_for_reply([&saved_req_id](uint64_t req_id, const Req& req) {
    saved_req_id = req_id;            // save request ID for later
});
// ... later, from any thread:
server.reply(saved_req_id, Resp{...});

Fire-and-forget Example (no response)

Server<Req> server("dds://my_service");   // RespT defaults to EmptyType
server.listen([](const Req& req) {
    handle(req);
});

Note

Calling listen() / listen_for_reply() more than once is fatal. reply() must only be called after listen_for_reply(); calling it after a synchronous listen() triggers a fatal log.

Template Parameters

ReqT	Request message type. Must satisfy Serializer::is_supported().
RespT	Response message type. Defaults to Traits::EmptyType (no response).
SecT	Security mode; defaults to SecurityType::kWithoutSecurity.