source3/torture/test_ctdbconn.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Test new ctdb API
   4    Copyright (C) Volker Lendecke 2012
   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 "includes.h"
  21 #include "torture/proto.h"
  22
  23 #ifdef CLUSTER_SUPPORT
  24
  25 #include "ctdb_conn.h"
  26 #include "lib/util/tevent_unix.h"
  27 #include "tdb.h"
  28
  29 #ifdef HAVE_CTDB_PROTOCOL_H
  30 #include "ctdb_protocol.h"
  31 #else
  32 #include "ctdb_private.h"
  33 #endif
  34
  35 #include "messages.h"
  36
  37 struct ctdb_conn_test_state {
  38         struct tevent_context *ev;
  39         struct ctdb_conn *conn;
  40         struct ctdb_msg_channel *channel;
  41         int msgno;
  42 };
  43
  44 static void ctdb_conn_test_got_conn(struct tevent_req *subreq);
  45 static void ctdb_conn_test_got_pnn(struct tevent_req *subreq);
  46 static void ctdb_conn_test_got_channel(struct tevent_req *subreq);
  47 static void ctdb_conn_test_got_msg(struct tevent_req *subreq);
  48 static void ctdb_conn_test_msg_sent(struct tevent_req *subreq);
  49
  50 static struct tevent_req *ctdb_conn_test_send(TALLOC_CTX *mem_ctx,
  51                                               struct tevent_context *ev)
  52 {
  53         struct tevent_req *req, *subreq;
  54         struct ctdb_conn_test_state *state;
  55
  56         req = tevent_req_create(mem_ctx, &state, struct ctdb_conn_test_state);
  57         if (req == NULL) {
  58                 return NULL;
  59         }
  60         state->ev = ev;
  61
  62         subreq = ctdb_conn_init_send(mem_ctx, ev, lp_ctdbd_socket());
  63         if (tevent_req_nomem(subreq, req)) {
  64                 return tevent_req_post(req, ev);
  65         }
  66         tevent_req_set_callback(subreq, ctdb_conn_test_got_conn, req);
  67         return req;
  68 }
  69
  70 static void ctdb_conn_test_got_conn(struct tevent_req *subreq)
  71 {
  72         struct tevent_req *req = tevent_req_callback_data(
  73                 subreq, struct tevent_req);
  74         struct ctdb_conn_test_state *state = tevent_req_data(
  75                 req, struct ctdb_conn_test_state);
  76         uint64_t ret;
  77
  78         ret = ctdb_conn_init_recv(subreq, state, &state->conn);
  79         TALLOC_FREE(subreq);
  80         if (tevent_req_error(req, ret)) {
  81                 return;
  82         }
  83         subreq = ctdb_conn_control_send(state, state->ev, state->conn,
  84                                         CTDB_CURRENT_NODE,
  85                                         CTDB_CONTROL_GET_PNN, 0, 0, NULL, 0);
  86         if (tevent_req_nomem(subreq, req)) {
  87                 return;
  88         }
  89         tevent_req_set_callback(subreq, ctdb_conn_test_got_pnn, req);
  90 }
  91
  92 static void ctdb_conn_test_got_pnn(struct tevent_req *subreq)
  93 {
  94         struct tevent_req *req = tevent_req_callback_data(
  95                 subreq, struct tevent_req);
  96         struct ctdb_conn_test_state *state = tevent_req_data(
  97                 req, struct ctdb_conn_test_state);
  98         int ret;
  99         struct ctdb_reply_control *reply;
 100
 101         ret = ctdb_conn_control_recv(subreq, talloc_tos(), &reply);
 102         TALLOC_FREE(subreq);
 103         if (tevent_req_error(req, ret)) {
 104                 return;
 105         }
 106         printf("vnn=%d\n", (int)reply->status);
 107
 108         subreq = ctdb_msg_channel_init_send(
 109                 state, state->ev, lp_ctdbd_socket(), 999999);
 110         if (tevent_req_nomem(subreq, req)) {
 111                 return;
 112         }
 113         tevent_req_set_callback(subreq, ctdb_conn_test_got_channel, req);
 114 }
 115
 116 static void ctdb_conn_test_got_channel(struct tevent_req *subreq)
 117 {
 118         struct tevent_req *req = tevent_req_callback_data(
 119                 subreq, struct tevent_req);
 120         struct ctdb_conn_test_state *state = tevent_req_data(
 121                 req, struct ctdb_conn_test_state);
 122         int ret;
 123
 124         ret = ctdb_msg_channel_init_recv(subreq, state, &state->channel);
 125         TALLOC_FREE(subreq);
 126         if (tevent_req_error(req, ret)) {
 127                 return;
 128         }
 129
 130         subreq = ctdb_msg_read_send(state, state->ev, state->channel);
 131         if (tevent_req_nomem(subreq, req)) {
 132                 return;
 133         }
 134         tevent_req_set_callback(subreq, ctdb_conn_test_got_msg, req);
 135
 136         state->msgno += 1;
 137
 138         subreq = ctdb_conn_msg_write_send(
 139                 state, state->ev, state->conn, CTDB_CURRENT_NODE, 999999,
 140                 (uint8_t *)&state->msgno, sizeof(state->msgno));
 141         if (tevent_req_nomem(subreq, req)) {
 142                 return;
 143         }
 144         tevent_req_set_callback(subreq, ctdb_conn_test_msg_sent, req);
 145 }
 146
 147 static void ctdb_conn_test_got_msg(struct tevent_req *subreq)
 148 {
 149         struct tevent_req *req = tevent_req_callback_data(
 150                 subreq, struct tevent_req);
 151         struct ctdb_conn_test_state *state = tevent_req_data(
 152                 req, struct ctdb_conn_test_state);
 153         uint8_t *buf;
 154         size_t buf_len;
 155         int ret;
 156
 157         ret = ctdb_msg_read_recv(subreq, talloc_tos(), &buf, &buf_len);
 158         TALLOC_FREE(subreq);
 159         if (tevent_req_error(req, ret)) {
 160                 return;
 161         }
 162         if (buf_len != sizeof(int)) {
 163                 printf("got invalid msg\n");
 164                 tevent_req_error(req, EINVAL);
 165                 return;
 166         }
 167         memcpy(&ret, buf, buf_len);
 168         printf("got msg %d\n", ret);
 169         if (ret == 5) {
 170                 tevent_req_done(req);
 171                 return;
 172         }
 173
 174         subreq = ctdb_msg_read_send(state, state->ev, state->channel);
 175         if (tevent_req_nomem(subreq, req)) {
 176                 return;
 177         }
 178         tevent_req_set_callback(subreq, ctdb_conn_test_got_msg, req);
 179 }
 180
 181 static void ctdb_conn_test_msg_sent(struct tevent_req *subreq)
 182 {
 183         struct tevent_req *req = tevent_req_callback_data(
 184                 subreq, struct tevent_req);
 185         struct ctdb_conn_test_state *state = tevent_req_data(
 186                 req, struct ctdb_conn_test_state);
 187         int ret;
 188
 189         ret = ctdb_conn_msg_write_recv(subreq);
 190         TALLOC_FREE(subreq);
 191         if (tevent_req_error(req, ret)) {
 192                 return;
 193         }
 194         state->msgno += 1;
 195
 196         if (state->msgno >= 10) {
 197                 return;
 198         }
 199
 200         subreq = ctdb_conn_msg_write_send(
 201                 state, state->ev, state->conn, CTDB_CURRENT_NODE, 999999,
 202                 (uint8_t *)&state->msgno, sizeof(state->msgno));
 203         if (tevent_req_nomem(subreq, req)) {
 204                 return;
 205         }
 206         tevent_req_set_callback(subreq, ctdb_conn_test_msg_sent, req);
 207 }
 208
 209 static int ctdb_conn_test_recv(struct tevent_req *req)
 210 {
 211         int err;
 212         if (tevent_req_is_unix_error(req, &err)) {
 213                 return err;
 214         }
 215         return 0;
 216 }
 217
 218 bool run_ctdb_conn(int dummy)
 219 {
 220         struct tevent_context *ev;
 221         struct tevent_req *req;
 222         int ret;
 223
 224         ev = tevent_context_init(talloc_tos());
 225         if (ev == NULL) {
 226                 fprintf(stderr, "tevent_context_init failed\n");
 227                 return false;
 228         }
 229         req = ctdb_conn_test_send(ev, ev);
 230         if (req == NULL) {
 231                 fprintf(stderr, "ctdb_conn_test_send failed\n");
 232                 return false;
 233         }
 234         if (!tevent_req_poll(req, ev)) {
 235                 fprintf(stderr, "tevent_req_poll failed\n");
 236                 return false;
 237         }
 238         ret = ctdb_conn_test_recv(req);
 239         TALLOC_FREE(req);
 240         printf("ctdb_conn_test returned %s\n",
 241                ret ? strerror(ret) : "success");
 242         TALLOC_FREE(ev);
 243         return (ret == 0);
 244 }
 245
 246 #else /* CLUSTER_SUPPORT */
 247
 248 bool run_ctdb_conn(int dummy)
 249 {
 250         return true;
 251 }
 252
 253 #endif