ctdb/tests/src/protocol_common_event.c

   1 /*
   2    protocol tests - eventd protocol
   3
   4    Copyright (C) Amitay Isaacs  2017
   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/network.h"
  22
  23 #include <assert.h>
  24
  25 #include "tests/src/protocol_common.h"
  26 #include "tests/src/protocol_common_event.h"
  27
  28 /*
  29  * Functions to fill and verify eventd protocol structures
  30  */
  31
  32 void fill_ctdb_event_request_run(TALLOC_CTX *mem_ctx,
  33                                  struct ctdb_event_request_run *p)
  34 {
  35         p->event = rand_int(CTDB_EVENT_MAX);
  36         p->timeout = rand();
  37         fill_ctdb_string(mem_ctx, &p->arg_str);
  38 }
  39
  40 void verify_ctdb_event_request_run(struct ctdb_event_request_run *p1,
  41                                    struct ctdb_event_request_run *p2)
  42 {
  43         assert(p1->event == p2->event);
  44         assert(p1->timeout == p2->timeout);
  45         verify_ctdb_string(&p1->arg_str, &p2->arg_str);
  46 }
  47
  48 void fill_ctdb_event_request_status(TALLOC_CTX *mem_ctx,
  49                                     struct ctdb_event_request_status *p)
  50 {
  51         p->event = rand_int(CTDB_EVENT_MAX);
  52         p->state = rand_int(3) + 1;
  53 }
  54
  55 void verify_ctdb_event_request_status(struct ctdb_event_request_status *p1,
  56                                       struct ctdb_event_request_status *p2)
  57 {
  58         assert(p1->event == p2->event);
  59         assert(p1->state == p2->state);
  60 }
  61
  62 void fill_ctdb_event_request_script_enable(TALLOC_CTX *mem_ctx,
  63                                 struct ctdb_event_request_script_enable *p)
  64 {
  65         fill_ctdb_string(mem_ctx, &p->script_name);
  66 }
  67
  68 void verify_ctdb_event_request_script_enable(
  69                                 struct ctdb_event_request_script_enable *p1,
  70                                 struct ctdb_event_request_script_enable *p2)
  71 {
  72         verify_ctdb_string(&p1->script_name, &p2->script_name);
  73 }
  74
  75 void fill_ctdb_event_request_script_disable(TALLOC_CTX *mem_ctx,
  76                                 struct ctdb_event_request_script_disable *p)
  77 {
  78         fill_ctdb_string(mem_ctx, &p->script_name);
  79 }
  80
  81 void verify_ctdb_event_request_script_disable(
  82                                 struct ctdb_event_request_script_disable *p1,
  83                                 struct ctdb_event_request_script_disable *p2)
  84 {
  85         verify_ctdb_string(&p1->script_name, &p2->script_name);
  86 }
  87
  88 void fill_ctdb_event_reply_status(TALLOC_CTX *mem_ctx,
  89                                   struct ctdb_event_reply_status *p)
  90 {
  91         if (rand_int(2) == 0) {
  92                 p->status = 0;
  93                 p->script_list = talloc(mem_ctx, struct ctdb_script_list);
  94                 assert(p->script_list != NULL);
  95                 fill_ctdb_script_list(mem_ctx, p->script_list);
  96         } else {
  97                 p->status = rand32i();
  98                 p->script_list = NULL;
  99         }
 100 }
 101
 102 void verify_ctdb_event_reply_status(struct ctdb_event_reply_status *p1,
 103                                     struct ctdb_event_reply_status *p2)
 104 {
 105         assert(p1->status == p2->status);
 106         if (p1->script_list == NULL) {
 107                 assert(p1->script_list == p2->script_list);
 108         } else {
 109                 verify_ctdb_script_list(p1->script_list, p2->script_list);
 110         }
 111 }
 112
 113 void fill_ctdb_event_reply_script_list(TALLOC_CTX *mem_ctx,
 114                                        struct ctdb_event_reply_script_list *p)
 115 {
 116         p->script_list = talloc(mem_ctx, struct ctdb_script_list);
 117         assert(p->script_list != NULL);
 118
 119         fill_ctdb_script_list(mem_ctx, p->script_list);
 120 }
 121
 122 void verify_ctdb_event_reply_script_list(
 123                                 struct ctdb_event_reply_script_list *p1,
 124                                 struct ctdb_event_reply_script_list *p2)
 125 {
 126         verify_ctdb_script_list(p1->script_list, p2->script_list);
 127 }
 128
 129 void fill_ctdb_event_request_data(TALLOC_CTX *mem_ctx,
 130                                   struct ctdb_event_request_data *r,
 131                                   uint32_t command)
 132 {
 133         r->command = command;
 134
 135         switch (command) {
 136         case CTDB_EVENT_COMMAND_RUN:
 137                 r->data.run = talloc(mem_ctx, struct ctdb_event_request_run);
 138                 assert(r->data.run != NULL);
 139
 140                 fill_ctdb_event_request_run(mem_ctx, r->data.run);
 141                 break;
 142
 143         case CTDB_EVENT_COMMAND_STATUS:
 144                 r->data.status = talloc(mem_ctx,
 145                                         struct ctdb_event_request_status);
 146                 assert(r->data.status != NULL);
 147
 148                 fill_ctdb_event_request_status(mem_ctx, r->data.status);
 149                 break;
 150
 151         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 152                 break;
 153
 154         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 155                 r->data.script_enable = talloc(mem_ctx,
 156                                 struct ctdb_event_request_script_enable);
 157                 assert(r->data.script_enable != NULL);
 158
 159                 fill_ctdb_event_request_script_enable(mem_ctx,
 160                                                       r->data.script_enable);
 161                 break;
 162
 163         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 164                 r->data.script_disable = talloc(mem_ctx,
 165                                 struct ctdb_event_request_script_disable);
 166                 assert(r->data.script_disable != NULL);
 167
 168                 fill_ctdb_event_request_script_disable(mem_ctx,
 169                                                        r->data.script_disable);
 170                 break;
 171         }
 172 }
 173
 174 void verify_ctdb_event_request_data(struct ctdb_event_request_data *r,
 175                                     struct ctdb_event_request_data *r2)
 176 {
 177         assert(r->command == r2->command);
 178
 179         switch (r->command) {
 180         case CTDB_EVENT_COMMAND_RUN:
 181                 verify_ctdb_event_request_run(r->data.run, r2->data.run);
 182                 break;
 183
 184         case CTDB_EVENT_COMMAND_STATUS:
 185                 verify_ctdb_event_request_status(r->data.status,
 186                                                  r2->data.status);
 187                 break;
 188
 189         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 190                 break;
 191
 192         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 193                 verify_ctdb_event_request_script_enable(r->data.script_enable,
 194                                                         r2->data.script_enable);
 195                 break;
 196
 197         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 198                 verify_ctdb_event_request_script_disable(r->data.script_disable,
 199                                                          r2->data.script_disable);
 200                 break;
 201         }
 202 }
 203
 204 void fill_ctdb_event_reply_data(TALLOC_CTX *mem_ctx,
 205                                 struct ctdb_event_reply_data *r,
 206                                 uint32_t command)
 207 {
 208         r->command = command;
 209         r->result = rand32i();
 210
 211         switch (command) {
 212         case CTDB_EVENT_COMMAND_STATUS:
 213                 r->data.status = talloc(mem_ctx,
 214                                         struct ctdb_event_reply_status);
 215                 assert(r->data.status != NULL);
 216
 217                 fill_ctdb_event_reply_status(mem_ctx, r->data.status);
 218                 break;
 219
 220         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 221                 r->data.script_list = talloc(mem_ctx,
 222                                 struct ctdb_event_reply_script_list);
 223                 assert(r->data.script_list != NULL);
 224
 225                 fill_ctdb_event_reply_script_list(mem_ctx,
 226                                                   r->data.script_list);
 227                 break;
 228         }
 229 }
 230
 231 void verify_ctdb_event_reply_data(struct ctdb_event_reply_data *r,
 232                                   struct ctdb_event_reply_data *r2)
 233 {
 234         assert(r->command == r2->command);
 235         assert(r->result == r2->result);
 236
 237         switch (r->command) {
 238         case CTDB_EVENT_COMMAND_RUN:
 239                 break;
 240
 241         case CTDB_EVENT_COMMAND_STATUS:
 242                 verify_ctdb_event_reply_status(r->data.status,
 243                                                r2->data.status);
 244                 break;
 245
 246         case CTDB_EVENT_COMMAND_SCRIPT_LIST:
 247                 verify_ctdb_event_reply_script_list(r->data.script_list,
 248                                                     r2->data.script_list);
 249                 break;
 250
 251         case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
 252                 break;
 253
 254         case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
 255                 break;
 256         }
 257 }
 258
 259 void fill_ctdb_event_request(TALLOC_CTX *mem_ctx,
 260                              struct ctdb_event_request *r, uint32_t command)
 261 {
 262         fill_sock_packet_header(&r->header);
 263         fill_ctdb_event_request_data(mem_ctx, &r->rdata, command);
 264 }
 265
 266 void verify_ctdb_event_request(struct ctdb_event_request *r,
 267                                struct ctdb_event_request *r2)
 268 {
 269         verify_sock_packet_header(&r->header, &r2->header);
 270         verify_ctdb_event_request_data(&r->rdata, &r2->rdata);
 271 }
 272
 273 void fill_ctdb_event_reply(TALLOC_CTX *mem_ctx, struct ctdb_event_reply *r,
 274                            uint32_t command)
 275 {
 276         fill_sock_packet_header(&r->header);
 277         fill_ctdb_event_reply_data(mem_ctx, &r->rdata, command);
 278 }
 279
 280 void verify_ctdb_event_reply(struct ctdb_event_reply *r,
 281                              struct ctdb_event_reply *r2)
 282 {
 283         verify_sock_packet_header(&r->header, &r2->header);
 284         verify_ctdb_event_reply_data(&r->rdata, &r2->rdata);
 285 }