charset/tests: assert the exact values of str[n]casecmp_m()

[Samba.git] / ctdb / client / client.h

/*
   CTDB client code

   Copyright (C) Amitay Isaacs  2015

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __CTDB_CLIENT_H__
#define __CTDB_CLIENT_H__

#include <talloc.h>
#include <tevent.h>

#include "protocol/protocol.h"
#include "common/srvid.h"

/**
 * @file client.h
 *
 * @brief Client api to talk to ctdb daemon
 *
 * This API allows to connect to ctdb daemon, perform various database
 * operations, send controls to ctdb daemon and send messages to other ctdb
 * clients.
 */

/**
 * @brief The abstract context that holds client connection to ctdb daemon
 */
struct ctdb_client_context;

/**
 * @brief The abstract context that represents a clustered database
 */
struct ctdb_db_context;

/**
 * @brief The abstract context that represents a record from a distributed
 * database
 */
struct ctdb_record_handle;

/**
 * @brief The abstract context that represents a transaction on a replicated
 * database
 */
struct ctdb_transaction_handle;

/**
 * @brief Client callback function
 *
 * This function can be registered to be invoked in case of ctdb daemon going
 * away.
 */
typedef void (*ctdb_client_callback_func_t)(void *private_data);

/**
 * @brief Initialize and connect to ctdb daemon
 *
 * This returns a ctdb client context.  Freeing this context will free the
 * connection to ctdb daemon and any memory associated with it.
 *
 * If the connection to ctdb daemon is lost, the client will terminate
 * automatically as the library will call exit().  If the client code
 * wants to perform cleanup or wants to re-establish a new connection,
 * the client should register a disconnect callback function.
 *
 * @see ctdb_client_set_disconnect_callback
 *
 * When a disconnect callback function is registered, client library will
 * not call exit().  It is the responsibility of the client code to take
 * appropriate action.
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] sockpath Path to ctdb daemon unix domain socket
 * @param[out] result The new ctdb client context
 * @return 0 on succcess, errno on failure
 */
int ctdb_client_init(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                     const char *sockpath,
                     struct ctdb_client_context **result);

/**
 * @brief Register a callback in case of client disconnection
 *
 * This allows client code to know if the connection to ctdb daemon is lost.
 * This is useful if the client wants to re-establish a new connection to ctdb
 * daemon.
 *
 * @param[in] client Client connection context
 * @param[in] func Callback function
 * @param[in] private_data private data for callback function
 */
void ctdb_client_set_disconnect_callback(struct ctdb_client_context *client,
                                         ctdb_client_callback_func_t func,
                                         void *private_data);

/**
 * @brief Get the node number of the current node
 *
 * @param[in] client Client connection context
 * return node number on success, CTDB_UNKNOWN_PNN on error
 */
uint32_t ctdb_client_pnn(struct ctdb_client_context *client);

/**
 * @brief Client event loop waiting for a flag
 *
 * This can used to wait for asynchronous computations to complete.
 * When this function is called, it will run tevent event loop and wait
 * till the done flag is set to true.  This function will block and will
 * not return as long as the done flag is false.
 *
 * @param[in] ev Tevent context
 * @param[in] done Boolean flag to indicate when to stop waiting
 */
void ctdb_client_wait(struct tevent_context *ev, bool *done);

/**
 * @brief Client event loop waiting for a flag with timeout
 *
 * This can be used to wait for asynchronous computations to complete.
 * When this function is called, it will run tevent event loop and wait
 * till the done flag is set to true or if the timeout occurs.
 *
 * This function will return when either
 *  - done flag is set to true, or
 *  - timeout has occurred.
 *
 * @param[in] ev Tevent context
 * @param[in] done Boolean flag to indicate when to stop waiting
 * @param[in] timeout How long to wait
 * @return 0 on succes, ETIME on timeout, and errno on failure
 */
int ctdb_client_wait_timeout(struct tevent_context *ev, bool *done,
                             struct timeval timeout);

/**
 * @brief Async computation start to wait till recovery is completed
 *
 * CTDB daemon does not perform many operations while in recovery (especially
 * database operations).  This computation allows to wait till ctdb daemon has
 * finished recovery.
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @return new tevent request, or NULL on failure
 */
struct tevent_req *ctdb_recovery_wait_send(TALLOC_CTX *mem_ctx,
                                           struct tevent_context *ev,
                                           struct ctdb_client_context *client);

/**
 * @brief Async computation end to wait till recovery is completed
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_recovery_wait_recv(struct tevent_req *req, int *perr);

/**
 * @brief Sync wrapper for ctdb_recovery_wait computation
 *
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @return true on success, false on failure
 */
bool ctdb_recovery_wait(struct tevent_context *ev,
                        struct ctdb_client_context *client);

/**
 * @brief Async computation start to migrate a database record
 *
 * This sends a request to ctdb daemon to migrate a database record to
 * the local node.  CTDB daemon will locate the data master for the record
 * and will migrate record (and the data master) to the current node.
 *
 * @see ctdb_fetch_lock_send
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev  Tevent context
 * @param[in] client Client connection context
 * @param[in] request CTDB request data
 * @return a new tevent req, or NULL on failure
 */
struct tevent_req *ctdb_client_call_send(TALLOC_CTX *mem_ctx,
                                         struct tevent_context *ev,
                                         struct ctdb_client_context *client,
                                         struct ctdb_req_call *request);

/**
 * @brief Async computation end to migrate a database record
 *
 * @param[in] req Tevent request
 * @param[in] mem_ctx Talloc memory context
 * @param[out] reply CTDB reply data
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_client_call_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
                           struct ctdb_reply_call **reply, int *perr);


/**
 * @brief Async computation start to send a message to remote client(s)
 *
 * This sends a message to ctdb clients on a remote node.  All the
 * messages are associated with a specific SRVID.  All the clients on the
 * remote node listening to that SRVID, will get the message.
 *
 * Clients can register and deregister for messages for a SRVID using
 * ctdb_client_set_message_handler() and ctdb_client_remove_message_handler().
 *
 * @see ctdb_client_set_message_handler_send,
 *      ctdb_client_remove_message_handler_send
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] destnode Remote node id
 * @param[in] message Message to send
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_client_message_send(TALLOC_CTX *mem_ctx,
                                            struct tevent_context *ev,
                                            struct ctdb_client_context *client,
                                            uint32_t destnode,
                                            struct ctdb_req_message *message);

/**
 * @brief Async computation end to send a message to remote client(s)
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_client_message_recv(struct tevent_req *req, int *perr);

/**
 * @brief Sync wrapper to send a message to client(s) on remote node
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] destnode Node id
 * @param[in] message Message to send
 */
int ctdb_client_message(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                        struct ctdb_client_context *client,
                        uint32_t destnode, struct ctdb_req_message *message);

/**
 * @brief Async computation start to send a message to multiple nodes
 *
 * This sends a message to ctdb clients on multiple remote nodes.  All the
 * messages are associated with a specific SRVID.  All the clients on remote
 * nodes listening to that SRVID, will get the message.
 *
 * Clients can register and deregister for messages for a SRVID using
 * ctdb_client_set_message_handler() and ctdb_client_remove_message_handler().
 *
 * @see ctdb_client_set_message_handler_send,
 *      ctdb_client_remove_message_handler_send
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] pnn_list List of node ids
 * @param[in] count Number of node ids
 * @param[in] message Message to send
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_client_message_multi_send(
                                TALLOC_CTX *mem_ctx,
                                struct tevent_context *ev,
                                struct ctdb_client_context *client,
                                uint32_t *pnn_list, int count,
                                struct ctdb_req_message *message);

/**
 * @brief Async computation end to send a message to multiple nodes
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @param[in] mem_ctx Talloc memory context
 * @param[out] perr_list The status from each node id
 * @return true on success, false on failure
 *
 * If perr_list is not NULL, then the status (0 on success, errno on failure)
 * of sending message to each of the node in the specified node list.  The
 * perr_list is an array of the same size as of pnn_list.
 */
bool ctdb_client_message_multi_recv(struct tevent_req *req, int *perr,
                                    TALLOC_CTX *mem_ctx, int **perr_list);

/**
 * @brief Sync wrapper to send a message to multiple nodes
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] pnn_list List of node ids
 * @param[in] count Number of node ids
 * @param[in] message Message to send
 * @param[out] perr_list The status from each node id
 * @return 0 on success, errno on failure
 */
int ctdb_client_message_multi(TALLOC_CTX *mem_ctx,
                              struct tevent_context *ev,
                              struct ctdb_client_context *client,
                              uint32_t *pnn_list, int count,
                              struct ctdb_req_message *message,
                              int **perr_list);

/**
 * @brief Async computation start to receive messages for a SRVID
 *
 * This computation informs ctdb that the client is interested in all messages
 * for a specific SRVID.
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] srvid SRVID
 * @param[in] handler Callback function to call when a message is received
 * @param[in] private_data Private data for callback
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_client_set_message_handler_send(
                                        TALLOC_CTX *mem_ctx,
                                        struct tevent_context *ev,
                                        struct ctdb_client_context *client,
                                        uint64_t srvid,
                                        srvid_handler_fn handler,
                                        void *private_data);

/**
 * @brief Async computation end to receive messages for a SRVID
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_client_set_message_handler_recv(struct tevent_req *req, int *perr);

/**
 * Sync wrapper to receive messages for a SRVID
 *
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] srvid SRVID
 * @param[in] handler Callback function to call when a message is received
 * @param[in] private_data Private data for callback
 * @return 0 on success, errno on failure
 */
int ctdb_client_set_message_handler(struct tevent_context *ev,
                                    struct ctdb_client_context *client,
                                    uint64_t srvid, srvid_handler_fn handler,
                                    void *private_data);

/**
 * @brief Async computation start to stop receiving messages for a SRVID
 *
 * This computation informs ctdb that the client is no longer interested in
 * messages for a specific SRVID.
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] srvid SRVID
 * @param[in] private_data Private data used to register callback
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_client_remove_message_handler_send(
                                        TALLOC_CTX *mem_ctx,
                                        struct tevent_context *ev,
                                        struct ctdb_client_context *client,
                                        uint64_t srvid,
                                        void *private_data);

/**
 * @brief Async computation end to stop receiving messages for a SRVID
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_client_remove_message_handler_recv(struct tevent_req *req,
                                             int *perr);

/**
 * Sync wrapper to stop receiving messages for a SRVID
 *
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] srvid SRVID
 * @param[in] private_data Private data used to register callback
 * @return 0 on success, errno on failure
 */
int ctdb_client_remove_message_handler(struct tevent_context *ev,
                                       struct ctdb_client_context *client,
                                       uint64_t srvid, void *private_data);

/**
 * @brief Async computation start to send a control to ctdb daemon
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] destnode Node id
 * @param[in] timeout How long to wait
 * @param[in] request Control request
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_client_control_send(TALLOC_CTX *mem_ctx,
                                            struct tevent_context *ev,
                                            struct ctdb_client_context *client,
                                            uint32_t destnode,
                                            struct timeval timeout,
                                            struct ctdb_req_control *request);

/**
 * @brief Async computation end to send a control to ctdb daemon
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @param[in] mem_ctx Talloc memory context
 * @param[out] preply Control reply
 * @return true on success, false on failure
 */
bool ctdb_client_control_recv(struct tevent_req *req, int *perr,
                              TALLOC_CTX *mem_ctx,
                              struct ctdb_reply_control **preply);

/**
 * @brief Sync wrapper to send a control to ctdb daemon
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] destnode Node id
 * @param[in] timeout How long to wait
 * @param[in] request Control request
 * @param[out] preply Control reply
 * @return 0 on success, errno on failure
 */
int ctdb_client_control(TALLOC_CTX *mem_ctx,
                        struct tevent_context *ev,
                        struct ctdb_client_context *client,
                        uint32_t destnode,
                        struct timeval timeout,
                        struct ctdb_req_control *request,
                        struct ctdb_reply_control **preply);

/**
 * @brief Async computation start to send a control to multiple nodes
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] pnn_list List of node ids
 * @param[in] count Number of node ids
 * @param[in] timeout How long to wait
 * @param[in] request Control request
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_client_control_multi_send(
                                TALLOC_CTX *mem_ctx,
                                struct tevent_context *ev,
                                struct ctdb_client_context *client,
                                uint32_t *pnn_list, int count,
                                struct timeval timeout,
                                struct ctdb_req_control *request);

/**
 * @brief Async computation end to send a control to multiple nodes
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @param[in] mem_ctx Talloc memory context
 * @param[out] perr_list Status from each node
 * @param[out] preply Control reply from each node
 * @return true on success, false on failure
 */
bool ctdb_client_control_multi_recv(struct tevent_req *req, int *perr,
                                    TALLOC_CTX *mem_ctx, int **perr_list,
                                    struct ctdb_reply_control ***preply);

/**
 * @brief Sync wrapper to send a control to multiple nodes
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] pnn_list List of node ids
 * @param[in] count Number of node ids
 * @param[in] timeout How long to wait
 * @param[in] request Control request
 * @param[out] perr_list Status from each node
 * @param[out] preply Control reply from each node
 * @return 0 on success, errno on failure
 */
int ctdb_client_control_multi(TALLOC_CTX *mem_ctx,
                              struct tevent_context *ev,
                              struct ctdb_client_context *client,
                              uint32_t *pnn_list, int count,
                              struct timeval timeout,
                              struct ctdb_req_control *request,
                              int **perr_list,
                              struct ctdb_reply_control ***preply);

/**
 * @brief Check err_list for errors
 *
 * This is a convenience function to parse the err_list returned from
 * functions that send requests to multiple nodes.
 *
 * If status from any of the node is non-zero, then return first non-zero
 * status.
 *
 * If status from all the nodes is 0, then return 0.
 *
 * @param[in] pnn_list List of node ids
 * @param[in] count Number of node ids
 * @param[in] err_list Status from each node
 * @param[out] pnn Node id in case of failure
 * @return 0 if no failures, status from first failure
 */
int ctdb_client_control_multi_error(uint32_t *pnn_list, int count,
                                    int *err_list, uint32_t *pnn);

/**
 * @brief Async computation start to attach a database
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in[ client Client connection context
 * @param[in] timeout How long to wait
 * @param[in] db_name Name of the database
 * @param[in] db_flags Database flags
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_attach_send(TALLOC_CTX *mem_ctx,
                                    struct tevent_context *ev,
                                    struct ctdb_client_context *client,
                                    struct timeval timeout,
                                    const char *db_name, uint8_t db_flags);

/**
 * @brief Async computation end to attach a database
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @param[out] result New database context
 * @return true on success, false on failure
 */
bool ctdb_attach_recv(struct tevent_req *req, int *perr,
                      struct ctdb_db_context **result);

/**
 * @brief Sync wrapper to attach a database
 *
 * @param[in] ev Tevent context
 * @param[in[ client Client connection context
 * @param[in] timeout How long to wait
 * @param[in] db_name Name of the database
 * @param[in] db_flags Database flags
 * @param[out] result New database context
 * @return 0 on success, errno on failure
 */
int ctdb_attach(struct tevent_context *ev,
                struct ctdb_client_context *client,
                struct timeval timeout,
                const char *db_name, uint8_t db_flags,
                struct ctdb_db_context **result);

/**
 * @brief Async computation start to detach a database
 *
 * Only volatile databases can be detached at runtime.
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in[ client Client connection context
 * @param[in] timeout How long to wait
 * @param[in] db_id Database id
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_detach_send(TALLOC_CTX *mem_ctx,
                                    struct tevent_context *ev,
                                    struct ctdb_client_context *client,
                                    struct timeval timeout, uint32_t db_id);

/**
 * @brief Async computation end to detach a database
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_detach_recv(struct tevent_req *req, int *perr);

/**
 * @brief Sync wrapper to detach a database
 *
 * Only volatile databases can be detached at runtime.
 *
 * @param[in] ev Tevent context
 * @param[in[ client Client connection context
 * @param[in] timeout How long to wait
 * @param[in] db_id Database id
 * @return 0 on success, errno on failure
 */
int ctdb_detach(struct tevent_context *ev,
                struct ctdb_client_context *client,
                struct timeval timeout, uint32_t db_id);


/**
 * @brief Get database id from database context
 *
 * @param[in] db Database context
 * @return database id
 */
uint32_t ctdb_db_id(struct ctdb_db_context *db);

/**
 * @brief Traverse a database locally on the node
 *
 * This function traverses a database locally on the node and for each record
 * calls the parser function.  If the parser function returns 1, the traverse
 * will terminate.  If parser function returns 0, the traverse will continue
 * till all records in database are parsed.
 *
 * This is useful for replicated databases, since each node has exactly the
 * same records.
 *
 * @param[in] db Database context
 * @param[in] readonly Is the traversal for reading or updating
 * @param[in] extract_header Whether to extract ltdb header from record data
 * @param[in] parser Record parsing function
 * @param[in] private_data Private data for parser function
 * @return 0 on success, non-zero return value from parser function
 */
int ctdb_db_traverse_local(struct ctdb_db_context *db, bool readonly,
                           bool extract_header,
                           ctdb_rec_parser_func_t parser, void *private_data);

/**
 * @brief Async computation start to a cluster-wide database traverse
 *
 * This function traverses a database on all the nodes and for each record
 * calls the parser function.  If the parser function returns 1, the traverse
 * will terminate.  If parser function returns 0, the traverse will continue
 * till all records all on nodes are parsed.
 *
 * This is useful for distributed databases as the records are distributed
 * among the cluster nodes.
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] db Database context
 * @param[in] destnode Node id
 * @param[in] timeout How long to wait
 * @param[in] parser Record parser function
 * @param[in] private_data Private data for parser
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_db_traverse_send(TALLOC_CTX *mem_ctx,
                                         struct tevent_context *ev,
                                         struct ctdb_client_context *client,
                                         struct ctdb_db_context *db,
                                         uint32_t destnode,
                                         struct timeval timeout,
                                         ctdb_rec_parser_func_t parser,
                                         void *private_data);

/**
 * @brief Async computation end to a cluster-wide database traverse
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_db_traverse_recv(struct tevent_req *req, int *perr);

/**
 * @brief Sync wrapper for a cluster-wide database traverse
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] db Database context
 * @param[in] destnode Node id
 * @param[in] timeout How long to wait
 * @param[in] parser Record parser function
 * @param[in] private_data Private data for parser
 * @return 0 on success, errno on failure or non-zero status from parser
 */
int ctdb_db_traverse(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                     struct ctdb_client_context *client,
                     struct ctdb_db_context *db,
                     uint32_t destnode, struct timeval timeout,
                     ctdb_rec_parser_func_t parser, void *private_data);

/**
 * @brief Fetch a record from a local database
 *
 * This function is primarily for internal use.
 * Clients should use ctdb_fetch_lock() instead.
 *
 * @param[in] db Database context
 * @param[in] key Record key
 * @param[out] header Record header
 * @param[in] mem_ctx Talloc memory context
 * @param[out] data Record data
 */
int ctdb_ltdb_fetch(struct ctdb_db_context *db, TDB_DATA key,
                    struct ctdb_ltdb_header *header,
                    TALLOC_CTX *mem_ctx, TDB_DATA *data);

/**
 * @brief Async computation start to fetch a locked record
 *
 * This function is used to fetch a record from a distributed database.
 *
 * If the record is already available on the local node, then lock the
 * record and return the record handle.
 *
 * If the record is not available on the local node, send a CTDB request to
 * migrate the record.  Once the record is migrated to the local node, lock
 * the record and return the record handle.
 *
 * At the end of the computation, a record handle is returned which holds
 * the record lock.  When the record handle is freed, the record is unlocked.
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client context
 * @param[in] db Database context
 * @param[in] key Record key
 * @param[in] readonly Whether to request readonly copy of the record
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_fetch_lock_send(TALLOC_CTX *mem_ctx,
                                        struct tevent_context *ev,
                                        struct ctdb_client_context *client,
                                        struct ctdb_db_context *db,
                                        TDB_DATA key, bool readonly);

/**
 * @brief Async computation end to fetch a locked record
 *
 * @param[in] req Tevent request
 * @param[out] header Record header
 * @param[in] mem_ctx Talloc memory context
 * @param[out] data Record data
 * @param[out] perr errno in case of failure
 * @return a new record handle, NULL on failure
 */
struct ctdb_record_handle *ctdb_fetch_lock_recv(struct tevent_req *req,
                                                struct ctdb_ltdb_header *header,
                                                TALLOC_CTX *mem_ctx,
                                                TDB_DATA *data, int *perr);

/**
 * @brief Sync wrapper to fetch a locked record
 *
 * @see ctdb_fetch_lock_send
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client context
 * @param[in] db Database context
 * @param[in] key Record key
 * @param[in] readonly Whether to request readonly copy of the record
 * @param[out] header Record header
 * @param[out] data Record data
 * return 0 on success, errno on failure
 */
int ctdb_fetch_lock(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                    struct ctdb_client_context *client,
                    struct ctdb_db_context *db, TDB_DATA key, bool readonly,
                    struct ctdb_record_handle **out,
                    struct ctdb_ltdb_header *header, TDB_DATA *data);

/**
 * @brief Update a locked record
 *
 * This function is used to update a record in a distributed database.
 *
 * This function should NOT be used to store null data, instead use
 * ctdb_delete_record().
 *
 * @param[in] h Record handle
 * @param[in] data New record data
 * @return 0 on success, errno on failure
 */
int ctdb_store_record(struct ctdb_record_handle *h, TDB_DATA data);

/**
 * @brief Async computation start to delete a locked record
 *
 * This function is used to delete a record in a distributed database
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] h Record handle
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_delete_record_send(TALLOC_CTX *mem_ctx,
                                           struct tevent_context *ev,
                                           struct ctdb_record_handle *h);

/**
 * @brief Async computation end to delete a locked record
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_delete_record_recv(struct tevent_req *req, int *perr);

/**
 * @brief Sync wrapper to delete a locked record
 *
 * @see ctdb_delete_record_send
 *
 * @param[in] h Record handle
 * @return 0 on success, errno on failure
 */
int ctdb_delete_record(struct ctdb_record_handle *h);

/**
 * @brief Async computation start to get a global database lock
 *
 * Functions related to global locks are primarily used internally for
 * implementing transaction api.
 *
 * Clients should use transaction api directly.
 * @see ctdb_transaction_start_send
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client context
 * @param[in] db Database context for g_lock.tdb
 * @param[in] keyname Record key
 * @param[in] sid Server id
 * @param[in] readonly Lock type
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_g_lock_lock_send(TALLOC_CTX *mem_ctx,
                                         struct tevent_context *ev,
                                         struct ctdb_client_context *client,
                                         struct ctdb_db_context *db,
                                         const char *keyname,
                                         struct ctdb_server_id *sid,
                                         bool readonly);

/**
 * @brief Async computation end to get a global database lock
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_g_lock_lock_recv(struct tevent_req *req, int *perr);

/**
 * @brief Async computation start to release a global database lock
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] db Database context
 * @param[in] keyname Record key
 * @param[in] sid Server id
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_g_lock_unlock_send(TALLOC_CTX *mem_ctx,
                                           struct tevent_context *ev,
                                           struct ctdb_client_context *client,
                                           struct ctdb_db_context *db,
                                           const char *keyname,
                                           struct ctdb_server_id sid);

/**
 * @brief Async computation end to release a global database lock
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_g_lock_unlock_recv(struct tevent_req *req, int *perr);

/**
 * @brief Async computation start to start a transaction
 *
 * This function is used to start a transaction on a replicated database.
 *
 * To perform any updates on a replicated database
 * - start transaction
 * - fetch record (ctdb_transaction_fetch_record)
 * - store record (ctdb_transaction_store_record)
 * - delete record (ctdb_transaction_delete_record)
 * - commit transaction (ctdb_transaction_commit_send), or
 * - cancel transaction (ctdb_transaction_cancel_send)
 *
 * Starting a transaction will return a transaction handle.  This is used
 * for updating records under a transaction.  This handle is automatically
 * freed once the transacion is committed or cancelled.
 *
 * Clients should NOT free the transaction handle.
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] timeout How long to wait
 * @param[in] db Database context
 * @param[in] readonly Is transaction readonly
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_transaction_start_send(TALLOC_CTX *mem_ctx,
                                               struct tevent_context *ev,
                                               struct ctdb_client_context *client,
                                               struct timeval timeout,
                                               struct ctdb_db_context *db,
                                               bool readonly);

/**
 * @brief Async computation end to start a transaction
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return a new transaction handle on success, NULL on failure
 */
struct ctdb_transaction_handle *ctdb_transaction_start_recv(
                                        struct tevent_req *req,
                                        int *perr);

/**
 * @brief Sync wrapper to start a transaction
 *
 * @see ctdb_transaction_start_send
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] timeout How long to wait
 * @param[in] db Database context
 * @param[in] readonly Is transaction readonly
 * @param[out] result a new transaction handle
 * @return 0 on success, errno on failure
 */
int ctdb_transaction_start(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                           struct ctdb_client_context *client,
                           struct timeval timeout,
                           struct ctdb_db_context *db, bool readonly,
                           struct ctdb_transaction_handle **result);

/**
 * @brief Fetch a record under a transaction
 *
 * @see ctdb_transaction_start_send
 *
 * @param[in] h Transaction handle
 * @param[in] key Record key
 * @param[in] mem_ctx Talloc memory context
 * @param[out] data Record data
 * @return 0 on success, errno on failure
 */
int ctdb_transaction_fetch_record(struct ctdb_transaction_handle *h,
                                  TDB_DATA key,
                                  TALLOC_CTX *mem_ctx, TDB_DATA *data);

/**
 * @brief Store a record under a transaction
 *
 * @see ctdb_transaction_start_send
 *
 * @param[in] h Transaction handle
 * @param[in] key Record key
 * @param[in] data New record data
 * @return 0 on success, errno on failure
 */
int ctdb_transaction_store_record(struct ctdb_transaction_handle *h,
                                  TDB_DATA key, TDB_DATA data);

/**
 * @brief Delete a record under a transaction
 *
 * @see ctdb_transaction_start_send
 *
 * @param[in] h Transaction handle
 * @param[in] key Record key
 * @return 0 on success, errno on failure
 */
int ctdb_transaction_delete_record(struct ctdb_transaction_handle *h,
                                   TDB_DATA key);

/**
 * @brief Async computation start to commit a transaction
 *
 * @see ctdb_transaction_start_send
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] timeout How long to wait
 * @param[in] h Transaction handle
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_transaction_commit_send(
                                        TALLOC_CTX *mem_ctx,
                                        struct tevent_context *ev,
                                        struct timeval timeout,
                                        struct ctdb_transaction_handle *h);

/**
 * @brief Async computation end to commit a transaction
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_transaction_commit_recv(struct tevent_req *req, int *perr);

/**
 * @brief Sync wrapper to commit a transaction
 *
 * @see ctdb_transaction_commit_send
 *
 * @param[in] h Transaction handle
 * @return 0 on success, errno on failure
 */
int ctdb_transaction_commit(struct ctdb_transaction_handle *h);

/**
 * @brief Async computation start to cancel a transaction
 *
 * @see ctdb_transaction_start_send
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] timeout How long to wait
 * @param[in] h Transaction handle
 * @return a new tevent req on success, NULL on failure
 */
struct tevent_req *ctdb_transaction_cancel_send(
                                        TALLOC_CTX *mem_ctx,
                                        struct tevent_context *ev,
                                        struct timeval timeout,
                                        struct ctdb_transaction_handle *h);

/**
 * @brief Async computation end to cancel a transaction
 *
 * @param[in] req Tevent request
 * @param[out] perr errno in case of failure
 * @return true on success, false on failure
 */
bool ctdb_transaction_cancel_recv(struct tevent_req *req, int *perr);

/**
 * @brief Sync wrapper to cancel a transaction
 *
 * @see ctdb_transaction_cancel_send
 *
 * @param[in] h Transaction handle
 * @return 0 on success, errno on failure
 */
int ctdb_transaction_cancel(struct ctdb_transaction_handle *h);

/**
 * @brief Utility function to extract a list of node ids from nodemap
 *
 * @param[in] nodemap Node map
 * @param[in] flags_mask Flags to match on
 * @param[in] exclude_pnn Node id to exclude from the list
 * @param[in] mem_ctx Talloc memory context
 * @param[out] pnn_list List of node ids
 * @return number of node ids on success, -1 on failure
 */
int list_of_nodes(struct ctdb_node_map *nodemap,
                  uint32_t flags_mask, uint32_t exclude_pnn,
                  TALLOC_CTX *mem_ctx, uint32_t **pnn_list);

/**
 * @brief Utility function to extract a list of node ids for active nodes
 *
 * @param[in] nodemap Node map
 * @param[in] exclude_pnn Node id to exclude from the list
 * @param[in] mem_ctx Talloc memory context
 * @param[out] pnn_list List of node ids
 * @return number of node ids on success, -1 on failure
 */
int list_of_active_nodes(struct ctdb_node_map *nodemap, uint32_t exclude_pnn,
                         TALLOC_CTX *mem_ctx, uint32_t **pnn_list);

/**
 * @brief Utility function to extract a list of node ids for connected nodes
 *
 * @param[in] nodemap Node map
 * @param[in] exclude_pnn Node id to exclude from the list
 * @param[in] mem_ctx Talloc memory context
 * @param[out] pnn_list List of node ids
 * @return number of node ids on success, -1 on failure
 */
int list_of_connected_nodes(struct ctdb_node_map *nodemap,
                            uint32_t exclude_pnn,
                            TALLOC_CTX *mem_ctx, uint32_t **pnn_list);

/**
 * @brief Construct a new server id
 *
 * @param[in] client Client connection context
 * @param[in] task_id Task id
 * @return a new server id
 */
struct ctdb_server_id ctdb_client_get_server_id(
                                struct ctdb_client_context *client,
                                uint32_t task_id);

/**
 * @brief Check if two server ids are the same
 *
 * @param[in] sid1 Server id 1
 * @param[in] sid2 Server id 2
 * @return true if the server ids are same, false otherwise
 */
bool ctdb_server_id_equal(struct ctdb_server_id *sid1,
                          struct ctdb_server_id *sid2);

/**
 * @brief Check if the process with server id exists
 *
 * @param[in] mem_ctx Talloc memory context
 * @param[in] ev Tevent context
 * @param[in] client Client connection context
 * @param[in] sid Server id
 * @param[out] exists Boolean flag to indicate if the process exists
 * @return 0 on success, errno on failure
 */
int ctdb_server_id_exists(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                          struct ctdb_client_context *client,
                          struct ctdb_server_id *sid, bool *exists);

#endif /* __CTDB_CLIENT_H__ */