use ctdb_call_info, so struct ctdb_call can be used for top level call
[vlendec/samba-autobuild/.git] / ctdb / ctdb_test.c
1 /* 
2    ctdb test harness
3
4    Copyright (C) Andrew Tridgell  2006
5
6    This library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2 of the License, or (at your option) any later version.
10
11    This library 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 GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with this library; if not, write to the Free Software
18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 */
20
21 #include "includes.h"
22 #include "lib/events/events.h"
23 #include "system/filesys.h"
24 #include "popt.h"
25
26 enum my_functions {FUNC_SORT=1, FUNC_FETCH=2};
27
28 static int int_compare(int *i1, int *i2)
29 {
30         return *i1 - *i2;
31 }
32
33 /*
34   add an integer into a record in sorted order
35 */
36 static int sort_func(struct ctdb_call_info *call)
37 {
38         if (call->call_data == NULL ||
39             call->call_data->dsize != sizeof(int)) {
40                 return CTDB_ERR_INVALID;
41         }
42         call->new_data = talloc(call, TDB_DATA);
43         if (call->new_data == NULL) {
44                 return CTDB_ERR_NOMEM;
45         }
46         call->new_data->dptr = talloc_size(call, 
47                                            call->record_data.dsize + 
48                                            call->call_data->dsize);
49         if (call->new_data->dptr == NULL) {
50                 return CTDB_ERR_NOMEM;
51         }
52         call->new_data->dsize = call->record_data.dsize + call->call_data->dsize;
53         memcpy(call->new_data->dptr,
54                call->record_data.dptr, call->record_data.dsize);
55         memcpy(call->new_data->dptr+call->record_data.dsize,
56                call->call_data->dptr, call->call_data->dsize);
57
58         qsort(call->new_data->dptr, call->new_data->dsize / sizeof(int),
59               sizeof(int), (comparison_fn_t)int_compare);
60
61         return 0;
62 }
63
64 /*
65   ctdb call function to fetch a record
66 */
67 static int fetch_func(struct ctdb_call_info *call)
68 {
69         call->reply_data = &call->record_data;
70         return 0;
71 }
72
73 /*
74   main program
75 */
76 int main(int argc, const char *argv[])
77 {
78         struct ctdb_context *ctdb;
79         const char *nlist = NULL;
80         const char *transport = "tcp";
81         const char *myaddress = NULL;
82         int self_connect=0;
83
84         struct poptOption popt_options[] = {
85                 POPT_AUTOHELP
86                 { "nlist", 0, POPT_ARG_STRING, &nlist, 0, "node list file", "filename" },
87                 { "listen", 0, POPT_ARG_STRING, &myaddress, 0, "address to listen on", "address" },
88                 { "transport", 0, POPT_ARG_STRING, &transport, 0, "protocol transport", NULL },
89                 { "self-connect", 0, POPT_ARG_NONE, &self_connect, 0, "enable self connect", "boolean" },
90                 POPT_TABLEEND
91         };
92         int opt;
93         const char **extra_argv;
94         int extra_argc = 0;
95         int i, ret;
96         TDB_DATA key, data;
97         poptContext pc;
98         struct event_context *ev;
99
100         pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
101
102         while ((opt = poptGetNextOpt(pc)) != -1) {
103                 switch (opt) {
104                 default:
105                         fprintf(stderr, "Invalid option %s: %s\n", 
106                                 poptBadOption(pc, 0), poptStrerror(opt));
107                         exit(1);
108                 }
109         }
110
111         /* setup the remaining options for the main program to use */
112         extra_argv = poptGetArgs(pc);
113         if (extra_argv) {
114                 extra_argv++;
115                 while (extra_argv[extra_argc]) extra_argc++;
116         }
117
118         if (nlist == NULL || myaddress == NULL) {
119                 printf("You must provide a node list with --nlist and an address with --listen\n");
120                 exit(1);
121         }
122
123         ev = event_context_init(NULL);
124
125         /* initialise ctdb */
126         ctdb = ctdb_init(ev);
127         if (ctdb == NULL) {
128                 printf("Failed to init ctdb\n");
129                 exit(1);
130         }
131
132         if (self_connect) {
133                 ctdb_set_flags(ctdb, CTDB_FLAG_SELF_CONNECT);
134         }
135
136         ret = ctdb_set_transport(ctdb, transport);
137         if (ret == -1) {
138                 printf("ctdb_set_transport failed - %s\n", ctdb_errstr(ctdb));
139                 exit(1);
140         }
141
142         /* tell ctdb what address to listen on */
143         ret = ctdb_set_address(ctdb, myaddress);
144         if (ret == -1) {
145                 printf("ctdb_set_address failed - %s\n", ctdb_errstr(ctdb));
146                 exit(1);
147         }
148
149         /* tell ctdb what nodes are available */
150         ret = ctdb_set_nlist(ctdb, nlist);
151         if (ret == -1) {
152                 printf("ctdb_set_nlist failed - %s\n", ctdb_errstr(ctdb));
153                 exit(1);
154         }
155
156         /* setup a ctdb call function */
157         ret = ctdb_set_call(ctdb, sort_func,  FUNC_SORT);
158         ret = ctdb_set_call(ctdb, fetch_func, FUNC_FETCH);
159
160         /* attach to a specific database */
161         ret = ctdb_attach(ctdb, "test.tdb", TDB_DEFAULT, O_RDWR|O_CREAT|O_TRUNC, 0666);
162         if (ret == -1) {
163                 printf("ctdb_attach failed - %s\n", ctdb_errstr(ctdb));
164                 exit(1);
165         }
166
167         /* start the protocol running */
168         ret = ctdb_start(ctdb);
169
170         /* wait until all nodes are connected (should not be needed
171            outide of test code) */
172         ctdb_connect_wait(ctdb);
173        
174         key.dptr = "test";
175         key.dsize = strlen("test")+1;
176
177         /* add some random data */
178         for (i=0;i<10;i++) {
179                 int v = random() % 1000;
180                 data.dptr = (uint8_t *)&v;
181                 data.dsize = sizeof(v);
182                 ret = ctdb_call(ctdb, key, FUNC_SORT, &data, NULL);
183                 if (ret == -1) {
184                         printf("ctdb_call FUNC_SORT failed - %s\n", ctdb_errstr(ctdb));
185                         exit(1);
186                 }
187         }
188
189         /* fetch the record */
190         ret = ctdb_call(ctdb, key, FUNC_FETCH, NULL, &data);
191         if (ret == -1) {
192                 printf("ctdb_call FUNC_FETCH failed - %s\n", ctdb_errstr(ctdb));
193                 exit(1);
194         }
195
196         for (i=0;i<data.dsize/sizeof(int);i++) {
197                 printf("%3d\n", ((int *)data.dptr)[i]);
198         }
199         talloc_free(data.dptr);
200
201         /* go into a wait loop to allow other nodes to complete */
202         ctdb_wait_loop(ctdb);
203
204         /* shut it down */
205         talloc_free(ctdb);
206         return 0;
207 }