X-Git-Url: http://git.samba.org/?a=blobdiff_plain;f=include%2Fctdb.h;h=c95c2e1e26796fc7af934e2077678435e3109a86;hb=d5413f066cb0ef80ebfaf1fdc62481b9b9fa3221;hp=bd4fdc12b16cef47bae226d0b6840f9e3fece611;hpb=d41b802250ddc0a89581eb6285edfd66bdc7a78a;p=sahlberg%2Fctdb.git diff --git a/include/ctdb.h b/include/ctdb.h index bd4fdc12..c95c2e1e 100644 --- a/include/ctdb.h +++ b/include/ctdb.h @@ -23,213 +23,748 @@ #include #include #include +#include +#include #include +#include +#include -/* All *_send() functions are guaranteed to be non-blocking and fully - * asynchronous. The non-_send variants are synchronous. */ +/** + * ctdb - a library for accessing tdbs controlled by ctdbd + * + * ctdbd (clustered tdb daemon) is a daemon designed to syncronize TDB + * databases across a cluster. Using this library, you can communicate with + * the daemon to access the databases, pass messages across the cluster, and + * control the daemon itself. + * + * The general API is event-driven and asynchronous: you call the + * *_send functions, supplying callbacks, then when the ctdbd file + * descriptor is usable, call ctdb_service() to perform read from it + * and call your callbacks, which use the *_recv functions to unpack + * the replies from ctdbd. + * + * There is also a synchronous wrapper for each function for trivial + * programs; these can be found in the section marked "Synchronous API". + */ -/* - * Connect to ctdb using the specified domain socket. - * Returns a ctdb context if successful or NULL. +/** + * ctdb_log_fn_t - logging function for ctdbd + * @log_priv: private (typesafe) arg via ctdb_connect + * @severity: syslog-style severity + * @format: printf-style format string. + * @ap: arguments for formatting. + * + * The severity passed to log() are as per syslog(3). In particular, + * LOG_DEBUG is used for tracing, LOG_WARNING is used for unusual + * conditions which don't necessarily return an error through the API, + * LOG_ERR is used for errors such as lost communication with ctdbd or + * out-of-memory, LOG_ALERT is used for library usage bugs, LOG_CRIT is + * used for libctdb internal consistency checks. + * + * The log() function can be typesafe: the @log_priv arg to + * ctdb_donnect and signature of log() should match. + */ +typedef void (*ctdb_log_fn_t)(void *log_priv, + int severity, const char *format, va_list ap); + +/** + * ctdb_connect - connect to ctdb using the specified domain socket. + * @addr: the socket address, or NULL for default + * @log: the logging function + * @log_priv: the private argument to the logging function. + * + * Returns a ctdb context if successful or NULL. Use ctdb_disconnect() to + * release the returned ctdb_connection when finished. + * + * See Also: + * ctdb_log_fn_t, ctdb_log_file() + */ +struct ctdb_connection *ctdb_connect(const char *addr, + ctdb_log_fn_t log_fn, void *log_priv); + +/** + * ctdb_log_file - example logging function + * + * Logs everything at priority LOG_WARNING or above to the file given (via + * the log_priv argument, usually stderr). + */ +void ctdb_log_file(FILE *, int, const char *, va_list); + +/** + * ctdb_log_level - level at which to call logging function + * + * This variable globally controls filtering on the logging function. + * It is initialized to LOG_WARNING, meaning that strange but nonfatal + * events, as well as errors and API misuses are reported. * - * Use ctdb_free() to release the returned ctdb_connection when finished. + * Set it to LOG_DEBUG to receive all messages. */ -struct ctdb_connection *ctdb_connect(const char *addr); +extern int ctdb_log_level; + +/** + * ctdb_disconnect - close down a connection to ctdbd. + * @ctdb: the ctdb connectio returned from ctdb_connect. + * + * The @ctdb arg will be freed by this call, and must not be used again. + */ +void ctdb_disconnect(struct ctdb_connection *ctdb); + +/*** + * + * Asynchronous API + * + ***/ +/** + * ctdb_get_fd - get the filedescriptor to select/poll on + * @ctdb: the ctdb_connection from ctdb_connect. + * + * By using poll or select on this file descriptor, you will know when to call + * ctdb_service(). + * + * See Also: + * ctdb_which_events(), ctdb_service() + */ int ctdb_get_fd(struct ctdb_connection *ctdb); +/** + * ctdb_which_events - determine which events ctdb_service wants to see + * @ctdb: the ctdb_connection from ctdb_connect. + * + * This returns POLLIN, possibly or'd with POLLOUT if there are writes + * pending. You can set this straight into poll.events. + * + * See Also: + * ctdb_service() + */ int ctdb_which_events(struct ctdb_connection *ctdb); -int ctdb_service(struct ctdb_connection *ctdb, int revents); +/** + * ctdb_service - service any I/O and callbacks from ctdbd communication + * @ctdb: the ctdb_connection from ctdb_connect. + * @revents: which events are available. + * + * This is the core of the library: it read and writes to the ctdbd + * socket. It may call callbacks registered with the various _send + * functions. + * + * revents is a bitset: POLLIN and/or POLLOUT may be set to indicate + * it is worth attempting to read/write the (nonblocking) + * filedescriptor respectively. + * + * Note that the synchronous functions call this internally. + * Returns false on catastrophic failure. + */ +bool ctdb_service(struct ctdb_connection *ctdb, int revents); +/** + * struct ctdb_request - handle for an outstanding request + * + * This opaque structure returned from various *_send functions gives + * you a handle by which you can cancel a request. You can't do + * anything else with it until the request is completed and it is + * handed to your callback function. + */ struct ctdb_request; -void ctdb_request_free(struct ctdb_request *req); - -/* - * Callback for completed requests: it would normally unpack the request - * using ctdb_*_recv(). You must free the request using ctdb_request_free(). +/** + * ctdb_request_free - free a completed request * - * Note that due to macro magic, your callback doesn't have to take void *, - * it can take a type which matches the actual private parameter. + * This frees a request: you should only call it once it has been + * handed to your callback. For incomplete requests, see ctdb_cancel(). */ -typedef void (*ctdb_callback_t)(struct ctdb_connection *ctdb, - struct ctdb_request *req, void *private); +void ctdb_request_free(struct ctdb_connection *ctdb, struct ctdb_request *req); -/* - * Special node addresses : +/** + * ctdb_callback_t - callback for completed requests. + * + * This would normally unpack the request using ctdb_*_recv(). You + * must free the request using ctdb_request_free(). + * + * Note that due to macro magic, actual your callback can be typesafe: + * instead of taking a void *, it can take a type which matches the + * actual private parameter. */ -/* used on the domain socket, send a pdu to the local daemon */ -#define CTDB_CURRENT_NODE 0xF0000001 -/* send a broadcast to all nodes in the cluster, active or not */ -#define CTDB_BROADCAST_ALL 0xF0000002 -/* send a broadcast to all nodes in the current vnn map */ -#define CTDB_BROADCAST_VNNMAP 0xF0000003 -/* send a broadcast to all connected nodes */ -#define CTDB_BROADCAST_CONNECTED 0xF0000004 - +typedef void (*ctdb_callback_t)(struct ctdb_connection *ctdb, + struct ctdb_request *req, void *private_data); -/* - * functions to attach to a database - * if the database does not exist it will be created. +/** + * struct ctdb_db - connection to a particular open TDB * - * You have to free the handle with ctdb_detach_db() when finished with it. + * This represents a particular open database: you receive it from + * ctdb_attachdb or ctdb_attachdb_recv to manipulate a database. + * + * You have to free the handle with ctdb_detachdb() when finished with it. */ struct ctdb_db; +/** + * ctdb_attachdb_send - open a clustered TDB + * @ctdb: the ctdb_connection from ctdb_connect. + * @name: the filename of the database (no /). + * @persistent: whether the database is persistent across ctdbd's life + * @tdb_flags: the flags to pass to tdb_open. + * @callback: the callback when we're attached or failed (typesafe) + * @cbdata: the argument to callback() + * + * This function connects to a TDB controlled by ctdbd. It can create + * a new TDB if it does not exist, depending on tdb_flags. Returns + * the pending request, or NULL on error. + */ struct ctdb_request * ctdb_attachdb_send(struct ctdb_connection *ctdb, - const char *name, int persistent, uint32_t tdb_flags, - ctdb_callback_t callback, void *private_data); + const char *name, bool persistent, uint32_t tdb_flags, + ctdb_callback_t callback, void *cbdata); -struct ctdb_db *ctdb_attachdb_recv(struct ctdb_request *req); +/** + * ctdb_attachdb_recv - read an ctdb_attach reply from ctdbd + * @ctdb: the ctdb_connection from ctdb_connect. + * @req: the completed request. + * + * This returns NULL if something went wrong, or otherwise the open database. + */ +struct ctdb_db *ctdb_attachdb_recv(struct ctdb_connection *ctdb, + struct ctdb_request *req); -struct ctdb_db *ctdb_attachdb(struct ctdb_connection *ctdb, - const char *name, int persistent, - uint32_t tdb_flags); +/** + * struct ctdb_lock - a record lock on a clustered TDB database + * + * This locks a subset of the database across the entire cluster; it + * is the fundamental sychronization element for ctdb. You cannot have + * more than one lock at once. + * + * You MUST NOT block during holding this lock and MUST release it + * quickly by performing ctdb_release_lock(lock). + * Do NOT make any system calls that may block while holding the lock. + * + * Try to release the lock as quickly as possible. + */ struct ctdb_lock; -/* - * functions to read a record from the database - * when the callback is invoked, the client will hold an exclusive lock - * on the record, the client MUST NOT block during holding this lock and MUST - * release it quickly by performing ctdb_release_lock(lock). - * - * When the lock is released, data is freed too, so make sure to copy the data - * before that. - * - * This returns true on success, and req will be non-NULL if a request was - * actually sent, otherwise callback will have already been called. - */ -bool -ctdb_readrecordlock_send(struct ctdb_db *ctdb_db, TDB_DATA key, - struct ctdb_request **req, - ctdb_callback_t callback, void *private_data); -struct ctdb_lock *ctdb_readrecordlock_recv(struct ctdb_db *ctdb_db, - struct ctdb_request *handle, - TDB_DATA *data); - -/* Returns null on failure. */ -struct ctdb_lock *ctdb_readrecordlock(struct ctdb_db *ctdb_db, TDB_DATA key, - TDB_DATA *data); +/** + * ctdb_rrl_callback_t - callback for ctdb_readrecordlock_async + * + * This is not the standard ctdb_callback_t, because there is often no + * request required to access a database record (ie. if it is local already). + * So the callback is handed the lock directly: it might be NULL if there + * was an error obtaining the lock. + * + * See Also: + * ctdb_readrecordlock_async(), ctdb_readrecordlock() + */ +typedef void (*ctdb_rrl_callback_t)(struct ctdb_db *ctdb_db, + struct ctdb_lock *lock, + TDB_DATA data, + void *private_data); + +/** + * ctdb_readrecordlock_async - read and lock a record + * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv. + * @key: the key of the record to lock. + * @callback: the callback once the record is locked (typesafe). + * @cbdata: the argument to callback() + * + * This returns true on success. Commonly, we can obtain the record + * immediately and so the callback will be invoked. Otherwise a request + * will be queued to ctdbd for the record. + * + * If failure is immediate, false is returned. Otherwise, the callback + * may receive a NULL lock arg to indicate asynchronous failure. + */ +bool ctdb_readrecordlock_async(struct ctdb_db *ctdb_db, TDB_DATA key, + ctdb_rrl_callback_t callback, void *cbdata); + +/** + * ctdb_writerecord - write a locked record in a TDB + * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv. + * @lock: the lock from ctdb_readrecordlock/ctdb_readrecordlock_recv + * @data: the new data to place in the record. + */ +bool ctdb_writerecord(struct ctdb_db *ctdb_db, + struct ctdb_lock *lock, TDB_DATA data); -/* - * Function to write data to a record - * This function may ONLY be called while holding a lock to the record - * created by ctdb_readrecordlock* - * Either from the callback provided to ctdb_readrecordlock_send() - * or after calling ctdb_readrecordlock_recv() but before calling - * ctdb_release_lock() to release the lock. +/** + * ctdb_release_lock - release a record lock on a TDB + * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv. + * @lock: the lock from ctdb_readrecordlock/ctdb_readrecordlock_async */ -int ctdb_writerecord(struct ctdb_lock *lock, TDB_DATA data); +void ctdb_release_lock(struct ctdb_db *ctdb_db, struct ctdb_lock *lock); -void ctdb_release_lock(struct ctdb_lock *lock); -/* - * messaging functions - * these functions provide a messaging layer for applications to communicate - * with eachother across +/** + * ctdb_traverse_callback_t - callback for ctdb_traverse_async. + * return 0 - to continue traverse + * return 1 - to abort the traverse + * + * See Also: + * ctdb_traverse_async() + */ +#define TRAVERSE_STATUS_RECORD 0 +#define TRAVERSE_STATUS_FINISHED 1 +#define TRAVERSE_STATUS_ERROR 2 +typedef int (*ctdb_traverse_callback_t)(struct ctdb_connection *ctdb, + struct ctdb_db *ctdb_db, + int status, + TDB_DATA key, + TDB_DATA data, + void *private_data); + +/** + * ctdb_traverse_async - traverse a database. + * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv. + * @callback: the callback once the record is locked (typesafe). + * @cbdata: the argument to callback() + * + * This returns true on success. + * when successfull, the callback will be invoked for each record + * until the traversal is finished. + * + * status == + * TRAVERSE_STATUS_RECORD key/data contains a record. + * TRAVERSE_STATUS_FINISHED traverse is finished. key/data is undefined. + * TRAVERSE_STATUS_ERROR an error occured during traverse. + * key/data is undefined. + * + * If failure is immediate, false is returned. */ -typedef void (*ctdb_message_fn_t)(struct ctdb_connection *, uint64_t srvid, TDB_DATA data, void *); +bool ctdb_traverse_async(struct ctdb_db *ctdb_db, + ctdb_traverse_callback_t callback, void *cbdata); +/** + * ctdb_message_fn_t - messaging callback for ctdb messages + * + * ctdbd provides a simple messaging API; you can register for a particular + * 64-bit id on which you want to send messages, and send to other ids. + * + * See Also: + * ctdb_set_message_handler_send() + */ +typedef void (*ctdb_message_fn_t)(struct ctdb_connection *, + uint64_t srvid, TDB_DATA data, void *); + +/** + * ctdb_set_message_handler_send - register for messages to a srvid + * @ctdb: the ctdb_connection from ctdb_connect. + * @srvid: the 64 bit identifier for our messages. + * @handler: the callback when we receive such a message (typesafe) + * @handler_data: the argument to handler() + * @callback: the callback when ctdb replies to our message (typesafe) + * @cbdata: the argument to callback() + * + * Note: our callback will always be called before handler. + * + * See Also: + * ctdb_set_message_handler_recv(), ctdb_remove_message_handler_send() + */ struct ctdb_request * ctdb_set_message_handler_send(struct ctdb_connection *ctdb, uint64_t srvid, ctdb_message_fn_t handler, + void *handler_data, ctdb_callback_t callback, - void *private_data); + void *cbdata); -int ctdb_set_message_handler_recv(struct ctdb_connection *ctdb, - struct ctdb_request *handle); +/** + * ctdb_set_message_handler_recv - read a set_message_handler result + * @ctdb: the ctdb_connection from ctdb_connect. + * @req: the completed request + * + * If this returns true, the registered handler may be called from the next + * ctdb_service(). If this returns false, the registration failed. + */ +bool ctdb_set_message_handler_recv(struct ctdb_connection *ctdb, + struct ctdb_request *handle); + +/** + * ctdb_remove_message_handler_send - unregister for messages to a srvid + * @ctdb: the ctdb_connection from ctdb_connect. + * @srvid: the 64 bit identifier for our messages. + * @handler: the callback when we receive such a message (typesafe) + * @handler_data: the argument to handler() + * @callback: the callback when ctdb replies to our message (typesafe) + * @cbdata: the argument to callback() + * + * This undoes a successful ctdb_set_message_handler or + * ctdb_set_message_handler_recv. + */ +struct ctdb_request * +ctdb_remove_message_handler_send(struct ctdb_connection *ctdb, uint64_t srvid, + ctdb_message_fn_t handler, void *handler_data, + ctdb_callback_t callback, void *cbdata); -int ctdb_set_message_handler(struct ctdb_connection *ctdb, uint64_t srvid, - ctdb_message_fn_t handler, void *private_data); +/** + * ctdb_remove_message_handler_recv - read a remove_message_handler result + * @ctdb: the ctdb_connection from ctdb_connect. + * @req: the completed request + * + * After this returns true, the registered handler will no longer be called. + * If this returns false, the de-registration failed. + */ +bool ctdb_remove_message_handler_recv(struct ctdb_connection *ctdb, + struct ctdb_request *req); +/** + * ctdb_send_message - send a message via ctdbd + * @ctdb: the ctdb_connection from ctdb_connect. + * @pnn: the physical node number to send to + * @srvid: the 64 bit identifier for this message type. + * @data: the data to send + * + * This allows arbitrary messages to be sent across the cluster to those + * listening (via ctdb_set_message_handler et al). + * + * This queues a message to be sent: you will need to call + * ctdb_service() to actually send the message. There is no callback + * because there is no acknowledgement. + * + * See Also: + * ctdb_getpnn_send(), ctdb_getpnn() + */ +bool ctdb_send_message(struct ctdb_connection *ctdb, uint32_t pnn, uint64_t srvid, TDB_DATA data); + +/** + * ctdb_getpnn_send - read the pnn number of a node. + * @ctdb: the ctdb_connection from ctdb_connect. + * @destnode: the destination node (see below) + * @callback: the callback when ctdb replies to our message (typesafe) + * @cbdata: the argument to callback() + * + * There are several special values for destnode, detailed in + * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the + * local ctdbd. + */ +struct ctdb_request * +ctdb_getpnn_send(struct ctdb_connection *ctdb, + uint32_t destnode, + ctdb_callback_t callback, + void *cbdata); +/** + * ctdb_getpnn_recv - read an ctdb_getpnn reply from ctdbd + * @ctdb: the ctdb_connection from ctdb_connect. + * @req: the completed request. + * @pnn: a pointer to the pnn to fill in + * + * This returns false if something went wrong, or otherwise fills in pnn. + */ +bool ctdb_getpnn_recv(struct ctdb_connection *ctdb, + struct ctdb_request *req, uint32_t *pnn); + -/* - * unregister a message handler and stop listening on teh specified port +/** + * ctdb_getnodemap_send - read the nodemap number from a node. + * @ctdb: the ctdb_connection from ctdb_connect. + * @destnode: the destination node (see below) + * @callback: the callback when ctdb replies to our message (typesafe) + * @cbdata: the argument to callback() + * + * There are several special values for destnode, detailed in + * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the + * local ctdbd. */ struct ctdb_request * -ctdb_remove_message_handler_send(struct ctdb_connection *ctdb, uint64_t srvid, - ctdb_callback_t callback, - void *private_data); +ctdb_getnodemap_send(struct ctdb_connection *ctdb, + uint32_t destnode, + ctdb_callback_t callback, + void *cbdata); +/** + * ctdb_getnodemap_recv - read an ctdb_getnodemap reply from ctdbd + * @ctdb: the ctdb_connection from ctdb_connect. + * @req: the completed request. + * @nodemap: a pointer to the returned nodemap structure + * + * This returns false if something went wrong. + * If the command failed, it guarantees to set nodemap to NULL. + * A non-NULL value for nodemap means the command was successful. + * + * A non-NULL value of the nodemap must be release released/freed + * by ctdb_free_nodemap(). + */ +bool ctdb_getnodemap_recv(struct ctdb_connection *ctdb, + struct ctdb_request *req, struct ctdb_node_map **nodemap); + +/** + * ctdb_getpublicips_send - read the public ip list from a node. + * @ctdb: the ctdb_connection from ctdb_connect. + * @destnode: the destination node (see below) + * @callback: the callback when ctdb replies to our message (typesafe) + * @cbdata: the argument to callback() + * + * This control returns the list of public ips known to the local node. + * Deamons only know about those ips that are listed in the local + * public addresses file, which means the returned list of ips may + * be only a subset of all ips across the entire cluster. + * + * There are several special values for destnode, detailed in + * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the + * local ctdbd. + */ +struct ctdb_request * +ctdb_getpublicips_send(struct ctdb_connection *ctdb, + uint32_t destnode, + ctdb_callback_t callback, + void *cbdata); +/** + * ctdb_getpublicips_recv - read the public ip list from a node + * @ctdb: the ctdb_connection from ctdb_connect. + * @req: the completed request. + * @ips: a pointer to the returned public ip list + * + * This returns false if something went wrong. + * If the command failed, it guarantees to set ips to NULL. + * A non-NULL value for nodemap means the command was successful. + * + * A non-NULL value of the nodemap must be release released/freed + * by ctdb_free_publicips(). + */ +bool ctdb_getpublicips_recv(struct ctdb_connection *ctdb, + struct ctdb_request *req, struct ctdb_all_public_ips **ips); -int ctdb_remove_message_handler_recv(struct ctdb_request *handle); -int ctdb_remove_message_handler(struct ctdb_connection *ctdb, uint64_t srvid); +/** + * ctdb_getrecmaster_send - read the recovery master of a node + * @ctdb: the ctdb_connection from ctdb_connect. + * @destnode: the destination node (see below) + * @callback: the callback when ctdb replies to our message (typesafe) + * @cbdata: the argument to callback() + * + * There are several special values for destnode, detailed in + * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the + * local ctdbd. + */ +struct ctdb_request * +ctdb_getrecmaster_send(struct ctdb_connection *ctdb, + uint32_t destnode, + ctdb_callback_t callback, void *cbdata); +/** + * ctdb_getrecmaster_recv - read an ctdb_getrecmaster reply from ctdbd + * @ctdb: the ctdb_connection from ctdb_connect. + * @req: the completed request. + * @recmaster: a pointer to the recmaster to fill in + * + * This returns false if something went wrong, or otherwise fills in + * recmaster. + */ +bool ctdb_getrecmaster_recv(struct ctdb_connection *ctdb, + struct ctdb_request *handle, + uint32_t *recmaster); + +/** + * ctdb_cancel - cancel an uncompleted request + * @ctdb: the ctdb_connection from ctdb_connect. + * @req: the uncompleted request. + * + * This cancels a request, returning true. You may not cancel a + * request which has already been completed (ie. once its callback has + * been called); you should simply use ctdb_request_free() in that case. + */ +void ctdb_cancel(struct ctdb_connection *ctdb, struct ctdb_request *req); +/*** + * + * Synchronous API + * + ***/ + +/** + * ctdb_attachdb - open a clustered TDB (synchronous) + * @ctdb: the ctdb_connection from ctdb_connect. + * @name: the filename of the database (no /). + * @persistent: whether the database is persistent across ctdbd's life + * @tdb_flags: the flags to pass to tdb_open. + * + * Do a ctdb_attachdb_send and wait for it to complete. + * Returns NULL on failure. + */ +struct ctdb_db *ctdb_attachdb(struct ctdb_connection *ctdb, + const char *name, bool persistent, + uint32_t tdb_flags); -/* - * send a message to a specific node/port - * this function is non-blocking +/** + * ctdb_detachdb - close a clustered TDB. + * @ctdb: the ctdb_connection from ctdb_connect. + * @db: the database from ctdb_attachdb/ctdb_attachdb_send + * + * Closes a clustered tdb. + */ +void ctdb_detachdb(struct ctdb_connection *ctdb, struct ctdb_db *db); + +/** + * ctdb_readrecordlock - read and lock a record (synchronous) + * @ctdb: the ctdb_connection from ctdb_connect. + * @ctdb_db: the database handle from ctdb_attachdb/ctdb_attachdb_recv. + * @key: the key of the record to lock. + * @req: a pointer to the request, if one is needed. + * + * Do a ctdb_readrecordlock_send and wait for it to complete. + * Returns NULL on failure. */ -int ctdb_send_message(struct ctdb_connection *ctdb, uint32_t pnn, uint64_t srvid, TDB_DATA data); +struct ctdb_lock *ctdb_readrecordlock(struct ctdb_connection *ctdb, + struct ctdb_db *ctdb_db, TDB_DATA key, + TDB_DATA *data); +/** + * ctdb_set_message_handler - register for messages to a srvid (synchronous) + * @ctdb: the ctdb_connection from ctdb_connect. + * @srvid: the 64 bit identifier for our messages. + * @handler: the callback when we receive such a message (typesafe) + * @cbdata: the argument to handler() + * + * If this returns true, the message handler can be called from any + * ctdb_service() (which is also called indirectly by other + * synchronous functions). If this returns false, the registration + * failed. + */ +bool ctdb_set_message_handler(struct ctdb_connection *ctdb, uint64_t srvid, + ctdb_message_fn_t handler, void *cbdata); -/* - * functions to read the pnn number of the local node + +/** + * ctdb_remove_message_handler - deregister for messages (synchronous) + * @ctdb: the ctdb_connection from ctdb_connect. + * @srvid: the 64 bit identifier for our messages. + * @handler: the callback when we receive such a message (typesafe) + * @handler_data: the argument to handler() + * + * If this returns true, the message handler will no longer be called. + * If this returns false, the deregistration failed. */ -struct ctdb_request * -ctdb_getpnn_send(struct ctdb_connection *ctdb, +bool ctdb_remove_message_handler(struct ctdb_connection *ctdb, uint64_t srvid, + ctdb_message_fn_t handler, void *handler_data); + +/** + * ctdb_getpnn - read the pnn number of a node (synchronous) + * @ctdb: the ctdb_connection from ctdb_connect. + * @destnode: the destination node (see below) + * @pnn: a pointer to the pnn to fill in + * + * There are several special values for destnode, detailed in + * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the + * local ctdbd. + * + * Returns true and fills in *pnn on success. + */ +bool ctdb_getpnn(struct ctdb_connection *ctdb, uint32_t destnode, - ctdb_callback_t callback, - void *private_data); -int ctdb_getpnn_recv(struct ctdb_request *req, uint32_t *pnn); - -int ctdb_getpnn(struct ctdb_connection *ctdb, - uint32_t destnode, - uint32_t *pnn); + uint32_t *pnn); +/** + * ctdb_getrecmaster - read the recovery master of a node (synchronous) + * @ctdb: the ctdb_connection from ctdb_connect. + * @destnode: the destination node (see below) + * @recmaster: a pointer to the recmaster to fill in + * + * There are several special values for destnode, detailed in + * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the + * local ctdbd. + * + * Returns true and fills in *recmaster on success. + */ +bool ctdb_getrecmaster(struct ctdb_connection *ctdb, + uint32_t destnode, + uint32_t *recmaster); +/** + * ctdb_getnodemap - read the nodemap from a node (synchronous) + * @ctdb: the ctdb_connection from ctdb_connect. + * @destnode: the destination node (see below) + * @nodemap: a pointer to the nodemap to fill in + * + * There are several special values for destnode, detailed in + * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the + * local ctdbd. + * + * Returns true and fills in *nodemap on success. + * A non-NULL nodemap must be freed by calling ctdb_free_nodemap. + */ +bool ctdb_getnodemap(struct ctdb_connection *ctdb, + uint32_t destnode, struct ctdb_node_map **nodemap); /* - * functions to read the recovery master of a node + * This function is used to release/free the nodemap structure returned + * by ctdb_getnodemap() and ctdb_getnodemap_recv() */ -struct ctdb_request * -ctdb_getrecmaster_send(struct ctdb_connection *ctdb, - uint32_t destnode, - ctdb_callback_t callback, - void *private_data); -int ctdb_getrecmaster_recv(struct ctdb_request *handle, - uint32_t *recmaster); -int ctdb_getrecmaster(struct ctdb_connection *ctdb, - uint32_t destnode, - uint32_t *recmaster); - +void ctdb_free_nodemap(struct ctdb_node_map *nodemap); +/** + * ctdb_getpublicips - read the public ip list from a node. + * @ctdb: the ctdb_connection from ctdb_connect. + * @destnode: the destination node (see below) + * @ips: a pointer to the returned public ip list + * + * This control returns the list of public ips known to the local node. + * Deamons only know about those ips that are listed in the local + * public addresses file, which means the returned list of ips may + * be only a subset of all ips across the entire cluster. + * + * There are several special values for destnode, detailed in + * ctdb_protocol.h, particularly CTDB_CURRENT_NODE which means the + * local ctdbd. + * + * This returns false if something went wrong. + * If the command failed, it guarantees to set ips to NULL. + * A non-NULL value for nodemap means the command was successful. + * + * A non-NULL value of the nodemap must be release released/freed + * by ctdb_free_publicips(). + */ +bool ctdb_getpublicips(struct ctdb_connection *ctdb, + uint32_t destnode, struct ctdb_all_public_ips **ips); /* - * cancel a request + * This function is used to release/free the public ip structure returned + * by ctdb_getpublicips() and ctdb_getpublicips_recv() */ -int ctdb_cancel(struct ctdb_request *); +void ctdb_free_publicips(struct ctdb_all_public_ips *ips); /* These ugly macro wrappers make the callbacks typesafe. */ -#include +#include #define ctdb_sendcb(cb, cbdata) \ typesafe_cb_preargs(void, (cb), (cbdata), \ struct ctdb_connection *, struct ctdb_request *) +#define ctdb_msgcb(cb, cbdata) \ + typesafe_cb_preargs(void, (cb), (cbdata), \ + struct ctdb_connection *, uint64_t, TDB_DATA) + +#define ctdb_connect(addr, log, logpriv) \ + ctdb_connect((addr), \ + typesafe_cb_postargs(void, (log), (logpriv), \ + int, const char *, va_list), \ + (logpriv)) + +#define ctdb_set_message_handler(ctdb, srvid, handler, hdata) \ + ctdb_set_message_handler((ctdb), (srvid), \ + ctdb_msgcb((handler), (hdata)), (hdata)) + +#define ctdb_remove_message_handler(ctdb, srvid, handler, hdata) \ + ctdb_remove_message_handler((ctdb), (srvid), \ + ctdb_msgcb((handler), (hdata)), (hdata)) + #define ctdb_attachdb_send(ctdb, name, persistent, tdb_flags, cb, cbdata) \ ctdb_attachdb_send((ctdb), (name), (persistent), (tdb_flags), \ ctdb_sendcb((cb), (cbdata)), (cbdata)) -#define ctdb_readrecordlock_send(ctdb_db, key, reqp, cb, cbdata) \ - ctdb_readrecordlock_send((ctdb_db), (key), (reqp), \ - ctdb_sendcb((cb), (cbdata)), (cbdata)) +#define ctdb_readrecordlock_async(_ctdb_db, key, cb, cbdata) \ + ctdb_readrecordlock_async((_ctdb_db), (key), \ + typesafe_cb_preargs(void, (cb), (cbdata), \ + struct ctdb_db *, struct ctdb_lock *, \ + TDB_DATA), (cbdata)) -#define ctdb_set_message_handler_send(ctdb, srvid, handler, cb, cbdata) \ - ctdb_set_message_handler_send((ctdb), (srvid), (handler), \ - ctdb_sendcb((cb), (cbdata)), (cbdata)) +#define ctdb_set_message_handler_send(ctdb, srvid, handler, hdata, cb, cbdata) \ + ctdb_set_message_handler_send((ctdb), (srvid), \ + ctdb_msgcb((handler), (hdata)), (hdata), \ + ctdb_sendcb((cb), (cbdata)), (cbdata)) -#define ctdb_remove_message_handler_send(ctdb, srvid, cb, cbdata) \ +#define ctdb_remove_message_handler_send(ctdb, srvid, handler, hdata, cb, cbdata) \ ctdb_remove_message_handler_send((ctdb), (srvid), \ + ctdb_msgcb((handler), (hdata)), (hdata), \ ctdb_sendcb((cb), (cbdata)), (cbdata)) #define ctdb_getpnn_send(ctdb, destnode, cb, cbdata) \ @@ -239,4 +774,13 @@ int ctdb_cancel(struct ctdb_request *); #define ctdb_getrecmaster_send(ctdb, destnode, cb, cbdata) \ ctdb_getrecmaster_send((ctdb), (destnode), \ ctdb_sendcb((cb), (cbdata)), (cbdata)) + +#define ctdb_getnodemap_send(ctdb, destnode, cb, cbdata) \ + ctdb_getnodemap_send((ctdb), (destnode), \ + ctdb_sendcb((cb), (cbdata)), (cbdata)) + +#define ctdb_getpublicips_send(ctdb, destnode, cb, cbdata) \ + ctdb_getpublicips_send((ctdb), (destnode), \ + ctdb_sendcb((cb), (cbdata)), (cbdata)) + #endif