evrpc.h File Reference

This header files provides basic support for an RPC server and client. More...

#include <event2/event_struct.h>

Go to the source code of this file.

Data Structures

struct evrpc

struct evrpc_status

provides information about the completed RPC request. More...

Defines

#define EVRPC_GENERATE(rpcname, reqstruct, rplystruct)

Generates the code for receiving and sending an RPC message.

#define EVRPC_HEADER(rpcname, reqstruct, rplystruct)

Creates the definitions and prototypes for an RPC.

#define EVRPC_MAKE_CTX(rpcname, reqstruct, rplystruct, pool, request, reply, cb, cbarg)

Creates a context structure that contains rpc specific information.

#define EVRPC_MAKE_REQUEST(name, pool, request, reply, cb, cbarg)   evrpc_send_request_##name(pool, request, reply, cb, cbarg)

launches an RPC and sends it to the server

#define EVRPC_REGISTER(base, name, request, reply, callback, cbarg)

register RPCs with the HTTP Server

#define EVRPC_REGISTER_OBJECT(rpc, name, request, reply)

#define EVRPC_REQUEST_DONE(rpc_req)

Creates the reply to an RPC request.

#define EVRPC_REQUEST_HTTP(rpc_req)   (rpc_req)->http_req

Provides access to the HTTP request object underlying an RPC.

#define EVRPC_STATUS_ERR_BADPAYLOAD   2

#define EVRPC_STATUS_ERR_HOOKABORTED   4

#define EVRPC_STATUS_ERR_NONE   0

#define EVRPC_STATUS_ERR_TIMEOUT   1

#define EVRPC_STATUS_ERR_UNSTARTED   3

#define EVRPC_STRUCT(rpcname)   struct evrpc_req__##rpcname

The type of a specific RPC Message.

#define EVRPC_UNREGISTER(base, name)   evrpc_unregister_rpc(base, #name)

Unregisters an already registered RPC.

#define INPUT   EVRPC_INPUT

Deprecated alias for EVRPC_INPUT.

#define OUTPUT   EVRPC_OUTPUT

Deprecated alias for EVRPC_OUTPUT.

Enumerations

enum EVRPC_HOOK_RESULT { EVRPC_TERMINATE = -1, EVRPC_CONTINUE = 0, EVRPC_PAUSE = 1 }

Return value from hook processing functions. More...

enum EVRPC_HOOK_TYPE { EVRPC_INPUT, EVRPC_OUTPUT }

Hooks for changing the input and output of RPCs; this can be used to implement compression, authentication, encryption, . More...

Functions

void * evrpc_add_hook (void *vbase, enum EVRPC_HOOK_TYPE hook_type, int(*cb)(void *, struct evhttp_request *, struct evbuffer *, void *), void *cb_arg)

adds a processing hook to either an rpc base or rpc pool

void evrpc_free (struct evrpc_base *base)

Frees the evrpc base.

void evrpc_hook_add_meta (void *ctx, const char *key, const void *data, size_t data_size)

adds meta data to request

int evrpc_hook_find_meta (void *ctx, const char *key, void **data, size_t *data_size)

retrieves meta data previously associated

struct evhttp_connection * evrpc_hook_get_connection (void *ctx)

returns the connection object associated with the request

struct evrpc_base * evrpc_init (struct evhttp *server)

Creates a new rpc base from which RPC requests can be received.

int evrpc_make_request (struct evrpc_request_wrapper *)

struct evrpc_request_wrapper * evrpc_make_request_ctx (struct evrpc_pool *pool, void *request, void *reply, const char *rpcname, void(*req_marshal)(struct evbuffer *, void *), void(*rpl_clear)(void *), int(*rpl_unmarshal)(void *, struct evbuffer *), void(*cb)(struct evrpc_status *, void *, void *, void *), void *cbarg)

use EVRPC_GENERATE instead

void evrpc_pool_add_connection (struct evrpc_pool *pool, struct evhttp_connection *evcon)

Adds a connection over which rpc can be dispatched to the pool.

void evrpc_pool_free (struct evrpc_pool *pool)

frees an rpc connection pool

struct evrpc_pool * evrpc_pool_new (struct event_base *base)

creates an rpc connection pool

void evrpc_pool_remove_connection (struct evrpc_pool *pool, struct evhttp_connection *evcon)

Removes a connection from the pool.

void evrpc_pool_set_timeout (struct evrpc_pool *pool, int timeout_in_secs)

Sets the timeout in secs after which a request has to complete.

int evrpc_register_rpc (struct evrpc_base *, struct evrpc *, void(*)(struct evrpc_req_generic *, void *), void *)

int evrpc_remove_hook (void *vbase, enum EVRPC_HOOK_TYPE hook_type, void *handle)

removes a previously added hook

void evrpc_request_done (struct evrpc_req_generic *req)

completes the server response to an rpc request

struct evrpc_pool * evrpc_request_get_pool (struct evrpc_request_wrapper *ctx)

accessors for obscure and undocumented functionality

void evrpc_request_set_cb (struct evrpc_request_wrapper *ctx, void(*cb)(struct evrpc_status *, void *request, void *reply, void *arg), void *cb_arg)

void evrpc_request_set_pool (struct evrpc_request_wrapper *ctx, struct evrpc_pool *pool)

int evrpc_resume_request (void *vbase, void *ctx, enum EVRPC_HOOK_RESULT res)

resume a paused request

int evrpc_unregister_rpc (struct evrpc_base *base, const char *name)

Detailed Description

This header files provides basic support for an RPC server and client.

To support RPCs in a server, every supported RPC command needs to be defined and registered.

EVRPC_HEADER(SendCommand, Request, Reply);

SendCommand is the name of the RPC command. Request is the name of a structure generated by event_rpcgen.py. It contains all parameters relating to the SendCommand RPC. The server needs to fill in the Reply structure. Reply is the name of a structure generated by event_rpcgen.py. It contains the answer to the RPC.

To register an RPC with an HTTP server, you need to first create an RPC base with:

struct evrpc_base *base = evrpc_init(http);

A specific RPC can then be registered with

EVRPC_REGISTER(base, SendCommand, Request, Reply, FunctionCB, arg);

when the server receives an appropriately formatted RPC, the user callback is invokved. The callback needs to fill in the reply structure.

void FunctionCB(EVRPC_STRUCT(SendCommand)* rpc, void *arg);

To send the reply, call EVRPC_REQUEST_DONE(rpc);

See the regression test for an example.

Define Documentation

#define EVRPC_GENERATE	(	rpcname,
		reqstruct,
		rplystruct	)

Value:

int evrpc_send_request_##rpcname(struct evrpc_pool *pool, \
    struct reqstruct *request, struct rplystruct *reply, \
    void (*cb)(struct evrpc_status *, \
        struct reqstruct *, struct rplystruct *, void *cbarg),  \
    void *cbarg) { \
        struct evrpc_status status;                                 \
        struct evrpc_request_wrapper *ctx;                          \
        ctx = evrpc_make_request_ctx(pool, request, reply,          \
            #rpcname,                                               \
            (void (*)(struct evbuffer *, void *))reqstruct##_marshal, \
            (void (*)(void *))rplystruct##_clear, \
            (int (*)(void *, struct evbuffer *))rplystruct##_unmarshal, \
            (void (*)(struct evrpc_status *, void *, void *, void *))cb, \
            cbarg);                                                     \
        if (ctx == NULL)                                            \
                goto error;                                         \
        return (evrpc_make_request(ctx));                           \
error:                                                              \
        memset(&status, 0, sizeof(status));                         \
        status.error = EVRPC_STATUS_ERR_UNSTARTED;                  \
        (*(cb))(&status, request, reply, cbarg);                    \
        return (-1);                                                \
}

Generates the code for receiving and sending an RPC message.

EVRPC_GENERATE is used to create the code corresponding to sending and receiving a particular RPC message

Parameters:

	rpcname	the name of the RPC
	reqstruct	the name of the RPC request structure
	replystruct	the name of the RPC reply structure

See also:: EVRPC_HEADER()

#define EVRPC_HEADER	(	rpcname,
		reqstruct,
		rplystruct	)

Value:

EVRPC_STRUCT(rpcname) { \
        struct evrpc_hook_meta *hook_meta; \
        struct reqstruct* request; \
        struct rplystruct* reply; \
        struct evrpc* rpc; \
        struct evhttp_request* http_req; \
        struct evbuffer* rpc_data; \
};                                                                   \
int evrpc_send_request_##rpcname(struct evrpc_pool *, \
    struct reqstruct *, struct rplystruct *, \
    void (*)(struct evrpc_status *, \
        struct reqstruct *, struct rplystruct *, void *cbarg),  \
    void *);

Creates the definitions and prototypes for an RPC.

You need to use EVRPC_HEADER to create structures and function prototypes needed by the server and client implementation. The structures have to be defined in an .rpc file and converted to source code via event_rpcgen.py

Parameters:

	rpcname	the name of the RPC
	reqstruct	the name of the RPC request structure
	replystruct	the name of the RPC reply structure

See also:: EVRPC_GENERATE()

#define EVRPC_MAKE_CTX	(	rpcname,
		reqstruct,
		rplystruct,
		pool,
		request,
		reply,
		cb,
		cbarg	)

Value:

evrpc_make_request_ctx(pool, request, reply,                    \
            #rpcname,                                                   \
            (void (*)(struct evbuffer *, void *))reqstruct##_marshal,   \
            (void (*)(void *))rplystruct##_clear,                       \
            (int (*)(void *, struct evbuffer *))rplystruct##_unmarshal, \
            (void (*)(struct evrpc_status *, void *, void *, void *))cb, \
            cbarg)

Creates a context structure that contains rpc specific information.

EVRPC_MAKE_CTX is used to populate a RPC specific context that contains information about marshaling the RPC data types.

Parameters:

	rpcname	the name of the RPC
	reqstruct	the name of the RPC request structure
	replystruct	the name of the RPC reply structure
	pool	the evrpc_pool over which to make the request
	request	a pointer to the RPC request structure object
	reply	a pointer to the RPC reply structure object
	cb	the callback function to call when the RPC has completed
	cbarg	the argument to supply to the callback

#define EVRPC_MAKE_REQUEST	(	name,
		pool,
		request,
		reply,
		cb,
		cbarg	)	evrpc_send_request_##name(pool, request, reply, cb, cbarg)

launches an RPC and sends it to the server

EVRPC_MAKE_REQUEST() is used by the client to send an RPC to the server.

Parameters:

	name	the name of the RPC
	pool	the evrpc_pool that contains the connection objects over which the request should be sent.
	request	a pointer to the RPC request structure - it contains the data to be sent to the server.
	reply	a pointer to the RPC reply structure. It is going to be filled if the request was answered successfully
	cb	the callback to invoke when the RPC request has been answered
	cbarg	an additional argument to be passed to the client

Returns:: 0 on success, -1 on failure

#define EVRPC_REGISTER	(	base,
		name,
		request,
		reply,
		callback,
		cbarg	)

Value:

do { \
    struct evrpc* rpc = (struct evrpc *)calloc(1, sizeof(struct evrpc)); \
    EVRPC_REGISTER_OBJECT(rpc, name, request, reply); \
    evrpc_register_rpc(base, rpc, \
        (void (*)(struct evrpc_req_generic*, void *))callback, cbarg);  \
  } while (0)

register RPCs with the HTTP Server

registers a new RPC with the HTTP server, each RPC needs to have a unique name under which it can be identified.

Parameters:

	base	the evrpc_base structure in which the RPC should be registered.
	name	the name of the RPC
	request	the name of the RPC request structure
	reply	the name of the RPC reply structure
	callback	the callback that should be invoked when the RPC is received. The callback has the following prototype void (callback)(EVRPC_STRUCT(Message) rpc, void *arg)
	cbarg	an additional parameter that can be passed to the callback. The parameter can be used to carry around state.

#define EVRPC_REGISTER_OBJECT	(	rpc,
		name,
		request,
		reply	)

Value:

do { \
    (rpc)->uri = strdup(#name); \
    if ((rpc)->uri == NULL) {                    \
      fprintf(stderr, "failed to register object\n");   \
      exit(1);                                          \
    } \
    (rpc)->request_new = (void *(*)(void))request##_new; \
    (rpc)->request_free = (void (*)(void *))request##_free; \
    (rpc)->request_unmarshal = (int (*)(void *, struct evbuffer *))request##_unmarshal; \
    (rpc)->reply_new = (void *(*)(void))reply##_new; \
    (rpc)->reply_free = (void (*)(void *))reply##_free; \
    (rpc)->reply_complete = (int (*)(void *))reply##_complete; \
    (rpc)->reply_marshal = (void (*)(struct evbuffer*, void *))reply##_marshal; \
  } while (0)

#define EVRPC_REQUEST_DONE ( rpc_req )

Value:

do { \
  struct evrpc_req_generic *_req = (struct evrpc_req_generic *)(rpc_req); \
  evrpc_request_done(_req);                                     \
} while (0)

Creates the reply to an RPC request.

EVRPC_REQUEST_DONE is used to answer a request; the reply is expected to have been filled in. The request and reply pointers become invalid after this call has finished.

Parameters:

rpc_req

the rpc request structure provided to the server callback

#define EVRPC_REQUEST_HTTP ( rpc_req ) (rpc_req)->http_req

Provides access to the HTTP request object underlying an RPC.

Access to the underlying http object; can be used to look at headers or for getting the remote ip address

Parameters:

rpc_req

the rpc request structure provided to the server callback

Returns:: an struct evhttp_request object that can be inspected for HTTP headers or sender information.

#define EVRPC_STRUCT ( rpcname ) struct evrpc_req__##rpcname

The type of a specific RPC Message.

Parameters:

rpcname

the name of the RPC message

#define EVRPC_UNREGISTER	(	base,
		name		)	evrpc_unregister_rpc(base, #name)

Unregisters an already registered RPC.

Parameters:

	base	the evrpc_base object from which to unregister an RPC
	name	the name of the rpc to unregister

Returns:: -1 on error or 0 when successful.

See also:: EVRPC_REGISTER()

#define INPUT EVRPC_INPUT

Deprecated alias for EVRPC_INPUT.

Not available on windows, where it conflicts with platform headers.

#define OUTPUT EVRPC_OUTPUT

Deprecated alias for EVRPC_OUTPUT.

Not available on windows, where it conflicts with platform headers.

Enumeration Type Documentation

enum EVRPC_HOOK_RESULT

Return value from hook processing functions.

Enumerator:

EVRPC_TERMINATE	indicates the rpc should be terminated
EVRPC_CONTINUE	continue processing the rpc
EVRPC_PAUSE	pause processing request until resumed

enum EVRPC_HOOK_TYPE

Hooks for changing the input and output of RPCs; this can be used to implement compression, authentication, encryption, .

..

Enumerator:

EVRPC_INPUT	apply the function to an input hook
EVRPC_OUTPUT	apply the function to an output hook

Function Documentation

void* evrpc_add_hook	(	void *	vbase,
		enum EVRPC_HOOK_TYPE	hook_type,
		int()(void , struct evhttp_request , struct evbuffer , void *)	cb,
		void *	cb_arg
	)

adds a processing hook to either an rpc base or rpc pool

If a hook returns TERMINATE, the processing is aborted. On CONTINUE, the request is immediately processed after the hook returns. If the hook returns PAUSE, request processing stops until evrpc_resume_request() has been called.

The add functions return handles that can be used for removing hooks.

Parameters:

	vbase	a pointer to either struct evrpc_base or struct evrpc_pool
	hook_type	either INPUT or OUTPUT
	cb	the callback to call when the hook is activated
	cb_arg	an additional argument for the callback

Returns:: a handle to the hook so it can be removed later

See also:: evrpc_remove_hook()

void evrpc_free ( struct evrpc_base * base )

Frees the evrpc base.

For now, you are responsible for making sure that no rpcs are ongoing.

Parameters:

base

the evrpc_base object to be freed

See also:: evrpc_init

void evrpc_hook_add_meta	(	void *	ctx,
		const char *	key,
		const void *	data,
		size_t	data_size
	)

adds meta data to request

evrpc_hook_add_meta() allows hooks to add meta data to a request. for a client requet, the meta data can be inserted by an outgoing request hook and retrieved by the incoming request hook.

Parameters:

	ctx	the context provided to the hook call
	key	a NUL-terminated c-string
	data	the data to be associated with the key
	data_size	the size of the data

int evrpc_hook_find_meta	(	void *	ctx,
		const char *	key,
		void **	data,
		size_t *	data_size
	)

retrieves meta data previously associated

evrpc_hook_find_meta() can be used to retrieve meta data associated to a request by a previous hook.

Parameters:

	ctx	the context provided to the hook call
	key	a NUL-terminated c-string
	data	pointer to a data pointer that will contain the retrieved data
	data_size	pointer tothe size of the data

Returns:: 0 on success or -1 on failure

struct evhttp_connection* evrpc_hook_get_connection ( void * ctx ) [read]

returns the connection object associated with the request

Parameters:

ctx

the context provided to the hook call

Returns:: a pointer to the evhttp_connection object

struct evrpc_base* evrpc_init ( struct evhttp * server ) [read]

Creates a new rpc base from which RPC requests can be received.

Parameters:

server

a pointer to an existing HTTP server

Returns:: a newly allocated evrpc_base struct

See also:: evrpc_free()

void evrpc_pool_add_connection	(	struct evrpc_pool *	pool,
		struct evhttp_connection *	evcon
	)

Adds a connection over which rpc can be dispatched to the pool.

The connection object must have been newly created.

Parameters:

	pool	the pool to which to add the connection
	evcon	the connection to add to the pool.

void evrpc_pool_free ( struct evrpc_pool * pool )

frees an rpc connection pool

Parameters:

pool

a pointer to an evrpc_pool allocated via evrpc_pool_new()

See also:: evrpc_pool_new()

struct evrpc_pool* evrpc_pool_new ( struct event_base * base ) [read]

creates an rpc connection pool

a pool has a number of connections associated with it. rpc requests are always made via a pool.

Parameters:

base

a pointer to an struct event_based object; can be left NULL in singled-threaded applications

Returns:: a newly allocated struct evrpc_pool object

See also:: evrpc_pool_free()

void evrpc_pool_remove_connection	(	struct evrpc_pool *	pool,
		struct evhttp_connection *	evcon
	)

Removes a connection from the pool.

The connection object must have been newly created.

Parameters:

	pool	the pool from which to remove the connection
	evcon	the connection to remove from the pool.

void evrpc_pool_set_timeout	(	struct evrpc_pool *	pool,
		int	timeout_in_secs
	)

Sets the timeout in secs after which a request has to complete.

The RPC is completely aborted if it does not complete by then. Setting the timeout to 0 means that it never timeouts and can be used to implement callback type RPCs.

Any connection already in the pool will be updated with the new timeout. Connections added to the pool after set_timeout has be called receive the pool timeout only if no timeout has been set for the connection itself.

Parameters:

	pool	a pointer to a struct evrpc_pool object
	timeout_in_secs	the number of seconds after which a request should timeout and a failure be returned to the callback.

int evrpc_remove_hook	(	void *	vbase,
		enum EVRPC_HOOK_TYPE	hook_type,
		void *	handle
	)

removes a previously added hook

Parameters:

	vbase	a pointer to either struct evrpc_base or struct evrpc_pool
	hook_type	either INPUT or OUTPUT
	handle	a handle returned by evrpc_add_hook()

Returns:: 1 on success or 0 on failure

See also:: evrpc_add_hook()

int evrpc_resume_request	(	void *	vbase,
		void *	ctx,
		enum EVRPC_HOOK_RESULT	res
	)

resume a paused request

Parameters:

	vbase	a pointer to either struct evrpc_base or struct evrpc_pool
	ctx	the context pointer provided to the original hook call


Data Structures
struct	evrpc
struct	evrpc_status
	provides information about the completed RPC request. More...
Defines
#define	EVRPC_GENERATE(rpcname, reqstruct, rplystruct)
	Generates the code for receiving and sending an RPC message.
#define	EVRPC_HEADER(rpcname, reqstruct, rplystruct)
	Creates the definitions and prototypes for an RPC.
#define	EVRPC_MAKE_CTX(rpcname, reqstruct, rplystruct, pool, request, reply, cb, cbarg)
	Creates a context structure that contains rpc specific information.
#define	EVRPC_MAKE_REQUEST(name, pool, request, reply, cb, cbarg) evrpc_send_request_##name(pool, request, reply, cb, cbarg)
	launches an RPC and sends it to the server
#define	EVRPC_REGISTER(base, name, request, reply, callback, cbarg)
	register RPCs with the HTTP Server
#define	EVRPC_REGISTER_OBJECT(rpc, name, request, reply)
#define	EVRPC_REQUEST_DONE(rpc_req)
	Creates the reply to an RPC request.
#define	EVRPC_REQUEST_HTTP(rpc_req) (rpc_req)->http_req
	Provides access to the HTTP request object underlying an RPC.
#define	EVRPC_STATUS_ERR_BADPAYLOAD 2
#define	EVRPC_STATUS_ERR_HOOKABORTED 4
#define	EVRPC_STATUS_ERR_NONE 0
#define	EVRPC_STATUS_ERR_TIMEOUT 1
#define	EVRPC_STATUS_ERR_UNSTARTED 3
#define	EVRPC_STRUCT(rpcname) struct evrpc_req__##rpcname
	The type of a specific RPC Message.
#define	EVRPC_UNREGISTER(base, name) evrpc_unregister_rpc(base, #name)
	Unregisters an already registered RPC.
#define	INPUT EVRPC_INPUT
	Deprecated alias for EVRPC_INPUT.
#define	OUTPUT EVRPC_OUTPUT
	Deprecated alias for EVRPC_OUTPUT.
Enumerations
enum	EVRPC_HOOK_RESULT { EVRPC_TERMINATE = -1, EVRPC_CONTINUE = 0, EVRPC_PAUSE = 1 }
	Return value from hook processing functions. More...
enum	EVRPC_HOOK_TYPE { EVRPC_INPUT, EVRPC_OUTPUT }
	Hooks for changing the input and output of RPCs; this can be used to implement compression, authentication, encryption, . More...
Functions
void *	evrpc_add_hook (void vbase, enum EVRPC_HOOK_TYPE hook_type, int(cb)(void , struct evhttp_request , struct evbuffer , void ), void *cb_arg)
	adds a processing hook to either an rpc base or rpc pool
void	evrpc_free (struct evrpc_base *base)
	Frees the evrpc base.
void	evrpc_hook_add_meta (void ctx, const char key, const void *data, size_t data_size)
	adds meta data to request
int	evrpc_hook_find_meta (void ctx, const char key, void *data, size_t data_size)
	retrieves meta data previously associated
struct evhttp_connection *	evrpc_hook_get_connection (void *ctx)
	returns the connection object associated with the request
struct evrpc_base *	evrpc_init (struct evhttp *server)
	Creates a new rpc base from which RPC requests can be received.
int	evrpc_make_request (struct evrpc_request_wrapper *)
struct evrpc_request_wrapper *	evrpc_make_request_ctx (struct evrpc_pool pool, void request, void reply, const char rpcname, void(req_marshal)(struct evbuffer , void ), void(rpl_clear)(void ), int(rpl_unmarshal)(void , struct evbuffer ), void(cb)(struct evrpc_status , void , void , void ), void cbarg)
	use EVRPC_GENERATE instead
void	evrpc_pool_add_connection (struct evrpc_pool pool, struct evhttp_connection evcon)
	Adds a connection over which rpc can be dispatched to the pool.
void	evrpc_pool_free (struct evrpc_pool *pool)
	frees an rpc connection pool
struct evrpc_pool *	evrpc_pool_new (struct event_base *base)
	creates an rpc connection pool
void	evrpc_pool_remove_connection (struct evrpc_pool pool, struct evhttp_connection evcon)
	Removes a connection from the pool.
void	evrpc_pool_set_timeout (struct evrpc_pool *pool, int timeout_in_secs)
	Sets the timeout in secs after which a request has to complete.
int	evrpc_register_rpc (struct evrpc_base , struct evrpc , void()(struct evrpc_req_generic , void ), void )
int	evrpc_remove_hook (void vbase, enum EVRPC_HOOK_TYPE hook_type, void handle)
	removes a previously added hook
void	evrpc_request_done (struct evrpc_req_generic *req)
	completes the server response to an rpc request
struct evrpc_pool *	evrpc_request_get_pool (struct evrpc_request_wrapper *ctx)
	accessors for obscure and undocumented functionality
void	evrpc_request_set_cb (struct evrpc_request_wrapper ctx, void(cb)(struct evrpc_status , void request, void reply, void arg), void *cb_arg)
void	evrpc_request_set_pool (struct evrpc_request_wrapper ctx, struct evrpc_pool pool)
int	evrpc_resume_request (void vbase, void ctx, enum EVRPC_HOOK_RESULT res)
	resume a paused request
int	evrpc_unregister_rpc (struct evrpc_base base, const char name)