]> git.proxmox.com Git - mirror_corosync.git/blame - test/testsam.c
projects / mirror_corosync.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
libqb: convert coropoll calls to qb_loop calls.
[mirror_corosync.git] / test / testsam.c
CommitLineData
0ed4d530
JF		 1/*
2 * Copyright (c) 2009 Red Hat, Inc.
3 *
4 * All rights reserved.
5 *
6 * Author: Jan Friesse (jfriesse@redhat.com)
7 *
8 * This software licensed under BSD license, the text of which follows:
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions are met:
12 *
13 * - Redistributions of source code must retain the above copyright notice,
14 * this list of conditions and the following disclaimer.
15 * - Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 * - Neither the name of the Red Hat, Inc. nor the names of its
19 * contributors may be used to endorse or promote products derived from this
20 * software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32 * THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35/*
36 * Provides test of SAM API
37 */
38
39#include <config.h>
40
1a32fc4a 41#include <limits.h>
0ed4d530
JF		 42#include <sys/types.h>
43#include <stdio.h>
44#include <stdint.h>
45#include <stdlib.h>
46#include <unistd.h>
47#include <corosync/corotypes.h>
d5884cd7 48#include <corosync/confdb.h>
0ed4d530
JF		 49#include <corosync/sam.h>
50#include <signal.h>
da6fce35 51#include <string.h>
0ed4d530
JF		 52#include <sys/wait.h>
53
1a32fc4a
JF		 54extern const char *__progname;
55
0ed4d530 56static int test2_sig_delivered = 0;
da6fce35 57static int test5_hc_cb_count = 0;
088a2a0f 58static int test6_sig_delivered = 0;
0ed4d530
JF		 59
60/*
61 * First test will just register SAM, with policy restart. First instance will
62 * sleep one second, send hc and sleep another 3 seconds. This should force restart.
63 * Second instance will sleep one second, send hc, stop hc and sleep 3 seconds.
64 * Then start hc again and sleep 3 seconds. This should force restart again.
65 * Last instance just calls initialize again. This should end with error.
66 * Then call start, followed by stop and start again. Finally, we will call finalize
67 * twice. One should succeed, second should fail. After this, we will call every function
68 * (none should succeed).
69 */
70static int test1 (void)
71{
72 cs_error_t error;
73 unsigned int instance_id;
74 int i;
75
76 printf ("%s: initialize\n", __FUNCTION__);
77 error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
78 if (error != CS_OK) {
79 fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
80 return 1;
81 }
82 printf ("%s: register\n", __FUNCTION__);
83 error = sam_register (&instance_id);
84 if (error != CS_OK) {
85 fprintf (stderr, "Can't register. Error %d\n", error);
86 return 1;
87 }
88
89 if (instance_id == 1 || instance_id == 2) {
90 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
91 error = sam_start ();
92 if (error != CS_OK) {
93 fprintf (stderr, "Can't start hc. Error %d\n", error);
94 return 1;
95 }
96
97 for (i = 0; i < 10; i++) {
98 printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
99 sleep (1);
100
101 printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
102 error = sam_hc_send ();
103 if (error != CS_OK) {
104 fprintf (stderr, "Can't send hc. Error %d\n", error);
105 return 1;
106 }
107 }
108
109 if (instance_id == 2) {
110 printf ("%s iid %d: stop\n", __FUNCTION__, instance_id);
111 error = sam_stop ();
112
113 if (error != CS_OK) {
114 fprintf (stderr, "Can't send hc. Error %d\n", error);
115 return 1;
116 }
117 }
118
119 printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
120 sleep (3);
121
122 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
123 error = sam_start ();
124 if (error != CS_OK) {
125 fprintf (stderr, "Can't start hc. Error %d\n", error);
126 return 1;
127 }
128
129 printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
130 sleep (3);
131 return 0;
132 }
133
134 if (instance_id == 3) {
135 error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
136 if (error == CS_OK) {
137 fprintf (stderr, "Can initialize SAM API after initialization");
138 return 1;
139 }
140
141 error = sam_start ();
142 if (error != CS_OK) {
143 fprintf (stderr, "Can't start hc. Error %d\n", error);
144 return 1;
145 }
146 error = sam_stop ();
147 if (error != CS_OK) {
148 fprintf (stderr, "Can't stop hc. Error %d\n", error);
149 return 1;
150 }
151 error = sam_finalize ();
152 if (error != CS_OK) {
153 fprintf (stderr, "Can't finalize sam. Error %d\n", error);
154 return 1;
155 }
156 error = sam_finalize ();
157 if (error == CS_OK) {
158 fprintf (stderr, "Can finalize sam after finalization!\n");
159 return 1;
160 }
161
162 if (sam_initialize (2, SAM_RECOVERY_POLICY_RESTART) == CS_OK ||
163 sam_start () == CS_OK || sam_stop () == CS_OK ||
164 sam_register (NULL) == CS_OK || sam_hc_send () == CS_OK ||
165 sam_hc_callback_register (NULL) == CS_OK) {
166
167 fprintf (stderr, "Can call one of function after finalization!\n");
168
169 return 1;
170 }
171
172 return 0;
173 }
174
175 return 1;
176}
177
178
179static void test2_signal (int sig) {
180 printf ("%s\n", __FUNCTION__);
181
182 test2_sig_delivered = 1;
183}
184
185/*
186 * This tests recovery policy quit and callback.
187 */
188static int test2 (void) {
189 cs_error_t error;
190 unsigned int instance_id;
191
192 printf ("%s: initialize\n", __FUNCTION__);
193 error = sam_initialize (2000, SAM_RECOVERY_POLICY_QUIT);
194 if (error != CS_OK) {
195 fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
196 return 1;
197 }
198 printf ("%s: register\n", __FUNCTION__);
199 error = sam_register (&instance_id);
200 if (error != CS_OK) {
201 fprintf (stderr, "Can't register. Error %d\n", error);
202 return 1;
203 }
204
205 if (instance_id == 1) {
206 signal (SIGTERM, test2_signal);
207
208 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
209 error = sam_start ();
210 if (error != CS_OK) {
211 fprintf (stderr, "Can't start hc. Error %d\n", error);
212 return 1;
213 }
214
215 printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
216 sleep (1);
217
218 printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
219 error = sam_hc_send ();
220 if (error != CS_OK) {
221 fprintf (stderr, "Can't send hc. Error %d\n", error);
222 return 1;
223 }
224
225
226 printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
227 while (!test2_sig_delivered) {
228 sleep (1);
229 }
230
231 printf ("%s iid %d: wait for real kill\n", __FUNCTION__, instance_id);
232
233 sleep (3);
234 }
235
236 return 1;
237
238}
239
240/*
241 * Smoke test. Better to turn off coredump ;) This has no time limit, just restart process
242 * when it dies.
243 */
244static int test3 (void) {
245 cs_error_t error;
246 unsigned int instance_id;
247 int tmp1, tmp2, tmp3;
248
249 printf ("%s: initialize\n", __FUNCTION__);
250 error = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART);
251 if (error != CS_OK) {
252 fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
253 return 1;
254 }
255 printf ("%s: register\n", __FUNCTION__);
256 error = sam_register (&instance_id);
257 if (error != CS_OK) {
258 fprintf (stderr, "Can't register. Error %d\n", error);
259 return 1;
260 }
261
262 if (instance_id < 100) {
263 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
264 error = sam_start ();
265 if (error != CS_OK) {
266 fprintf (stderr, "Can't start hc. Error %d\n", error);
267 return 1;
268 }
269
270 printf ("%s iid %d: divide by zero\n", __FUNCTION__, instance_id);
271 tmp2 = rand ();
272 tmp3 = 0;
273 tmp1 = tmp2 / tmp3;
274
275 return 1;
276 }
277
278 return 0;
279
280}
281
da6fce35
JF		 282/*
283 * Test sam_data_store, sam_data_restore and sam_data_getsize
284 */
285static int test4 (void)
286{
287 size_t size;
288 cs_error_t err;
289 int i;
290 unsigned int instance_id;
291 char saved_data[128];
292 char saved_data2[128];
293
294 printf ("%s: sam_data_getsize 1\n", __FUNCTION__);
295 err = sam_data_getsize (&size);
296 if (err != CS_ERR_BAD_HANDLE) {
297 fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
298 return 1;
299 }
300
301 printf ("%s: sam_data_getsize 2\n", __FUNCTION__);
302 err = sam_data_getsize (NULL);
303 if (err != CS_ERR_INVALID_PARAM) {
304 fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
305 return 1;
306 }
307
308 printf ("%s: sam_data_store 1\n", __FUNCTION__);
309 err = sam_data_store (NULL, 0);
310 if (err != CS_ERR_BAD_HANDLE) {
311 fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
312 return 1;
313 }
314
315 printf ("%s: sam_data_restore 1\n", __FUNCTION__);
316 err = sam_data_restore (saved_data, sizeof (saved_data));
317 if (err != CS_ERR_BAD_HANDLE) {
318 fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
319 return 1;
320 }
321
322 printf ("%s: sam_initialize\n", __FUNCTION__);
323 err = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART);
324 if (err != CS_OK) {
325 fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
326 return 1;
327 }
328
329 printf ("%s: sam_data_getsize 3\n", __FUNCTION__);
330 err = sam_data_getsize (&size);
331 if (err != CS_OK) {
332 fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
333 return 1;
334 }
335 if (size != 0) {
336 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
337 return 1;
338 }
339
340 printf ("%s: sam_data_restore 2\n", __FUNCTION__);
341 err = sam_data_restore (NULL, sizeof (saved_data));
342 if (err != CS_ERR_INVALID_PARAM) {
343 fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
344 return 1;
345 }
346
347 /*
348 * Store some real data
349 */
350 for (i = 0; i < sizeof (saved_data); i++) {
351 saved_data[i] = (char)(i + 5);
352 }
353
354 printf ("%s: sam_data_store 2\n", __FUNCTION__);
355 err = sam_data_store (saved_data, sizeof (saved_data));
356 if (err != CS_OK) {
357 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
358 return 1;
359 }
360
361 printf ("%s: sam_data_getsize 4\n", __FUNCTION__);
362 err = sam_data_getsize (&size);
363 if (err != CS_OK) {
364 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
365 return 1;
366 }
367 if (size != sizeof (saved_data)) {
368 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
369 return 1;
370 }
371
372 printf ("%s: sam_data_restore 3\n", __FUNCTION__);
373 err = sam_data_restore (saved_data2, sizeof (saved_data2) - 1);
374 if (err != CS_ERR_INVALID_PARAM) {
375 fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
376 return 1;
377 }
378
379 printf ("%s: sam_data_restore 4\n", __FUNCTION__);
380 err = sam_data_restore (saved_data2, sizeof (saved_data2));
381 if (err != CS_OK) {
382 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
383 return 1;
384 }
385
386 if (memcmp (saved_data, saved_data2, sizeof (saved_data2)) != 0) {
387 fprintf (stderr, "Retored data are not same\n");
388 return 1;
389 }
390
391 memset (saved_data2, 0, sizeof (saved_data2));
392
393 printf ("%s: sam_data_store 3\n", __FUNCTION__);
394 err = sam_data_store (NULL, 1);
395 if (err != CS_OK) {
396 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
397 return 1;
398 }
399
400 printf ("%s: sam_data_getsize 5\n", __FUNCTION__);
401 err = sam_data_getsize (&size);
402 if (err != CS_OK) {
403 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
404 return 1;
405 }
406 if (size != 0) {
407 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
408 return 1;
409 }
410
411 printf ("%s: sam_data_store 4\n", __FUNCTION__);
412 err = sam_data_store (saved_data, sizeof (saved_data));
413 if (err != CS_OK) {
414 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
415 return 1;
416 }
417
418 printf ("%s: register\n", __FUNCTION__);
419 err = sam_register (&instance_id);
420 if (err != CS_OK) {
421 fprintf (stderr, "Can't register. Error %d\n", err);
422 return 1;
423 }
424
425 if (instance_id == 1) {
426 printf ("%s iid %d: sam_start\n", __FUNCTION__, instance_id);
427 err = sam_start ();
428 if (err != CS_OK) {
429 fprintf (stderr, "Can't start hc. Error %d\n", err);
430 return 1;
431 }
432
433 printf ("%s iid %d: sam_data_getsize 6\n", __FUNCTION__, instance_id);
434 err = sam_data_getsize (&size);
435 if (err != CS_OK) {
436 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
437 return 1;
438 }
439 if (size != sizeof (saved_data2)) {
440 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
441 return 1;
442 }
443
444 printf ("%s iid %d: sam_data_restore 5\n", __FUNCTION__, instance_id);
445 err = sam_data_restore (saved_data2, sizeof (saved_data2));
446 if (err != CS_OK) {
447 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
448 return 1;
449 }
450
451 if (memcmp (saved_data, saved_data2, sizeof (saved_data2)) != 0) {
452 fprintf (stderr, "Retored data are not same\n");
453 return 1;
454 }
455
456 for (i = 0; i < sizeof (saved_data); i++) {
457 saved_data[i] = (char)(i - 5);
458 }
459
460 printf ("%s iid %d: sam_data_store 5\n", __FUNCTION__, instance_id);
461 err = sam_data_store (saved_data, sizeof (saved_data) - 7);
462 if (err != CS_OK) {
463 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
464 return 1;
465 }
466
467 exit (1);
468 }
469
470 if (instance_id == 2) {
471 printf ("%s iid %d: sam_start\n", __FUNCTION__, instance_id);
472 err = sam_start ();
473 if (err != CS_OK) {
474 fprintf (stderr, "Can't start hc. Error %d\n", err);
475 return 1;
476 }
477
478 printf ("%s iid %d: sam_data_getsize 7\n", __FUNCTION__, instance_id);
479 err = sam_data_getsize (&size);
480 if (err != CS_OK) {
481 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
482 return 1;
483 }
484 if (size != sizeof (saved_data2) - 7) {
485 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
486 return 1;
487 }
488
489 printf ("%s iid %d: sam_data_restore 6\n", __FUNCTION__, instance_id);
490 err = sam_data_restore (saved_data2, sizeof (saved_data2));
491 if (err != CS_OK) {
492 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
493 return 1;
494 }
495
496 for (i = 0; i < sizeof (saved_data); i++) {
497 saved_data[i] = (char)(i - 5);
498 }
499
500 if (memcmp (saved_data, saved_data2, sizeof (saved_data2) - 7) != 0) {
501 fprintf (stderr, "Retored data are not same\n");
502 return 1;
503 }
504
505 printf ("%s iid %d: sam_data_store 6\n", __FUNCTION__, instance_id);
506 err = sam_data_store (NULL, 0);
507 if (err != CS_OK) {
508 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
509 return 1;
510 }
511
512 exit (1);
513 }
514
515 if (instance_id == 3) {
516 printf ("%s iid %d: sam_data_getsize 8\n", __FUNCTION__, instance_id);
517 err = sam_data_getsize (&size);
518 if (err != CS_OK) {
519 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
520 return 1;
521 }
522 if (size != 0) {
523 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
524 return 1;
525 }
526 }
527
528 return (0);
529}
530
531static int test5_hc_cb (void)
0ed4d530 532{
da6fce35
JF		 533 printf ("%s %d\n", __FUNCTION__, ++test5_hc_cb_count);
534
535 sam_data_store (&test5_hc_cb_count, sizeof (test5_hc_cb_count));
0ed4d530 536
da6fce35 537 if (test5_hc_cb_count > 10)
0ed4d530
JF		 538 return 1;
539
540 return 0;
541}
542/*
543 * Test event driven healtchecking.
544 */
da6fce35 545static int test5 (void)
0ed4d530
JF		 546{
547 cs_error_t error;
548 unsigned int instance_id;
da6fce35 549 int hc_cb_count;
0ed4d530
JF		 550
551 printf ("%s: initialize\n", __FUNCTION__);
552 error = sam_initialize (100, SAM_RECOVERY_POLICY_RESTART);
553 if (error != CS_OK) {
554 fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
555 return 1;
556 }
557 printf ("%s: register\n", __FUNCTION__);
558 error = sam_register (&instance_id);
559 if (error != CS_OK) {
560 fprintf (stderr, "Can't register. Error %d\n", error);
561 return 1;
562 }
563
564 if (instance_id == 1) {
565 printf ("%s iid %d: hc callback register\n", __FUNCTION__, instance_id);
da6fce35 566 error = sam_hc_callback_register (test5_hc_cb);
0ed4d530
JF		 567 if (error != CS_OK) {
568 fprintf (stderr, "Can't register hc cb. Error %d\n", error);
569 return 1;
570 }
571
572
573 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
574 error = sam_start ();
575 if (error != CS_OK) {
576 fprintf (stderr, "Can't start hc. Error %d\n", error);
577 return 1;
578 }
579
580 sleep (2);
581
582 printf ("%s iid %d: Failed. Wasn't killed.\n", __FUNCTION__, instance_id);
583 return 1;
584 }
585
586 if (instance_id == 2) {
da6fce35
JF		 587 error = sam_data_restore (&hc_cb_count, sizeof (hc_cb_count));
588 if (error != CS_OK) {
589 fprintf (stderr, "sam_data_restore should return CS_OK. Error returned %d\n", error);
590 return 1;
591 }
592
593 if (hc_cb_count != 11) {
594 fprintf (stderr, "%s iid %d: Premature killed. hc_cb_count should be 11 and it is %d\n",
595 __FUNCTION__, instance_id - 1, hc_cb_count);
596 return 1;
597
598 }
0ed4d530
JF		 599 return 0;
600 }
601
602 return 1;
603}
604
088a2a0f
JF		 605static void test6_signal (int sig) {
606 cs_error_t error;
607
608 printf ("%s\n", __FUNCTION__);
609 test6_sig_delivered++;
610
611 if ((error = sam_data_store (&test6_sig_delivered, sizeof (test6_sig_delivered))) != CS_OK) {
612 fprintf (stderr, "Can't store data! Error : %d\n", error);
613 }
614}
615
616/*
617 * Test warn signal set.
618 */
619static int test6 (void) {
620 cs_error_t error;
621 unsigned int instance_id;
622 int test6_sig_del;
623
624 printf ("%s: initialize\n", __FUNCTION__);
625 error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
626 if (error != CS_OK) {
627 fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
628 return 1;
629 }
630 printf ("%s: register\n", __FUNCTION__);
631 error = sam_register (&instance_id);
632 if (error != CS_OK) {
633 fprintf (stderr, "Can't register. Error %d\n", error);
634 return 1;
635 }
636
637 if (instance_id == 1) {
638 error = sam_warn_signal_set (SIGUSR1);
639 if (error != CS_OK) {
640 fprintf (stderr, "Can't set warn signal. Error %d\n", error);
641 return 1;
642 }
643
644 signal (SIGUSR1, test6_signal);
645
646 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
647 error = sam_start ();
648 if (error != CS_OK) {
649 fprintf (stderr, "Can't start hc. Error %d\n", error);
650 return 1;
651 }
652
653 printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
654 sleep (1);
655
656 printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
657 error = sam_hc_send ();
658 if (error != CS_OK) {
659 fprintf (stderr, "Can't send hc. Error %d\n", error);
660 return 1;
661 }
662
663
664 printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
665 while (!test6_sig_delivered) {
666 sleep (1);
667 }
668
669 printf ("%s iid %d: wait for real kill\n", __FUNCTION__, instance_id);
670
671 sleep (3);
672
673 printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
674 return (1);
675 }
676
677 if (instance_id == 2) {
678 error = sam_data_restore (&test6_sig_del, sizeof (test6_sig_del));
679 if (error != CS_OK) {
680 fprintf (stderr, "Can't restore data. Error %d\n", error);
681 return 1;
682 }
683
684 if (test6_sig_del != 1) {
685 fprintf (stderr, "Previous test failed. Signal was not delivered\n");
686 return 1;
687 }
688
689 error = sam_warn_signal_set (SIGKILL);
690 if (error != CS_OK) {
691 fprintf (stderr, "Can't set warn signal. Error %d\n", error);
692 return 1;
693 }
694
695 signal (SIGUSR1, test6_signal);
696
697 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
698 error = sam_start ();
699 if (error != CS_OK) {
700 fprintf (stderr, "Can't start hc. Error %d\n", error);
701 return 1;
702 }
703
704 printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
705 sleep (1);
706
707 printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
708 error = sam_hc_send ();
709 if (error != CS_OK) {
710 fprintf (stderr, "Can't send hc. Error %d\n", error);
711 return 1;
712 }
713
714
715 printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
716 while (!test6_sig_delivered) {
717 sleep (1);
718 }
719
720 printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
721 return (1);
722 }
723
724 if (instance_id == 3) {
725 error = sam_data_restore (&test6_sig_del, sizeof (test6_sig_del));
726 if (error != CS_OK) {
727 fprintf (stderr, "Can't restore data. Error %d\n", error);
728 return 1;
729 }
730
731 if (test6_sig_del != 1) {
732 fprintf (stderr, "Previous test failed. Signal WAS delivered\n");
733 return 1;
734 }
735
736 return (0);
737 }
738
739 return 1;
740}
da6fce35 741
d5884cd7
JF		 742static void *test7_thread (void *arg)
743{
744 /* Wait 5s */
745 sleep (5);
746 exit (0);
747}
748
749/*
750 * Test quorum
751 */
752static int test7 (void) {
753 confdb_handle_t cdb_handle;
754 cs_error_t err;
755 hdb_handle_t quorum_handle;
756 size_t value_len;
757 char key_value[256];
758 unsigned int instance_id;
759 pthread_t kill_thread;
760
761 err = confdb_initialize (&cdb_handle, NULL);
762 if (err != CS_OK) {
763 printf ("Could not initialize Cluster Configuration Database API instance error %d. Test skipped\n", err);
764 return (1);
765 }
766
767 err = confdb_object_find_start(cdb_handle, OBJECT_PARENT_HANDLE);
768 if (err != CS_OK) {
769 printf ("Could not start object_find %d. Test skipped\n", err);
770 return (1);
771 }
772
773 err = confdb_object_find(cdb_handle, OBJECT_PARENT_HANDLE, "quorum", strlen("quorum"), &quorum_handle);
774 if (err != CS_OK) {
775 printf ("Could not object_find \"quorum\": %d. Test skipped\n", err);
776 return (1);
777 }
778
779 err = confdb_key_get(cdb_handle, quorum_handle, "provider", strlen("provider"), key_value, &value_len);
780 if (err != CS_OK) {
781 printf ("Could not get \"provider\" key: %d. Test skipped\n", err);
782 return (1);
783 }
784
785 if (!(value_len - 1 == strlen ("testquorum") && memcmp (key_value, "testquorum", value_len - 1) == 0)) {
786 printf ("Provider is not testquorum. Test skipped\n");
787 return (1);
788 }
789
790 /*
791 * Set to not quorate
792 */
793 err = confdb_key_create(cdb_handle, quorum_handle, "quorate", strlen("quorate"), "0", strlen("0"));
794 if (err != CS_OK) {
795 printf ("Can't create confdb key. Error %d\n", err);
796 return (2);
797 }
798
799 printf ("%s: initialize\n", __FUNCTION__);
800 err = sam_initialize (2000, SAM_RECOVERY_POLICY_QUORUM_RESTART);
801 if (err != CS_OK) {
802 fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
803 return 2;
804 }
805
806 printf ("%s: register\n", __FUNCTION__);
807 err = sam_register (&instance_id);
808 if (err != CS_OK) {
809 fprintf (stderr, "Can't register. Error %d\n", err);
810 return 2;
811 }
812
813 if (instance_id == 1) {
814 /*
815 * Sam start should block forever, but 10s for us should be enough
816 */
817 pthread_create (&kill_thread, NULL, test7_thread, NULL);
818
819 printf ("%s iid %d: start - should block forever (waiting 5s)\n", __FUNCTION__, instance_id);
820 err = sam_start ();
821 if (err != CS_OK) {
822 fprintf (stderr, "Can't start hc. Error %d\n", err);
823 return 2;
824 }
825
826 printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
827 return (2);
828 }
829
830 if (instance_id == 2) {
831 /*
832 * Set to quorate
833 */
834 err = confdb_key_create(cdb_handle, quorum_handle, "quorate", strlen("quorate"), "1", strlen("1"));
835 if (err != CS_OK) {
836 printf ("Can't create confdb key. Error %d\n", err);
837 return (2);
838 }
839
840 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
841 err = sam_start ();
842 if (err != CS_OK) {
843 fprintf (stderr, "Can't start hc. Error %d\n", err);
844 return 2;
845 }
846
847 /*
848 * Set corosync unquorate
849 */
850 err = confdb_key_create(cdb_handle, quorum_handle, "quorate", strlen("quorate"), "0", strlen("0"));
851 if (err != CS_OK) {
852 printf ("Can't create confdb key. Error %d\n", err);
853 return (2);
854 }
855
856 printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
857 sleep (3);
858
859 printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
860 return (2);
861 }
862
863 if (instance_id == 3) {
864 return (0);
865 }
866
867 return (2);
868}
869
1a32fc4a
JF		 870/*
871 * Test confdb integration + quit policy
872 */
873static int test8 (pid_t pid, pid_t old_pid, int test_n) {
874 confdb_handle_t cdb_handle;
875 cs_error_t err;
876 hdb_handle_t res_handle, proc_handle, pid_handle;
877 size_t value_len;
878 uint64_t tstamp1, tstamp2;
83b24b66 879 int32_t msec_diff;
1a32fc4a
JF		 880 char key_value[256];
881 unsigned int instance_id;
882 char tmp_obj[PATH_MAX];
883 confdb_value_types_t cdbtype;
884
885 err = confdb_initialize (&cdb_handle, NULL);
886 if (err != CS_OK) {
887 printf ("Could not initialize Cluster Configuration Database API instance error %d. Test skipped\n", err);
888 return (1);
889 }
890
891 printf ("%s test %d\n", __FUNCTION__, test_n);
892
893 if (test_n == 2) {
894 /*
895 * Object should not exist
896 */
897 printf ("%s Testing if object exists (it shouldn't)\n", __FUNCTION__);
898
899 err = confdb_object_find_start(cdb_handle, OBJECT_PARENT_HANDLE);
900 if (err != CS_OK) {
901 printf ("Could not start object_find %d.\n", err);
902 return (2);
903 }
904
905 err = confdb_object_find(cdb_handle, OBJECT_PARENT_HANDLE, "resources", strlen("resources"), &res_handle);
906 if (err != CS_OK) {
907 printf ("Could not object_find \"resources\": %d.\n", err);
908 return (2);
909 }
910
911 err = confdb_object_find_start(cdb_handle, res_handle);
912 if (err != CS_OK) {
913 printf ("Could not start object_find %d.\n", err);
914 return (2);
915 }
916
917 err = confdb_object_find(cdb_handle, res_handle, "process", strlen("process"), &proc_handle);
918 if (err != CS_OK) {
919 printf ("Could not object_find \"process\": %d.\n", err);
920 return (2);
921 }
922
923 if (snprintf (tmp_obj, sizeof (tmp_obj), "%s:%d", __progname, pid) >= sizeof (tmp_obj)) {
924 snprintf (tmp_obj, sizeof (tmp_obj), "%d", pid);
925 }
926
927 err = confdb_object_find_start(cdb_handle, proc_handle);
928 if (err != CS_OK) {
929 printf ("Could not start object_find %d.\n", err);
930 return (2);
931 }
932
933 err = confdb_object_find(cdb_handle, proc_handle, tmp_obj, strlen(tmp_obj), &pid_handle);
934 if (err == CS_OK) {
935 printf ("Could find object \"%s\": %d.\n", tmp_obj, err);
936 return (2);
937 }
938 }
939
940 if (test_n == 1 || test_n == 2) {
941 printf ("%s: initialize\n", __FUNCTION__);
942 err = sam_initialize (2000, SAM_RECOVERY_POLICY_QUIT | SAM_RECOVERY_POLICY_CONFDB);
943 if (err != CS_OK) {
944 fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
945 return 2;
946 }
947
948 printf ("%s: register\n", __FUNCTION__);
949 err = sam_register (&instance_id);
950 if (err != CS_OK) {
951 fprintf (stderr, "Can't register. Error %d\n", err);
952 return 2;
953 }
954
955 err = confdb_object_find_start(cdb_handle, OBJECT_PARENT_HANDLE);
956 if (err != CS_OK) {
957 printf ("Could not start object_find %d.\n", err);
958 return (2);
959 }
960
961 err = confdb_object_find(cdb_handle, OBJECT_PARENT_HANDLE, "resources", strlen("resources"), &res_handle);
962 if (err != CS_OK) {
963 printf ("Could not object_find \"resources\": %d.\n", err);
964 return (2);
965 }
966
967 err = confdb_object_find_start(cdb_handle, res_handle);
968 if (err != CS_OK) {
969 printf ("Could not start object_find %d.\n", err);
970 return (2);
971 }
972
973 err = confdb_object_find(cdb_handle, res_handle, "process", strlen("process"), &proc_handle);
974 if (err != CS_OK) {
975 printf ("Could not object_find \"process\": %d.\n", err);
976 return (2);
977 }
978
979 if (snprintf (tmp_obj, sizeof (tmp_obj), "%s:%d", __progname, pid) >= sizeof (tmp_obj)) {
980 snprintf (tmp_obj, sizeof (tmp_obj), "%d", pid);
981 }
982
983 err = confdb_object_find_start(cdb_handle, proc_handle);
984 if (err != CS_OK) {
985 printf ("Could not start object_find %d.\n", err);
986 return (2);
987 }
988
989 err = confdb_object_find(cdb_handle, proc_handle, tmp_obj, strlen(tmp_obj), &pid_handle);
990 if (err != CS_OK) {
991 printf ("Could not object_find \"%s\": %d.\n", tmp_obj, err);
992 return (2);
993 }
994
995 err = confdb_key_get(cdb_handle, pid_handle, "recovery", strlen("recovery"), key_value, &value_len);
996 if (err != CS_OK) {
997 printf ("Could not get \"recovery\" key: %d.\n", err);
998 return (2);
999 }
1000
1001 if (value_len != strlen ("quit") || memcmp (key_value, "quit", value_len) != 0) {
1002 printf ("Recovery key \"%s\" is not \"watchdog\".\n", key_value);
1003 return (2);
1004 }
1005
1006 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1007 if (err != CS_OK) {
1008 printf ("Could not get \"state\" key: %d.\n", err);
1009 return (2);
1010 }
1011
83b24b66
AS		 1012 if (value_len != strlen ("stopped") || memcmp (key_value, "stopped", value_len) != 0) {
1013 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 1014 return (2);
1015 }
1016
1017 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
1018 err = sam_start ();
1019 if (err != CS_OK) {
1020 fprintf (stderr, "Can't start hc. Error %d\n", err);
1021 return 2;
1022 }
1023
1024 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1025 if (err != CS_OK) {
1026 printf ("Could not get \"state\" key: %d.\n", err);
1027 return (2);
1028 }
1029
83b24b66
AS		 1030 if (value_len != strlen ("running") || memcmp (key_value, "running", value_len) != 0) {
1031 printf ("State key is not \"running\".\n");
1a32fc4a
JF		 1032 return (2);
1033 }
1034
1035 printf ("%s iid %d: stop\n", __FUNCTION__, instance_id);
1036 err = sam_stop ();
1037 if (err != CS_OK) {
1038 fprintf (stderr, "Can't stop hc. Error %d\n", err);
1039 return 2;
1040 }
1041
1042 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1043 if (err != CS_OK) {
1044 printf ("Could not get \"state\" key: %d.\n", err);
1045 return (2);
1046 }
1047
83b24b66
AS		 1048 if (value_len != strlen ("stopped") || memcmp (key_value, "stopped", value_len) != 0) {
1049 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 1050 return (2);
1051 }
1052
1053 printf ("%s iid %d: sleeping 5\n", __FUNCTION__, instance_id);
1054 sleep (5);
1055
1056 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1057 if (err != CS_OK) {
1058 printf ("Could not get \"state\" key: %d.\n", err);
1059 return (2);
1060 }
1061
83b24b66
AS		 1062 if (value_len != strlen ("stopped") || memcmp (key_value, "stopped", value_len) != 0) {
1063 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 1064 return (2);
1065 }
1066
1067 printf ("%s iid %d: start 2\n", __FUNCTION__, instance_id);
1068 err = sam_start ();
1069 if (err != CS_OK) {
1070 fprintf (stderr, "Can't start hc. Error %d\n", err);
1071 return 2;
1072 }
1073
1074 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1075 if (err != CS_OK) {
1076 printf ("Could not get \"state\" key: %d.\n", err);
1077 return (2);
1078 }
1079
83b24b66
AS		 1080 if (value_len != strlen ("running") || memcmp (key_value, "running", value_len) != 0) {
1081 printf ("State key is not \"running\".\n");
1a32fc4a
JF		 1082 return (2);
1083 }
1084
1085 if (test_n == 2) {
1086 printf ("%s iid %d: sleeping 5. Should be killed\n", __FUNCTION__, instance_id);
1087 sleep (5);
1088
1089 return (2);
1090 } else {
1091 printf ("%s iid %d: Test HC\n", __FUNCTION__, instance_id);
1092 err = sam_hc_send ();
1093 if (err != CS_OK) {
1094 fprintf (stderr, "Can't send hc. Error %d\n", err);
1095 return 2;
1096 }
83b24b66 1097 err = confdb_key_get_typed (cdb_handle, pid_handle, "last_updated", &tstamp1, &value_len, &cdbtype);
1a32fc4a
JF		 1098 if (err != CS_OK) {
1099 printf ("Could not get \"state\" key: %d.\n", err);
1100 return (2);
1101 }
1102 printf ("%s iid %d: Sleep 1\n", __FUNCTION__, instance_id);
1103 sleep (1);
1104 err = sam_hc_send ();
1105 if (err != CS_OK) {
1106 fprintf (stderr, "Can't send hc. Error %d\n", err);
1107 return 2;
1108 }
1109 sleep (1);
83b24b66 1110 err = confdb_key_get_typed (cdb_handle, pid_handle, "last_updated", &tstamp2, &value_len, &cdbtype);
1a32fc4a
JF		 1111 if (err != CS_OK) {
1112 printf ("Could not get \"state\" key: %d.\n", err);
1113 return (2);
1114 }
83b24b66
AS		 1115 msec_diff = (tstamp2 - tstamp1)/CS_TIME_NS_IN_MSEC;
1116
1117 if (msec_diff < 500 || msec_diff > 2000) {
1118 printf ("Difference %d is not within <500, 2000> interval.\n", msec_diff);
1a32fc4a
JF		 1119 return (2);
1120 }
1121
1122 printf ("%s iid %d: stop 2\n", __FUNCTION__, instance_id);
1123 err = sam_stop ();
1124 if (err != CS_OK) {
1125 fprintf (stderr, "Can't stop hc. Error %d\n", err);
1126 return 2;
1127 }
1128
1129 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1130 if (err != CS_OK) {
1131 printf ("Could not get \"state\" key: %d.\n", err);
1132 return (2);
1133 }
1134
83b24b66
AS		 1135 if (value_len != strlen ("stopped") || memcmp (key_value, "stopped", value_len) != 0) {
1136 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 1137 return (2);
1138 }
1139
1140 printf ("%s iid %d: exiting\n", __FUNCTION__, instance_id);
1141 return (0);
1142 }
1143 }
1144
1145 if (test_n == 3) {
1146 printf ("%s Testing if status is failed\n", __FUNCTION__);
1147
1148 /*
1149 * Previous should be FAILED
1150 */
1151 err = confdb_object_find_start(cdb_handle, OBJECT_PARENT_HANDLE);
1152 if (err != CS_OK) {
1153 printf ("Could not start object_find %d.\n", err);
1154 return (2);
1155 }
1156
1157 err = confdb_object_find(cdb_handle, OBJECT_PARENT_HANDLE, "resources", strlen("resources"), &res_handle);
1158 if (err != CS_OK) {
1159 printf ("Could not object_find \"resources\": %d.\n", err);
1160 return (2);
1161 }
1162
1163 err = confdb_object_find_start(cdb_handle, res_handle);
1164 if (err != CS_OK) {
1165 printf ("Could not start object_find %d.\n", err);
1166 return (2);
1167 }
1168
1169 err = confdb_object_find(cdb_handle, res_handle, "process", strlen("process"), &proc_handle);
1170 if (err != CS_OK) {
1171 printf ("Could not object_find \"process\": %d.\n", err);
1172 return (2);
1173 }
1174
1175 if (snprintf (tmp_obj, sizeof (tmp_obj), "%s:%d", __progname, pid) >= sizeof (tmp_obj)) {
1176 snprintf (tmp_obj, sizeof (tmp_obj), "%d", pid);
1177 }
1178
1179 err = confdb_object_find_start(cdb_handle, proc_handle);
1180 if (err != CS_OK) {
1181 printf ("Could not start object_find %d.\n", err);
1182 return (2);
1183 }
1184
1185 err = confdb_object_find(cdb_handle, proc_handle, tmp_obj, strlen(tmp_obj), &pid_handle);
1186 if (err != CS_OK) {
1187 printf ("Could not object_find \"%s\": %d.\n", tmp_obj, err);
1188 return (2);
1189 }
1190
1191 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1192 if (err != CS_OK) {
1193 printf ("Could not get \"state\" key: %d.\n", err);
1194 return (2);
1195 }
1196
1197 if (value_len != strlen ("failed") || memcmp (key_value, "failed", value_len) != 0) {
1198 printf ("State key is not \"failed\".\n");
1199 return (2);
1200 }
1201
1202 return (0);
1203 }
1204
1205 return (2);
1206}
1207
1208/*
1209 * Test confdb integration + restart policy
1210 */
1211static int test9 (pid_t pid, pid_t old_pid, int test_n) {
1212 confdb_handle_t cdb_handle;
1213 cs_error_t err;
1214 hdb_handle_t res_handle, proc_handle, pid_handle;
1215 size_t value_len;
1216 char key_value[256];
1217 unsigned int instance_id;
1218 char tmp_obj[PATH_MAX];
1219
1220 err = confdb_initialize (&cdb_handle, NULL);
1221 if (err != CS_OK) {
1222 printf ("Could not initialize Cluster Configuration Database API instance error %d. Test skipped\n", err);
1223 return (1);
1224 }
1225
1226 printf ("%s test %d\n", __FUNCTION__, test_n);
1227
1228 if (test_n == 1) {
1229 printf ("%s: initialize\n", __FUNCTION__);
1230 err = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART | SAM_RECOVERY_POLICY_CONFDB);
1231 if (err != CS_OK) {
1232 fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
1233 return 2;
1234 }
1235
1236 printf ("%s: register\n", __FUNCTION__);
1237 err = sam_register (&instance_id);
1238 if (err != CS_OK) {
1239 fprintf (stderr, "Can't register. Error %d\n", err);
1240 return 2;
1241 }
1242 printf ("%s: iid %d\n", __FUNCTION__, instance_id);
1243
1244 if (instance_id < 3) {
1245 err = confdb_object_find_start(cdb_handle, OBJECT_PARENT_HANDLE);
1246 if (err != CS_OK) {
1247 printf ("Could not start object_find %d.\n", err);
1248 return (2);
1249 }
1250
1251 err = confdb_object_find(cdb_handle, OBJECT_PARENT_HANDLE, "resources", strlen("resources"),
1252 &res_handle);
1253 if (err != CS_OK) {
1254 printf ("Could not object_find \"resources\": %d.\n", err);
1255 return (2);
1256 }
1257
1258 err = confdb_object_find_start(cdb_handle, res_handle);
1259 if (err != CS_OK) {
1260 printf ("Could not start object_find %d.\n", err);
1261 return (2);
1262 }
1263
1264 err = confdb_object_find(cdb_handle, res_handle, "process", strlen("process"), &proc_handle);
1265 if (err != CS_OK) {
1266 printf ("Could not object_find \"process\": %d.\n", err);
1267 return (2);
1268 }
1269
1270 if (snprintf (tmp_obj, sizeof (tmp_obj), "%s:%d", __progname, pid) >= sizeof (tmp_obj)) {
1271 snprintf (tmp_obj, sizeof (tmp_obj), "%d", pid);
1272 }
1273
1274 err = confdb_object_find_start(cdb_handle, proc_handle);
1275 if (err != CS_OK) {
1276 printf ("Could not start object_find %d.\n", err);
1277 return (2);
1278 }
1279
1280 err = confdb_object_find(cdb_handle, proc_handle, tmp_obj, strlen(tmp_obj), &pid_handle);
1281 if (err != CS_OK) {
1282 printf ("Could not object_find \"%s\": %d.\n", tmp_obj, err);
1283 return (2);
1284 }
1285
1286 err = confdb_key_get(cdb_handle, pid_handle, "recovery", strlen("recovery"), key_value, &value_len);
1287 if (err != CS_OK) {
1288 printf ("Could not get \"recovery\" key: %d.\n", err);
1289 return (2);
1290 }
1291
1292 if (value_len != strlen ("restart") || memcmp (key_value, "restart", value_len) != 0) {
1293 printf ("Recovery key \"%s\" is not \"restart\".\n", key_value);
1294 return (2);
1295 }
1296
1297 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1298 if (err != CS_OK) {
1299 printf ("Could not get \"state\" key: %d.\n", err);
1300 return (2);
1301 }
1302
83b24b66
AS		 1303 if (value_len != strlen ("stopped") || memcmp (key_value, "stopped", value_len) != 0) {
1304 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 1305 return (2);
1306 }
1307
1308 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
1309 err = sam_start ();
1310 if (err != CS_OK) {
1311 fprintf (stderr, "Can't start hc. Error %d\n", err);
1312 return 2;
1313 }
1314
1315 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1316 if (err != CS_OK) {
1317 printf ("Could not get \"state\" key: %d.\n", err);
1318 return (2);
1319 }
1320
83b24b66
AS		 1321 if (value_len != strlen ("running") || memcmp (key_value, "running", value_len) != 0) {
1322 printf ("State key is not \"running\".\n");
1a32fc4a
JF		 1323 return (2);
1324 }
1325
1326 printf ("%s iid %d: waiting for kill\n", __FUNCTION__, instance_id);
1327 sleep (10);
1328
1329 return (2);
1330 }
1331
1332 if (instance_id == 3) {
1333 printf ("%s iid %d: mark failed\n", __FUNCTION__, instance_id);
1334 if (err != CS_OK) {
1335 fprintf (stderr, "Can't start hc. Error %d\n", err);
1336 return 2;
1337 }
1338 err = sam_mark_failed ();
1339 if (err != CS_OK) {
1340 fprintf (stderr, "Can't mark failed. Error %d\n", err);
1341 return 2;
1342 }
1343
1344 sleep (10);
1345
1346 return (2);
1347 }
1348
1349 return (2);
1350 }
1351
1352 if (test_n == 2) {
1353 printf ("%s Testing if status is failed\n", __FUNCTION__);
1354
1355 /*
1356 * Previous should be FAILED
1357 */
1358 err = confdb_object_find_start(cdb_handle, OBJECT_PARENT_HANDLE);
1359 if (err != CS_OK) {
1360 printf ("Could not start object_find %d.\n", err);
1361 return (2);
1362 }
1363
1364 err = confdb_object_find(cdb_handle, OBJECT_PARENT_HANDLE, "resources", strlen("resources"), &res_handle);
1365 if (err != CS_OK) {
1366 printf ("Could not object_find \"resources\": %d.\n", err);
1367 return (2);
1368 }
1369
1370 err = confdb_object_find_start(cdb_handle, res_handle);
1371 if (err != CS_OK) {
1372 printf ("Could not start object_find %d.\n", err);
1373 return (2);
1374 }
1375
1376 err = confdb_object_find(cdb_handle, res_handle, "process", strlen("process"), &proc_handle);
1377 if (err != CS_OK) {
1378 printf ("Could not object_find \"process\": %d.\n", err);
1379 return (2);
1380 }
1381
1382 if (snprintf (tmp_obj, sizeof (tmp_obj), "%s:%d", __progname, pid) >= sizeof (tmp_obj)) {
1383 snprintf (tmp_obj, sizeof (tmp_obj), "%d", pid);
1384 }
1385
1386 err = confdb_object_find_start(cdb_handle, proc_handle);
1387 if (err != CS_OK) {
1388 printf ("Could not start object_find %d.\n", err);
1389 return (2);
1390 }
1391
1392 err = confdb_object_find(cdb_handle, proc_handle, tmp_obj, strlen(tmp_obj), &pid_handle);
1393 if (err != CS_OK) {
1394 printf ("Could not object_find \"%s\": %d.\n", tmp_obj, err);
1395 return (2);
1396 }
1397
1398 err = confdb_key_get(cdb_handle, pid_handle, "state", strlen("state"), key_value, &value_len);
1399 if (err != CS_OK) {
1400 printf ("Could not get \"state\" key: %d.\n", err);
1401 return (2);
1402 }
1403
1404 if (value_len != strlen ("failed") || memcmp (key_value, "failed", value_len) != 0) {
1405 printf ("State key is not \"failed\".\n");
1406 return (2);
1407 }
1408
1409 return (0);
1410 }
1411
1412 return (2);
1413}
1414
0ed4d530
JF		 1415int main(int argc, char *argv[])
1416{
1a32fc4a 1417 pid_t pid, old_pid;
0ed4d530
JF		 1418 int err;
1419 int stat;
1420 int all_passed = 1;
d5884cd7 1421 int no_skipped = 0;
0ed4d530
JF		 1422
1423 pid = fork ();
1424
1425 if (pid == -1) {
1426 fprintf (stderr, "Can't fork\n");
1427 return 1;
1428 }
1429
1430 if (pid == 0) {
088a2a0f
JF		 1431 err = test1 ();
1432 sam_finalize ();
1433 return err;
0ed4d530
JF		 1434 }
1435
da6fce35 1436 waitpid (pid, &stat, 0);
0ed4d530 1437
da6fce35
JF		 1438 fprintf (stderr, "test1 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1439 if (WEXITSTATUS (stat) != 0)
1440 all_passed = 0;
0ed4d530
JF		 1441
1442 pid = fork ();
1443
1444 if (pid == -1) {
1445 fprintf (stderr, "Can't fork\n");
1446 return 1;
1447 }
1448
1449 if (pid == 0) {
1450 err = test2 ();
1451
088a2a0f
JF		 1452 sam_finalize ();
1453 return (err);
0ed4d530
JF		 1454 }
1455
1456 waitpid (pid, &stat, 0);
1457
1458 fprintf (stderr, "test2 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1459 if (WEXITSTATUS (stat) != 0)
1460 all_passed = 0;
1461
1462 pid = fork ();
1463
1464 if (pid == -1) {
1465 fprintf (stderr, "Can't fork\n");
1466 return 1;
1467 }
1468
1469 if (pid == 0) {
088a2a0f
JF		 1470 err = test3 ();
1471 sam_finalize ();
1472 return (err);
da6fce35 1473 }
0ed4d530 1474
da6fce35
JF		 1475 waitpid (pid, &stat, 0);
1476
1477 fprintf (stderr, "test3 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1478 if (WEXITSTATUS (stat) != 0)
1479 all_passed = 0;
1480
1481 pid = fork ();
1482
1483 if (pid == -1) {
1484 fprintf (stderr, "Can't fork\n");
1485 return 1;
0ed4d530
JF		 1486 }
1487
da6fce35 1488 if (pid == 0) {
088a2a0f
JF		 1489 err = test4 ();
1490 sam_finalize ();
1491 return (err);
da6fce35
JF		 1492 }
1493
1494 waitpid (pid, &stat, 0);
1495
1496 fprintf (stderr, "test4 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1497 if (WEXITSTATUS (stat) != 0)
1498 all_passed = 0;
0ed4d530
JF		 1499
1500 pid = fork ();
1501
1502 if (pid == -1) {
1503 fprintf (stderr, "Can't fork\n");
1504 return 1;
1505 }
1506
1507 if (pid == 0) {
da6fce35 1508 err = test5 ();
0ed4d530 1509
088a2a0f
JF		 1510 sam_finalize ();
1511 return (err);
0ed4d530
JF		 1512 }
1513
da6fce35
JF		 1514 waitpid (pid, &stat, 0);
1515 fprintf (stderr, "test5 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1516 if (WEXITSTATUS (stat) != 0)
1517 all_passed = 0;
0ed4d530 1518
088a2a0f
JF		 1519 pid = fork ();
1520
1521 if (pid == -1) {
1522 fprintf (stderr, "Can't fork\n");
1523 return 1;
1524 }
1525
1526 if (pid == 0) {
1527 err = test6 ();
1528 sam_finalize ();
1529 return (err);
1530 }
1531
1532 waitpid (pid, &stat, 0);
1533 fprintf (stderr, "test6 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1534 if (WEXITSTATUS (stat) != 0)
1535 all_passed = 0;
1536
d5884cd7
JF		 1537 pid = fork ();
1538
1539 if (pid == -1) {
1540 fprintf (stderr, "Can't fork\n");
1a32fc4a 1541 return 2;
d5884cd7
JF		 1542 }
1543
1544 if (pid == 0) {
1545 err = test7 ();
1546 sam_finalize ();
1547 return (err);
1548 }
1549
1550 waitpid (pid, &stat, 0);
1551 fprintf (stderr, "test7 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : (WEXITSTATUS (stat) == 1 ? "skipped" : "failed")));
1a32fc4a
JF		 1552 if (WEXITSTATUS (stat) == 1)
1553 no_skipped++;
1554 if (WEXITSTATUS (stat) > 1)
1555 all_passed = 0;
1556
1557 pid = fork ();
1558
1559 if (pid == -1) {
1560 fprintf (stderr, "Can't fork\n");
1561 return 2;
1562 }
1563
1564 if (pid == 0) {
1565 err = test8 (getpid (), 0, 1);
1566 sam_finalize ();
1567 return (err);
1568 }
1569
1570 waitpid (pid, &stat, 0);
1571 old_pid = pid;
1572
1573 if (WEXITSTATUS (stat) == 0) {
1574 pid = fork ();
1575
1576 if (pid == -1) {
1577 fprintf (stderr, "Can't fork\n");
1578 return 2;
1579 }
1580
1581 if (pid == 0) {
1582 err = test8 (getpid (), old_pid, 2);
1583 sam_finalize ();
1584 return (err);
1585 }
1586
1587 waitpid (pid, &stat, 0);
1588 old_pid = pid;
1589
1590 if (WEXITSTATUS (stat) == 0) {
1591 pid = fork ();
1592
1593 if (pid == -1) {
1594 fprintf (stderr, "Can't fork\n");
1595 return 2;
1596 }
1597
1598 if (pid == 0) {
1599 err = test8 (old_pid, 0, 3);
1600 sam_finalize ();
1601 return (err);
1602 }
1603
1604 waitpid (pid, &stat, 0);
1605 }
1606 }
1607
1608 if (WEXITSTATUS (stat) == 1)
1609 no_skipped++;
1610 if (WEXITSTATUS (stat) > 1)
1611 all_passed = 0;
1612
1613 pid = fork ();
1614
1615 if (pid == -1) {
1616 fprintf (stderr, "Can't fork\n");
1617 return 2;
1618 }
1619
1620 if (pid == 0) {
1621 err = test9 (getpid (), 0, 1);
1622 sam_finalize ();
1623 return (err);
1624 }
1625
1626 waitpid (pid, &stat, 0);
1627 old_pid = pid;
1628
1629 if (WEXITSTATUS (stat) == 0) {
1630 pid = fork ();
1631
1632 if (pid == -1) {
1633 fprintf (stderr, "Can't fork\n");
1634 return 2;
1635 }
1636
1637 if (pid == 0) {
1638 err = test9 (old_pid, 0, 2);
1639 sam_finalize ();
1640 return (err);
1641 }
1642
1643 waitpid (pid, &stat, 0);
1644 }
1645 fprintf (stderr, "test9 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : (WEXITSTATUS (stat) == 1 ? "skipped" : "failed")));
d5884cd7
JF		 1646 if (WEXITSTATUS (stat) == 1)
1647 no_skipped++;
1648
1649 if (WEXITSTATUS (stat) > 1)
1650 all_passed = 0;
1651
0ed4d530 1652 if (all_passed)
d5884cd7 1653 fprintf (stderr, "All tests passed (%d skipped)\n", no_skipped);
0ed4d530
JF		 1654
1655 return (all_passed ? 0 : 1);
1656}
corosync mirror