Page MenuHomeClusterLabs Projects
Files F7609755

No OneTemporary
Actions

View Options

diff --git a/test/testsam.c b/test/testsam.c
index 0c4c4e05..78b45b32 100644
--- a/test/testsam.c
+++ b/test/testsam.c
@@ -1,1499 +1,1394 @@
/*
* Copyright (c) 2009-2025 Red Hat, Inc.
*
* All rights reserved.
*
* Author: Jan Friesse (jfriesse@redhat.com)
*
* This software licensed under BSD license, the text of which follows:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the Red Hat, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Provides test of SAM API
*/
#include <config.h>
#include <sys/types.h>
#include <sys/resource.h>
#include <limits.h>
#include <pthread.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <corosync/corotypes.h>
#include <corosync/sam.h>
#include <signal.h>
#include <string.h>
#include <sys/wait.h>
#include <corosync/cmap.h>
-extern const char *__progname;
-static int test2_sig_delivered = 0;
-static int test5_hc_cb_count = 0;
-static int test6_sig_delivered = 0;
+static int test_sig_delivered = 0;
+static int test_hc_cb_count = 0;
/*
* First test will just register SAM, with policy restart. First instance will
* sleep one second, send hc and sleep another 3 seconds. This should force restart.
* Second instance will sleep one second, send hc, stop hc and sleep 3 seconds.
* Then start hc again and sleep 3 seconds. This should force restart again.
* Last instance just calls initialize again. This should end with error.
* Then call start, followed by stop and start again. Finally, we will call finalize
* twice. One should succeed, second should fail. After this, we will call every function
* (none should succeed).
*/
-static int test1 (void)
+static int test_basics (void)
{
cs_error_t error;
unsigned int instance_id;
int i;
printf ("%s: initialize\n", __FUNCTION__);
error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
if (error != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
return 1;
}
printf ("%s: register\n", __FUNCTION__);
error = sam_register (&instance_id);
if (error != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", error);
return 1;
}
if (instance_id == 1 || instance_id == 2) {
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
error = sam_start ();
if (error != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", error);
return 1;
}
for (i = 0; i < 10; i++) {
printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
sleep (1);
printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
error = sam_hc_send ();
if (error != CS_OK) {
fprintf (stderr, "Can't send hc. Error %d\n", error);
return 1;
}
}
if (instance_id == 2) {
printf ("%s iid %d: stop\n", __FUNCTION__, instance_id);
error = sam_stop ();
if (error != CS_OK) {
- fprintf (stderr, "Can't send hc. Error %d\n", error);
+ fprintf (stderr, "Can't stop hc. Error %d\n", error);
return 1;
}
}
printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
sleep (3);
+ if (instance_id == 1) {
+ printf ("%s iid %d: Failed. Wasn't killed.\n", __FUNCTION__, instance_id);
+
+ return 1;
+ }
+
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
error = sam_start ();
if (error != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", error);
return 1;
}
printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
sleep (3);
return 0;
}
if (instance_id == 3) {
error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
if (error == CS_OK) {
fprintf (stderr, "Can initialize SAM API after initialization");
return 1;
}
error = sam_start ();
if (error != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", error);
return 1;
}
error = sam_stop ();
if (error != CS_OK) {
fprintf (stderr, "Can't stop hc. Error %d\n", error);
return 1;
}
error = sam_finalize ();
if (error != CS_OK) {
fprintf (stderr, "Can't finalize sam. Error %d\n", error);
return 1;
}
error = sam_finalize ();
if (error == CS_OK) {
fprintf (stderr, "Can finalize sam after finalization!\n");
return 1;
}
if (sam_initialize (2, SAM_RECOVERY_POLICY_RESTART) == CS_OK ||
sam_start () == CS_OK || sam_stop () == CS_OK ||
sam_register (NULL) == CS_OK || sam_hc_send () == CS_OK ||
sam_hc_callback_register (NULL) == CS_OK) {
fprintf (stderr, "Can call one of function after finalization!\n");
return 1;
}
return 0;
}
return 1;
}
-static void test2_signal (int sig) {
+static void test_signal_handler (int sig) {
printf ("%s\n", __FUNCTION__);
- test2_sig_delivered = 1;
+ test_sig_delivered = 1;
}
/*
* This tests recovery policy quit and callback.
*/
-static int test2 (void) {
+static int test_signal (void) {
cs_error_t error;
unsigned int instance_id;
+ test_sig_delivered = 0;
+
printf ("%s: initialize\n", __FUNCTION__);
error = sam_initialize (2000, SAM_RECOVERY_POLICY_QUIT);
if (error != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
return 1;
}
printf ("%s: register\n", __FUNCTION__);
error = sam_register (&instance_id);
if (error != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", error);
return 1;
}
if (instance_id == 1) {
- signal (SIGTERM, test2_signal);
+ signal (SIGTERM, test_signal_handler);
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
error = sam_start ();
if (error != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", error);
return 1;
}
printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
sleep (1);
printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
error = sam_hc_send ();
if (error != CS_OK) {
fprintf (stderr, "Can't send hc. Error %d\n", error);
return 1;
}
printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
- while (!test2_sig_delivered) {
+ while (!test_sig_delivered) {
sleep (1);
}
printf ("%s iid %d: wait for real kill\n", __FUNCTION__, instance_id);
sleep (3);
}
return 1;
}
/*
* Smoke test. This has no time limit, just restart process
* when it dies.
*/
-static int test3 (void) {
+static int test_smoke (void) {
cs_error_t error;
unsigned int instance_id;
struct rlimit lim;
lim.rlim_cur = lim.rlim_max = 0;
/*
* Try to turn off core creation
*/
setrlimit(RLIMIT_CORE, &lim);
printf ("%s: initialize\n", __FUNCTION__);
error = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART);
if (error != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
return 1;
}
printf ("%s: register\n", __FUNCTION__);
error = sam_register (&instance_id);
if (error != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", error);
return 1;
}
if (instance_id < 100) {
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
error = sam_start ();
if (error != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", error);
return 1;
}
printf ("%s iid %d: Sending signal\n", __FUNCTION__, instance_id);
kill(getpid(), SIGSEGV);
return 1;
}
return 0;
}
/*
* Test sam_data_store, sam_data_restore and sam_data_getsize
*/
-static int test4 (void)
+static int test_data_store_restore (void)
{
size_t size;
cs_error_t err;
int i;
unsigned int instance_id;
char saved_data[128];
char saved_data2[128];
printf ("%s: sam_data_getsize 1\n", __FUNCTION__);
err = sam_data_getsize (&size);
if (err != CS_ERR_BAD_HANDLE) {
fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
return 1;
}
printf ("%s: sam_data_getsize 2\n", __FUNCTION__);
err = sam_data_getsize (NULL);
if (err != CS_ERR_INVALID_PARAM) {
fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
return 1;
}
printf ("%s: sam_data_store 1\n", __FUNCTION__);
err = sam_data_store (NULL, 0);
if (err != CS_ERR_BAD_HANDLE) {
fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
return 1;
}
printf ("%s: sam_data_restore 1\n", __FUNCTION__);
err = sam_data_restore (saved_data, sizeof (saved_data));
if (err != CS_ERR_BAD_HANDLE) {
fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
return 1;
}
printf ("%s: sam_initialize\n", __FUNCTION__);
err = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART);
if (err != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
return 1;
}
printf ("%s: sam_data_getsize 3\n", __FUNCTION__);
err = sam_data_getsize (&size);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_ERR_BAD_HANDLE. Error returned %d\n", err);
return 1;
}
if (size != 0) {
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
return 1;
}
printf ("%s: sam_data_restore 2\n", __FUNCTION__);
err = sam_data_restore (NULL, sizeof (saved_data));
if (err != CS_ERR_INVALID_PARAM) {
fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
return 1;
}
/*
* Store some real data
*/
for (i = 0; i < sizeof (saved_data); i++) {
saved_data[i] = (char)(i + 5);
}
printf ("%s: sam_data_store 2\n", __FUNCTION__);
err = sam_data_store (saved_data, sizeof (saved_data));
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
printf ("%s: sam_data_getsize 4\n", __FUNCTION__);
err = sam_data_getsize (&size);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
if (size != sizeof (saved_data)) {
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
return 1;
}
printf ("%s: sam_data_restore 3\n", __FUNCTION__);
err = sam_data_restore (saved_data2, sizeof (saved_data2) - 1);
if (err != CS_ERR_INVALID_PARAM) {
fprintf (stderr, "Test should return CS_ERR_INVALID_PARAM. Error returned %d\n", err);
return 1;
}
printf ("%s: sam_data_restore 4\n", __FUNCTION__);
err = sam_data_restore (saved_data2, sizeof (saved_data2));
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
if (memcmp (saved_data, saved_data2, sizeof (saved_data2)) != 0) {
fprintf (stderr, "Retored data are not same\n");
return 1;
}
memset (saved_data2, 0, sizeof (saved_data2));
printf ("%s: sam_data_store 3\n", __FUNCTION__);
err = sam_data_store (NULL, 1);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
printf ("%s: sam_data_getsize 5\n", __FUNCTION__);
err = sam_data_getsize (&size);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
if (size != 0) {
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
return 1;
}
printf ("%s: sam_data_store 4\n", __FUNCTION__);
err = sam_data_store (saved_data, sizeof (saved_data));
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
printf ("%s: register\n", __FUNCTION__);
err = sam_register (&instance_id);
if (err != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", err);
return 1;
}
if (instance_id == 1) {
printf ("%s iid %d: sam_start\n", __FUNCTION__, instance_id);
err = sam_start ();
if (err != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", err);
return 1;
}
printf ("%s iid %d: sam_data_getsize 6\n", __FUNCTION__, instance_id);
err = sam_data_getsize (&size);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
if (size != sizeof (saved_data2)) {
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
return 1;
}
printf ("%s iid %d: sam_data_restore 5\n", __FUNCTION__, instance_id);
err = sam_data_restore (saved_data2, sizeof (saved_data2));
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
if (memcmp (saved_data, saved_data2, sizeof (saved_data2)) != 0) {
fprintf (stderr, "Retored data are not same\n");
return 1;
}
for (i = 0; i < sizeof (saved_data); i++) {
saved_data[i] = (char)(i - 5);
}
printf ("%s iid %d: sam_data_store 5\n", __FUNCTION__, instance_id);
err = sam_data_store (saved_data, sizeof (saved_data) - 7);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
exit (1);
}
if (instance_id == 2) {
printf ("%s iid %d: sam_start\n", __FUNCTION__, instance_id);
err = sam_start ();
if (err != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", err);
return 1;
}
printf ("%s iid %d: sam_data_getsize 7\n", __FUNCTION__, instance_id);
err = sam_data_getsize (&size);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
if (size != sizeof (saved_data2) - 7) {
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
return 1;
}
printf ("%s iid %d: sam_data_restore 6\n", __FUNCTION__, instance_id);
err = sam_data_restore (saved_data2, sizeof (saved_data2));
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
for (i = 0; i < sizeof (saved_data); i++) {
saved_data[i] = (char)(i - 5);
}
if (memcmp (saved_data, saved_data2, sizeof (saved_data2) - 7) != 0) {
fprintf (stderr, "Retored data are not same\n");
return 1;
}
printf ("%s iid %d: sam_data_store 6\n", __FUNCTION__, instance_id);
err = sam_data_store (NULL, 0);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
exit (1);
}
if (instance_id == 3) {
printf ("%s iid %d: sam_data_getsize 8\n", __FUNCTION__, instance_id);
err = sam_data_getsize (&size);
if (err != CS_OK) {
fprintf (stderr, "Test should return CS_OK. Error returned %d\n", err);
return 1;
}
if (size != 0) {
fprintf (stderr, "Test should return size of 0. Returned %zx\n", size);
return 1;
}
}
return (0);
}
-static int test5_hc_cb (void)
+static int test_hc_cb (void)
{
cs_error_t res;
- printf ("%s %d\n", __FUNCTION__, ++test5_hc_cb_count);
+ printf ("%s %d\n", __FUNCTION__, ++test_hc_cb_count);
- res = sam_data_store (&test5_hc_cb_count, sizeof (test5_hc_cb_count));
+ res = sam_data_store (&test_hc_cb_count, sizeof (test_hc_cb_count));
if (res != CS_OK)
return 1;
- if (test5_hc_cb_count > 10)
+ if (test_hc_cb_count > 10)
return 1;
return 0;
}
/*
* Test event driven healtchecking.
*/
-static int test5 (void)
+static int test_hc (void)
{
cs_error_t error;
unsigned int instance_id;
int hc_cb_count;
printf ("%s: initialize\n", __FUNCTION__);
error = sam_initialize (100, SAM_RECOVERY_POLICY_RESTART);
if (error != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
return 1;
}
printf ("%s: register\n", __FUNCTION__);
error = sam_register (&instance_id);
if (error != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", error);
return 1;
}
if (instance_id == 1) {
printf ("%s iid %d: hc callback register\n", __FUNCTION__, instance_id);
- error = sam_hc_callback_register (test5_hc_cb);
+ error = sam_hc_callback_register (test_hc_cb);
if (error != CS_OK) {
fprintf (stderr, "Can't register hc cb. Error %d\n", error);
return 1;
}
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
error = sam_start ();
if (error != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", error);
return 1;
}
sleep (2);
printf ("%s iid %d: Failed. Wasn't killed.\n", __FUNCTION__, instance_id);
return 1;
}
if (instance_id == 2) {
error = sam_data_restore (&hc_cb_count, sizeof (hc_cb_count));
if (error != CS_OK) {
fprintf (stderr, "sam_data_restore should return CS_OK. Error returned %d\n", error);
return 1;
}
if (hc_cb_count != 11) {
fprintf (stderr, "%s iid %d: Premature killed. hc_cb_count should be 11 and it is %d\n",
__FUNCTION__, instance_id - 1, hc_cb_count);
return 1;
}
return 0;
}
return 1;
}
-static void test6_signal (int sig) {
+static void test_warn_signal_handler (int sig) {
cs_error_t error;
printf ("%s\n", __FUNCTION__);
- test6_sig_delivered++;
+ test_sig_delivered++;
- if ((error = sam_data_store (&test6_sig_delivered, sizeof (test6_sig_delivered))) != CS_OK) {
+ if ((error = sam_data_store (&test_sig_delivered, sizeof (test_sig_delivered))) != CS_OK) {
fprintf (stderr, "Can't store data! Error : %d\n", error);
}
}
/*
* Test warn signal set.
*/
-static int test6 (void) {
+static int test_warn_signal (void) {
cs_error_t error;
unsigned int instance_id;
- int test6_sig_del;
+ int tmp_sig_delivered;
+
+ test_sig_delivered = 0;
printf ("%s: initialize\n", __FUNCTION__);
error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART);
if (error != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", error);
return 1;
}
printf ("%s: register\n", __FUNCTION__);
error = sam_register (&instance_id);
if (error != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", error);
return 1;
}
if (instance_id == 1) {
error = sam_warn_signal_set (SIGUSR1);
if (error != CS_OK) {
fprintf (stderr, "Can't set warn signal. Error %d\n", error);
return 1;
}
- signal (SIGUSR1, test6_signal);
+ signal (SIGUSR1, test_warn_signal_handler);
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
error = sam_start ();
if (error != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", error);
return 1;
}
printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
sleep (1);
printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
error = sam_hc_send ();
if (error != CS_OK) {
fprintf (stderr, "Can't send hc. Error %d\n", error);
return 1;
}
printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
- while (!test6_sig_delivered) {
+ while (!test_sig_delivered) {
sleep (1);
}
printf ("%s iid %d: wait for real kill\n", __FUNCTION__, instance_id);
sleep (3);
printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
return (1);
}
if (instance_id == 2) {
- error = sam_data_restore (&test6_sig_del, sizeof (test6_sig_del));
+ error = sam_data_restore (&tmp_sig_delivered, sizeof (tmp_sig_delivered));
if (error != CS_OK) {
fprintf (stderr, "Can't restore data. Error %d\n", error);
return 1;
}
- if (test6_sig_del != 1) {
+ if (tmp_sig_delivered != 1) {
fprintf (stderr, "Previous test failed. Signal was not delivered\n");
return 1;
}
error = sam_warn_signal_set (SIGKILL);
if (error != CS_OK) {
fprintf (stderr, "Can't set warn signal. Error %d\n", error);
return 1;
}
- signal (SIGUSR1, test6_signal);
+ signal (SIGUSR1, test_warn_signal_handler);
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
error = sam_start ();
if (error != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", error);
return 1;
}
printf ("%s iid %d: sleep 1\n", __FUNCTION__, instance_id);
sleep (1);
printf ("%s iid %d: hc send\n", __FUNCTION__, instance_id);
error = sam_hc_send ();
if (error != CS_OK) {
fprintf (stderr, "Can't send hc. Error %d\n", error);
return 1;
}
printf ("%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id);
- while (!test6_sig_delivered) {
+ while (!test_sig_delivered) {
sleep (1);
}
printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
return (1);
}
if (instance_id == 3) {
- error = sam_data_restore (&test6_sig_del, sizeof (test6_sig_del));
+ error = sam_data_restore (&tmp_sig_delivered, sizeof (tmp_sig_delivered));
if (error != CS_OK) {
fprintf (stderr, "Can't restore data. Error %d\n", error);
return 1;
}
- if (test6_sig_del != 1) {
+ if (tmp_sig_delivered != 1) {
fprintf (stderr, "Previous test failed. Signal WAS delivered\n");
return 1;
}
return (0);
}
return 1;
}
-static void *test7_thread (void *arg)
+static void *test_quorum_thread (void *arg)
{
/* Wait 5s */
sleep (5);
exit (0);
}
/*
* Test quorum
*/
-static int test7 (void) {
+static int test_quorum (void) {
cmap_handle_t cmap_handle;
cs_error_t err;
unsigned int instance_id;
pthread_t kill_thread;
char *str;
uint32_t expected_votes;
err = cmap_initialize (&cmap_handle);
if (err != CS_OK) {
printf ("Could not initialize Cluster Map API instance error %d. Test skipped\n", err);
return (1);
}
if (cmap_get_string(cmap_handle, "quorum.provider", &str) != CS_OK) {
printf ("Could not get \"provider\" key: %d. Test skipped\n", err);
return (1);
}
if (strcmp(str, "corosync_votequorum") != 0) {
printf ("Provider is not corosync_votequorum. Test skipped\n");
free(str);
return (1);
}
free(str);
if (cmap_get_uint32(cmap_handle, "quorum.expected_votes", &expected_votes) != CS_OK) {
printf ("Could not get \"expected_votes\" key: %d. Test skipped\n", err);
return (1);
}
if (expected_votes != 1) {
printf ("Expected_votes is not 1. Test skipped\n");
return (1);
}
/*
* Set to not quorate
*/
err = cmap_set_uint32(cmap_handle, "quorum.expected_votes", 2);
if (err != CS_OK) {
printf ("Can't set map key. Error %d\n", err);
return (2);
}
printf ("%s: initialize\n", __FUNCTION__);
err = sam_initialize (2000, SAM_RECOVERY_POLICY_QUORUM_RESTART);
if (err != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
return 2;
}
printf ("%s: register\n", __FUNCTION__);
err = sam_register (&instance_id);
if (err != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", err);
return 2;
}
if (instance_id == 1) {
/*
* Sam start should block forever, but 10s for us should be enough
*/
- pthread_create (&kill_thread, NULL, test7_thread, NULL);
+ pthread_create (&kill_thread, NULL, test_quorum_thread, NULL);
printf ("%s iid %d: start - should block forever (waiting 5s)\n", __FUNCTION__, instance_id);
err = sam_start ();
if (err != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", err);
return 2;
}
printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
return (2);
}
if (instance_id == 2) {
/*
* Set to quorate
*/
err = cmap_set_uint32(cmap_handle, "quorum.expected_votes", 1);
if (err != CS_OK) {
printf ("Can't set map key. Error %d\n", err);
return (2);
}
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
err = sam_start ();
if (err != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", err);
return 2;
}
/*
* Set corosync unquorate
*/
err = cmap_set_uint32(cmap_handle, "quorum.expected_votes", 2);
if (err != CS_OK) {
printf ("Can't set map key. Error %d\n", err);
return (2);
}
printf ("%s iid %d: sleep 3\n", __FUNCTION__, instance_id);
sleep (3);
printf ("%s iid %d: wasn't killed\n", __FUNCTION__, instance_id);
return (2);
}
if (instance_id == 3) {
return (0);
}
return (2);
}
/*
* Test cmap integration + quit policy
*/
-static int test8 (pid_t pid, pid_t old_pid, int test_n) {
+static int test_cmap_quit (pid_t pid, pid_t old_pid, int test_n)
+{
cmap_handle_t cmap_handle;
cs_error_t err;
uint64_t tstamp1, tstamp2;
int32_t msec_diff;
unsigned int instance_id;
char key_name[CMAP_KEYNAME_MAXLEN];
char *str;
err = cmap_initialize (&cmap_handle);
if (err != CS_OK) {
printf ("Could not initialize Cluster Map API instance error %d. Test skipped\n", err);
return (1);
}
printf ("%s test %d\n", __FUNCTION__, test_n);
if (test_n == 2) {
/*
* Object should not exist
*/
printf ("%s Testing if object exists (it shouldn't)\n", __FUNCTION__);
snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err == CS_OK) {
printf ("Could find key \"%s\": %d.\n", key_name, err);
free(str);
return (2);
}
}
if (test_n == 1 || test_n == 2) {
printf ("%s: initialize\n", __FUNCTION__);
err = sam_initialize (2000, SAM_RECOVERY_POLICY_QUIT | SAM_RECOVERY_POLICY_CMAP);
if (err != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
return 2;
}
printf ("%s: register\n", __FUNCTION__);
err = sam_register (&instance_id);
if (err != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", err);
return 2;
}
snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.recovery", pid);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"recovery\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "quit") != 0) {
printf ("Recovery key \"%s\" is not \"quit\".\n", key_name);
free(str);
return (2);
}
free(str);
snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "stopped") != 0) {
printf ("State key is not \"stopped\".\n");
free(str);
return (2);
}
free(str);
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
err = sam_start ();
if (err != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", err);
return 2;
}
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "running") != 0) {
printf ("State key is not \"running\".\n");
free(str);
return (2);
}
free(str);
printf ("%s iid %d: stop\n", __FUNCTION__, instance_id);
err = sam_stop ();
if (err != CS_OK) {
fprintf (stderr, "Can't stop hc. Error %d\n", err);
return 2;
}
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "stopped") != 0) {
printf ("State key is not \"stopped\".\n");
free(str);
return (2);
}
free(str);
printf ("%s iid %d: sleeping 5\n", __FUNCTION__, instance_id);
sleep (5);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "stopped") != 0) {
printf ("State key is not \"stopped\".\n");
free(str);
return (2);
}
free(str);
printf ("%s iid %d: start 2\n", __FUNCTION__, instance_id);
err = sam_start ();
if (err != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", err);
return 2;
}
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "running") != 0) {
printf ("State key is not \"running\".\n");
free(str);
return (2);
}
free(str);
if (test_n == 2) {
printf ("%s iid %d: sleeping 5. Should be killed\n", __FUNCTION__, instance_id);
sleep (5);
return (2);
} else {
printf ("%s iid %d: Test HC\n", __FUNCTION__, instance_id);
err = sam_hc_send ();
if (err != CS_OK) {
fprintf (stderr, "Can't send hc. Error %d\n", err);
return 2;
}
snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.last_updated", pid);
err = cmap_get_uint64(cmap_handle, key_name, &tstamp1);
if (err != CS_OK) {
printf ("Could not get \"last_updated\" key: %d.\n", err);
return (2);
}
printf ("%s iid %d: Sleep 1\n", __FUNCTION__, instance_id);
sleep (1);
err = sam_hc_send ();
if (err != CS_OK) {
fprintf (stderr, "Can't send hc. Error %d\n", err);
return 2;
}
sleep (1);
err = cmap_get_uint64(cmap_handle, key_name, &tstamp2);
if (err != CS_OK) {
printf ("Could not get \"last_updated\" key: %d.\n", err);
return (2);
}
msec_diff = (tstamp2 - tstamp1)/CS_TIME_NS_IN_MSEC;
if (msec_diff < 500 || msec_diff > 2000) {
printf ("Difference %d is not within <500, 2000> interval.\n", msec_diff);
return (2);
}
printf ("%s iid %d: stop 2\n", __FUNCTION__, instance_id);
err = sam_stop ();
if (err != CS_OK) {
fprintf (stderr, "Can't stop hc. Error %d\n", err);
return 2;
}
snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "stopped") != 0) {
printf ("State key is not \"stopped\".\n");
free(str);
return (2);
}
free(str);
printf ("%s iid %d: exiting\n", __FUNCTION__, instance_id);
return (0);
}
}
if (test_n == 3) {
printf ("%s Testing if status is failed\n", __FUNCTION__);
/*
* Previous should be FAILED
*/
- snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
+ snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", old_pid);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "failed") != 0) {
printf ("State key is not \"failed\".\n");
free(str);
return (2);
}
free(str);
return (0);
}
return (2);
}
/*
* Test cmap integration + restart policy
*/
-static int test9 (pid_t pid, pid_t old_pid, int test_n) {
+static int test_cmap_restart (pid_t pid, pid_t old_pid, int test_n) {
cs_error_t err;
cmap_handle_t cmap_handle;
unsigned int instance_id;
char *str;
char key_name[CMAP_KEYNAME_MAXLEN];
err = cmap_initialize (&cmap_handle);
if (err != CS_OK) {
printf ("Could not initialize Cluster Map API instance error %d. Test skipped\n", err);
return (1);
}
printf ("%s test %d\n", __FUNCTION__, test_n);
if (test_n == 1) {
printf ("%s: initialize\n", __FUNCTION__);
err = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART | SAM_RECOVERY_POLICY_CMAP);
if (err != CS_OK) {
fprintf (stderr, "Can't initialize SAM API. Error %d\n", err);
return 2;
}
printf ("%s: register\n", __FUNCTION__);
err = sam_register (&instance_id);
if (err != CS_OK) {
fprintf (stderr, "Can't register. Error %d\n", err);
return 2;
}
printf ("%s: iid %d\n", __FUNCTION__, instance_id);
if (instance_id < 3) {
snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.recovery", pid);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"recovery\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "restart") != 0) {
printf ("Recovery key \"%s\" is not \"restart\".\n", str);
free(str);
return (2);
}
free(str);
snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "stopped") != 0) {
printf ("State key is not \"stopped\".\n");
free(str);
return (2);
}
free(str);
printf ("%s iid %d: start\n", __FUNCTION__, instance_id);
err = sam_start ();
if (err != CS_OK) {
fprintf (stderr, "Can't start hc. Error %d\n", err);
return 2;
}
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "running") != 0) {
printf ("State key is not \"running\".\n");
free(str);
return (2);
}
free(str);
printf ("%s iid %d: waiting for kill\n", __FUNCTION__, instance_id);
sleep (10);
return (2);
}
if (instance_id == 3) {
printf ("%s iid %d: mark failed\n", __FUNCTION__, instance_id);
err = sam_mark_failed ();
if (err != CS_OK) {
fprintf (stderr, "Can't mark failed. Error %d\n", err);
return 2;
}
sleep (10);
return (2);
}
return (2);
}
if (test_n == 2) {
printf ("%s Testing if status is failed\n", __FUNCTION__);
/*
* Previous should be FAILED
*/
- snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", pid);
+ snprintf(key_name, CMAP_KEYNAME_MAXLEN, "resources.process.%d.state", old_pid);
err = cmap_get_string(cmap_handle, key_name, &str);
if (err != CS_OK) {
printf ("Could not get \"state\" key: %d.\n", err);
return (2);
}
if (strcmp(str, "failed") != 0) {
printf ("State key is not \"failed\".\n");
free(str);
return (2);
}
free(str);
return (0);
}
return (2);
}
-int main(int argc, char *argv[])
+static int run_test(const char *test_name, int (test_func)(void), int skippable, int *all_passed, int *no_skipped)
{
- pid_t pid, old_pid;
+ pid_t pid;
int err;
int stat;
- int all_passed = 1;
- int no_skipped = 0;
-
- setlinebuf(stdout);
+ const char *res_str;
+ fprintf (stderr, "Running %s test\n", test_name);
pid = fork ();
if (pid == -1) {
fprintf (stderr, "Can't fork\n");
- return 1;
- }
-
- if (pid == 0) {
- err = test1 ();
- sam_finalize ();
- return err;
- }
-
- waitpid (pid, &stat, 0);
- fprintf (stderr, "test1 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
- if (WEXITSTATUS (stat) != 0)
- all_passed = 0;
-
- pid = fork ();
-
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 1;
+ exit(1);
}
if (pid == 0) {
- err = test2 ();
-
- sam_finalize ();
- return (err);
- }
-
- waitpid (pid, &stat, 0);
-
- fprintf (stderr, "test2 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
- if (WEXITSTATUS (stat) != 0)
- all_passed = 0;
-
- pid = fork ();
-
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 1;
- }
-
- if (pid == 0) {
- err = test3 ();
- sam_finalize ();
- return (err);
- }
-
- waitpid (pid, &stat, 0);
-
- fprintf (stderr, "test3 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
- if (WEXITSTATUS (stat) != 0)
- all_passed = 0;
-
- pid = fork ();
-
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 1;
- }
+ /*
+ * Child runs tests and sets exit code to result of test
+ */
+ err = test_func ();
- if (pid == 0) {
- err = test4 ();
+ /*
+ * After sam_register this is child of child
+ */
sam_finalize ();
- return (err);
- }
-
- waitpid (pid, &stat, 0);
-
- fprintf (stderr, "test4 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
- if (WEXITSTATUS (stat) != 0)
- all_passed = 0;
- pid = fork ();
-
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 1;
- }
-
- if (pid == 0) {
- err = test5 ();
-
- sam_finalize ();
- return (err);
+ exit (err);
}
+ /*
+ * Parent waits for child to run the test and return exit code
+ */
waitpid (pid, &stat, 0);
- fprintf (stderr, "test5 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
- if (WEXITSTATUS (stat) != 0)
- all_passed = 0;
- pid = fork ();
+ err = WEXITSTATUS (stat);
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 1;
- }
+ if (!skippable) {
+ res_str = (err == 0 ? "passed" : "failed");
- if (pid == 0) {
- err = test6 ();
- sam_finalize ();
- return (err);
- }
-
- waitpid (pid, &stat, 0);
- fprintf (stderr, "test6 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : "failed"));
- if (WEXITSTATUS (stat) != 0)
- all_passed = 0;
-
- pid = fork ();
-
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 2;
- }
+ if (err != 0) {
+ (*all_passed) = 0;
+ }
+ } else {
+ res_str = (err == 0 ? "passed" : (err == 1 ? "skipped" : "failed"));
- if (pid == 0) {
- err = test7 ();
- sam_finalize ();
- return (err);
+ if (err == 1) {
+ (*no_skipped)++;
+ } else if (err > 1) {
+ (*all_passed) = 0;
+ }
}
- waitpid (pid, &stat, 0);
- fprintf (stderr, "test7 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : (WEXITSTATUS (stat) == 1 ? "skipped" : "failed")));
- if (WEXITSTATUS (stat) == 1)
- no_skipped++;
- if (WEXITSTATUS (stat) > 1)
- all_passed = 0;
+ fprintf (stderr, "%s test %s\n", test_name, res_str);
- pid = fork ();
+ return (err);
+}
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 2;
- }
+static int run_cmap_test(const char *test_name,
+ int (test_func)(pid_t pid, pid_t old_pid, int test_n),
+ int no_tests, int *all_passed, int *no_skipped)
+{
+ pid_t pid, old_pid;
+ int err;
+ int stat;
+ const char *res_str;
+ int n;
- if (pid == 0) {
- err = test8 (getpid (), 0, 1);
- sam_finalize ();
- return (err);
- }
+ old_pid = 0;
- waitpid (pid, &stat, 0);
- old_pid = pid;
+ fprintf (stderr, "Running %s test\n", test_name);
- if (WEXITSTATUS (stat) == 0) {
+ for (n = 1; n <= no_tests; n++) {
pid = fork ();
if (pid == -1) {
fprintf (stderr, "Can't fork\n");
- return 2;
+
+ exit (2);
}
if (pid == 0) {
- err = test8 (getpid (), old_pid, 2);
+ err = test_func (getpid (), old_pid, n);
sam_finalize ();
- return (err);
+ exit (err);
}
waitpid (pid, &stat, 0);
old_pid = pid;
- if (WEXITSTATUS (stat) == 0) {
- pid = fork ();
-
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 2;
- }
-
- if (pid == 0) {
- err = test8 (old_pid, 0, 3);
- sam_finalize ();
- return (err);
- }
-
- waitpid (pid, &stat, 0);
+ err = WEXITSTATUS (stat);
+ if (err != 0) {
+ break;
}
}
- fprintf (stderr, "test8 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : (WEXITSTATUS (stat) == 1 ? "skipped" : "failed")));
- if (WEXITSTATUS (stat) == 1)
- no_skipped++;
- if (WEXITSTATUS (stat) > 1)
- all_passed = 0;
+ res_str = (err == 0 ? "passed" : (err == 1 ? "skipped" : "failed"));
- pid = fork ();
-
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 2;
+ if (err == 1) {
+ (*no_skipped)++;
+ } else if (err > 1) {
+ (*all_passed) = 0;
}
- if (pid == 0) {
- err = test9 (getpid (), 0, 1);
- sam_finalize ();
- return (err);
- }
+ fprintf (stderr, "%s test %s\n", test_name, res_str);
- waitpid (pid, &stat, 0);
- old_pid = pid;
-
- if (WEXITSTATUS (stat) == 0) {
- pid = fork ();
-
- if (pid == -1) {
- fprintf (stderr, "Can't fork\n");
- return 2;
- }
+ return (err);
+}
- if (pid == 0) {
- err = test9 (old_pid, 0, 2);
- sam_finalize ();
- return (err);
- }
+int main(int argc, char *argv[])
+{
+ int all_passed = 1;
+ int no_skipped = 0;
- waitpid (pid, &stat, 0);
- }
- fprintf (stderr, "test9 %s\n", (WEXITSTATUS (stat) == 0 ? "passed" : (WEXITSTATUS (stat) == 1 ? "skipped" : "failed")));
- if (WEXITSTATUS (stat) == 1)
- no_skipped++;
+ setlinebuf(stdout);
- if (WEXITSTATUS (stat) > 1)
- all_passed = 0;
+ run_test("basics", test_basics, 0, &all_passed, &no_skipped);
+ run_test("signal", test_signal, 0, &all_passed, &no_skipped);
+ run_test("smoke", test_smoke, 0, &all_passed, &no_skipped);
+ run_test("data_store/restore", test_data_store_restore, 0, &all_passed, &no_skipped);
+ run_test("hc", test_hc, 0, &all_passed, &no_skipped);
+ run_test("warn_signal", test_warn_signal, 0, &all_passed, &no_skipped);
+ run_test("quorum", test_quorum, 1, &all_passed, &no_skipped);
+ run_cmap_test("cmap quit", test_cmap_quit, 3, &all_passed, &no_skipped);
+ run_cmap_test("cmap restart", test_cmap_restart, 2, &all_passed, &no_skipped);
if (all_passed)
fprintf (stderr, "All tests passed (%d skipped)\n", no_skipped);
return (all_passed ? 0 : 1);
}

File Metadata

Mime Type
text/x-diff
Expires
Thu, Oct 16, 12:16 AM (1 d, 6 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2530766
Default Alt Text
(41 KB)

Event Timeline