4 Copyright (C) Andrew Tridgell 2007
5 Copyright (C) Ronnie Sahlberg 2007
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, see <http://www.gnu.org/licenses/>.
22 #include "system/time.h"
23 #include "system/filesys.h"
24 #include "system/network.h"
25 #include "system/locale.h"
28 #include "../include/ctdb_version.h"
29 #include "../include/ctdb.h"
30 #include "../include/ctdb_client.h"
31 #include "../include/ctdb_private.h"
32 #include "../common/rb_tree.h"
35 #define ERR_TIMEOUT 20 /* timed out trying to reach node */
36 #define ERR_NONODE 21 /* node does not exist */
37 #define ERR_DISNODE 22 /* node is disconnected */
39 struct ctdb_connection *ctdb_connection;
41 static void usage(void);
50 int printemptyrecords;
57 #define TIMELIMIT() timeval_current_ofs(options.timelimit, 0)
58 #define LONGTIMELIMIT() timeval_current_ofs(options.timelimit*10, 0)
60 static int control_version(struct ctdb_context *ctdb, int argc, const char **argv)
62 printf("CTDB version: %s\n", CTDB_VERSION_STRING);
66 #define CTDB_NOMEM_ABORT(p) do { if (!(p)) { \
67 DEBUG(DEBUG_ALERT,("ctdb fatal error: %s\n", \
68 "Out of memory in " __location__ )); \
72 static uint32_t getpnn(struct ctdb_context *ctdb)
74 if ((options.pnn == CTDB_BROADCAST_ALL) ||
75 (options.pnn == CTDB_MULTICAST)) {
77 ("Cannot get PNN for node %u\n", options.pnn));
81 if (options.pnn == CTDB_CURRENT_NODE) {
82 return ctdb_get_pnn(ctdb);
88 static void assert_single_node_only(void)
90 if ((options.pnn == CTDB_BROADCAST_ALL) ||
91 (options.pnn == CTDB_MULTICAST)) {
93 ("This control can not be applied to multiple PNNs\n"));
98 /* Pretty print the flags to a static buffer in human-readable format.
99 * This never returns NULL!
101 static const char *pretty_print_flags(uint32_t flags)
104 static const struct {
108 { NODE_FLAGS_DISCONNECTED, "DISCONNECTED" },
109 { NODE_FLAGS_PERMANENTLY_DISABLED, "DISABLED" },
110 { NODE_FLAGS_BANNED, "BANNED" },
111 { NODE_FLAGS_UNHEALTHY, "UNHEALTHY" },
112 { NODE_FLAGS_DELETED, "DELETED" },
113 { NODE_FLAGS_STOPPED, "STOPPED" },
114 { NODE_FLAGS_INACTIVE, "INACTIVE" },
116 static char flags_str[512]; /* Big enough to contain all flag names */
119 for (j=0;j<ARRAY_SIZE(flag_names);j++) {
120 if (flags & flag_names[j].flag) {
121 if (flags_str[0] == '\0') {
122 (void) strcpy(flags_str, flag_names[j].name);
124 (void) strcat(flags_str, "|");
125 (void) strcat(flags_str, flag_names[j].name);
129 if (flags_str[0] == '\0') {
130 (void) strcpy(flags_str, "OK");
136 static int h2i(char h)
138 if (h >= 'a' && h <= 'f') return h - 'a' + 10;
139 if (h >= 'A' && h <= 'F') return h - 'f' + 10;
143 static TDB_DATA hextodata(TALLOC_CTX *mem_ctx, const char *str)
146 TDB_DATA key = {NULL, 0};
150 DEBUG(DEBUG_ERR,("Key specified with odd number of hexadecimal digits\n"));
155 key.dptr = talloc_size(mem_ctx, key.dsize);
157 for (i=0; i < len/2; i++) {
158 key.dptr[i] = h2i(str[i*2]) << 4 | h2i(str[i*2+1]);
163 /* Parse a nodestring. Parameter dd_ok controls what happens to nodes
164 * that are disconnected or deleted. If dd_ok is true those nodes are
165 * included in the output list of nodes. If dd_ok is false, those
166 * nodes are filtered from the "all" case and cause an error if
167 * explicitly specified.
169 static bool parse_nodestring(struct ctdb_context *ctdb,
170 const char * nodestring,
171 uint32_t current_pnn,
178 struct ctdb_node_map *nodemap;
183 if (!ctdb_getnodemap(ctdb_connection, CTDB_CURRENT_NODE, &nodemap)) {
184 DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node\n"));
188 if (nodestring != NULL) {
189 *nodes = talloc_array(ctdb, uint32_t, 0);
190 CTDB_NOMEM_ABORT(*nodes);
194 if (strcmp(nodestring, "all") == 0) {
195 *pnn_mode = CTDB_BROADCAST_ALL;
198 for (i = 0; i < nodemap->num; i++) {
199 if ((nodemap->nodes[i].flags &
200 (NODE_FLAGS_DISCONNECTED |
201 NODE_FLAGS_DELETED)) && !dd_ok) {
204 *nodes = talloc_realloc(ctdb, *nodes,
206 CTDB_NOMEM_ABORT(*nodes);
214 ns = talloc_strdup(ctdb, nodestring);
215 tok = strtok(ns, ",");
216 while (tok != NULL) {
218 i = (uint32_t)strtoul(tok, NULL, 0);
219 if (i >= nodemap->num) {
220 DEBUG(DEBUG_ERR, ("Node %u does not exist\n", i));
223 if ((nodemap->nodes[i].flags &
224 (NODE_FLAGS_DISCONNECTED |
225 NODE_FLAGS_DELETED)) && !dd_ok) {
226 DEBUG(DEBUG_ERR, ("Node %u has status %s\n", i, pretty_print_flags(nodemap->nodes[i].flags)));
229 if (!ctdb_getpnn(ctdb_connection, i, &pnn)) {
230 DEBUG(DEBUG_ERR, ("Can not access node %u. Node is not operational.\n", i));
234 *nodes = talloc_realloc(ctdb, *nodes,
236 CTDB_NOMEM_ABORT(*nodes);
241 tok = strtok(NULL, ",");
246 *pnn_mode = (*nodes)[0];
248 *pnn_mode = CTDB_MULTICAST;
252 /* default - no nodes specified */
253 *nodes = talloc_array(ctdb, uint32_t, 1);
254 CTDB_NOMEM_ABORT(*nodes);
255 *pnn_mode = CTDB_CURRENT_NODE;
257 if (!ctdb_getpnn(ctdb_connection, current_pnn,
263 ctdb_free_nodemap(nodemap);
269 check if a database exists
271 static bool db_exists(struct ctdb_context *ctdb, const char *dbarg, uint32_t *dbid, uint8_t *flags)
274 struct ctdb_dbid_map *dbmap=NULL;
275 bool dbid_given = false, found = false;
277 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
279 ret = ctdb_ctrl_getdbmap(ctdb, TIMELIMIT(), options.pnn, tmp_ctx, &dbmap);
281 DEBUG(DEBUG_ERR, ("Unable to get dbids from node %u\n", options.pnn));
285 if (strncmp(dbarg, "0x", 2) == 0) {
286 id = strtoul(dbarg, NULL, 0);
290 for(i=0; i<dbmap->num; i++) {
292 if (id == dbmap->dbs[i].dbid) {
298 ret = ctdb_ctrl_getdbname(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, tmp_ctx, &name);
300 DEBUG(DEBUG_ERR, ("Unable to get dbname from dbid %u\n", dbmap->dbs[i].dbid));
304 if (strcmp(name, dbarg) == 0) {
305 id = dbmap->dbs[i].dbid;
313 if (dbid) *dbid = id;
314 if (flags) *flags = dbmap->dbs[i].flags;
316 DEBUG(DEBUG_ERR,("No database matching '%s' found\n", dbarg));
320 talloc_free(tmp_ctx);
325 see if a process exists
327 static int control_process_exists(struct ctdb_context *ctdb, int argc, const char **argv)
335 if (sscanf(argv[0], "%u:%u", &pnn, &pid) != 2) {
336 DEBUG(DEBUG_ERR, ("Badly formed pnn:pid\n"));
340 ret = ctdb_ctrl_process_exists(ctdb, pnn, pid);
342 printf("%u:%u exists\n", pnn, pid);
344 printf("%u:%u does not exist\n", pnn, pid);
350 display statistics structure
352 static void show_statistics(struct ctdb_statistics *s, int show_header)
354 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
356 const char *prefix=NULL;
358 int tmp, days, hours, minutes, seconds;
363 #define STATISTICS_FIELD(n) { #n, offsetof(struct ctdb_statistics, n) }
364 STATISTICS_FIELD(num_clients),
365 STATISTICS_FIELD(frozen),
366 STATISTICS_FIELD(recovering),
367 STATISTICS_FIELD(num_recoveries),
368 STATISTICS_FIELD(client_packets_sent),
369 STATISTICS_FIELD(client_packets_recv),
370 STATISTICS_FIELD(node_packets_sent),
371 STATISTICS_FIELD(node_packets_recv),
372 STATISTICS_FIELD(keepalive_packets_sent),
373 STATISTICS_FIELD(keepalive_packets_recv),
374 STATISTICS_FIELD(node.req_call),
375 STATISTICS_FIELD(node.reply_call),
376 STATISTICS_FIELD(node.req_dmaster),
377 STATISTICS_FIELD(node.reply_dmaster),
378 STATISTICS_FIELD(node.reply_error),
379 STATISTICS_FIELD(node.req_message),
380 STATISTICS_FIELD(node.req_control),
381 STATISTICS_FIELD(node.reply_control),
382 STATISTICS_FIELD(client.req_call),
383 STATISTICS_FIELD(client.req_message),
384 STATISTICS_FIELD(client.req_control),
385 STATISTICS_FIELD(timeouts.call),
386 STATISTICS_FIELD(timeouts.control),
387 STATISTICS_FIELD(timeouts.traverse),
388 STATISTICS_FIELD(locks.num_calls),
389 STATISTICS_FIELD(locks.num_current),
390 STATISTICS_FIELD(locks.num_pending),
391 STATISTICS_FIELD(locks.num_failed),
392 STATISTICS_FIELD(total_calls),
393 STATISTICS_FIELD(pending_calls),
394 STATISTICS_FIELD(childwrite_calls),
395 STATISTICS_FIELD(pending_childwrite_calls),
396 STATISTICS_FIELD(memory_used),
397 STATISTICS_FIELD(max_hop_count),
398 STATISTICS_FIELD(total_ro_delegations),
399 STATISTICS_FIELD(total_ro_revokes),
402 tmp = s->statistics_current_time.tv_sec - s->statistics_start_time.tv_sec;
411 if (options.machinereadable){
413 printf("CTDB version:");
414 printf("Current time of statistics:");
415 printf("Statistics collected since:");
416 for (i=0;i<ARRAY_SIZE(fields);i++) {
417 printf("%s:", fields[i].name);
419 printf("num_reclock_ctdbd_latency:");
420 printf("min_reclock_ctdbd_latency:");
421 printf("avg_reclock_ctdbd_latency:");
422 printf("max_reclock_ctdbd_latency:");
424 printf("num_reclock_recd_latency:");
425 printf("min_reclock_recd_latency:");
426 printf("avg_reclock_recd_latency:");
427 printf("max_reclock_recd_latency:");
429 printf("num_call_latency:");
430 printf("min_call_latency:");
431 printf("avg_call_latency:");
432 printf("max_call_latency:");
434 printf("num_lockwait_latency:");
435 printf("min_lockwait_latency:");
436 printf("avg_lockwait_latency:");
437 printf("max_lockwait_latency:");
439 printf("num_childwrite_latency:");
440 printf("min_childwrite_latency:");
441 printf("avg_childwrite_latency:");
442 printf("max_childwrite_latency:");
445 printf("%d:", CTDB_VERSION);
446 printf("%d:", (int)s->statistics_current_time.tv_sec);
447 printf("%d:", (int)s->statistics_start_time.tv_sec);
448 for (i=0;i<ARRAY_SIZE(fields);i++) {
449 printf("%d:", *(uint32_t *)(fields[i].offset+(uint8_t *)s));
451 printf("%d:", s->reclock.ctdbd.num);
452 printf("%.6f:", s->reclock.ctdbd.min);
453 printf("%.6f:", s->reclock.ctdbd.num?s->reclock.ctdbd.total/s->reclock.ctdbd.num:0.0);
454 printf("%.6f:", s->reclock.ctdbd.max);
456 printf("%d:", s->reclock.recd.num);
457 printf("%.6f:", s->reclock.recd.min);
458 printf("%.6f:", s->reclock.recd.num?s->reclock.recd.total/s->reclock.recd.num:0.0);
459 printf("%.6f:", s->reclock.recd.max);
461 printf("%d:", s->call_latency.num);
462 printf("%.6f:", s->call_latency.min);
463 printf("%.6f:", s->call_latency.num?s->call_latency.total/s->call_latency.num:0.0);
464 printf("%.6f:", s->call_latency.max);
466 printf("%d:", s->childwrite_latency.num);
467 printf("%.6f:", s->childwrite_latency.min);
468 printf("%.6f:", s->childwrite_latency.num?s->childwrite_latency.total/s->childwrite_latency.num:0.0);
469 printf("%.6f:", s->childwrite_latency.max);
472 printf("CTDB version %u\n", CTDB_VERSION);
473 printf("Current time of statistics : %s", ctime(&s->statistics_current_time.tv_sec));
474 printf("Statistics collected since : (%03d %02d:%02d:%02d) %s", days, hours, minutes, seconds, ctime(&s->statistics_start_time.tv_sec));
476 for (i=0;i<ARRAY_SIZE(fields);i++) {
477 if (strchr(fields[i].name, '.')) {
478 preflen = strcspn(fields[i].name, ".")+1;
479 if (!prefix || strncmp(prefix, fields[i].name, preflen) != 0) {
480 prefix = fields[i].name;
481 printf(" %*.*s\n", preflen-1, preflen-1, fields[i].name);
486 printf(" %*s%-22s%*s%10u\n",
488 fields[i].name+preflen,
490 *(uint32_t *)(fields[i].offset+(uint8_t *)s));
492 printf(" hop_count_buckets:");
493 for (i=0;i<MAX_COUNT_BUCKETS;i++) {
494 printf(" %d", s->hop_count_bucket[i]);
497 printf(" lock_buckets:");
498 for (i=0; i<MAX_COUNT_BUCKETS; i++) {
499 printf(" %d", s->locks.buckets[i]);
502 printf(" %-30s %.6f/%.6f/%.6f sec out of %d\n", "locks_latency MIN/AVG/MAX", s->locks.latency.min, s->locks.latency.num?s->locks.latency.total/s->locks.latency.num:0.0, s->locks.latency.max, s->locks.latency.num);
504 printf(" %-30s %.6f/%.6f/%.6f sec out of %d\n", "reclock_ctdbd MIN/AVG/MAX", s->reclock.ctdbd.min, s->reclock.ctdbd.num?s->reclock.ctdbd.total/s->reclock.ctdbd.num:0.0, s->reclock.ctdbd.max, s->reclock.ctdbd.num);
506 printf(" %-30s %.6f/%.6f/%.6f sec out of %d\n", "reclock_recd MIN/AVG/MAX", s->reclock.recd.min, s->reclock.recd.num?s->reclock.recd.total/s->reclock.recd.num:0.0, s->reclock.recd.max, s->reclock.recd.num);
508 printf(" %-30s %.6f/%.6f/%.6f sec out of %d\n", "call_latency MIN/AVG/MAX", s->call_latency.min, s->call_latency.num?s->call_latency.total/s->call_latency.num:0.0, s->call_latency.max, s->call_latency.num);
509 printf(" %-30s %.6f/%.6f/%.6f sec out of %d\n", "childwrite_latency MIN/AVG/MAX", s->childwrite_latency.min, s->childwrite_latency.num?s->childwrite_latency.total/s->childwrite_latency.num:0.0, s->childwrite_latency.max, s->childwrite_latency.num);
512 talloc_free(tmp_ctx);
516 display remote ctdb statistics combined from all nodes
518 static int control_statistics_all(struct ctdb_context *ctdb)
521 struct ctdb_statistics statistics;
525 nodes = ctdb_get_connected_nodes(ctdb, TIMELIMIT(), ctdb, &num_nodes);
526 CTDB_NO_MEMORY(ctdb, nodes);
528 ZERO_STRUCT(statistics);
530 for (i=0;i<num_nodes;i++) {
531 struct ctdb_statistics s1;
533 uint32_t *v1 = (uint32_t *)&s1;
534 uint32_t *v2 = (uint32_t *)&statistics;
536 offsetof(struct ctdb_statistics, __last_counter) / sizeof(uint32_t);
537 ret = ctdb_ctrl_statistics(ctdb, nodes[i], &s1);
539 DEBUG(DEBUG_ERR, ("Unable to get statistics from node %u\n", nodes[i]));
542 for (j=0;j<num_ints;j++) {
545 statistics.max_hop_count =
546 MAX(statistics.max_hop_count, s1.max_hop_count);
547 statistics.call_latency.max =
548 MAX(statistics.call_latency.max, s1.call_latency.max);
551 printf("Gathered statistics for %u nodes\n", num_nodes);
552 show_statistics(&statistics, 1);
557 display remote ctdb statistics
559 static int control_statistics(struct ctdb_context *ctdb, int argc, const char **argv)
562 struct ctdb_statistics statistics;
564 if (options.pnn == CTDB_BROADCAST_ALL) {
565 return control_statistics_all(ctdb);
568 ret = ctdb_ctrl_statistics(ctdb, options.pnn, &statistics);
570 DEBUG(DEBUG_ERR, ("Unable to get statistics from node %u\n", options.pnn));
573 show_statistics(&statistics, 1);
579 reset remote ctdb statistics
581 static int control_statistics_reset(struct ctdb_context *ctdb, int argc, const char **argv)
585 ret = ctdb_statistics_reset(ctdb, options.pnn);
587 DEBUG(DEBUG_ERR, ("Unable to reset statistics on node %u\n", options.pnn));
595 display remote ctdb rolling statistics
597 static int control_stats(struct ctdb_context *ctdb, int argc, const char **argv)
600 struct ctdb_statistics_wire *stats;
601 int i, num_records = -1;
603 assert_single_node_only();
606 num_records = atoi(argv[0]) - 1;
609 ret = ctdb_ctrl_getstathistory(ctdb, TIMELIMIT(), options.pnn, ctdb, &stats);
611 DEBUG(DEBUG_ERR, ("Unable to get rolling statistics from node %u\n", options.pnn));
614 for (i=0;i<stats->num;i++) {
615 if (stats->stats[i].statistics_start_time.tv_sec == 0) {
618 show_statistics(&stats->stats[i], i==0);
619 if (i == num_records) {
628 display remote ctdb db statistics
630 static int control_dbstatistics(struct ctdb_context *ctdb, int argc, const char **argv)
632 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
633 struct ctdb_db_statistics *dbstat;
642 if (!db_exists(ctdb, argv[0], &db_id, NULL)) {
646 if (!ctdb_getdbstat(ctdb_connection, options.pnn, db_id, &dbstat)) {
647 DEBUG(DEBUG_ERR,("Failed to read db statistics from node\n"));
648 talloc_free(tmp_ctx);
652 printf("DB Statistics: %s\n", argv[0]);
653 printf(" %*s%-22s%*s%10u\n", 0, "", "ro_delegations", 4, "",
654 dbstat->db_ro_delegations);
655 printf(" %*s%-22s%*s%10u\n", 0, "", "ro_revokes", 4, "",
656 dbstat->db_ro_delegations);
657 printf(" %s\n", "locks");
658 printf(" %*s%-22s%*s%10u\n", 4, "", "total", 0, "",
659 dbstat->locks.num_calls);
660 printf(" %*s%-22s%*s%10u\n", 4, "", "failed", 0, "",
661 dbstat->locks.num_failed);
662 printf(" %*s%-22s%*s%10u\n", 4, "", "current", 0, "",
663 dbstat->locks.num_current);
664 printf(" %*s%-22s%*s%10u\n", 4, "", "pending", 0, "",
665 dbstat->locks.num_pending);
666 printf(" %s", "hop_count_buckets:");
667 for (i=0; i<MAX_COUNT_BUCKETS; i++) {
668 printf(" %d", dbstat->hop_count_bucket[i]);
671 printf(" %s", "lock_buckets:");
672 for (i=0; i<MAX_COUNT_BUCKETS; i++) {
673 printf(" %d", dbstat->locks.buckets[i]);
676 printf(" %-30s %.6f/%.6f/%.6f sec out of %d\n",
677 "locks_latency MIN/AVG/MAX",
678 dbstat->locks.latency.min,
679 (dbstat->locks.latency.num ?
680 dbstat->locks.latency.total /dbstat->locks.latency.num :
682 dbstat->locks.latency.max,
683 dbstat->locks.latency.num);
685 for (i=0; i<dbstat->num_hot_keys; i++) {
686 if (dbstat->hot_keys[i].count > 0) {
690 dbstat->num_hot_keys = num_hot_keys;
692 printf(" Num Hot Keys: %d\n", dbstat->num_hot_keys);
693 for (i = 0; i < dbstat->num_hot_keys; i++) {
695 printf(" Count:%d Key:", dbstat->hot_keys[i].count);
696 for (j = 0; j < dbstat->hot_keys[i].key.dsize; j++) {
697 printf("%02x", dbstat->hot_keys[i].key.dptr[j]&0xff);
702 ctdb_free_dbstat(dbstat);
707 display uptime of remote node
709 static int control_uptime(struct ctdb_context *ctdb, int argc, const char **argv)
712 struct ctdb_uptime *uptime = NULL;
713 int tmp, days, hours, minutes, seconds;
715 ret = ctdb_ctrl_uptime(ctdb, ctdb, TIMELIMIT(), options.pnn, &uptime);
717 DEBUG(DEBUG_ERR, ("Unable to get uptime from node %u\n", options.pnn));
721 if (options.machinereadable){
722 printf(":Current Node Time:Ctdb Start Time:Last Recovery/Failover Time:Last Recovery/IPFailover Duration:\n");
723 printf(":%u:%u:%u:%lf\n",
724 (unsigned int)uptime->current_time.tv_sec,
725 (unsigned int)uptime->ctdbd_start_time.tv_sec,
726 (unsigned int)uptime->last_recovery_finished.tv_sec,
727 timeval_delta(&uptime->last_recovery_finished,
728 &uptime->last_recovery_started)
733 printf("Current time of node : %s", ctime(&uptime->current_time.tv_sec));
735 tmp = uptime->current_time.tv_sec - uptime->ctdbd_start_time.tv_sec;
743 printf("Ctdbd start time : (%03d %02d:%02d:%02d) %s", days, hours, minutes, seconds, ctime(&uptime->ctdbd_start_time.tv_sec));
745 tmp = uptime->current_time.tv_sec - uptime->last_recovery_finished.tv_sec;
753 printf("Time of last recovery/failover: (%03d %02d:%02d:%02d) %s", days, hours, minutes, seconds, ctime(&uptime->last_recovery_finished.tv_sec));
755 printf("Duration of last recovery/failover: %lf seconds\n",
756 timeval_delta(&uptime->last_recovery_finished,
757 &uptime->last_recovery_started));
763 show the PNN of the current node
765 static int control_pnn(struct ctdb_context *ctdb, int argc, const char **argv)
769 mypnn = getpnn(ctdb);
771 printf("PNN:%d\n", mypnn);
777 struct pnn_node *next;
782 static struct pnn_node *read_nodes_file(TALLOC_CTX *mem_ctx)
784 const char *nodes_list;
788 struct pnn_node *pnn_nodes = NULL;
789 struct pnn_node *pnn_node;
790 struct pnn_node *tmp_node;
792 /* read the nodes file */
793 nodes_list = getenv("CTDB_NODES");
794 if (nodes_list == NULL) {
795 nodes_list = "/etc/ctdb/nodes";
797 lines = file_lines_load(nodes_list, &nlines, mem_ctx);
801 while (nlines > 0 && strcmp(lines[nlines-1], "") == 0) {
804 for (i=0, pnn=0; i<nlines; i++) {
808 /* strip leading spaces */
809 while((*node == ' ') || (*node == '\t')) {
816 if (strcmp(node, "") == 0) {
819 pnn_node = talloc(mem_ctx, struct pnn_node);
820 pnn_node->pnn = pnn++;
821 pnn_node->addr = talloc_strdup(pnn_node, node);
822 pnn_node->next = pnn_nodes;
823 pnn_nodes = pnn_node;
826 /* swap them around so we return them in incrementing order */
827 pnn_node = pnn_nodes;
831 pnn_node = pnn_node->next;
833 tmp_node->next = pnn_nodes;
834 pnn_nodes = tmp_node;
841 show the PNN of the current node
842 discover the pnn by loading the nodes file and try to bind to all
843 addresses one at a time until the ip address is found.
845 static int control_xpnn(struct ctdb_context *ctdb, int argc, const char **argv)
847 TALLOC_CTX *mem_ctx = talloc_new(NULL);
848 struct pnn_node *pnn_nodes;
849 struct pnn_node *pnn_node;
851 assert_single_node_only();
853 pnn_nodes = read_nodes_file(mem_ctx);
854 if (pnn_nodes == NULL) {
855 DEBUG(DEBUG_ERR,("Failed to read nodes file\n"));
856 talloc_free(mem_ctx);
860 for(pnn_node=pnn_nodes;pnn_node;pnn_node=pnn_node->next) {
863 if (parse_ip(pnn_node->addr, NULL, 63999, &addr) == 0) {
864 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s' in nodes file\n", pnn_node->addr));
865 talloc_free(mem_ctx);
869 if (ctdb_sys_have_ip(&addr)) {
870 printf("PNN:%d\n", pnn_node->pnn);
871 talloc_free(mem_ctx);
876 printf("Failed to detect which PNN this node is\n");
877 talloc_free(mem_ctx);
881 /* Helpers for ctdb status
883 static bool is_partially_online(struct ctdb_node_and_flags *node)
888 if (node->flags == 0) {
889 struct ctdb_ifaces_list *ifaces;
891 if (ctdb_getifaces(ctdb_connection, node->pnn, &ifaces)) {
892 for (j=0; j < ifaces->num; j++) {
893 if (ifaces->ifaces[j].link_state != 0) {
899 ctdb_free_ifaces(ifaces);
906 static void control_status_header_machine(void)
908 printf(":Node:IP:Disconnected:Banned:Disabled:Unhealthy:Stopped"
909 ":Inactive:PartiallyOnline:ThisNode:\n");
912 static int control_status_1_machine(int mypnn, struct ctdb_node_and_flags *node)
914 printf(":%d:%s:%d:%d:%d:%d:%d:%d:%d:%c:\n", node->pnn,
915 ctdb_addr_to_str(&node->addr),
916 !!(node->flags&NODE_FLAGS_DISCONNECTED),
917 !!(node->flags&NODE_FLAGS_BANNED),
918 !!(node->flags&NODE_FLAGS_PERMANENTLY_DISABLED),
919 !!(node->flags&NODE_FLAGS_UNHEALTHY),
920 !!(node->flags&NODE_FLAGS_STOPPED),
921 !!(node->flags&NODE_FLAGS_INACTIVE),
922 is_partially_online(node) ? 1 : 0,
923 (node->pnn == mypnn)?'Y':'N');
928 static int control_status_1_human(int mypnn, struct ctdb_node_and_flags *node)
930 printf("pnn:%d %-16s %s%s\n", node->pnn,
931 ctdb_addr_to_str(&node->addr),
932 is_partially_online(node) ? "PARTIALLYONLINE" : pretty_print_flags(node->flags),
933 node->pnn == mypnn?" (THIS NODE)":"");
939 display remote ctdb status
941 static int control_status(struct ctdb_context *ctdb, int argc, const char **argv)
944 struct ctdb_vnn_map *vnnmap=NULL;
945 struct ctdb_node_map *nodemap=NULL;
946 uint32_t recmode, recmaster, mypnn;
947 int num_deleted_nodes = 0;
949 mypnn = getpnn(ctdb);
951 if (!ctdb_getnodemap(ctdb_connection, options.pnn, &nodemap)) {
952 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
956 if (options.machinereadable) {
957 control_status_header_machine();
958 for (i=0;i<nodemap->num;i++) {
959 if (nodemap->nodes[i].flags & NODE_FLAGS_DELETED) {
962 (void) control_status_1_machine(mypnn,
968 for (i=0; i<nodemap->num; i++) {
969 if (nodemap->nodes[i].flags & NODE_FLAGS_DELETED) {
973 if (num_deleted_nodes == 0) {
974 printf("Number of nodes:%d\n", nodemap->num);
976 printf("Number of nodes:%d (including %d deleted nodes)\n",
977 nodemap->num, num_deleted_nodes);
979 for(i=0;i<nodemap->num;i++){
980 if (nodemap->nodes[i].flags & NODE_FLAGS_DELETED) {
983 (void) control_status_1_human(mypnn, &nodemap->nodes[i]);
986 if (!ctdb_getvnnmap(ctdb_connection, options.pnn, &vnnmap)) {
987 DEBUG(DEBUG_ERR, ("Unable to get vnnmap from node %u\n", options.pnn));
990 if (vnnmap->generation == INVALID_GENERATION) {
991 printf("Generation:INVALID\n");
993 printf("Generation:%d\n",vnnmap->generation);
995 printf("Size:%d\n",vnnmap->size);
996 for(i=0;i<vnnmap->size;i++){
997 printf("hash:%d lmaster:%d\n", i, vnnmap->map[i]);
999 ctdb_free_vnnmap(vnnmap);
1001 if (!ctdb_getrecmode(ctdb_connection, options.pnn, &recmode)) {
1002 DEBUG(DEBUG_ERR, ("Unable to get recmode from node %u\n", options.pnn));
1005 printf("Recovery mode:%s (%d)\n",recmode==CTDB_RECOVERY_NORMAL?"NORMAL":"RECOVERY",recmode);
1007 if (!ctdb_getrecmaster(ctdb_connection, options.pnn, &recmaster)) {
1008 DEBUG(DEBUG_ERR, ("Unable to get recmaster from node %u\n", options.pnn));
1011 printf("Recovery master:%d\n",recmaster);
1016 static int control_nodestatus(struct ctdb_context *ctdb, int argc, const char **argv)
1019 struct ctdb_node_map *nodemap=NULL;
1021 uint32_t pnn_mode, mypnn;
1027 if (!parse_nodestring(ctdb, argc == 1 ? argv[0] : NULL,
1028 options.pnn, true, &nodes, &pnn_mode)) {
1032 if (options.machinereadable) {
1033 control_status_header_machine();
1034 } else if (pnn_mode == CTDB_BROADCAST_ALL) {
1035 printf("Number of nodes:%d\n", (int) talloc_array_length(nodes));
1038 mypnn = getpnn(ctdb);
1040 if (!ctdb_getnodemap(ctdb_connection, options.pnn, &nodemap)) {
1041 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
1047 for (i = 0; i < talloc_array_length(nodes); i++) {
1048 if (options.machinereadable) {
1049 ret |= control_status_1_machine(mypnn,
1050 &nodemap->nodes[nodes[i]]);
1052 ret |= control_status_1_human(mypnn,
1053 &nodemap->nodes[nodes[i]]);
1060 struct natgw_node *next;
1064 static int find_natgw(struct ctdb_context *ctdb,
1065 struct ctdb_node_map *nodemap, uint32_t flags,
1066 uint32_t *pnn, const char **ip)
1069 uint32_t capabilities;
1071 for (i=0;i<nodemap->num;i++) {
1072 if (!(nodemap->nodes[i].flags & flags)) {
1073 if (!ctdb_getcapabilities(ctdb_connection, nodemap->nodes[i].pnn, &capabilities)) {
1074 DEBUG(DEBUG_ERR, ("Unable to get capabilities from node %u\n", nodemap->nodes[i].pnn));
1077 if (!(capabilities&CTDB_CAP_NATGW)) {
1080 *pnn = nodemap->nodes[i].pnn;
1081 *ip = ctdb_addr_to_str(&nodemap->nodes[i].addr);
1086 return 2; /* matches ENOENT */
1090 display the list of nodes belonging to this natgw configuration
1092 static int control_natgwlist(struct ctdb_context *ctdb, int argc, const char **argv)
1095 const char *natgw_list;
1098 struct natgw_node *natgw_nodes = NULL;
1099 struct natgw_node *natgw_node;
1100 struct ctdb_node_map *nodemap=NULL;
1101 uint32_t mypnn, pnn;
1104 /* When we have some nodes that could be the NATGW, make a
1105 * series of attempts to find the first node that doesn't have
1106 * certain status flags set.
1108 uint32_t exclude_flags[] = {
1109 /* Look for a nice healthy node */
1110 NODE_FLAGS_DISCONNECTED|NODE_FLAGS_STOPPED|NODE_FLAGS_DELETED|NODE_FLAGS_BANNED|NODE_FLAGS_UNHEALTHY,
1111 /* If not found, an UNHEALTHY/BANNED node will do */
1112 NODE_FLAGS_DISCONNECTED|NODE_FLAGS_STOPPED|NODE_FLAGS_DELETED,
1113 /* If not found, a STOPPED node will do */
1114 NODE_FLAGS_DISCONNECTED|NODE_FLAGS_DELETED,
1118 /* read the natgw nodes file into a linked list */
1119 natgw_list = getenv("CTDB_NATGW_NODES");
1120 if (natgw_list == NULL) {
1121 natgw_list = "/etc/ctdb/natgw_nodes";
1123 lines = file_lines_load(natgw_list, &nlines, ctdb);
1124 if (lines == NULL) {
1125 ctdb_set_error(ctdb, "Failed to load natgw node list '%s'\n", natgw_list);
1128 for (i=0;i<nlines;i++) {
1132 /* strip leading spaces */
1133 while((*node == ' ') || (*node == '\t')) {
1139 if (strcmp(node, "") == 0) {
1142 natgw_node = talloc(ctdb, struct natgw_node);
1143 natgw_node->addr = talloc_strdup(natgw_node, node);
1144 CTDB_NO_MEMORY(ctdb, natgw_node->addr);
1145 natgw_node->next = natgw_nodes;
1146 natgw_nodes = natgw_node;
1149 if (!ctdb_getnodemap(ctdb_connection, CTDB_CURRENT_NODE, &nodemap)) {
1150 DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node.\n"));
1154 /* Trim the nodemap so it only includes connected nodes in the
1155 * current natgw group.
1158 while(i<nodemap->num) {
1159 for(natgw_node=natgw_nodes;natgw_node;natgw_node=natgw_node->next) {
1160 if (!strcmp(natgw_node->addr, ctdb_addr_to_str(&nodemap->nodes[i].addr))) {
1165 /* this node was not in the natgw so we just remove it from
1168 if ((natgw_node == NULL)
1169 || (nodemap->nodes[i].flags & NODE_FLAGS_DISCONNECTED) ) {
1172 for (j=i+1; j<nodemap->num; j++) {
1173 nodemap->nodes[j-1] = nodemap->nodes[j];
1182 ret = 2; /* matches ENOENT */
1185 for (i = 0; exclude_flags[i] != 0; i++) {
1186 ret = find_natgw(ctdb, nodemap,
1197 if (options.machinereadable) {
1198 printf(":Node:IP:\n");
1199 printf(":%d:%s:\n", pnn, ip);
1201 printf("%d %s\n", pnn, ip);
1204 /* print the pruned list of nodes belonging to this natgw list */
1205 mypnn = getpnn(ctdb);
1206 if (options.machinereadable) {
1207 control_status_header_machine();
1209 printf("Number of nodes:%d\n", nodemap->num);
1211 for(i=0;i<nodemap->num;i++){
1212 if (nodemap->nodes[i].flags & NODE_FLAGS_DELETED) {
1215 if (options.machinereadable) {
1216 control_status_1_machine(mypnn, &(nodemap->nodes[i]));
1218 control_status_1_human(mypnn, &(nodemap->nodes[i]));
1223 ctdb_free_nodemap(nodemap);
1228 display the status of the scripts for monitoring (or other events)
1230 static int control_one_scriptstatus(struct ctdb_context *ctdb,
1231 enum ctdb_eventscript_call type)
1233 struct ctdb_scripts_wire *script_status;
1236 ret = ctdb_ctrl_getscriptstatus(ctdb, TIMELIMIT(), options.pnn, ctdb, type, &script_status);
1238 DEBUG(DEBUG_ERR, ("Unable to get script status from node %u\n", options.pnn));
1242 if (script_status == NULL) {
1243 if (!options.machinereadable) {
1244 printf("%s cycle never run\n",
1245 ctdb_eventscript_call_names[type]);
1250 if (!options.machinereadable) {
1251 printf("%d scripts were executed last %s cycle\n",
1252 script_status->num_scripts,
1253 ctdb_eventscript_call_names[type]);
1255 for (i=0; i<script_status->num_scripts; i++) {
1256 const char *status = NULL;
1258 switch (script_status->scripts[i].status) {
1260 status = "TIMEDOUT";
1263 status = "DISABLED";
1269 if (script_status->scripts[i].status > 0)
1273 if (options.machinereadable) {
1274 printf(":%s:%s:%i:%s:%lu.%06lu:%lu.%06lu:%s:\n",
1275 ctdb_eventscript_call_names[type],
1276 script_status->scripts[i].name,
1277 script_status->scripts[i].status,
1279 (long)script_status->scripts[i].start.tv_sec,
1280 (long)script_status->scripts[i].start.tv_usec,
1281 (long)script_status->scripts[i].finished.tv_sec,
1282 (long)script_status->scripts[i].finished.tv_usec,
1283 script_status->scripts[i].output);
1287 printf("%-20s Status:%s ",
1288 script_status->scripts[i].name, status);
1290 /* Some other error, eg from stat. */
1291 printf("%-20s Status:CANNOT RUN (%s)",
1292 script_status->scripts[i].name,
1293 strerror(-script_status->scripts[i].status));
1295 if (script_status->scripts[i].status >= 0) {
1296 printf("Duration:%.3lf ",
1297 timeval_delta(&script_status->scripts[i].finished,
1298 &script_status->scripts[i].start));
1300 if (script_status->scripts[i].status != -ENOEXEC) {
1302 ctime(&script_status->scripts[i].start.tv_sec));
1303 if (script_status->scripts[i].status != 0) {
1304 printf(" OUTPUT:%s\n",
1305 script_status->scripts[i].output);
1315 static int control_scriptstatus(struct ctdb_context *ctdb,
1316 int argc, const char **argv)
1319 enum ctdb_eventscript_call type, min, max;
1323 DEBUG(DEBUG_ERR, ("Unknown arguments to scriptstatus\n"));
1328 arg = ctdb_eventscript_call_names[CTDB_EVENT_MONITOR];
1332 for (type = 0; type < CTDB_EVENT_MAX; type++) {
1333 if (strcmp(arg, ctdb_eventscript_call_names[type]) == 0) {
1339 if (type == CTDB_EVENT_MAX) {
1340 if (strcmp(arg, "all") == 0) {
1342 max = CTDB_EVENT_MAX;
1344 DEBUG(DEBUG_ERR, ("Unknown event type %s\n", argv[0]));
1349 if (options.machinereadable) {
1350 printf(":Type:Name:Code:Status:Start:End:Error Output...:\n");
1353 for (type = min; type < max; type++) {
1354 ret = control_one_scriptstatus(ctdb, type);
1364 enable an eventscript
1366 static int control_enablescript(struct ctdb_context *ctdb, int argc, const char **argv)
1374 ret = ctdb_ctrl_enablescript(ctdb, TIMELIMIT(), options.pnn, argv[0]);
1376 DEBUG(DEBUG_ERR, ("Unable to enable script %s on node %u\n", argv[0], options.pnn));
1384 disable an eventscript
1386 static int control_disablescript(struct ctdb_context *ctdb, int argc, const char **argv)
1394 ret = ctdb_ctrl_disablescript(ctdb, TIMELIMIT(), options.pnn, argv[0]);
1396 DEBUG(DEBUG_ERR, ("Unable to disable script %s on node %u\n", argv[0], options.pnn));
1404 display the pnn of the recovery master
1406 static int control_recmaster(struct ctdb_context *ctdb, int argc, const char **argv)
1410 if (!ctdb_getrecmaster(ctdb_connection, options.pnn, &recmaster)) {
1411 DEBUG(DEBUG_ERR, ("Unable to get recmaster from node %u\n", options.pnn));
1414 printf("%d\n",recmaster);
1420 add a tickle to a public address
1422 static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **argv)
1424 struct ctdb_tcp_connection t;
1428 assert_single_node_only();
1434 if (parse_ip_port(argv[0], &t.src_addr) == 0) {
1435 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
1438 if (parse_ip_port(argv[1], &t.dst_addr) == 0) {
1439 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1]));
1443 data.dptr = (uint8_t *)&t;
1444 data.dsize = sizeof(t);
1446 /* tell all nodes about this tcp connection */
1447 ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE,
1448 0, data, ctdb, NULL, NULL, NULL, NULL);
1450 DEBUG(DEBUG_ERR,("Failed to add tickle\n"));
1459 delete a tickle from a node
1461 static int control_del_tickle(struct ctdb_context *ctdb, int argc, const char **argv)
1463 struct ctdb_tcp_connection t;
1467 assert_single_node_only();
1473 if (parse_ip_port(argv[0], &t.src_addr) == 0) {
1474 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
1477 if (parse_ip_port(argv[1], &t.dst_addr) == 0) {
1478 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1]));
1482 data.dptr = (uint8_t *)&t;
1483 data.dsize = sizeof(t);
1485 /* tell all nodes about this tcp connection */
1486 ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_TCP_REMOVE,
1487 0, data, ctdb, NULL, NULL, NULL, NULL);
1489 DEBUG(DEBUG_ERR,("Failed to remove tickle\n"));
1498 get a list of all tickles for this pnn
1500 static int control_get_tickles(struct ctdb_context *ctdb, int argc, const char **argv)
1502 struct ctdb_control_tcp_tickle_list *list;
1503 ctdb_sock_addr addr;
1507 assert_single_node_only();
1514 port = atoi(argv[1]);
1517 if (parse_ip(argv[0], NULL, 0, &addr) == 0) {
1518 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
1522 ret = ctdb_ctrl_get_tcp_tickles(ctdb, TIMELIMIT(), options.pnn, ctdb, &addr, &list);
1524 DEBUG(DEBUG_ERR, ("Unable to list tickles\n"));
1528 if (options.machinereadable){
1529 printf(":source ip:port:destination ip:port:\n");
1530 for (i=0;i<list->tickles.num;i++) {
1531 if (port && port != ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)) {
1534 printf(":%s:%u", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port));
1535 printf(":%s:%u:\n", ctdb_addr_to_str(&list->tickles.connections[i].dst_addr), ntohs(list->tickles.connections[i].dst_addr.ip.sin_port));
1538 printf("Tickles for ip:%s\n", ctdb_addr_to_str(&list->addr));
1539 printf("Num tickles:%u\n", list->tickles.num);
1540 for (i=0;i<list->tickles.num;i++) {
1541 if (port && port != ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)) {
1544 printf("SRC: %s:%u ", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port));
1545 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));
1555 static int move_ip(struct ctdb_context *ctdb, ctdb_sock_addr *addr, uint32_t pnn)
1557 struct ctdb_all_public_ips *ips;
1558 struct ctdb_public_ip ip;
1561 uint32_t disable_time;
1563 struct ctdb_node_map *nodemap=NULL;
1564 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
1567 data.dptr = (uint8_t*)&disable_time;
1568 data.dsize = sizeof(disable_time);
1569 ret = ctdb_client_send_message(ctdb, CTDB_BROADCAST_CONNECTED, CTDB_SRVID_DISABLE_IP_CHECK, data);
1571 DEBUG(DEBUG_ERR,("Failed to send message to disable ipcheck\n"));
1577 /* read the public ip list from the node */
1578 ret = ctdb_ctrl_get_public_ips(ctdb, TIMELIMIT(), pnn, ctdb, &ips);
1580 DEBUG(DEBUG_ERR, ("Unable to get public ip list from node %u\n", pnn));
1581 talloc_free(tmp_ctx);
1585 for (i=0;i<ips->num;i++) {
1586 if (ctdb_same_ip(addr, &ips->ips[i].addr)) {
1591 DEBUG(DEBUG_ERR, ("Node %u can not host ip address '%s'\n",
1592 pnn, ctdb_addr_to_str(addr)));
1593 talloc_free(tmp_ctx);
1600 data.dptr = (uint8_t *)&ip;
1601 data.dsize = sizeof(ip);
1603 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), options.pnn, tmp_ctx, &nodemap);
1605 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
1606 talloc_free(tmp_ctx);
1610 nodes = list_of_nodes(ctdb, nodemap, tmp_ctx, NODE_FLAGS_INACTIVE, pnn);
1611 ret = ctdb_client_async_control(ctdb, CTDB_CONTROL_RELEASE_IP,
1618 DEBUG(DEBUG_ERR,("Failed to release IP on nodes\n"));
1619 talloc_free(tmp_ctx);
1623 ret = ctdb_ctrl_takeover_ip(ctdb, LONGTIMELIMIT(), pnn, &ip);
1625 DEBUG(DEBUG_ERR,("Failed to take over IP on node %d\n", pnn));
1626 talloc_free(tmp_ctx);
1630 /* update the recovery daemon so it now knows to expect the new
1631 node assignment for this ip.
1633 ret = ctdb_client_send_message(ctdb, CTDB_BROADCAST_CONNECTED, CTDB_SRVID_RECD_UPDATE_IP, data);
1635 DEBUG(DEBUG_ERR,("Failed to send message to update the ip on the recovery master.\n"));
1639 talloc_free(tmp_ctx);
1645 * scans all other nodes and returns a pnn for another node that can host this
1649 find_other_host_for_public_ip(struct ctdb_context *ctdb, ctdb_sock_addr *addr)
1651 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
1652 struct ctdb_all_public_ips *ips;
1653 struct ctdb_node_map *nodemap=NULL;
1656 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, tmp_ctx, &nodemap);
1658 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
1659 talloc_free(tmp_ctx);
1663 for(i=0;i<nodemap->num;i++){
1664 if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
1667 if (nodemap->nodes[i].pnn == options.pnn) {
1671 /* read the public ip list from this node */
1672 ret = ctdb_ctrl_get_public_ips(ctdb, TIMELIMIT(), nodemap->nodes[i].pnn, tmp_ctx, &ips);
1674 DEBUG(DEBUG_ERR, ("Unable to get public ip list from node %u\n", nodemap->nodes[i].pnn));
1678 for (j=0;j<ips->num;j++) {
1679 if (ctdb_same_ip(addr, &ips->ips[j].addr)) {
1680 talloc_free(tmp_ctx);
1681 return nodemap->nodes[i].pnn;
1687 talloc_free(tmp_ctx);
1691 /* If pnn is -1 then try to find a node to move IP to... */
1692 static bool try_moveip(struct ctdb_context *ctdb, ctdb_sock_addr *addr, uint32_t pnn)
1694 bool pnn_specified = (pnn == -1 ? false : true);
1697 while (retries < 5) {
1698 if (!pnn_specified) {
1699 pnn = find_other_host_for_public_ip(ctdb, addr);
1704 ("Trying to move public IP to node %u\n", pnn));
1707 if (move_ip(ctdb, addr, pnn) == 0) {
1720 move/failover an ip address to a specific node
1722 static int control_moveip(struct ctdb_context *ctdb, int argc, const char **argv)
1725 ctdb_sock_addr addr;
1727 assert_single_node_only();
1734 if (parse_ip(argv[0], NULL, 0, &addr) == 0) {
1735 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
1740 if (sscanf(argv[1], "%u", &pnn) != 1) {
1741 DEBUG(DEBUG_ERR, ("Badly formed pnn\n"));
1745 if (!try_moveip(ctdb, &addr, pnn)) {
1746 DEBUG(DEBUG_ERR,("Failed to move IP to node %d.\n", pnn));
1753 static int rebalance_node(struct ctdb_context *ctdb, uint32_t pnn)
1758 if (ctdb_ctrl_getrecmaster(ctdb, ctdb, TIMELIMIT(), pnn, &recmaster) != 0) {
1759 DEBUG(DEBUG_ERR, ("Unable to get recmaster from node %u\n", pnn));
1763 data.dptr = (uint8_t *)&pnn;
1764 data.dsize = sizeof(uint32_t);
1765 if (ctdb_client_send_message(ctdb, recmaster, CTDB_SRVID_REBALANCE_NODE, data) != 0) {
1766 DEBUG(DEBUG_ERR,("Failed to send message to force node reallocation\n"));
1775 rebalance a node by setting it to allow failback and triggering a
1778 static int control_rebalancenode(struct ctdb_context *ctdb, int argc, const char **argv)
1780 switch (options.pnn) {
1781 case CTDB_BROADCAST_ALL:
1782 case CTDB_CURRENT_NODE:
1783 DEBUG(DEBUG_ERR,("You must specify a node number with -n <pnn> for the node to rebalance\n"));
1787 return rebalance_node(ctdb, options.pnn);
1791 static int rebalance_ip(struct ctdb_context *ctdb, ctdb_sock_addr *addr)
1793 struct ctdb_public_ip ip;
1796 uint32_t disable_time;
1798 struct ctdb_node_map *nodemap=NULL;
1799 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
1802 data.dptr = (uint8_t*)&disable_time;
1803 data.dsize = sizeof(disable_time);
1804 ret = ctdb_client_send_message(ctdb, CTDB_BROADCAST_CONNECTED, CTDB_SRVID_DISABLE_IP_CHECK, data);
1806 DEBUG(DEBUG_ERR,("Failed to send message to disable ipcheck\n"));
1813 data.dptr = (uint8_t *)&ip;
1814 data.dsize = sizeof(ip);
1816 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), options.pnn, tmp_ctx, &nodemap);
1818 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
1819 talloc_free(tmp_ctx);
1823 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
1824 ret = ctdb_client_async_control(ctdb, CTDB_CONTROL_RELEASE_IP,
1831 DEBUG(DEBUG_ERR,("Failed to release IP on nodes\n"));
1832 talloc_free(tmp_ctx);
1836 talloc_free(tmp_ctx);
1841 release an ip form all nodes and have it re-assigned by recd
1843 static int control_rebalanceip(struct ctdb_context *ctdb, int argc, const char **argv)
1845 ctdb_sock_addr addr;
1847 assert_single_node_only();
1854 if (parse_ip(argv[0], NULL, 0, &addr) == 0) {
1855 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
1859 if (rebalance_ip(ctdb, &addr) != 0) {
1860 DEBUG(DEBUG_ERR,("Error when trying to reassign ip\n"));
1867 static int getips_store_callback(void *param, void *data)
1869 struct ctdb_public_ip *node_ip = (struct ctdb_public_ip *)data;
1870 struct ctdb_all_public_ips *ips = param;
1874 ips->ips[i].pnn = node_ip->pnn;
1875 ips->ips[i].addr = node_ip->addr;
1879 static int getips_count_callback(void *param, void *data)
1881 uint32_t *count = param;
1888 static uint32_t *ip_key(ctdb_sock_addr *ip)
1890 static uint32_t key[IP_KEYLEN];
1892 bzero(key, sizeof(key));
1894 switch (ip->sa.sa_family) {
1896 key[0] = ip->ip.sin_addr.s_addr;
1899 uint32_t *s6_a32 = (uint32_t *)&(ip->ip6.sin6_addr.s6_addr);
1907 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family passed :%u\n", ip->sa.sa_family));
1914 static void *add_ip_callback(void *parm, void *data)
1920 control_get_all_public_ips(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx, struct ctdb_all_public_ips **ips)
1922 struct ctdb_all_public_ips *tmp_ips;
1923 struct ctdb_node_map *nodemap=NULL;
1924 trbt_tree_t *ip_tree;
1928 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, tmp_ctx, &nodemap);
1930 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
1934 ip_tree = trbt_create(tmp_ctx, 0);
1936 for(i=0;i<nodemap->num;i++){
1937 if (nodemap->nodes[i].flags & NODE_FLAGS_DELETED) {
1940 if (nodemap->nodes[i].flags & NODE_FLAGS_DISCONNECTED) {
1944 /* read the public ip list from this node */
1945 ret = ctdb_ctrl_get_public_ips(ctdb, TIMELIMIT(), nodemap->nodes[i].pnn, tmp_ctx, &tmp_ips);
1947 DEBUG(DEBUG_ERR, ("Unable to get public ip list from node %u\n", nodemap->nodes[i].pnn));
1951 for (j=0; j<tmp_ips->num;j++) {
1952 struct ctdb_public_ip *node_ip;
1954 node_ip = talloc(tmp_ctx, struct ctdb_public_ip);
1955 node_ip->pnn = tmp_ips->ips[j].pnn;
1956 node_ip->addr = tmp_ips->ips[j].addr;
1958 trbt_insertarray32_callback(ip_tree,
1959 IP_KEYLEN, ip_key(&tmp_ips->ips[j].addr),
1963 talloc_free(tmp_ips);
1968 trbt_traversearray32(ip_tree, IP_KEYLEN, getips_count_callback, &count);
1970 len = offsetof(struct ctdb_all_public_ips, ips) +
1971 count*sizeof(struct ctdb_public_ip);
1972 tmp_ips = talloc_zero_size(tmp_ctx, len);
1973 trbt_traversearray32(ip_tree, IP_KEYLEN, getips_store_callback, tmp_ips);
1981 static void ctdb_every_second(struct event_context *ev, struct timed_event *te, struct timeval t, void *p)
1983 struct ctdb_context *ctdb = talloc_get_type(p, struct ctdb_context);
1985 event_add_timed(ctdb->ev, ctdb,
1986 timeval_current_ofs(1, 0),
1987 ctdb_every_second, ctdb);
1990 struct srvid_reply_handler_data {
1994 const char *srvid_str;
1997 static void srvid_broadcast_reply_handler(struct ctdb_context *ctdb,
2002 struct srvid_reply_handler_data *d =
2003 (struct srvid_reply_handler_data *)private_data;
2007 if (data.dsize != sizeof(ret)) {
2008 DEBUG(DEBUG_ERR, (__location__ " Wrong reply size\n"));
2012 /* ret will be a PNN (i.e. >=0) on success, or negative on error */
2013 ret = *(int32_t *)data.dptr;
2016 ("%s failed with result %d\n", d->srvid_str, ret));
2020 if (!d->wait_for_all) {
2025 /* Wait for all replies */
2027 for (i = 0; i < talloc_array_length(d->nodes); i++) {
2028 if (d->nodes[i] == ret) {
2030 ("%s reply received from node %u\n",
2031 d->srvid_str, ret));
2034 if (d->nodes[i] != -1) {
2035 /* Found a node that hasn't yet replied */
2041 /* Broadcast the given SRVID to all connected nodes. Wait for 1 reply
2042 * or replies from all connected nodes. arg is the data argument to
2043 * pass in the srvid_request structure - pass 0 if this isn't needed.
2045 static int srvid_broadcast(struct ctdb_context *ctdb,
2046 uint64_t srvid, uint32_t arg,
2047 const char *srvid_str, bool wait_for_all)
2051 struct srvid_request request;
2052 struct srvid_reply_handler_data reply_data;
2055 ZERO_STRUCT(request);
2057 /* Time ticks to enable timeouts to be processed */
2058 event_add_timed(ctdb->ev, ctdb,
2059 timeval_current_ofs(1, 0),
2060 ctdb_every_second, ctdb);
2062 request.pnn = ctdb_get_pnn(ctdb);
2063 request.srvid = getpid();
2066 /* Register message port for reply from recovery master */
2067 ctdb_client_set_message_handler(ctdb, request.srvid,
2068 srvid_broadcast_reply_handler,
2071 data.dptr = (uint8_t *)&request;
2072 data.dsize = sizeof(request);
2074 reply_data.wait_for_all = wait_for_all;
2075 reply_data.nodes = NULL;
2076 reply_data.srvid_str = srvid_str;
2079 reply_data.done = false;
2082 struct ctdb_node_map *nodemap;
2084 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(),
2085 CTDB_CURRENT_NODE, ctdb, &nodemap);
2088 ("Unable to get nodemap from current node, try again\n"));
2093 if (reply_data.nodes != NULL) {
2094 talloc_free(reply_data.nodes);
2096 reply_data.nodes = list_of_connected_nodes(ctdb, nodemap,
2099 talloc_free(nodemap);
2102 /* Send to all connected nodes. Only recmaster replies */
2103 ret = ctdb_client_send_message(ctdb, CTDB_BROADCAST_CONNECTED,
2106 /* This can only happen if the socket is closed and
2107 * there's no way to recover from that, so don't try
2111 ("Failed to send %s request to connected nodes\n",
2116 tv = timeval_current();
2117 /* This loop terminates the reply is received */
2118 while (timeval_elapsed(&tv) < 5.0 && !reply_data.done) {
2119 event_loop_once(ctdb->ev);
2122 if (!reply_data.done) {
2124 ("Still waiting for confirmation of %s\n", srvid_str));
2129 ctdb_client_remove_message_handler(ctdb, request.srvid, &reply_data);
2131 talloc_free(reply_data.nodes);
2136 static int ipreallocate(struct ctdb_context *ctdb)
2138 return srvid_broadcast(ctdb, CTDB_SRVID_TAKEOVER_RUN, 0,
2139 "IP reallocation", false);
2143 static int control_ipreallocate(struct ctdb_context *ctdb, int argc, const char **argv)
2145 return ipreallocate(ctdb);
2149 add a public ip address to a node
2151 static int control_addip(struct ctdb_context *ctdb, int argc, const char **argv)
2154 int len, retries = 0;
2156 ctdb_sock_addr addr;
2157 struct ctdb_control_ip_iface *pub;
2158 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
2159 struct ctdb_all_public_ips *ips;
2163 talloc_free(tmp_ctx);
2167 if (!parse_ip_mask(argv[0], argv[1], &addr, &mask)) {
2168 DEBUG(DEBUG_ERR, ("Badly formed ip/mask : %s\n", argv[0]));
2169 talloc_free(tmp_ctx);
2173 /* read the public ip list from the node */
2174 ret = ctdb_ctrl_get_public_ips(ctdb, TIMELIMIT(), options.pnn, tmp_ctx, &ips);
2176 DEBUG(DEBUG_ERR, ("Unable to get public ip list from node %u\n", options.pnn));
2177 talloc_free(tmp_ctx);
2180 for (i=0;i<ips->num;i++) {
2181 if (ctdb_same_ip(&addr, &ips->ips[i].addr)) {
2182 DEBUG(DEBUG_ERR,("Can not add ip to node. Node already hosts this ip\n"));
2189 /* Dont timeout. This command waits for an ip reallocation
2190 which sometimes can take wuite a while if there has
2191 been a recent recovery
2195 len = offsetof(struct ctdb_control_ip_iface, iface) + strlen(argv[1]) + 1;
2196 pub = talloc_size(tmp_ctx, len);
2197 CTDB_NO_MEMORY(ctdb, pub);
2201 pub->len = strlen(argv[1])+1;
2202 memcpy(&pub->iface[0], argv[1], strlen(argv[1])+1);
2205 ret = ctdb_ctrl_add_public_ip(ctdb, TIMELIMIT(), options.pnn, pub);
2207 DEBUG(DEBUG_ERR, ("Unable to add public ip to node %u. Wait 3 seconds and try again.\n", options.pnn));
2211 } while (retries < 5 && ret != 0);
2213 DEBUG(DEBUG_ERR, ("Unable to add public ip to node %u. Giving up.\n", options.pnn));
2214 talloc_free(tmp_ctx);
2218 if (rebalance_node(ctdb, options.pnn) != 0) {
2219 DEBUG(DEBUG_ERR,("Error when trying to rebalance node\n"));
2223 talloc_free(tmp_ctx);
2228 add a public ip address to a node
2230 static int control_ipiface(struct ctdb_context *ctdb, int argc, const char **argv)
2232 ctdb_sock_addr addr;
2238 if (!parse_ip(argv[0], NULL, 0, &addr)) {
2239 printf("Badly formed ip : %s\n", argv[0]);
2243 printf("IP on interface %s\n", ctdb_sys_find_ifname(&addr));
2248 static int control_delip(struct ctdb_context *ctdb, int argc, const char **argv);
2250 static int control_delip_all(struct ctdb_context *ctdb, int argc, const char **argv, ctdb_sock_addr *addr)
2252 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
2253 struct ctdb_node_map *nodemap=NULL;
2254 struct ctdb_all_public_ips *ips;
2257 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, tmp_ctx, &nodemap);
2259 DEBUG(DEBUG_ERR, ("Unable to get nodemap from current node\n"));
2263 /* remove it from the nodes that are not hosting the ip currently */
2264 for(i=0;i<nodemap->num;i++){
2265 if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
2268 if (ctdb_ctrl_get_public_ips(ctdb, TIMELIMIT(), nodemap->nodes[i].pnn, tmp_ctx, &ips) != 0) {
2269 DEBUG(DEBUG_ERR, ("Unable to get public ip list from node %d\n", nodemap->nodes[i].pnn));
2273 for (j=0;j<ips->num;j++) {
2274 if (ctdb_same_ip(addr, &ips->ips[j].addr)) {
2282 if (ips->ips[j].pnn == nodemap->nodes[i].pnn) {
2286 options.pnn = nodemap->nodes[i].pnn;
2287 control_delip(ctdb, argc, argv);
2291 /* remove it from every node (also the one hosting it) */
2292 for(i=0;i<nodemap->num;i++){
2293 if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
2296 if (ctdb_ctrl_get_public_ips(ctdb, TIMELIMIT(), nodemap->nodes[i].pnn, tmp_ctx, &ips) != 0) {
2297 DEBUG(DEBUG_ERR, ("Unable to get public ip list from node %d\n", nodemap->nodes[i].pnn));
2301 for (j=0;j<ips->num;j++) {
2302 if (ctdb_same_ip(addr, &ips->ips[j].addr)) {
2310 options.pnn = nodemap->nodes[i].pnn;
2311 control_delip(ctdb, argc, argv);
2314 talloc_free(tmp_ctx);
2319 delete a public ip address from a node
2321 static int control_delip(struct ctdb_context *ctdb, int argc, const char **argv)
2324 ctdb_sock_addr addr;
2325 struct ctdb_control_ip_iface pub;
2326 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
2327 struct ctdb_all_public_ips *ips;
2330 talloc_free(tmp_ctx);
2334 if (parse_ip(argv[0], NULL, 0, &addr) == 0) {
2335 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
2339 if (options.pnn == CTDB_BROADCAST_ALL) {
2340 return control_delip_all(ctdb, argc, argv, &addr);
2347 ret = ctdb_ctrl_get_public_ips(ctdb, TIMELIMIT(), options.pnn, tmp_ctx, &ips);
2349 DEBUG(DEBUG_ERR, ("Unable to get public ip list from cluster\n"));
2350 talloc_free(tmp_ctx);
2354 for (i=0;i<ips->num;i++) {
2355 if (ctdb_same_ip(&addr, &ips->ips[i].addr)) {
2361 DEBUG(DEBUG_ERR, ("This node does not support this public address '%s'\n",
2362 ctdb_addr_to_str(&addr)));
2363 talloc_free(tmp_ctx);
2367 /* This is an optimisation. If this node is hosting the IP
2368 * then try to move it somewhere else without invoking a full
2369 * takeover run. We don't care if this doesn't work!
2371 if (ips->ips[i].pnn == options.pnn) {
2372 (void) try_moveip(ctdb, &addr, -1);
2375 ret = ctdb_ctrl_del_public_ip(ctdb, TIMELIMIT(), options.pnn, &pub);
2377 DEBUG(DEBUG_ERR, ("Unable to del public ip from node %u\n", options.pnn));
2378 talloc_free(tmp_ctx);
2382 talloc_free(tmp_ctx);
2386 static int kill_tcp_from_file(struct ctdb_context *ctdb,
2387 int argc, const char **argv)
2389 struct ctdb_control_killtcp *killtcp;
2390 int max_entries, current, i;
2391 struct timeval timeout;
2392 char line[128], src[128], dst[128];
2395 struct client_async_data *async_data;
2396 struct ctdb_client_control_state *state;
2406 while (!feof(stdin)) {
2407 if (fgets(line, sizeof(line), stdin) == NULL) {
2411 /* Silently skip empty lines */
2412 if (line[0] == '\n') {
2416 if (sscanf(line, "%s %s\n", src, dst) != 2) {
2417 DEBUG(DEBUG_ERR, ("Bad line [%d]: '%s'\n",
2419 talloc_free(killtcp);
2423 if (current >= max_entries) {
2424 max_entries += 1024;
2425 killtcp = talloc_realloc(ctdb, killtcp,
2426 struct ctdb_control_killtcp,
2428 CTDB_NO_MEMORY(ctdb, killtcp);
2431 if (!parse_ip_port(src, &killtcp[current].src_addr)) {
2432 DEBUG(DEBUG_ERR, ("Bad IP:port on line [%d]: '%s'\n",
2434 talloc_free(killtcp);
2438 if (!parse_ip_port(dst, &killtcp[current].dst_addr)) {
2439 DEBUG(DEBUG_ERR, ("Bad IP:port on line [%d]: '%s'\n",
2441 talloc_free(killtcp);
2448 async_data = talloc_zero(ctdb, struct client_async_data);
2449 if (async_data == NULL) {
2450 talloc_free(killtcp);
2454 for (i = 0; i < current; i++) {
2456 data.dsize = sizeof(struct ctdb_control_killtcp);
2457 data.dptr = (unsigned char *)&killtcp[i];
2459 timeout = TIMELIMIT();
2460 state = ctdb_control_send(ctdb, options.pnn, 0,
2461 CTDB_CONTROL_KILL_TCP, 0, data,
2462 async_data, &timeout, NULL);
2464 if (state == NULL) {
2466 ("Failed to call async killtcp control to node %u\n",
2468 talloc_free(killtcp);
2472 ctdb_client_async_add(async_data, state);
2475 if (ctdb_client_async_wait(ctdb, async_data) != 0) {
2476 DEBUG(DEBUG_ERR,("killtcp failed\n"));
2477 talloc_free(killtcp);
2481 talloc_free(killtcp);
2487 kill a tcp connection
2489 static int kill_tcp(struct ctdb_context *ctdb, int argc, const char **argv)
2492 struct ctdb_control_killtcp killtcp;
2494 assert_single_node_only();
2497 return kill_tcp_from_file(ctdb, argc, argv);
2504 if (!parse_ip_port(argv[0], &killtcp.src_addr)) {
2505 DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[0]));
2509 if (!parse_ip_port(argv[1], &killtcp.dst_addr)) {
2510 DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[1]));
2514 ret = ctdb_ctrl_killtcp(ctdb, TIMELIMIT(), options.pnn, &killtcp);
2516 DEBUG(DEBUG_ERR, ("Unable to killtcp from node %u\n", options.pnn));
2527 static int control_gratious_arp(struct ctdb_context *ctdb, int argc, const char **argv)
2530 ctdb_sock_addr addr;
2532 assert_single_node_only();
2538 if (!parse_ip(argv[0], NULL, 0, &addr)) {
2539 DEBUG(DEBUG_ERR, ("Bad IP '%s'\n", argv[0]));
2543 ret = ctdb_ctrl_gratious_arp(ctdb, TIMELIMIT(), options.pnn, &addr, argv[1]);
2545 DEBUG(DEBUG_ERR, ("Unable to send gratious_arp from node %u\n", options.pnn));
2553 register a server id
2555 static int regsrvid(struct ctdb_context *ctdb, int argc, const char **argv)
2558 struct ctdb_server_id server_id;
2564 server_id.pnn = strtoul(argv[0], NULL, 0);
2565 server_id.type = strtoul(argv[1], NULL, 0);
2566 server_id.server_id = strtoul(argv[2], NULL, 0);
2568 ret = ctdb_ctrl_register_server_id(ctdb, TIMELIMIT(), &server_id);
2570 DEBUG(DEBUG_ERR, ("Unable to register server_id from node %u\n", options.pnn));
2573 DEBUG(DEBUG_ERR,("Srvid registered. Sleeping for 999 seconds\n"));
2579 unregister a server id
2581 static int unregsrvid(struct ctdb_context *ctdb, int argc, const char **argv)
2584 struct ctdb_server_id server_id;
2590 server_id.pnn = strtoul(argv[0], NULL, 0);
2591 server_id.type = strtoul(argv[1], NULL, 0);
2592 server_id.server_id = strtoul(argv[2], NULL, 0);
2594 ret = ctdb_ctrl_unregister_server_id(ctdb, TIMELIMIT(), &server_id);
2596 DEBUG(DEBUG_ERR, ("Unable to unregister server_id from node %u\n", options.pnn));
2603 check if a server id exists
2605 static int chksrvid(struct ctdb_context *ctdb, int argc, const char **argv)
2609 struct ctdb_server_id server_id;
2615 server_id.pnn = strtoul(argv[0], NULL, 0);
2616 server_id.type = strtoul(argv[1], NULL, 0);
2617 server_id.server_id = strtoul(argv[2], NULL, 0);
2619 ret = ctdb_ctrl_check_server_id(ctdb, TIMELIMIT(), options.pnn, &server_id, &status);
2621 DEBUG(DEBUG_ERR, ("Unable to check server_id from node %u\n", options.pnn));
2626 printf("Server id %d:%d:%d EXISTS\n", server_id.pnn, server_id.type, server_id.server_id);
2628 printf("Server id %d:%d:%d does NOT exist\n", server_id.pnn, server_id.type, server_id.server_id);
2634 get a list of all server ids that are registered on a node
2636 static int getsrvids(struct ctdb_context *ctdb, int argc, const char **argv)
2639 struct ctdb_server_id_list *server_ids;
2641 ret = ctdb_ctrl_get_server_id_list(ctdb, ctdb, TIMELIMIT(), options.pnn, &server_ids);
2643 DEBUG(DEBUG_ERR, ("Unable to get server_id list from node %u\n", options.pnn));
2647 for (i=0; i<server_ids->num; i++) {
2648 printf("Server id %d:%d:%d\n",
2649 server_ids->server_ids[i].pnn,
2650 server_ids->server_ids[i].type,
2651 server_ids->server_ids[i].server_id);
2658 check if a server id exists
2660 static int check_srvids(struct ctdb_context *ctdb, int argc, const char **argv)
2662 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
2668 talloc_free(tmp_ctx);
2672 ids = talloc_array(tmp_ctx, uint64_t, argc);
2673 result = talloc_array(tmp_ctx, uint8_t, argc);
2675 for (i = 0; i < argc; i++) {
2676 ids[i] = strtoull(argv[i], NULL, 0);
2679 if (!ctdb_check_message_handlers(ctdb_connection,
2680 options.pnn, argc, ids, result)) {
2681 DEBUG(DEBUG_ERR, ("Unable to check server_id from node %u\n",
2683 talloc_free(tmp_ctx);
2687 for (i=0; i < argc; i++) {
2688 printf("Server id %d:%llu %s\n", options.pnn, (long long)ids[i],
2689 result[i] ? "exists" : "does not exist");
2692 talloc_free(tmp_ctx);
2697 send a tcp tickle ack
2699 static int tickle_tcp(struct ctdb_context *ctdb, int argc, const char **argv)
2702 ctdb_sock_addr src, dst;
2708 if (!parse_ip_port(argv[0], &src)) {
2709 DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[0]));
2713 if (!parse_ip_port(argv[1], &dst)) {
2714 DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[1]));
2718 ret = ctdb_sys_send_tcp(&src, &dst, 0, 0, 0);
2722 DEBUG(DEBUG_ERR, ("Error while sending tickle ack\n"));
2729 display public ip status
2731 static int control_ip(struct ctdb_context *ctdb, int argc, const char **argv)
2734 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
2735 struct ctdb_all_public_ips *ips;
2737 if (options.pnn == CTDB_BROADCAST_ALL) {
2738 /* read the list of public ips from all nodes */
2739 ret = control_get_all_public_ips(ctdb, tmp_ctx, &ips);
2741 /* read the public ip list from this node */
2742 ret = ctdb_ctrl_get_public_ips(ctdb, TIMELIMIT(), options.pnn, tmp_ctx, &ips);
2745 DEBUG(DEBUG_ERR, ("Unable to get public ips from node %u\n", options.pnn));
2746 talloc_free(tmp_ctx);
2750 if (options.machinereadable){
2751 printf(":Public IP:Node:");
2752 if (options.verbose){
2753 printf("ActiveInterface:AvailableInterfaces:ConfiguredInterfaces:");
2757 if (options.pnn == CTDB_BROADCAST_ALL) {
2758 printf("Public IPs on ALL nodes\n");
2760 printf("Public IPs on node %u\n", options.pnn);
2764 for (i=1;i<=ips->num;i++) {
2765 struct ctdb_control_public_ip_info *info = NULL;
2767 char *aciface = NULL;
2768 char *avifaces = NULL;
2769 char *cifaces = NULL;
2771 if (options.pnn == CTDB_BROADCAST_ALL) {
2772 pnn = ips->ips[ips->num-i].pnn;
2778 ret = ctdb_ctrl_get_public_ip_info(ctdb, TIMELIMIT(), pnn, ctdb,
2779 &ips->ips[ips->num-i].addr, &info);
2786 for (j=0; j < info->num; j++) {
2787 if (cifaces == NULL) {
2788 cifaces = talloc_strdup(info,
2789 info->ifaces[j].name);
2791 cifaces = talloc_asprintf_append(cifaces,
2793 info->ifaces[j].name);
2796 if (info->active_idx == j) {
2797 aciface = info->ifaces[j].name;
2800 if (info->ifaces[j].link_state == 0) {
2804 if (avifaces == NULL) {
2805 avifaces = talloc_strdup(info, info->ifaces[j].name);
2807 avifaces = talloc_asprintf_append(avifaces,
2809 info->ifaces[j].name);
2814 if (options.machinereadable){
2816 ctdb_addr_to_str(&ips->ips[ips->num-i].addr),
2817 ips->ips[ips->num-i].pnn);
2818 if (options.verbose){
2821 avifaces?avifaces:"",
2822 cifaces?cifaces:"");
2826 if (options.verbose) {
2827 printf("%s node[%d] active[%s] available[%s] configured[%s]\n",
2828 ctdb_addr_to_str(&ips->ips[ips->num-i].addr),
2829 ips->ips[ips->num-i].pnn,
2831 avifaces?avifaces:"",
2832 cifaces?cifaces:"");
2835 ctdb_addr_to_str(&ips->ips[ips->num-i].addr),
2836 ips->ips[ips->num-i].pnn);
2842 talloc_free(tmp_ctx);
2849 static int control_ipinfo(struct ctdb_context *ctdb, int argc, const char **argv)
2852 ctdb_sock_addr addr;
2853 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
2854 struct ctdb_control_public_ip_info *info;
2857 talloc_free(tmp_ctx);
2861 if (parse_ip(argv[0], NULL, 0, &addr) == 0) {
2862 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
2866 /* read the public ip info from this node */
2867 ret = ctdb_ctrl_get_public_ip_info(ctdb, TIMELIMIT(), options.pnn,
2868 tmp_ctx, &addr, &info);
2870 DEBUG(DEBUG_ERR, ("Unable to get public ip[%s]info from node %u\n",
2871 argv[0], options.pnn));
2872 talloc_free(tmp_ctx);
2876 printf("Public IP[%s] info on node %u\n",
2877 ctdb_addr_to_str(&info->ip.addr),
2880 printf("IP:%s\nCurrentNode:%d\nNumInterfaces:%u\n",
2881 ctdb_addr_to_str(&info->ip.addr),
2882 info->ip.pnn, info->num);
2884 for (i=0; i<info->num; i++) {
2885 info->ifaces[i].name[CTDB_IFACE_SIZE] = '\0';
2887 printf("Interface[%u]: Name:%s Link:%s References:%u%s\n",
2888 i+1, info->ifaces[i].name,
2889 info->ifaces[i].link_state?"up":"down",
2890 (unsigned int)info->ifaces[i].references,
2891 (i==info->active_idx)?" (active)":"");
2894 talloc_free(tmp_ctx);
2899 display interfaces status
2901 static int control_ifaces(struct ctdb_context *ctdb, int argc, const char **argv)
2904 struct ctdb_ifaces_list *ifaces;
2906 /* read the public ip list from this node */
2907 if (!ctdb_getifaces(ctdb_connection, options.pnn, &ifaces)) {
2908 DEBUG(DEBUG_ERR, ("Unable to get interfaces from node %u\n",
2913 if (options.machinereadable){
2914 printf(":Name:LinkStatus:References:\n");
2916 printf("Interfaces on node %u\n", options.pnn);
2919 for (i=0; i<ifaces->num; i++) {
2920 if (options.machinereadable){
2921 printf(":%s:%s:%u\n",
2922 ifaces->ifaces[i].name,
2923 ifaces->ifaces[i].link_state?"1":"0",
2924 (unsigned int)ifaces->ifaces[i].references);
2926 printf("name:%s link:%s references:%u\n",
2927 ifaces->ifaces[i].name,
2928 ifaces->ifaces[i].link_state?"up":"down",
2929 (unsigned int)ifaces->ifaces[i].references);
2933 ctdb_free_ifaces(ifaces);
2939 set link status of an interface
2941 static int control_setifacelink(struct ctdb_context *ctdb, int argc, const char **argv)
2944 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
2945 struct ctdb_control_iface_info info;
2953 if (strlen(argv[0]) > CTDB_IFACE_SIZE) {
2954 DEBUG(DEBUG_ERR, ("interfaces name '%s' too long\n",
2956 talloc_free(tmp_ctx);
2959 strcpy(info.name, argv[0]);
2961 if (strcmp(argv[1], "up") == 0) {
2962 info.link_state = 1;
2963 } else if (strcmp(argv[1], "down") == 0) {
2964 info.link_state = 0;
2966 DEBUG(DEBUG_ERR, ("link state invalid '%s' should be 'up' or 'down'\n",
2968 talloc_free(tmp_ctx);
2972 /* read the public ip list from this node */
2973 ret = ctdb_ctrl_set_iface_link(ctdb, TIMELIMIT(), options.pnn,
2976 DEBUG(DEBUG_ERR, ("Unable to set link state for interfaces %s node %u\n",
2977 argv[0], options.pnn));
2978 talloc_free(tmp_ctx);
2982 talloc_free(tmp_ctx);
2987 display pid of a ctdb daemon
2989 static int control_getpid(struct ctdb_context *ctdb, int argc, const char **argv)
2994 ret = ctdb_ctrl_getpid(ctdb, TIMELIMIT(), options.pnn, &pid);
2996 DEBUG(DEBUG_ERR, ("Unable to get daemon pid from node %u\n", options.pnn));
2999 printf("Pid:%d\n", pid);
3004 typedef bool update_flags_handler_t(struct ctdb_context *ctdb, void *data);
3006 static int update_flags_and_ipreallocate(struct ctdb_context *ctdb,
3008 update_flags_handler_t handler,
3013 struct ctdb_node_map *nodemap = NULL;
3016 /* Check if the node is already in the desired state */
3017 if (ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, ctdb, &nodemap) != 0) {
3018 DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node\n"));
3021 flag_is_set = nodemap->nodes[options.pnn].flags & flag;
3022 if (set_flag == flag_is_set) {
3023 DEBUG(DEBUG_NOTICE, ("Node %d is %s %s\n", options.pnn,
3024 (set_flag ? "already" : "not"), desc));
3029 if (!handler(ctdb, data)) {
3030 DEBUG(DEBUG_WARNING,
3031 ("Failed to send control to set state %s on node %u, try again\n",
3032 desc, options.pnn));
3037 /* Read the nodemap and verify the change took effect.
3038 * Even if the above control/hanlder timed out then it
3039 * could still have worked!
3041 if (ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE,
3042 ctdb, &nodemap) != 0) {
3043 DEBUG(DEBUG_WARNING,
3044 ("Unable to get nodemap from local node, try again\n"));
3046 flag_is_set = nodemap->nodes[options.pnn].flags & flag;
3047 } while (nodemap == NULL || (set_flag != flag_is_set));
3049 return ipreallocate(ctdb);
3052 /* Administratively disable a node */
3053 static bool update_flags_disabled(struct ctdb_context *ctdb, void *data)
3055 return ctdb_ctrl_modflags(ctdb, TIMELIMIT(), options.pnn,
3056 NODE_FLAGS_PERMANENTLY_DISABLED, 0) == 0;
3059 static int control_disable(struct ctdb_context *ctdb, int argc, const char **argv)
3061 return update_flags_and_ipreallocate(ctdb, NULL,
3062 update_flags_disabled,
3063 NODE_FLAGS_PERMANENTLY_DISABLED,
3065 true /* set_flag*/);
3068 /* Administratively re-enable a node */
3069 static bool update_flags_not_disabled(struct ctdb_context *ctdb, void *data)
3071 return ctdb_ctrl_modflags(ctdb, TIMELIMIT(), options.pnn,
3072 0, NODE_FLAGS_PERMANENTLY_DISABLED) == 0;
3075 static int control_enable(struct ctdb_context *ctdb, int argc, const char **argv)
3077 return update_flags_and_ipreallocate(ctdb, NULL,
3078 update_flags_not_disabled,
3079 NODE_FLAGS_PERMANENTLY_DISABLED,
3081 false /* set_flag*/);
3085 static bool update_flags_stopped(struct ctdb_context *ctdb, void *data)
3087 return ctdb_ctrl_stop_node(ctdb, TIMELIMIT(), options.pnn) == 0;
3090 static int control_stop(struct ctdb_context *ctdb, int argc, const char **argv)
3092 return update_flags_and_ipreallocate(ctdb, NULL,
3093 update_flags_stopped,
3096 true /* set_flag*/);
3099 /* Continue a stopped node */
3100 static bool update_flags_not_stopped(struct ctdb_context *ctdb, void *data)
3102 return ctdb_ctrl_continue_node(ctdb, TIMELIMIT(), options.pnn) == 0;
3105 static int control_continue(struct ctdb_context *ctdb, int argc, const char **argv)
3107 return update_flags_and_ipreallocate(ctdb, NULL,
3108 update_flags_not_stopped,
3111 false /* set_flag */);
3114 static uint32_t get_generation(struct ctdb_context *ctdb)
3116 struct ctdb_vnn_map *vnnmap=NULL;
3119 /* wait until the recmaster is not in recovery mode */
3121 uint32_t recmode, recmaster;
3123 if (vnnmap != NULL) {
3124 talloc_free(vnnmap);
3128 /* get the recmaster */
3129 if (!ctdb_getrecmaster(ctdb_connection, CTDB_CURRENT_NODE, &recmaster)) {
3130 DEBUG(DEBUG_ERR, ("Unable to get recmaster from node %u\n", options.pnn));
3134 /* get recovery mode */
3135 if (!ctdb_getrecmode(ctdb_connection, recmaster, &recmode)) {
3136 DEBUG(DEBUG_ERR, ("Unable to get recmode from node %u\n", options.pnn));
3140 /* get the current generation number */
3141 ret = ctdb_ctrl_getvnnmap(ctdb, TIMELIMIT(), recmaster, ctdb, &vnnmap);
3143 DEBUG(DEBUG_ERR, ("Unable to get vnnmap from recmaster (%u)\n", recmaster));
3147 if ((recmode == CTDB_RECOVERY_NORMAL)
3148 && (vnnmap->generation != 1)){
3149 return vnnmap->generation;
3156 static bool update_state_banned(struct ctdb_context *ctdb, void *data)
3158 struct ctdb_ban_time *bantime = (struct ctdb_ban_time *)data;
3159 return ctdb_ctrl_set_ban(ctdb, TIMELIMIT(), options.pnn, bantime) == 0;
3162 static int control_ban(struct ctdb_context *ctdb, int argc, const char **argv)
3164 struct ctdb_ban_time bantime;
3170 bantime.pnn = options.pnn;
3171 bantime.time = strtoul(argv[0], NULL, 0);
3173 return update_flags_and_ipreallocate(ctdb, &bantime,
3174 update_state_banned,
3177 true /* set_flag*/);
3182 static int control_unban(struct ctdb_context *ctdb, int argc, const char **argv)
3184 struct ctdb_ban_time bantime;
3186 bantime.pnn = options.pnn;
3189 return update_flags_and_ipreallocate(ctdb, &bantime,
3190 update_state_banned,
3193 false /* set_flag*/);
3197 show ban information for a node
3199 static int control_showban(struct ctdb_context *ctdb, int argc, const char **argv)
3202 struct ctdb_node_map *nodemap=NULL;
3203 struct ctdb_ban_time *bantime;
3205 /* verify the node exists */
3206 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, ctdb, &nodemap);
3208 DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node\n"));
3212 ret = ctdb_ctrl_get_ban(ctdb, TIMELIMIT(), options.pnn, ctdb, &bantime);
3214 DEBUG(DEBUG_ERR,("Showing ban info for node %d failed.\n", options.pnn));
3218 if (bantime->time == 0) {
3219 printf("Node %u is not banned\n", bantime->pnn);
3221 printf("Node %u is banned, %d seconds remaining\n",
3222 bantime->pnn, bantime->time);
3231 static int control_shutdown(struct ctdb_context *ctdb, int argc, const char **argv)
3235 ret = ctdb_ctrl_shutdown(ctdb, TIMELIMIT(), options.pnn);
3237 DEBUG(DEBUG_ERR, ("Unable to shutdown node %u\n", options.pnn));
3247 static int control_recover(struct ctdb_context *ctdb, int argc, const char **argv)
3250 uint32_t generation, next_generation;
3253 /* "force" option ignores freeze failure and forces recovery */
3254 force = (argc == 1) && (strcasecmp(argv[0], "force") == 0);
3256 /* record the current generation number */
3257 generation = get_generation(ctdb);
3259 ret = ctdb_ctrl_freeze_priority(ctdb, TIMELIMIT(), options.pnn, 1);
3262 DEBUG(DEBUG_ERR, ("Unable to freeze node\n"));
3265 DEBUG(DEBUG_WARNING, ("Unable to freeze node but proceeding because \"force\" option given\n"));
3268 ret = ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
3270 DEBUG(DEBUG_ERR, ("Unable to set recovery mode\n"));
3274 /* wait until we are in a new generation */
3276 next_generation = get_generation(ctdb);
3277 if (next_generation != generation) {
3288 display monitoring mode of a remote node
3290 static int control_getmonmode(struct ctdb_context *ctdb, int argc, const char **argv)
3295 ret = ctdb_ctrl_getmonmode(ctdb, TIMELIMIT(), options.pnn, &monmode);
3297 DEBUG(DEBUG_ERR, ("Unable to get monmode from node %u\n", options.pnn));
3300 if (!options.machinereadable){
3301 printf("Monitoring mode:%s (%d)\n",monmode==CTDB_MONITORING_ACTIVE?"ACTIVE":"DISABLED",monmode);
3304 printf(":%d:\n",monmode);
3311 display capabilities of a remote node
3313 static int control_getcapabilities(struct ctdb_context *ctdb, int argc, const char **argv)
3315 uint32_t capabilities;
3317 if (!ctdb_getcapabilities(ctdb_connection, options.pnn, &capabilities)) {
3318 DEBUG(DEBUG_ERR, ("Unable to get capabilities from node %u\n", options.pnn));
3322 if (!options.machinereadable){
3323 printf("RECMASTER: %s\n", (capabilities&CTDB_CAP_RECMASTER)?"YES":"NO");
3324 printf("LMASTER: %s\n", (capabilities&CTDB_CAP_LMASTER)?"YES":"NO");
3325 printf("LVS: %s\n", (capabilities&CTDB_CAP_LVS)?"YES":"NO");
3326 printf("NATGW: %s\n", (capabilities&CTDB_CAP_NATGW)?"YES":"NO");
3328 printf(":RECMASTER:LMASTER:LVS:NATGW:\n");
3329 printf(":%d:%d:%d:%d:\n",
3330 !!(capabilities&CTDB_CAP_RECMASTER),
3331 !!(capabilities&CTDB_CAP_LMASTER),
3332 !!(capabilities&CTDB_CAP_LVS),
3333 !!(capabilities&CTDB_CAP_NATGW));
3339 display lvs configuration
3341 static int control_lvs(struct ctdb_context *ctdb, int argc, const char **argv)
3343 uint32_t *capabilities;
3344 struct ctdb_node_map *nodemap=NULL;
3346 int healthy_count = 0;
3348 if (!ctdb_getnodemap(ctdb_connection, options.pnn, &nodemap)) {
3349 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
3353 capabilities = talloc_array(ctdb, uint32_t, nodemap->num);
3354 CTDB_NO_MEMORY(ctdb, capabilities);
3358 /* collect capabilities for all connected nodes */
3359 for (i=0; i<nodemap->num; i++) {
3360 if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
3363 if (nodemap->nodes[i].flags & NODE_FLAGS_PERMANENTLY_DISABLED) {
3367 if (!ctdb_getcapabilities(ctdb_connection, i, &capabilities[i])) {
3368 DEBUG(DEBUG_ERR, ("Unable to get capabilities from node %u\n", i));
3373 if (!(capabilities[i] & CTDB_CAP_LVS)) {
3377 if (!(nodemap->nodes[i].flags & NODE_FLAGS_UNHEALTHY)) {
3382 /* Print all LVS nodes */
3383 for (i=0; i<nodemap->num; i++) {
3384 if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
3387 if (nodemap->nodes[i].flags & NODE_FLAGS_PERMANENTLY_DISABLED) {
3390 if (!(capabilities[i] & CTDB_CAP_LVS)) {
3394 if (healthy_count != 0) {
3395 if (nodemap->nodes[i].flags & NODE_FLAGS_UNHEALTHY) {
3400 printf("%d:%s\n", i,
3401 ctdb_addr_to_str(&nodemap->nodes[i].addr));
3405 ctdb_free_nodemap(nodemap);
3410 display who is the lvs master
3412 static int control_lvsmaster(struct ctdb_context *ctdb, int argc, const char **argv)
3414 uint32_t *capabilities;
3415 struct ctdb_node_map *nodemap=NULL;
3417 int healthy_count = 0;
3419 if (!ctdb_getnodemap(ctdb_connection, options.pnn, &nodemap)) {
3420 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
3424 capabilities = talloc_array(ctdb, uint32_t, nodemap->num);
3425 CTDB_NO_MEMORY(ctdb, capabilities);
3429 /* collect capabilities for all connected nodes */
3430 for (i=0; i<nodemap->num; i++) {
3431 if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
3434 if (nodemap->nodes[i].flags & NODE_FLAGS_PERMANENTLY_DISABLED) {
3438 if (!ctdb_getcapabilities(ctdb_connection, i, &capabilities[i])) {
3439 DEBUG(DEBUG_ERR, ("Unable to get capabilities from node %u\n", i));
3444 if (!(capabilities[i] & CTDB_CAP_LVS)) {
3448 if (!(nodemap->nodes[i].flags & NODE_FLAGS_UNHEALTHY)) {
3453 /* find and show the lvsmaster */
3454 for (i=0; i<nodemap->num; i++) {
3455 if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
3458 if (nodemap->nodes[i].flags & NODE_FLAGS_PERMANENTLY_DISABLED) {
3461 if (!(capabilities[i] & CTDB_CAP_LVS)) {
3465 if (healthy_count != 0) {
3466 if (nodemap->nodes[i].flags & NODE_FLAGS_UNHEALTHY) {
3471 if (options.machinereadable){
3474 printf("Node %d is LVS master\n", i);
3480 printf("There is no LVS master\n");
3482 ctdb_free_nodemap(nodemap);
3487 disable monitoring on a node
3489 static int control_disable_monmode(struct ctdb_context *ctdb, int argc, const char **argv)
3494 ret = ctdb_ctrl_disable_monmode(ctdb, TIMELIMIT(), options.pnn);
3496 DEBUG(DEBUG_ERR, ("Unable to disable monmode on node %u\n", options.pnn));
3499 printf("Monitoring mode:%s\n","DISABLED");
3505 enable monitoring on a node
3507 static int control_enable_monmode(struct ctdb_context *ctdb, int argc, const char **argv)
3512 ret = ctdb_ctrl_enable_monmode(ctdb, TIMELIMIT(), options.pnn);
3514 DEBUG(DEBUG_ERR, ("Unable to enable monmode on node %u\n", options.pnn));
3517 printf("Monitoring mode:%s\n","ACTIVE");
3523 display remote list of keys/data for a db
3525 static int control_catdb(struct ctdb_context *ctdb, int argc, const char **argv)
3527 const char *db_name;
3528 struct ctdb_db_context *ctdb_db;
3530 struct ctdb_dump_db_context c;
3539 if (!db_exists(ctdb, db_name, NULL, &flags)) {
3543 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), db_name, flags & CTDB_DB_FLAGS_PERSISTENT, 0);
3544 if (ctdb_db == NULL) {
3545 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
3549 if (options.printlmaster) {
3550 ret = ctdb_ctrl_getvnnmap(ctdb, TIMELIMIT(), options.pnn,
3551 ctdb, &ctdb->vnn_map);
3553 DEBUG(DEBUG_ERR, ("Unable to get vnnmap from node %u\n",
3561 c.printemptyrecords = (bool)options.printemptyrecords;
3562 c.printdatasize = (bool)options.printdatasize;
3563 c.printlmaster = (bool)options.printlmaster;
3564 c.printhash = (bool)options.printhash;
3565 c.printrecordflags = (bool)options.printrecordflags;
3567 /* traverse and dump the cluster tdb */
3568 ret = ctdb_dump_db(ctdb_db, &c);
3570 DEBUG(DEBUG_ERR, ("Unable to dump database\n"));
3571 DEBUG(DEBUG_ERR, ("Maybe try 'ctdb getdbstatus %s'"
3572 " and 'ctdb getvar AllowUnhealthyDBRead'\n",
3576 talloc_free(ctdb_db);
3578 printf("Dumped %d records\n", ret);
3582 struct cattdb_data {
3583 struct ctdb_context *ctdb;
3587 static int cattdb_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *private_data)
3589 struct cattdb_data *d = private_data;
3590 struct ctdb_dump_db_context c;
3596 c.printemptyrecords = (bool)options.printemptyrecords;
3597 c.printdatasize = (bool)options.printdatasize;
3598 c.printlmaster = false;
3599 c.printhash = (bool)options.printhash;
3600 c.printrecordflags = true;
3602 return ctdb_dumpdb_record(d->ctdb, key, data, &c);
3606 cat the local tdb database using same format as catdb
3608 static int control_cattdb(struct ctdb_context *ctdb, int argc, const char **argv)
3610 const char *db_name;
3611 struct ctdb_db_context *ctdb_db;
3612 struct cattdb_data d;
3621 if (!db_exists(ctdb, db_name, NULL, &flags)) {
3625 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), db_name, flags & CTDB_DB_FLAGS_PERSISTENT, 0);
3626 if (ctdb_db == NULL) {
3627 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
3631 /* traverse the local tdb */
3634 if (tdb_traverse_read(ctdb_db->ltdb->tdb, cattdb_traverse, &d) == -1) {
3635 printf("Failed to cattdb data\n");
3638 talloc_free(ctdb_db);
3640 printf("Dumped %d records\n", d.count);
3645 display the content of a database key
3647 static int control_readkey(struct ctdb_context *ctdb, int argc, const char **argv)
3649 const char *db_name;
3650 struct ctdb_db_context *ctdb_db;
3651 struct ctdb_record_handle *h;
3652 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
3662 if (!db_exists(ctdb, db_name, NULL, &flags)) {
3666 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), db_name, flags & CTDB_DB_FLAGS_PERSISTENT, 0);
3667 if (ctdb_db == NULL) {
3668 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
3672 key.dptr = discard_const(argv[1]);
3673 key.dsize = strlen((char *)key.dptr);
3675 h = ctdb_fetch_lock(ctdb_db, tmp_ctx, key, &data);
3677 printf("Failed to fetch record '%s' on node %d\n",
3678 (const char *)key.dptr, ctdb_get_pnn(ctdb));
3679 talloc_free(tmp_ctx);
3683 printf("Data: size:%d ptr:[%s]\n", (int)data.dsize, data.dptr);
3685 talloc_free(ctdb_db);
3686 talloc_free(tmp_ctx);
3691 display the content of a database key
3693 static int control_writekey(struct ctdb_context *ctdb, int argc, const char **argv)
3695 const char *db_name;
3696 struct ctdb_db_context *ctdb_db;
3697 struct ctdb_record_handle *h;
3698 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
3708 if (!db_exists(ctdb, db_name, NULL, &flags)) {
3712 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), db_name, flags & CTDB_DB_FLAGS_PERSISTENT, 0);
3713 if (ctdb_db == NULL) {
3714 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
3718 key.dptr = discard_const(argv[1]);
3719 key.dsize = strlen((char *)key.dptr);
3721 h = ctdb_fetch_lock(ctdb_db, tmp_ctx, key, &data);
3723 printf("Failed to fetch record '%s' on node %d\n",
3724 (const char *)key.dptr, ctdb_get_pnn(ctdb));
3725 talloc_free(tmp_ctx);
3729 data.dptr = discard_const(argv[2]);
3730 data.dsize = strlen((char *)data.dptr);
3732 if (ctdb_record_store(h, data) != 0) {
3733 printf("Failed to store record\n");
3737 talloc_free(ctdb_db);
3738 talloc_free(tmp_ctx);
3743 fetch a record from a persistent database
3745 static int control_pfetch(struct ctdb_context *ctdb, int argc, const char **argv)
3747 const char *db_name;
3748 struct ctdb_db_context *ctdb_db;
3749 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
3750 struct ctdb_transaction_handle *h;
3757 talloc_free(tmp_ctx);
3763 if (!db_exists(ctdb, db_name, NULL, &flags)) {
3764 talloc_free(tmp_ctx);
3768 persistent = flags & CTDB_DB_FLAGS_PERSISTENT;
3770 DEBUG(DEBUG_ERR,("Database '%s' is not persistent\n", db_name));
3771 talloc_free(tmp_ctx);
3775 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), db_name, persistent, 0);
3776 if (ctdb_db == NULL) {
3777 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
3778 talloc_free(tmp_ctx);
3782 h = ctdb_transaction_start(ctdb_db, tmp_ctx);
3784 DEBUG(DEBUG_ERR,("Failed to start transaction on database %s\n", db_name));
3785 talloc_free(tmp_ctx);
3789 key.dptr = discard_const(argv[1]);
3790 key.dsize = strlen(argv[1]);
3791 ret = ctdb_transaction_fetch(h, tmp_ctx, key, &data);
3793 DEBUG(DEBUG_ERR,("Failed to fetch record\n"));
3794 talloc_free(tmp_ctx);
3798 if (data.dsize == 0 || data.dptr == NULL) {
3799 DEBUG(DEBUG_ERR,("Record is empty\n"));
3800 talloc_free(tmp_ctx);
3805 fd = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0600);
3807 DEBUG(DEBUG_ERR,("Failed to open output file %s\n", argv[2]));
3808 talloc_free(tmp_ctx);
3811 write(fd, data.dptr, data.dsize);
3814 write(1, data.dptr, data.dsize);
3817 /* abort the transaction */
3821 talloc_free(tmp_ctx);
3826 fetch a record from a tdb-file
3828 static int control_tfetch(struct ctdb_context *ctdb, int argc, const char **argv)
3830 const char *tdb_file;
3833 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
3842 tdb = tdb_open(tdb_file, 0, 0, O_RDONLY, 0);
3844 printf("Failed to open TDB file %s\n", tdb_file);
3848 if (!strncmp(argv[1], "0x", 2)) {
3849 key = hextodata(tmp_ctx, argv[1] + 2);
3850 if (key.dsize == 0) {
3851 printf("Failed to convert \"%s\" into a TDB_DATA\n", argv[1]);
3855 key.dptr = discard_const(argv[1]);
3856 key.dsize = strlen(argv[1]);
3859 data = tdb_fetch(tdb, key);
3860 if (data.dptr == NULL || data.dsize < sizeof(struct ctdb_ltdb_header)) {
3861 printf("Failed to read record %s from tdb %s\n", argv[1], tdb_file);
3869 fd = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0600);
3871 printf("Failed to open output file %s\n", argv[2]);
3874 if (options.verbose){
3875 write(fd, data.dptr, data.dsize);
3877 write(fd, data.dptr+sizeof(struct ctdb_ltdb_header), data.dsize-sizeof(struct ctdb_ltdb_header));
3881 if (options.verbose){
3882 write(1, data.dptr, data.dsize);
3884 write(1, data.dptr+sizeof(struct ctdb_ltdb_header), data.dsize-sizeof(struct ctdb_ltdb_header));
3888 talloc_free(tmp_ctx);
3893 store a record and header to a tdb-file
3895 static int control_tstore(struct ctdb_context *ctdb, int argc, const char **argv)
3897 const char *tdb_file;
3900 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
3908 tdb = tdb_open(tdb_file, 0, 0, O_RDWR, 0);
3910 printf("Failed to open TDB file %s\n", tdb_file);
3914 if (!strncmp(argv[1], "0x", 2)) {
3915 key = hextodata(tmp_ctx, argv[1] + 2);
3916 if (key.dsize == 0) {
3917 printf("Failed to convert \"%s\" into a TDB_DATA\n", argv[1]);
3921 key.dptr = discard_const(argv[1]);
3922 key.dsize = strlen(argv[1]);
3925 if (!strncmp(argv[2], "0x", 2)) {
3926 data = hextodata(tmp_ctx, argv[2] + 2);
3927 if (data.dsize == 0) {
3928 printf("Failed to convert \"%s\" into a TDB_DATA\n", argv[2]);
3932 data.dptr = discard_const(argv[2]);
3933 data.dsize = strlen(argv[2]);
3936 if (data.dsize < sizeof(struct ctdb_ltdb_header)) {
3937 printf("Not enough data. You must specify the full ctdb_ltdb_header too when storing\n");
3940 if (tdb_store(tdb, key, data, TDB_REPLACE) != 0) {
3941 printf("Failed to write record %s to tdb %s\n", argv[1], tdb_file);
3948 talloc_free(tmp_ctx);
3953 write a record to a persistent database
3955 static int control_pstore(struct ctdb_context *ctdb, int argc, const char **argv)
3957 const char *db_name;
3958 struct ctdb_db_context *ctdb_db;
3959 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
3960 struct ctdb_transaction_handle *h;
3966 talloc_free(tmp_ctx);
3970 fd = open(argv[2], O_RDONLY);
3972 DEBUG(DEBUG_ERR,("Failed to open file containing record data : %s %s\n", argv[2], strerror(errno)));
3973 talloc_free(tmp_ctx);
3977 ret = fstat(fd, &st);
3979 DEBUG(DEBUG_ERR,("fstat of file %s failed: %s\n", argv[2], strerror(errno)));
3981 talloc_free(tmp_ctx);
3985 if (!S_ISREG(st.st_mode)) {
3986 DEBUG(DEBUG_ERR,("Not a regular file %s\n", argv[2]));
3988 talloc_free(tmp_ctx);
3992 data.dsize = st.st_size;
3993 if (data.dsize == 0) {
3996 data.dptr = talloc_size(tmp_ctx, data.dsize);
3997 if (data.dptr == NULL) {
3998 DEBUG(DEBUG_ERR,("Failed to talloc %d of memory to store record data\n", (int)data.dsize));
4000 talloc_free(tmp_ctx);
4003 ret = read(fd, data.dptr, data.dsize);
4004 if (ret != data.dsize) {
4005 DEBUG(DEBUG_ERR,("Failed to read %d bytes of record data\n", (int)data.dsize));
4007 talloc_free(tmp_ctx);
4016 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), db_name, true, 0);
4017 if (ctdb_db == NULL) {
4018 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
4019 talloc_free(tmp_ctx);
4023 h = ctdb_transaction_start(ctdb_db, tmp_ctx);
4025 DEBUG(DEBUG_ERR,("Failed to start transaction on database %s\n", db_name));
4026 talloc_free(tmp_ctx);
4030 key.dptr = discard_const(argv[1]);
4031 key.dsize = strlen(argv[1]);
4032 ret = ctdb_transaction_store(h, key, data);
4034 DEBUG(DEBUG_ERR,("Failed to store record\n"));
4035 talloc_free(tmp_ctx);
4039 ret = ctdb_transaction_commit(h);
4041 DEBUG(DEBUG_ERR,("Failed to commit transaction\n"));
4042 talloc_free(tmp_ctx);
4047 talloc_free(tmp_ctx);
4052 * delete a record from a persistent database
4054 static int control_pdelete(struct ctdb_context *ctdb, int argc, const char **argv)
4056 const char *db_name;
4057 struct ctdb_db_context *ctdb_db;
4058 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
4059 struct ctdb_transaction_handle *h;
4066 talloc_free(tmp_ctx);
4072 if (!db_exists(ctdb, db_name, NULL, &flags)) {
4073 talloc_free(tmp_ctx);
4077 persistent = flags & CTDB_DB_FLAGS_PERSISTENT;
4079 DEBUG(DEBUG_ERR, ("Database '%s' is not persistent\n", db_name));
4080 talloc_free(tmp_ctx);
4084 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), db_name, persistent, 0);
4085 if (ctdb_db == NULL) {
4086 DEBUG(DEBUG_ERR, ("Unable to attach to database '%s'\n", db_name));
4087 talloc_free(tmp_ctx);
4091 h = ctdb_transaction_start(ctdb_db, tmp_ctx);
4093 DEBUG(DEBUG_ERR, ("Failed to start transaction on database %s\n", db_name));
4094 talloc_free(tmp_ctx);
4098 key.dptr = discard_const(argv[1]);
4099 key.dsize = strlen(argv[1]);
4100 ret = ctdb_transaction_store(h, key, tdb_null);
4102 DEBUG(DEBUG_ERR, ("Failed to delete record\n"));
4103 talloc_free(tmp_ctx);
4107 ret = ctdb_transaction_commit(h);
4109 DEBUG(DEBUG_ERR, ("Failed to commit transaction\n"));
4110 talloc_free(tmp_ctx);
4114 talloc_free(tmp_ctx);
4119 check if a service is bound to a port or not
4121 static int control_chktcpport(struct ctdb_context *ctdb, int argc, const char **argv)
4126 struct sockaddr_in sin;
4129 printf("Use: ctdb chktcport <port>\n");
4133 port = atoi(argv[0]);
4135 s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
4137 printf("Failed to open local socket\n");
4141 v = fcntl(s, F_GETFL, 0);
4142 fcntl(s, F_SETFL, v | O_NONBLOCK);
4144 bzero(&sin, sizeof(sin));
4145 sin.sin_family = PF_INET;
4146 sin.sin_port = htons(port);
4147 ret = bind(s, (struct sockaddr *)&sin, sizeof(sin));
4150 printf("Failed to bind to local socket: %d %s\n", errno, strerror(errno));
4159 static void log_handler(struct ctdb_context *ctdb, uint64_t srvid,
4160 TDB_DATA data, void *private_data)
4162 DEBUG(DEBUG_ERR,("Log data received\n"));
4163 if (data.dsize > 0) {
4164 printf("%s", data.dptr);
4171 display a list of log messages from the in memory ringbuffer
4173 static int control_getlog(struct ctdb_context *ctdb, int argc, const char **argv)
4177 struct ctdb_get_log_addr log_addr;
4181 /* Process options */
4183 log_addr.pnn = ctdb_get_pnn(ctdb);
4184 log_addr.level = DEBUG_NOTICE;
4185 for (i = 0; i < argc; i++) {
4186 if (strcmp(argv[i], "recoverd") == 0) {
4187 main_daemon = false;
4189 if (isalpha(argv[i][0]) || argv[i][0] == '-') {
4190 log_addr.level = get_debug_by_desc(argv[i]);
4192 log_addr.level = strtol(argv[i], NULL, 0);
4197 /* Our message port is our PID */
4198 log_addr.srvid = getpid();
4200 data.dptr = (unsigned char *)&log_addr;
4201 data.dsize = sizeof(log_addr);
4203 DEBUG(DEBUG_ERR, ("Pulling logs from node %u\n", options.pnn));
4205 ctdb_client_set_message_handler(ctdb, log_addr.srvid, log_handler, NULL);
4208 DEBUG(DEBUG_ERR,("Listen for response on %d\n", (int)log_addr.srvid));
4213 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
4215 ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_GET_LOG,
4216 0, data, tmp_ctx, NULL, &res, NULL, &errmsg);
4217 if (ret != 0 || res != 0) {
4218 DEBUG(DEBUG_ERR,("Failed to get logs - %s\n", errmsg));
4219 talloc_free(tmp_ctx);
4222 talloc_free(tmp_ctx);
4224 ret = ctdb_client_send_message(ctdb, options.pnn,
4225 CTDB_SRVID_GETLOG, data);
4227 DEBUG(DEBUG_ERR,("Failed to send getlog request message to %u\n", options.pnn));
4232 tv = timeval_current();
4233 /* this loop will terminate when we have received the reply */
4234 while (timeval_elapsed(&tv) < (double)options.timelimit) {
4235 event_loop_once(ctdb->ev);
4238 DEBUG(DEBUG_INFO,("Timed out waiting for log data.\n"));
4244 clear the in memory log area
4246 static int control_clearlog(struct ctdb_context *ctdb, int argc, const char **argv)
4250 if (argc == 0 || (argc >= 1 && strcmp(argv[0], "recoverd") != 0)) {
4251 /* "recoverd" not given - get logs from main daemon */
4254 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
4256 ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_CLEAR_LOG,
4257 0, tdb_null, tmp_ctx, NULL, &res, NULL, &errmsg);
4258 if (ret != 0 || res != 0) {
4259 DEBUG(DEBUG_ERR,("Failed to clear logs\n"));
4260 talloc_free(tmp_ctx);
4264 talloc_free(tmp_ctx);
4266 TDB_DATA data; /* unused in recoverd... */
4269 ret = ctdb_client_send_message(ctdb, options.pnn, CTDB_SRVID_CLEARLOG, data);
4271 DEBUG(DEBUG_ERR,("Failed to send clearlog request message to %u\n", options.pnn));
4279 /* Reload public IPs on a specified nodes */
4280 static int control_reloadips(struct ctdb_context *ctdb, int argc, const char **argv)
4285 assert_single_node_only();
4291 /* Determine the nodes where IPs need to be reloaded */
4292 if (!parse_nodestring(ctdb, argc == 1 ? argv[0] : NULL,
4293 options.pnn, true, &nodes, &pnn_mode)) {
4298 /* Disable takeover runs on all connected nodes. A reply
4299 * indicating success is needed from each node so all nodes
4300 * will need to be active. This will retry until maxruntime
4301 * is exceeded, hence no error handling.
4303 * A check could be added to not allow reloading of IPs when
4304 * there are disconnected nodes. However, this should
4305 * probably be left up to the administrator.
4307 srvid_broadcast(ctdb, CTDB_SRVID_DISABLE_TAKEOVER_RUNS, 60,
4308 "Disable takeover runs", true);
4310 /* Now tell all the desired nodes to reload their public IPs.
4311 * Keep trying this until it succeeds. This assumes all
4312 * failures are transient, which might not be true...
4314 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_RELOAD_PUBLIC_IPS,
4315 nodes, 0, LONGTIMELIMIT(),
4317 NULL, NULL, NULL) != 0) {
4319 ("Unable to reload IPs on some nodes, try again.\n"));
4323 /* It isn't strictly necessary to wait until takeover runs are
4324 * re-enabled but doing so can't hurt.
4326 srvid_broadcast(ctdb, CTDB_SRVID_DISABLE_TAKEOVER_RUNS, 0,
4327 "Enable takeover runs", true);
4336 display a list of the databases on a remote ctdb
4338 static int control_getdbmap(struct ctdb_context *ctdb, int argc, const char **argv)
4341 struct ctdb_dbid_map *dbmap=NULL;
4343 ret = ctdb_ctrl_getdbmap(ctdb, TIMELIMIT(), options.pnn, ctdb, &dbmap);
4345 DEBUG(DEBUG_ERR, ("Unable to get dbids from node %u\n", options.pnn));
4349 if(options.machinereadable){
4350 printf(":ID:Name:Path:Persistent:Sticky:Unhealthy:ReadOnly:\n");
4351 for(i=0;i<dbmap->num;i++){
4359 ctdb_ctrl_getdbpath(ctdb, TIMELIMIT(), options.pnn,
4360 dbmap->dbs[i].dbid, ctdb, &path);
4361 ctdb_ctrl_getdbname(ctdb, TIMELIMIT(), options.pnn,
4362 dbmap->dbs[i].dbid, ctdb, &name);
4363 ctdb_ctrl_getdbhealth(ctdb, TIMELIMIT(), options.pnn,
4364 dbmap->dbs[i].dbid, ctdb, &health);
4365 persistent = dbmap->dbs[i].flags & CTDB_DB_FLAGS_PERSISTENT;
4366 readonly = dbmap->dbs[i].flags & CTDB_DB_FLAGS_READONLY;
4367 sticky = dbmap->dbs[i].flags & CTDB_DB_FLAGS_STICKY;
4368 printf(":0x%08X:%s:%s:%d:%d:%d:%d:\n",
4369 dbmap->dbs[i].dbid, name, path,
4370 !!(persistent), !!(sticky),
4371 !!(health), !!(readonly));
4376 printf("Number of databases:%d\n", dbmap->num);
4377 for(i=0;i<dbmap->num;i++){
4385 ctdb_ctrl_getdbpath(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &path);
4386 ctdb_ctrl_getdbname(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &name);
4387 ctdb_ctrl_getdbhealth(ctdb, TIMELIMIT(), options.pnn, dbmap->dbs[i].dbid, ctdb, &health);
4388 persistent = dbmap->dbs[i].flags & CTDB_DB_FLAGS_PERSISTENT;
4389 readonly = dbmap->dbs[i].flags & CTDB_DB_FLAGS_READONLY;
4390 sticky = dbmap->dbs[i].flags & CTDB_DB_FLAGS_STICKY;
4391 printf("dbid:0x%08x name:%s path:%s%s%s%s%s\n",
4392 dbmap->dbs[i].dbid, name, path,
4393 persistent?" PERSISTENT":"",
4394 sticky?" STICKY":"",
4395 readonly?" READONLY":"",
4396 health?" UNHEALTHY":"");
4403 display the status of a database on a remote ctdb
4405 static int control_getdbstatus(struct ctdb_context *ctdb, int argc, const char **argv)
4407 const char *db_name;
4419 if (!db_exists(ctdb, db_name, &db_id, &flags)) {
4423 ctdb_ctrl_getdbpath(ctdb, TIMELIMIT(), options.pnn, db_id, ctdb, &path);
4424 ctdb_ctrl_getdbhealth(ctdb, TIMELIMIT(), options.pnn, db_id, ctdb, &health);
4425 printf("dbid: 0x%08x\nname: %s\npath: %s\nPERSISTENT: %s\nSTICKY: %s\nREADONLY: %s\nHEALTH: %s\n",
4426 db_id, db_name, path,
4427 (flags & CTDB_DB_FLAGS_PERSISTENT ? "yes" : "no"),
4428 (flags & CTDB_DB_FLAGS_STICKY ? "yes" : "no"),
4429 (flags & CTDB_DB_FLAGS_READONLY ? "yes" : "no"),
4430 (health ? health : "OK"));
4436 check if the local node is recmaster or not
4437 it will return 1 if this node is the recmaster and 0 if it is not
4438 or if the local ctdb daemon could not be contacted
4440 static int control_isnotrecmaster(struct ctdb_context *ctdb, int argc, const char **argv)
4442 uint32_t mypnn, recmaster;
4444 assert_single_node_only();
4446 mypnn = getpnn(ctdb);
4448 if (!ctdb_getrecmaster(ctdb_connection, options.pnn, &recmaster)) {
4449 printf("Failed to get the recmaster\n");
4453 if (recmaster != mypnn) {
4454 printf("this node is not the recmaster\n");
4458 printf("this node is the recmaster\n");
4465 static int control_ping(struct ctdb_context *ctdb, int argc, const char **argv)
4468 struct timeval tv = timeval_current();
4469 ret = ctdb_ctrl_ping(ctdb, options.pnn);
4471 printf("Unable to get ping response from node %u\n", options.pnn);
4474 printf("response from %u time=%.6f sec (%d clients)\n",
4475 options.pnn, timeval_elapsed(&tv), ret);
4482 get a node's runstate
4484 static int control_runstate(struct ctdb_context *ctdb, int argc, const char **argv)
4487 enum ctdb_runstate runstate;
4489 ret = ctdb_ctrl_get_runstate(ctdb, TIMELIMIT(), options.pnn, &runstate);
4491 printf("Unable to get runstate response from node %u\n",
4496 enum ctdb_runstate t;
4498 for (i=0; i<argc; i++) {
4500 t = runstate_from_string(argv[i]);
4501 if (t == CTDB_RUNSTATE_UNKNOWN) {
4502 printf("Invalid run state (%s)\n", argv[i]);
4506 if (t == runstate) {
4513 printf("CTDB not in required run state (got %s)\n",
4514 runstate_to_string((enum ctdb_runstate)runstate));
4519 printf("%s\n", runstate_to_string(runstate));
4527 static int control_getvar(struct ctdb_context *ctdb, int argc, const char **argv)
4538 ret = ctdb_ctrl_get_tunable(ctdb, TIMELIMIT(), options.pnn, name, &value);
4540 DEBUG(DEBUG_ERR, ("Unable to get tunable variable '%s'\n", name));
4544 printf("%-23s = %u\n", name, value);
4551 static int control_setvar(struct ctdb_context *ctdb, int argc, const char **argv)
4562 value = strtoul(argv[1], NULL, 0);
4564 ret = ctdb_ctrl_set_tunable(ctdb, TIMELIMIT(), options.pnn, name, value);
4566 DEBUG(DEBUG_ERR, ("Unable to set tunable variable '%s'\n", name));
4575 static int control_listvars(struct ctdb_context *ctdb, int argc, const char **argv)
4581 ret = ctdb_ctrl_list_tunables(ctdb, TIMELIMIT(), options.pnn, ctdb, &list, &count);
4583 DEBUG(DEBUG_ERR, ("Unable to list tunable variables\n"));
4587 for (i=0;i<count;i++) {
4588 control_getvar(ctdb, 1, &list[i]);
4597 display debug level on a node
4599 static int control_getdebug(struct ctdb_context *ctdb, int argc, const char **argv)
4604 ret = ctdb_ctrl_get_debuglevel(ctdb, options.pnn, &level);
4606 DEBUG(DEBUG_ERR, ("Unable to get debuglevel response from node %u\n", options.pnn));
4609 if (options.machinereadable){
4610 printf(":Name:Level:\n");
4611 printf(":%s:%d:\n",get_debug_by_level(level),level);
4613 printf("Node %u is at debug level %s (%d)\n", options.pnn, get_debug_by_level(level), level);
4620 display reclock file of a node
4622 static int control_getreclock(struct ctdb_context *ctdb, int argc, const char **argv)
4625 const char *reclock;
4627 ret = ctdb_ctrl_getreclock(ctdb, TIMELIMIT(), options.pnn, ctdb, &reclock);
4629 DEBUG(DEBUG_ERR, ("Unable to get reclock file from node %u\n", options.pnn));
4632 if (options.machinereadable){
4633 if (reclock != NULL) {
4634 printf("%s", reclock);
4637 if (reclock == NULL) {
4638 printf("No reclock file used.\n");
4640 printf("Reclock file:%s\n", reclock);
4648 set the reclock file of a node
4650 static int control_setreclock(struct ctdb_context *ctdb, int argc, const char **argv)
4653 const char *reclock;
4657 } else if (argc == 1) {
4663 ret = ctdb_ctrl_setreclock(ctdb, TIMELIMIT(), options.pnn, reclock);
4665 DEBUG(DEBUG_ERR, ("Unable to get reclock file from node %u\n", options.pnn));
4672 set the natgw state on/off
4674 static int control_setnatgwstate(struct ctdb_context *ctdb, int argc, const char **argv)
4677 uint32_t natgwstate;
4683 if (!strcmp(argv[0], "on")) {
4685 } else if (!strcmp(argv[0], "off")) {
4691 ret = ctdb_ctrl_setnatgwstate(ctdb, TIMELIMIT(), options.pnn, natgwstate);
4693 DEBUG(DEBUG_ERR, ("Unable to set the natgw state for node %u\n", options.pnn));
4701 set the lmaster role on/off
4703 static int control_setlmasterrole(struct ctdb_context *ctdb, int argc, const char **argv)
4706 uint32_t lmasterrole;
4712 if (!strcmp(argv[0], "on")) {
4714 } else if (!strcmp(argv[0], "off")) {
4720 ret = ctdb_ctrl_setlmasterrole(ctdb, TIMELIMIT(), options.pnn, lmasterrole);
4722 DEBUG(DEBUG_ERR, ("Unable to set the lmaster role for node %u\n", options.pnn));
4730 set the recmaster role on/off
4732 static int control_setrecmasterrole(struct ctdb_context *ctdb, int argc, const char **argv)
4735 uint32_t recmasterrole;
4741 if (!strcmp(argv[0], "on")) {
4743 } else if (!strcmp(argv[0], "off")) {
4749 ret = ctdb_ctrl_setrecmasterrole(ctdb, TIMELIMIT(), options.pnn, recmasterrole);
4751 DEBUG(DEBUG_ERR, ("Unable to set the recmaster role for node %u\n", options.pnn));
4759 set debug level on a node or all nodes
4761 static int control_setdebug(struct ctdb_context *ctdb, int argc, const char **argv)
4767 printf("You must specify the debug level. Valid levels are:\n");
4768 for (i=0; debug_levels[i].description != NULL; i++) {
4769 printf("%s (%d)\n", debug_levels[i].description, debug_levels[i].level);
4775 if (isalpha(argv[0][0]) || argv[0][0] == '-') {
4776 level = get_debug_by_desc(argv[0]);
4778 level = strtol(argv[0], NULL, 0);
4781 for (i=0; debug_levels[i].description != NULL; i++) {
4782 if (level == debug_levels[i].level) {
4786 if (debug_levels[i].description == NULL) {
4787 printf("Invalid debug level, must be one of\n");
4788 for (i=0; debug_levels[i].description != NULL; i++) {
4789 printf("%s (%d)\n", debug_levels[i].description, debug_levels[i].level);
4794 ret = ctdb_ctrl_set_debuglevel(ctdb, options.pnn, level);
4796 DEBUG(DEBUG_ERR, ("Unable to set debug level on node %u\n", options.pnn));
4805 static int control_thaw(struct ctdb_context *ctdb, int argc, const char **argv)
4811 priority = strtol(argv[0], NULL, 0);
4815 DEBUG(DEBUG_ERR,("Thaw by priority %u\n", priority));
4817 ret = ctdb_ctrl_thaw_priority(ctdb, TIMELIMIT(), options.pnn, priority);
4819 DEBUG(DEBUG_ERR, ("Unable to thaw node %u\n", options.pnn));
4826 attach to a database
4828 static int control_attach(struct ctdb_context *ctdb, int argc, const char **argv)
4830 const char *db_name;
4831 struct ctdb_db_context *ctdb_db;
4832 bool persistent = false;
4842 if (strcmp(argv[1], "persistent") != 0) {
4848 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), db_name, persistent, 0);
4849 if (ctdb_db == NULL) {
4850 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", db_name));
4860 static int control_setdbprio(struct ctdb_context *ctdb, int argc, const char **argv)
4862 struct ctdb_db_priority db_prio;
4869 db_prio.db_id = strtoul(argv[0], NULL, 0);
4870 db_prio.priority = strtoul(argv[1], NULL, 0);
4872 ret = ctdb_ctrl_set_db_priority(ctdb, TIMELIMIT(), options.pnn, &db_prio);
4874 DEBUG(DEBUG_ERR,("Unable to set db prio\n"));
4884 static int control_getdbprio(struct ctdb_context *ctdb, int argc, const char **argv)
4886 uint32_t db_id, priority;
4893 if (!db_exists(ctdb, argv[0], &db_id, NULL)) {
4897 ret = ctdb_ctrl_get_db_priority(ctdb, TIMELIMIT(), options.pnn, db_id, &priority);
4899 DEBUG(DEBUG_ERR,("Unable to get db prio\n"));
4903 DEBUG(DEBUG_ERR,("Priority:%u\n", priority));
4909 set the sticky records capability for a database
4911 static int control_setdbsticky(struct ctdb_context *ctdb, int argc, const char **argv)
4913 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
4921 if (!db_exists(ctdb, argv[0], &db_id, NULL)) {
4925 ret = ctdb_ctrl_set_db_sticky(ctdb, options.pnn, db_id);
4927 DEBUG(DEBUG_ERR,("Unable to set db to support sticky records\n"));
4928 talloc_free(tmp_ctx);
4932 talloc_free(tmp_ctx);
4937 set the readonly capability for a database
4939 static int control_setdbreadonly(struct ctdb_context *ctdb, int argc, const char **argv)
4941 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
4949 if (!db_exists(ctdb, argv[0], &db_id, NULL)) {
4953 ret = ctdb_ctrl_set_db_readonly(ctdb, options.pnn, db_id);
4955 DEBUG(DEBUG_ERR,("Unable to set db to support readonly\n"));
4956 talloc_free(tmp_ctx);
4960 talloc_free(tmp_ctx);
4967 static int control_getdbseqnum(struct ctdb_context *ctdb, int argc, const char **argv)
4977 if (!db_exists(ctdb, argv[0], &db_id, NULL)) {
4981 ret = ctdb_getdbseqnum(ctdb_connection, options.pnn, db_id, &seqnum);
4983 DEBUG(DEBUG_ERR, ("Unable to get seqnum from node."));
4987 printf("Sequence number:%lld\n", (long long)seqnum);
4995 static int control_setdbseqnum(struct ctdb_context *ctdb, int argc, const char **argv)
4998 struct ctdb_db_context *ctdb_db;
5001 uint64_t old_seqnum, new_seqnum;
5002 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
5003 struct ctdb_transaction_handle *h;
5008 talloc_free(tmp_ctx);
5012 if (!db_exists(ctdb, argv[0], &db_id, &flags)) {
5013 talloc_free(tmp_ctx);
5017 persistent = flags & CTDB_DB_FLAGS_PERSISTENT;
5019 DEBUG(DEBUG_ERR,("Database '%s' is not persistent\n", argv[0]));
5020 talloc_free(tmp_ctx);
5024 ret = ctdb_getdbseqnum(ctdb_connection, options.pnn, db_id, &old_seqnum);
5026 DEBUG(DEBUG_ERR, ("Unable to get seqnum from node."));
5027 talloc_free(tmp_ctx);
5031 new_seqnum = strtoull(argv[1], NULL, 0);
5032 if (new_seqnum <= old_seqnum) {
5033 DEBUG(DEBUG_ERR, ("New sequence number is less than current sequence number\n"));
5034 talloc_free(tmp_ctx);
5038 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), argv[0], persistent, 0);
5039 if (ctdb_db == NULL) {
5040 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", argv[0]));
5041 talloc_free(tmp_ctx);
5045 h = ctdb_transaction_start(ctdb_db, tmp_ctx);
5047 DEBUG(DEBUG_ERR,("Failed to start transaction on database %s\n", argv[0]));
5048 talloc_free(tmp_ctx);
5052 key.dptr = (uint8_t *)discard_const(CTDB_DB_SEQNUM_KEY);
5053 key.dsize = strlen(CTDB_DB_SEQNUM_KEY) + 1;
5055 data.dsize = sizeof(new_seqnum);
5056 data.dptr = talloc_size(tmp_ctx, data.dsize);
5057 *data.dptr = new_seqnum;
5059 ret = ctdb_transaction_store(h, key, data);
5061 DEBUG(DEBUG_ERR,("Failed to store record\n"));
5062 talloc_free(tmp_ctx);
5066 ret = ctdb_transaction_commit(h);
5068 DEBUG(DEBUG_ERR,("Failed to commit transaction\n"));
5069 talloc_free(tmp_ctx);
5073 talloc_free(tmp_ctx);
5078 run an eventscript on a node
5080 static int control_eventscript(struct ctdb_context *ctdb, int argc, const char **argv)
5086 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
5089 DEBUG(DEBUG_ERR,("Invalid arguments\n"));
5093 data.dptr = (unsigned char *)discard_const(argv[0]);
5094 data.dsize = strlen((char *)data.dptr) + 1;
5096 DEBUG(DEBUG_ERR, ("Running eventscripts with arguments \"%s\" on node %u\n", data.dptr, options.pnn));
5098 ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_RUN_EVENTSCRIPTS,
5099 0, data, tmp_ctx, NULL, &res, NULL, &errmsg);
5100 if (ret != 0 || res != 0) {
5101 DEBUG(DEBUG_ERR,("Failed to run eventscripts - %s\n", errmsg));
5102 talloc_free(tmp_ctx);
5105 talloc_free(tmp_ctx);
5109 #define DB_VERSION 1
5110 #define MAX_DB_NAME 64
5111 struct db_file_header {
5112 unsigned long version;
5114 unsigned long persistent;
5116 const char name[MAX_DB_NAME];
5119 struct backup_data {
5120 struct ctdb_marshall_buffer *records;
5123 bool traverse_error;
5126 static int backup_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *private)
5128 struct backup_data *bd = talloc_get_type(private, struct backup_data);
5129 struct ctdb_rec_data *rec;
5131 /* add the record */
5132 rec = ctdb_marshall_record(bd->records, 0, key, NULL, data);
5134 bd->traverse_error = true;
5135 DEBUG(DEBUG_ERR,("Failed to marshall record\n"));
5138 bd->records = talloc_realloc_size(NULL, bd->records, rec->length + bd->len);
5139 if (bd->records == NULL) {
5140 DEBUG(DEBUG_ERR,("Failed to expand marshalling buffer\n"));
5141 bd->traverse_error = true;
5144 bd->records->count++;
5145 memcpy(bd->len+(uint8_t *)bd->records, rec, rec->length);
5146 bd->len += rec->length;
5154 * backup a database to a file
5156 static int control_backupdb(struct ctdb_context *ctdb, int argc, const char **argv)
5159 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
5160 struct db_file_header dbhdr;
5161 struct ctdb_db_context *ctdb_db;
5162 struct backup_data *bd;
5165 const char *reason = NULL;
5169 assert_single_node_only();
5172 DEBUG(DEBUG_ERR,("Invalid arguments\n"));
5176 if (!db_exists(ctdb, argv[0], &db_id, &flags)) {
5180 ret = ctdb_ctrl_getdbhealth(ctdb, TIMELIMIT(), options.pnn,
5181 db_id, tmp_ctx, &reason);
5183 DEBUG(DEBUG_ERR,("Unable to get dbhealth for database '%s'\n",
5185 talloc_free(tmp_ctx);
5189 uint32_t allow_unhealthy = 0;
5191 ctdb_ctrl_get_tunable(ctdb, TIMELIMIT(), options.pnn,
5192 "AllowUnhealthyDBRead",
5195 if (allow_unhealthy != 1) {
5196 DEBUG(DEBUG_ERR,("database '%s' is unhealthy: %s\n",
5199 DEBUG(DEBUG_ERR,("disallow backup : tunable AllowUnhealthyDBRead = %u\n",
5201 talloc_free(tmp_ctx);
5205 DEBUG(DEBUG_WARNING,("WARNING database '%s' is unhealthy - see 'ctdb getdbstatus %s'\n",
5207 DEBUG(DEBUG_WARNING,("WARNING! allow backup of unhealthy database: "
5208 "tunnable AllowUnhealthyDBRead = %u\n",
5212 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), argv[0], flags & CTDB_DB_FLAGS_PERSISTENT, 0);
5213 if (ctdb_db == NULL) {
5214 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", argv[0]));
5215 talloc_free(tmp_ctx);
5220 ret = tdb_transaction_start(ctdb_db->ltdb->tdb);
5222 DEBUG(DEBUG_ERR,("Failed to start transaction\n"));
5223 talloc_free(tmp_ctx);
5228 bd = talloc_zero(tmp_ctx, struct backup_data);
5230 DEBUG(DEBUG_ERR,("Failed to allocate backup_data\n"));
5231 talloc_free(tmp_ctx);
5235 bd->records = talloc_zero(bd, struct ctdb_marshall_buffer);
5236 if (bd->records == NULL) {
5237 DEBUG(DEBUG_ERR,("Failed to allocate ctdb_marshall_buffer\n"));
5238 talloc_free(tmp_ctx);
5242 bd->len = offsetof(struct ctdb_marshall_buffer, data);
5243 bd->records->db_id = ctdb_db->db_id;
5244 /* traverse the database collecting all records */
5245 if (tdb_traverse_read(ctdb_db->ltdb->tdb, backup_traverse, bd) == -1 ||
5246 bd->traverse_error) {
5247 DEBUG(DEBUG_ERR,("Traverse error\n"));
5248 talloc_free(tmp_ctx);
5252 tdb_transaction_cancel(ctdb_db->ltdb->tdb);
5255 fh = open(argv[1], O_RDWR|O_CREAT, 0600);
5257 DEBUG(DEBUG_ERR,("Failed to open file '%s'\n", argv[1]));
5258 talloc_free(tmp_ctx);
5262 dbhdr.version = DB_VERSION;
5263 dbhdr.timestamp = time(NULL);
5264 dbhdr.persistent = flags & CTDB_DB_FLAGS_PERSISTENT;
5265 dbhdr.size = bd->len;
5266 if (strlen(argv[0]) >= MAX_DB_NAME) {
5267 DEBUG(DEBUG_ERR,("Too long dbname\n"));
5270 strncpy(discard_const(dbhdr.name), argv[0], MAX_DB_NAME);
5271 ret = write(fh, &dbhdr, sizeof(dbhdr));
5273 DEBUG(DEBUG_ERR,("write failed: %s\n", strerror(errno)));
5276 ret = write(fh, bd->records, bd->len);
5278 DEBUG(DEBUG_ERR,("write failed: %s\n", strerror(errno)));
5287 DEBUG(DEBUG_ERR,("close failed: %s\n", strerror(errno)));
5291 DEBUG(DEBUG_ERR,("Database backed up to %s\n", argv[1]));
5293 talloc_free(tmp_ctx);
5298 * restore a database from a file
5300 static int control_restoredb(struct ctdb_context *ctdb, int argc, const char **argv)
5303 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
5306 struct db_file_header dbhdr;
5307 struct ctdb_db_context *ctdb_db;
5308 struct ctdb_node_map *nodemap=NULL;
5309 struct ctdb_vnn_map *vnnmap=NULL;
5311 struct ctdb_control_wipe_database w;
5313 uint32_t generation;
5318 assert_single_node_only();
5320 if (argc < 1 || argc > 2) {
5321 DEBUG(DEBUG_ERR,("Invalid arguments\n"));
5325 fh = open(argv[0], O_RDONLY);
5327 DEBUG(DEBUG_ERR,("Failed to open file '%s'\n", argv[0]));
5328 talloc_free(tmp_ctx);
5332 read(fh, &dbhdr, sizeof(dbhdr));
5333 if (dbhdr.version != DB_VERSION) {
5334 DEBUG(DEBUG_ERR,("Invalid version of database dump. File is version %lu but expected version was %u\n", dbhdr.version, DB_VERSION));
5335 talloc_free(tmp_ctx);
5339 dbname = discard_const(dbhdr.name);
5341 dbname = discard_const(argv[1]);
5344 outdata.dsize = dbhdr.size;
5345 outdata.dptr = talloc_size(tmp_ctx, outdata.dsize);
5346 if (outdata.dptr == NULL) {
5347 DEBUG(DEBUG_ERR,("Failed to allocate data of size '%lu'\n", dbhdr.size));
5349 talloc_free(tmp_ctx);
5352 read(fh, outdata.dptr, outdata.dsize);
5355 tm = localtime(&dbhdr.timestamp);
5356 strftime(tbuf,sizeof(tbuf)-1,"%Y/%m/%d %H:%M:%S", tm);
5357 printf("Restoring database '%s' from backup @ %s\n",
5361 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), dbname, dbhdr.persistent, 0);
5362 if (ctdb_db == NULL) {
5363 DEBUG(DEBUG_ERR,("Unable to attach to database '%s'\n", dbname));
5364 talloc_free(tmp_ctx);
5368 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), options.pnn, ctdb, &nodemap);
5370 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n", options.pnn));
5371 talloc_free(tmp_ctx);
5376 ret = ctdb_ctrl_getvnnmap(ctdb, TIMELIMIT(), options.pnn, tmp_ctx, &vnnmap);
5378 DEBUG(DEBUG_ERR, ("Unable to get vnnmap from node %u\n", options.pnn));
5379 talloc_free(tmp_ctx);
5383 /* freeze all nodes */
5384 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5385 for (i=1; i<=NUM_DB_PRIORITIES; i++) {
5386 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_FREEZE,
5392 DEBUG(DEBUG_ERR, ("Unable to freeze nodes.\n"));
5393 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5394 talloc_free(tmp_ctx);
5399 generation = vnnmap->generation;
5400 data.dptr = (void *)&generation;
5401 data.dsize = sizeof(generation);
5403 /* start a cluster wide transaction */
5404 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5405 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_TRANSACTION_START,
5407 TIMELIMIT(), false, data,
5410 DEBUG(DEBUG_ERR, ("Unable to start cluster wide transactions.\n"));
5415 w.db_id = ctdb_db->db_id;
5416 w.transaction_id = generation;
5418 data.dptr = (void *)&w;
5419 data.dsize = sizeof(w);
5421 /* wipe all the remote databases. */
5422 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5423 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_WIPE_DATABASE,
5425 TIMELIMIT(), false, data,
5428 DEBUG(DEBUG_ERR, ("Unable to wipe database.\n"));
5429 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5430 talloc_free(tmp_ctx);
5434 /* push the database */
5435 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5436 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_PUSH_DB,
5438 TIMELIMIT(), false, outdata,
5441 DEBUG(DEBUG_ERR, ("Failed to push database.\n"));
5442 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5443 talloc_free(tmp_ctx);
5447 data.dptr = (void *)&ctdb_db->db_id;
5448 data.dsize = sizeof(ctdb_db->db_id);
5450 /* mark the database as healthy */
5451 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5452 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_DB_SET_HEALTHY,
5454 TIMELIMIT(), false, data,
5457 DEBUG(DEBUG_ERR, ("Failed to mark database as healthy.\n"));
5458 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5459 talloc_free(tmp_ctx);
5463 data.dptr = (void *)&generation;
5464 data.dsize = sizeof(generation);
5466 /* commit all the changes */
5467 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_TRANSACTION_COMMIT,
5469 TIMELIMIT(), false, data,
5472 DEBUG(DEBUG_ERR, ("Unable to commit databases.\n"));
5473 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5474 talloc_free(tmp_ctx);
5479 /* thaw all nodes */
5480 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5481 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_THAW,
5487 DEBUG(DEBUG_ERR, ("Unable to thaw nodes.\n"));
5488 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5489 talloc_free(tmp_ctx);
5494 talloc_free(tmp_ctx);
5499 * dump a database backup from a file
5501 static int control_dumpdbbackup(struct ctdb_context *ctdb, int argc, const char **argv)
5503 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
5505 struct db_file_header dbhdr;
5509 struct ctdb_rec_data *rec = NULL;
5510 struct ctdb_marshall_buffer *m;
5511 struct ctdb_dump_db_context c;
5513 assert_single_node_only();
5516 DEBUG(DEBUG_ERR,("Invalid arguments\n"));
5520 fh = open(argv[0], O_RDONLY);
5522 DEBUG(DEBUG_ERR,("Failed to open file '%s'\n", argv[0]));
5523 talloc_free(tmp_ctx);
5527 read(fh, &dbhdr, sizeof(dbhdr));
5528 if (dbhdr.version != DB_VERSION) {
5529 DEBUG(DEBUG_ERR,("Invalid version of database dump. File is version %lu but expected version was %u\n", dbhdr.version, DB_VERSION));
5530 talloc_free(tmp_ctx);
5534 outdata.dsize = dbhdr.size;
5535 outdata.dptr = talloc_size(tmp_ctx, outdata.dsize);
5536 if (outdata.dptr == NULL) {
5537 DEBUG(DEBUG_ERR,("Failed to allocate data of size '%lu'\n", dbhdr.size));
5539 talloc_free(tmp_ctx);
5542 read(fh, outdata.dptr, outdata.dsize);
5544 m = (struct ctdb_marshall_buffer *)outdata.dptr;
5546 tm = localtime(&dbhdr.timestamp);
5547 strftime(tbuf,sizeof(tbuf)-1,"%Y/%m/%d %H:%M:%S", tm);
5548 printf("Backup of database name:'%s' dbid:0x%x08x from @ %s\n",
5549 dbhdr.name, m->db_id, tbuf);
5553 c.printemptyrecords = (bool)options.printemptyrecords;
5554 c.printdatasize = (bool)options.printdatasize;
5555 c.printlmaster = false;
5556 c.printhash = (bool)options.printhash;
5557 c.printrecordflags = (bool)options.printrecordflags;
5559 for (i=0; i < m->count; i++) {
5563 /* we do not want the header splitted, so we pass NULL*/
5564 rec = ctdb_marshall_loop_next(m, rec, &reqid,
5567 ctdb_dumpdb_record(ctdb, key, data, &c);
5570 printf("Dumped %d records\n", i);
5571 talloc_free(tmp_ctx);
5576 * wipe a database from a file
5578 static int control_wipedb(struct ctdb_context *ctdb, int argc,
5582 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
5584 struct ctdb_db_context *ctdb_db;
5585 struct ctdb_node_map *nodemap = NULL;
5586 struct ctdb_vnn_map *vnnmap = NULL;
5588 struct ctdb_control_wipe_database w;
5590 uint32_t generation;
5593 assert_single_node_only();
5596 DEBUG(DEBUG_ERR,("Invalid arguments\n"));
5600 if (!db_exists(ctdb, argv[0], NULL, &flags)) {
5604 ctdb_db = ctdb_attach(ctdb, TIMELIMIT(), argv[0], flags & CTDB_DB_FLAGS_PERSISTENT, 0);
5605 if (ctdb_db == NULL) {
5606 DEBUG(DEBUG_ERR, ("Unable to attach to database '%s'\n",
5608 talloc_free(tmp_ctx);
5612 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), options.pnn, ctdb,
5615 DEBUG(DEBUG_ERR, ("Unable to get nodemap from node %u\n",
5617 talloc_free(tmp_ctx);
5621 ret = ctdb_ctrl_getvnnmap(ctdb, TIMELIMIT(), options.pnn, tmp_ctx,
5624 DEBUG(DEBUG_ERR, ("Unable to get vnnmap from node %u\n",
5626 talloc_free(tmp_ctx);
5630 /* freeze all nodes */
5631 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5632 for (i=1; i<=NUM_DB_PRIORITIES; i++) {
5633 ret = ctdb_client_async_control(ctdb, CTDB_CONTROL_FREEZE,
5640 DEBUG(DEBUG_ERR, ("Unable to freeze nodes.\n"));
5641 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn,
5642 CTDB_RECOVERY_ACTIVE);
5643 talloc_free(tmp_ctx);
5648 generation = vnnmap->generation;
5649 data.dptr = (void *)&generation;
5650 data.dsize = sizeof(generation);
5652 /* start a cluster wide transaction */
5653 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5654 ret = ctdb_client_async_control(ctdb, CTDB_CONTROL_TRANSACTION_START,
5656 TIMELIMIT(), false, data,
5660 DEBUG(DEBUG_ERR, ("Unable to start cluster wide "
5661 "transactions.\n"));
5665 w.db_id = ctdb_db->db_id;
5666 w.transaction_id = generation;
5668 data.dptr = (void *)&w;
5669 data.dsize = sizeof(w);
5671 /* wipe all the remote databases. */
5672 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5673 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_WIPE_DATABASE,
5675 TIMELIMIT(), false, data,
5678 DEBUG(DEBUG_ERR, ("Unable to wipe database.\n"));
5679 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5680 talloc_free(tmp_ctx);
5684 data.dptr = (void *)&ctdb_db->db_id;
5685 data.dsize = sizeof(ctdb_db->db_id);
5687 /* mark the database as healthy */
5688 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5689 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_DB_SET_HEALTHY,
5691 TIMELIMIT(), false, data,
5694 DEBUG(DEBUG_ERR, ("Failed to mark database as healthy.\n"));
5695 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5696 talloc_free(tmp_ctx);
5700 data.dptr = (void *)&generation;
5701 data.dsize = sizeof(generation);
5703 /* commit all the changes */
5704 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_TRANSACTION_COMMIT,
5706 TIMELIMIT(), false, data,
5709 DEBUG(DEBUG_ERR, ("Unable to commit databases.\n"));
5710 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5711 talloc_free(tmp_ctx);
5715 /* thaw all nodes */
5716 nodes = list_of_active_nodes(ctdb, nodemap, tmp_ctx, true);
5717 if (ctdb_client_async_control(ctdb, CTDB_CONTROL_THAW,
5723 DEBUG(DEBUG_ERR, ("Unable to thaw nodes.\n"));
5724 ctdb_ctrl_setrecmode(ctdb, TIMELIMIT(), options.pnn, CTDB_RECOVERY_ACTIVE);
5725 talloc_free(tmp_ctx);
5729 DEBUG(DEBUG_ERR, ("Database wiped.\n"));
5731 talloc_free(tmp_ctx);
5738 static int control_dumpmemory(struct ctdb_context *ctdb, int argc, const char **argv)
5744 TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
5745 ret = ctdb_control(ctdb, options.pnn, 0, CTDB_CONTROL_DUMP_MEMORY,
5746 0, tdb_null, tmp_ctx, &data, &res, NULL, &errmsg);
5747 if (ret != 0 || res != 0) {
5748 DEBUG(DEBUG_ERR,("Failed to dump memory - %s\n", errmsg));
5749 talloc_free(tmp_ctx);
5752 write(1, data.dptr, data.dsize);
5753 talloc_free(tmp_ctx);
5758 handler for memory dumps
5760 static void mem_dump_handler(struct ctdb_context *ctdb, uint64_t srvid,
5761 TDB_DATA data, void *private_data)
5763 write(1, data.dptr, data.dsize);
5768 dump memory usage on the recovery daemon
5770 static int control_rddumpmemory(struct ctdb_context *ctdb, int argc, const char **argv)
5774 struct srvid_request rd;
5776 rd.pnn = ctdb_get_pnn(ctdb);
5777 rd.srvid = getpid();
5779 /* register a message port for receiveing the reply so that we
5780 can receive the reply
5782 ctdb_client_set_message_handler(ctdb, rd.srvid, mem_dump_handler, NULL);
5785 data.dptr = (uint8_t *)&rd;
5786 data.dsize = sizeof(rd);
5788 ret = ctdb_client_send_message(ctdb, options.pnn, CTDB_SRVID_MEM_DUMP, data);
5790 DEBUG(DEBUG_ERR,("Failed to send memdump request message to %u\n", options.pnn));
5794 /* this loop will terminate when we have received the reply */
5796 event_loop_once(ctdb->ev);
5803 send a message to a srvid
5805 static int control_msgsend(struct ctdb_context *ctdb, int argc, const char **argv)
5807 unsigned long srvid;
5815 srvid = strtoul(argv[0], NULL, 0);
5817 data.dptr = (uint8_t *)discard_const(argv[1]);
5818 data.dsize= strlen(argv[1]);
5820 ret = ctdb_client_send_message(ctdb, CTDB_BROADCAST_CONNECTED, srvid, data);
5822 DEBUG(DEBUG_ERR,("Failed to send memdump request message to %u\n", options.pnn));
5830 handler for msglisten
5832 static void msglisten_handler(struct ctdb_context *ctdb, uint64_t srvid,
5833 TDB_DATA data, void *private_data)
5837 printf("Message received: ");
5838 for (i=0;i<data.dsize;i++) {
5839 printf("%c", data.dptr[i]);
5845 listen for messages on a messageport
5847 static int control_msglisten(struct ctdb_context *ctdb, int argc, const char **argv)
5853 /* register a message port and listen for messages
5855 ctdb_client_set_message_handler(ctdb, srvid, msglisten_handler, NULL);
5856 printf("Listening for messages on srvid:%d\n", (int)srvid);
5859 event_loop_once(ctdb->ev);
5866 list all nodes in the cluster
5867 we parse the nodes file directly
5869 static int control_listnodes(struct ctdb_context *ctdb, int argc, const char **argv)
5871 TALLOC_CTX *mem_ctx = talloc_new(NULL);
5872 struct pnn_node *pnn_nodes;
5873 struct pnn_node *pnn_node;
5875 assert_single_node_only();
5877 pnn_nodes = read_nodes_file(mem_ctx);
5878 if (pnn_nodes == NULL) {
5879 DEBUG(DEBUG_ERR,("Failed to read nodes file\n"));
5880 talloc_free(mem_ctx);
5884 for(pnn_node=pnn_nodes;pnn_node;pnn_node=pnn_node->next) {
5885 ctdb_sock_addr addr;
5886 if (parse_ip(pnn_node->addr, NULL, 63999, &addr) == 0) {
5887 DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s' in nodes file\n", pnn_node->addr));
5888 talloc_free(mem_ctx);
5891 if (options.machinereadable){
5892 printf(":%d:%s:\n", pnn_node->pnn, pnn_node->addr);
5894 printf("%s\n", pnn_node->addr);
5897 talloc_free(mem_ctx);
5903 reload the nodes file on the local node
5905 static int control_reload_nodes_file(struct ctdb_context *ctdb, int argc, const char **argv)
5909 struct ctdb_node_map *nodemap=NULL;
5911 assert_single_node_only();
5913 mypnn = ctdb_get_pnn(ctdb);
5915 ret = ctdb_ctrl_getnodemap(ctdb, TIMELIMIT(), CTDB_CURRENT_NODE, ctdb, &nodemap);
5917 DEBUG(DEBUG_ERR, ("Unable to get nodemap from local node\n"));
5921 /* reload the nodes file on all remote nodes */
5922 for (i=0;i<nodemap->num;i++) {
5923 if (nodemap->nodes[i].pnn == mypnn) {
5926 DEBUG(DEBUG_NOTICE, ("Reloading nodes file on node %u\n", nodemap->nodes[i].pnn));
5927 ret = ctdb_ctrl_reload_nodes_file(ctdb, TIMELIMIT(),
5928 nodemap->nodes[i].pnn);
5930 DEBUG(DEBUG_ERR, ("ERROR: Failed to reload nodes file on node %u. You MUST fix that node manually!\n", nodemap->nodes[i].pnn));
5934 /* reload the nodes file on the local node */
5935 DEBUG(DEBUG_NOTICE, ("Reloading nodes file on node %u\n", mypnn));
5936 ret = ctdb_ctrl_reload_nodes_file(ctdb, TIMELIMIT(), mypnn);
5938 DEBUG(DEBUG_ERR, ("ERROR: Failed to reload nodes file on node %u. You MUST fix that node manually!\n", mypnn));
5941 /* initiate a recovery */
5942 control_recover(ctdb, argc, argv);
5948 static const struct {
5950 int (*fn)(struct ctdb_context *, int, const char **);
5952 bool without_daemon; /* can be run without daemon running ? */
5955 } ctdb_commands[] = {
5956 { "version", control_version, true, true, "show version of ctdb" },
5957 { "status", control_status, true, false, "show node status" },
5958 { "uptime", control_uptime, true, false, "show node uptime" },
5959 { "ping", control_ping, true, false, "ping all nodes" },
5960 { "runstate", control_runstate, true, false, "get/check runstate of a node", "[setup|first_recovery|startup|running]" },
5961 { "getvar", control_getvar, true, false, "get a tunable variable", "<name>"},
5962 { "setvar", control_setvar, true, false, "set a tunable variable", "<name> <value>"},
5963 { "listvars", control_listvars, true, false, "list tunable variables"},
5964 { "statistics", control_statistics, false, false, "show statistics" },
5965 { "statisticsreset", control_statistics_reset, true, false, "reset statistics"},
5966 { "stats", control_stats, false, false, "show rolling statistics", "[number of history records]" },
5967 { "ip", control_ip, false, false, "show which public ip's that ctdb manages" },
5968 { "ipinfo", control_ipinfo, true, false, "show details about a public ip that ctdb manages", "<ip>" },
5969 { "ifaces", control_ifaces, true, false, "show which interfaces that ctdb manages" },
5970 { "setifacelink", control_setifacelink, true, false, "set interface link status", "<iface> <status>" },
5971 { "process-exists", control_process_exists, true, false, "check if a process exists on a node", "<pid>"},
5972 { "getdbmap", control_getdbmap, true, false, "show the database map" },
5973 { "getdbstatus", control_getdbstatus, true, false, "show the status of a database", "<dbname|dbid>" },
5974 { "catdb", control_catdb, true, false, "dump a ctdb database" , "<dbname|dbid>"},
5975 { "cattdb", control_cattdb, true, false, "dump a local tdb database" , "<dbname|dbid>"},
5976 { "getmonmode", control_getmonmode, true, false, "show monitoring mode" },
5977 { "getcapabilities", control_getcapabilities, true, false, "show node capabilities" },
5978 { "pnn", control_pnn, true, false, "show the pnn of the currnet node" },
5979 { "lvs", control_lvs, true, false, "show lvs configuration" },
5980 { "lvsmaster", control_lvsmaster, true, false, "show which node is the lvs master" },
5981 { "disablemonitor", control_disable_monmode,true, false, "set monitoring mode to DISABLE" },
5982 { "enablemonitor", control_enable_monmode, true, false, "set monitoring mode to ACTIVE" },
5983 { "setdebug", control_setdebug, true, false, "set debug level", "<EMERG|ALERT|CRIT|ERR|WARNING|NOTICE|INFO|DEBUG>" },
5984 { "getdebug", control_getdebug, true, false, "get debug level" },
5985 { "getlog", control_getlog, true, false, "get the log data from the in memory ringbuffer", "[<level>] [recoverd]" },
5986 { "clearlog", control_clearlog, true, false, "clear the log data from the in memory ringbuffer", "[recoverd]" },
5987 { "attach", control_attach, true, false, "attach to a database", "<dbname> [persistent]" },
5988 { "dumpmemory", control_dumpmemory, true, false, "dump memory map to stdout" },
5989 { "rddumpmemory", control_rddumpmemory, true, false, "dump memory map from the recovery daemon to stdout" },
5990 { "getpid", control_getpid, true, false, "get ctdbd process ID" },
5991 { "disable", control_disable, true, false, "disable a nodes public IP" },
5992 { "enable", control_enable, true, false, "enable a nodes public IP" },
5993 { "stop", control_stop, true, false, "stop a node" },
5994 { "continue", control_continue, true, false, "re-start a stopped node" },
5995 { "ban", control_ban, true, false, "ban a node from the cluster", "<bantime|0>"},
5996 { "unban", control_unban, true, false, "unban a node" },
5997 { "showban", control_showban, true, false, "show ban information"},
5998 { "shutdown", control_shutdown, true, false, "shutdown ctdbd" },
5999 { "recover", control_recover, true, false, "force recovery" },
6000 { "sync", control_ipreallocate, false, false, "wait until ctdbd has synced all state changes" },
6001 { "ipreallocate", control_ipreallocate, false, false, "force the recovery daemon to perform a ip reallocation procedure" },
6002 { "thaw", control_thaw, true, false, "thaw databases", "[priority:1-3]" },
6003 { "isnotrecmaster", control_isnotrecmaster, false, false, "check if the local node is recmaster or not" },
6004 { "killtcp", kill_tcp, false, false, "kill a tcp connection.", "[<srcip:port> <dstip:port>]" },
6005 { "gratiousarp", control_gratious_arp, false, false, "send a gratious arp", "<ip> <interface>" },
6006 { "tickle", tickle_tcp, false, false, "send a tcp tickle ack", "<srcip:port> <dstip:port>" },
6007 { "gettickles", control_get_tickles, false, false, "get the list of tickles registered for this ip", "<ip> [<port>]" },
6008 { "addtickle", control_add_tickle, false, false, "add a tickle for this ip", "<ip>:<port> <ip>:<port>" },
6010 { "deltickle", control_del_tickle, false, false, "delete a tickle from this ip", "<ip>:<port> <ip>:<port>" },
6012 { "regsrvid", regsrvid, false, false, "register a server id", "<pnn> <type> <id>" },
6013 { "unregsrvid", unregsrvid, false, false, "unregister a server id", "<pnn> <type> <id>" },
6014 { "chksrvid", chksrvid, false, false, "check if a server id exists", "<pnn> <type> <id>" },
6015 { "getsrvids", getsrvids, false, false, "get a list of all server ids"},
6016 { "check_srvids", check_srvids, false, false, "check if a srvid exists", "<id>+" },
6017 { "vacuum", ctdb_vacuum, false, true, "vacuum the databases of empty records", "[max_records]"},
6018 { "repack", ctdb_repack, false, false, "repack all databases", "[max_freelist]"},
6019 { "listnodes", control_listnodes, false, true, "list all nodes in the cluster"},
6020 { "reloadnodes", control_reload_nodes_file, false, false, "reload the nodes file and restart the transport on all nodes"},
6021 { "moveip", control_moveip, false, false, "move/failover an ip address to another node", "<ip> <node>"},
6022 { "rebalanceip", control_rebalanceip, false, false, "release an ip from the node and let recd rebalance it", "<ip>"},
6023 { "addip", control_addip, true, false, "add a ip address to a node", "<ip/mask> <iface>"},
6024 { "delip", control_delip, false, false, "delete an ip address from a node", "<ip>"},
6025 { "eventscript", control_eventscript, true, false, "run the eventscript with the given parameters on a node", "<arguments>"},
6026 { "backupdb", control_backupdb, false, false, "backup the database into a file.", "<dbname|dbid> <file>"},
6027 { "restoredb", control_restoredb, false, false, "restore the database from a file.", "<file> [dbname]"},
6028 { "dumpdbbackup", control_dumpdbbackup, false, true, "dump database backup from a file.", "<file>"},
6029 { "wipedb", control_wipedb, false, false, "wipe the contents of a database.", "<dbname|dbid>"},
6030 { "recmaster", control_recmaster, true, false, "show the pnn for the recovery master."},
6031 { "scriptstatus", control_scriptstatus, true, false, "show the status of the monitoring scripts (or all scripts)", "[all]"},
6032 { "enablescript", control_enablescript, true, false, "enable an eventscript", "<script>"},
6033 { "disablescript", control_disablescript, true, false, "disable an eventscript", "<script>"},
6034 { "natgwlist", control_natgwlist, true, false, "show the nodes belonging to this natgw configuration"},
6035 { "xpnn", control_xpnn, false, true, "find the pnn of the local node without talking to the daemon (unreliable)" },
6036 { "getreclock", control_getreclock, true, false, "Show the reclock file of a node"},
6037 { "setreclock", control_setreclock, true, false, "Set/clear the reclock file of a node", "[filename]"},
6038 { "setnatgwstate", control_setnatgwstate, false, false, "Set NATGW state to on/off", "{on|off}"},
6039 { "setlmasterrole", control_setlmasterrole, false, false, "Set LMASTER role to on/off", "{on|off}"},
6040 { "setrecmasterrole", control_setrecmasterrole, false, false, "Set RECMASTER role to on/off", "{on|off}"},
6041 { "setdbprio", control_setdbprio, false, false, "Set DB priority", "<dbname|dbid> <prio:1-3>"},
6042 { "getdbprio", control_getdbprio, false, false, "Get DB priority", "<dbname|dbid>"},
6043 { "setdbreadonly", control_setdbreadonly, false, false, "Set DB readonly capable", "<dbname|dbid>"},
6044 { "setdbsticky", control_setdbsticky, false, false, "Set DB sticky-records capable", "<dbname|dbid>"},
6045 { "msglisten", control_msglisten, false, false, "Listen on a srvid port for messages", "<msg srvid>"},
6046 { "msgsend", control_msgsend, false, false, "Send a message to srvid", "<srvid> <message>"},
6047 { "pfetch", control_pfetch, false, false, "fetch a record from a persistent database", "<dbname|dbid> <key> [<file>]" },
6048 { "pstore", control_pstore, false, false, "write a record to a persistent database", "<dbname|dbid> <key> <file containing record>" },
6049 { "pdelete", control_pdelete, false, false, "delete a record from a persistent database", "<dbname|dbid> <key>" },
6050 { "tfetch", control_tfetch, false, true, "fetch a record from a [c]tdb-file [-v]", "<tdb-file> <key> [<file>]" },
6051 { "tstore", control_tstore, false, true, "store a record (including ltdb header)", "<tdb-file> <key> <data+header>" },
6052 { "readkey", control_readkey, true, false, "read the content off a database key", "<tdb-file> <key>" },
6053 { "writekey", control_writekey, true, false, "write to a database key", "<tdb-file> <key> <value>" },
6054 { "checktcpport", control_chktcpport, false, true, "check if a service is bound to a specific tcp port or not", "<port>" },
6055 { "rebalancenode", control_rebalancenode, false, false, "release a node by allowing it to takeover ips", "<pnn>"},
6056 { "getdbseqnum", control_getdbseqnum, false, false, "get the sequence number off a database", "<dbname|dbid>" },
6057 { "setdbseqnum", control_setdbseqnum, false, false, "set the sequence number for a database", "<dbname|dbid> <seqnum>" },
6058 { "nodestatus", control_nodestatus, true, false, "show and return node status" },
6059 { "dbstatistics", control_dbstatistics, false, false, "show db statistics", "<dbname|dbid>" },
6060 { "reloadips", control_reloadips, false, false, "reload the public addresses file on a node" },
6061 { "ipiface", control_ipiface, false, true, "Find which interface an ip address is hsoted on", "<ip>" },
6067 static void usage(void)
6071 "Usage: ctdb [options] <control>\n" \
6073 " -n <node> choose node number, or 'all' (defaults to local node)\n"
6074 " -Y generate machinereadable output\n"
6075 " -v generate verbose output\n"
6076 " -t <timelimit> set timelimit for control in seconds (default %u)\n", options.timelimit);
6077 printf("Controls:\n");
6078 for (i=0;i<ARRAY_SIZE(ctdb_commands);i++) {
6079 printf(" %-15s %-27s %s\n",
6080 ctdb_commands[i].name,
6081 ctdb_commands[i].args?ctdb_commands[i].args:"",
6082 ctdb_commands[i].msg);
6088 static void ctdb_alarm(int sig)
6090 printf("Maximum runtime exceeded - exiting\n");
6097 int main(int argc, const char *argv[])
6099 struct ctdb_context *ctdb;
6100 char *nodestring = NULL;
6101 struct poptOption popt_options[] = {
6104 { "timelimit", 't', POPT_ARG_INT, &options.timelimit, 0, "timelimit", "integer" },
6105 { "node", 'n', POPT_ARG_STRING, &nodestring, 0, "node", "integer|all" },
6106 { "machinereadable", 'Y', POPT_ARG_NONE, &options.machinereadable, 0, "enable machinereadable output", NULL },
6107 { "verbose", 'v', POPT_ARG_NONE, &options.verbose, 0, "enable verbose output", NULL },
6108 { "maxruntime", 'T', POPT_ARG_INT, &options.maxruntime, 0, "die if runtime exceeds this limit (in seconds)", "integer" },
6109 { "print-emptyrecords", 0, POPT_ARG_NONE, &options.printemptyrecords, 0, "print the empty records when dumping databases (catdb, cattdb, dumpdbbackup)", NULL },
6110 { "print-datasize", 0, POPT_ARG_NONE, &options.printdatasize, 0, "do not print record data when dumping databases, only the data size", NULL },
6111 { "print-lmaster", 0, POPT_ARG_NONE, &options.printlmaster, 0, "print the record's lmaster in catdb", NULL },
6112 { "print-hash", 0, POPT_ARG_NONE, &options.printhash, 0, "print the record's hash when dumping databases", NULL },
6113 { "print-recordflags", 0, POPT_ARG_NONE, &options.printrecordflags, 0, "print the record flags in catdb and dumpdbbackup", NULL },
6117 const char **extra_argv;
6121 struct event_context *ev;
6122 const char *control;
6123 const char *socket_name;
6127 /* set some defaults */
6128 options.maxruntime = 0;
6129 options.timelimit = 10;
6130 options.pnn = CTDB_CURRENT_NODE;
6132 pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
6134 while ((opt = poptGetNextOpt(pc)) != -1) {
6137 DEBUG(DEBUG_ERR, ("Invalid option %s: %s\n",
6138 poptBadOption(pc, 0), poptStrerror(opt)));
6143 /* setup the remaining options for the main program to use */
6144 extra_argv = poptGetArgs(pc);
6147 while (extra_argv[extra_argc]) extra_argc++;
6150 if (extra_argc < 1) {
6154 if (options.maxruntime == 0) {
6155 const char *ctdb_timeout;
6156 ctdb_timeout = getenv("CTDB_TIMEOUT");
6157 if (ctdb_timeout != NULL) {
6158 options.maxruntime = strtoul(ctdb_timeout, NULL, 0);
6160 /* default timeout is 120 seconds */
6161 options.maxruntime = 120;
6165 signal(SIGALRM, ctdb_alarm);
6166 alarm(options.maxruntime);
6168 control = extra_argv[0];
6170 ev = event_context_init(NULL);
6172 DEBUG(DEBUG_ERR, ("Failed to initialize event system\n"));
6176 for (i=0;i<ARRAY_SIZE(ctdb_commands);i++) {
6177 if (strcmp(control, ctdb_commands[i].name) == 0) {
6182 if (i == ARRAY_SIZE(ctdb_commands)) {
6183 DEBUG(DEBUG_ERR, ("Unknown control '%s'\n", control));
6187 if (ctdb_commands[i].without_daemon == true) {
6188 if (nodestring != NULL) {
6189 DEBUG(DEBUG_ERR, ("Can't specify node(s) with \"ctdb %s\"\n", control));
6193 return ctdb_commands[i].fn(NULL, extra_argc-1, extra_argv+1);
6196 /* initialise ctdb */
6197 ctdb = ctdb_cmdline_client(ev, TIMELIMIT());
6200 DEBUG(DEBUG_ERR, ("Failed to init ctdb\n"));
6204 /* initialize a libctdb connection as well */
6205 socket_name = ctdb_get_socketname(ctdb);
6206 ctdb_connection = ctdb_connect(socket_name,
6207 ctdb_log_file, stderr);
6208 if (ctdb_connection == NULL) {
6209 DEBUG(DEBUG_ERR, ("Failed to connect to daemon from libctdb\n"));
6213 /* setup the node number(s) to contact */
6214 if (!parse_nodestring(ctdb, nodestring, CTDB_CURRENT_NODE, false,
6215 &options.nodes, &options.pnn)) {
6219 if (options.pnn == CTDB_CURRENT_NODE) {
6220 options.pnn = options.nodes[0];
6223 if (ctdb_commands[i].auto_all &&
6224 ((options.pnn == CTDB_BROADCAST_ALL) ||
6225 (options.pnn == CTDB_MULTICAST))) {
6229 for (j = 0; j < talloc_array_length(options.nodes); j++) {
6230 options.pnn = options.nodes[j];
6231 ret |= ctdb_commands[i].fn(ctdb, extra_argc-1, extra_argv+1);
6234 ret = ctdb_commands[i].fn(ctdb, extra_argc-1, extra_argv+1);
6237 ctdb_disconnect(ctdb_connection);
6240 (void)poptFreeContext(pc);