2 synchronous wrappers for libctdb
4 Copyright (C) Rusty Russell 2010
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.
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.
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/>.
20 #include <sys/socket.h>
26 #include "libctdb_private.h"
28 /* Remove type-safety macros. */
29 #undef ctdb_set_message_handler
31 /* On failure, frees req and returns NULL. */
32 static struct ctdb_request *synchronous(struct ctdb_connection *ctdb,
33 struct ctdb_request *req,
38 /* Pass through allocation failures. */
42 fds.fd = ctdb_get_fd(ctdb);
44 fds.events = ctdb_which_events(ctdb);
45 if (poll(&fds, 1, -1) < 0) {
46 /* Signalled is OK, other error is bad. */
49 ctdb_cancel(ctdb, req);
50 DEBUG(ctdb, LOG_ERR, "ctdb_synchronous: poll failed");
53 if (!ctdb_service(ctdb, fds.revents)) {
54 /* It can have failed after it completed request. */
56 ctdb_cancel(ctdb, req);
58 ctdb_request_free(req);
65 static void set(struct ctdb_connection *ctdb,
66 struct ctdb_request *req, bool *done)
71 bool ctdb_getrecmaster(struct ctdb_connection *ctdb,
72 uint32_t destnode, uint32_t *recmaster)
74 struct ctdb_request *req;
78 req = synchronous(ctdb,
79 ctdb_getrecmaster_send(ctdb, destnode, set, &done),
82 ret = ctdb_getrecmaster_recv(ctdb, req, recmaster);
83 ctdb_request_free(req);
88 bool ctdb_getrecmode(struct ctdb_connection *ctdb,
89 uint32_t destnode, uint32_t *recmode)
91 struct ctdb_request *req;
95 req = synchronous(ctdb,
96 ctdb_getrecmode_send(ctdb, destnode, set, &done),
99 ret = ctdb_getrecmode_recv(ctdb, req, recmode);
100 ctdb_request_free(req);
105 struct ctdb_db *ctdb_attachdb(struct ctdb_connection *ctdb,
106 const char *name, bool persistent,
109 struct ctdb_request *req;
111 struct ctdb_db *ret = NULL;
113 req = synchronous(ctdb,
114 ctdb_attachdb_send(ctdb, name, persistent, tdb_flags,
118 ret = ctdb_attachdb_recv(ctdb, req);
119 ctdb_request_free(req);
124 bool ctdb_getpnn(struct ctdb_connection *ctdb,
125 uint32_t destnode, uint32_t *pnn)
127 struct ctdb_request *req;
131 req = synchronous(ctdb,
132 ctdb_getpnn_send(ctdb, destnode, set, &done),
135 ret = ctdb_getpnn_recv(ctdb, req, pnn);
136 ctdb_request_free(req);
141 bool ctdb_getdbstat(struct ctdb_connection *ctdb,
142 uint32_t destnode, uint32_t db_id,
143 struct ctdb_db_statistics **stat)
145 struct ctdb_request *req;
149 req = synchronous(ctdb,
150 ctdb_getdbstat_send(ctdb, destnode, db_id, set, &done),
153 ret = ctdb_getdbstat_recv(ctdb, req, stat);
154 ctdb_request_free(req);
159 bool ctdb_check_message_handlers(struct ctdb_connection *ctdb,
160 uint32_t destnode, uint32_t num,
161 uint64_t *mhs, uint8_t *result)
163 struct ctdb_request *req;
167 req = synchronous(ctdb,
168 ctdb_check_message_handlers_send(ctdb, destnode, num, mhs, set, &done),
171 ret = ctdb_check_message_handlers_recv(ctdb, req, num, result);
172 ctdb_request_free(req);
177 bool ctdb_getnodemap(struct ctdb_connection *ctdb,
178 uint32_t destnode, struct ctdb_node_map **nodemap)
180 struct ctdb_request *req;
186 req = synchronous(ctdb,
187 ctdb_getnodemap_send(ctdb, destnode, set, &done),
190 ret = ctdb_getnodemap_recv(ctdb, req, nodemap);
191 ctdb_request_free(req);
196 bool ctdb_getpublicips(struct ctdb_connection *ctdb,
197 uint32_t destnode, struct ctdb_all_public_ips **ips)
199 struct ctdb_request *req;
205 req = synchronous(ctdb,
206 ctdb_getpublicips_send(ctdb, destnode, set, &done),
209 ret = ctdb_getpublicips_recv(ctdb, req, ips);
210 ctdb_request_free(req);
215 bool ctdb_set_message_handler(struct ctdb_connection *ctdb, uint64_t srvid,
216 ctdb_message_fn_t handler, void *cbdata)
218 struct ctdb_request *req;
222 req = synchronous(ctdb,
223 ctdb_set_message_handler_send(ctdb, srvid, handler,
227 ret = ctdb_set_message_handler_recv(ctdb, req);
228 ctdb_request_free(req);
235 struct ctdb_lock *lock;
239 static void rrl_callback(struct ctdb_db *ctdb_db,
240 struct ctdb_lock *lock,
242 struct rrl_info *rrl)
249 struct ctdb_lock *ctdb_readrecordlock(struct ctdb_connection *ctdb,
250 struct ctdb_db *ctdb_db, TDB_DATA key,
260 /* Immediate failure is easy. */
261 if (!ctdb_readrecordlock_async(ctdb_db, key, rrl_callback, &rrl))
264 /* Immediate success is easy. */
266 /* Otherwise wait until callback called. */
267 fds.fd = ctdb_get_fd(ctdb);
269 fds.events = ctdb_which_events(ctdb);
270 if (poll(&fds, 1, -1) < 0) {
271 /* Signalled is OK, other error is bad. */
275 "ctdb_readrecordlock: poll failed");
278 if (!ctdb_service(ctdb, fds.revents)) {
286 bool ctdb_getdbseqnum(struct ctdb_connection *ctdb,
287 uint32_t destnode, uint32_t dbid,
290 struct ctdb_request *req;
294 req = synchronous(ctdb,
295 ctdb_getdbseqnum_send(ctdb, destnode, dbid, set, &done),
298 ret = ctdb_getdbseqnum_recv(ctdb, req, seqnum);
299 ctdb_request_free(req);
304 bool ctdb_getifaces(struct ctdb_connection *ctdb,
305 uint32_t destnode, struct ctdb_ifaces_list **ifaces)
307 struct ctdb_request *req;
313 req = synchronous(ctdb,
314 ctdb_getifaces_send(ctdb, destnode, set, &done),
317 ret = ctdb_getifaces_recv(ctdb, req, ifaces);
318 ctdb_request_free(req);
323 bool ctdb_getvnnmap(struct ctdb_connection *ctdb,
324 uint32_t destnode, struct ctdb_vnn_map **vnnmap)
326 struct ctdb_request *req;
332 req = synchronous(ctdb,
333 ctdb_getvnnmap_send(ctdb, destnode, set, &done),
336 ret = ctdb_getvnnmap_recv(ctdb, req, vnnmap);
337 ctdb_request_free(req);
342 bool ctdb_getcapabilities(struct ctdb_connection *ctdb,
343 uint32_t destnode, uint32_t *capabilities)
345 struct ctdb_request *req;
349 req = synchronous(ctdb,
350 ctdb_getcapabilities_send(ctdb, destnode, set, &done),
353 ret = ctdb_getcapabilities_recv(ctdb, req, capabilities);
354 ctdb_request_free(req);