ctdb/include/ctdb_client.h

   1 /*
   2    ctdb database library: old client interface
   3
   4    Copyright (C) Andrew Tridgell  2006
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #ifndef _CTDB_CLIENT_H
  21 #define _CTDB_CLIENT_H
  22
  23 #include "common/srvid.h"
  24 #include "ctdb_protocol.h"
  25
  26 enum control_state {
  27         CTDB_CONTROL_WAIT,
  28         CTDB_CONTROL_DONE,
  29         CTDB_CONTROL_ERROR,
  30         CTDB_CONTROL_TIMEOUT
  31 };
  32
  33 struct ctdb_client_control_state {
  34         struct ctdb_context *ctdb;
  35         uint32_t reqid;
  36         int32_t status;
  37         TDB_DATA outdata;
  38         enum control_state state;
  39         char *errormsg;
  40         struct ctdb_req_control_old *c;
  41
  42         /* if we have a callback registered for the completion (or failure) of
  43            this control
  44            if a callback is used, it MUST talloc_free the cb_data passed to it
  45         */
  46         struct {
  47                 void (*fn)(struct ctdb_client_control_state *);
  48                 void *private_data;
  49         } async;
  50 };
  51
  52 struct tevent_context;
  53 struct ctdb_db_context;
  54
  55 /*
  56   allocate a packet for use in client<->daemon communication
  57  */
  58 struct ctdb_req_header *_ctdbd_allocate_pkt(struct ctdb_context *ctdb,
  59                                             TALLOC_CTX *mem_ctx,
  60                                             enum ctdb_operation operation,
  61                                             size_t length, size_t slength,
  62                                             const char *type);
  63
  64 #define ctdbd_allocate_pkt(ctdb, mem_ctx, operation, length, type) \
  65         (type *)_ctdbd_allocate_pkt(ctdb, mem_ctx, operation, length, \
  66                                     sizeof(type), #type)
  67
  68 int ctdb_call_local(struct ctdb_db_context *ctdb_db, struct ctdb_call *call,
  69                     struct ctdb_ltdb_header *header, TALLOC_CTX *mem_ctx,
  70                     TDB_DATA *data, bool updatetdb);
  71
  72 void ctdb_request_message(struct ctdb_context *ctdb,
  73                           struct ctdb_req_header *hdr);
  74
  75 void ctdb_client_read_cb(uint8_t *data, size_t cnt, void *args);
  76
  77 int ctdb_socket_connect(struct ctdb_context *ctdb);
  78
  79 /*
  80   make a ctdb call. The associated ctdb call function will be called on the DMASTER
  81   for the given record
  82 */
  83 struct ctdb_client_call_state *ctdb_call_send(struct ctdb_db_context *ctdb_db,
  84                                               struct ctdb_call *call);
  85 int ctdb_call_recv(struct ctdb_client_call_state *state,
  86                    struct ctdb_call *call);
  87 int ctdb_call(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
  88
  89 /* setup a handler for ctdb messages */
  90 typedef void (*ctdb_msg_fn_t)(struct ctdb_context *, uint64_t srvid,
  91                               TDB_DATA data, void *);
  92
  93 int ctdb_client_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid,
  94                                     srvid_handler_fn handler,
  95                                     void *private_data);
  96 int ctdb_client_remove_message_handler(struct ctdb_context *ctdb,
  97                                        uint64_t srvid, void *private_data);
  98 int ctdb_client_check_message_handlers(struct ctdb_context *ctdb,
  99                                        uint64_t *ids, uint32_t num,
 100                                        uint8_t *result);
 101
 102 /* send a ctdb message */
 103 int ctdb_client_send_message(struct ctdb_context *ctdb, uint32_t pnn,
 104                              uint64_t srvid, TDB_DATA data);
 105
 106 /*
 107    Fetch a ctdb record from a remote node. Underneath this will force the
 108    dmaster for the record to be moved to the local node.
 109 */
 110 struct ctdb_record_handle *ctdb_fetch_lock(struct ctdb_db_context *ctdb_db,
 111                                            TALLOC_CTX *mem_ctx,
 112                                            TDB_DATA key, TDB_DATA *data);
 113
 114 struct ctdb_record_handle *ctdb_fetch_readonly_lock(
 115                                         struct ctdb_db_context *ctdb_db,
 116                                         TALLOC_CTX *mem_ctx, TDB_DATA key,
 117                                         TDB_DATA *data, int read_only);
 118
 119 int ctdb_record_store(struct ctdb_record_handle *h, TDB_DATA data);
 120
 121 int ctdb_fetch(struct ctdb_db_context *ctdb_db, TALLOC_CTX *mem_ctx,
 122                TDB_DATA key, TDB_DATA *data);
 123
 124 struct ctdb_client_control_state *ctdb_control_send(struct ctdb_context *ctdb,
 125                                                     uint32_t destnode,
 126                                                     uint64_t srvid,
 127                                                     uint32_t opcode,
 128                                                     uint32_t flags,
 129                                                     TDB_DATA data,
 130                                                     TALLOC_CTX *mem_ctx,
 131                                                     struct timeval *timeout,
 132                                                     char **errormsg);
 133 int ctdb_control_recv(struct ctdb_context *ctdb,
 134                       struct ctdb_client_control_state *state,
 135                       TALLOC_CTX *mem_ctx, TDB_DATA *outdata,
 136                       int32_t *status, char **errormsg);
 137 int ctdb_control(struct ctdb_context *ctdb, uint32_t destnode, uint64_t srvid,
 138                  uint32_t opcode, uint32_t flags, TDB_DATA data,
 139                  TALLOC_CTX *mem_ctx, TDB_DATA *outdata, int32_t *status,
 140                  struct timeval *timeout, char **errormsg);
 141
 142 int ctdb_ctrl_process_exists(struct ctdb_context *ctdb, uint32_t destnode,
 143                              pid_t pid);
 144
 145 int ctdb_ctrl_statistics(struct ctdb_context *ctdb, uint32_t destnode,
 146                          struct ctdb_statistics *status);
 147 int ctdb_ctrl_dbstatistics(struct ctdb_context *ctdb, uint32_t destnode,
 148                            uint32_t dbid, TALLOC_CTX *mem_ctx,
 149                            struct ctdb_db_statistics_old **dbstat);
 150
 151 int ctdb_ctrl_shutdown(struct ctdb_context *ctdb, struct timeval timeout,
 152                        uint32_t destnode);
 153
 154 int ctdb_ctrl_getvnnmap(struct ctdb_context *ctdb, struct timeval timeout,
 155                         uint32_t destnode, TALLOC_CTX *mem_ctx,
 156                         struct ctdb_vnn_map **vnnmap);
 157 int ctdb_ctrl_setvnnmap(struct ctdb_context *ctdb, struct timeval timeout,
 158                         uint32_t destnode, TALLOC_CTX *mem_ctx,
 159                         struct ctdb_vnn_map *vnnmap);
 160
 161 /*
 162   get the recovery mode of a remote node
 163  */
 164 struct ctdb_client_control_state *ctdb_ctrl_getrecmode_send(
 165                                         struct ctdb_context *ctdb,
 166                                         TALLOC_CTX *mem_ctx,
 167                                         struct timeval timeout,
 168                                         uint32_t destnode);
 169 int ctdb_ctrl_getrecmode_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 170                               struct ctdb_client_control_state *state,
 171                               uint32_t *recmode);
 172 int ctdb_ctrl_getrecmode(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 173                          struct timeval timeout, uint32_t destnode,
 174                          uint32_t *recmode);
 175
 176 /*
 177   set the recovery mode of a remote node
 178  */
 179 int ctdb_ctrl_setrecmode(struct ctdb_context *ctdb, struct timeval timeout,
 180                          uint32_t destnode, uint32_t recmode);
 181
 182 /*
 183   get the recovery master of a remote node
 184  */
 185 struct ctdb_client_control_state *ctdb_ctrl_getrecmaster_send(
 186                                         struct ctdb_context *ctdb,
 187                                         TALLOC_CTX *mem_ctx,
 188                                         struct timeval timeout,
 189                                         uint32_t destnode);
 190 int ctdb_ctrl_getrecmaster_recv(struct ctdb_context *ctdb,
 191                                 TALLOC_CTX *mem_ctx,
 192                                 struct ctdb_client_control_state *state,
 193                                 uint32_t *recmaster);
 194 int ctdb_ctrl_getrecmaster(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 195                            struct timeval timeout, uint32_t destnode,
 196                            uint32_t *recmaster);
 197
 198 /*
 199   set the recovery master of a remote node
 200  */
 201 int ctdb_ctrl_setrecmaster(struct ctdb_context *ctdb, struct timeval timeout,
 202                            uint32_t destnode, uint32_t recmaster);
 203
 204 int ctdb_ctrl_getdbmap(struct ctdb_context *ctdb, struct timeval timeout,
 205                        uint32_t destnode, TALLOC_CTX *mem_ctx,
 206                        struct ctdb_dbid_map_old **dbmap);
 207
 208 int ctdb_ctrl_getnodemap(struct ctdb_context *ctdb, struct timeval timeout,
 209                          uint32_t destnode, TALLOC_CTX *mem_ctx,
 210                          struct ctdb_node_map_old **nodemap);
 211
 212 int ctdb_ctrl_getnodesfile(struct ctdb_context *ctdb, struct timeval timeout,
 213                            uint32_t destnode, TALLOC_CTX *mem_ctx,
 214                            struct ctdb_node_map_old **nodemap);
 215
 216 int ctdb_ctrl_reload_nodes_file(struct ctdb_context *ctdb,
 217                                 struct timeval timeout, uint32_t destnode);
 218
 219 struct ctdb_client_control_state *ctdb_ctrl_pulldb_send(
 220                                         struct ctdb_context *ctdb,
 221                                         uint32_t destnode, uint32_t dbid,
 222                                         uint32_t lmaster, TALLOC_CTX *mem_ctx,
 223                                         struct timeval timeout);
 224 int ctdb_ctrl_pulldb_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 225                           struct ctdb_client_control_state *state,
 226                           TDB_DATA *outdata);
 227 int ctdb_ctrl_pulldb(struct ctdb_context *ctdb, uint32_t destnode,
 228                      uint32_t dbid, uint32_t lmaster, TALLOC_CTX *mem_ctx,
 229                      struct timeval timeout, TDB_DATA *outdata);
 230
 231 /*
 232   change dmaster for all keys in the database to the new value
 233  */
 234 int ctdb_ctrl_setdmaster(struct ctdb_context *ctdb, struct timeval timeout,
 235                          uint32_t destnode, TALLOC_CTX *mem_ctx,
 236                          uint32_t dbid, uint32_t dmaster);
 237
 238 int ctdb_ctrl_ping(struct ctdb_context *ctdb, uint32_t destnode);
 239
 240 int ctdb_ctrl_get_runstate(struct ctdb_context *ctdb, struct timeval timeout,
 241                            uint32_t destnode, uint32_t *runstate);
 242
 243 int ctdb_ctrl_getdbpath(struct ctdb_context *ctdb, struct timeval timeout,
 244                         uint32_t destnode, uint32_t dbid,
 245                         TALLOC_CTX *mem_ctx, const char **path);
 246 int ctdb_ctrl_getdbname(struct ctdb_context *ctdb, struct timeval timeout,
 247                         uint32_t destnode, uint32_t dbid,
 248                         TALLOC_CTX *mem_ctx, const char **name);
 249 int ctdb_ctrl_getdbhealth(struct ctdb_context *ctdb, struct timeval timeout,
 250                           uint32_t destnode, uint32_t dbid,
 251                           TALLOC_CTX *mem_ctx, const char **reason);
 252 int ctdb_ctrl_getdbseqnum(struct ctdb_context *ctdb, struct timeval timeout,
 253                           uint32_t destnode, uint32_t dbid, uint64_t *seqnum);
 254
 255 int ctdb_ctrl_createdb(struct ctdb_context *ctdb, struct timeval timeout,
 256                        uint32_t destnode, TALLOC_CTX *mem_ctx,
 257                        const char *name, bool persistent);
 258
 259 int ctdb_ctrl_get_debuglevel(struct ctdb_context *ctdb, uint32_t destnode,
 260                              int32_t *level);
 261 int ctdb_ctrl_set_debuglevel(struct ctdb_context *ctdb, uint32_t destnode,
 262                              int32_t level);
 263
 264 uint32_t *ctdb_get_connected_nodes(struct ctdb_context *ctdb,
 265                                    struct timeval timeout,
 266                                    TALLOC_CTX *mem_ctx, uint32_t *num_nodes);
 267
 268 int ctdb_statistics_reset(struct ctdb_context *ctdb, uint32_t destnode);
 269
 270 /*
 271   attach to a ctdb database
 272 */
 273 struct ctdb_db_context *ctdb_attach(struct ctdb_context *ctdb,
 274                                     struct timeval timeout,
 275                                     const char *name,
 276                                     bool persistent,
 277                                     uint32_t tdb_flags);
 278
 279 int ctdb_detach(struct ctdb_context *ctdb, uint32_t db_id);
 280
 281 /* a ctdb call function */
 282 typedef int (*ctdb_fn_t)(struct ctdb_call_info *);
 283
 284 /*
 285   setup a ctdb call function
 286 */
 287 int ctdb_set_call(struct ctdb_db_context *ctdb_db, ctdb_fn_t fn, uint32_t id);
 288
 289
 290 typedef int (*ctdb_traverse_func)(TDB_DATA, TDB_DATA, void *);
 291
 292 int ctdb_traverse(struct ctdb_db_context *ctdb_db, ctdb_traverse_func fn,
 293                   void *private_data);
 294
 295 struct ctdb_dump_db_context {
 296         struct ctdb_context *ctdb;
 297         FILE *f;
 298         bool printemptyrecords;
 299         bool printdatasize;
 300         bool printlmaster;
 301         bool printhash;
 302         bool printrecordflags;
 303 };
 304
 305 int ctdb_dumpdb_record(TDB_DATA key, TDB_DATA data, void *p);
 306 int ctdb_dump_db(struct ctdb_db_context *ctdb_db,
 307                  struct ctdb_dump_db_context *ctx);
 308
 309 /*
 310   get the pid of a ctdb daemon
 311  */
 312 int ctdb_ctrl_getpid(struct ctdb_context *ctdb, struct timeval timeout,
 313                      uint32_t destnode, uint32_t *pid);
 314
 315 struct ctdb_client_control_state *ctdb_ctrl_freeze_send(
 316                                         struct ctdb_context *ctdb,
 317                                         TALLOC_CTX *mem_ctx,
 318                                         struct timeval timeout,
 319                                         uint32_t destnode, uint32_t priority);
 320 int ctdb_ctrl_freeze_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 321                           struct ctdb_client_control_state *state);
 322
 323 int ctdb_ctrl_freeze_priority(struct ctdb_context *ctdb, struct timeval timeout,
 324                               uint32_t destnode, uint32_t priority);
 325 int ctdb_ctrl_freeze(struct ctdb_context *ctdb, struct timeval timeout,
 326                      uint32_t destnode);
 327
 328 int ctdb_ctrl_thaw_priority(struct ctdb_context *ctdb, struct timeval timeout,
 329                             uint32_t destnode, uint32_t priority);
 330 int ctdb_ctrl_thaw(struct ctdb_context *ctdb, struct timeval timeout,
 331                    uint32_t destnode);
 332
 333 int ctdb_ctrl_getpnn(struct ctdb_context *ctdb, struct timeval timeout,
 334                      uint32_t destnode);
 335
 336 /*
 337   get the monitoring mode of a remote node
 338  */
 339 int ctdb_ctrl_getmonmode(struct ctdb_context *ctdb, struct timeval timeout,
 340                          uint32_t destnode, uint32_t *monmode);
 341
 342 /*
 343   set the monitoring mode of a remote node to active
 344  */
 345 int ctdb_ctrl_enable_monmode(struct ctdb_context *ctdb,
 346                              struct timeval timeout, uint32_t destnode);
 347
 348 /*
 349   set the monitoring mode of a remote node to disabled
 350  */
 351 int ctdb_ctrl_disable_monmode(struct ctdb_context *ctdb,
 352                               struct timeval timeout, uint32_t destnode);
 353
 354 int ctdb_ctrl_takeover_ip(struct ctdb_context *ctdb, struct timeval timeout,
 355                           uint32_t destnode, struct ctdb_public_ip *ip);
 356 int ctdb_ctrl_release_ip(struct ctdb_context *ctdb, struct timeval timeout,
 357                          uint32_t destnode, struct ctdb_public_ip *ip);
 358
 359 int ctdb_ctrl_get_tunable(struct ctdb_context *ctdb,
 360                           struct timeval timeout, uint32_t destnode,
 361                           const char *name, uint32_t *value);
 362 int ctdb_ctrl_set_tunable(struct ctdb_context *ctdb,
 363                           struct timeval timeout, uint32_t destnode,
 364                           const char *name, uint32_t value);
 365 int ctdb_ctrl_list_tunables(struct ctdb_context *ctdb,
 366                             struct timeval timeout, uint32_t destnode,
 367                             TALLOC_CTX *mem_ctx,
 368                             const char ***list, uint32_t *count);
 369
 370 int ctdb_ctrl_get_public_ips_flags(struct ctdb_context *ctdb,
 371                                    struct timeval timeout, uint32_t destnode,
 372                                    TALLOC_CTX *mem_ctx, uint32_t flags,
 373                                    struct ctdb_public_ip_list_old **ips);
 374 int ctdb_ctrl_get_public_ips(struct ctdb_context *ctdb,
 375                              struct timeval timeout, uint32_t destnode,
 376                              TALLOC_CTX *mem_ctx,
 377                              struct ctdb_public_ip_list_old **ips);
 378 int ctdb_ctrl_get_public_ip_info(struct ctdb_context *ctdb,
 379                                  struct timeval timeout, uint32_t destnode,
 380                                  TALLOC_CTX *mem_ctx,
 381                                  const ctdb_sock_addr *addr,
 382                                  struct ctdb_public_ip_info_old **info);
 383
 384 int ctdb_ctrl_get_ifaces(struct ctdb_context *ctdb,
 385                          struct timeval timeout, uint32_t destnode,
 386                          TALLOC_CTX *mem_ctx,
 387                          struct ctdb_iface_list_old **ifaces);
 388 int ctdb_ctrl_set_iface_link(struct ctdb_context *ctdb,
 389                              struct timeval timeout, uint32_t destnode,
 390                              TALLOC_CTX *mem_ctx,
 391                              const struct ctdb_iface *info);
 392
 393 int ctdb_ctrl_modflags(struct ctdb_context *ctdb,
 394                        struct timeval timeout,
 395                        uint32_t destnode,
 396                        uint32_t set, uint32_t clear);
 397
 398 int ctdb_ctrl_get_all_tunables(struct ctdb_context *ctdb,
 399                                struct timeval timeout, uint32_t destnode,
 400                                struct ctdb_tunable_list *tunables);
 401
 402 int ctdb_ctrl_add_public_ip(struct ctdb_context *ctdb,
 403                             struct timeval timeout, uint32_t destnode,
 404                             struct ctdb_addr_info_old *pub);
 405 int ctdb_ctrl_del_public_ip(struct ctdb_context *ctdb,
 406                             struct timeval timeout, uint32_t destnode,
 407                             struct ctdb_addr_info_old *pub);
 408
 409 int ctdb_ctrl_killtcp(struct ctdb_context *ctdb,
 410                       struct timeval timeout, uint32_t destnode,
 411                       struct ctdb_connection *killtcp);
 412
 413 int ctdb_ctrl_gratious_arp(struct ctdb_context *ctdb,
 414                            struct timeval timeout, uint32_t destnode,
 415                            ctdb_sock_addr *addr, const char *ifname);
 416
 417 int ctdb_ctrl_get_tcp_tickles(struct ctdb_context *ctdb,
 418                               struct timeval timeout, uint32_t destnode,
 419                               TALLOC_CTX *mem_ctx, ctdb_sock_addr *addr,
 420                               struct ctdb_tickle_list_old **list);
 421
 422 int ctdb_ctrl_register_server_id(struct ctdb_context *ctdb,
 423                                  struct timeval timeout,
 424                                  struct ctdb_client_id *id);
 425 int ctdb_ctrl_unregister_server_id(struct ctdb_context *ctdb,
 426                                    struct timeval timeout,
 427                                    struct ctdb_client_id *id);
 428 int ctdb_ctrl_check_server_id(struct ctdb_context *ctdb,
 429                               struct timeval timeout, uint32_t destnode,
 430                               struct ctdb_client_id *id, uint32_t *status);
 431 int ctdb_ctrl_get_server_id_list(struct ctdb_context *ctdb,
 432                                  TALLOC_CTX *mem_ctx,
 433                                  struct timeval timeout, uint32_t destnode,
 434                                  struct ctdb_client_id_list_old **svid_list);
 435
 436 /*
 437   initialise ctdb subsystem
 438 */
 439 struct ctdb_context *ctdb_init(struct tevent_context *ev);
 440
 441 /*
 442   set some flags
 443 */
 444 void ctdb_set_flags(struct ctdb_context *ctdb, unsigned flags);
 445
 446 int ctdb_set_socketname(struct ctdb_context *ctdb, const char *socketname);
 447 const char *ctdb_get_socketname(struct ctdb_context *ctdb);
 448
 449 /* return pnn of this node */
 450 uint32_t ctdb_get_pnn(struct ctdb_context *ctdb);
 451
 452 /*
 453   get the uptime of a remote node
 454  */
 455 struct ctdb_client_control_state *ctdb_ctrl_uptime_send(
 456                                         struct ctdb_context *ctdb,
 457                                         TALLOC_CTX *mem_ctx,
 458                                         struct timeval timeout,
 459                                         uint32_t destnode);
 460 int ctdb_ctrl_uptime_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 461                           struct ctdb_client_control_state *state,
 462                           struct ctdb_uptime **uptime);
 463 int ctdb_ctrl_uptime(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 464                      struct timeval timeout, uint32_t destnode,
 465                      struct ctdb_uptime **uptime);
 466
 467 int ctdb_ctrl_end_recovery(struct ctdb_context *ctdb, struct timeval timeout,
 468                            uint32_t destnode);
 469
 470 typedef void (*client_async_callback)(struct ctdb_context *ctdb,
 471                                       uint32_t node_pnn, int32_t res,
 472                                       TDB_DATA outdata, void *callback_data);
 473
 474 struct client_async_data {
 475         enum ctdb_controls opcode;
 476         bool dont_log_errors;
 477         uint32_t count;
 478         uint32_t fail_count;
 479         client_async_callback callback;
 480         client_async_callback fail_callback;
 481         void *callback_data;
 482 };
 483
 484 void ctdb_client_async_add(struct client_async_data *data,
 485                            struct ctdb_client_control_state *state);
 486 int ctdb_client_async_wait(struct ctdb_context *ctdb,
 487                            struct client_async_data *data);
 488 int ctdb_client_async_control(struct ctdb_context *ctdb,
 489                               enum ctdb_controls opcode, uint32_t *nodes,
 490                               uint64_t srvid, struct timeval timeout,
 491                               bool dont_log_errors, TDB_DATA data,
 492                               client_async_callback client_callback,
 493                               client_async_callback fail_callback,
 494                               void *callback_data);
 495
 496 uint32_t *list_of_vnnmap_nodes(struct ctdb_context *ctdb,
 497                                struct ctdb_vnn_map *vnn_map,
 498                                TALLOC_CTX *mem_ctx, bool include_self);
 499
 500 uint32_t *list_of_nodes(struct ctdb_context *ctdb,
 501                         struct ctdb_node_map_old *node_map,
 502                         TALLOC_CTX *mem_ctx, uint32_t mask, int exclude_pnn);
 503 uint32_t *list_of_active_nodes(struct ctdb_context *ctdb,
 504                                struct ctdb_node_map_old *node_map,
 505                                TALLOC_CTX *mem_ctx, bool include_self);
 506 uint32_t *list_of_connected_nodes(struct ctdb_context *ctdb,
 507                                   struct ctdb_node_map_old *node_map,
 508                                   TALLOC_CTX *mem_ctx, bool include_self);
 509
 510 int ctdb_read_pnn_lock(int fd, int32_t pnn);
 511
 512 /*
 513   get capabilities of a remote node
 514  */
 515
 516 struct ctdb_client_control_state *ctdb_ctrl_getcapabilities_send(
 517                                         struct ctdb_context *ctdb,
 518                                         TALLOC_CTX *mem_ctx,
 519                                         struct timeval timeout,
 520                                         uint32_t destnode);
 521 int ctdb_ctrl_getcapabilities_recv(struct ctdb_context *ctdb,
 522                                    TALLOC_CTX *mem_ctx,
 523                                    struct ctdb_client_control_state *state,
 524                                    uint32_t *capabilities);
 525 int ctdb_ctrl_getcapabilities(struct ctdb_context *ctdb,
 526                               struct timeval timeout, uint32_t destnode,
 527                               uint32_t *capabilities);
 528
 529 struct ctdb_node_capabilities {
 530         bool retrieved;
 531         uint32_t capabilities;
 532 };
 533
 534 /* Retrieve capabilities for all connected nodes.  The length of the
 535  * returned array can be calculated using talloc_array_length(). */
 536 struct ctdb_node_capabilities *ctdb_get_capabilities(
 537                                         struct ctdb_context *ctdb,
 538                                         TALLOC_CTX *mem_ctx,
 539                                         struct timeval timeout,
 540                                         struct ctdb_node_map_old *nodemap);
 541
 542 /* Get capabilities for specified node, NULL if not found */
 543 uint32_t *ctdb_get_node_capabilities(struct ctdb_node_capabilities *caps,
 544                                      uint32_t pnn);
 545
 546 /* True if the given node has all of the required capabilities */
 547 bool ctdb_node_has_capabilities(struct ctdb_node_capabilities *caps,
 548                                 uint32_t pnn, uint32_t capabilities_required);
 549
 550
 551 struct ctdb_transaction_handle *ctdb_transaction_start(
 552                                         struct ctdb_db_context *ctdb_db,
 553                                         TALLOC_CTX *mem_ctx);
 554 int ctdb_transaction_fetch(struct ctdb_transaction_handle *h,
 555                            TALLOC_CTX *mem_ctx,
 556                            TDB_DATA key, TDB_DATA *data);
 557 int ctdb_transaction_store(struct ctdb_transaction_handle *h,
 558                            TDB_DATA key, TDB_DATA data);
 559 int ctdb_transaction_commit(struct ctdb_transaction_handle *h);
 560 int ctdb_transaction_cancel(struct ctdb_transaction_handle *h);
 561
 562 int ctdb_ctrl_recd_ping(struct ctdb_context *ctdb);
 563
 564 int ctdb_ctrl_getscriptstatus(struct ctdb_context *ctdb,
 565                               struct timeval timeout, uint32_t destnode,
 566                               TALLOC_CTX *mem_ctx,
 567                               enum ctdb_event type,
 568                               struct ctdb_script_list_old **script_status);
 569
 570 int ctdb_ctrl_report_recd_lock_latency(struct ctdb_context *ctdb,
 571                                        struct timeval timeout, double latency);
 572
 573 int ctdb_ctrl_getreclock(struct ctdb_context *ctdb,
 574                          struct timeval timeout, uint32_t destnode,
 575                          TALLOC_CTX *mem_ctx, const char **reclock);
 576 int ctdb_ctrl_setreclock(struct ctdb_context *ctdb,
 577                          struct timeval timeout, uint32_t destnode,
 578                          const char *reclock);
 579
 580 int ctdb_ctrl_stop_node(struct ctdb_context *ctdb, struct timeval timeout,
 581                         uint32_t destnode);
 582 int ctdb_ctrl_continue_node(struct ctdb_context *ctdb, struct timeval timeout,
 583                             uint32_t destnode);
 584
 585 int ctdb_ctrl_setnatgwstate(struct ctdb_context *ctdb,
 586                             struct timeval timeout, uint32_t destnode,
 587                             uint32_t natgwstate);
 588 int ctdb_ctrl_setlmasterrole(struct ctdb_context *ctdb,
 589                              struct timeval timeout, uint32_t destnode,
 590                              uint32_t lmasterrole);
 591 int ctdb_ctrl_setrecmasterrole(struct ctdb_context *ctdb,
 592                                struct timeval timeout, uint32_t destnode,
 593                                uint32_t recmasterrole);
 594
 595 int ctdb_ctrl_enablescript(struct ctdb_context *ctdb, struct timeval timeout,
 596                            uint32_t destnode, const char *script);
 597 int ctdb_ctrl_disablescript(struct ctdb_context *ctdb, struct timeval timeout,
 598                             uint32_t destnode, const char *script);
 599
 600 int ctdb_ctrl_set_ban(struct ctdb_context *ctdb, struct timeval timeout,
 601                       uint32_t destnode, struct ctdb_ban_state *bantime);
 602 int ctdb_ctrl_get_ban(struct ctdb_context *ctdb, struct timeval timeout,
 603                       uint32_t destnode, TALLOC_CTX *mem_ctx,
 604                       struct ctdb_ban_state **bantime);
 605
 606 int ctdb_ctrl_set_db_priority(struct ctdb_context *ctdb,
 607                               struct timeval timeout, uint32_t destnode,
 608                               struct ctdb_db_priority *db_prio);
 609 int ctdb_ctrl_get_db_priority(struct ctdb_context *ctdb,
 610                               struct timeval timeout, uint32_t destnode,
 611                               uint32_t db_id, uint32_t *priority);
 612
 613 int ctdb_ctrl_getstathistory(struct ctdb_context *ctdb,
 614                              struct timeval timeout, uint32_t destnode,
 615                              TALLOC_CTX *mem_ctx,
 616                              struct ctdb_statistics_list_old **stats);
 617
 618 struct ctdb_ltdb_header *ctdb_header_from_record_handle(
 619                                         struct ctdb_record_handle *h);
 620
 621 struct ctdb_client_control_state *ctdb_ctrl_updaterecord_send(
 622                                         struct ctdb_context *ctdb,
 623                                         TALLOC_CTX *mem_ctx,
 624                                         struct timeval timeout,
 625                                         uint32_t destnode,
 626                                         struct ctdb_db_context *ctdb_db,
 627                                         TDB_DATA key,
 628                                         struct ctdb_ltdb_header *header,
 629                                         TDB_DATA data);
 630 int ctdb_ctrl_updaterecord_recv(struct ctdb_context *ctdb,
 631                                 struct ctdb_client_control_state *state);
 632 int ctdb_ctrl_updaterecord(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 633                            struct timeval timeout, uint32_t destnode,
 634                            struct ctdb_db_context *ctdb_db, TDB_DATA key,
 635                            struct ctdb_ltdb_header *header, TDB_DATA data);
 636
 637 struct ctdb_client_control_state *ctdb_ctrl_set_db_readonly_send(
 638                                         struct ctdb_context *ctdb,
 639                                         uint32_t destnode, uint32_t dbid);
 640 int ctdb_ctrl_set_db_readonly_recv(struct ctdb_context *ctdb,
 641                                    struct ctdb_client_control_state *state);
 642 int ctdb_ctrl_set_db_readonly(struct ctdb_context *ctdb, uint32_t destnode,
 643                               uint32_t dbid);
 644
 645 struct ctdb_client_control_state *ctdb_ctrl_set_db_sticky_send(
 646                                         struct ctdb_context *ctdb,
 647                                         uint32_t destnode, uint32_t dbid);
 648 int ctdb_ctrl_set_db_sticky_recv(struct ctdb_context *ctdb,
 649                                  struct ctdb_client_control_state *state);
 650 int ctdb_ctrl_set_db_sticky(struct ctdb_context *ctdb, uint32_t destnode,
 651                             uint32_t dbid);
 652
 653 #endif /* _CTDB_CLIENT_H */