*/
#include "includes.h"
-#include "lib/events/events.h"
+#include "lib/tevent/tevent.h"
#include "system/time.h"
#include "system/filesys.h"
#include "system/network.h"
#include "popt.h"
#include "cmdline.h"
#include "../include/ctdb.h"
+#include "../include/ctdb_client.h"
#include "../include/ctdb_private.h"
#include "../common/rb_tree.h"
#include "db_wrap.h"
#define ERR_NONODE 21 /* node does not exist */
#define ERR_DISNODE 22 /* node is disconnected */
+struct ctdb_connection *ctdb_connection;
+
static void usage(void);
static struct {
int timelimit;
uint32_t pnn;
int machinereadable;
+ int verbose;
int maxruntime;
} options;
#define TIMELIMIT() timeval_current_ofs(options.timelimit, 0)
+#define LONGTIMELIMIT() timeval_current_ofs(options.timelimit*10, 0)
#ifdef CTDB_VERS
static int control_version(struct ctdb_context *ctdb, int argc, const char **argv)
/* verify we can access the node */
ret = ctdb_ctrl_getpnn(ctdb, TIMELIMIT(), options.pnn);
if (ret == -1) {
- DEBUG(DEBUG_ERR,("Can not ban node. Node is not operational.\n"));
+ DEBUG(DEBUG_ERR,("Can not access node. Node is not operational.\n"));
exit(10);
}
}
/*
check if a database exists
*/
-static int db_exists(struct ctdb_context *ctdb, const char *db_name)
+static int db_exists(struct ctdb_context *ctdb, const char *db_name, bool *persistent)
{
int i, ret;
struct ctdb_dbid_map *dbmap=NULL;
ctdb_ctrl_getdbname(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &name);
if (!strcmp(name, db_name)) {
+ if (persistent) {
+ *persistent = dbmap->dbs[i].persistent;
+ }
return 0;
}
}
/*
display statistics structure
*/
-static void show_statistics(struct ctdb_statistics *s)
+static void show_statistics(struct ctdb_statistics *s, int show_header)
{
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
int i;
const char *prefix=NULL;
int preflen=0;
+ int tmp, days, hours, minutes, seconds;
const struct {
const char *name;
uint32_t offset;
STATISTICS_FIELD(num_clients),
STATISTICS_FIELD(frozen),
STATISTICS_FIELD(recovering),
+ STATISTICS_FIELD(num_recoveries),
STATISTICS_FIELD(client_packets_sent),
STATISTICS_FIELD(client_packets_recv),
STATISTICS_FIELD(node_packets_sent),
STATISTICS_FIELD(memory_used),
STATISTICS_FIELD(max_hop_count),
};
- printf("CTDB version %u\n", CTDB_VERSION);
- for (i=0;i<ARRAY_SIZE(fields);i++) {
- if (strchr(fields[i].name, '.')) {
- preflen = strcspn(fields[i].name, ".")+1;
- if (!prefix || strncmp(prefix, fields[i].name, preflen) != 0) {
- prefix = fields[i].name;
- printf(" %*.*s\n", preflen-1, preflen-1, fields[i].name);
+ tmp = s->statistics_current_time.tv_sec - s->statistics_start_time.tv_sec;
+ seconds = tmp%60;
+ tmp /= 60;
+ minutes = tmp%60;
+ tmp /= 60;
+ hours = tmp%24;
+ tmp /= 24;
+ days = tmp;
+
+ if (options.machinereadable){
+ if (show_header) {
+ printf("CTDB version:");
+ printf("Current time of statistics:");
+ printf("Statistics collected since:");
+ for (i=0;i<ARRAY_SIZE(fields);i++) {
+ printf("%s:", fields[i].name);
}
- } else {
- preflen = 0;
+ printf("max_reclock_ctdbd:");
+ printf("max_reclock_recd:");
+ printf("max_call_latency:");
+ printf("max_lockwait_latency:");
+ printf("max_childwrite_latency:");
+ printf("max_childwrite_latency:");
+ printf("\n");
+ }
+ printf("%d:", CTDB_VERSION);
+ printf("%d:", (int)s->statistics_current_time.tv_sec);
+ printf("%d:", (int)s->statistics_start_time.tv_sec);
+ for (i=0;i<ARRAY_SIZE(fields);i++) {
+ printf("%d:", *(uint32_t *)(fields[i].offset+(uint8_t *)s));
+ }
+ printf("%.6f:", s->reclock.ctdbd);
+ printf("%.6f:", s->reclock.recd);
+ printf("%.6f:", s->max_call_latency);
+ printf("%.6f:", s->max_lockwait_latency);
+ printf("%.6f:", s->max_childwrite_latency);
+ printf("%.6f:", s->max_childwrite_latency);
+ printf("\n");
+ } else {
+ printf("CTDB version %u\n", CTDB_VERSION);
+ printf("Current time of statistics : %s", ctime(&s->statistics_current_time.tv_sec));
+ printf("Statistics collected since : (%03d %02d:%02d:%02d) %s", days, hours, minutes, seconds, ctime(&s->statistics_start_time.tv_sec));
+
+ for (i=0;i<ARRAY_SIZE(fields);i++) {
+ if (strchr(fields[i].name, '.')) {
+ preflen = strcspn(fields[i].name, ".")+1;
+ if (!prefix || strncmp(prefix, fields[i].name, preflen) != 0) {
+ prefix = fields[i].name;
+ printf(" %*.*s\n", preflen-1, preflen-1, fields[i].name);
+ }
+ } else {
+ preflen = 0;
+ }
+ printf(" %*s%-22s%*s%10u\n",
+ preflen?4:0, "",
+ fields[i].name+preflen,
+ preflen?0:4, "",
+ *(uint32_t *)(fields[i].offset+(uint8_t *)s));
}
- printf(" %*s%-22s%*s%10u\n",
- preflen?4:0, "",
- fields[i].name+preflen,
- preflen?0:4, "",
- *(uint32_t *)(fields[i].offset+(uint8_t *)s));
+ printf(" %-30s %.6f sec\n", "max_reclock_ctdbd", s->reclock.ctdbd);
+ printf(" %-30s %.6f sec\n", "max_reclock_recd", s->reclock.recd);
+
+ printf(" %-30s %.6f sec\n", "max_call_latency", s->max_call_latency);
+ printf(" %-30s %.6f sec\n", "max_lockwait_latency", s->max_lockwait_latency);
+ printf(" %-30s %.6f sec\n", "max_childwrite_latency", s->max_childwrite_latency);
+ printf(" %-30s %.6f sec\n", "max_childwrite_latency", s->max_childwrite_latency);
}
- printf(" %-30s %.6f sec\n", "max_reclock_ctdbd", s->reclock.ctdbd);
- printf(" %-30s %.6f sec\n", "max_reclock_recd", s->reclock.recd);
- printf(" %-30s %.6f sec\n", "max_call_latency", s->max_call_latency);
- printf(" %-30s %.6f sec\n", "max_lockwait_latency", s->max_lockwait_latency);
- printf(" %-30s %.6f sec\n", "max_childwrite_latency", s->max_childwrite_latency);
talloc_free(tmp_ctx);
}
}
talloc_free(nodes);
printf("Gathered statistics for %u nodes\n", num_nodes);
- show_statistics(&statistics);
+ show_statistics(&statistics, 1);
return 0;
}
DEBUG(DEBUG_ERR, ("Unable to get statistics from node %u\n", options.pnn));
return ret;
}
- show_statistics(&statistics);
+ show_statistics(&statistics, 1);
return 0;
}
}
+/*
+ display remote ctdb rolling statistics
+ */
+static int control_stats(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ int ret;
+ struct ctdb_statistics_wire *stats;
+ int i, num_records = -1;
+
+ if (argc ==1) {
+ num_records = atoi(argv[0]) - 1;
+ }
+
+ ret = ctdb_ctrl_getstathistory(ctdb, TIMELIMIT(), options.pnn, ctdb, &stats);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get rolling statistics from node %u\n", options.pnn));
+ return ret;
+ }
+ for (i=0;i<stats->num;i++) {
+ if (stats->stats[i].statistics_start_time.tv_sec == 0) {
+ continue;
+ }
+ show_statistics(&stats->stats[i], i==0);
+ if (i == num_records) {
+ break;
+ }
+ }
+ return 0;
+}
+
+
/*
display uptime of remote node
*/
*/
static int control_pnn(struct ctdb_context *ctdb, int argc, const char **argv)
{
- int mypnn;
+ uint32_t mypnn;
+ bool ret;
- mypnn = ctdb_ctrl_getpnn(ctdb, TIMELIMIT(), options.pnn);
- if (mypnn == -1) {
- DEBUG(DEBUG_ERR, ("Unable to get pnn from local node."));
+ ret = ctdb_getpnn(ctdb_connection, options.pnn, &mypnn);
+ if (!ret) {
+ DEBUG(DEBUG_ERR, ("Unable to get pnn from node."));
return -1;
}
}
if(options.machinereadable){
- printf(":Node:IP:Disconnected:Banned:Disabled:Unhealthy:Stopped:\n");
+ printf(":Node:IP:Disconnected:Banned:Disabled:Unhealthy:Stopped:Inactive:PartiallyOnline:\n");
for(i=0;i<nodemap->num;i++){
+ int partially_online = 0;
+ int j;
+
if (nodemap->nodes[i].flags & NODE_FLAGS_DELETED) {
continue;
}
- printf(":%d:%s:%d:%d:%d:%d:%d:\n", nodemap->nodes[i].pnn,
+ if (nodemap->nodes[i].flags == 0) {
+ struct ctdb_control_get_ifaces *ifaces;
+
+ ret = ctdb_ctrl_get_ifaces(ctdb, TIMELIMIT(),
+ nodemap->nodes[i].pnn,
+ ctdb, &ifaces);
+ if (ret == 0) {
+ for (j=0; j < ifaces->num; j++) {
+ if (ifaces->ifaces[j].link_state != 0) {
+ continue;
+ }
+ partially_online = 1;
+ break;
+ }
+ talloc_free(ifaces);
+ }
+ }
+ printf(":%d:%s:%d:%d:%d:%d:%d:%d:%d:\n", nodemap->nodes[i].pnn,
ctdb_addr_to_str(&nodemap->nodes[i].addr),
!!(nodemap->nodes[i].flags&NODE_FLAGS_DISCONNECTED),
!!(nodemap->nodes[i].flags&NODE_FLAGS_BANNED),
!!(nodemap->nodes[i].flags&NODE_FLAGS_PERMANENTLY_DISABLED),
!!(nodemap->nodes[i].flags&NODE_FLAGS_UNHEALTHY),
- !!(nodemap->nodes[i].flags&NODE_FLAGS_STOPPED));
+ !!(nodemap->nodes[i].flags&NODE_FLAGS_STOPPED),
+ !!(nodemap->nodes[i].flags&NODE_FLAGS_INACTIVE),
+ partially_online);
}
return 0;
}
{ NODE_FLAGS_UNHEALTHY, "UNHEALTHY" },
{ NODE_FLAGS_DELETED, "DELETED" },
{ NODE_FLAGS_STOPPED, "STOPPED" },
+ { NODE_FLAGS_INACTIVE, "INACTIVE" },
};
char *flags_str = NULL;
int j;
if (nodemap->nodes[i].flags & NODE_FLAGS_DELETED) {
continue;
}
+ if (nodemap->nodes[i].flags == 0) {
+ struct ctdb_control_get_ifaces *ifaces;
+
+ ret = ctdb_ctrl_get_ifaces(ctdb, TIMELIMIT(),
+ nodemap->nodes[i].pnn,
+ ctdb, &ifaces);
+ if (ret == 0) {
+ for (j=0; j < ifaces->num; j++) {
+ if (ifaces->ifaces[j].link_state != 0) {
+ continue;
+ }
+ flags_str = talloc_strdup(ctdb, "PARTIALLYONLINE");
+ break;
+ }
+ talloc_free(ifaces);
+ }
+ }
for (j=0;j<ARRAY_SIZE(flag_names);j++) {
if (nodemap->nodes[i].flags & flag_names[j].flag) {
if (flags_str == NULL) {
static int control_natgwlist(struct ctdb_context *ctdb, int argc, const char **argv)
{
int i, ret;
+ uint32_t capabilities;
const char *natgw_list;
int nlines;
char **lines;
*/
for(i=0;i<nodemap->num;i++){
if (!(nodemap->nodes[i].flags & (NODE_FLAGS_DISCONNECTED|NODE_FLAGS_STOPPED|NODE_FLAGS_DELETED|NODE_FLAGS_BANNED|NODE_FLAGS_UNHEALTHY))) {
+ ret = ctdb_ctrl_getcapabilities(ctdb, TIMELIMIT(), nodemap->nodes[i].pnn, &capabilities);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get capabilities from node %u\n", nodemap->nodes[i].pnn));
+ return ret;
+ }
+ if (!(capabilities&CTDB_CAP_NATGW)) {
+ continue;
+ }
printf("%d %s\n", nodemap->nodes[i].pnn,ctdb_addr_to_str(&nodemap->nodes[i].addr));
break;
}
if (i == nodemap->num) {
for(i=0;i<nodemap->num;i++){
if (!(nodemap->nodes[i].flags & (NODE_FLAGS_DISCONNECTED|NODE_FLAGS_STOPPED|NODE_FLAGS_DELETED))) {
+ ret = ctdb_ctrl_getcapabilities(ctdb, TIMELIMIT(), nodemap->nodes[i].pnn, &capabilities);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get capabilities from node %u\n", nodemap->nodes[i].pnn));
+ return ret;
+ }
+ if (!(capabilities&CTDB_CAP_NATGW)) {
+ continue;
+ }
printf("%d %s\n", nodemap->nodes[i].pnn,ctdb_addr_to_str(&nodemap->nodes[i].addr));
break;
}
if (i == nodemap->num) {
for(i=0;i<nodemap->num;i++){
if (!(nodemap->nodes[i].flags & (NODE_FLAGS_DISCONNECTED|NODE_FLAGS_DELETED))) {
+ ret = ctdb_ctrl_getcapabilities(ctdb, TIMELIMIT(), nodemap->nodes[i].pnn, &capabilities);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get capabilities from node %u\n", nodemap->nodes[i].pnn));
+ return ret;
+ }
+ if (!(capabilities&CTDB_CAP_NATGW)) {
+ continue;
+ }
printf("%d %s\n", nodemap->nodes[i].pnn, ctdb_addr_to_str(&nodemap->nodes[i].addr));
break;
}
return 0;
}
-
/*
- display the status of the monitoring scripts
+ display the status of the scripts for monitoring (or other events)
*/
-static int control_scriptstatus(struct ctdb_context *ctdb, int argc, const char **argv)
+static int control_one_scriptstatus(struct ctdb_context *ctdb,
+ enum ctdb_eventscript_call type)
{
- int i, ret;
struct ctdb_scripts_wire *script_status;
+ int ret, i;
- ret = ctdb_ctrl_getscriptstatus(ctdb, TIMELIMIT(), options.pnn, ctdb, &script_status);
+ ret = ctdb_ctrl_getscriptstatus(ctdb, TIMELIMIT(), options.pnn, ctdb, type, &script_status);
if (ret != 0) {
DEBUG(DEBUG_ERR, ("Unable to get script status from node %u\n", options.pnn));
return ret;
}
- if (options.machinereadable) {
- printf(":Name:Code:Status:Start:End:Error Output...:\n");
- } else {
- printf("%d scripts were executed last monitoring cycle\n", script_status->num_scripts);
+ if (script_status == NULL) {
+ if (!options.machinereadable) {
+ printf("%s cycle never run\n",
+ ctdb_eventscript_call_names[type]);
+ }
+ return 0;
+ }
+
+ if (!options.machinereadable) {
+ printf("%d scripts were executed last %s cycle\n",
+ script_status->num_scripts,
+ ctdb_eventscript_call_names[type]);
}
for (i=0; i<script_status->num_scripts; i++) {
const char *status = NULL;
break;
}
if (options.machinereadable) {
- printf("%s:%i:%s:%lu.%06lu:%lu.%06lu:%s:\n",
+ printf("%s:%s:%i:%s:%lu.%06lu:%lu.%06lu:%s:\n",
+ ctdb_eventscript_call_names[type],
script_status->scripts[i].name,
script_status->scripts[i].status,
status,
if (script_status->scripts[i].status != -ENOEXEC) {
printf("%s",
ctime(&script_status->scripts[i].start.tv_sec));
+ if (script_status->scripts[i].status != 0) {
+ printf(" OUTPUT:%s\n",
+ script_status->scripts[i].output);
+ }
+ } else {
+ printf("\n");
+ }
+ }
+ return 0;
+}
+
+
+static int control_scriptstatus(struct ctdb_context *ctdb,
+ int argc, const char **argv)
+{
+ int ret;
+ enum ctdb_eventscript_call type, min, max;
+ const char *arg;
+
+ if (argc > 1) {
+ DEBUG(DEBUG_ERR, ("Unknown arguments to scriptstatus\n"));
+ return -1;
+ }
+
+ if (argc == 0)
+ arg = ctdb_eventscript_call_names[CTDB_EVENT_MONITOR];
+ else
+ arg = argv[0];
+
+ for (type = 0; type < CTDB_EVENT_MAX; type++) {
+ if (strcmp(arg, ctdb_eventscript_call_names[type]) == 0) {
+ min = type;
+ max = type+1;
+ break;
+ }
+ }
+ if (type == CTDB_EVENT_MAX) {
+ if (strcmp(arg, "all") == 0) {
+ min = 0;
+ max = CTDB_EVENT_MAX;
+ } else {
+ DEBUG(DEBUG_ERR, ("Unknown event type %s\n", argv[0]));
+ return -1;
}
- if (script_status->scripts[i].status != 0) {
- printf(" OUTPUT:%s\n",
- script_status->scripts[i].output);
+ }
+
+ if (options.machinereadable) {
+ printf(":Type:Name:Code:Status:Start:End:Error Output...:\n");
+ }
+
+ for (type = min; type < max; type++) {
+ ret = control_one_scriptstatus(ctdb, type);
+ if (ret != 0) {
+ return ret;
}
}
return 0;
}
-
/*
enable an eventscript
return 0;
}
+/*
+ add a tickle to a public address
+ */
+static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ struct ctdb_tcp_connection t;
+ TDB_DATA data;
+ int ret;
+
+ if (argc < 2) {
+ usage();
+ }
+
+ if (parse_ip_port(argv[0], &t.src_addr) == 0) {
+ DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
+ return -1;
+ }
+ if (parse_ip_port(argv[1], &t.dst_addr) == 0) {
+ DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1]));
+ return -1;
+ }
+
+ data.dptr = (uint8_t *)&t;
+ data.dsize = sizeof(t);
+
+ /* tell all nodes about this tcp connection */
+ ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE,
+ 0, data, ctdb, NULL, NULL, NULL, NULL);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Failed to add tickle\n"));
+ return -1;
+ }
+
+ return 0;
+}
+
+
+/*
+ delete a tickle from a node
+ */
+static int control_del_tickle(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ struct ctdb_tcp_connection t;
+ TDB_DATA data;
+ int ret;
+
+ if (argc < 2) {
+ usage();
+ }
+
+ if (parse_ip_port(argv[0], &t.src_addr) == 0) {
+ DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
+ return -1;
+ }
+ if (parse_ip_port(argv[1], &t.dst_addr) == 0) {
+ DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1]));
+ return -1;
+ }
+
+ data.dptr = (uint8_t *)&t;
+ data.dsize = sizeof(t);
+
+ /* tell all nodes about this tcp connection */
+ ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_TCP_REMOVE,
+ 0, data, ctdb, NULL, NULL, NULL, NULL);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Failed to remove tickle\n"));
+ return -1;
+ }
+
+ return 0;
+}
+
+
/*
get a list of all tickles for this pnn
*/
struct ctdb_control_tcp_tickle_list *list;
ctdb_sock_addr addr;
int i, ret;
+ unsigned port = 0;
if (argc < 1) {
usage();
}
+ if (argc == 2) {
+ port = atoi(argv[1]);
+ }
+
if (parse_ip(argv[0], NULL, 0, &addr) == 0) {
DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
return -1;
return -1;
}
- printf("Tickles for ip:%s\n", ctdb_addr_to_str(&list->addr));
- printf("Num tickles:%u\n", list->tickles.num);
- for (i=0;i<list->tickles.num;i++) {
- printf("SRC: %s:%u ", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port));
- printf("DST: %s:%u\n", ctdb_addr_to_str(&list->tickles.connections[i].dst_addr), ntohs(list->tickles.connections[i].dst_addr.ip.sin_port));
+ if (options.machinereadable){
+ printf(":source ip:port:destination ip:port:\n");
+ for (i=0;i<list->tickles.num;i++) {
+ if (port && port != ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)) {
+ continue;
+ }
+ printf(":%s:%u", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port));
+ printf(":%s:%u:\n", ctdb_addr_to_str(&list->tickles.connections[i].dst_addr), ntohs(list->tickles.connections[i].dst_addr.ip.sin_port));
+ }
+ } else {
+ printf("Tickles for ip:%s\n", ctdb_addr_to_str(&list->addr));
+ printf("Num tickles:%u\n", list->tickles.num);
+ for (i=0;i<list->tickles.num;i++) {
+ if (port && port != ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)) {
+ continue;
+ }
+ printf("SRC: %s:%u ", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port));
+ printf("DST: %s:%u\n", ctdb_addr_to_str(&list->tickles.connections[i].dst_addr), ntohs(list->tickles.connections[i].dst_addr.ip.sin_port));
+ }
}
talloc_free(list);
}
-
static int move_ip(struct ctdb_context *ctdb, ctdb_sock_addr *addr, uint32_t pnn)
{
struct ctdb_all_public_ips *ips;
disable_time = 30;
data.dptr = (uint8_t*)&disable_time;
data.dsize = sizeof(disable_time);
- ret = ctdb_send_message(ctdb, CTDB_BROADCAST_CONNECTED, CTDB_SRVID_DISABLE_IP_CHECK, data);
+ ret = ctdb_client_send_message(ctdb, CTDB_BROADCAST_CONNECTED, CTDB_SRVID_DISABLE_IP_CHECK, data);
if (ret != 0) {
DEBUG(DEBUG_ERR,("Failed to send message to disable ipcheck\n"));
return -1;
nodes = list_of_active_nodes_except_pnn(ctdb, nodemap, tmp_ctx, pnn);
ret = ctdb_client_async_control(ctdb, CTDB_CONTROL_RELEASE_IP,
nodes, 0,
- TIMELIMIT(),
+ LONGTIMELIMIT(),
false, data,
NULL, NULL,
NULL);
return -1;
}
- ret = ctdb_ctrl_takeover_ip(ctdb, TIMELIMIT(), pnn, &ip);
+ ret = ctdb_ctrl_takeover_ip(ctdb, LONGTIMELIMIT(), pnn, &ip);
if (ret != 0) {
DEBUG(DEBUG_ERR,("Failed to take over IP on node %d\n", pnn));
talloc_free(tmp_ctx);
return -1;
}
+ /* update the recovery daemon so it now knows to expect the new
+ node assignment for this ip.
+ */
+ ret = ctdb_client_send_message(ctdb, CTDB_BROADCAST_CONNECTED, CTDB_SRVID_RECD_UPDATE_IP, data);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Failed to send message to update the ip on the recovery master.\n"));
+ return -1;
+ }
+
talloc_free(tmp_ctx);
return 0;
}
DEBUG(DEBUG_ERR, ("Unable to register server_id from node %u\n", options.pnn));
return ret;
}
+ DEBUG(DEBUG_ERR,("Srvid registered. Sleeping for 999 seconds\n"));
+ sleep(999);
return -1;
}
}
if (options.machinereadable){
- printf(":Public IP:Node:\n");
+ printf(":Public IP:Node:");
+ if (options.verbose){
+ printf("ActiveInterface:AvailableInterfaces:ConfiguredInterfaces:");
+ }
+ printf("\n");
} else {
if (options.pnn == CTDB_BROADCAST_ALL) {
printf("Public IPs on ALL nodes\n");
}
for (i=1;i<=ips->num;i++) {
+ struct ctdb_control_public_ip_info *info = NULL;
+ int32_t pnn;
+ char *aciface = NULL;
+ char *avifaces = NULL;
+ char *cifaces = NULL;
+
+ if (options.pnn == CTDB_BROADCAST_ALL) {
+ pnn = ips->ips[ips->num-i].pnn;
+ } else {
+ pnn = options.pnn;
+ }
+
+ if (pnn != -1) {
+ ret = ctdb_ctrl_get_public_ip_info(ctdb, TIMELIMIT(), pnn, ctdb,
+ &ips->ips[ips->num-i].addr, &info);
+ } else {
+ ret = -1;
+ }
+
+ if (ret == 0) {
+ int j;
+ for (j=0; j < info->num; j++) {
+ if (cifaces == NULL) {
+ cifaces = talloc_strdup(info,
+ info->ifaces[j].name);
+ } else {
+ cifaces = talloc_asprintf_append(cifaces,
+ ",%s",
+ info->ifaces[j].name);
+ }
+
+ if (info->active_idx == j) {
+ aciface = info->ifaces[j].name;
+ }
+
+ if (info->ifaces[j].link_state == 0) {
+ continue;
+ }
+
+ if (avifaces == NULL) {
+ avifaces = talloc_strdup(info, info->ifaces[j].name);
+ } else {
+ avifaces = talloc_asprintf_append(avifaces,
+ ",%s",
+ info->ifaces[j].name);
+ }
+ }
+ }
+
if (options.machinereadable){
- printf(":%s:%d:\n", ctdb_addr_to_str(&ips->ips[ips->num-i].addr), ips->ips[ips->num-i].pnn);
+ printf(":%s:%d:",
+ ctdb_addr_to_str(&ips->ips[ips->num-i].addr),
+ ips->ips[ips->num-i].pnn);
+ if (options.verbose){
+ printf("%s:%s:%s:",
+ aciface?aciface:"",
+ avifaces?avifaces:"",
+ cifaces?cifaces:"");
+ }
+ printf("\n");
} else {
- printf("%s %d\n", ctdb_addr_to_str(&ips->ips[ips->num-i].addr), ips->ips[ips->num-i].pnn);
+ if (options.verbose) {
+ printf("%s node[%d] active[%s] available[%s] configured[%s]\n",
+ ctdb_addr_to_str(&ips->ips[ips->num-i].addr),
+ ips->ips[ips->num-i].pnn,
+ aciface?aciface:"",
+ avifaces?avifaces:"",
+ cifaces?cifaces:"");
+ } else {
+ printf("%s %d\n",
+ ctdb_addr_to_str(&ips->ips[ips->num-i].addr),
+ ips->ips[ips->num-i].pnn);
+ }
}
+ talloc_free(info);
}
talloc_free(tmp_ctx);
}
/*
- display pid of a ctdb daemon
+ public ip info
*/
-static int control_getpid(struct ctdb_context *ctdb, int argc, const char **argv)
+static int control_ipinfo(struct ctdb_context *ctdb, int argc, const char **argv)
{
- uint32_t pid;
- int ret;
+ int i, ret;
+ ctdb_sock_addr addr;
+ TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+ struct ctdb_control_public_ip_info *info;
- ret = ctdb_ctrl_getpid(ctdb, TIMELIMIT(), options.pnn, &pid);
+ if (argc != 1) {
+ talloc_free(tmp_ctx);
+ usage();
+ }
+
+ if (parse_ip(argv[0], NULL, 0, &addr) == 0) {
+ DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
+ return -1;
+ }
+
+ /* read the public ip info from this node */
+ ret = ctdb_ctrl_get_public_ip_info(ctdb, TIMELIMIT(), options.pnn,
+ tmp_ctx, &addr, &info);
if (ret != 0) {
- DEBUG(DEBUG_ERR, ("Unable to get daemon pid from node %u\n", options.pnn));
+ DEBUG(DEBUG_ERR, ("Unable to get public ip[%s]info from node %u\n",
+ argv[0], options.pnn));
+ talloc_free(tmp_ctx);
return ret;
}
- printf("Pid:%d\n", pid);
- return 0;
-}
+ printf("Public IP[%s] info on node %u\n",
+ ctdb_addr_to_str(&info->ip.addr),
+ options.pnn);
-/*
- handler for receiving the response to ipreallocate
-*/
-static void ip_reallocate_handler(struct ctdb_context *ctdb, uint64_t srvid,
- TDB_DATA data, void *private_data)
-{
- exit(0);
-}
+ printf("IP:%s\nCurrentNode:%d\nNumInterfaces:%u\n",
+ ctdb_addr_to_str(&info->ip.addr),
+ info->ip.pnn, info->num);
-static void ctdb_every_second(struct event_context *ev, struct timed_event *te, struct timeval t, void *p)
-{
- struct ctdb_context *ctdb = talloc_get_type(p, struct ctdb_context);
+ for (i=0; i<info->num; i++) {
+ info->ifaces[i].name[CTDB_IFACE_SIZE] = '\0';
- event_add_timed(ctdb->ev, ctdb,
- timeval_current_ofs(1, 0),
- ctdb_every_second, ctdb);
+ printf("Interface[%u]: Name:%s Link:%s References:%u%s\n",
+ i+1, info->ifaces[i].name,
+ info->ifaces[i].link_state?"up":"down",
+ (unsigned int)info->ifaces[i].references,
+ (i==info->active_idx)?" (active)":"");
+ }
+
+ talloc_free(tmp_ctx);
+ return 0;
}
/*
- ask the recovery daemon on the recovery master to perform a ip reallocation
+ display interfaces status
*/
-static int control_ipreallocate(struct ctdb_context *ctdb, int argc, const char **argv)
+static int control_ifaces(struct ctdb_context *ctdb, int argc, const char **argv)
{
int i, ret;
- TDB_DATA data;
- struct takeover_run_reply rd;
- uint32_t recmaster;
- struct ctdb_node_map *nodemap=NULL;
- int retries=0;
- struct timeval tv = timeval_current();
+ TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+ struct ctdb_control_get_ifaces *ifaces;
- /* we need some events to trigger so we can timeout and restart
- the loop
- */
- event_add_timed(ctdb->ev, ctdb,
- timeval_current_ofs(1, 0),
- ctdb_every_second, ctdb);
+ /* read the public ip list from this node */
+ ret = ctdb_ctrl_get_ifaces(ctdb, TIMELIMIT(), options.pnn,
+ tmp_ctx, &ifaces);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get interfaces from node %u\n",
+ options.pnn));
+ talloc_free(tmp_ctx);
+ return ret;
+ }
- rd.pnn = ctdb_ctrl_getpnn(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE);
- if (rd.pnn == -1) {
- DEBUG(DEBUG_ERR, ("Failed to get pnn of local node\n"));
- return -1;
+ if (options.machinereadable){
+ printf(":Name:LinkStatus:References:\n");
+ } else {
+ printf("Interfaces on node %u\n", options.pnn);
}
- rd.srvid = getpid();
+
+ for (i=0; i<ifaces->num; i++) {
+ if (options.machinereadable){
+ printf(":%s:%s:%u\n",
+ ifaces->ifaces[i].name,
+ ifaces->ifaces[i].link_state?"1":"0",
+ (unsigned int)ifaces->ifaces[i].references);
+ } else {
+ printf("name:%s link:%s references:%u\n",
+ ifaces->ifaces[i].name,
+ ifaces->ifaces[i].link_state?"up":"down",
+ (unsigned int)ifaces->ifaces[i].references);
+ }
+ }
+
+ talloc_free(tmp_ctx);
+ return 0;
+}
+
+
+/*
+ set link status of an interface
+ */
+static int control_setifacelink(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ int ret;
+ TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+ struct ctdb_control_iface_info info;
+
+ ZERO_STRUCT(info);
+
+ if (argc != 2) {
+ usage();
+ }
+
+ if (strlen(argv[0]) > CTDB_IFACE_SIZE) {
+ DEBUG(DEBUG_ERR, ("interfaces name '%s' too long\n",
+ argv[0]));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+ strcpy(info.name, argv[0]);
+
+ if (strcmp(argv[1], "up") == 0) {
+ info.link_state = 1;
+ } else if (strcmp(argv[1], "down") == 0) {
+ info.link_state = 0;
+ } else {
+ DEBUG(DEBUG_ERR, ("link state invalid '%s' should be 'up' or 'down'\n",
+ argv[1]));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ /* read the public ip list from this node */
+ ret = ctdb_ctrl_set_iface_link(ctdb, TIMELIMIT(), options.pnn,
+ tmp_ctx, &info);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to set link state for interfaces %s node %u\n",
+ argv[0], options.pnn));
+ talloc_free(tmp_ctx);
+ return ret;
+ }
+
+ talloc_free(tmp_ctx);
+ return 0;
+}
+
+/*
+ display pid of a ctdb daemon
+ */
+static int control_getpid(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ uint32_t pid;
+ int ret;
+
+ ret = ctdb_ctrl_getpid(ctdb, TIMELIMIT(), options.pnn, &pid);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get daemon pid from node %u\n", options.pnn));
+ return ret;
+ }
+ printf("Pid:%d\n", pid);
+
+ return 0;
+}
+
+static uint32_t ipreallocate_finished;
+
+/*
+ handler for receiving the response to ipreallocate
+*/
+static void ip_reallocate_handler(struct ctdb_context *ctdb, uint64_t srvid,
+ TDB_DATA data, void *private_data)
+{
+ ipreallocate_finished = 1;
+}
+
+static void ctdb_every_second(struct event_context *ev, struct timed_event *te, struct timeval t, void *p)
+{
+ struct ctdb_context *ctdb = talloc_get_type(p, struct ctdb_context);
+
+ event_add_timed(ctdb->ev, ctdb,
+ timeval_current_ofs(1, 0),
+ ctdb_every_second, ctdb);
+}
+
+/*
+ ask the recovery daemon on the recovery master to perform a ip reallocation
+ */
+static int control_ipreallocate(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ int i, ret;
+ TDB_DATA data;
+ struct takeover_run_reply rd;
+ uint32_t recmaster;
+ struct ctdb_node_map *nodemap=NULL;
+ int retries=0;
+ struct timeval tv = timeval_current();
+
+ /* we need some events to trigger so we can timeout and restart
+ the loop
+ */
+ event_add_timed(ctdb->ev, ctdb,
+ timeval_current_ofs(1, 0),
+ ctdb_every_second, ctdb);
+
+ rd.pnn = ctdb_ctrl_getpnn(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE);
+ if (rd.pnn == -1) {
+ DEBUG(DEBUG_ERR, ("Failed to get pnn of local node\n"));
+ return -1;
+ }
+ rd.srvid = getpid();
/* register a message port for receiveing the reply so that we
can receive the reply
*/
- ctdb_set_message_handler(ctdb, rd.srvid, ip_reallocate_handler, NULL);
+ ctdb_client_set_message_handler(ctdb, rd.srvid, ip_reallocate_handler, NULL);
data.dptr = (uint8_t *)&rd;
data.dsize = sizeof(rd);
again:
- if (retries>5) {
- DEBUG(DEBUG_ERR,("Failed waiting for cluster convergense\n"));
- exit(10);
- }
-
/* check that there are valid nodes available */
if (ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), options.pnn, ctdb, &nodemap) != 0) {
DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node\n"));
- exit(10);
+ return -1;
}
for (i=0; i<nodemap->num;i++) {
if ((nodemap->nodes[i].flags & (NODE_FLAGS_DELETED|NODE_FLAGS_BANNED|NODE_FLAGS_STOPPED)) == 0) {
/* verify the node exists */
if (ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), recmaster, ctdb, &nodemap) != 0) {
DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node\n"));
- exit(10);
+ return -1;
}
goto again;
}
- ret = ctdb_send_message(ctdb, recmaster, CTDB_SRVID_TAKEOVER_RUN, data);
+ ipreallocate_finished = 0;
+ ret = ctdb_client_send_message(ctdb, recmaster, CTDB_SRVID_TAKEOVER_RUN, data);
if (ret != 0) {
DEBUG(DEBUG_ERR,("Failed to send ip takeover run request message to %u\n", options.pnn));
return -1;
tv = timeval_current();
/* this loop will terminate when we have received the reply */
- while (timeval_elapsed(&tv) < 3.0) {
+ while (timeval_elapsed(&tv) < 3.0) {
event_loop_once(ctdb->ev);
}
+ if (ipreallocate_finished == 1) {
+ return 0;
+ }
- DEBUG(DEBUG_INFO,("Timed out waiting for recmaster ipreallocate. Trying again\n"));
+ DEBUG(DEBUG_ERR,("Timed out waiting for recmaster ipreallocate. Trying again\n"));
retries++;
sleep(1);
goto again;
int ret;
struct ctdb_node_map *nodemap=NULL;
+ /* check if the node is already disabled */
+ if (ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, ctdb, &nodemap) != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node\n"));
+ exit(10);
+ }
+ if (nodemap->nodes[options.pnn].flags & NODE_FLAGS_PERMANENTLY_DISABLED) {
+ DEBUG(DEBUG_ERR,("Node %d is already disabled.\n", options.pnn));
+ return 0;
+ }
+
do {
ret = ctdb_ctrl_modflags(ctdb, TIMELIMIT(), options.pnn, NODE_FLAGS_PERMANENTLY_DISABLED, 0);
if (ret != 0) {
struct ctdb_node_map *nodemap=NULL;
+
+ /* check if the node is already enabled */
+ if (ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, ctdb, &nodemap) != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node\n"));
+ exit(10);
+ }
+ if (!(nodemap->nodes[options.pnn].flags & NODE_FLAGS_PERMANENTLY_DISABLED)) {
+ DEBUG(DEBUG_ERR,("Node %d is already enabled.\n", options.pnn));
+ return 0;
+ }
+
do {
ret = ctdb_ctrl_modflags(ctdb, TIMELIMIT(), options.pnn, 0, NODE_FLAGS_PERMANENTLY_DISABLED);
if (ret != 0) {
}
} while (nodemap->nodes[options.pnn].flags & NODE_FLAGS_PERMANENTLY_DISABLED);
+
ret = control_ipreallocate(ctdb, argc, argv);
if (ret != 0) {
DEBUG(DEBUG_ERR, ("IP Reallocate failed on node %u\n", options.pnn));
const char *db_name;
struct ctdb_db_context *ctdb_db;
int ret;
+ bool persistent;
if (argc < 1) {
usage();
db_name = argv[0];
- if (db_exists(ctdb, db_name)) {
+ if (db_exists(ctdb, db_name, &persistent)) {
DEBUG(DEBUG_ERR,("Database '%s' does not exist\n", db_name));
return -1;
}
- ctdb_db = ctdb_attach(ctdb, db_name, false, 0);
+ ctdb_db = ctdb_attach(ctdb, db_name, persistent, 0);
if (ctdb_db == NULL) {
DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
ret = ctdb_dump_db(ctdb_db, stdout);
if (ret == -1) {
DEBUG(DEBUG_ERR, ("Unable to dump database\n"));
+ DEBUG(DEBUG_ERR, ("Maybe try 'ctdb getdbstatus %s'"
+ " and 'ctdb getvar AllowUnhealthyDBRead'\n",
+ db_name));
return -1;
}
talloc_free(ctdb_db);
}
+/*
+ fetch a record from a persistent database
+ */
+static int control_pfetch(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ const char *db_name;
+ struct ctdb_db_context *ctdb_db;
+ TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+ struct ctdb_transaction_handle *h;
+ TDB_DATA key, data;
+ int fd, ret;
+
+ if (argc < 2) {
+ talloc_free(tmp_ctx);
+ usage();
+ }
+
+ db_name = argv[0];
+
+
+ if (db_exists(ctdb, db_name, NULL)) {
+ DEBUG(DEBUG_ERR,("Database '%s' does not exist\n", db_name));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ ctdb_db = ctdb_attach(ctdb, db_name, true, 0);
+
+ if (ctdb_db == NULL) {
+ DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ h = ctdb_transaction_start(ctdb_db, tmp_ctx);
+ if (h == NULL) {
+ DEBUG(DEBUG_ERR,("Failed to start transaction on database %s\n", db_name));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ key.dptr = discard_const(argv[1]);
+ key.dsize = strlen(argv[1]);
+ ret = ctdb_transaction_fetch(h, tmp_ctx, key, &data);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Failed to fetch record\n"));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ if (data.dsize == 0 || data.dptr == NULL) {
+ DEBUG(DEBUG_ERR,("Record is empty\n"));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ if (argc == 3) {
+ fd = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0600);
+ if (fd == -1) {
+ DEBUG(DEBUG_ERR,("Failed to open output file %s\n", argv[2]));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+ write(fd, data.dptr, data.dsize);
+ close(fd);
+ } else {
+ write(1, data.dptr, data.dsize);
+ }
+
+ /* abort the transaction */
+ talloc_free(h);
+
+
+ talloc_free(tmp_ctx);
+ return 0;
+}
+
+/*
+ fetch a record from a tdb-file
+ */
+static int control_tfetch(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ const char *tdb_file;
+ TDB_CONTEXT *tdb;
+ TDB_DATA key, data;
+ int fd;
+
+ if (argc < 2) {
+ usage();
+ }
+
+ tdb_file = argv[0];
+
+ tdb = tdb_open(tdb_file, 0, 0, O_RDONLY, 0);
+ if (tdb == NULL) {
+ DEBUG(DEBUG_ERR,("Failed to open TDB file %s\n", tdb_file));
+ return -1;
+ }
+
+ key.dptr = discard_const(argv[1]);
+ key.dsize = strlen(argv[1]);
+ data = tdb_fetch(tdb, key);
+ if (data.dptr == NULL || data.dsize < sizeof(struct ctdb_ltdb_header)) {
+ DEBUG(DEBUG_ERR,("Failed to read record %s from tdb %s\n", argv[1], tdb_file));
+ tdb_close(tdb);
+ return -1;
+ }
+
+ tdb_close(tdb);
+
+ if (argc == 3) {
+ fd = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0600);
+ if (fd == -1) {
+ DEBUG(DEBUG_ERR,("Failed to open output file %s\n", argv[2]));
+ return -1;
+ }
+ write(fd, data.dptr+sizeof(struct ctdb_ltdb_header), data.dsize-sizeof(struct ctdb_ltdb_header));
+ close(fd);
+ } else {
+ write(1, data.dptr+sizeof(struct ctdb_ltdb_header), data.dsize-sizeof(struct ctdb_ltdb_header));
+ }
+
+ return 0;
+}
+
+/*
+ write a record to a persistent database
+ */
+static int control_pstore(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ const char *db_name;
+ struct ctdb_db_context *ctdb_db;
+ TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+ struct ctdb_transaction_handle *h;
+ struct stat st;
+ TDB_DATA key, data;
+ int fd, ret;
+
+ if (argc < 3) {
+ talloc_free(tmp_ctx);
+ usage();
+ }
+
+ fd = open(argv[2], O_RDONLY);
+ if (fd == -1) {
+ DEBUG(DEBUG_ERR,("Failed to open file containing record data : %s %s\n", argv[2], strerror(errno)));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ ret = fstat(fd, &st);
+ if (ret == -1) {
+ DEBUG(DEBUG_ERR,("fstat of file %s failed: %s\n", argv[2], strerror(errno)));
+ close(fd);
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ if (!S_ISREG(st.st_mode)) {
+ DEBUG(DEBUG_ERR,("Not a regular file %s\n", argv[2]));
+ close(fd);
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ data.dsize = st.st_size;
+ if (data.dsize == 0) {
+ data.dptr = NULL;
+ } else {
+ data.dptr = talloc_size(tmp_ctx, data.dsize);
+ if (data.dptr == NULL) {
+ DEBUG(DEBUG_ERR,("Failed to talloc %d of memory to store record data\n", (int)data.dsize));
+ close(fd);
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+ ret = read(fd, data.dptr, data.dsize);
+ if (ret != data.dsize) {
+ DEBUG(DEBUG_ERR,("Failed to read %d bytes of record data\n", (int)data.dsize));
+ close(fd);
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+ }
+ close(fd);
+
+
+ db_name = argv[0];
+
+ ctdb_db = ctdb_attach(ctdb, db_name, true, 0);
+
+ if (ctdb_db == NULL) {
+ DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ h = ctdb_transaction_start(ctdb_db, tmp_ctx);
+ if (h == NULL) {
+ DEBUG(DEBUG_ERR,("Failed to start transaction on database %s\n", db_name));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ key.dptr = discard_const(argv[1]);
+ key.dsize = strlen(argv[1]);
+ ret = ctdb_transaction_store(h, key, data);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Failed to store record\n"));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ ret = ctdb_transaction_commit(h);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Failed to commit transaction\n"));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+
+ talloc_free(tmp_ctx);
+ return 0;
+}
+
static void log_handler(struct ctdb_context *ctdb, uint64_t srvid,
TDB_DATA data, void *private_data)
{
DEBUG(DEBUG_ERR, ("Pulling logs from node %u\n", options.pnn));
- ctdb_set_message_handler(ctdb, log_addr.srvid, log_handler, NULL);
+ ctdb_client_set_message_handler(ctdb, log_addr.srvid, log_handler, NULL);
sleep(1);
DEBUG(DEBUG_ERR,("Listen for response on %d\n", (int)log_addr.srvid));
char *errmsg;
TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
- ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_CLEAR_LOG,
- 0, tdb_null, tmp_ctx, NULL, &res, NULL, &errmsg);
- if (ret != 0 || res != 0) {
- DEBUG(DEBUG_ERR,("Failed to clear logs\n"));
- talloc_free(tmp_ctx);
- return -1;
+ ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_CLEAR_LOG,
+ 0, tdb_null, tmp_ctx, NULL, &res, NULL, &errmsg);
+ if (ret != 0 || res != 0) {
+ DEBUG(DEBUG_ERR,("Failed to clear logs\n"));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ talloc_free(tmp_ctx);
+ return 0;
+}
+
+
+
+/*
+ display a list of the databases on a remote ctdb
+ */
+static int control_getdbmap(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ int i, ret;
+ struct ctdb_dbid_map *dbmap=NULL;
+
+ ret = ctdb_ctrl_getdbmap(ctdb, TIMELIMIT(), options.pnn, ctdb, &dbmap);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get dbids from node %u\n", options.pnn));
+ return ret;
+ }
+
+ if(options.machinereadable){
+ printf(":ID:Name:Path:Persistent:Unhealthy:\n");
+ for(i=0;i<dbmap->num;i++){
+ const char *path;
+ const char *name;
+ const char *health;
+ bool persistent;
+
+ ctdb_ctrl_getdbpath(ctdb, TIMELIMIT(), options.pnn,
+ dbmap->dbs[i].dbid, ctdb, &path);
+ ctdb_ctrl_getdbname(ctdb, TIMELIMIT(), options.pnn,
+ dbmap->dbs[i].dbid, ctdb, &name);
+ ctdb_ctrl_getdbhealth(ctdb, TIMELIMIT(), options.pnn,
+ dbmap->dbs[i].dbid, ctdb, &health);
+ persistent = dbmap->dbs[i].persistent;
+ printf(":0x%08X:%s:%s:%d:%d:\n",
+ dbmap->dbs[i].dbid, name, path,
+ !!(persistent), !!(health));
+ }
+ return 0;
+ }
+
+ printf("Number of databases:%d\n", dbmap->num);
+ for(i=0;i<dbmap->num;i++){
+ const char *path;
+ const char *name;
+ const char *health;
+ bool persistent;
+
+ ctdb_ctrl_getdbpath(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &path);
+ ctdb_ctrl_getdbname(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &name);
+ ctdb_ctrl_getdbhealth(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &health);
+ persistent = dbmap->dbs[i].persistent;
+ printf("dbid:0x%08x name:%s path:%s%s%s\n",
+ dbmap->dbs[i].dbid, name, path,
+ persistent?" PERSISTENT":"",
+ health?" UNHEALTHY":"");
}
- talloc_free(tmp_ctx);
return 0;
}
-
-
/*
- display a list of the databases on a remote ctdb
+ display the status of a database on a remote ctdb
*/
-static int control_getdbmap(struct ctdb_context *ctdb, int argc, const char **argv)
+static int control_getdbstatus(struct ctdb_context *ctdb, int argc, const char **argv)
{
int i, ret;
struct ctdb_dbid_map *dbmap=NULL;
+ const char *db_name;
+
+ if (argc < 1) {
+ usage();
+ }
+
+ db_name = argv[0];
ret = ctdb_ctrl_getdbmap(ctdb, TIMELIMIT(), options.pnn, ctdb, &dbmap);
if (ret != 0) {
return ret;
}
- printf("Number of databases:%d\n", dbmap->num);
for(i=0;i<dbmap->num;i++){
const char *path;
const char *name;
+ const char *health;
bool persistent;
- ctdb_ctrl_getdbpath(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &path);
ctdb_ctrl_getdbname(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &name);
+ if (strcmp(name, db_name) != 0) {
+ continue;
+ }
+
+ ctdb_ctrl_getdbpath(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &path);
+ ctdb_ctrl_getdbhealth(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &health);
persistent = dbmap->dbs[i].persistent;
- printf("dbid:0x%08x name:%s path:%s %s\n", dbmap->dbs[i].dbid, name,
- path, persistent?"PERSISTENT":"");
+ printf("dbid: 0x%08x\nname: %s\npath: %s\nPERSISTENT: %s\nHEALTH: %s\n",
+ dbmap->dbs[i].dbid, name, path,
+ persistent?"yes":"no",
+ health?health:"OK");
+ return 0;
}
+ DEBUG(DEBUG_ERR, ("db %s doesn't exist on node %u\n", db_name, options.pnn));
return 0;
}
}
-/*
- freeze a node
- */
-static int control_freeze(struct ctdb_context *ctdb, int argc, const char **argv)
-{
- int ret;
- uint32_t priority;
-
- if (argc == 1) {
- priority = strtol(argv[0], NULL, 0);
- } else {
- priority = 0;
- }
- DEBUG(DEBUG_ERR,("Freeze by priority %u\n", priority));
-
- ret = ctdb_ctrl_freeze_priority(ctdb, TIMELIMIT(), options.pnn, priority);
- if (ret != 0) {
- DEBUG(DEBUG_ERR, ("Unable to freeze node %u\n", options.pnn));
- }
- return 0;
-}
-
/*
thaw a node
*/
{
const char *db_name;
struct ctdb_db_context *ctdb_db;
+ bool persistent = false;
if (argc < 1) {
usage();
}
db_name = argv[0];
+ if (argc > 2) {
+ usage();
+ }
+ if (argc == 2) {
+ if (strcmp(argv[1], "persistent") != 0) {
+ usage();
+ }
+ persistent = true;
+ }
- ctdb_db = ctdb_attach(ctdb, db_name, false, 0);
+ ctdb_db = ctdb_attach(ctdb, db_name, persistent, 0);
if (ctdb_db == NULL) {
DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
return -1;
struct backup_data *bd;
int fh = -1;
int status = -1;
+ const char *reason = NULL;
if (argc != 2) {
DEBUG(DEBUG_ERR,("Invalid arguments\n"));
return -1;
}
+ ret = ctdb_ctrl_getdbhealth(ctdb, TIMELIMIT(), options.pnn,
+ dbmap->dbs[i].dbid, tmp_ctx, &reason);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Unable to get dbhealth for database '%s'\n",
+ argv[0]));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+ if (reason) {
+ uint32_t allow_unhealthy = 0;
+
+ ctdb_ctrl_get_tunable(ctdb, TIMELIMIT(), options.pnn,
+ "AllowUnhealthyDBRead",
+ &allow_unhealthy);
+
+ if (allow_unhealthy != 1) {
+ DEBUG(DEBUG_ERR,("database '%s' is unhealthy: %s\n",
+ argv[0], reason));
+
+ DEBUG(DEBUG_ERR,("disallow backup : tunnable AllowUnhealthyDBRead = %u\n",
+ allow_unhealthy));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ DEBUG(DEBUG_WARNING,("WARNING database '%s' is unhealthy - see 'ctdb getdbstatus %s'\n",
+ argv[0], argv[0]));
+ DEBUG(DEBUG_WARNING,("WARNING! allow backup of unhealthy database: "
+ "tunnable AllowUnhealthyDBRead = %u\n",
+ allow_unhealthy));
+ }
ctdb_db = ctdb_attach(ctdb, argv[0], dbmap->dbs[i].persistent, 0);
if (ctdb_db == NULL) {
uint32_t generation;
struct tm *tm;
char tbuf[100];
+ char *dbname;
- if (argc != 1) {
+ if (argc < 1 || argc > 2) {
DEBUG(DEBUG_ERR,("Invalid arguments\n"));
return -1;
}
return -1;
}
+ dbname = discard_const(dbhdr.name);
+ if (argc == 2) {
+ dbname = discard_const(argv[1]);
+ }
+
outdata.dsize = dbhdr.size;
outdata.dptr = talloc_size(tmp_ctx, outdata.dsize);
if (outdata.dptr == NULL) {
tm = localtime(&dbhdr.timestamp);
strftime(tbuf,sizeof(tbuf)-1,"%Y/%m/%d %H:%M:%S", tm);
printf("Restoring database '%s' from backup @ %s\n",
- dbhdr.name, tbuf);
+ dbname, tbuf);
- ctdb_db = ctdb_attach(ctdb, dbhdr.name, dbhdr.persistent, 0);
+ ctdb_db = ctdb_attach(ctdb, dbname, dbhdr.persistent, 0);
if (ctdb_db == NULL) {
- DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", dbhdr.name));
+ DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", dbname));
talloc_free(tmp_ctx);
return -1;
}
return -1;
}
+ data.dptr = (void *)&ctdb_db->db_id;
+ data.dsize = sizeof(ctdb_db->db_id);
+
+ /* mark the database as healthy */
+ nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
+ if (ctdb_client_async_control(ctdb, CTDB_CONTROL_DB_SET_HEALTHY,
+ nodes, 0,
+ TIMELIMIT(), false, data,
+ NULL, NULL,
+ NULL) != 0) {
+ DEBUG(DEBUG_ERR, ("Failed to mark database as healthy.\n"));
+ ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
data.dptr = (void *)&generation;
data.dsize = sizeof(generation);
return 0;
}
+/*
+ * dump a database backup from a file
+ */
+static int control_dumpdbbackup(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
+ TDB_DATA outdata;
+ struct db_file_header dbhdr;
+ int i, fh;
+ struct tm *tm;
+ char tbuf[100];
+ struct ctdb_rec_data *rec = NULL;
+ struct ctdb_marshall_buffer *m;
+
+ if (argc != 1) {
+ DEBUG(DEBUG_ERR,("Invalid arguments\n"));
+ return -1;
+ }
+
+ fh = open(argv[0], O_RDONLY);
+ if (fh == -1) {
+ DEBUG(DEBUG_ERR,("Failed to open file '%s'\n", argv[0]));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ read(fh, &dbhdr, sizeof(dbhdr));
+ if (dbhdr.version != DB_VERSION) {
+ DEBUG(DEBUG_ERR,("Invalid version of database dump. File is version %lu but expected version was %u\n", dbhdr.version, DB_VERSION));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ outdata.dsize = dbhdr.size;
+ outdata.dptr = talloc_size(tmp_ctx, outdata.dsize);
+ if (outdata.dptr == NULL) {
+ DEBUG(DEBUG_ERR,("Failed to allocate data of size '%lu'\n", dbhdr.size));
+ close(fh);
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+ read(fh, outdata.dptr, outdata.dsize);
+ close(fh);
+ m = (struct ctdb_marshall_buffer *)outdata.dptr;
+
+ tm = localtime(&dbhdr.timestamp);
+ strftime(tbuf,sizeof(tbuf)-1,"%Y/%m/%d %H:%M:%S", tm);
+ printf("Backup of database name:'%s' dbid:0x%x08x from @ %s\n",
+ dbhdr.name, m->db_id, tbuf);
+
+ for (i=0; i < m->count; i++) {
+ uint32_t reqid = 0;
+ TDB_DATA key, data;
+
+ /* we do not want the header splitted, so we pass NULL*/
+ rec = ctdb_marshall_loop_next(m, rec, &reqid,
+ NULL, &key, &data);
+
+ ctdb_dumpdb_record(ctdb, key, data, stdout);
+ }
+
+ printf("Dumped %d records\n", i);
+ talloc_free(tmp_ctx);
+ return 0;
+}
+
/*
* wipe a database from a file
*/
return -1;
}
+ data.dptr = (void *)&ctdb_db->db_id;
+ data.dsize = sizeof(ctdb_db->db_id);
+
+ /* mark the database as healthy */
+ nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
+ if (ctdb_client_async_control(ctdb, CTDB_CONTROL_DB_SET_HEALTHY,
+ nodes, 0,
+ TIMELIMIT(), false, data,
+ NULL, NULL,
+ NULL) != 0) {
+ DEBUG(DEBUG_ERR, ("Failed to mark database as healthy.\n"));
+ ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
data.dptr = (void *)&generation;
data.dsize = sizeof(generation);
return 0;
}
-/*
- * set flags of a node in the nodemap
- */
-static int control_setflags(struct ctdb_context *ctdb, int argc, const char **argv)
-{
- int ret;
- int32_t status;
- int node;
- int flags;
- TDB_DATA data;
- struct ctdb_node_flag_change c;
-
- if (argc != 2) {
- usage();
- return -1;
- }
-
- if (sscanf(argv[0], "%d", &node) != 1) {
- DEBUG(DEBUG_ERR, ("Badly formed node\n"));
- usage();
- return -1;
- }
- if (sscanf(argv[1], "0x%x", &flags) != 1) {
- DEBUG(DEBUG_ERR, ("Badly formed flags\n"));
- usage();
- return -1;
- }
-
- c.pnn = node;
- c.old_flags = 0;
- c.new_flags = flags;
-
- data.dsize = sizeof(c);
- data.dptr = (unsigned char *)&c;
-
- ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_MODIFY_FLAGS, 0,
- data, NULL, NULL, &status, NULL, NULL);
- if (ret != 0 || status != 0) {
- DEBUG(DEBUG_ERR,("Failed to modify flags\n"));
- return -1;
- }
- return 0;
-}
-
/*
dump memory usage
*/
/* register a message port for receiveing the reply so that we
can receive the reply
*/
- ctdb_set_message_handler(ctdb, rd.srvid, mem_dump_handler, NULL);
+ ctdb_client_set_message_handler(ctdb, rd.srvid, mem_dump_handler, NULL);
data.dptr = (uint8_t *)&rd;
data.dsize = sizeof(rd);
- ret = ctdb_send_message(ctdb, options.pnn, CTDB_SRVID_MEM_DUMP, data);
+ ret = ctdb_client_send_message(ctdb, options.pnn, CTDB_SRVID_MEM_DUMP, data);
if (ret != 0) {
DEBUG(DEBUG_ERR,("Failed to send memdump request message to %u\n", options.pnn));
return -1;
return 0;
}
+/*
+ send a message to a srvid
+ */
+static int control_msgsend(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ unsigned long srvid;
+ int ret;
+ TDB_DATA data;
+
+ if (argc < 2) {
+ usage();
+ }
+
+ srvid = strtoul(argv[0], NULL, 0);
+
+ data.dptr = (uint8_t *)discard_const(argv[1]);
+ data.dsize= strlen(argv[1]);
+
+ ret = ctdb_client_send_message(ctdb, CTDB_BROADCAST_CONNECTED, srvid, data);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Failed to send memdump request message to %u\n", options.pnn));
+ return -1;
+ }
+
+ return 0;
+}
+
+/*
+ handler for msglisten
+*/
+static void msglisten_handler(struct ctdb_context *ctdb, uint64_t srvid,
+ TDB_DATA data, void *private_data)
+{
+ int i;
+
+ printf("Message received: ");
+ for (i=0;i<data.dsize;i++) {
+ printf("%c", data.dptr[i]);
+ }
+ printf("\n");
+}
+
+/*
+ listen for messages on a messageport
+ */
+static int control_msglisten(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ uint64_t srvid;
+
+ srvid = getpid();
+
+ /* register a message port and listen for messages
+ */
+ ctdb_client_set_message_handler(ctdb, srvid, msglisten_handler, NULL);
+ printf("Listening for messages on srvid:%d\n", (int)srvid);
+
+ while (1) {
+ event_loop_once(ctdb->ev);
+ }
+
+ return 0;
+}
+
/*
list all nodes in the cluster
- if the daemon is running, we read the data from the daemon.
- if the daemon is not running we parse the nodes file directly
+ we parse the nodes file directly
*/
static int control_listnodes(struct ctdb_context *ctdb, int argc, const char **argv)
{
- int i, ret;
- struct ctdb_node_map *nodemap=NULL;
+ TALLOC_CTX *mem_ctx = talloc_new(NULL);
+ struct pnn_node *pnn_nodes;
+ struct pnn_node *pnn_node;
- if (ctdb != NULL) {
- ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), options.pnn, ctdb, &nodemap);
- if (ret != 0) {
- DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
- return ret;
- }
+ pnn_nodes = read_nodes_file(mem_ctx);
+ if (pnn_nodes == NULL) {
+ DEBUG(DEBUG_ERR,("Failed to read nodes file\n"));
+ talloc_free(mem_ctx);
+ return -1;
+ }
- for(i=0;i<nodemap->num;i++){
- if (nodemap->nodes[i].flags & NODE_FLAGS_DELETED) {
- continue;
- }
- if (options.machinereadable){
- printf(":%d:%s:\n", nodemap->nodes[i].pnn, ctdb_addr_to_str(&nodemap->nodes[i].addr));
- } else {
- printf("%s\n", ctdb_addr_to_str(&nodemap->nodes[i].addr));
- }
- }
- } else {
- TALLOC_CTX *mem_ctx = talloc_new(NULL);
- struct pnn_node *pnn_nodes;
- struct pnn_node *pnn_node;
-
- pnn_nodes = read_nodes_file(mem_ctx);
- if (pnn_nodes == NULL) {
- DEBUG(DEBUG_ERR,("Failed to read nodes file\n"));
+ for(pnn_node=pnn_nodes;pnn_node;pnn_node=pnn_node->next) {
+ ctdb_sock_addr addr;
+ if (parse_ip(pnn_node->addr, NULL, 63999, &addr) == 0) {
+ DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s' in nodes file\n", pnn_node->addr));
talloc_free(mem_ctx);
return -1;
}
-
- for(pnn_node=pnn_nodes;pnn_node;pnn_node=pnn_node->next) {
- ctdb_sock_addr addr;
-
- if (parse_ip(pnn_node->addr, NULL, 63999, &addr) == 0) {
- DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s' in nodes file\n", pnn_node->addr));
- talloc_free(mem_ctx);
- return -1;
- }
-
- if (options.machinereadable){
- printf(":%d:%s:\n", pnn_node->pnn, pnn_node->addr);
- } else {
- printf("%s\n", pnn_node->addr);
- }
+ if (options.machinereadable){
+ printf(":%d:%s:\n", pnn_node->pnn, pnn_node->addr);
+ } else {
+ printf("%s\n", pnn_node->addr);
}
- talloc_free(mem_ctx);
}
+ talloc_free(mem_ctx);
return 0;
}
{ "listvars", control_listvars, true, false, "list tunable variables"},
{ "statistics", control_statistics, false, false, "show statistics" },
{ "statisticsreset", control_statistics_reset, true, false, "reset statistics"},
+ { "stats", control_stats, false, false, "show rolling statistics", "[number of history records]" },
{ "ip", control_ip, false, false, "show which public ip's that ctdb manages" },
+ { "ipinfo", control_ipinfo, true, false, "show details about a public ip that ctdb manages", "<ip>" },
+ { "ifaces", control_ifaces, true, false, "show which interfaces that ctdb manages" },
+ { "setifacelink", control_setifacelink, true, false, "set interface link status", "<iface> <status>" },
{ "process-exists", control_process_exists, true, false, "check if a process exists on a node", "<pid>"},
{ "getdbmap", control_getdbmap, true, false, "show the database map" },
+ { "getdbstatus", control_getdbstatus, true, false, "show the status of a database", "<dbname>" },
{ "catdb", control_catdb, true, false, "dump a database" , "<dbname>"},
{ "getmonmode", control_getmonmode, true, false, "show monitoring mode" },
{ "getcapabilities", control_getcapabilities, true, false, "show node capabilities" },
{ "getdebug", control_getdebug, true, false, "get debug level" },
{ "getlog", control_getlog, true, false, "get the log data from the in memory ringbuffer", "<level>" },
{ "clearlog", control_clearlog, true, false, "clear the log data from the in memory ringbuffer" },
- { "attach", control_attach, true, false, "attach to a database", "<dbname>" },
+ { "attach", control_attach, true, false, "attach to a database", "<dbname> [persistent]" },
{ "dumpmemory", control_dumpmemory, true, false, "dump memory map to stdout" },
{ "rddumpmemory", control_rddumpmemory, true, false, "dump memory map from the recovery daemon to stdout" },
{ "getpid", control_getpid, true, false, "get ctdbd process ID" },
{ "showban", control_showban, true, false, "show ban information"},
{ "shutdown", control_shutdown, true, false, "shutdown ctdbd" },
{ "recover", control_recover, true, false, "force recovery" },
+ { "sync", control_ipreallocate, true, false, "wait until ctdbd has synced all state changes" },
{ "ipreallocate", control_ipreallocate, true, false, "force the recovery daemon to perform a ip reallocation procedure" },
- { "freeze", control_freeze, true, false, "freeze databases", "[priority:1-3]" },
{ "thaw", control_thaw, true, false, "thaw databases", "[priority:1-3]" },
{ "isnotrecmaster", control_isnotrecmaster, false, false, "check if the local node is recmaster or not" },
{ "killtcp", kill_tcp, false, false, "kill a tcp connection.", "<srcip:port> <dstip:port>" },
{ "gratiousarp", control_gratious_arp, false, false, "send a gratious arp", "<ip> <interface>" },
{ "tickle", tickle_tcp, false, false, "send a tcp tickle ack", "<srcip:port> <dstip:port>" },
- { "gettickles", control_get_tickles, false, false, "get the list of tickles registered for this ip", "<ip>" },
+ { "gettickles", control_get_tickles, false, false, "get the list of tickles registered for this ip", "<ip> [<port>]" },
+ { "addtickle", control_add_tickle, false, false, "add a tickle for this ip", "<ip>:<port> <ip>:<port>" },
+
+ { "deltickle", control_del_tickle, false, false, "delete a tickle from this ip", "<ip>:<port> <ip>:<port>" },
{ "regsrvid", regsrvid, false, false, "register a server id", "<pnn> <type> <id>" },
{ "unregsrvid", unregsrvid, false, false, "unregister a server id", "<pnn> <type> <id>" },
{ "delip", control_delip, false, false, "delete an ip address from a node", "<ip>"},
{ "eventscript", control_eventscript, true, false, "run the eventscript with the given parameters on a node", "<arguments>"},
{ "backupdb", control_backupdb, false, false, "backup the database into a file.", "<database> <file>"},
- { "restoredb", control_restoredb, false, false, "restore the database from a file.", "<file>"},
+ { "restoredb", control_restoredb, false, false, "restore the database from a file.", "<file> [dbname]"},
+ { "dumpdbbackup", control_dumpdbbackup, false, true, "dump database backup from a file.", "<file>"},
{ "wipedb", control_wipedb, false, false, "wipe the contents of a database.", "<dbname>"},
{ "recmaster", control_recmaster, false, false, "show the pnn for the recovery master."},
- { "setflags", control_setflags, false, false, "set flags for a node in the nodemap.", "<node> <flags>"},
- { "scriptstatus", control_scriptstatus, false, false, "show the status of the monitoring scripts"},
+ { "scriptstatus", control_scriptstatus, false, false, "show the status of the monitoring scripts (or all scripts)", "[all]"},
{ "enablescript", control_enablescript, false, false, "enable an eventscript", "<script>"},
{ "disablescript", control_disablescript, false, false, "disable an eventscript", "<script>"},
{ "natgwlist", control_natgwlist, false, false, "show the nodes belonging to this natgw configuration"},
{ "setrecmasterrole", control_setrecmasterrole, false, false, "Set RECMASTER role to on/off", "{on|off}"},
{ "setdbprio", control_setdbprio, false, false, "Set DB priority", "<dbid> <prio:1-3>"},
{ "getdbprio", control_getdbprio, false, false, "Get DB priority", "<dbid>"},
+ { "msglisten", control_msglisten, false, false, "Listen on a srvid port for messages", "<msg srvid>"},
+ { "msgsend", control_msgsend, false, false, "Send a message to srvid", "<srvid> <message>"},
+ { "sync", control_ipreallocate, false, false, "wait until ctdbd has synced all state changes" },
+ { "pfetch", control_pfetch, false, false, "fetch a record from a persistent database", "<db> <key> [<file>]" },
+ { "pstore", control_pstore, false, false, "write a record to a persistent database", "<db> <key> <file containing record>" },
+ { "tfetch", control_tfetch, false, true, "fetch a record from a [c]tdb-file", "<tdb-file> <key> [<file>]" },
};
/*
"Options:\n" \
" -n <node> choose node number, or 'all' (defaults to local node)\n"
" -Y generate machinereadable output\n"
+" -v generate verbose output\n"
" -t <timelimit> set timelimit for control in seconds (default %u)\n", options.timelimit);
printf("Controls:\n");
for (i=0;i<ARRAY_SIZE(ctdb_commands);i++) {
{ "timelimit", 't', POPT_ARG_INT, &options.timelimit, 0, "timelimit", "integer" },
{ "node", 'n', POPT_ARG_STRING, &nodestring, 0, "node", "integer|all" },
{ "machinereadable", 'Y', POPT_ARG_NONE, &options.machinereadable, 0, "enable machinereadable output", NULL },
+ { "verbose", 'v', POPT_ARG_NONE, &options.verbose, 0, "enable verbose output", NULL },
{ "maxruntime", 'T', POPT_ARG_INT, &options.maxruntime, 0, "die if runtime exceeds this limit (in seconds)", "integer" },
POPT_TABLEEND
};
control = extra_argv[0];
ev = event_context_init(NULL);
+ if (!ev) {
+ DEBUG(DEBUG_ERR, ("Failed to initialize event system\n"));
+ exit(1);
+ }
+ tevent_loop_allow_nesting(ev);
for (i=0;i<ARRAY_SIZE(ctdb_commands);i++) {
if (strcmp(control, ctdb_commands[i].name) == 0) {
ctdb = ctdb_cmdline_client(ev);
if (ctdb_commands[i].without_daemon == false) {
+ const char *socket_name;
+
if (ctdb == NULL) {
DEBUG(DEBUG_ERR, ("Failed to init ctdb\n"));
exit(1);
}
+ /* initialize a libctdb connection as well */
+ socket_name = ctdb_get_socketname(ctdb);
+ ctdb_connection = ctdb_connect(socket_name,
+ ctdb_log_file, stderr);
+ if (ctdb_connection == NULL) {
+ fprintf(stderr, "Failed to connect to daemon from libctdb\n");
+ exit(1);
+ }
+
/* verify the node exists */
verify_node(ctdb);
git.samba.org / metze / ctdb / wip.git / blobdiff