]> 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
Move SAM to use CMAP service
[mirror_corosync.git] / test / testsam.c
CommitLineData
0ed4d530 1/*
120531cd 2 * Copyright (c) 2009-2011 Red Hat, Inc.
0ed4d530
JF		 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>
c6895faa 42#include <pthread.h>
0ed4d530
JF		 43#include <sys/types.h>
44#include <stdio.h>
45#include <stdint.h>
46#include <stdlib.h>
47#include <unistd.h>
48#include <corosync/corotypes.h>
49#include <corosync/sam.h>
50#include <signal.h>
da6fce35 51#include <string.h>
0ed4d530 52#include <sys/wait.h>
120531cd 53#include <corosync/cmap.h>
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;
0ed4d530
JF		 247
248 printf ("%s: initialize\n", __FUNCTION__);
249 error = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART);
250 if (error != CS_OK) {
251 fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
252 return 1;
253 }
254 printf ("%s: register\n", __FUNCTION__);
255 error = sam_register (&instance_id);
256 if (error != CS_OK) {
257 fprintf (stderr, "Can't register. Error %d\n", error);
258 return 1;
259 }
260
261 if (instance_id < 100) {
262 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
263 error = sam_start ();
264 if (error != CS_OK) {
265 fprintf (stderr, "Can't start hc. Error %d\n", error);
266 return 1;
267 }
268
120531cd
JF		 269 printf ("%s iid %d: Sending signal\n", __FUNCTION__, instance_id);
270 kill(getpid(), SIGSEGV);
0ed4d530
JF		 271 return 1;
272 }
273
274 return 0;
275
276}
277
da6fce35
JF		 278/*
279 * Test sam_data_store, sam_data_restore and sam_data_getsize
280 */
281static int test4 (void)
282{
283 size_t size;
284 cs_error_t err;
285 int i;
286 unsigned int instance_id;
287 char saved_data[128];
288 char saved_data2[128];
289
290 printf ("%s: sam_data_getsize 1\n", __FUNCTION__);
291 err = sam_data_getsize (&size);
292 if (err != CS_ERR_BAD_HANDLE) {
293 fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
294 return 1;
295 }
296
297 printf ("%s: sam_data_getsize 2\n", __FUNCTION__);
298 err = sam_data_getsize (NULL);
299 if (err != CS_ERR_INVALID_PARAM) {
300 fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
301 return 1;
302 }
303
304 printf ("%s: sam_data_store 1\n", __FUNCTION__);
305 err = sam_data_store (NULL, 0);
306 if (err != CS_ERR_BAD_HANDLE) {
307 fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
308 return 1;
309 }
310
311 printf ("%s: sam_data_restore 1\n", __FUNCTION__);
312 err = sam_data_restore (saved_data, sizeof (saved_data));
313 if (err != CS_ERR_BAD_HANDLE) {
314 fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
315 return 1;
316 }
317
318 printf ("%s: sam_initialize\n", __FUNCTION__);
319 err = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART);
320 if (err != CS_OK) {
321 fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
322 return 1;
323 }
324
325 printf ("%s: sam_data_getsize 3\n", __FUNCTION__);
326 err = sam_data_getsize (&size);
327 if (err != CS_OK) {
328 fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
329 return 1;
330 }
331 if (size != 0) {
332 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
333 return 1;
334 }
335
336 printf ("%s: sam_data_restore 2\n", __FUNCTION__);
337 err = sam_data_restore (NULL, sizeof (saved_data));
338 if (err != CS_ERR_INVALID_PARAM) {
339 fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
340 return 1;
341 }
342
343 /*
344 * Store some real data
345 */
346 for (i = 0; i < sizeof (saved_data); i++) {
347 saved_data[i] = (char)(i + 5);
348 }
349
350 printf ("%s: sam_data_store 2\n", __FUNCTION__);
351 err = sam_data_store (saved_data, sizeof (saved_data));
352 if (err != CS_OK) {
353 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
354 return 1;
355 }
356
357 printf ("%s: sam_data_getsize 4\n", __FUNCTION__);
358 err = sam_data_getsize (&size);
359 if (err != CS_OK) {
360 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
361 return 1;
362 }
363 if (size != sizeof (saved_data)) {
364 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
365 return 1;
366 }
367
368 printf ("%s: sam_data_restore 3\n", __FUNCTION__);
369 err = sam_data_restore (saved_data2, sizeof (saved_data2) - 1);
370 if (err != CS_ERR_INVALID_PARAM) {
371 fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
372 return 1;
373 }
374
375 printf ("%s: sam_data_restore 4\n", __FUNCTION__);
376 err = sam_data_restore (saved_data2, sizeof (saved_data2));
377 if (err != CS_OK) {
378 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
379 return 1;
380 }
381
382 if (memcmp (saved_data, saved_data2, sizeof (saved_data2)) != 0) {
383 fprintf (stderr, "Retored data are not same\n");
384 return 1;
385 }
386
387 memset (saved_data2, 0, sizeof (saved_data2));
388
389 printf ("%s: sam_data_store 3\n", __FUNCTION__);
390 err = sam_data_store (NULL, 1);
391 if (err != CS_OK) {
392 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
393 return 1;
394 }
395
396 printf ("%s: sam_data_getsize 5\n", __FUNCTION__);
397 err = sam_data_getsize (&size);
398 if (err != CS_OK) {
399 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
400 return 1;
401 }
402 if (size != 0) {
403 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
404 return 1;
405 }
406
407 printf ("%s: sam_data_store 4\n", __FUNCTION__);
408 err = sam_data_store (saved_data, sizeof (saved_data));
409 if (err != CS_OK) {
410 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
411 return 1;
412 }
413
414 printf ("%s: register\n", __FUNCTION__);
415 err = sam_register (&instance_id);
416 if (err != CS_OK) {
417 fprintf (stderr, "Can't register. Error %d\n", err);
418 return 1;
419 }
420
421 if (instance_id == 1) {
422 printf ("%s iid %d: sam_start\n", __FUNCTION__, instance_id);
423 err = sam_start ();
424 if (err != CS_OK) {
425 fprintf (stderr, "Can't start hc. Error %d\n", err);
426 return 1;
427 }
428
429 printf ("%s iid %d: sam_data_getsize 6\n", __FUNCTION__, instance_id);
430 err = sam_data_getsize (&size);
431 if (err != CS_OK) {
432 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
433 return 1;
434 }
435 if (size != sizeof (saved_data2)) {
436 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
437 return 1;
438 }
439
440 printf ("%s iid %d: sam_data_restore 5\n", __FUNCTION__, instance_id);
441 err = sam_data_restore (saved_data2, sizeof (saved_data2));
442 if (err != CS_OK) {
443 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
444 return 1;
445 }
446
447 if (memcmp (saved_data, saved_data2, sizeof (saved_data2)) != 0) {
448 fprintf (stderr, "Retored data are not same\n");
449 return 1;
450 }
451
452 for (i = 0; i < sizeof (saved_data); i++) {
453 saved_data[i] = (char)(i - 5);
454 }
455
456 printf ("%s iid %d: sam_data_store 5\n", __FUNCTION__, instance_id);
457 err = sam_data_store (saved_data, sizeof (saved_data) - 7);
458 if (err != CS_OK) {
459 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
460 return 1;
461 }
462
463 exit (1);
464 }
465
466 if (instance_id == 2) {
467 printf ("%s iid %d: sam_start\n", __FUNCTION__, instance_id);
468 err = sam_start ();
469 if (err != CS_OK) {
470 fprintf (stderr, "Can't start hc. Error %d\n", err);
471 return 1;
472 }
473
474 printf ("%s iid %d: sam_data_getsize 7\n", __FUNCTION__, instance_id);
475 err = sam_data_getsize (&size);
476 if (err != CS_OK) {
477 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
478 return 1;
479 }
480 if (size != sizeof (saved_data2) - 7) {
481 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
482 return 1;
483 }
484
485 printf ("%s iid %d: sam_data_restore 6\n", __FUNCTION__, instance_id);
486 err = sam_data_restore (saved_data2, sizeof (saved_data2));
487 if (err != CS_OK) {
488 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
489 return 1;
490 }
491
492 for (i = 0; i < sizeof (saved_data); i++) {
493 saved_data[i] = (char)(i - 5);
494 }
495
496 if (memcmp (saved_data, saved_data2, sizeof (saved_data2) - 7) != 0) {
497 fprintf (stderr, "Retored data are not same\n");
498 return 1;
499 }
500
501 printf ("%s iid %d: sam_data_store 6\n", __FUNCTION__, instance_id);
502 err = sam_data_store (NULL, 0);
503 if (err != CS_OK) {
504 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
505 return 1;
506 }
507
508 exit (1);
509 }
510
511 if (instance_id == 3) {
512 printf ("%s iid %d: sam_data_getsize 8\n", __FUNCTION__, instance_id);
513 err = sam_data_getsize (&size);
514 if (err != CS_OK) {
515 fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
516 return 1;
517 }
518 if (size != 0) {
519 fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
520 return 1;
521 }
522 }
523
524 return (0);
525}
526
527static int test5_hc_cb (void)
0ed4d530 528{
bdd03a4b 529 cs_error_t res;
da6fce35
JF		 530 printf ("%s %d\n", __FUNCTION__, ++test5_hc_cb_count);
531
bdd03a4b
SD		 532 res = sam_data_store (&test5_hc_cb_count, sizeof (test5_hc_cb_count));
533 if (res != CS_OK)
534 return 1;
0ed4d530 535
da6fce35 536 if (test5_hc_cb_count > 10)
0ed4d530
JF		 537 return 1;
538
539 return 0;
540}
541/*
542 * Test event driven healtchecking.
543 */
da6fce35 544static int test5 (void)
0ed4d530
JF		 545{
546 cs_error_t error;
547 unsigned int instance_id;
da6fce35 548 int hc_cb_count;
0ed4d530
JF		 549
550 printf ("%s: initialize\n", __FUNCTION__);
551 error = sam_initialize (100, SAM_RECOVERY_POLICY_RESTART);
552 if (error != CS_OK) {
553 fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
554 return 1;
555 }
556 printf ("%s: register\n", __FUNCTION__);
557 error = sam_register (&instance_id);
558 if (error != CS_OK) {
559 fprintf (stderr, "Can't register. Error %d\n", error);
560 return 1;
561 }
562
563 if (instance_id == 1) {
564 printf ("%s iid %d: hc callback register\n", __FUNCTION__, instance_id);
da6fce35 565 error = sam_hc_callback_register (test5_hc_cb);
0ed4d530
JF		 566 if (error != CS_OK) {
567 fprintf (stderr, "Can't register hc cb. Error %d\n", error);
568 return 1;
569 }
570
571
572 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
573 error = sam_start ();
574 if (error != CS_OK) {
575 fprintf (stderr, "Can't start hc. Error %d\n", error);
576 return 1;
577 }
578
579 sleep (2);
580
581 printf ("%s iid %d: Failed. Wasn't killed.\n", __FUNCTION__, instance_id);
582 return 1;
583 }
584
585 if (instance_id == 2) {
da6fce35
JF		 586 error = sam_data_restore (&hc_cb_count, sizeof (hc_cb_count));
587 if (error != CS_OK) {
588 fprintf (stderr, "sam_data_restore should return CS_OK. Error returned %d\n", error);
589 return 1;
590 }
591
592 if (hc_cb_count != 11) {
593 fprintf (stderr, "%s iid %d: Premature killed. hc_cb_count should be 11 and it is %d\n",
594 __FUNCTION__, instance_id - 1, hc_cb_count);
595 return 1;
596
597 }
0ed4d530
JF		 598 return 0;
599 }
600
601 return 1;
602}
603
088a2a0f
JF		 604static void test6_signal (int sig) {
605 cs_error_t error;
606
607 printf ("%s\n", __FUNCTION__);
608 test6_sig_delivered++;
609
610 if ((error = sam_data_store (&test6_sig_delivered, sizeof (test6_sig_delivered))) != CS_OK) {
611 fprintf (stderr, "Can't store data! Error : %d\n", error);
612 }
613}
614
615/*
616 * Test warn signal set.
617 */
618static int test6 (void) {
619 cs_error_t error;
620 unsigned int instance_id;
621 int test6_sig_del;
622
623 printf ("%s: initialize\n", __FUNCTION__);
624 error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
625 if (error != CS_OK) {
626 fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
627 return 1;
628 }
629 printf ("%s: register\n", __FUNCTION__);
630 error = sam_register (&instance_id);
631 if (error != CS_OK) {
632 fprintf (stderr, "Can't register. Error %d\n", error);
633 return 1;
634 }
635
636 if (instance_id == 1) {
637 error = sam_warn_signal_set (SIGUSR1);
638 if (error != CS_OK) {
639 fprintf (stderr, "Can't set warn signal. Error %d\n", error);
640 return 1;
641 }
642
643 signal (SIGUSR1, test6_signal);
644
645 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
646 error = sam_start ();
647 if (error != CS_OK) {
648 fprintf (stderr, "Can't start hc. Error %d\n", error);
649 return 1;
650 }
651
652 printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
653 sleep (1);
654
655 printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
656 error = sam_hc_send ();
657 if (error != CS_OK) {
658 fprintf (stderr, "Can't send hc. Error %d\n", error);
659 return 1;
660 }
661
662
663 printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
664 while (!test6_sig_delivered) {
665 sleep (1);
666 }
667
668 printf ("%s iid %d: wait for real kill\n", __FUNCTION__, instance_id);
669
670 sleep (3);
671
672 printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
673 return (1);
674 }
675
676 if (instance_id == 2) {
677 error = sam_data_restore (&test6_sig_del, sizeof (test6_sig_del));
678 if (error != CS_OK) {
679 fprintf (stderr, "Can't restore data. Error %d\n", error);
680 return 1;
681 }
682
683 if (test6_sig_del != 1) {
684 fprintf (stderr, "Previous test failed. Signal was not delivered\n");
685 return 1;
686 }
687
688 error = sam_warn_signal_set (SIGKILL);
689 if (error != CS_OK) {
690 fprintf (stderr, "Can't set warn signal. Error %d\n", error);
691 return 1;
692 }
693
694 signal (SIGUSR1, test6_signal);
695
696 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
697 error = sam_start ();
698 if (error != CS_OK) {
699 fprintf (stderr, "Can't start hc. Error %d\n", error);
700 return 1;
701 }
702
703 printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
704 sleep (1);
705
706 printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
707 error = sam_hc_send ();
708 if (error != CS_OK) {
709 fprintf (stderr, "Can't send hc. Error %d\n", error);
710 return 1;
711 }
712
713
714 printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
715 while (!test6_sig_delivered) {
716 sleep (1);
717 }
718
719 printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
720 return (1);
721 }
722
723 if (instance_id == 3) {
724 error = sam_data_restore (&test6_sig_del, sizeof (test6_sig_del));
725 if (error != CS_OK) {
726 fprintf (stderr, "Can't restore data. Error %d\n", error);
727 return 1;
728 }
729
730 if (test6_sig_del != 1) {
731 fprintf (stderr, "Previous test failed. Signal WAS delivered\n");
732 return 1;
733 }
734
735 return (0);
736 }
737
738 return 1;
739}
da6fce35 740
d5884cd7
JF		 741static void *test7_thread (void *arg)
742{
743 /* Wait 5s */
744 sleep (5);
745 exit (0);
746}
747
748/*
749 * Test quorum
750 */
751static int test7 (void) {
120531cd 752 cmap_handle_t cmap_handle;
d5884cd7 753 cs_error_t err;
d5884cd7
JF		 754 unsigned int instance_id;
755 pthread_t kill_thread;
120531cd 756 char *str;
d5884cd7 757
120531cd 758 err = cmap_initialize (&cmap_handle);
d5884cd7 759 if (err != CS_OK) {
120531cd 760 printf ("Could not initialize Cluster Map API instance error %d. Test skipped\n", err);
d5884cd7
JF		 761 return (1);
762 }
763
d5884cd7 764
120531cd 765 if (cmap_get_string(cmap_handle, "quorum.provider", &str) != CS_OK) {
d5884cd7
JF		 766 printf ("Could not get \"provider\" key: %d. Test skipped\n", err);
767 return (1);
768 }
120531cd 769 if (strcmp(str, "testquorum") != 0) {
d5884cd7
JF		 770 printf ("Provider is not testquorum. Test skipped\n");
771 return (1);
772 }
120531cd 773 free(str);
d5884cd7
JF		 774
775 /*
776 * Set to not quorate
777 */
120531cd 778 err = cmap_set_uint8(cmap_handle, "quorum.quorate", 0);
d5884cd7 779 if (err != CS_OK) {
120531cd 780 printf ("Can't set map key. Error %d\n", err);
d5884cd7
JF		 781 return (2);
782 }
783
784 printf ("%s: initialize\n", __FUNCTION__);
785 err = sam_initialize (2000, SAM_RECOVERY_POLICY_QUORUM_RESTART);
786 if (err != CS_OK) {
787 fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
788 return 2;
789 }
790
791 printf ("%s: register\n", __FUNCTION__);
792 err = sam_register (&instance_id);
793 if (err != CS_OK) {
794 fprintf (stderr, "Can't register. Error %d\n", err);
795 return 2;
796 }
797
798 if (instance_id == 1) {
799 /*
800 * Sam start should block forever, but 10s for us should be enough
801 */
802 pthread_create (&kill_thread, NULL, test7_thread, NULL);
803
804 printf ("%s iid %d: start - should block forever (waiting 5s)\n", __FUNCTION__, instance_id);
805 err = sam_start ();
806 if (err != CS_OK) {
807 fprintf (stderr, "Can't start hc. Error %d\n", err);
808 return 2;
809 }
810
811 printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
812 return (2);
813 }
814
815 if (instance_id == 2) {
816 /*
817 * Set to quorate
818 */
120531cd 819 err = cmap_set_uint8(cmap_handle, "quorum.quorate", 1);
d5884cd7 820 if (err != CS_OK) {
120531cd 821 printf ("Can't set map key. Error %d\n", err);
d5884cd7
JF		 822 return (2);
823 }
824
825 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
826 err = sam_start ();
827 if (err != CS_OK) {
828 fprintf (stderr, "Can't start hc. Error %d\n", err);
829 return 2;
830 }
831
832 /*
833 * Set corosync unquorate
834 */
120531cd 835 err = cmap_set_uint8(cmap_handle, "quorum.quorate", 0);
d5884cd7 836 if (err != CS_OK) {
120531cd 837 printf ("Can't set map key. Error %d\n", err);
d5884cd7
JF		 838 return (2);
839 }
840
841 printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
842 sleep (3);
843
844 printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
845 return (2);
846 }
847
848 if (instance_id == 3) {
849 return (0);
850 }
851
852 return (2);
853}
854
1a32fc4a 855/*
120531cd 856 * Test cmap integration + quit policy
1a32fc4a
JF		 857 */
858static int test8 (pid_t pid, pid_t old_pid, int test_n) {
120531cd 859 cmap_handle_t cmap_handle;
1a32fc4a 860 cs_error_t err;
1a32fc4a 861 uint64_t tstamp1, tstamp2;
83b24b66 862 int32_t msec_diff;
1a32fc4a 863 unsigned int instance_id;
120531cd
JF		 864 char key_name[CMAP_KEYNAME_MAXLEN];
865 char *str;
1a32fc4a 866
120531cd 867 err = cmap_initialize (&cmap_handle);
1a32fc4a 868 if (err != CS_OK) {
120531cd 869 printf ("Could not initialize Cluster Map API instance error %d. Test skipped\n", err);
1a32fc4a
JF		 870 return (1);
871 }
872
873 printf ("%s test %d\n", __FUNCTION__, test_n);
874
875 if (test_n == 2) {
876 /*
877 * Object should not exist
878 */
879 printf ("%s Testing if object exists (it shouldn't)\n", __FUNCTION__);
880
120531cd
JF		 881 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
882 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a 883 if (err == CS_OK) {
120531cd
JF		 884 printf ("Could find key \"%s\": %d.\n", key_name, err);
885 free(str);
1a32fc4a
JF		 886 return (2);
887 }
888 }
889
890 if (test_n == 1 || test_n == 2) {
891 printf ("%s: initialize\n", __FUNCTION__);
120531cd 892 err = sam_initialize (2000, SAM_RECOVERY_POLICY_QUIT | SAM_RECOVERY_POLICY_CMAP);
1a32fc4a
JF		 893 if (err != CS_OK) {
894 fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
895 return 2;
896 }
897
898 printf ("%s: register\n", __FUNCTION__);
899 err = sam_register (&instance_id);
900 if (err != CS_OK) {
901 fprintf (stderr, "Can't register. Error %d\n", err);
902 return 2;
903 }
904
120531cd
JF		 905 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.recovery", pid);
906 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 907 if (err != CS_OK) {
908 printf ("Could not get \"recovery\" key: %d.\n", err);
909 return (2);
910 }
911
120531cd
JF		 912 if (strcmp(str, "quit") != 0) {
913 printf ("Recovery key \"%s\" is not \"quit\".\n", key_name);
1a32fc4a
JF		 914 return (2);
915 }
120531cd 916 free(str);
1a32fc4a 917
120531cd
JF		 918 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
919 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 920 if (err != CS_OK) {
921 printf ("Could not get \"state\" key: %d.\n", err);
922 return (2);
923 }
924
120531cd 925 if (strcmp(str, "stopped") != 0) {
83b24b66 926 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 927 return (2);
928 }
120531cd 929 free(str);
1a32fc4a
JF		 930
931 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
932 err = sam_start ();
933 if (err != CS_OK) {
934 fprintf (stderr, "Can't start hc. Error %d\n", err);
935 return 2;
936 }
937
120531cd 938 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 939 if (err != CS_OK) {
940 printf ("Could not get \"state\" key: %d.\n", err);
941 return (2);
942 }
943
120531cd 944 if (strcmp(str, "running") != 0) {
83b24b66 945 printf ("State key is not \"running\".\n");
1a32fc4a
JF		 946 return (2);
947 }
120531cd 948 free(str);
1a32fc4a
JF		 949
950 printf ("%s iid %d: stop\n", __FUNCTION__, instance_id);
951 err = sam_stop ();
952 if (err != CS_OK) {
953 fprintf (stderr, "Can't stop hc. Error %d\n", err);
954 return 2;
955 }
956
120531cd 957 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 958 if (err != CS_OK) {
959 printf ("Could not get \"state\" key: %d.\n", err);
960 return (2);
961 }
962
120531cd 963 if (strcmp(str, "stopped") != 0) {
83b24b66 964 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 965 return (2);
966 }
120531cd 967 free(str);
1a32fc4a
JF		 968
969 printf ("%s iid %d: sleeping 5\n", __FUNCTION__, instance_id);
970 sleep (5);
971
120531cd 972 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 973 if (err != CS_OK) {
974 printf ("Could not get \"state\" key: %d.\n", err);
975 return (2);
976 }
977
120531cd 978 if (strcmp(str, "stopped") != 0) {
83b24b66 979 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 980 return (2);
981 }
120531cd 982 free(str);
1a32fc4a
JF		 983
984 printf ("%s iid %d: start 2\n", __FUNCTION__, instance_id);
985 err = sam_start ();
986 if (err != CS_OK) {
987 fprintf (stderr, "Can't start hc. Error %d\n", err);
988 return 2;
989 }
990
120531cd 991 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 992 if (err != CS_OK) {
993 printf ("Could not get \"state\" key: %d.\n", err);
994 return (2);
995 }
996
120531cd 997 if (strcmp(str, "running") != 0) {
83b24b66 998 printf ("State key is not \"running\".\n");
1a32fc4a
JF		 999 return (2);
1000 }
120531cd 1001 free(str);
1a32fc4a
JF		 1002
1003 if (test_n == 2) {
1004 printf ("%s iid %d: sleeping 5. Should be killed\n", __FUNCTION__, instance_id);
1005 sleep (5);
1006
1007 return (2);
1008 } else {
1009 printf ("%s iid %d: Test HC\n", __FUNCTION__, instance_id);
1010 err = sam_hc_send ();
1011 if (err != CS_OK) {
1012 fprintf (stderr, "Can't send hc. Error %d\n", err);
1013 return 2;
1014 }
120531cd
JF		 1015
1016 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.last_updated", pid);
1017 err = cmap_get_uint64(cmap_handle, key_name, &tstamp1);
1a32fc4a 1018 if (err != CS_OK) {
120531cd 1019 printf ("Could not get \"last_updated\" key: %d.\n", err);
1a32fc4a
JF		 1020 return (2);
1021 }
1022 printf ("%s iid %d: Sleep 1\n", __FUNCTION__, instance_id);
1023 sleep (1);
1024 err = sam_hc_send ();
1025 if (err != CS_OK) {
1026 fprintf (stderr, "Can't send hc. Error %d\n", err);
1027 return 2;
1028 }
1029 sleep (1);
120531cd 1030 err = cmap_get_uint64(cmap_handle, key_name, &tstamp2);
1a32fc4a 1031 if (err != CS_OK) {
120531cd 1032 printf ("Could not get \"last_updated\" key: %d.\n", err);
1a32fc4a
JF		 1033 return (2);
1034 }
83b24b66
AS		 1035 msec_diff = (tstamp2 - tstamp1)/CS_TIME_NS_IN_MSEC;
1036
1037 if (msec_diff < 500 || msec_diff > 2000) {
1038 printf ("Difference %d is not within <500, 2000> interval.\n", msec_diff);
1a32fc4a
JF		 1039 return (2);
1040 }
1041
1042 printf ("%s iid %d: stop 2\n", __FUNCTION__, instance_id);
1043 err = sam_stop ();
1044 if (err != CS_OK) {
1045 fprintf (stderr, "Can't stop hc. Error %d\n", err);
1046 return 2;
1047 }
1048
120531cd
JF		 1049 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
1050 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 1051 if (err != CS_OK) {
1052 printf ("Could not get \"state\" key: %d.\n", err);
1053 return (2);
1054 }
1055
120531cd 1056 if (strcmp(str, "stopped") != 0) {
83b24b66 1057 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 1058 return (2);
1059 }
120531cd 1060 free(str);
1a32fc4a
JF		 1061
1062 printf ("%s iid %d: exiting\n", __FUNCTION__, instance_id);
1063 return (0);
1064 }
1065 }
1066
1067 if (test_n == 3) {
1068 printf ("%s Testing if status is failed\n", __FUNCTION__);
1069
1070 /*
1071 * Previous should be FAILED
1072 */
1a32fc4a 1073
120531cd
JF		 1074 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
1075 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 1076 if (err != CS_OK) {
1077 printf ("Could not get \"state\" key: %d.\n", err);
1078 return (2);
1079 }
1080
120531cd 1081 if (strcmp(str, "failed") != 0) {
1a32fc4a
JF		 1082 printf ("State key is not \"failed\".\n");
1083 return (2);
1084 }
1085
1086 return (0);
1087 }
1088
1089 return (2);
1090}
1091
1092/*
120531cd 1093 * Test cmap integration + restart policy
1a32fc4a
JF		 1094 */
1095static int test9 (pid_t pid, pid_t old_pid, int test_n) {
1a32fc4a 1096 cs_error_t err;
120531cd 1097 cmap_handle_t cmap_handle;
1a32fc4a 1098 unsigned int instance_id;
120531cd
JF		 1099 char *str;
1100 char key_name[CMAP_KEYNAME_MAXLEN];
1a32fc4a 1101
120531cd 1102 err = cmap_initialize (&cmap_handle);
1a32fc4a 1103 if (err != CS_OK) {
120531cd 1104 printf ("Could not initialize Cluster Map API instance error %d. Test skipped\n", err);
1a32fc4a
JF		 1105 return (1);
1106 }
1107
1108 printf ("%s test %d\n", __FUNCTION__, test_n);
1109
1110 if (test_n == 1) {
1111 printf ("%s: initialize\n", __FUNCTION__);
120531cd 1112 err = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART | SAM_RECOVERY_POLICY_CMAP);
1a32fc4a
JF		 1113 if (err != CS_OK) {
1114 fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
1115 return 2;
1116 }
1117
1118 printf ("%s: register\n", __FUNCTION__);
1119 err = sam_register (&instance_id);
1120 if (err != CS_OK) {
1121 fprintf (stderr, "Can't register. Error %d\n", err);
1122 return 2;
1123 }
1124 printf ("%s: iid %d\n", __FUNCTION__, instance_id);
1125
1126 if (instance_id < 3) {
120531cd
JF		 1127 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.recovery", pid);
1128 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 1129 if (err != CS_OK) {
1130 printf ("Could not get \"recovery\" key: %d.\n", err);
1131 return (2);
1132 }
1133
120531cd
JF		 1134 if (strcmp(str, "restart") != 0) {
1135 printf ("Recovery key \"%s\" is not \"restart\".\n", str);
1a32fc4a
JF		 1136 return (2);
1137 }
120531cd 1138 free(str);
1a32fc4a 1139
120531cd
JF		 1140 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
1141 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 1142 if (err != CS_OK) {
1143 printf ("Could not get \"state\" key: %d.\n", err);
1144 return (2);
1145 }
1146
120531cd 1147 if (strcmp(str, "stopped") != 0) {
83b24b66 1148 printf ("State key is not \"stopped\".\n");
1a32fc4a
JF		 1149 return (2);
1150 }
120531cd 1151 free(str);
1a32fc4a
JF		 1152
1153 printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
1154 err = sam_start ();
1155 if (err != CS_OK) {
1156 fprintf (stderr, "Can't start hc. Error %d\n", err);
1157 return 2;
1158 }
1159
120531cd 1160 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 1161 if (err != CS_OK) {
1162 printf ("Could not get \"state\" key: %d.\n", err);
1163 return (2);
1164 }
1165
120531cd 1166 if (strcmp(str, "running") != 0) {
83b24b66 1167 printf ("State key is not \"running\".\n");
1a32fc4a
JF		 1168 return (2);
1169 }
120531cd 1170 free(str);
1a32fc4a
JF		 1171
1172 printf ("%s iid %d: waiting for kill\n", __FUNCTION__, instance_id);
1173 sleep (10);
1174
1175 return (2);
1176 }
1177
1178 if (instance_id == 3) {
1179 printf ("%s iid %d: mark failed\n", __FUNCTION__, instance_id);
1180 if (err != CS_OK) {
1181 fprintf (stderr, "Can't start hc. Error %d\n", err);
1182 return 2;
1183 }
1184 err = sam_mark_failed ();
1185 if (err != CS_OK) {
1186 fprintf (stderr, "Can't mark failed. Error %d\n", err);
1187 return 2;
1188 }
1189
1190 sleep (10);
1191
1192 return (2);
1193 }
1194
1195 return (2);
1196 }
1197
1198 if (test_n == 2) {
1199 printf ("%s Testing if status is failed\n", __FUNCTION__);
1200
1201 /*
1202 * Previous should be FAILED
1203 */
120531cd
JF		 1204 snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
1205 err = cmap_get_string(cmap_handle, key_name, &str);
1a32fc4a
JF		 1206 if (err != CS_OK) {
1207 printf ("Could not get \"state\" key: %d.\n", err);
1208 return (2);
1209 }
1210
120531cd 1211 if (strcmp(str, "failed") != 0) {
1a32fc4a
JF		 1212 printf ("State key is not \"failed\".\n");
1213 return (2);
1214 }
120531cd 1215 free(str);
1a32fc4a
JF		 1216
1217 return (0);
1218 }
1219
1220 return (2);
1221}
1222
0ed4d530
JF		 1223int main(int argc, char *argv[])
1224{
1a32fc4a 1225 pid_t pid, old_pid;
0ed4d530
JF		 1226 int err;
1227 int stat;
1228 int all_passed = 1;
d5884cd7 1229 int no_skipped = 0;
0ed4d530
JF		 1230
1231 pid = fork ();
1232
1233 if (pid == -1) {
1234 fprintf (stderr, "Can't fork\n");
1235 return 1;
1236 }
1237
1238 if (pid == 0) {
088a2a0f
JF		 1239 err = test1 ();
1240 sam_finalize ();
1241 return err;
0ed4d530
JF		 1242 }
1243
da6fce35 1244 waitpid (pid, &stat, 0);
0ed4d530 1245
da6fce35
JF		 1246 fprintf (stderr, "test1 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1247 if (WEXITSTATUS (stat) != 0)
1248 all_passed = 0;
0ed4d530
JF		 1249
1250 pid = fork ();
1251
1252 if (pid == -1) {
1253 fprintf (stderr, "Can't fork\n");
1254 return 1;
1255 }
1256
1257 if (pid == 0) {
1258 err = test2 ();
1259
088a2a0f
JF		 1260 sam_finalize ();
1261 return (err);
0ed4d530
JF		 1262 }
1263
1264 waitpid (pid, &stat, 0);
1265
1266 fprintf (stderr, "test2 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1267 if (WEXITSTATUS (stat) != 0)
1268 all_passed = 0;
1269
1270 pid = fork ();
1271
1272 if (pid == -1) {
1273 fprintf (stderr, "Can't fork\n");
1274 return 1;
1275 }
1276
1277 if (pid == 0) {
088a2a0f
JF		 1278 err = test3 ();
1279 sam_finalize ();
1280 return (err);
da6fce35 1281 }
0ed4d530 1282
da6fce35
JF		 1283 waitpid (pid, &stat, 0);
1284
1285 fprintf (stderr, "test3 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1286 if (WEXITSTATUS (stat) != 0)
1287 all_passed = 0;
1288
1289 pid = fork ();
1290
1291 if (pid == -1) {
1292 fprintf (stderr, "Can't fork\n");
1293 return 1;
0ed4d530
JF		 1294 }
1295
da6fce35 1296 if (pid == 0) {
088a2a0f
JF		 1297 err = test4 ();
1298 sam_finalize ();
1299 return (err);
da6fce35
JF		 1300 }
1301
1302 waitpid (pid, &stat, 0);
1303
1304 fprintf (stderr, "test4 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1305 if (WEXITSTATUS (stat) != 0)
1306 all_passed = 0;
0ed4d530
JF		 1307
1308 pid = fork ();
1309
1310 if (pid == -1) {
1311 fprintf (stderr, "Can't fork\n");
1312 return 1;
1313 }
1314
1315 if (pid == 0) {
da6fce35 1316 err = test5 ();
0ed4d530 1317
088a2a0f
JF		 1318 sam_finalize ();
1319 return (err);
0ed4d530
JF		 1320 }
1321
da6fce35
JF		 1322 waitpid (pid, &stat, 0);
1323 fprintf (stderr, "test5 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1324 if (WEXITSTATUS (stat) != 0)
1325 all_passed = 0;
0ed4d530 1326
088a2a0f
JF		 1327 pid = fork ();
1328
1329 if (pid == -1) {
1330 fprintf (stderr, "Can't fork\n");
1331 return 1;
1332 }
1333
1334 if (pid == 0) {
1335 err = test6 ();
1336 sam_finalize ();
1337 return (err);
1338 }
1339
1340 waitpid (pid, &stat, 0);
1341 fprintf (stderr, "test6 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
1342 if (WEXITSTATUS (stat) != 0)
1343 all_passed = 0;
1344
d5884cd7
JF		 1345 pid = fork ();
1346
1347 if (pid == -1) {
1348 fprintf (stderr, "Can't fork\n");
1a32fc4a 1349 return 2;
d5884cd7
JF		 1350 }
1351
1352 if (pid == 0) {
1353 err = test7 ();
1354 sam_finalize ();
1355 return (err);
1356 }
1357
1358 waitpid (pid, &stat, 0);
1359 fprintf (stderr, "test7 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : (WEXITSTATUS (stat) == 1 ? "skipped" : "failed")));
1a32fc4a
JF		 1360 if (WEXITSTATUS (stat) == 1)
1361 no_skipped++;
1362 if (WEXITSTATUS (stat) > 1)
1363 all_passed = 0;
1364
1365 pid = fork ();
1366
1367 if (pid == -1) {
1368 fprintf (stderr, "Can't fork\n");
1369 return 2;
1370 }
1371
1372 if (pid == 0) {
1373 err = test8 (getpid (), 0, 1);
1374 sam_finalize ();
1375 return (err);
1376 }
1377
1378 waitpid (pid, &stat, 0);
1379 old_pid = pid;
1380
1381 if (WEXITSTATUS (stat) == 0) {
1382 pid = fork ();
1383
1384 if (pid == -1) {
1385 fprintf (stderr, "Can't fork\n");
1386 return 2;
1387 }
1388
1389 if (pid == 0) {
1390 err = test8 (getpid (), old_pid, 2);
1391 sam_finalize ();
1392 return (err);
1393 }
1394
1395 waitpid (pid, &stat, 0);
1396 old_pid = pid;
1397
1398 if (WEXITSTATUS (stat) == 0) {
1399 pid = fork ();
1400
1401 if (pid == -1) {
1402 fprintf (stderr, "Can't fork\n");
1403 return 2;
1404 }
1405
1406 if (pid == 0) {
1407 err = test8 (old_pid, 0, 3);
1408 sam_finalize ();
1409 return (err);
1410 }
1411
1412 waitpid (pid, &stat, 0);
1413 }
1414 }
1415
120531cd 1416 fprintf (stderr, "test8 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : (WEXITSTATUS (stat) == 1 ? "skipped" : "failed")));
1a32fc4a
JF		 1417 if (WEXITSTATUS (stat) == 1)
1418 no_skipped++;
1419 if (WEXITSTATUS (stat) > 1)
1420 all_passed = 0;
1421
1422 pid = fork ();
1423
1424 if (pid == -1) {
1425 fprintf (stderr, "Can't fork\n");
1426 return 2;
1427 }
1428
1429 if (pid == 0) {
1430 err = test9 (getpid (), 0, 1);
1431 sam_finalize ();
1432 return (err);
1433 }
1434
1435 waitpid (pid, &stat, 0);
1436 old_pid = pid;
1437
1438 if (WEXITSTATUS (stat) == 0) {
1439 pid = fork ();
1440
1441 if (pid == -1) {
1442 fprintf (stderr, "Can't fork\n");
1443 return 2;
1444 }
1445
1446 if (pid == 0) {
1447 err = test9 (old_pid, 0, 2);
1448 sam_finalize ();
1449 return (err);
1450 }
1451
1452 waitpid (pid, &stat, 0);
1453 }
1454 fprintf (stderr, "test9 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : (WEXITSTATUS (stat) == 1 ? "skipped" : "failed")));
d5884cd7
JF		 1455 if (WEXITSTATUS (stat) == 1)
1456 no_skipped++;
1457
1458 if (WEXITSTATUS (stat) > 1)
1459 all_passed = 0;
1460
0ed4d530 1461 if (all_passed)
d5884cd7 1462 fprintf (stderr, "All tests passed (%d skipped)\n", no_skipped);
0ed4d530
JF		 1463
1464 return (all_passed ? 0 : 1);
1465}
corosync mirror