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