ctdb/server/ctdb_eventd.c

   1 /*
   2    Event script running daemon
   3
   4    Copyright (C) Amitay Isaacs  2016
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "replace.h"
  21 #include "system/filesys.h"
  22 #include "system/dir.h"
  23 #include "system/wait.h"
  24 #include "system/locale.h"
  25
  26 #include <popt.h>
  27 #include <talloc.h>
  28 #include <tevent.h>
  29
  30 #include "lib/util/debug.h"
  31 #include "lib/util/tevent_unix.h"
  32 #include "lib/util/blocking.h"
  33 #include "lib/util/sys_rw.h"
  34 #include "lib/util/dlinklist.h"
  35 #include "lib/async_req/async_sock.h"
  36
  37 #include "protocol/protocol_api.h"
  38
  39 #include "common/comm.h"
  40 #include "common/logging.h"
  41 #include "common/run_event.h"
  42 #include "common/sock_daemon.h"
  43
  44 struct pending_event {
  45         struct pending_event *prev, *next;
  46
  47         struct tevent_req *req;
  48 };
  49
  50 struct eventd_client {
  51         struct eventd_client *prev, *next;
  52
  53         struct sock_client_context *client_ctx;
  54         struct pending_event *pending_list;
  55 };
  56
  57 struct eventd_context {
  58         struct run_event_context *run_ctx;
  59         struct tevent_queue *queue;
  60
  61         /* current state */
  62         bool running;
  63         enum ctdb_event event;
  64         struct tevent_req *req;
  65
  66         /* result of last execution */
  67         struct run_event_script_list *status_run[CTDB_EVENT_MAX];
  68         struct run_event_script_list *status_pass[CTDB_EVENT_MAX];
  69         struct run_event_script_list *status_fail[CTDB_EVENT_MAX];
  70
  71         struct eventd_client *client_list;
  72 };
  73
  74 /*
  75  * Global state manipulation functions
  76  */
  77
  78 static int eventd_context_init(TALLOC_CTX *mem_ctx,
  79                                struct tevent_context *ev,
  80                                const char *script_dir,
  81                                const char *debug_script,
  82                                struct eventd_context **result)
  83 {
  84         struct eventd_context *ectx;
  85         int ret;
  86
  87         ectx = talloc_zero(mem_ctx, struct eventd_context);
  88         if (ectx == NULL) {
  89                 return ENOMEM;
  90         }
  91
  92         ret = run_event_init(ectx, ev, script_dir, debug_script,
  93                              &ectx->run_ctx);
  94         if (ret != 0) {
  95                 talloc_free(ectx);
  96                 return ret;
  97         }
  98
  99         ectx->queue = tevent_queue_create(ectx, "run event queue");
 100         if (ectx->queue == NULL) {
 101                 talloc_free(ectx);
 102                 return ENOMEM;
 103         }
 104
 105         ectx->running = false;
 106         ectx->event = CTDB_EVENT_INIT;
 107
 108         *result = ectx;
 109         return 0;
 110 }
 111
 112 static struct run_event_context *eventd_run_context(struct eventd_context *ectx)
 113 {
 114         return ectx->run_ctx;
 115 }
 116
 117 static struct tevent_queue *eventd_queue(struct eventd_context *ectx)
 118 {
 119         return ectx->queue;
 120 }
 121
 122 static void eventd_start_running(struct eventd_context *ectx,
 123                                  enum ctdb_event event,
 124                                  struct tevent_req *req)
 125 {
 126         ectx->running = true;
 127         ectx->event = event;
 128         ectx->req = req;
 129 }
 130
 131 static void eventd_stop_running(struct eventd_context *ectx)
 132 {
 133         ectx->running = false;
 134         ectx->req = NULL;
 135 }
 136
 137 static struct tevent_req *eventd_cancel_running(struct eventd_context *ectx)
 138 {
 139         struct tevent_req *req = ectx->req;
 140
 141         ectx->req = NULL;
 142         eventd_stop_running(ectx);
 143
 144         return req;
 145 }
 146
 147 static bool eventd_is_running(struct eventd_context *ectx,
 148                               enum ctdb_event *event)
 149 {
 150         if (event != NULL && ectx->running) {
 151                 *event = ectx->event;
 152         }
 153
 154         return ectx->running;
 155 }
 156
 157 static struct run_event_script_list *script_list_copy(
 158                                         TALLOC_CTX *mem_ctx,
 159                                         struct run_event_script_list *s)
 160 {
 161         struct run_event_script_list *s2;
 162
 163         s2 = talloc_zero(mem_ctx, struct run_event_script_list);
 164         if (s2 == NULL) {
 165                 return NULL;
 166         }
 167
 168         s2->num_scripts = s->num_scripts;
 169         s2->script = talloc_memdup(s2, s->script,
 170                                    s->num_scripts *
 171                                    sizeof(struct run_event_script));
 172         if (s2->script == NULL) {
 173                 talloc_free(s2);
 174                 return NULL;
 175         }
 176         s2->summary = s->summary;
 177
 178         return s2;
 179 }
 180
 181 static struct ctdb_script_list *script_list_to_ctdb_script_list(
 182                                         TALLOC_CTX *mem_ctx,
 183                                         struct run_event_script_list *s)
 184 {
 185         struct ctdb_script_list *sl;
 186         int i;
 187
 188         sl = talloc_zero(mem_ctx, struct ctdb_script_list);
 189         if (sl == NULL) {
 190                 return NULL;
 191         }
 192
 193         sl->script = talloc_zero_array(sl, struct ctdb_script, s->num_scripts);
 194         if (sl->script == NULL) {
 195                 talloc_free(sl);
 196                 return NULL;
 197         }
 198
 199         sl->num_scripts = s->num_scripts;
 200
 201         for (i=0; i<s->num_scripts; i++) {
 202                 struct run_event_script *escript = &s->script[i];
 203                 struct ctdb_script *script = &sl->script[i];
 204
 205                 strlcpy(script->name, escript->name, MAX_SCRIPT_NAME+1);
 206                 script->start = escript->begin;
 207                 script->finished = escript->end;
 208                 script->status = escript->summary;
 209                 if (escript->output != NULL) {
 210                         strlcpy(script->output, escript->output,
 211                                 MAX_SCRIPT_OUTPUT+1);
 212                 }
 213         }
 214
 215         return sl;
 216 }
 217
 218 static void eventd_set_result(struct eventd_context *ectx,
 219                               enum ctdb_event event,
 220                               struct run_event_script_list *script_list)
 221 {
 222         struct run_event_script_list *s;
 223
 224         if (script_list == NULL) {
 225                 return;
 226         }
 227
 228         TALLOC_FREE(ectx->status_run[event]);
 229         ectx->status_run[event] = talloc_steal(ectx, script_list);
 230
 231         s = script_list_copy(ectx, script_list);
 232         if (s == NULL) {
 233                 return;
 234         }
 235
 236         if (s->summary == 0) {
 237                 TALLOC_FREE(ectx->status_pass[event]);
 238                 ectx->status_pass[event] = s;
 239         } else {
 240                 TALLOC_FREE(ectx->status_fail[event]);
 241                 ectx->status_fail[event] = s;
 242         }
 243 }
 244
 245 static int eventd_get_result(struct eventd_context *ectx,
 246                              enum ctdb_event event,
 247                              enum ctdb_event_status_state state,
 248                              TALLOC_CTX *mem_ctx,
 249                              struct ctdb_script_list **out)
 250 {
 251         struct run_event_script_list *s = NULL;
 252
 253         switch (state) {
 254                 case CTDB_EVENT_LAST_RUN:
 255                         s = ectx->status_run[event];
 256                         break;
 257
 258                 case CTDB_EVENT_LAST_PASS:
 259                         s = ectx->status_pass[event];
 260                         break;
 261
 262                 case CTDB_EVENT_LAST_FAIL:
 263                         s = ectx->status_fail[event];
 264                         break;
 265         }
 266
 267         if (s == NULL) {
 268                 *out = NULL;
 269                 return 0;
 270         }
 271
 272         *out = script_list_to_ctdb_script_list(mem_ctx, s);
 273         return s->summary;
 274 }
 275
 276 /*
 277  * Process RUN command
 278  */
 279
 280 struct command_run_state {
 281         struct tevent_context *ev;
 282         struct eventd_context *ectx;
 283         struct eventd_client *client;
 284
 285         enum ctdb_event event;
 286         uint32_t timeout;
 287         const char *arg_str;
 288         struct ctdb_event_reply *reply;
 289         struct tevent_req *subreq;
 290 };
 291
 292 static void command_run_trigger(struct tevent_req *req, void *private_data);
 293 static void command_run_done(struct tevent_req *subreq);
 294 static void command_run_cancel(struct tevent_req *req);
 295
 296 static struct tevent_req *command_run_send(TALLOC_CTX *mem_ctx,
 297                                            struct tevent_context *ev,
 298                                            struct eventd_context *ectx,
 299                                            struct eventd_client *client,
 300                                            struct ctdb_event_request *request)
 301 {
 302         struct tevent_req *req, *mon_req;
 303         struct command_run_state *state;
 304         struct pending_event *pending;
 305         enum ctdb_event running_event;
 306         bool running, status;
 307
 308         req = tevent_req_create(mem_ctx, &state, struct command_run_state);
 309         if (req == NULL) {
 310                 return NULL;
 311         }
 312
 313         state->ev = ev;
 314         state->ectx = ectx;
 315         state->client = client;
 316
 317         state->event = request->rdata.data.run->event;
 318         state->timeout = request->rdata.data.run->timeout;
 319         state->arg_str = talloc_steal(state, request->rdata.data.run->arg_str);
 320
 321         state->reply = talloc_zero(state, struct ctdb_event_reply);
 322         if (tevent_req_nomem(state->reply, req)) {
 323                 return tevent_req_post(req, ev);
 324         }
 325
 326         state->reply->rdata.command = request->rdata.command;
 327
 328         /*
 329          * If monitor event is running,
 330          *   Cancel the running monitor event and run new event
 331          *
 332          * If any other event is running,
 333          *   If new event is monitor, cancel that event
 334          *   Else add new event to the queue
 335          */
 336
 337         running = eventd_is_running(ectx, &running_event);
 338         if (running) {
 339                 if (running_event == CTDB_EVENT_MONITOR) {
 340                         mon_req = eventd_cancel_running(ectx);
 341                         command_run_cancel(mon_req);
 342                 } else if (state->event == CTDB_EVENT_MONITOR) {
 343                         state->reply->rdata.result = -ECANCELED;
 344                         tevent_req_done(req);
 345                         return tevent_req_post(req, ev);
 346                 }
 347         }
 348
 349         pending = talloc_zero(state, struct pending_event);
 350         if (tevent_req_nomem(pending, req)) {
 351                 return tevent_req_post(req, ev);
 352         }
 353
 354         pending->req = req;
 355         DLIST_ADD(client->pending_list, pending);
 356
 357         status = tevent_queue_add(eventd_queue(ectx), ev, req,
 358                                   command_run_trigger, pending);
 359         if (! status) {
 360                 tevent_req_error(req, ENOMEM);
 361                 return tevent_req_post(req, ev);
 362         }
 363
 364         return req;
 365 }
 366
 367 static void command_run_trigger(struct tevent_req *req, void *private_data)
 368 {
 369         struct pending_event *pending = talloc_get_type_abort(
 370                 private_data, struct pending_event);
 371         struct command_run_state *state = tevent_req_data(
 372                 req, struct command_run_state);
 373
 374         DLIST_REMOVE(state->client->pending_list, pending);
 375
 376         if (pending->req != req) {
 377                 tevent_req_error(req, EIO);
 378                 return;
 379         }
 380
 381         talloc_free(pending);
 382
 383         D_DEBUG("Running event %s with args \"%s\"\n",
 384                 ctdb_event_to_string(state->event),
 385                 state->arg_str == NULL ? "(null)" : state->arg_str);
 386
 387         state->subreq = run_event_send(state, state->ev,
 388                                        eventd_run_context(state->ectx),
 389                                        ctdb_event_to_string(state->event),
 390                                        state->arg_str,
 391                                        tevent_timeval_current_ofs(
 392                                                state->timeout, 0));
 393         if (tevent_req_nomem(state->subreq, req)) {
 394                 return;
 395         }
 396         tevent_req_set_callback(state->subreq, command_run_done, req);
 397
 398         eventd_start_running(state->ectx, state->event, req);
 399 }
 400
 401 static void command_run_done(struct tevent_req *subreq)
 402 {
 403         struct tevent_req *req = tevent_req_callback_data(
 404                 subreq, struct tevent_req);
 405         struct command_run_state *state = tevent_req_data(
 406                 req, struct command_run_state);
 407         struct run_event_script_list *script_list;
 408         int ret;
 409         bool status;
 410
 411         eventd_stop_running(state->ectx);
 412
 413         status = run_event_recv(subreq, &ret, state, &script_list);
 414         TALLOC_FREE(subreq);
 415         if (! status) {
 416                 tevent_req_error(req, ret);
 417                 return;
 418         }
 419
 420         if (script_list == NULL) {
 421                 eventd_set_result(state->ectx, state->event, NULL);
 422                 state->reply->rdata.result = 0;
 423         } else {
 424                 eventd_set_result(state->ectx, state->event, script_list);
 425                 state->reply->rdata.result = script_list->summary;
 426         }
 427
 428         tevent_req_done(req);
 429 }
 430
 431 static void command_run_cancel(struct tevent_req *req)
 432 {
 433         struct command_run_state *state = tevent_req_data(
 434                 req, struct command_run_state);
 435
 436         eventd_stop_running(state->ectx);
 437
 438         TALLOC_FREE(state->subreq);
 439
 440         state->reply->rdata.result = -ECANCELED;
 441
 442         tevent_req_done(req);
 443 }
 444
 445 static bool command_run_recv(struct tevent_req *req, int *perr,
 446                              TALLOC_CTX *mem_ctx,
 447                              struct ctdb_event_reply **reply)
 448 {
 449         struct command_run_state *state = tevent_req_data(
 450                 req, struct command_run_state);
 451         int ret;
 452
 453         if (tevent_req_is_unix_error(req, &ret)) {
 454                 if (perr != NULL) {
 455                         *perr = ret;
 456                 }
 457                 return false;
 458         }
 459
 460         if (reply != NULL) {
 461                 *reply = talloc_steal(mem_ctx, state->reply);
 462         }
 463         return true;
 464 }
 465
 466 /*
 467  * Process STATUS command
 468  */
 469
 470 struct command_status_state {
 471         struct ctdb_event_reply *reply;
 472 };
 473
 474 static struct tevent_req *command_status_send(
 475                                         TALLOC_CTX *mem_ctx,
 476                                         struct tevent_context *ev,
 477                                         struct eventd_context *ectx,
 478                                         struct eventd_client *client,
 479                                         struct ctdb_event_request *request)
 480 {
 481         struct tevent_req *req;
 482         struct command_status_state *state;
 483         enum ctdb_event event;
 484         enum ctdb_event_status_state estate;
 485
 486         req = tevent_req_create(mem_ctx, &state, struct command_status_state);
 487         if (req == NULL) {
 488                 return NULL;
 489         }
 490
 491         event = request->rdata.data.status->event;
 492         estate = request->rdata.data.status->state;
 493
 494         state->reply = talloc_zero(state, struct ctdb_event_reply);
 495         if (tevent_req_nomem(state->reply, req)) {
 496                 return tevent_req_post(req, ev);
 497         }
 498
 499         state->reply->rdata.data.status =
 500                 talloc(state->reply, struct ctdb_event_reply_status);
 501         if (tevent_req_nomem(state->reply->rdata.data.status, req)) {
 502                 return tevent_req_post(req, ev);
 503         }
 504
 505         state->reply->rdata.command = request->rdata.command;
 506         state->reply->rdata.result = 0;
 507         state->reply->rdata.data.status->status =
 508                 eventd_get_result(ectx, event, estate, state->reply,
 509                                 &state->reply->rdata.data.status->script_list);
 510
 511         tevent_req_done(req);
 512         return tevent_req_post(req, ev);
 513 }
 514
 515 static bool command_status_recv(struct tevent_req *req, int *perr,
 516                                 TALLOC_CTX *mem_ctx,
 517                                 struct ctdb_event_reply **reply)
 518 {
 519         struct command_status_state *state = tevent_req_data(
 520                 req, struct command_status_state);
 521         int ret;
 522
 523         if (tevent_req_is_unix_error(req, &ret)) {
 524                 if (perr != NULL) {
 525                         *perr = ret;
 526                 }
 527                 return false;
 528         }
 529
 530         if (reply != NULL) {
 531                 *reply = talloc_steal(mem_ctx, state->reply);
 532         }
 533         return true;
 534 }
 535
 536 /*
 537  * Process SCRIPT_LIST command
 538  */
 539
 540 struct command_script_list_state {
 541         struct ctdb_event_reply *reply;
 542 };
 543
 544 static struct tevent_req *command_script_list_send(
 545                                         TALLOC_CTX *mem_ctx,
 546                                         struct tevent_context *ev,
 547                                         struct eventd_context *ectx,
 548                                         struct eventd_client *client,
 549                                         struct ctdb_event_request *request)
 550 {
 551         struct tevent_req *req;
 552         struct command_script_list_state *state;
 553         struct run_event_script_list *s;
 554         int ret;
 555
 556         req = tevent_req_create(mem_ctx, &state,
 557                                 struct command_script_list_state);
 558         if (req == NULL) {
 559                 return NULL;
 560         }
 561
 562         state->reply = talloc_zero(state, struct ctdb_event_reply);
 563         if (tevent_req_nomem(state->reply, req)) {
 564                 return tevent_req_post(req, ev);
 565         }
 566
 567         state->reply->rdata.data.script_list =
 568                 talloc(state->reply, struct ctdb_event_reply_script_list);
 569         if (tevent_req_nomem(state->reply->rdata.data.script_list, req)) {
 570                 return tevent_req_post(req, ev);
 571         }
 572
 573         ret = run_event_script_list(eventd_run_context(ectx), state->reply,
 574                                     &s);
 575         if (ret != 0) {
 576                 tevent_req_error(req, ret);
 577                 return tevent_req_post(req, ev);
 578         }
 579
 580         state->reply->rdata.command = request->rdata.command;
 581         if (s == NULL) {
 582                 state->reply->rdata.result = 0;
 583                 state->reply->rdata.data.script_list->script_list = NULL;
 584         } else {
 585                 state->reply->rdata.result = s->summary;
 586                 state->reply->rdata.data.script_list->script_list =
 587                         script_list_to_ctdb_script_list(state->reply, s);
 588         }
 589
 590         tevent_req_done(req);
 591         return tevent_req_post(req, ev);
 592 }
 593
 594 static bool command_script_list_recv(struct tevent_req *req, int *perr,
 595                                      TALLOC_CTX *mem_ctx,
 596                                      struct ctdb_event_reply **reply)
 597 {
 598         struct command_script_list_state *state = tevent_req_data(
 599                 req, struct command_script_list_state);
 600         int ret;
 601
 602         if (tevent_req_is_unix_error(req, &ret)) {
 603                 if (perr != NULL) {
 604                         *perr = ret;
 605                 }
 606                 return false;
 607         }
 608
 609         if (reply != NULL) {
 610                 *reply = talloc_steal(mem_ctx, state->reply);
 611         }
 612         return true;
 613 }
 614
 615 /*
 616  * Process SCRIPT_ENABLE command
 617  */
 618
 619 struct command_script_enable_state {
 620         struct ctdb_event_reply *reply;
 621 };
 622
 623 static struct tevent_req *command_script_enable_send(
 624                                         TALLOC_CTX *mem_ctx,
 625                                         struct tevent_context *ev,
 626                                         struct eventd_context *ectx,
 627                                         struct eventd_client *client,
 628                                         struct ctdb_event_request *request)
 629 {
 630         struct tevent_req *req;
 631         struct command_script_enable_state *state;
 632         const char *script_name;
 633         int ret;
 634
 635         req = tevent_req_create(mem_ctx, &state,
 636                                 struct command_script_enable_state);
 637         if (req == NULL) {
 638                 return NULL;
 639         }
 640
 641         script_name = request->rdata.data.script_enable->script_name;
 642
 643         state->reply = talloc_zero(state, struct ctdb_event_reply);
 644         if (tevent_req_nomem(state->reply, req)) {
 645                 return tevent_req_post(req, ev);
 646         }
 647
 648         state->reply->rdata.command = request->rdata.command;
 649
 650         ret = run_event_script_enable(eventd_run_context(ectx), script_name);
 651         state->reply->rdata.result = -ret;
 652
 653         tevent_req_done(req);
 654         return tevent_req_post(req, ev);
 655 }
 656
 657 static bool command_script_enable_recv(struct tevent_req *req, int *perr,
 658                                        TALLOC_CTX *mem_ctx,
 659                                        struct ctdb_event_reply **reply)
 660 {
 661         struct command_script_enable_state *state = tevent_req_data(
 662                 req, struct command_script_enable_state);
 663         int ret;
 664
 665         if (tevent_req_is_unix_error(req, &ret)) {
 666                 if (perr != NULL) {
 667                         *perr = ret;
 668                 }
 669                 return false;
 670         }
 671
 672         if (reply != NULL) {
 673                 *reply = talloc_steal(mem_ctx, state->reply);
 674         }
 675         return true;
 676 }
 677
 678 /*
 679  * Process SCRIPT_DISABLE command
 680  */
 681
 682 struct command_script_disable_state {
 683         struct ctdb_event_reply *reply;
 684 };
 685
 686 static struct tevent_req *command_script_disable_send(
 687                                         TALLOC_CTX *mem_ctx,
 688                                         struct tevent_context *ev,
 689                                         struct eventd_context *ectx,
 690                                         struct eventd_client *client,
 691                                         struct ctdb_event_request *request)
 692 {
 693         struct tevent_req *req;
 694         struct command_script_disable_state *state;
 695         const char *script_name;
 696         int ret;
 697
 698         req = tevent_req_create(mem_ctx, &state,
 699                                 struct command_script_disable_state);
 700         if (req == NULL) {
 701                 return NULL;
 702         }
 703
 704         script_name = request->rdata.data.script_disable->script_name;
 705
 706         state->reply = talloc_zero(state, struct ctdb_event_reply);
 707         if (tevent_req_nomem(state->reply, req)) {
 708                 return tevent_req_post(req, ev);
 709         }
 710
 711         state->reply->rdata.command = request->rdata.command;
 712
 713         ret = run_event_script_disable(eventd_run_context(ectx), script_name);
 714         state->reply->rdata.result = -ret;
 715
 716         tevent_req_done(req);
 717         return tevent_req_post(req, ev);
 718 }
 719
 720 static bool command_script_disable_recv(struct tevent_req *req, int *perr,
 721                                         TALLOC_CTX *mem_ctx,
 722                                         struct ctdb_event_reply **reply)
 723 {
 724         struct command_script_disable_state *state = tevent_req_data(
 725                 req, struct command_script_disable_state);
 726         int ret;
 727
 728         if (tevent_req_is_unix_error(req, &ret)) {
 729                 if (perr != NULL) {
 730                         *perr = ret;
 731                 }
 732                 return false;
 733         }
 734
 735         if (reply != NULL) {
 736                 *reply = talloc_steal(mem_ctx, state->reply);
 737         }
 738         return true;
 739 }
 740
 741 /*
 742  * Process clients
 743  */
 744
 745 static struct eventd_client *client_find(struct eventd_context *ectx,
 746                                          struct sock_client_context *client_ctx)
 747 {
 748         struct eventd_client *client;
 749
 750         for (client = ectx->client_list;
 751              client != NULL;
 752              client = client->next) {
 753                 if (client->client_ctx == client_ctx) {
 754                         return client;
 755                 }
 756         }
 757
 758         return NULL;
 759 }
 760
 761 static bool client_connect(struct sock_client_context *client_ctx,
 762                            void *private_data)
 763 {
 764         struct eventd_context *ectx = talloc_get_type_abort(
 765                 private_data, struct eventd_context);
 766         struct eventd_client *client;
 767
 768         client = talloc_zero(ectx, struct eventd_client);
 769         if (client == NULL) {
 770                 return false;
 771         }
 772
 773         client->client_ctx = client_ctx;
 774
 775         DLIST_ADD(ectx->client_list, client);
 776         return true;
 777 }
 778
 779 static void client_disconnect(struct sock_client_context *client_ctx,
 780                               void *private_data)
 781 {
 782         struct eventd_context *ectx = talloc_get_type_abort(
 783                 private_data, struct eventd_context);
 784         struct eventd_client *client;
 785         struct pending_event *pe;
 786
 787         client = client_find(ectx, client_ctx);
 788         if (client == NULL) {
 789                 return;
 790         }
 791
 792         /* Get rid of pending events */
 793         while ((pe = client->pending_list) != NULL) {
 794                 DLIST_REMOVE(client->pending_list, pe);
 795                 talloc_free(pe->req);
 796         }
 797 }
 798
 799 struct client_process_state {
 800         struct tevent_context *ev;
 801
 802         struct eventd_client *client;
 803         struct ctdb_event_request request;
 804 };
 805
 806 static void client_run_done(struct tevent_req *subreq);
 807 static void client_status_done(struct tevent_req *subreq);
 808 static void client_script_list_done(struct tevent_req *subreq);
 809 static void client_script_enable_done(struct tevent_req *subreq);
 810 static void client_script_disable_done(struct tevent_req *subreq);
 811 static void client_process_reply(struct tevent_req *req,
 812                                  struct ctdb_event_reply *reply);
 813 static void client_process_reply_done(struct tevent_req *subreq);
 814
 815 static struct tevent_req *client_process_send(
 816                                 TALLOC_CTX *mem_ctx,
 817                                 struct tevent_context *ev,
 818                                 struct sock_client_context *client_ctx,
 819                                 uint8_t *buf, size_t buflen,
 820                                 void *private_data)
 821 {
 822         struct eventd_context *ectx = talloc_get_type_abort(
 823                 private_data, struct eventd_context);
 824         struct tevent_req *req, *subreq;
 825         struct client_process_state *state;
 826         int ret;
 827
 828         req = tevent_req_create(mem_ctx, &state, struct client_process_state);
 829         if (req == NULL) {
 830                 return NULL;
 831         }
 832
 833         state->ev = ev;
 834
 835         state->client = client_find(ectx, client_ctx);
 836         if (state->client == NULL) {
 837                 tevent_req_error(req, EIO);
 838                 return tevent_req_post(req, ev);
 839         }
 840
 841         ret = ctdb_event_request_pull(buf, buflen, state, &state->request);
 842         if (ret != 0) {
 843                 tevent_req_error(req, EPROTO);
 844                 return tevent_req_post(req, ev);
 845         }
 846
 847         switch (state->request.rdata.command) {
 848         case CTDB_EVENT_COMMAND_RUN:
 849                 subreq = command_run_send(state, ev, ectx, state->client,
 850                                           &state->request);
 851                 if (tevent_req_nomem(subreq, req)) {
 852                         return tevent_req_post(req, ev);
 853                 }
 854                 tevent_req_set_callback(subreq, client_run_done, req);
 855                 break;
 856
 857         case CTDB_EVENT_COMMAND_STATUS:
 858                 subreq = command_status_send(state, ev, ectx, state->client,
 859                                              &state->request);
 860                 if (tevent_req_nomem(subreq, req)) {
 861                         return tevent_req_post(req, ev);
 862                 }
 863                 tevent_req_set_callback(subreq, client_status_done, req);
 864                 break;
 865
 866         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 867                 subreq = command_script_list_send(state, ev, ectx,
 868                                                   state->client,
 869                                                   &state->request);
 870                 if (tevent_req_nomem(subreq, req)) {
 871                         return tevent_req_post(req, ev);
 872                 }
 873                 tevent_req_set_callback(subreq, client_script_list_done, req);
 874                 break;
 875
 876         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 877                 subreq = command_script_enable_send(state, ev, ectx,
 878                                                     state->client,
 879                                                     &state->request);
 880                 if (tevent_req_nomem(subreq, req)) {
 881                         return tevent_req_post(req, ev);
 882                 }
 883                 tevent_req_set_callback(subreq, client_script_enable_done,
 884                                         req);
 885                 break;
 886
 887         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 888                 subreq = command_script_disable_send(state, ev, ectx,
 889                                                      state->client,
 890                                                      &state->request);
 891                 if (tevent_req_nomem(subreq, req)) {
 892                         return tevent_req_post(req, ev);
 893                 }
 894                 tevent_req_set_callback(subreq, client_script_disable_done,
 895                                         req);
 896                 break;
 897         }
 898
 899         return req;
 900 }
 901
 902 static void client_run_done(struct tevent_req *subreq)
 903 {
 904         struct tevent_req *req = tevent_req_callback_data(
 905                 subreq, struct tevent_req);
 906         struct client_process_state *state = tevent_req_data(
 907                 req, struct client_process_state);
 908         struct ctdb_event_reply *reply = NULL;
 909         int ret = 0;
 910         bool status;
 911
 912         status = command_run_recv(subreq, &ret, state, &reply);
 913         TALLOC_FREE(subreq);
 914         if (! status) {
 915                 D_ERR("COMMAND_RUN failed\n");
 916                 tevent_req_error(req, ret);
 917                 return;
 918         }
 919
 920         client_process_reply(req, reply);
 921         talloc_free(reply);
 922 }
 923
 924 static void client_status_done(struct tevent_req *subreq)
 925 {
 926         struct tevent_req *req = tevent_req_callback_data(
 927                 subreq, struct tevent_req);
 928         struct client_process_state *state = tevent_req_data(
 929                 req, struct client_process_state);
 930         struct ctdb_event_reply *reply = NULL;
 931         int ret = 0;
 932         bool status;
 933
 934         status = command_status_recv(subreq, &ret, state, &reply);
 935         TALLOC_FREE(subreq);
 936         if (! status) {
 937                 D_ERR("COMMAND_STATUS failed\n");
 938                 tevent_req_error(req, ret);
 939                 return;
 940         }
 941
 942         client_process_reply(req, reply);
 943         talloc_free(reply);
 944 }
 945
 946 static void client_script_list_done(struct tevent_req *subreq)
 947 {
 948         struct tevent_req *req = tevent_req_callback_data(
 949                 subreq, struct tevent_req);
 950         struct client_process_state *state = tevent_req_data(
 951                 req, struct client_process_state);
 952         struct ctdb_event_reply *reply = NULL;
 953         int ret = 0;
 954         bool status;
 955
 956         status = command_script_list_recv(subreq, &ret, state, &reply);
 957         TALLOC_FREE(subreq);
 958         if (! status) {
 959                 D_ERR("COMMAND_SCRIPT_LIST failed\n");
 960                 tevent_req_error(req, ret);
 961                 return;
 962         }
 963
 964         client_process_reply(req, reply);
 965         talloc_free(reply);
 966 }
 967
 968 static void client_script_enable_done(struct tevent_req *subreq)
 969 {
 970         struct tevent_req *req = tevent_req_callback_data(
 971                 subreq, struct tevent_req);
 972         struct client_process_state *state = tevent_req_data(
 973                 req, struct client_process_state);
 974         struct ctdb_event_reply *reply = NULL;
 975         int ret = 0;
 976         bool status;
 977
 978         status = command_script_enable_recv(subreq, &ret, state, &reply);
 979         TALLOC_FREE(subreq);
 980         if (! status) {
 981                 D_ERR("COMMAND_SCRIPT_ENABLE failed\n");
 982                 tevent_req_error(req, ret);
 983                 return;
 984         }
 985
 986         client_process_reply(req, reply);
 987         talloc_free(reply);
 988 }
 989
 990 static void client_script_disable_done(struct tevent_req *subreq)
 991 {
 992         struct tevent_req *req = tevent_req_callback_data(
 993                 subreq, struct tevent_req);
 994         struct client_process_state *state = tevent_req_data(
 995                 req, struct client_process_state);
 996         struct ctdb_event_reply *reply = NULL;
 997         int ret = 0;
 998         bool status;
 999
1000         status = command_script_disable_recv(subreq, &ret, state, &reply);
1001         TALLOC_FREE(subreq);
1002         if (! status) {
1003                 D_ERR("COMMAND_SCRIPT_DISABLE failed\n");
1004                 tevent_req_error(req, ret);
1005                 return;
1006         }
1007
1008         client_process_reply(req, reply);
1009         talloc_free(reply);
1010 }
1011
1012 static void client_process_reply(struct tevent_req *req,
1013                                  struct ctdb_event_reply *reply)
1014 {
1015         struct client_process_state *state = tevent_req_data(
1016                 req, struct client_process_state);
1017         struct tevent_req *subreq;
1018         uint8_t *buf;
1019         size_t buflen;
1020         int ret;
1021
1022         ctdb_event_header_fill(&reply->header, state->request.header.reqid);
1023
1024         buflen = ctdb_event_reply_len(reply);
1025         buf = talloc_zero_size(state, buflen);
1026         if (tevent_req_nomem(buf, req)) {
1027                 return;
1028         }
1029
1030         ret = ctdb_event_reply_push(reply, buf, &buflen);
1031         if (ret != 0) {
1032                 talloc_free(buf);
1033                 tevent_req_error(req, ret);
1034                 return;
1035         }
1036
1037         subreq = sock_socket_write_send(state, state->ev,
1038                                         state->client->client_ctx,
1039                                         buf, buflen);
1040         if (tevent_req_nomem(subreq, req)) {
1041                 return;
1042         }
1043         tevent_req_set_callback(subreq, client_process_reply_done, req);
1044 }
1045
1046 static void client_process_reply_done(struct tevent_req *subreq)
1047 {
1048         struct tevent_req *req = tevent_req_callback_data(
1049                 subreq, struct tevent_req);
1050         int ret;
1051         bool status;
1052
1053         status = sock_socket_write_recv(subreq, &ret);
1054         TALLOC_FREE(subreq);
1055         if (! status) {
1056                 D_ERR("Sending reply failed\n");
1057                 tevent_req_error(req, ret);
1058                 return;
1059         }
1060
1061         tevent_req_done(req);
1062 }
1063
1064 static bool client_process_recv(struct tevent_req *req, int *perr)
1065 {
1066         int ret;
1067
1068         if (tevent_req_is_unix_error(req, &ret)) {
1069                 if (perr != NULL) {
1070                         *perr = ret;
1071                 }
1072                 return false;
1073         }
1074
1075         return true;
1076 }
1077
1078 /*
1079  * Event daemon
1080  */
1081
1082 static void eventd_shutdown(void *private_data)
1083 {
1084         struct eventd_context *ectx = talloc_get_type_abort(
1085                 private_data, struct eventd_context);
1086         struct eventd_client *client;
1087
1088         while ((client = ectx->client_list) != NULL) {
1089                 DLIST_REMOVE(ectx->client_list, client);
1090                 talloc_free(client);
1091         }
1092 }
1093
1094 static struct {
1095         const char *debug_script;
1096         const char *script_dir;
1097         const char *logging;
1098         const char *debug_level;
1099         const char *pidfile;
1100         const char *socket;
1101         int pid;
1102 } options = {
1103         .debug_level = "ERR",
1104 };
1105
1106 struct poptOption cmdline_options[] = {
1107         POPT_AUTOHELP
1108         { "debug_script", 'D', POPT_ARG_STRING, &options.debug_script, 0,
1109                 "debug script", "FILE" },
1110         { "pid", 'P', POPT_ARG_INT, &options.pid, 0,
1111                 "pid to wait for", "PID" },
1112         { "event_script_dir", 'e', POPT_ARG_STRING, &options.script_dir, 0,
1113                 "event script dir", "DIRECTORY" },
1114         { "logging", 'l', POPT_ARG_STRING, &options.logging, 0,
1115                 "logging specification" },
1116         { "debug", 'd', POPT_ARG_STRING, &options.debug_level, 0,
1117                 "debug level" },
1118         { "pidfile", 'p', POPT_ARG_STRING, &options.pidfile, 0,
1119                 "eventd pid file", "FILE" },
1120         { "socket", 's', POPT_ARG_STRING, &options.socket, 0,
1121                 "eventd socket path", "FILE" },
1122         POPT_TABLEEND
1123 };
1124
1125 int main(int argc, const char **argv)
1126 {
1127         poptContext pc;
1128         TALLOC_CTX *mem_ctx;
1129         struct tevent_context *ev;
1130         struct eventd_context *ectx;
1131         struct sock_daemon_context *sockd;
1132         struct sock_daemon_funcs daemon_funcs;
1133         struct sock_socket_funcs socket_funcs;
1134         struct stat statbuf;
1135         int opt, ret;
1136
1137         /* Set default options */
1138         options.pid = -1;
1139
1140         pc = poptGetContext(argv[0], argc, argv, cmdline_options,
1141                             POPT_CONTEXT_KEEP_FIRST);
1142         while ((opt = poptGetNextOpt(pc)) != -1) {
1143                 fprintf(stderr, "Invalid options %s: %s\n",
1144                         poptBadOption(pc, 0), poptStrerror(opt));
1145                 exit(1);
1146         }
1147
1148         if (options.socket == NULL) {
1149                 fprintf(stderr, "Please specify eventd socket (--socket)\n");
1150                 exit(1);
1151         }
1152
1153         if (options.script_dir == NULL) {
1154                 fprintf(stderr,
1155                         "Please specify script dir (--event_script_dir)\n");
1156                 exit(1);
1157         }
1158
1159         if (options.logging == NULL) {
1160                 fprintf(stderr,
1161                         "Please specify logging (--logging)\n");
1162                 exit(1);
1163         }
1164
1165         ret = stat(options.script_dir, &statbuf);
1166         if (ret != 0) {
1167                 ret = errno;
1168                 fprintf(stderr, "Error reading script_dir %s, ret=%d\n",
1169                         options.script_dir, ret);
1170                 exit(1);
1171         }
1172         if (! S_ISDIR(statbuf.st_mode)) {
1173                 fprintf(stderr, "script_dir %s is not a directory\n",
1174                         options.script_dir);
1175                 exit(1);
1176         }
1177
1178         mem_ctx = talloc_new(NULL);
1179         if (mem_ctx == NULL) {
1180                 exit(1);
1181         }
1182
1183         ev = tevent_context_init(mem_ctx);
1184         if (ev == NULL) {
1185                 ret = 1;
1186                 goto fail;
1187         }
1188
1189         ret = eventd_context_init(mem_ctx, ev, options.script_dir,
1190                                   options.debug_script, &ectx);
1191         if (ret != 0) {
1192                 goto fail;
1193         }
1194
1195         daemon_funcs = (struct sock_daemon_funcs) {
1196                 .shutdown = eventd_shutdown,
1197         };
1198
1199         ret = sock_daemon_setup(mem_ctx, "ctdb-eventd", options.logging,
1200                                 options.debug_level, options.pidfile,
1201                                 &daemon_funcs, ectx, &sockd);
1202         if (ret != 0) {
1203                 goto fail;
1204         }
1205
1206         socket_funcs = (struct sock_socket_funcs) {
1207                 .connect = client_connect,
1208                 .disconnect = client_disconnect,
1209                 .read_send = client_process_send,
1210                 .read_recv = client_process_recv,
1211         };
1212
1213         ret = sock_daemon_add_unix(sockd, options.socket, &socket_funcs, ectx);
1214         if (ret != 0) {
1215                 goto fail;
1216         }
1217
1218         ret = sock_daemon_run(ev, sockd, options.pid);
1219         if (ret == EINTR) {
1220                 ret = 0;
1221         }
1222
1223 fail:
1224         talloc_free(mem_ctx);
1225         (void)poptFreeContext(pc);
1226         exit(ret);
1227 }