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 {CTDB_CONTROL_WAIT, CTDB_CONTROL_DONE, CTDB_CONTROL_ERROR, CTDB_CONTROL_TIMEOUT};
  27
  28 struct ctdb_client_control_state {
  29         struct ctdb_context *ctdb;
  30         uint32_t reqid;
  31         int32_t status;
  32         TDB_DATA outdata;
  33         enum control_state state;
  34         char *errormsg;
  35         struct ctdb_req_control *c;
  36
  37         /* if we have a callback registered for the completion (or failure) of
  38            this control
  39            if a callback is used, it MUST talloc_free the cb_data passed to it
  40         */
  41         struct {
  42                 void (*fn)(struct ctdb_client_control_state *);
  43                 void *private_data;
  44         } async;
  45 };
  46
  47 struct ctdb_client_notify_register {
  48         uint64_t srvid;
  49         uint32_t len;
  50         uint8_t notify_data[1];
  51 };
  52
  53 struct ctdb_client_notify_deregister {
  54         uint64_t srvid;
  55 };
  56
  57 struct tevent_context;
  58
  59 /*
  60   initialise ctdb subsystem
  61 */
  62 struct ctdb_context *ctdb_init(struct tevent_context *ev);
  63
  64 /*
  65   choose the transport
  66 */
  67 int ctdb_set_transport(struct ctdb_context *ctdb, const char *transport);
  68
  69 /*
  70   set some flags
  71 */
  72 void ctdb_set_flags(struct ctdb_context *ctdb, unsigned flags);
  73
  74 /*
  75   tell ctdb what address to listen on, in transport specific format
  76 */
  77 int ctdb_set_address(struct ctdb_context *ctdb, const char *address);
  78
  79 int ctdb_set_socketname(struct ctdb_context *ctdb, const char *socketname);
  80 const char *ctdb_get_socketname(struct ctdb_context *ctdb);
  81
  82 /*
  83   Check that a specific ip address exists in the node list and returns
  84   the id for the node or -1
  85 */
  86 int ctdb_ip_to_nodeid(struct ctdb_context *ctdb, const ctdb_sock_addr *nodeip);
  87
  88 /*
  89   attach to a ctdb database
  90 */
  91 struct ctdb_db_context *ctdb_attach(struct ctdb_context *ctdb,
  92                                     struct timeval timeout,
  93                                     const char *name,
  94                                     bool persistent,
  95                                     uint32_t tdb_flags);
  96
  97 int ctdb_detach(struct ctdb_context *ctdb, uint32_t db_id);
  98
  99 /* a ctdb call function */
 100 typedef int (*ctdb_fn_t)(struct ctdb_call_info *);
 101
 102 /*
 103   setup a ctdb call function
 104 */
 105 int ctdb_set_call(struct ctdb_db_context *ctdb_db, ctdb_fn_t fn, uint32_t id);
 106
 107
 108
 109 /*
 110   make a ctdb call. The associated ctdb call function will be called on the DMASTER
 111   for the given record
 112 */
 113 int ctdb_call(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
 114
 115 /* return pnn of this node */
 116 uint32_t ctdb_get_pnn(struct ctdb_context *ctdb);
 117
 118 /* setup a handler for ctdb messages */
 119 typedef void (*ctdb_msg_fn_t)(struct ctdb_context *, uint64_t srvid,
 120                                   TDB_DATA data, void *);
 121 int ctdb_client_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid,
 122                                     srvid_handler_fn handler,
 123                                     void *private_data);
 124 int ctdb_client_remove_message_handler(struct ctdb_context *ctdb,
 125                                        uint64_t srvid, void *private_data);
 126 int ctdb_client_check_message_handlers(struct ctdb_context *ctdb,
 127                                        uint64_t *ids, uint32_t num,
 128                                        uint8_t *result);
 129
 130 int ctdb_call(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
 131 struct ctdb_client_call_state *ctdb_call_send(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
 132 int ctdb_call_recv(struct ctdb_client_call_state *state, struct ctdb_call *call);
 133
 134 /* send a ctdb message */
 135 int ctdb_client_send_message(struct ctdb_context *ctdb, uint32_t pnn,
 136                       uint64_t srvid, TDB_DATA data);
 137
 138
 139 /*
 140    Fetch a ctdb record from a remote node
 141  . Underneath this will force the
 142    dmaster for the record to be moved to the local node.
 143 */
 144 struct ctdb_record_handle *ctdb_fetch_lock(struct ctdb_db_context *ctdb_db, TALLOC_CTX *mem_ctx,
 145                                            TDB_DATA key, TDB_DATA *data);
 146
 147 struct ctdb_record_handle *ctdb_fetch_readonly_lock(struct ctdb_db_context *ctdb_db, TALLOC_CTX *mem_ctx, TDB_DATA key, TDB_DATA *data, int read_only);
 148
 149 int ctdb_record_store(struct ctdb_record_handle *h, TDB_DATA data);
 150
 151 int ctdb_fetch(struct ctdb_db_context *ctdb_db, TALLOC_CTX *mem_ctx,
 152                TDB_DATA key, TDB_DATA *data);
 153
 154
 155 struct ctdb_statistics;
 156 int ctdb_ctrl_statistics(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_statistics *status);
 157 int ctdb_ctrl_dbstatistics(struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid,
 158                            TALLOC_CTX *mem_ctx, struct ctdb_db_statistics **dbstat);
 159
 160 int ctdb_ctrl_shutdown(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
 161
 162 struct ctdb_vnn_map;
 163 int ctdb_ctrl_getvnnmap(struct ctdb_context *ctdb,
 164                 struct timeval timeout, uint32_t destnode,
 165                 TALLOC_CTX *mem_ctx, struct ctdb_vnn_map **vnnmap);
 166 int ctdb_ctrl_setvnnmap(struct ctdb_context *ctdb,
 167                 struct timeval timeout, uint32_t destnode,
 168                 TALLOC_CTX *mem_ctx, struct ctdb_vnn_map *vnnmap);
 169
 170 /* table that contains a list of all dbids on a node
 171  */
 172 struct ctdb_dbid_map {
 173         uint32_t num;
 174         struct ctdb_dbid {
 175                 uint32_t dbid;
 176 #define CTDB_DB_FLAGS_PERSISTENT        0x01
 177 #define CTDB_DB_FLAGS_READONLY          0x02
 178 #define CTDB_DB_FLAGS_STICKY            0x04
 179                 uint8_t flags;
 180         } dbs[1];
 181 };
 182 int ctdb_ctrl_getdbmap(struct ctdb_context *ctdb,
 183         struct timeval timeout, uint32_t destnode,
 184         TALLOC_CTX *mem_ctx, struct ctdb_dbid_map **dbmap);
 185
 186
 187 struct ctdb_node_map;
 188
 189 int ctdb_ctrl_getnodemap(struct ctdb_context *ctdb,
 190                     struct timeval timeout, uint32_t destnode,
 191                     TALLOC_CTX *mem_ctx, struct ctdb_node_map **nodemap);
 192
 193 int ctdb_ctrl_getnodesfile(struct ctdb_context *ctdb,
 194                            struct timeval timeout, uint32_t destnode,
 195                            TALLOC_CTX *mem_ctx, struct ctdb_node_map **nodemap);
 196
 197 int ctdb_ctrl_reload_nodes_file(struct ctdb_context *ctdb,
 198                     struct timeval timeout, uint32_t destnode);
 199
 200 struct ctdb_key_list {
 201         uint32_t dbid;
 202         uint32_t num;
 203         TDB_DATA *keys;
 204         struct ctdb_ltdb_header *headers;
 205         TDB_DATA *data;
 206 };
 207
 208 int ctdb_ctrl_pulldb(
 209        struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid,
 210        uint32_t lmaster, TALLOC_CTX *mem_ctx,
 211        struct timeval timeout, TDB_DATA *outdata);
 212
 213 struct ctdb_client_control_state *ctdb_ctrl_pulldb_send(
 214        struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid,
 215        uint32_t lmaster, TALLOC_CTX *mem_ctx, struct timeval timeout);
 216
 217 int ctdb_ctrl_pulldb_recv(
 218        struct ctdb_context *ctdb,
 219        TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state,
 220        TDB_DATA *outdata);
 221
 222 int ctdb_ctrl_getdbpath(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t dbid, TALLOC_CTX *mem_ctx, const char **path);
 223 int ctdb_ctrl_getdbname(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t dbid, TALLOC_CTX *mem_ctx, const char **name);
 224 int ctdb_ctrl_getdbhealth(struct ctdb_context *ctdb,
 225                           struct timeval timeout,
 226                           uint32_t destnode,
 227                           uint32_t dbid, TALLOC_CTX *mem_ctx,
 228                           const char **reason);
 229 int ctdb_ctrl_getdbseqnum(struct ctdb_context *ctdb, struct timeval timeout,
 230                           uint32_t destnode, uint32_t dbid, uint64_t *seqnum);
 231 int ctdb_ctrl_createdb(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, TALLOC_CTX *mem_ctx, const char *name, bool persistent);
 232
 233 int ctdb_ctrl_process_exists(struct ctdb_context *ctdb, uint32_t destnode, pid_t pid);
 234
 235 int ctdb_ctrl_ping(struct ctdb_context *ctdb, uint32_t destnode);
 236
 237 int ctdb_ctrl_get_runstate(struct ctdb_context *ctdb,
 238                            struct timeval timeout,
 239                            uint32_t destnode,
 240                            uint32_t *runstate);
 241
 242 int ctdb_ctrl_get_debuglevel(struct ctdb_context *ctdb, uint32_t destnode, int32_t *level);
 243 int ctdb_ctrl_set_debuglevel(struct ctdb_context *ctdb, uint32_t destnode, int32_t level);
 244
 245 /*
 246   change dmaster for all keys in the database to the new value
 247  */
 248 int ctdb_ctrl_setdmaster(struct ctdb_context *ctdb,
 249         struct timeval timeout, uint32_t destnode,
 250         TALLOC_CTX *mem_ctx, uint32_t dbid, uint32_t dmaster);
 251
 252 #define CTDB_RECOVERY_NORMAL            0
 253 #define CTDB_RECOVERY_ACTIVE            1
 254
 255 /*
 256   get the recovery mode of a remote node
 257  */
 258 int ctdb_ctrl_getrecmode(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, uint32_t *recmode);
 259
 260 struct ctdb_client_control_state *ctdb_ctrl_getrecmode_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
 261
 262 int ctdb_ctrl_getrecmode_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *recmode);
 263
 264
 265 /*
 266   set the recovery mode of a remote node
 267  */
 268 int ctdb_ctrl_setrecmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t recmode);
 269 /*
 270   get the monitoring mode of a remote node
 271  */
 272 int ctdb_ctrl_getmonmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t *monmode);
 273
 274 /*
 275   set the monitoring mode of a remote node to active
 276  */
 277 int ctdb_ctrl_enable_monmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
 278
 279 /*
 280   set the monitoring mode of a remote node to disabled
 281  */
 282 int ctdb_ctrl_disable_monmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
 283
 284
 285 /*
 286   get the recovery master of a remote node
 287  */
 288 int ctdb_ctrl_getrecmaster(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, uint32_t *recmaster);
 289
 290 struct ctdb_client_control_state *ctdb_ctrl_getrecmaster_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
 291
 292 int ctdb_ctrl_getrecmaster_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *recmaster);
 293
 294
 295
 296 /*
 297   set the recovery master of a remote node
 298  */
 299 int ctdb_ctrl_setrecmaster(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t recmaster);
 300
 301 uint32_t *ctdb_get_connected_nodes(struct ctdb_context *ctdb,
 302                                    struct timeval timeout,
 303                                    TALLOC_CTX *mem_ctx,
 304                                    uint32_t *num_nodes);
 305
 306 int ctdb_statistics_reset(struct ctdb_context *ctdb, uint32_t destnode);
 307
 308 typedef int (*ctdb_traverse_func)(TDB_DATA, TDB_DATA, void *);
 309 int ctdb_traverse(struct ctdb_db_context *ctdb_db, ctdb_traverse_func fn, void *private_data);
 310
 311 struct ctdb_dump_db_context {
 312         struct ctdb_context *ctdb;
 313         FILE *f;
 314         bool printemptyrecords;
 315         bool printdatasize;
 316         bool printlmaster;
 317         bool printhash;
 318         bool printrecordflags;
 319 };
 320
 321 int ctdb_dumpdb_record(TDB_DATA key, TDB_DATA data, void *p);
 322 int ctdb_dump_db(struct ctdb_db_context *ctdb_db,
 323                  struct ctdb_dump_db_context *ctx);
 324
 325 /*
 326   get the pid of a ctdb daemon
 327  */
 328 int ctdb_ctrl_getpid(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t *pid);
 329
 330 int ctdb_ctrl_freeze(struct ctdb_context *ctdb, struct timeval timeout,
 331                         uint32_t destnode);
 332 int ctdb_ctrl_freeze_priority(struct ctdb_context *ctdb, struct timeval timeout,
 333                               uint32_t destnode, uint32_t priority);
 334
 335 struct ctdb_client_control_state *
 336 ctdb_ctrl_freeze_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 337                       struct timeval timeout, uint32_t destnode,
 338                       uint32_t priority);
 339
 340 int ctdb_ctrl_freeze_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
 341                         struct ctdb_client_control_state *state);
 342
 343 int ctdb_ctrl_thaw_priority(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t priority);
 344 int ctdb_ctrl_thaw(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
 345
 346 int ctdb_ctrl_getpnn(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
 347
 348 int ctdb_ctrl_get_tunable(struct ctdb_context *ctdb,
 349                           struct timeval timeout,
 350                           uint32_t destnode,
 351                           const char *name, uint32_t *value);
 352
 353 int ctdb_ctrl_set_tunable(struct ctdb_context *ctdb,
 354                           struct timeval timeout,
 355                           uint32_t destnode,
 356                           const char *name, uint32_t value);
 357
 358 int ctdb_ctrl_list_tunables(struct ctdb_context *ctdb,
 359                             struct timeval timeout,
 360                             uint32_t destnode,
 361                             TALLOC_CTX *mem_ctx,
 362                             const char ***list, uint32_t *count);
 363
 364 int ctdb_ctrl_modflags(struct ctdb_context *ctdb,
 365                        struct timeval timeout,
 366                        uint32_t destnode,
 367                        uint32_t set, uint32_t clear);
 368
 369 enum ctdb_server_id_type {
 370         SERVER_TYPE_SAMBA=1,
 371         SERVER_TYPE_NFSD=2,
 372         SERVER_TYPE_ISCSID=3
 373 };
 374
 375 struct ctdb_server_id {
 376         enum ctdb_server_id_type type;
 377         uint32_t pnn;
 378         uint32_t server_id;
 379 };
 380
 381 struct ctdb_server_id_list {
 382         uint32_t num;
 383         struct ctdb_server_id server_ids[1];
 384 };
 385
 386
 387 int ctdb_ctrl_register_server_id(struct ctdb_context *ctdb,
 388                 struct timeval timeout,
 389                 struct ctdb_server_id *id);
 390 int ctdb_ctrl_unregister_server_id(struct ctdb_context *ctdb,
 391                 struct timeval timeout,
 392                 struct ctdb_server_id *id);
 393 int ctdb_ctrl_check_server_id(struct ctdb_context *ctdb,
 394                 struct timeval timeout, uint32_t destnode,
 395                 struct ctdb_server_id *id, uint32_t *status);
 396 int ctdb_ctrl_get_server_id_list(struct ctdb_context *ctdb,
 397                 TALLOC_CTX *mem_ctx,
 398                 struct timeval timeout, uint32_t destnode,
 399                 struct ctdb_server_id_list **svid_list);
 400
 401 struct ctdb_uptime {
 402         struct timeval current_time;
 403         struct timeval ctdbd_start_time;
 404         struct timeval last_recovery_started;
 405         struct timeval last_recovery_finished;
 406 };
 407
 408 struct ctdb_control_tcp_addr {
 409         ctdb_sock_addr src;
 410         ctdb_sock_addr dest;
 411 };
 412
 413 int ctdb_socket_connect(struct ctdb_context *ctdb);
 414
 415 /*
 416   get the uptime of a remote node
 417  */
 418 int ctdb_ctrl_uptime(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, struct ctdb_uptime **uptime);
 419
 420 struct ctdb_client_control_state *ctdb_ctrl_uptime_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
 421
 422 int ctdb_ctrl_uptime_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, struct ctdb_uptime **uptime);
 423
 424 int ctdb_ctrl_end_recovery(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
 425
 426 int ctdb_ctrl_getreclock(struct ctdb_context *ctdb,
 427         struct timeval timeout, uint32_t destnode,
 428         TALLOC_CTX *mem_ctx, const char **reclock);
 429 int ctdb_ctrl_setreclock(struct ctdb_context *ctdb,
 430         struct timeval timeout, uint32_t destnode,
 431         const char *reclock);
 432
 433 struct ctdb_node_capabilities {
 434         bool retrieved;
 435         uint32_t capabilities;
 436 };
 437
 438 /* Retrieve capabilities for all connected nodes.  The length of the
 439  * returned array can be calculated using talloc_array_length(). */
 440 struct ctdb_node_capabilities *
 441 ctdb_get_capabilities(struct ctdb_context *ctdb,
 442                       TALLOC_CTX *mem_ctx,
 443                       struct timeval timeout,
 444                       struct ctdb_node_map *nodemap);
 445
 446 /* Get capabilities for specified node, NULL if not found */
 447 uint32_t *
 448 ctdb_get_node_capabilities(struct ctdb_node_capabilities *caps,
 449                            uint32_t pnn);
 450
 451 /* True if the given node has all of the required capabilities */
 452 bool ctdb_node_has_capabilities(struct ctdb_node_capabilities *caps,
 453                                 uint32_t pnn,
 454                                 uint32_t capabilities_required);
 455
 456 uint32_t *list_of_nodes(struct ctdb_context *ctdb,
 457                         struct ctdb_node_map *node_map,
 458                         TALLOC_CTX *mem_ctx,
 459                         uint32_t mask,
 460                         int exclude_pnn);
 461 uint32_t *list_of_connected_nodes(struct ctdb_context *ctdb,
 462                                 struct ctdb_node_map *node_map,
 463                                 TALLOC_CTX *mem_ctx,
 464                                 bool include_self);
 465 uint32_t *list_of_active_nodes(struct ctdb_context *ctdb,
 466                                 struct ctdb_node_map *node_map,
 467                                 TALLOC_CTX *mem_ctx,
 468                                 bool include_self);
 469 uint32_t *list_of_vnnmap_nodes(struct ctdb_context *ctdb,
 470                                 struct ctdb_vnn_map *vnn_map,
 471                                 TALLOC_CTX *mem_ctx,
 472                                 bool include_self);
 473
 474 int ctdb_read_pnn_lock(int fd, int32_t pnn);
 475
 476 /*
 477   get capabilities of a remote node
 478  */
 479 int ctdb_ctrl_getcapabilities(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t *capabilities);
 480
 481 struct ctdb_client_control_state *ctdb_ctrl_getcapabilities_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
 482
 483 int ctdb_ctrl_getcapabilities_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *capabilities);
 484
 485 struct ctdb_transaction_handle *ctdb_transaction_start(struct ctdb_db_context *ctdb_db,
 486                                                        TALLOC_CTX *mem_ctx);
 487 int ctdb_transaction_fetch(struct ctdb_transaction_handle *h,
 488                            TALLOC_CTX *mem_ctx,
 489                            TDB_DATA key, TDB_DATA *data);
 490 int ctdb_transaction_store(struct ctdb_transaction_handle *h,
 491                            TDB_DATA key, TDB_DATA data);
 492 int ctdb_transaction_commit(struct ctdb_transaction_handle *h);
 493 int ctdb_transaction_cancel(struct ctdb_transaction_handle *h);
 494
 495 int ctdb_ctrl_recd_ping(struct ctdb_context *ctdb);
 496
 497 int switch_from_server_to_client(struct ctdb_context *ctdb, const char *fmt,
 498                                  ...);
 499
 500 int ctdb_ctrl_getscriptstatus(struct ctdb_context *ctdb,
 501                     struct timeval timeout, uint32_t destnode,
 502                     TALLOC_CTX *mem_ctx, enum ctdb_eventscript_call type,
 503                     struct ctdb_scripts_wire **script_status);
 504
 505
 506 int ctdb_ctrl_stop_node(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
 507 int ctdb_ctrl_continue_node(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
 508
 509 int ctdb_ctrl_setnatgwstate(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t natgwstate);
 510 int ctdb_ctrl_setlmasterrole(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t lmasterrole);
 511 int ctdb_ctrl_setrecmasterrole(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t recmasterrole);
 512
 513 int ctdb_ctrl_enablescript(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, const char *script);
 514 int ctdb_ctrl_disablescript(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, const char *script);
 515
 516 struct ctdb_ban_time {
 517         uint32_t pnn;
 518         uint32_t time;
 519 };
 520
 521 int ctdb_ctrl_set_ban(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, struct ctdb_ban_time *bantime);
 522 int ctdb_ctrl_get_ban(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, TALLOC_CTX *mem_ctx, struct ctdb_ban_time **bantime);
 523
 524 struct ctdb_db_priority {
 525         uint32_t db_id;
 526         uint32_t priority;
 527 };
 528
 529 int ctdb_ctrl_set_db_priority(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, struct ctdb_db_priority *db_prio);
 530 int ctdb_ctrl_get_db_priority(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t db_id, uint32_t *priority);
 531
 532 int ctdb_ctrl_getstathistory(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, TALLOC_CTX *mem_ctx, struct ctdb_statistics_wire **stats);
 533
 534
 535
 536 struct ctdb_client_control_state *
 537 ctdb_ctrl_updaterecord_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, struct ctdb_db_context *ctdb_db, TDB_DATA key, struct ctdb_ltdb_header *header, TDB_DATA data);
 538
 539 int ctdb_ctrl_updaterecord_recv(struct ctdb_context *ctdb, struct ctdb_client_control_state *state);
 540
 541 int
 542 ctdb_ctrl_updaterecord(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, struct ctdb_db_context *ctdb_db, TDB_DATA key, struct ctdb_ltdb_header *header, TDB_DATA data);
 543
 544
 545 struct ctdb_client_control_state *
 546 ctdb_ctrl_set_db_readonly_send(struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid);
 547 int ctdb_ctrl_set_db_readonly_recv(struct ctdb_context *ctdb, struct ctdb_client_control_state *state);
 548 int ctdb_ctrl_set_db_readonly(struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid);
 549
 550 struct ctdb_client_control_state *
 551 ctdb_ctrl_set_db_sticky_send(struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid);
 552 int ctdb_ctrl_set_db_sticky_recv(struct ctdb_context *ctdb, struct ctdb_client_control_state *state);
 553 int ctdb_ctrl_set_db_sticky(struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid);
 554
 555 #endif /* _CTDB_CLIENT_H */