diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 17:20:00 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 17:20:00 +0000 |
commit | 8daa83a594a2e98f39d764422bfbdbc62c9efd44 (patch) | |
tree | 4099e8021376c7d8c05bdf8503093d80e9c7bad0 /ctdb/tests/src/tunnel_test.c | |
parent | Initial commit. (diff) | |
download | samba-8daa83a594a2e98f39d764422bfbdbc62c9efd44.tar.xz samba-8daa83a594a2e98f39d764422bfbdbc62c9efd44.zip |
Adding upstream version 2:4.20.0+dfsg.upstream/2%4.20.0+dfsg
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | ctdb/tests/src/tunnel_test.c | 480 |
1 files changed, 480 insertions, 0 deletions
diff --git a/ctdb/tests/src/tunnel_test.c b/ctdb/tests/src/tunnel_test.c new file mode 100644 index 0000000..a6d44ba --- /dev/null +++ b/ctdb/tests/src/tunnel_test.c @@ -0,0 +1,480 @@ +/* + CTDB tunnel test + + Copyright (C) Amitay Isaacs 2017 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, see <http://www.gnu.org/licenses/>. +*/ + +#include "replace.h" +#include "system/network.h" + +#include "lib/util/debug.h" +#include "lib/util/tevent_unix.h" + +#include "protocol/protocol_private.h" +#include "client/client.h" +#include "tests/src/test_options.h" +#include "tests/src/cluster_wait.h" + +struct test_data { + uint32_t pnn; + uint32_t count; +}; + +static size_t test_data_len(struct test_data *in) +{ + return ctdb_uint32_len(&in->pnn) + ctdb_uint32_len(&in->count); +} + +static void test_data_push(struct test_data *in, uint8_t *buf, size_t *npush) +{ + size_t offset = 0, np; + + ctdb_uint32_push(&in->pnn, buf+offset, &np); + offset += np; + + ctdb_uint32_push(&in->count, buf+offset, &np); + offset += np; + + *npush = offset; +} + +static int test_data_pull(uint8_t *buf, size_t buflen, struct test_data *out, + size_t *npull) +{ + size_t offset = 0, np; + int ret; + + ret = ctdb_uint32_pull(buf+offset, buflen-offset, &out->pnn, &np); + if (ret != 0) { + return ret; + } + offset += np; + + ret = ctdb_uint32_pull(buf+offset, buflen-offset, &out->count, &np); + if (ret != 0) { + return ret; + } + offset += np; + + *npull = offset; + return 0; +} + +/* + * Set up 2 tunnels from each node - one to the next node and one to the + * previous node. The tunnel to the next node is used for sending data and + * tunnel to the previous node is used for receiving data. + */ + +struct tunnel_test_state { + struct tevent_context *ev; + struct ctdb_client_context *client; + int num_nodes; + int timelimit; + + uint32_t pnn; + uint32_t next_node; + uint32_t prev_node; + bool done; + struct ctdb_tunnel_context *send_tunnel; + struct ctdb_tunnel_context *recv_tunnel; + uint32_t count; + uint8_t *buf; +}; + +static void tunnel_test_send_tunnel_done(struct tevent_req *subreq); +static void tunnel_test_recv_tunnel_done(struct tevent_req *subreq); +static void tunnel_test_start(struct tevent_req *subreq); +static void tunnel_test_msg_send(struct tevent_req *req, + struct test_data *tdata); +static void tunnel_test_msg_send_done(struct tevent_req *subreq); +static void tunnel_test_handler(struct ctdb_tunnel_context *tctx, + uint32_t srcnode, uint32_t reqid, + uint8_t *buf, size_t buflen, + void *private_data); +static void tunnel_test_done(struct tevent_req *subreq); +static void tunnel_test_finish(struct tevent_req *subreq); +static void tunnel_test_send_tunnel_closed(struct tevent_req *subreq); +static void tunnel_test_recv_tunnel_closed(struct tevent_req *subreq); + +static struct tevent_req *tunnel_test_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct ctdb_client_context *client, + int num_nodes, int timelimit) +{ + struct tevent_req *req, *subreq; + struct tunnel_test_state *state; + + req = tevent_req_create(mem_ctx, &state, struct tunnel_test_state); + if (req == NULL) { + return NULL; + } + + state->ev = ev; + state->client = client; + state->num_nodes = num_nodes; + state->timelimit = timelimit; + state->pnn = ctdb_client_pnn(client); + state->prev_node = (state->pnn + num_nodes - 1) % num_nodes; + state->next_node = (state->pnn + 1) % num_nodes; + state->done = false; + + subreq = ctdb_tunnel_setup_send(state, state->ev, state->client, + CTDB_TUNNEL_TEST | state->pnn, + tunnel_test_handler, req); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, tunnel_test_send_tunnel_done, req); + + return req; +} + +static void tunnel_test_send_tunnel_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + int ret; + bool status; + + status = ctdb_tunnel_setup_recv(subreq, &ret, &state->send_tunnel); + TALLOC_FREE(subreq); + if (! status) { + tevent_req_error(req, ret); + return; + } + + subreq = ctdb_tunnel_setup_send(state, state->ev, state->client, + CTDB_TUNNEL_TEST | state->prev_node, + tunnel_test_handler, req); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, tunnel_test_recv_tunnel_done, req); +} + +static void tunnel_test_recv_tunnel_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + int ret; + bool status; + + status = ctdb_tunnel_setup_recv(subreq, &ret, &state->recv_tunnel); + TALLOC_FREE(subreq); + if (! status) { + tevent_req_error(req, ret); + return; + } + + subreq = cluster_wait_send(state, state->ev, state->client, + state->num_nodes); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, tunnel_test_start, req); +} + +static void tunnel_test_start(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + struct test_data tdata; + int ret; + bool status; + + status = cluster_wait_recv(subreq, &ret); + TALLOC_FREE(subreq); + if (! status) { + tevent_req_error(req, ret); + return; + } + + subreq = tevent_wakeup_send(state, state->ev, + tevent_timeval_current_ofs(state->timelimit, 0)); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, tunnel_test_done, req); + + tdata.pnn = state->pnn; + tdata.count = state->count; + tunnel_test_msg_send(req, &tdata); +} + +static void tunnel_test_msg_send(struct tevent_req *req, + struct test_data *tdata) +{ + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + struct tevent_req *subreq; + size_t buflen, np; + + buflen = test_data_len(tdata); + state->buf = talloc_size(state, buflen); + if (tevent_req_nomem(state->buf, req)) { + return; + } + test_data_push(tdata, state->buf, &np); + + subreq = ctdb_tunnel_request_send(state, state->ev, + state->send_tunnel, + state->next_node, + tevent_timeval_zero(), + state->buf, buflen, false); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, tunnel_test_msg_send_done, req); +} + +static void tunnel_test_msg_send_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + int ret; + bool status; + + status = ctdb_tunnel_request_recv(subreq, &ret, NULL, NULL, NULL); + TALLOC_FREE(subreq); + if (! status) { + tevent_req_error(req, ret); + return; + } + + TALLOC_FREE(state->buf); +} + +static void tunnel_test_handler(struct ctdb_tunnel_context *tctx, + uint32_t srcnode, uint32_t reqid, + uint8_t *buf, size_t buflen, + void *private_data) +{ + struct tevent_req *req = talloc_get_type_abort( + private_data, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + struct test_data tdata; + size_t np; + int ret; + + if (state->done) { + return; + } + + if (tctx == state->send_tunnel) { + fprintf(stderr, "pnn:%u Received data on send tunnel\n", + state->pnn); + tevent_req_error(req, EPROTO); + return; + } + + ret = test_data_pull(buf, buflen, &tdata, &np); + if (ret != 0) { + tevent_req_error(req, ret); + return; + } + + if (tdata.pnn == state->pnn) { + if (tdata.count != state->count) { + tevent_req_error(req, EPROTO); + return; + } + + state->count = tdata.count + 1; + tdata.count = state->count; + } + + tunnel_test_msg_send(req, &tdata); +} + +static void tunnel_test_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + bool status; + + status = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (! status) { + tevent_req_error(req, EIO); + return; + } + + printf("pnn[%u] %.1lf msgs/sec\n", + state->pnn, (double)state->count / state->timelimit); + + state->done = true; + + /* wait few more seconds */ + subreq = tevent_wakeup_send(state, state->ev, + tevent_timeval_current_ofs(3, 0)); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, tunnel_test_finish, req); +} + +static void tunnel_test_finish(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + bool status; + + status = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (! status) { + tevent_req_error(req, EIO); + return; + } + + subreq = ctdb_tunnel_destroy_send(state, state->ev, + state->send_tunnel); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, tunnel_test_send_tunnel_closed, req); +} + +static void tunnel_test_send_tunnel_closed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + int ret; + bool status; + + status = ctdb_tunnel_destroy_recv(subreq, &ret); + TALLOC_FREE(subreq); + if (! status) { + tevent_req_error(req, ret); + return; + } + state->send_tunnel = NULL; + + subreq = ctdb_tunnel_destroy_send(state, state->ev, + state->recv_tunnel); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, tunnel_test_recv_tunnel_closed, req); +} + +static void tunnel_test_recv_tunnel_closed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct tunnel_test_state *state = tevent_req_data( + req, struct tunnel_test_state); + int ret; + bool status; + + status = ctdb_tunnel_destroy_recv(subreq, &ret); + TALLOC_FREE(subreq); + if (! status) { + tevent_req_error(req, ret); + return; + } + state->recv_tunnel = NULL; + + tevent_req_done(req); +} + +static bool tunnel_test_recv(struct tevent_req *req, int *perr) +{ + int ret; + + if (tevent_req_is_unix_error(req, &ret)) { + if (perr != NULL) { + *perr = ret; + } + return false; + } + + return true; +} + +int main(int argc, const char *argv[]) +{ + const struct test_options *opts; + TALLOC_CTX *mem_ctx; + struct tevent_context *ev; + struct ctdb_client_context *client; + struct tevent_req *req; + int ret; + bool status; + + setup_logging("tunnel_test", DEBUG_STDERR); + + status = process_options_basic(argc, argv, &opts); + if (! status) { + exit(1); + } + + mem_ctx = talloc_new(NULL); + if (mem_ctx == NULL) { + fprintf(stderr, "Memory allocation error\n"); + exit(1); + } + + ev = tevent_context_init(mem_ctx); + if (ev == NULL) { + fprintf(stderr, "Memory allocation error\n"); + exit(1); + } + + ret = ctdb_client_init(mem_ctx, ev, opts->socket, &client); + if (ret != 0) { + fprintf(stderr, "Failed to initialize client, ret=%d\n", ret); + exit(1); + } + + if (! ctdb_recovery_wait(ev, client)) { + fprintf(stderr, "Memory allocation error\n"); + exit(1); + } + + req = tunnel_test_send(mem_ctx, ev, client, opts->num_nodes, + opts->timelimit); + if (req == NULL) { + fprintf(stderr, "Memory allocation error\n"); + exit(1); + } + + tevent_req_poll(req, ev); + + status = tunnel_test_recv(req, &ret); + if (! status) { + fprintf(stderr, "tunnel test failed, ret=%d\n", ret); + exit(1); + } + + talloc_free(mem_ctx); + return 0; +} |