2 CTDB event daemon utility code
4 Copyright (C) Amitay Isaacs 2018
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #include "system/filesys.h"
22 #include "system/time.h"
28 #include "lib/util/debug.h"
30 #include "common/cmdline.h"
31 #include "common/logging.h"
32 #include "common/path.h"
33 #include "common/event_script.h"
35 #include "event/event_protocol_api.h"
36 #include "event/event.h"
37 #include "event/event_tool.h"
39 struct event_tool_context {
40 struct cmdline_context *cmdline;
41 struct tevent_context *ev;
42 struct ctdb_event_context *eclient;
45 static int compact_args(TALLOC_CTX *mem_ctx,
59 arg_str = talloc_strdup(mem_ctx, argv[from]);
60 if (arg_str == NULL) {
64 for (i = from+1; i < argc; i++) {
65 arg_str = talloc_asprintf_append(arg_str, " %s", argv[i]);
66 if (arg_str == NULL) {
75 static int event_command_run(TALLOC_CTX *mem_ctx,
80 struct event_tool_context *ctx = talloc_get_type_abort(
81 private_data, struct event_tool_context);
82 struct tevent_req *req;
83 struct ctdb_event_request_run request_run;
84 const char *arg_str = NULL;
86 int timeout, ret = 0, result = 0;
90 cmdline_usage(ctx->cmdline, "run");
94 ret = ctdb_event_init(ctx, ctx->ev, &ctx->eclient);
96 D_ERR("Failed to initialize event client, ret=%d\n", ret);
100 timeout = atoi(argv[0]);
105 ret = compact_args(mem_ctx, argv, argc, 3, &arg_str);
107 D_ERR("Memory allocation error\n");
111 request_run.component = argv[1];
112 request_run.event = argv[2];
113 request_run.args = arg_str;
114 request_run.timeout = timeout;
115 request_run.flags = 0;
117 t = getenv("CTDB_TEST_MODE");
119 t = getenv("CTDB_EVENT_RUN_ALL");
121 request_run.flags = CTDB_EVENT_RUN_ALL;
125 req = ctdb_event_run_send(mem_ctx,
130 D_ERR("Memory allocation error\n");
134 tevent_req_poll(req, ctx->ev);
136 ok = ctdb_event_run_recv(req, &ret, &result);
138 D_ERR("Failed to run event %s in %s, ret=%d\n",
145 D_NOTICE("Command run finished with result=%d\n", result);
147 if (result == ENOENT) {
148 printf("Event dir for %s does not exist\n", argv[1]);
149 } else if (result == ETIMEDOUT) {
150 printf("Event %s in %s timed out\n", argv[2], argv[1]);
151 } else if (result == ECANCELED) {
152 printf("Event %s in %s got cancelled\n", argv[2], argv[1]);
153 } else if (result == ENOEXEC) {
154 printf("Event %s in %s failed\n", argv[2], argv[1]);
155 } else if (result != 0) {
156 printf("Failed to run event %s in %s, result=%d\n",
162 ret = (result < 0) ? -result : result;
166 static double timeval_delta(struct timeval *tv2, struct timeval *tv)
168 return (tv2->tv_sec - tv->tv_sec) +
169 (tv2->tv_usec - tv->tv_usec) * 1.0e-6;
172 static void print_status_one(struct ctdb_event_script *script)
174 if (script->result == -ETIMEDOUT) {
175 printf("%-20s %-10s %s",
178 ctime(&script->begin.tv_sec));
179 } else if (script->result == -ENOEXEC) {
180 printf("%-20s %-10s\n", script->name, "DISABLED");
181 } else if (script->result < 0) {
182 printf("%-20s %-10s (%s)\n",
185 strerror(-script->result));
186 } else if (script->result == 0) {
187 printf("%-20s %-10s %.3lf %s",
190 timeval_delta(&script->end, &script->begin),
191 ctime(&script->begin.tv_sec));
193 printf("%-20s %-10s %.3lf %s",
196 timeval_delta(&script->end, &script->begin),
197 ctime(&script->begin.tv_sec));
200 if (script->result != 0 && script->result != -ENOEXEC) {
201 printf(" OUTPUT: %s\n",
202 script->output == NULL ? "" : script->output);
206 static void print_status(const char *component,
209 struct ctdb_event_reply_status *status)
214 if (result == ENOENT) {
215 printf("Event dir for %s does not exist\n", component);
216 } else if (result == EINVAL) {
217 printf("Event %s has never run in %s\n",
221 printf("Unknown error (%d) for event %s in %s\n",
229 for (i=0; i<status->script_list->num_scripts; i++) {
230 print_status_one(&status->script_list->script[i]);
234 static int event_command_status(TALLOC_CTX *mem_ctx,
239 struct event_tool_context *ctx = talloc_get_type_abort(
240 private_data, struct event_tool_context);
241 struct tevent_req *req;
242 struct ctdb_event_request_status request_status;
243 struct ctdb_event_reply_status *reply_status;
244 int ret = 0, result = 0;
248 cmdline_usage(ctx->cmdline, "status");
252 ret = ctdb_event_init(ctx, ctx->ev, &ctx->eclient);
254 D_ERR("Failed to initialize event client, ret=%d\n", ret);
258 request_status.component = argv[0];
259 request_status.event = argv[1];
261 req = ctdb_event_status_send(mem_ctx,
266 D_ERR("Memory allocation error\n");
270 tevent_req_poll(req, ctx->ev);
272 ok = ctdb_event_status_recv(req,
278 D_ERR("Failed to get status for event %s in %s, ret=%d\n",
285 D_NOTICE("Command status finished with result=%d\n", result);
287 print_status(argv[0], argv[1], result, reply_status);
289 if (reply_status == NULL) {
292 ret = reply_status->summary;
293 ret = (ret < 0) ? -ret : ret;
298 #define EVENT_SCRIPT_DISABLED ' '
299 #define EVENT_SCRIPT_ENABLED '*'
301 static int event_command_script_list(TALLOC_CTX *mem_ctx,
306 struct event_tool_context *ctx = talloc_get_type_abort(
307 private_data, struct event_tool_context);
309 char *data_dir = NULL;
310 char *etc_dir = NULL;
311 struct event_script_list *data_list = NULL;
312 struct event_script_list *etc_list = NULL;
313 unsigned int i, j, matched;
317 cmdline_usage(ctx->cmdline, "script list");
321 subdir = talloc_asprintf(mem_ctx, "events/%s", argv[0]);
322 if (subdir == NULL) {
326 data_dir = path_datadir_append(mem_ctx, subdir);
327 if (data_dir == NULL) {
331 etc_dir = path_etcdir_append(mem_ctx, subdir);
332 if (etc_dir == NULL) {
337 * Ignore error on ENOENT for cut down (e.g. fixed/embedded)
338 * installs that don't use symlinks but just populate etc_dir
341 ret = event_script_get_list(mem_ctx, data_dir, &data_list);
342 if (ret != 0 && ret != ENOENT) {
343 D_ERR("Command script list finished with result=%d\n", ret);
347 ret = event_script_get_list(mem_ctx, etc_dir, &etc_list);
349 D_ERR("Command script list finished with result=%d\n", ret);
353 D_NOTICE("Command script list finished with result=%d\n", ret);
355 if (data_list == NULL) {
356 goto list_enabled_only;
360 * First list scripts provided by CTDB. Flag those that are
361 * enabled via a symlink and arrange for them to be excluded
362 * from the subsequent list of local scripts.
364 * Both lists are sorted, so walk the list of enabled scripts
365 * only once in this pass.
369 for (i = 0; i < data_list->num_scripts; i++) {
370 struct event_script *d = data_list->script[i];
371 char flag = EVENT_SCRIPT_DISABLED;
375 /* Check to see if this script is enabled */
376 while (j < etc_list->num_scripts) {
377 struct event_script *e = etc_list->script[j];
379 ret = strcmp(e->name, d->name);
383 * Enabled name is greater, so needs
384 * to be considered later: done
390 /* Enabled name is less: next */
395 len = readlink(e->path, buf, sizeof(buf));
396 if (len == -1 || len >= sizeof(buf)) {
398 * Not a link? Disappeared? Invalid
399 * link target? Something else?
401 * Doesn't match provided script: next, done
407 /* readlink() does not NUL-terminate */
410 ret = strcmp(buf, d->path);
412 /* Enabled link doesn't match: next, done */
418 * Enabled script's symlink matches our
419 * script: flag our script as enabled
421 * Also clear the enabled script so it can be
422 * trivially skipped in the next pass
424 flag = EVENT_SCRIPT_ENABLED;
425 TALLOC_FREE(etc_list->script[j]);
431 printf("%c %s\n", flag, d->name);
434 /* Print blank line if both provided and local lists are being printed */
435 if (data_list->num_scripts > 0 && matched != etc_list->num_scripts) {
441 /* Now print details of local scripts, after a blank line */
442 for (j = 0; j < etc_list->num_scripts; j++) {
443 struct event_script *e = etc_list->script[j];
444 char flag = EVENT_SCRIPT_DISABLED;
447 /* Matched in previous pass: next */
451 /* Script is local: if executable then flag as enabled */
453 flag = EVENT_SCRIPT_ENABLED;
456 printf("%c %s\n", flag, e->name);
463 talloc_free(data_dir);
464 talloc_free(etc_dir);
465 talloc_free(data_list);
466 talloc_free(etc_list);
471 static int event_command_script(TALLOC_CTX *mem_ctx,
472 struct event_tool_context *ctx,
473 const char *component,
477 char *subdir, *etc_dir;
480 subdir = talloc_asprintf(mem_ctx, "events/%s", component);
481 if (subdir == NULL) {
485 etc_dir = path_etcdir_append(mem_ctx, subdir);
486 if (etc_dir == NULL) {
491 result = event_script_chmod(etc_dir, script, true);
493 result = event_script_chmod(etc_dir, script, false);
497 talloc_free(etc_dir);
499 D_NOTICE("Command script finished with result=%d\n", result);
501 if (result == EINVAL) {
502 printf("Script %s is invalid in %s\n", script, component);
503 } else if (result == ENOENT) {
504 printf("Script %s does not exist in %s\n", script, component);
510 static int event_command_script_enable(TALLOC_CTX *mem_ctx,
515 struct event_tool_context *ctx = talloc_get_type_abort(
516 private_data, struct event_tool_context);
518 char *script, *etc_script, *data_script;
522 cmdline_usage(ctx->cmdline, "script enable");
526 script = talloc_asprintf(mem_ctx, "events/%s/%s.script", argv[0], argv[1]);
527 if (script == NULL) {
531 etc_script = path_etcdir_append(mem_ctx, script);
532 if (etc_script == NULL) {
536 data_script = path_datadir_append(mem_ctx, script);
537 if (data_script == NULL) {
541 ret = lstat(etc_script, &statbuf);
543 if (S_ISLNK(statbuf.st_mode)) {
544 /* Link already exists */
546 } else if (S_ISREG(statbuf.st_mode)) {
547 return event_command_script(mem_ctx,
554 printf("Script %s is not a file or a link\n", etc_script);
557 if (errno == ENOENT) {
558 ret = stat(data_script, &statbuf);
560 printf("Script %s does not exist in %s\n",
565 ret = symlink(data_script, etc_script);
567 printf("Failed to create symlink %s\n",
575 printf("Script %s does not exist\n", etc_script);
580 static int event_command_script_disable(TALLOC_CTX *mem_ctx,
585 struct event_tool_context *ctx = talloc_get_type_abort(
586 private_data, struct event_tool_context);
588 char *script, *etc_script;
593 cmdline_usage(ctx->cmdline, "script disable");
597 script = talloc_asprintf(mem_ctx, "events/%s/%s.script", argv[0], argv[1]);
598 if (script == NULL) {
602 etc_script = path_etcdir_append(mem_ctx, script);
603 if (etc_script == NULL) {
607 ret = lstat(etc_script, &statbuf);
609 if (S_ISLNK(statbuf.st_mode)) {
611 ret = unlink(etc_script);
613 printf("Failed to remove symlink %s\n",
619 } else if (S_ISREG(statbuf.st_mode)) {
620 return event_command_script(mem_ctx,
627 printf("Script %s is not a file or a link\n", etc_script);
634 struct cmdline_command event_commands[] = {
635 { "run", event_command_run,
636 "Run an event", "<timeout> <component> <event> <args>" },
637 { "status", event_command_status,
638 "Get status of an event", "<component> <event>" },
639 { "script list", event_command_script_list,
640 "List event scripts", "<component>" },
641 { "script enable", event_command_script_enable,
642 "Enable an event script", "<component> <script>" },
643 { "script disable", event_command_script_disable,
644 "Disable an event script", "<component> <script>" },
648 int event_tool_init(TALLOC_CTX *mem_ctx,
650 struct poptOption *options,
654 struct event_tool_context **result)
656 struct event_tool_context *ctx;
659 ctx = talloc_zero(mem_ctx, struct event_tool_context);
661 D_ERR("Memory allocation error\n");
665 ret = cmdline_init(mem_ctx,
671 D_ERR("Failed to initialize cmdline, ret=%d\n", ret);
676 ret = cmdline_parse(ctx->cmdline, argc, argv, parse_options);
678 cmdline_usage(ctx->cmdline, NULL);
687 int event_tool_run(struct event_tool_context *ctx, int *result)
691 ctx->ev = tevent_context_init(ctx);
692 if (ctx->ev == NULL) {
693 D_ERR("Failed to initialize tevent\n");
697 ret = cmdline_run(ctx->cmdline, ctx, result);
701 #ifdef CTDB_EVENT_TOOL
709 struct poptOption event_options[] = {
710 { "debug", 'd', POPT_ARG_STRING, &event_data.debug, 0,
711 "debug level", "ERROR|WARNING|NOTICE|INFO|DEBUG" },
715 int main(int argc, const char **argv)
718 struct event_tool_context *ctx;
722 mem_ctx = talloc_new(NULL);
723 if (mem_ctx == NULL) {
724 fprintf(stderr, "Memory allocation error\n");
728 ret = event_tool_init(mem_ctx,
736 talloc_free(mem_ctx);
740 setup_logging("ctdb-event", DEBUG_STDERR);
741 ok = debug_level_parse(event_data.debug, &DEBUGLEVEL);
743 DEBUGLEVEL = DEBUG_ERR;
746 ret = event_tool_run(ctx, &result);
751 talloc_free(mem_ctx);
755 #endif /* CTDB_EVENT_TOOL */