Debian Codegraph @

test/lib/server.c

raw
1 #include <unistd.h>
2
3 #include "fs.h"
4 #include "server.h"
5
6 static int endpointConnect(void *data, const char *address, int *fd)
7 {
8 struct sockaddr_un addr;
9 int rv;
10 (void)address;
11 (void)data;
12 memset(&addr, 0, sizeof addr);
13 addr.sun_family = AF_UNIX;
14 strcpy(addr.sun_path + 1, address + 1);
15 *fd = socket(AF_UNIX, SOCK_STREAM, 0);
16 munit_assert_int(*fd, !=, -1);
17 rv = connect(*fd, (struct sockaddr *)&addr,
18 sizeof(sa_family_t) + strlen(address + 1) + 1);
19 return rv;
20 }
21
22 void test_server_setup(struct test_server *s,
23 const unsigned id,
24 const MunitParameter params[])
25 {
26 (void)params;
27
28 s->id = id;
29 sprintf(s->address, "@%u", id);
30
31 s->dir = test_dir_setup();
32 s->role_management = false;
33
34 memset(s->others, 0, sizeof s->others);
35 }
36
37 void test_server_stop(struct test_server *s)
38 {
39 int rv;
40
41 test_server_client_close(s, &s->client);
42
43 if (s->role_management) {
44 cowsql_node_handover(s->cowsql);
45 rv = cowsql_node_stop(s->cowsql);
46 } else {
47 rv = cowsql_node_stop(s->cowsql);
48 }
49 munit_assert_int(rv, ==, 0);
50
51 cowsql_node_destroy(s->cowsql);
52 }
53
54 void test_server_tear_down(struct test_server *s)
55 {
56 test_server_stop(s);
57 test_dir_tear_down(s->dir);
58 }
59
60 void test_server_start(struct test_server *s, const MunitParameter params[])
61 {
62 int rv;
63
64 rv = cowsql_node_create(s->id, s->address, s->dir, &s->cowsql);
65 munit_assert_int(rv, ==, 0);
66
67 rv = cowsql_node_set_bind_address(s->cowsql, s->address);
68 munit_assert_int(rv, ==, 0);
69
70 rv = cowsql_node_set_connect_func(s->cowsql, endpointConnect, s);
71 munit_assert_int(rv, ==, 0);
72
73 rv = cowsql_node_set_network_latency_ms(s->cowsql, 30);
74 munit_assert_int(rv, ==, 0);
75
76 const char *snapshot_threshold_param =
77 munit_parameters_get(params, SNAPSHOT_THRESHOLD_PARAM);
78 if (snapshot_threshold_param != NULL) {
79 unsigned threshold = (unsigned)atoi(snapshot_threshold_param);
80 rv = cowsql_node_set_snapshot_params(s->cowsql, threshold,
81 threshold);
82 munit_assert_int(rv, ==, 0);
83 }
84
85 if (getenv("CI") != NULL) {
86 const char *target_voters_param =
87 munit_parameters_get(params, "target_voters");
88 if (target_voters_param != NULL) {
89 int n = atoi(target_voters_param);
90 rv = cowsql_node_set_target_voters(s->cowsql, n);
91 munit_assert_int(rv, ==, 0);
92 }
93
94 const char *target_standbys_param =
95 munit_parameters_get(params, "target_standbys");
96 if (target_standbys_param != NULL) {
97 int n = atoi(target_standbys_param);
98 rv = cowsql_node_set_target_standbys(s->cowsql, n);
99 munit_assert_int(rv, ==, 0);
100 }
101
102 const char *role_management_param =
103 munit_parameters_get(params, "role_management");
104 if (role_management_param != NULL) {
105 bool role_management =
106 (bool)atoi(role_management_param);
107 s->role_management = role_management;
108 if (role_management) {
109 rv = cowsql_node_enable_role_management(
110 s->cowsql);
111 munit_assert_int(rv, ==, 0);
112 }
113 }
114 }
115
116 rv = cowsql_node_start(s->cowsql);
117 munit_assert_int(rv, ==, 0);
118
119 test_server_client_connect(s, &s->client);
120 }
121
122 struct client_proto *test_server_client(struct test_server *s)
123 {
124 return &s->client;
125 }
126
127 void test_server_client_reconnect(struct test_server *s, struct client_proto *c)
128 {
129 test_server_client_close(s, c);
130 test_server_client_connect(s, c);
131 }
132
133 void test_server_client_connect(struct test_server *s, struct client_proto *c)
134 {
135 int rv;
136 int fd;
137
138 rv = endpointConnect(NULL, s->address, &fd);
139 munit_assert_int(rv, ==, 0);
140
141 memset(c, 0, sizeof *c);
142 buffer__init(&c->read);
143 buffer__init(&c->write);
144 c->fd = fd;
145 }
146
147 void test_server_client_close(struct test_server *s, struct client_proto *c)
148 {
149 (void)s;
150 clientClose(c);
151 }
152
153 static void setOther(struct test_server *s, struct test_server *other)
154 {
155 unsigned i = other->id - 1;
156 munit_assert_ptr_null(s->others[i]);
157 s->others[i] = other;
158 }
159 void test_server_network(struct test_server *servers, unsigned n_servers)
160 {
161 unsigned i;
162 unsigned j;
163 for (i = 0; i < n_servers; i++) {
164 for (j = 0; j < n_servers; j++) {
165 struct test_server *server = &servers[i];
166 struct test_server *other = &servers[j];
167 if (i == j) {
168 continue;
169 }
170 setOther(server, other);
171 }
172 }
173 }