sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
Code
290559e53d
samba-mirror/ctdb/include/ctdb_client.h

623 lines
21 KiB
C
Raw Normal View History

libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
/*
ctdb database library: old client interface
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
Copyright (C) Andrew Tridgell 2006
ctdb is GPL not LGPL (This used to be ctdb commit 8624378010d1c2a1438e1e701339dfba7276f960)
2007-05-31 07:50:53 +04:00
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
update lib/replace from samba4 (This used to be ctdb commit f0555484105668c01c21f56322992e752e831109)
2007-07-10 09:29:31 +04:00
the Free Software Foundation; either version 3 of the License, or
ctdb is GPL not LGPL (This used to be ctdb commit 8624378010d1c2a1438e1e701339dfba7276f960)
2007-05-31 07:50:53 +04:00
(at your option) any later version.
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
ctdb is GPL not LGPL (This used to be ctdb commit 8624378010d1c2a1438e1e701339dfba7276f960)
2007-05-31 07:50:53 +04:00
This program is distributed in the hope that it will be useful,
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
but WITHOUT ANY WARRANTY; without even the implied warranty of
ctdb is GPL not LGPL (This used to be ctdb commit 8624378010d1c2a1438e1e701339dfba7276f960)
2007-05-31 07:50:53 +04:00
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
ctdb is GPL not LGPL (This used to be ctdb commit 8624378010d1c2a1438e1e701339dfba7276f960)
2007-05-31 07:50:53 +04:00
You should have received a copy of the GNU General Public License
update lib/replace from samba4 (This used to be ctdb commit f0555484105668c01c21f56322992e752e831109)
2007-07-10 09:29:31 +04:00
along with this program; if not, see <http://www.gnu.org/licenses/>.
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
*/
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
#ifndef _CTDB_CLIENT_H
#define _CTDB_CLIENT_H
#include <ctdb_protocol.h>
define CTDB_DB_SEQNUM_KEY - used with the new implementation of transactions. Michael (This used to be ctdb commit 4b1dbcf0853bdc4832d39a477823ae34f216da52)
2009-12-11 16:19:55 +03:00
try out a slightly different api for controls where you provide a callback function which is called upon completion (or timeout) of the control. modify scanning of recmaster in the monitoring_cluster code to try the api out (This used to be ctdb commit c37843f1d97b169afec910e7ddb4e5ac12c3015c)
2007-08-23 13:27:09 +04:00
enum control_state {CTDB_CONTROL_WAIT, CTDB_CONTROL_DONE, CTDB_CONTROL_ERROR, CTDB_CONTROL_TIMEOUT};
change the api for managing callbacks to controls so that isntead of passing it as a parameter we set the callback function explicitely from the caller if the ..._send() function returned a valid state pointer. (This used to be ctdb commit aa939570662786455f63299b62c99882cff29d42)
2007-08-24 04:42:06 +04:00
struct ctdb_client_control_state {
struct ctdb_context *ctdb;
uint32_t reqid;
try out a slightly different api for controls where you provide a callback function which is called upon completion (or timeout) of the control. modify scanning of recmaster in the monitoring_cluster code to try the api out (This used to be ctdb commit c37843f1d97b169afec910e7ddb4e5ac12c3015c)
2007-08-23 13:27:09 +04:00
int32_t status;
TDB_DATA outdata;
change the api for managing callbacks to controls so that isntead of passing it as a parameter we set the callback function explicitely from the caller if the ..._send() function returned a valid state pointer. (This used to be ctdb commit aa939570662786455f63299b62c99882cff29d42)
2007-08-24 04:42:06 +04:00
enum control_state state;
try out a slightly different api for controls where you provide a callback function which is called upon completion (or timeout) of the control. modify scanning of recmaster in the monitoring_cluster code to try the api out (This used to be ctdb commit c37843f1d97b169afec910e7ddb4e5ac12c3015c)
2007-08-23 13:27:09 +04:00
char *errormsg;
change the api for managing callbacks to controls so that isntead of passing it as a parameter we set the callback function explicitely from the caller if the ..._send() function returned a valid state pointer. (This used to be ctdb commit aa939570662786455f63299b62c99882cff29d42)
2007-08-24 04:42:06 +04:00
struct ctdb_req_control *c;
/* if we have a callback registered for the completion (or failure) of
this control
if a callback is used, it MUST talloc_free the cb_data passed to it
*/
struct {
void (*fn)(struct ctdb_client_control_state *);
change async.private to async.private_data since private is a reserved work in c++ (This used to be ctdb commit 79eb28f6cd5dcc30b04966d202a050eaf98a2552)
2007-09-26 08:25:32 +04:00
void *private_data;
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
} async;
try out a slightly different api for controls where you provide a callback function which is called upon completion (or timeout) of the control. modify scanning of recmaster in the monitoring_cluster code to try the api out (This used to be ctdb commit c37843f1d97b169afec910e7ddb4e5ac12c3015c)
2007-08-23 13:27:09 +04:00
};
Add a mechanism where we can register notifications to be sent out to a SRVID when the client disconnects. The way to use this is from a client to : 1, first create a message handle and bind it to a SRVID A special prefix for the srvid space has been set aside for samba : Only samba is allowed to use srvid's with the top 32 bits set like this. The lower 32 bits are for samba to use internally. 2, register a "notification" using the new control : CTDB_CONTROL_REGISTER_NOTIFY = 114, This control takes as indata a structure like this : struct ctdb_client_notify_register { uint64_t srvid; uint32_t len; uint8_t notify_data[1]; }; srvid is the srvid used in the space set aside above. len and notify_data is an arbitrary blob. When notifications are later sent out to all clients, this is the payload of that notification message. If a client has registered with control 114 and then disconnects from ctdbd, ctdbd will broadcast a message to that srvid to all nodes/listeners in the cluster. A client can resister itself with as many different srvid's it want, but this is handled through a linked list from the client structure so it mainly designed for "few notifications per client". 3, a client that no longer wants to have a notification set up can deregister using control CTDB_CONTROL_DEREGISTER_NOTIFY = 115, which takes this as arguments : struct ctdb_client_notify_deregister { uint64_t srvid; }; When a client deregisters, there will no longer be sent a message to all other clients when this client disconnects from ctdbd. (This used to be ctdb commit f1b6ee4a55cdca60f93d992f0431d91bf301af2c)
2009-10-23 08:24:51 +04:00
struct ctdb_client_notify_register {
uint64_t srvid;
uint32_t len;
uint8_t notify_data[1];
};
struct ctdb_client_notify_deregister {
uint64_t srvid;
};
try out a slightly different api for controls where you provide a callback function which is called upon completion (or timeout) of the control. modify scanning of recmaster in the monitoring_cluster code to try the api out (This used to be ctdb commit c37843f1d97b169afec910e7ddb4e5ac12c3015c)
2007-08-23 13:27:09 +04:00
event: Update events to latest Samba version 0.9.8 In Samba this is now called "tevent", and while we use the backwards compatibility wrappers they don't offer EVENT_FD_AUTOCLOSE: that is now a separate tevent_fd_set_auto_close() function. This is based on Samba version 7f29f817fa939ef1bbb740584f09e76e2ecd5b06. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 85e5e760cc91eb3157d3a88996ce474491646726)
2010-08-18 03:46:31 +04:00
struct tevent_context;
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
/*
initialise ctdb subsystem
*/
event: Update events to latest Samba version 0.9.8 In Samba this is now called "tevent", and while we use the backwards compatibility wrappers they don't offer EVENT_FD_AUTOCLOSE: that is now a separate tevent_fd_set_auto_close() function. This is based on Samba version 7f29f817fa939ef1bbb740584f09e76e2ecd5b06. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 85e5e760cc91eb3157d3a88996ce474491646726)
2010-08-18 03:46:31 +04:00
struct ctdb_context *ctdb_init(struct tevent_context *ev);
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
started splitting out transport code (This used to be ctdb commit 3b75ef65bd0bff9c6366aba5a26b90be509fa77b)
2006-11-27 13:38:13 +03:00
/*
choose the transport
*/
int ctdb_set_transport(struct ctdb_context *ctdb, const char *transport);
Add --dbdir to ctdbd. Necessary for shared operation between ctdbd and smbd. (This used to be ctdb commit bce40105e2ccbca5e364793bbf1a6357e6dd69b2)
2007-04-18 18:36:22 +04:00
/*
set the directory for the local databases
*/
merged the db_dir changes from volker. Changed them slightly, to make the --dbdir option available to all ctdb tools, not just the daemon (This used to be ctdb commit add63b0ae11d8727163bb6f0c94a617d9b88ef28)
2007-04-19 03:14:25 +04:00
int ctdb_set_tdb_dir(struct ctdb_context *ctdb, const char *dir);
added support for persistent databases in ctdbd (This used to be ctdb commit 3115090a0d882beca9d70761130b74bb0821f201)
2007-09-21 06:24:02 +04:00
int ctdb_set_tdb_dir_persistent(struct ctdb_context *ctdb, const char *dir);
server: add db_directory_state to ctdb_context metze (This used to be ctdb commit 656a6ec5ed81ccfbb86144156a3158e48f105ee4)
2009-11-23 16:38:03 +03:00
int ctdb_set_tdb_dir_state(struct ctdb_context *ctdb, const char *dir);
Add --dbdir to ctdbd. Necessary for shared operation between ctdbd and smbd. (This used to be ctdb commit bce40105e2ccbca5e364793bbf1a6357e6dd69b2)
2007-04-18 18:36:22 +04:00
- added ctdb_set_flags() call - added --self-connect option to ctdb_test, allowing testing when a node connects to itself. not as efficient as local bypass, but very useful for testing purposes (easier to work with 1 task in gdb than 2) - split the ctdb_call() into an async triple, in the style of Samba4 async functions. So we now have ctdb_call_send(), ctdb_call_recv() and ctdb_call(). - added the main ctdb_call protocol logic. No error checking yet, but seems to work for simple cases - ensure we initialise the length argument to getsockopt() (This used to be ctdb commit 95fad717ef5ab93be3603aa11d2878876fe868d3)
2006-12-01 07:45:24 +03:00
/*
set some flags
*/
void ctdb_set_flags(struct ctdb_context *ctdb, unsigned flags);
added ctdb_set_address and broke out parsing (This used to be ctdb commit 88071e67c916be8c9cd406f1353480183e24919c)
2006-11-18 03:21:40 +03:00
/*
tell ctdb what address to listen on, in transport specific format
*/
int ctdb_set_address(struct ctdb_context *ctdb, const char *address);
added a ctdb control message, and tool (This used to be ctdb commit 0d7a71f35bb8ce95231f8ca1e8e3e4024fe657e5)
2007-04-26 16:27:49 +04:00
int ctdb_set_socketname(struct ctdb_context *ctdb, const char *socketname);
add a function to read the current socketname from the ctdb structure (This used to be ctdb commit 112d252b2ab614eeac38e4a1658cd1e85f6eb829)
2010-06-02 04:25:31 +04:00
const char *ctdb_get_socketname(struct ctdb_context *ctdb);
added a ctdb control message, and tool (This used to be ctdb commit 0d7a71f35bb8ce95231f8ca1e8e3e4024fe657e5)
2007-04-26 16:27:49 +04:00
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
/*
tell ctdb what nodes are available. This takes a filename, which will contain
1 node address per line, in a transport specific format
*/
int ctdb_set_nlist(struct ctdb_context *ctdb, const char *nlist);
Add a --node-ip argument so that one can specify which ip address a specific instance of ctdbd should bind to. This helps when running a "virtual" cluster on a single machine where all instcances bind to different alias interfaces. If --node-ip is specified, then we will only try to bind to this ip address only. Othervise we fall back to the original method trying the ip addresses in /etc/ctdb/nodes one by one until we find one we can bind to. No variable in /etc/sysconfig/ctdb added since this parameter only makes sense in a virtual test/debug cluster. (This used to be ctdb commit d96cb02c2c24f9eabbc53d3d38e90dea49cff3e0)
2007-11-26 02:52:55 +03:00
/*
Check that a specific ip address exists in the node list and returns
the id for the node or -1
*/
int ctdb_ip_to_nodeid(struct ctdb_context *ctdb, const char *nodeip);
added ctdb_set_address and broke out parsing (This used to be ctdb commit 88071e67c916be8c9cd406f1353480183e24919c)
2006-11-18 03:21:40 +03:00
/*
start the ctdb protocol
*/
int ctdb_start(struct ctdb_context *ctdb);
delay loading the public ip address file until after we have started the transport and discovered ouw own pnn number (This used to be ctdb commit 1b57fc866fc836b5dbd3ef7b646e5a0f4280e81e)
2010-11-10 04:59:25 +03:00
int ctdb_start_daemon(struct ctdb_context *ctdb, bool do_fork, bool use_syslog, const char *public_address_list);
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
Split CTDB into sub contexts to handle multiple concurrent databases within the same context. (This used to be ctdb commit d995103143f6f13f59118549d93ab4b29c27ec89)
2007-04-03 13:41:00 +04:00
/*
attach to a ctdb database
*/
client: add timeout argument to ctdb_attach Rather than using a fixed 2 second CTDB_CONTROL_GETDBPATH timeout. (This used to be ctdb commit 9e178671560cb95121e11d718a76b05380ecd6c5)
2011-08-08 18:35:56 +04:00
struct ctdb_db_context *ctdb_attach(struct ctdb_context *ctdb,
struct timeval timeout,
const char *name,
bool persistent,
uint32_t tdb_flags);
Split CTDB into sub contexts to handle multiple concurrent databases within the same context. (This used to be ctdb commit d995103143f6f13f59118549d93ab4b29c27ec89)
2007-04-03 13:41:00 +04:00
merge back some changes from Samba4 (This used to be ctdb commit b946ff61c0e4b3269d3c7e01093d0a6d5215d6ee)
2007-04-04 09:02:49 +04:00
/*
find an attached ctdb_db handle given a name
*/
struct ctdb_db_context *ctdb_db_handle(struct ctdb_context *ctdb, const char *name);
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
/*
error string for last ctdb error
*/
const char *ctdb_errstr(struct ctdb_context *);
/* a ctdb call function */
use ctdb_call_info, so struct ctdb_call can be used for top level call (This used to be ctdb commit 05565ce504b75671566661199f5203a9ace31583)
2007-01-25 07:19:16 +03:00
typedef int (*ctdb_fn_t)(struct ctdb_call_info *);
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
/*
setup a ctdb call function
*/
changed the way set_call and attach are done so that you can safely attach to databases after the protocol has started. The daemon broadcasts information on new databases to the other daemons. This also eliminates the need for the client to know about the hash between db name and db_id. (This used to be ctdb commit 3bad91a9d987d4c09fe3322eac23c2733660ad08)
2007-04-30 17:31:40 +04:00
int ctdb_set_call(struct ctdb_db_context *ctdb_db, ctdb_fn_t fn, uint32_t id);
initial version (This used to be ctdb commit 5bba7deef9b03a68d336c138e83d6d4fac35bfce)
2006-11-18 02:41:20 +03:00
/*
make a ctdb call. The associated ctdb call function will be called on the DMASTER
for the given record
*/
Split CTDB into sub contexts to handle multiple concurrent databases within the same context. (This used to be ctdb commit d995103143f6f13f59118549d93ab4b29c27ec89)
2007-04-03 13:41:00 +04:00
int ctdb_call(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
started splitting out transport code (This used to be ctdb commit 3b75ef65bd0bff9c6366aba5a26b90be509fa77b)
2006-11-27 13:38:13 +03:00
- added ctdb_set_flags() call - added --self-connect option to ctdb_test, allowing testing when a node connects to itself. not as efficient as local bypass, but very useful for testing purposes (easier to work with 1 task in gdb than 2) - split the ctdb_call() into an async triple, in the style of Samba4 async functions. So we now have ctdb_call_send(), ctdb_call_recv() and ctdb_call(). - added the main ctdb_call protocol logic. No error checking yet, but seems to work for simple cases - ensure we initialise the length argument to getsockopt() (This used to be ctdb commit 95fad717ef5ab93be3603aa11d2878876fe868d3)
2006-12-01 07:45:24 +03:00
/*
initial shutdown function where a client can request an orderly shutdown of a ctdb cluster (This used to be ctdb commit 00d2748bd4e7209ff7e253f6652fdd9bf16cf147)
2007-04-18 06:39:03 +04:00
initiate an ordered ctdb cluster shutdown
this function will never return
- added ctdb_set_flags() call - added --self-connect option to ctdb_test, allowing testing when a node connects to itself. not as efficient as local bypass, but very useful for testing purposes (easier to work with 1 task in gdb than 2) - split the ctdb_call() into an async triple, in the style of Samba4 async functions. So we now have ctdb_call_send(), ctdb_call_recv() and ctdb_call(). - added the main ctdb_call protocol logic. No error checking yet, but seems to work for simple cases - ensure we initialise the length argument to getsockopt() (This used to be ctdb commit 95fad717ef5ab93be3603aa11d2878876fe868d3)
2006-12-01 07:45:24 +03:00
*/
initial shutdown function where a client can request an orderly shutdown of a ctdb cluster (This used to be ctdb commit 00d2748bd4e7209ff7e253f6652fdd9bf16cf147)
2007-04-18 06:39:03 +04:00
void ctdb_shutdown(struct ctdb_context *ctdb);
- added ctdb_set_flags() call - added --self-connect option to ctdb_test, allowing testing when a node connects to itself. not as efficient as local bypass, but very useful for testing purposes (easier to work with 1 task in gdb than 2) - split the ctdb_call() into an async triple, in the style of Samba4 async functions. So we now have ctdb_call_send(), ctdb_call_recv() and ctdb_call(). - added the main ctdb_call protocol logic. No error checking yet, but seems to work for simple cases - ensure we initialise the length argument to getsockopt() (This used to be ctdb commit 95fad717ef5ab93be3603aa11d2878876fe868d3)
2006-12-01 07:45:24 +03:00
change ctdb_get_vnn to ctdb_get_pnn (This used to be ctdb commit 1e19930198c2bcc7ccb755e0ee51555fb823029a)
2007-09-04 04:18:44 +04:00
/* return pnn of this node */
uint32_t ctdb_get_pnn(struct ctdb_context *ctdb);
merge fixes from samba4 (This used to be ctdb commit fb90a5424348d0b6ed9a1b8da4ceadcc4d1a1cb1)
2007-01-23 03:38:45 +03:00
changed ctdb_bench.c to use messages instead of calls (This used to be ctdb commit d147a434f827f83cf90228a3ed37338db8e9df13)
2007-02-09 04:45:58 +03:00
/*
return the number of nodes
*/
uint32_t ctdb_get_num_nodes(struct ctdb_context *ctdb);
merged ctdb messaging code from samba4 (This used to be ctdb commit af3010562763811deb9b7e37fea9962a42885d9d)
2007-02-09 01:42:04 +03:00
/* setup a handler for ctdb messages */
rename ctdb_message_fn_t to ctdb_msg_fn_t to avoid a conflict with the type of the same name used in libctdb (This used to be ctdb commit 49e23f8329649e4d9eefab47c9b158fcc7210d07)
2010-06-02 04:00:58 +04:00
typedef void (*ctdb_msg_fn_t)(struct ctdb_context *, uint64_t srvid,
merged ctdb messaging code from samba4 (This used to be ctdb commit af3010562763811deb9b7e37fea9962a42885d9d)
2007-02-09 01:42:04 +03:00
TDB_DATA data, void *);
rename ctdb_set_message_handler to ctdb_client_set_message_handler to avoid a colission with the function of the same name in libctdb (This used to be ctdb commit 41dbdd4fc0ab560420fb0e24a3179ff7c94c5bb7)
2010-06-02 03:51:47 +04:00
int ctdb_client_set_message_handler(struct ctdb_context *ctdb, uint64_t srvid,
rename ctdb_message_fn_t to ctdb_msg_fn_t to avoid a conflict with the type of the same name used in libctdb (This used to be ctdb commit 49e23f8329649e4d9eefab47c9b158fcc7210d07)
2010-06-02 04:00:58 +04:00
ctdb_msg_fn_t handler,
Rename "private" to "private_data" (This used to be ctdb commit 78cf4443ac0c66fb750ef6919bcdec189ac219c9)
2007-04-11 22:12:15 +04:00
void *private_data);
rename ctdb_remove_message_handler to ctdb_client_remove_message_handler to avoid conflict with the function of the same name in libctdb (This used to be ctdb commit 636ed76d04c8c499a911eb0d72d54b71b0a73d31)
2010-06-02 04:05:58 +04:00
int ctdb_client_remove_message_handler(struct ctdb_context *ctdb,
uint64_t srvid, void *private_data);
merged ctdb messaging code from samba4 (This used to be ctdb commit af3010562763811deb9b7e37fea9962a42885d9d)
2007-02-09 01:42:04 +03:00
dispatcher daemon first try. does not yet work (This used to be ctdb commit ff428808c6546d6f2804a1ac1cf414d1bb9cdcb4)
2007-04-09 05:51:27 +04:00
int ctdb_call(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
ensure the recovery daemon is not clagged up by vacuum calls (This used to be ctdb commit ff7e80e247bf5a86adda0ef850d901478449675b)
2008-01-08 13:28:42 +03:00
struct ctdb_client_call_state *ctdb_call_send(struct ctdb_db_context *ctdb_db, struct ctdb_call *call);
- fully separate the client version of ctdb_call from the daemon version. The client version is different enough that this is worthwhile - enable local shortcut for client version of ctdb_call - add idr_find_type(), with better error reporting in case of type mismatch (This used to be ctdb commit 2388094c5f7b6ce003e86b05620c06217d63b49c)
2007-04-19 05:28:01 +04:00
int ctdb_call_recv(struct ctdb_client_call_state *state, struct ctdb_call *call);
dispatcher daemon first try. does not yet work (This used to be ctdb commit ff428808c6546d6f2804a1ac1cf414d1bb9cdcb4)
2007-04-09 05:51:27 +04:00
merged ctdb messaging code from samba4 (This used to be ctdb commit af3010562763811deb9b7e37fea9962a42885d9d)
2007-02-09 01:42:04 +03:00
/* send a ctdb message */
rename ctdb_send_message to ctdb_client_send_message to resolve colission with the function of the same name in libctdb (This used to be ctdb commit ac3292c12832484a22715f1d46aa23f3b7c8a6f6)
2010-06-02 03:45:21 +04:00
int ctdb_client_send_message(struct ctdb_context *ctdb, uint32_t pnn,
make srvid 64 bits instead of 32 bits (This used to be ctdb commit 723bcfbba1d5aa711496d37b9658190b78a2d66b)
2007-04-27 18:31:45 +04:00
uint64_t srvid, TDB_DATA data);
merged ctdb messaging code from samba4 (This used to be ctdb commit af3010562763811deb9b7e37fea9962a42885d9d)
2007-02-09 01:42:04 +03:00
first test of forced migration of records. compiles but not tested. (This used to be ctdb commit ac6ac290e79446f52caf31f429b4c38668c27eda)
2007-04-04 15:15:56 +04:00
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
/*
initial change to remove store_unlock pdu and use tdb chainlock in the client (This used to be ctdb commit 87dd265d2c61125ca2fa922cfcf9371a234fff0c)
2007-04-17 05:34:45 +04:00
Fetch a ctdb record from a remote node
. Underneath this will force the
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
dmaster for the record to be moved to the local node.
first test of forced migration of records. compiles but not tested. (This used to be ctdb commit ac6ac290e79446f52caf31f429b4c38668c27eda)
2007-04-04 15:15:56 +04:00
*/
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
struct ctdb_record_handle *ctdb_fetch_lock(struct ctdb_db_context *ctdb_db, TALLOC_CTX *mem_ctx,
- removed the non-daemon mode from ctdb, in order to simplify the code. It may be added back later once everything is working nicely, or simulated using a in-process pipe instead of a unix domain socket - rewrote the ctdb_fetch_lock() code to follow the new design (This used to be ctdb commit 5024dd1f305fe1ecc262db2240c56f773b4f28f0)
2007-04-17 08:52:51 +04:00
TDB_DATA key, TDB_DATA *data);
ReadOnly: Add clientside code to fetch readonly records (This used to be ctdb commit 6fccc902bce21fa6ff13ed08ee3341bbf8be39f2)
2011-07-20 09:37:37 +04:00
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);
- removed the non-daemon mode from ctdb, in order to simplify the code. It may be added back later once everything is working nicely, or simulated using a in-process pipe instead of a unix domain socket - rewrote the ctdb_fetch_lock() code to follow the new design (This used to be ctdb commit 5024dd1f305fe1ecc262db2240c56f773b4f28f0)
2007-04-17 08:52:51 +04:00
int ctdb_record_store(struct ctdb_record_handle *h, TDB_DATA data);
first test of forced migration of records. compiles but not tested. (This used to be ctdb commit ac6ac290e79446f52caf31f429b4c38668c27eda)
2007-04-04 15:15:56 +04:00
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_fetch(struct ctdb_db_context *ctdb_db, TALLOC_CTX *mem_ctx,
merge changes needed for samba4 (This used to be ctdb commit a7f80f78cd62401b3516da3640bf24d6362db872)
2007-08-15 03:03:58 +04:00
TDB_DATA key, TDB_DATA *data);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_register_message_handler(struct ctdb_context *ctdb,
add a test that sends messages between clients connected to the same ctdb add code to actually pass the messages between clients and ctdb (This used to be ctdb commit 6d5b55d7b9c611fb5e98765906757a7d82e4bf6b)
2007-04-11 07:43:15 +04:00
TALLOC_CTX *mem_ctx,
make srvid 64 bits instead of 32 bits (This used to be ctdb commit 723bcfbba1d5aa711496d37b9658190b78a2d66b)
2007-04-27 18:31:45 +04:00
uint64_t srvid,
rename ctdb_message_fn_t to ctdb_msg_fn_t to avoid a conflict with the type of the same name used in libctdb (This used to be ctdb commit 49e23f8329649e4d9eefab47c9b158fcc7210d07)
2010-06-02 04:00:58 +04:00
ctdb_msg_fn_t handler,
Rename "private" to "private_data" (This used to be ctdb commit 78cf4443ac0c66fb750ef6919bcdec189ac219c9)
2007-04-11 22:12:15 +04:00
void *private_data);
first test of forced migration of records. compiles but not tested. (This used to be ctdb commit ac6ac290e79446f52caf31f429b4c38668c27eda)
2007-04-04 15:15:56 +04:00
initial support for two new pdus for the domain socket to do fetch_lock no locking is yet done and the store_unlock call is still missing the ./tests/fetch.sh --daemon test fails with parent process dying which needs to be investigated. (This used to be ctdb commit 7d7141c968950a8856f1be79871932b688bfb07f)
2007-04-12 09:46:50 +04:00
struct ctdb_db_context *find_ctdb_db(struct ctdb_context *ctdb, uint32_t id);
initial change to remove store_unlock pdu and use tdb chainlock in the client (This used to be ctdb commit 87dd265d2c61125ca2fa922cfcf9371a234fff0c)
2007-04-17 05:34:45 +04:00
client: add req timeout argument to ctdb_cmdline_client Following connection to the local ctdbd, ctdb_cmdline_client() currently issues a CTDB_CONTROL_GET_PNN request with a fixed 3 second timeout. The ctdb cmd line client accepts a --timelimit argument for specifying a per request timeout, pass this value through to ctdb_cmdline_client() for use as a CTDB_CONTROL_GET_PNN request timeout. (This used to be ctdb commit 0634d0305f42f17048b6830733767e8dc300e11c)
2011-08-08 16:09:46 +04:00
struct ctdb_context *ctdb_cmdline_client(struct tevent_context *ev,
struct timeval req_timeout);
added ctdb_status tool (This used to be ctdb commit 908d6c6a936e21f70f05827ce302e966cca0132a)
2007-04-20 14:07:47 +04:00
- renamed ctdb_control utility to ctdb - use -n to specify node number in ctdb utility - change 'ctdb status' to 'ctdb statistics' - added 'ctdb status' which shows status - added netmask to public IPs, so you don't try a takeover on a foreign network - cleaned up tools/ctdb_control.c a lot - generate usage message at runtime (This used to be ctdb commit 28de71c03ace7d32a9fd9882fabbd5d668b97656)
2007-05-29 06:16:59 +04:00
struct ctdb_statistics;
int ctdb_ctrl_statistics(struct ctdb_context *ctdb, uint32_t destnode, struct ctdb_statistics *status);
added ctdb_status tool (This used to be ctdb commit 908d6c6a936e21f70f05827ce302e966cca0132a)
2007-04-20 14:07:47 +04:00
add a control to shutdown/kill a node (This used to be ctdb commit 3802f7304fd59d56062c855987e2561753e85a69)
2007-05-17 04:45:31 +04:00
int ctdb_ctrl_shutdown(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
add a control to read the vnnmap configuration from a node add support in ctdb_control to fetch this information from a node (This used to be ctdb commit 8d7f26c8d78d30c3ccb15a28ddea940d8666e052)
2007-04-27 14:56:10 +04:00
struct ctdb_vnn_map;
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_getvnnmap(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
update getvnnmap control to take a timeout parameter dont explicitely free the vnnmap pointer in the getvnnmap control this is freed by the mem_ctx instead add code to the recoverd to detect when/if recovery is required veiry that the number of active nodes, the nodemap and the vnn map is consistent across the entire cluster and if not trigger a recovery (which right now just prints "we need to do recovery" to the screen. (This used to be ctdb commit 2b0a207a3748bdb3394dc9fd0d1c344ee1bb0bb5)
2007-05-04 03:45:53 +04:00
TALLOC_CTX *mem_ctx, struct ctdb_vnn_map **vnnmap);
recovery daemon this program is a client to the local ctdb daemon every second it pulls all vnnmap and nodemaps from all nodes that are available and checks if a recovery is required a recovery is required if : * all nodes do NOT have an identical vnnmap and generation * all nodes do NOT have an identical nodemap * there are active nodes that are NOT in the nodemap * there are nodes in the nodemap that are NOT active During recovery, the recovery tool will also make sure that all nodes know about and have created all databases. (This used to be ctdb commit 2f2650467bac7e8954de7c17cb34f46b0bdbcd26)
2007-05-04 09:21:40 +04:00
int ctdb_ctrl_setvnnmap(struct ctdb_context *ctdb,
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
struct timeval timeout, uint32_t destnode,
recovery daemon this program is a client to the local ctdb daemon every second it pulls all vnnmap and nodemaps from all nodes that are available and checks if a recovery is required a recovery is required if : * all nodes do NOT have an identical vnnmap and generation * all nodes do NOT have an identical nodemap * there are active nodes that are NOT in the nodemap * there are nodes in the nodemap that are NOT active During recovery, the recovery tool will also make sure that all nodes know about and have created all databases. (This used to be ctdb commit 2f2650467bac7e8954de7c17cb34f46b0bdbcd26)
2007-05-04 09:21:40 +04:00
TALLOC_CTX *mem_ctx, struct ctdb_vnn_map *vnnmap);
add a few more controls that are useful for debugging a cluster (This used to be ctdb commit 751c1365ab55a217ff33d985d52bd26581578617)
2007-04-28 14:40:26 +04:00
/* table that contains a list of all dbids on a node
*/
struct ctdb_dbid_map {
uint32_t num;
added support for persistent databases in ctdbd (This used to be ctdb commit 3115090a0d882beca9d70761130b74bb0821f201)
2007-09-21 06:24:02 +04:00
struct ctdb_dbid {
uint32_t dbid;
ReadOnly: Change the ctdb_db structure to keep a uint8_t for flags instead of a boolean for the persistent flag. This is the same size as the original boolean but allows ut to add additional flags for the database (This used to be ctdb commit 7462761638d25880ad46024ad4ef21667eb99a98)
2011-09-01 04:21:55 +04:00
#define CTDB_DB_FLAGS_PERSISTENT 0x01
ReadOnly: add a readonly flag to the getdbmap control and show the readonly setting in ctdb getdbmap output (This used to be ctdb commit 4cac9ad7d9c9ca657a247a6c215476399c7d2210)
2011-09-01 04:28:15 +04:00
#define CTDB_DB_FLAGS_READONLY 0x02
ReadOnly: Change the ctdb_db structure to keep a uint8_t for flags instead of a boolean for the persistent flag. This is the same size as the original boolean but allows ut to add additional flags for the database (This used to be ctdb commit 7462761638d25880ad46024ad4ef21667eb99a98)
2011-09-01 04:21:55 +04:00
uint8_t flags;
added support for persistent databases in ctdbd (This used to be ctdb commit 3115090a0d882beca9d70761130b74bb0821f201)
2007-09-21 06:24:02 +04:00
} dbs[1];
add a few more controls that are useful for debugging a cluster (This used to be ctdb commit 751c1365ab55a217ff33d985d52bd26581578617)
2007-04-28 14:40:26 +04:00
};
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_getdbmap(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
recovery daemon this program is a client to the local ctdb daemon every second it pulls all vnnmap and nodemaps from all nodes that are available and checks if a recovery is required a recovery is required if : * all nodes do NOT have an identical vnnmap and generation * all nodes do NOT have an identical nodemap * there are active nodes that are NOT in the nodemap * there are nodes in the nodemap that are NOT active During recovery, the recovery tool will also make sure that all nodes know about and have created all databases. (This used to be ctdb commit 2f2650467bac7e8954de7c17cb34f46b0bdbcd26)
2007-05-04 09:21:40 +04:00
TALLOC_CTX *mem_ctx, struct ctdb_dbid_map **dbmap);
add a control to read the vnnmap configuration from a node add support in ctdb_control to fetch this information from a node (This used to be ctdb commit 8d7f26c8d78d30c3ccb15a28ddea940d8666e052)
2007-04-27 14:56:10 +04:00
add a few more controls that are useful for debugging a cluster (This used to be ctdb commit 751c1365ab55a217ff33d985d52bd26581578617)
2007-04-28 14:40:26 +04:00
add the ip address to the nodemap structure we pull from a server and display the physical address of a node when we do a ctdb status (This used to be ctdb commit 660bf30db713f0680acd3f74275ad603b35a0c24)
2007-06-04 07:26:07 +04:00
struct ctdb_node_map;
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_getnodemap(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
cleanup getnodemap (This used to be ctdb commit 3867ccf71a167fb82dbc5a3f03f968a325a0c70b)
2007-05-03 07:30:38 +04:00
TALLOC_CTX *mem_ctx, struct ctdb_node_map **nodemap);
add a few more controls that are useful for debugging a cluster (This used to be ctdb commit 751c1365ab55a217ff33d985d52bd26581578617)
2007-04-28 14:40:26 +04:00
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_getnodemapv4(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
update the client side of getnodemap and getpublicips controls to fallback to the old-style ipv4-only controls if the new-style ipv4/ipv6 control fails. this allows a 1.0.59+ (ipv4/ipv6) ctdb daemon being recmaster to be compatible with pre-1.0.59 versions of ctdb that are ipv4 only. (This used to be ctdb commit 8e912abc2c68f5fe7b06c600ba6fec1a6900127c)
2008-10-14 17:24:44 +04:00
TALLOC_CTX *mem_ctx, struct ctdb_node_map **nodemap);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_reload_nodes_file(struct ctdb_context *ctdb,
to make it easier/less disruptive to add nodes to a running cluster add a new control that causes the node to drop the current nodes list and reread it from the nodes file. During this operation, the node will also drop the tcp layer and restart it. When we drop the tcp layer, by talloc_free()ing the ctcp structure add a destructor to ctcp so that we also can clean up and remove the references in the ctdb structure to the transport layer add two new commands for the ctdb tool. one to list all nodes in the nodesfile and the second a command to trigger a node to drop the transport and reinitialize it with the nde nodes file (This used to be ctdb commit 4bc20ac73e9fa94ffd43cccb6eeb438eeff9963c)
2008-02-19 06:44:48 +03:00
struct timeval timeout, uint32_t destnode);
add a control to read an entire tdb from a node including key/lmaster/header and data (This used to be ctdb commit ac00d6271ba6356c1edf804df44d0d2600791610)
2007-04-28 23:47:13 +04:00
struct ctdb_key_list {
add push/pull of tdb and a control to copy a tdb from one node to another node (This used to be ctdb commit c313daff4c1362cd08a9f682ce04cab312678038)
2007-04-29 18:58:27 +04:00
uint32_t dbid;
add a control to read an entire tdb from a node including key/lmaster/header and data (This used to be ctdb commit ac00d6271ba6356c1edf804df44d0d2600791610)
2007-04-28 23:47:13 +04:00
uint32_t num;
TDB_DATA *keys;
struct ctdb_ltdb_header *headers;
TDB_DATA *data;
};
a new tunable DatabaseMaxDead that enables the tdb max dead cache logic (This used to be ctdb commit 01c519c3658a8fcb9545b507b597e723658e4c4e)
2008-01-05 01:36:53 +03:00
int ctdb_ctrl_pulldb(
struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid,
uint32_t lmaster, TALLOC_CTX *mem_ctx,
struct timeval timeout, TDB_DATA *outdata);
struct ctdb_client_control_state *ctdb_ctrl_pulldb_send(
struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid,
uint32_t lmaster, TALLOC_CTX *mem_ctx, struct timeval timeout);
int ctdb_ctrl_pulldb_recv(
struct ctdb_context *ctdb,
TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state,
TDB_DATA *outdata);
int ctdb_ctrl_pushdb(
struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid,
TALLOC_CTX *mem_ctx,
struct timeval timeout, TDB_DATA indata);
struct ctdb_client_control_state *ctdb_ctrl_pushdb_send(
struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid,
TALLOC_CTX *mem_ctx, struct timeval timeout,
TDB_DATA indata);
int ctdb_ctrl_pushdb_recv(
struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
struct ctdb_client_control_state *state);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_copydb(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t sourcenode,
uint32_t destnode, uint32_t dbid, uint32_t lmaster,
recovery daemon this program is a client to the local ctdb daemon every second it pulls all vnnmap and nodemaps from all nodes that are available and checks if a recovery is required a recovery is required if : * all nodes do NOT have an identical vnnmap and generation * all nodes do NOT have an identical nodemap * there are active nodes that are NOT in the nodemap * there are nodes in the nodemap that are NOT active During recovery, the recovery tool will also make sure that all nodes know about and have created all databases. (This used to be ctdb commit 2f2650467bac7e8954de7c17cb34f46b0bdbcd26)
2007-05-04 09:21:40 +04:00
TALLOC_CTX *mem_ctx);
add a control to read an entire tdb from a node including key/lmaster/header and data (This used to be ctdb commit ac00d6271ba6356c1edf804df44d0d2600791610)
2007-04-28 23:47:13 +04:00
recovery daemon this program is a client to the local ctdb daemon every second it pulls all vnnmap and nodemaps from all nodes that are available and checks if a recovery is required a recovery is required if : * all nodes do NOT have an identical vnnmap and generation * all nodes do NOT have an identical nodemap * there are active nodes that are NOT in the nodemap * there are nodes in the nodemap that are NOT active During recovery, the recovery tool will also make sure that all nodes know about and have created all databases. (This used to be ctdb commit 2f2650467bac7e8954de7c17cb34f46b0bdbcd26)
2007-05-04 09:21:40 +04:00
int ctdb_ctrl_getdbpath(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t dbid, TALLOC_CTX *mem_ctx, const char **path);
int ctdb_ctrl_getdbname(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t dbid, TALLOC_CTX *mem_ctx, const char **name);
client: add ctdb_ctrl_getdbhealth() metze (This used to be ctdb commit 5abe44d0113839d3a45c9a31d30856aa70c2ea1f)
2009-12-02 14:51:37 +03:00
int ctdb_ctrl_getdbhealth(struct ctdb_context *ctdb,
struct timeval timeout,
uint32_t destnode,
uint32_t dbid, TALLOC_CTX *mem_ctx,
const char **reason);
added support for persistent databases in ctdbd (This used to be ctdb commit 3115090a0d882beca9d70761130b74bb0821f201)
2007-09-21 06:24:02 +04:00
int ctdb_ctrl_createdb(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, TALLOC_CTX *mem_ctx, const char *name, bool persistent);
add pdu's that the client can use to query the ctdb daemon of the path to the database it created (so the client can open and access the same file) (This used to be ctdb commit c2eda19499b3263b2248c41bd531fb73c7b42212)
2007-04-23 18:06:48 +04:00
add push/pull of tdb and a control to copy a tdb from one node to another node (This used to be ctdb commit c313daff4c1362cd08a9f682ce04cab312678038)
2007-04-29 18:58:27 +04:00
int ctdb_ctrl_process_exists(struct ctdb_context *ctdb, uint32_t destnode, pid_t pid);
added a ctdb control message, and tool (This used to be ctdb commit 0d7a71f35bb8ce95231f8ca1e8e3e4024fe657e5)
2007-04-26 16:27:49 +04:00
add push/pull of tdb and a control to copy a tdb from one node to another node (This used to be ctdb commit c313daff4c1362cd08a9f682ce04cab312678038)
2007-04-29 18:58:27 +04:00
int ctdb_ctrl_ping(struct ctdb_context *ctdb, uint32_t destnode);
added a ctdb_get_config call added a ctdb ping control (This used to be ctdb commit 7d17378b6e6076a922cffe98239e20dfbbae3bf7)
2007-04-26 21:27:07 +04:00
add push/pull of tdb and a control to copy a tdb from one node to another node (This used to be ctdb commit c313daff4c1362cd08a9f682ce04cab312678038)
2007-04-29 18:58:27 +04:00
int ctdb_ctrl_get_config(struct ctdb_context *ctdb);
added a ctdb_get_config call added a ctdb ping control (This used to be ctdb commit 7d17378b6e6076a922cffe98239e20dfbbae3bf7)
2007-04-26 21:27:07 +04:00
Specify and print debuglevels by name and not by number (This used to be ctdb commit 79ad830294b8b677fbd0c5ad7ed6fbde71f74f8d)
2008-02-05 02:26:23 +03:00
int ctdb_ctrl_get_debuglevel(struct ctdb_context *ctdb, uint32_t destnode, int32_t *level);
int ctdb_ctrl_set_debuglevel(struct ctdb_context *ctdb, uint32_t destnode, int32_t level);
debug level controls (This used to be ctdb commit 85f883c081dd1ab069420d2e7f4f2e9d708b3cde)
2007-04-27 17:14:36 +04:00
add a new control to set all records in a database to a new dmaster (This used to be ctdb commit fd0d2385206b0329b74d908f3bdf89d3f32095d1)
2007-04-29 12:34:11 +04:00
/*
change dmaster for all keys in the database to the new value
*/
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_setdmaster(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
recovery daemon this program is a client to the local ctdb daemon every second it pulls all vnnmap and nodemaps from all nodes that are available and checks if a recovery is required a recovery is required if : * all nodes do NOT have an identical vnnmap and generation * all nodes do NOT have an identical nodemap * there are active nodes that are NOT in the nodemap * there are nodes in the nodemap that are NOT active During recovery, the recovery tool will also make sure that all nodes know about and have created all databases. (This used to be ctdb commit 2f2650467bac7e8954de7c17cb34f46b0bdbcd26)
2007-05-04 09:21:40 +04:00
TALLOC_CTX *mem_ctx, uint32_t dbid, uint32_t dmaster);
add a new control to set all records in a database to a new dmaster (This used to be ctdb commit fd0d2385206b0329b74d908f3bdf89d3f32095d1)
2007-04-29 12:34:11 +04:00
add a recover test change alignment for the pull/push db structures (This used to be ctdb commit 0eb45623ca103e69765ed577ae02e7f8ca777e37)
2007-05-02 15:00:02 +04:00
/*
write a record on a specific db (this implicitely updates dmaster of the record to locally be the vnn of the node where the control is executed on)
*/
int ctdb_ctrl_write_record(struct ctdb_context *ctdb, uint32_t destnode, TALLOC_CTX *mem_ctx, uint32_t dbid, TDB_DATA key, TDB_DATA data);
add a new "recovery mode" field to ctdb. while recovery is in progress the daemon will discard all CTDB_REQ_CALL and rely on clients retransmitting them add new controls to get/set the recovery mode (This used to be ctdb commit 41458a61577885ac49150f830e92e93e634c5411)
2007-04-29 16:51:56 +04:00
#define CTDB_RECOVERY_NORMAL 0
#define CTDB_RECOVERY_ACTIVE 1
added lockwait child code for entering recovery mode. A child processes holds lockall locks for the entire recovery process (This used to be ctdb commit f892f30def75b0d964c35eae38c4cf675597dd28)
2007-05-12 08:34:21 +04:00
add a new "recovery mode" field to ctdb. while recovery is in progress the daemon will discard all CTDB_REQ_CALL and rely on clients retransmitting them add new controls to get/set the recovery mode (This used to be ctdb commit 41458a61577885ac49150f830e92e93e634c5411)
2007-04-29 16:51:56 +04:00
/*
get the recovery mode of a remote node
*/
hang the ctdb_req_control structure off the ctdb_client_control_state struct so that if we timeout a control we can print debug info such as what opcode failed and to which node we dont need the *status parameter to ctdb_client_control_state create async versions of the getrecmaster control pass a memory context to getrecmaster (This used to be ctdb commit 558b680c82f830fba82c283c78c2de8a0b150b75)
2007-08-23 07:00:10 +04:00
int ctdb_ctrl_getrecmode(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, uint32_t *recmode);
struct ctdb_client_control_state *ctdb_ctrl_getrecmode_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
int ctdb_ctrl_getrecmode_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *recmode);
add a new "recovery mode" field to ctdb. while recovery is in progress the daemon will discard all CTDB_REQ_CALL and rely on clients retransmitting them add new controls to get/set the recovery mode (This used to be ctdb commit 41458a61577885ac49150f830e92e93e634c5411)
2007-04-29 16:51:56 +04:00
/*
set the recovery mode of a remote node
*/
recovery daemon this program is a client to the local ctdb daemon every second it pulls all vnnmap and nodemaps from all nodes that are available and checks if a recovery is required a recovery is required if : * all nodes do NOT have an identical vnnmap and generation * all nodes do NOT have an identical nodemap * there are active nodes that are NOT in the nodemap * there are nodes in the nodemap that are NOT active During recovery, the recovery tool will also make sure that all nodes know about and have created all databases. (This used to be ctdb commit 2f2650467bac7e8954de7c17cb34f46b0bdbcd26)
2007-05-04 09:21:40 +04:00
int ctdb_ctrl_setrecmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t recmode);
add controls to enable/disable the monitoring of dead nodes (This used to be ctdb commit 79d29c39bb81feb069db3fc6d3d392c1e75a4d13)
2007-05-21 03:24:34 +04:00
/*
get the monitoring mode of a remote node
*/
int ctdb_ctrl_getmonmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t *monmode);
add a new "recovery mode" field to ctdb. while recovery is in progress the daemon will discard all CTDB_REQ_CALL and rely on clients retransmitting them add new controls to get/set the recovery mode (This used to be ctdb commit 41458a61577885ac49150f830e92e93e634c5411)
2007-04-29 16:51:56 +04:00
From M Dietz, Add back the controls to enable/disable monitoring we used to have for debugging but removed a while ago (This used to be ctdb commit 8477f6a079e2beb8c09c19702733c4e17f5032fe)
2008-03-25 00:27:38 +03:00
/*
set the monitoring mode of a remote node to active
*/
int ctdb_ctrl_enable_monmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
/*
set the monitoring mode of a remote node to disabled
*/
int ctdb_ctrl_disable_monmode(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
add new controls to get and set the recovery master node of a daemon i.e. which node is "elected" to check for and drive recovery (This used to be ctdb commit d577093eb4b619392c71ab5ce81e8c02565d93f0)
2007-05-06 23:02:48 +04:00
/*
get the recovery master of a remote node
*/
try out a slightly different api for controls where you provide a callback function which is called upon completion (or timeout) of the control. modify scanning of recmaster in the monitoring_cluster code to try the api out (This used to be ctdb commit c37843f1d97b169afec910e7ddb4e5ac12c3015c)
2007-08-23 13:27:09 +04:00
int ctdb_ctrl_getrecmaster(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, uint32_t *recmaster);
change the api for managing callbacks to controls so that isntead of passing it as a parameter we set the callback function explicitely from the caller if the ..._send() function returned a valid state pointer. (This used to be ctdb commit aa939570662786455f63299b62c99882cff29d42)
2007-08-24 04:42:06 +04:00
struct ctdb_client_control_state *ctdb_ctrl_getrecmaster_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
try out a slightly different api for controls where you provide a callback function which is called upon completion (or timeout) of the control. modify scanning of recmaster in the monitoring_cluster code to try the api out (This used to be ctdb commit c37843f1d97b169afec910e7ddb4e5ac12c3015c)
2007-08-23 13:27:09 +04:00
int ctdb_ctrl_getrecmaster_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *recmaster);
add new controls to get and set the recovery master node of a daemon i.e. which node is "elected" to check for and drive recovery (This used to be ctdb commit d577093eb4b619392c71ab5ce81e8c02565d93f0)
2007-05-06 23:02:48 +04:00
/*
set the recovery master of a remote node
*/
int ctdb_ctrl_setrecmaster(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t recmaster);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
uint32_t *ctdb_get_connected_nodes(struct ctdb_context *ctdb,
struct timeval timeout,
change the signature for ctdb_ctrl_getnodemap() so that a timeout parameter is added. change ctdb_get_connected_nodes in the same way (This used to be ctdb commit d85f23bcf4c1230225abb2f4a053c70b68d469aa)
2007-05-04 03:01:01 +04:00
TALLOC_CTX *mem_ctx,
use ctdb_get_connected_nodes for node listing (This used to be ctdb commit b4efdd1944207e51dccd6cd5e50f451a7dddcd91)
2007-04-28 19:42:40 +04:00
uint32_t *num_nodes);
- renamed ctdb_control utility to ctdb - use -n to specify node number in ctdb utility - change 'ctdb status' to 'ctdb statistics' - added 'ctdb status' which shows status - added netmask to public IPs, so you don't try a takeover on a foreign network - cleaned up tools/ctdb_control.c a lot - generate usage message at runtime (This used to be ctdb commit 28de71c03ace7d32a9fd9882fabbd5d668b97656)
2007-05-29 06:16:59 +04:00
int ctdb_statistics_reset(struct ctdb_context *ctdb, uint32_t destnode);
added reset status control (This used to be ctdb commit ec342b667a085a5c740fbeec8882070571071862)
2007-04-28 21:13:36 +04:00
added syslog support, and use a pipe to catch logging from child processes to the ctdbd logging functions (This used to be ctdb commit 1306b04cd01e996fd1aa1159a9521f2ff7b06165)
2008-01-16 14:03:01 +03:00
int ctdb_set_logfile(struct ctdb_context *ctdb, const char *logfile, bool use_syslog);
saner logfile code testing of ctdbd (This used to be ctdb commit 05789da5818f8b20f04779b0df5125914d9047f6)
2007-04-30 00:42:23 +04:00
nicer interface to ctdb traverse (This used to be ctdb commit e5ce866dcc5037b5069e42bf1e168b646f007b01)
2007-05-04 06:18:39 +04:00
typedef int (*ctdb_traverse_func)(struct ctdb_context *, TDB_DATA, TDB_DATA, void *);
int ctdb_traverse(struct ctdb_db_context *ctdb_db, ctdb_traverse_func fn, void *private_data);
ctdb: add an option --print-emptyrecords to enable printing of empty records in dumping databases this option is used with the commands catdb, cattdb and dumpdbbackup. (This used to be ctdb commit 6ec68a2e667f66d2b194fe48cb75229a2777842e)
2011-11-28 20:11:16 +04:00
struct ctdb_dump_db_context {
FILE *f;
bool printemptyrecords;
ctdb: add an option --print-datasize to only print datasize instead of dumping data in db dumps Used in catdb, cattdb and dumpdbbackup. (This used to be ctdb commit dd866116041e71cbf91e7fd91edcc9501634051d)
2011-11-28 20:19:03 +04:00
bool printdatasize;
ctdb: add an option --print-lmaster to enable printing of lmaster in "ctdb catdb" (This used to be ctdb commit 326f88ef622620cb9e0569c4497bc0e86124beaa)
2011-11-28 20:36:03 +04:00
bool printlmaster;
ctdb: add an option --print-emptyrecords to enable printing of empty records in dumping databases this option is used with the commands catdb, cattdb and dumpdbbackup. (This used to be ctdb commit 6ec68a2e667f66d2b194fe48cb75229a2777842e)
2011-11-28 20:11:16 +04:00
};
client: make ctdb_dumpdb_record() public metze (This used to be ctdb commit 1cdc8dbb9cb971cf6dd6cd22b1adaf70ddc77e65)
2009-12-04 17:23:56 +03:00
int ctdb_dumpdb_record(struct ctdb_context *ctdb, TDB_DATA key, TDB_DATA data, void *p);
ctdb: add an option --print-emptyrecords to enable printing of empty records in dumping databases this option is used with the commands catdb, cattdb and dumpdbbackup. (This used to be ctdb commit 6ec68a2e667f66d2b194fe48cb75229a2777842e)
2011-11-28 20:11:16 +04:00
int ctdb_dump_db(struct ctdb_db_context *ctdb_db,
struct ctdb_dump_db_context *ctx);
first version of traverse is working (This used to be ctdb commit ecac90cee389a6fa0e9b1efba521e098a24d323f)
2007-05-03 11:12:23 +04:00
add a control to get the pid of a daemon. this makes it possible to kill a specific daemon in the recover test script (This used to be ctdb commit 2fa394b4c80988cb1a6d04b236ec64cc9d9e8a40)
2007-05-05 22:31:22 +04:00
/*
get the pid of a ctdb daemon
*/
int ctdb_ctrl_getpid(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t *pid);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_freeze(struct ctdb_context *ctdb, struct timeval timeout,
add async versions of the freeze node control and freeze all nodes in parallell (This used to be ctdb commit f34e89f54d9f4380e76eb1b5b2385a4d8500b505)
2007-08-27 04:31:22 +04:00
uint32_t destnode);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_freeze_priority(struct ctdb_context *ctdb, struct timeval timeout,
uptade the freeze/thaw commands to be able to send the requested database priority to freeze/thaw to the daemon. this is encoded in the srvid field of the request header (This used to be ctdb commit 0cb3d33caa42ed783e03bc825b181dde4cf63616)
2009-10-12 02:22:17 +04:00
uint32_t destnode, uint32_t priority);
add async versions of the freeze node control and freeze all nodes in parallell (This used to be ctdb commit f34e89f54d9f4380e76eb1b5b2385a4d8500b505)
2007-08-27 04:31:22 +04:00
struct ctdb_client_control_state *
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
ctdb_ctrl_freeze_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
uptade the freeze/thaw commands to be able to send the requested database priority to freeze/thaw to the daemon. this is encoded in the srvid field of the request header (This used to be ctdb commit 0cb3d33caa42ed783e03bc825b181dde4cf63616)
2009-10-12 02:22:17 +04:00
struct timeval timeout, uint32_t destnode,
uint32_t priority);
add async versions of the freeze node control and freeze all nodes in parallell (This used to be ctdb commit f34e89f54d9f4380e76eb1b5b2385a4d8500b505)
2007-08-27 04:31:22 +04:00
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_freeze_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx,
add async versions of the freeze node control and freeze all nodes in parallell (This used to be ctdb commit f34e89f54d9f4380e76eb1b5b2385a4d8500b505)
2007-08-27 04:31:22 +04:00
struct ctdb_client_control_state *state);
uptade the freeze/thaw commands to be able to send the requested database priority to freeze/thaw to the daemon. this is encoded in the srvid field of the request header (This used to be ctdb commit 0cb3d33caa42ed783e03bc825b181dde4cf63616)
2009-10-12 02:22:17 +04:00
int ctdb_ctrl_thaw_priority(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t priority);
separate out the freeze/thaw handling from recovery (This used to be ctdb commit 0b0640bd8b8334961f240e0cf276ac112cd6e616)
2007-05-12 09:15:27 +04:00
int ctdb_ctrl_thaw(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
change ctdb_ctrl_getvnn to ctdb_ctrl_getpnn (This used to be ctdb commit ef47cc4cd416065c69382e4d9e76c30a0a34e42f)
2007-09-04 04:38:48 +04:00
int ctdb_ctrl_getpnn(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
- startup frozen, and do an initial recovery - fixed a bug in traverse - get a lock on the node list file in the recmaster recovery daemon (This used to be ctdb commit 162a5647535ad1cb3e8e5d4042a2784365fb1913)
2007-05-23 08:35:19 +04:00
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_get_tunable(struct ctdb_context *ctdb,
struct timeval timeout,
added tunables settable using ctdb command line tool (This used to be ctdb commit 73d440f8cb19373cfad7a2f0f0ca4f963c57ff29)
2007-06-04 13:53:19 +04:00
uint32_t destnode,
const char *name, uint32_t *value);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_set_tunable(struct ctdb_context *ctdb,
struct timeval timeout,
added tunables settable using ctdb command line tool (This used to be ctdb commit 73d440f8cb19373cfad7a2f0f0ca4f963c57ff29)
2007-06-04 13:53:19 +04:00
uint32_t destnode,
const char *name, uint32_t value);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_list_tunables(struct ctdb_context *ctdb,
struct timeval timeout,
added tunables settable using ctdb command line tool (This used to be ctdb commit 73d440f8cb19373cfad7a2f0f0ca4f963c57ff29)
2007-06-04 13:53:19 +04:00
uint32_t destnode,
TALLOC_CTX *mem_ctx,
const char ***list, uint32_t *count);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_modflags(struct ctdb_context *ctdb,
struct timeval timeout,
uint32_t destnode,
implement a scheme where nodes are banned if they continuously caused the cluster to start a recovery session. The node is banned from the cluster for the RecoveryBanPeriod (default of 5 minutes) (This used to be ctdb commit 4ad43dd07f526b6002477177fbf55483246c2c0c)
2007-06-07 09:18:55 +04:00
uint32_t set, uint32_t clear);
added tunables settable using ctdb command line tool (This used to be ctdb commit 73d440f8cb19373cfad7a2f0f0ca4f963c57ff29)
2007-06-04 13:53:19 +04:00
Add two new server types to the server_id structure. NFSD and ISCSID for now. (This used to be ctdb commit 4cd4bab68f0ba0305a585a2aabcb6871cdb11d96)
2010-09-13 09:01:47 +04:00
enum ctdb_server_id_type {
SERVER_TYPE_SAMBA=1,
SERVER_TYPE_NFSD=2,
SERVER_TYPE_ISCSID=3
};
add an initial implementation of a service_id structure and three controls to register/unregister/check a server id. a server id consists of TYPE:VNN:ID where type is specific to the application. VNN is the node where the serverid was registered and ID might be a node unique identifier such as a pid or similar. Clients can register a server id for themself at the local ctdb daemon. When a client dissappears or when the domain socket connection for the client drops then any and all server ids registered across that domain socket will also be automatically removed from the store. clients can register as many server_ids as they want at the same time but each TYPE:VNN:ID must be globally unique. Clients have the option of explicitely unregister a server id by using the UNREGISTER control. Registration and unregistration can only be done by clients to the local daemon. clients can not register their server id to a remote node. clients can check if a server id does exist on any ctdb node in the network by using the check control (This used to be ctdb commit d44798feec26147c5cc05922cb2186f0ef0307be)
2007-08-24 09:53:41 +04:00
struct ctdb_server_id {
enum ctdb_server_id_type type;
change server_id.vnn to server_id.pnn (This used to be ctdb commit 26f2ee2b754a9271454412f05111a19b3013c6eb)
2007-09-04 04:21:51 +04:00
uint32_t pnn;
add an initial implementation of a service_id structure and three controls to register/unregister/check a server id. a server id consists of TYPE:VNN:ID where type is specific to the application. VNN is the node where the serverid was registered and ID might be a node unique identifier such as a pid or similar. Clients can register a server id for themself at the local ctdb daemon. When a client dissappears or when the domain socket connection for the client drops then any and all server ids registered across that domain socket will also be automatically removed from the store. clients can register as many server_ids as they want at the same time but each TYPE:VNN:ID must be globally unique. Clients have the option of explicitely unregister a server id by using the UNREGISTER control. Registration and unregistration can only be done by clients to the local daemon. clients can not register their server id to a remote node. clients can check if a server id does exist on any ctdb node in the network by using the check control (This used to be ctdb commit d44798feec26147c5cc05922cb2186f0ef0307be)
2007-08-24 09:53:41 +04:00
uint32_t server_id;
};
add a control to pull the server id list off a node (This used to be ctdb commit 38aa759aa88a042c31b401551f6a713fb7bbe84e)
2007-08-26 04:57:02 +04:00
struct ctdb_server_id_list {
uint32_t num;
struct ctdb_server_id server_ids[1];
};
add an initial implementation of a service_id structure and three controls to register/unregister/check a server id. a server id consists of TYPE:VNN:ID where type is specific to the application. VNN is the node where the serverid was registered and ID might be a node unique identifier such as a pid or similar. Clients can register a server id for themself at the local ctdb daemon. When a client dissappears or when the domain socket connection for the client drops then any and all server ids registered across that domain socket will also be automatically removed from the store. clients can register as many server_ids as they want at the same time but each TYPE:VNN:ID must be globally unique. Clients have the option of explicitely unregister a server id by using the UNREGISTER control. Registration and unregistration can only be done by clients to the local daemon. clients can not register their server id to a remote node. clients can check if a server id does exist on any ctdb node in the network by using the check control (This used to be ctdb commit d44798feec26147c5cc05922cb2186f0ef0307be)
2007-08-24 09:53:41 +04:00
int ctdb_ctrl_register_server_id(struct ctdb_context *ctdb,
struct timeval timeout,
struct ctdb_server_id *id);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_unregister_server_id(struct ctdb_context *ctdb,
struct timeval timeout,
add an initial implementation of a service_id structure and three controls to register/unregister/check a server id. a server id consists of TYPE:VNN:ID where type is specific to the application. VNN is the node where the serverid was registered and ID might be a node unique identifier such as a pid or similar. Clients can register a server id for themself at the local ctdb daemon. When a client dissappears or when the domain socket connection for the client drops then any and all server ids registered across that domain socket will also be automatically removed from the store. clients can register as many server_ids as they want at the same time but each TYPE:VNN:ID must be globally unique. Clients have the option of explicitely unregister a server id by using the UNREGISTER control. Registration and unregistration can only be done by clients to the local daemon. clients can not register their server id to a remote node. clients can check if a server id does exist on any ctdb node in the network by using the check control (This used to be ctdb commit d44798feec26147c5cc05922cb2186f0ef0307be)
2007-08-24 09:53:41 +04:00
struct ctdb_server_id *id);
int ctdb_ctrl_check_server_id(struct ctdb_context *ctdb,
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
struct timeval timeout, uint32_t destnode,
add an initial implementation of a service_id structure and three controls to register/unregister/check a server id. a server id consists of TYPE:VNN:ID where type is specific to the application. VNN is the node where the serverid was registered and ID might be a node unique identifier such as a pid or similar. Clients can register a server id for themself at the local ctdb daemon. When a client dissappears or when the domain socket connection for the client drops then any and all server ids registered across that domain socket will also be automatically removed from the store. clients can register as many server_ids as they want at the same time but each TYPE:VNN:ID must be globally unique. Clients have the option of explicitely unregister a server id by using the UNREGISTER control. Registration and unregistration can only be done by clients to the local daemon. clients can not register their server id to a remote node. clients can check if a server id does exist on any ctdb node in the network by using the check control (This used to be ctdb commit d44798feec26147c5cc05922cb2186f0ef0307be)
2007-08-24 09:53:41 +04:00
struct ctdb_server_id *id, uint32_t *status);
add a control to pull the server id list off a node (This used to be ctdb commit 38aa759aa88a042c31b401551f6a713fb7bbe84e)
2007-08-26 04:57:02 +04:00
int ctdb_ctrl_get_server_id_list(struct ctdb_context *ctdb,
TALLOC_CTX *mem_ctx,
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
struct timeval timeout, uint32_t destnode,
add a control to pull the server id list off a node (This used to be ctdb commit 38aa759aa88a042c31b401551f6a713fb7bbe84e)
2007-08-26 04:57:02 +04:00
struct ctdb_server_id_list **svid_list);
add an initial implementation of a service_id structure and three controls to register/unregister/check a server id. a server id consists of TYPE:VNN:ID where type is specific to the application. VNN is the node where the serverid was registered and ID might be a node unique identifier such as a pid or similar. Clients can register a server id for themself at the local ctdb daemon. When a client dissappears or when the domain socket connection for the client drops then any and all server ids registered across that domain socket will also be automatically removed from the store. clients can register as many server_ids as they want at the same time but each TYPE:VNN:ID must be globally unique. Clients have the option of explicitely unregister a server id by using the UNREGISTER control. Registration and unregistration can only be done by clients to the local daemon. clients can not register their server id to a remote node. clients can check if a server id does exist on any ctdb node in the network by using the check control (This used to be ctdb commit d44798feec26147c5cc05922cb2186f0ef0307be)
2007-08-24 09:53:41 +04:00
add a ctdb uptime command that prints when ctdb was started and when the last recovery occured (This used to be ctdb commit b86e8ccbdac044bb949c4fc2ebb27635126272a9)
2008-01-17 03:33:23 +03:00
struct ctdb_uptime {
struct timeval current_time;
struct timeval ctdbd_start_time;
track both when we last started and ended a recovery. make ctdb uptime print how long the recovery took in the recovery daemon when we check that the public ip address allocation on the local node is correct (we have the ips we should have and we dont have any we shouldnt have) use ctdb uptime and check the recovery start/stop times and make sure we dont check for ip allocation inconsistencies during a recovery where the ip address allocation is in flux. (This used to be ctdb commit f86551580349b7f662f9a07e4eb0c1189e38e429)
2008-07-02 07:55:59 +04:00
struct timeval last_recovery_started;
struct timeval last_recovery_finished;
add a ctdb uptime command that prints when ctdb was started and when the last recovery occured (This used to be ctdb commit b86e8ccbdac044bb949c4fc2ebb27635126272a9)
2008-01-17 03:33:23 +03:00
};
finish the ipv6 support. allow clients to register either ipv4 or ipv6 client connections to the tickles list (This used to be ctdb commit d9b44d7c3255b0fd7359b9afeb613e6ff4c4eaac)
2009-01-13 08:17:20 +03:00
/*
struct for tcp_client control
this is an ipv4 only version of this structure used by samba
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
samba will later be migrated over to use the
finish the ipv6 support. allow clients to register either ipv4 or ipv6 client connections to the tickles list (This used to be ctdb commit d9b44d7c3255b0fd7359b9afeb613e6ff4c4eaac)
2009-01-13 08:17:20 +03:00
ctdb_control_tcp_addr structure instead
*/
struct ctdb_control_tcp {
struct sockaddr_in src; // samba uses this
struct sockaddr_in dest;// samba uses this
};
/* new style structure */
struct ctdb_control_tcp_addr {
ctdb_sock_addr src;
ctdb_sock_addr dest;
};
merge changes needed for samba4 (This used to be ctdb commit a7f80f78cd62401b3516da3640bf24d6362db872)
2007-08-15 03:03:58 +04:00
int ctdb_socket_connect(struct ctdb_context *ctdb);
add a ctdb uptime command that prints when ctdb was started and when the last recovery occured (This used to be ctdb commit b86e8ccbdac044bb949c4fc2ebb27635126272a9)
2008-01-17 03:33:23 +03:00
/*
get the uptime of a remote node
*/
int ctdb_ctrl_uptime(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode, struct ctdb_uptime **uptime);
struct ctdb_client_control_state *ctdb_ctrl_uptime_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
int ctdb_ctrl_uptime_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, struct ctdb_uptime **uptime);
merge async recovery changes from Ronnie (This used to be ctdb commit 576e317640d25f8059114f15c6f1ebcee5e5b6e2)
2008-01-29 05:59:28 +03:00
int ctdb_ctrl_end_recovery(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_getreclock(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
add a control to get the name of the reclock file from the daemon (This used to be ctdb commit 9effb22cc1616d684352d7ebabb359e69adb0f52)
2008-02-29 02:03:39 +03:00
TALLOC_CTX *mem_ctx, const char **reclock);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_setreclock(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
add a control to set the reclock file (This used to be ctdb commit 36cc2e586f03fa497ee9b06f3e6afc80219c4aaa)
2009-06-25 08:25:18 +04:00
const char *reclock);
add a control to get the name of the reclock file from the daemon (This used to be ctdb commit 9effb22cc1616d684352d7ebabb359e69adb0f52)
2008-02-29 02:03:39 +03:00
reqrite the handling of flag updates across the cluster to eliminate a race between the ctdb tool and the recovery daemon both at once trying to push flag changes across the cluster. (This used to be ctdb commit a9a1156ea4e10483a4bf4265b8e9203f0af033aa)
2008-11-19 06:43:46 +03:00
uint32_t *list_of_connected_nodes(struct ctdb_context *ctdb,
struct ctdb_node_map *node_map,
TALLOC_CTX *mem_ctx,
bool include_self);
merge async recovery changes from Ronnie (This used to be ctdb commit 576e317640d25f8059114f15c6f1ebcee5e5b6e2)
2008-01-29 05:59:28 +03:00
uint32_t *list_of_active_nodes(struct ctdb_context *ctdb,
struct ctdb_node_map *node_map,
TALLOC_CTX *mem_ctx,
bool include_self);
uint32_t *list_of_vnnmap_nodes(struct ctdb_context *ctdb,
struct ctdb_vnn_map *vnn_map,
TALLOC_CTX *mem_ctx,
bool include_self);
add a new function to collect a list of all active nodes EXCEPT a certain node (This used to be ctdb commit be52954d921e7d443304cf49fbd488c619a9c4ec)
2009-10-06 03:52:31 +04:00
uint32_t *list_of_active_nodes_except_pnn(struct ctdb_context *ctdb,
struct ctdb_node_map *node_map,
TALLOC_CTX *mem_ctx,
uint32_t pnn);
merge async recovery changes from Ronnie (This used to be ctdb commit 576e317640d25f8059114f15c6f1ebcee5e5b6e2)
2008-01-29 05:59:28 +03:00
add a new file <reclock>.pnn where each recovery daemon can lock that byte at offset==pnn to offer an alternative way to detect which nodes are active instead of relying on CONNECTED being accurate. (This used to be ctdb commit 21d3319eaf463e2a00637d440ee2d4d15f53bf09)
2008-02-29 04:37:42 +03:00
int ctdb_read_pnn_lock(int fd, int32_t pnn);
Add a capabilities field to the ctdb structure Define two capabilities : can be recmaster can be lmaster Default both capabilities to YES Update the ctdb tool to read capabilities off a node (This used to be ctdb commit 50f1255ea9ed15bb8fa11cf838b29afa77e857fd)
2008-05-06 04:02:27 +04:00
/*
get capabilities of a remote node
*/
int ctdb_ctrl_getcapabilities(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t *capabilities);
struct ctdb_client_control_state *ctdb_ctrl_getcapabilities_send(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct timeval timeout, uint32_t destnode);
int ctdb_ctrl_getcapabilities_recv(struct ctdb_context *ctdb, TALLOC_CTX *mem_ctx, struct ctdb_client_control_state *state, uint32_t *capabilities);
make ctdb_ctrl_transaction_active public. Michael (This used to be ctdb commit e5496a83ef4a01604195b27c4b97f50d4979510e)
2009-12-03 02:25:16 +03:00
int32_t ctdb_ctrl_transaction_active(struct ctdb_context *ctdb,
uint32_t destnode,
uint32_t db_id);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
struct ctdb_marshall_buffer *ctdb_marshall_add(TALLOC_CTX *mem_ctx,
new prototypes (This used to be ctdb commit 71d9d24abae62f70acbd7c1ded8af0b817607c2a)
2008-07-30 13:58:27 +04:00
struct ctdb_marshall_buffer *m,
uint64_t db_id,
uint32_t reqid,
TDB_DATA key,
struct ctdb_ltdb_header *header,
TDB_DATA data);
TDB_DATA ctdb_marshall_finish(struct ctdb_marshall_buffer *m);
struct ctdb_transaction_handle *ctdb_transaction_start(struct ctdb_db_context *ctdb_db,
TALLOC_CTX *mem_ctx);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_transaction_fetch(struct ctdb_transaction_handle *h,
TALLOC_CTX *mem_ctx,
new prototypes (This used to be ctdb commit 71d9d24abae62f70acbd7c1ded8af0b817607c2a)
2008-07-30 13:58:27 +04:00
TDB_DATA key, TDB_DATA *data);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_transaction_store(struct ctdb_transaction_handle *h,
new prototypes (This used to be ctdb commit 71d9d24abae62f70acbd7c1ded8af0b817607c2a)
2008-07-30 13:58:27 +04:00
TDB_DATA key, TDB_DATA data);
int ctdb_transaction_commit(struct ctdb_transaction_handle *h);
additional monitoring between the two daemons. we currently only monitor that the dameons are running by kill(0, pid) and verifying the the domain socket between them is ok. this is not sufficient since we can have a situation where the recovery daemon is hung. this new code monitors that the recovery daemon is operating. if the recovery hangs, we log this and shut down the main daemon (This used to be ctdb commit cd69d292292eaab3aac0e9d9fc57cb621597c63c)
2008-09-09 07:44:46 +04:00
int ctdb_ctrl_recd_ping(struct ctdb_context *ctdb);
logging: give a unique logging name to each forked child. This means we can distinguish which child is logging, esp. via syslog where we have no pid. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 68b3761a0874429b90731741f0531f76dcfbb081)
2010-07-19 13:59:09 +04:00
int switch_from_server_to_client(struct ctdb_context *ctdb, const char *fmt,
...);
create a helper function that converts a ctdb instance in daemon mode to become a ctdb client instance. use this from the recovery daemon child process to switch to client mode and connect back to the main daemon (This used to be ctdb commit 16f31786a031255ab5b3099a0a3c745de973347a)
2009-03-23 04:37:30 +03:00
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
int ctdb_ctrl_getscriptstatus(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
ctdb: scriptstatus can now query non-monitor events We also no longer return an error before scripts have been run; a special zero-length data means we have never run the scripts. "ctdb scriptstatus all" returns all event script results. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 9b90d671581e390e2892d3a68f3ca98d58bef4df)
2009-12-07 18:20:55 +03:00
TALLOC_CTX *mem_ctx, enum ctdb_eventscript_call type,
struct ctdb_scripts_wire **script_status);
add a new command "ctdb scriptstatus" this command shows which eventscripts were executed during the last monitoring cycle and the status from each eventscript. If an eventscript timedout or returned an error we also show the output from the eventscript. Example : [root@rcn1 ctdb-git]# ./bin/ctdb scriptstatus 6 scripts were executed last monitoring cycle 00.ctdb Status:OK Duration:0.021 Mon Mar 23 19:04:32 2009 10.interface Status:OK Duration:0.048 Mon Mar 23 19:04:32 2009 20.multipathd Status:OK Duration:0.011 Mon Mar 23 19:04:33 2009 40.vsftpd Status:OK Duration:0.011 Mon Mar 23 19:04:33 2009 41.httpd Status:OK Duration:0.011 Mon Mar 23 19:04:33 2009 50.samba Status:ERROR Duration:0.057 Mon Mar 23 19:04:33 2009 OUTPUT:ERROR: Samba tcp port 445 is not responding Add a new helper function "switch_from_server_to_client()" which both the recovery daemon can use as well as in the child process we start for running the actual eventscripts. Create several new controls, both for the eventscript child process to inform the master daemon of the current status of the scripts as well as for the ctdb tool to extract this information from the runninc daemon. (This used to be ctdb commit c98f90ad61c9b1e679116fbed948ddca4111968d)
2009-03-23 11:07:45 +03:00
update the handling of debug levels so that we always can use a literal instead of a numeric value. validate the input values used and refuse setting the debug level to an unknown value (This used to be ctdb commit daec49cea1790bcc64599959faf2159dec2c5929)
2009-07-01 03:17:13 +04:00
struct debug_levels {
int32_t level;
const char *description;
};
extern struct debug_levels debug_levels[];
const char *get_debug_by_level(int32_t level);
int32_t get_debug_by_desc(const char *desc);
add two new controls, CTOP_NODE and CONTINUE_NODE that are used to stop/continue a node instead of using modflags messages (This used to be ctdb commit 54b4a02053a0f98f8c424e7f658890254023d39a)
2009-07-09 06:22:46 +04:00
int ctdb_ctrl_stop_node(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
int ctdb_ctrl_continue_node(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
update the handling of debug levels so that we always can use a literal instead of a numeric value. validate the input values used and refuse setting the debug level to an unknown value (This used to be ctdb commit daec49cea1790bcc64599959faf2159dec2c5929)
2009-07-01 03:17:13 +04:00
add a command "setnatgwstate {on|off}" that can be used to indicate if this node is using natgw functionality or not. (This used to be ctdb commit 89a9bb29a60a6fb1fba55987e6cf0a4baa695e50)
2009-07-28 03:58:11 +04:00
int ctdb_ctrl_setnatgwstate(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t natgwstate);
add two commands : setlmasterrole and setrecmasterrole to enable/disable these capabilities at runtime (This used to be ctdb commit 51aaed0e9e42e901451292e8dd545297ab725a62)
2009-07-28 07:45:13 +04:00
int ctdb_ctrl_setlmasterrole(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t lmasterrole);
int ctdb_ctrl_setrecmasterrole(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t recmasterrole);
add a command "setnatgwstate {on|off}" that can be used to indicate if this node is using natgw functionality or not. (This used to be ctdb commit 89a9bb29a60a6fb1fba55987e6cf0a4baa695e50)
2009-07-28 03:58:11 +04:00
add new controls to make it possible to enable/disable individual eventscripts update scriptstatus output so it lists disabled scripts (This used to be ctdb commit 7e799b7523c9699bd65a8a8207f7e03d668b0b81)
2009-08-13 07:04:08 +04:00
int ctdb_ctrl_enablescript(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, const char *script);
int ctdb_ctrl_disablescript(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, const char *script);
new prototype banning code (This used to be ctdb commit 0c4c2240267af183d54ffd4c0aacda208f6eff6a)
2009-09-03 20:20:39 +04:00
struct ctdb_ban_time {
uint32_t pnn;
uint32_t time;
};
int ctdb_ctrl_set_ban(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, struct ctdb_ban_time *bantime);
int ctdb_ctrl_get_ban(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, TALLOC_CTX *mem_ctx, struct ctdb_ban_time **bantime);
add a control to set a database priority. Let newly created databases default to priority 1. database priorities will be used to control in which order databases are locked during recovery in. (This used to be ctdb commit 67741c0ee01916d94cace8e9462ef02507e06078)
2009-10-10 07:26:09 +04:00
struct ctdb_db_priority {
uint32_t db_id;
uint32_t priority;
};
int ctdb_ctrl_set_db_priority(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, struct ctdb_db_priority *db_prio);
add a control to read the db priority from a database (This used to be ctdb commit ca6d045e419f308f57e74d4c978907afb05ddb85)
2009-10-10 08:04:18 +04:00
int ctdb_ctrl_get_db_priority(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, uint32_t db_id, uint32_t *priority);
new prototype banning code (This used to be ctdb commit 0c4c2240267af183d54ffd4c0aacda208f6eff6a)
2009-09-03 20:20:39 +04:00
Add rolling statistics that are collected across 10 second intervals. Add a new command "ctdb stats [num]" that prints the [num] most recent statistics intervals collected. (This used to be ctdb commit e6e16fcd5a45ebd3739a8160c8fb5f44494edb9e)
2010-09-29 06:13:05 +04:00
int ctdb_ctrl_getstathistory(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, TALLOC_CTX *mem_ctx, struct ctdb_statistics_wire **stats);
ReadOnly: Add clientside functions to send the UPDATE_RECORD control (This used to be ctdb commit 74a5b3d7bafd8827a4ee80095fde5798263821e4)
2011-07-20 06:06:37 +04:00
struct ctdb_client_control_state *
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);
int ctdb_ctrl_updaterecord_recv(struct ctdb_context *ctdb, struct ctdb_client_control_state *state);
int
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);
ReadOnly: add a new control to activate readonly lock capability for a database. let all databases default to not support this until enabled through this control (This used to be ctdb commit 908a07c42e5135a3ba30a625fc4f4e4916de197a)
2011-09-01 05:08:18 +04:00
struct ctdb_client_control_state *
ctdb_ctrl_set_db_readonly_send(struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid);
int ctdb_ctrl_set_db_readonly_recv(struct ctdb_context *ctdb, struct ctdb_client_control_state *state);
int ctdb_ctrl_set_db_readonly(struct ctdb_context *ctdb, uint32_t destnode, uint32_t dbid);
libctdb: reorganize headers: remove ctdb.h, add ctdb_client.h and ctdb_protocol.h ctdb_client.h is the existing internal client interface (which was mainly in ctdb.h), and ctdb_protocol.h is the information needed for the wire protocol only. ctdb.h will be the new, shiny, libctdb API. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (This used to be ctdb commit 4bba6b8cd47b352f98d41f9f06258d5ac3c9adef)
2010-05-20 09:48:30 +04:00
#endif /* _CTDB_CLIENT_H */
Copy Permalink