From efccdcf140565a540a6a27a049cd2cd39e8a68d0 Mon Sep 17 00:00:00 2001 From: Angus Salkeld Date: Tue, 30 Mar 2010 21:38:38 +0000 Subject: [PATCH] Add missing cts files. git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@2751 fd59a12c-fef9-0310-b244-a6a79926bd2f --- cts/agents/sam_test_agent.c | 417 +++++++++++++++++++++++++++++ cts/agents/syncv2.c | 309 +++++++++++++++++++++ cts/agents/votequorum_test_agent.c | 222 +++++++++++++++ 3 files changed, 948 insertions(+) create mode 100644 cts/agents/sam_test_agent.c create mode 100644 cts/agents/syncv2.c create mode 100644 cts/agents/votequorum_test_agent.c diff --git a/cts/agents/sam_test_agent.c b/cts/agents/sam_test_agent.c new file mode 100644 index 00000000..43c05dfd --- /dev/null +++ b/cts/agents/sam_test_agent.c @@ -0,0 +1,417 @@ +/* + * Copyright (c) 2009 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include "common_test_agent.h" + + +static int test2_sig_delivered = 0; +static int test4_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) +{ + cs_error_t error; + unsigned int instance_id; + int i; + + syslog (LOG_INFO,"%s: initialize\n", __FUNCTION__); + error = sam_initialize (2000, SAM_RECOVERY_POLICY_RESTART); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't initialize SAM API. Error %d\n", error); + return 1; + } + syslog (LOG_INFO,"%s: register\n", __FUNCTION__); + error = sam_register (&instance_id); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't register. Error %d\n", error); + return 1; + } + + if (instance_id == 1 || instance_id == 2) { + syslog (LOG_INFO,"%s iid %d: start\n", __FUNCTION__, instance_id); + error = sam_start (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't start hc. Error %d\n", error); + return 1; + } + + for (i = 0; i < 10; i++) { + syslog (LOG_INFO,"%s iid %d: sleep 1\n", __FUNCTION__, instance_id); + sleep (1); + + syslog (LOG_INFO,"%s iid %d: hc send\n", __FUNCTION__, instance_id); + error = sam_hc_send (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't send hc. Error %d\n", error); + return 1; + } + } + + if (instance_id == 2) { + syslog (LOG_INFO,"%s iid %d: stop\n", __FUNCTION__, instance_id); + error = sam_stop (); + + if (error != CS_OK) { + syslog (LOG_ERR, "Can't send hc. Error %d\n", error); + return 1; + } + } + + syslog (LOG_INFO,"%s iid %d: sleep 3\n", __FUNCTION__, instance_id); + sleep (3); + + syslog (LOG_INFO,"%s iid %d: start\n", __FUNCTION__, instance_id); + error = sam_start (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't start hc. Error %d\n", error); + return 1; + } + + syslog (LOG_INFO,"%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) { + syslog (LOG_ERR, "Can initialize SAM API after initialization"); + return 1; + } + + error = sam_start (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't start hc. Error %d\n", error); + return 1; + } + error = sam_stop (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't stop hc. Error %d\n", error); + return 1; + } + error = sam_finalize (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't finalize sam. Error %d\n", error); + return 1; + } + error = sam_finalize (); + if (error == CS_OK) { + syslog (LOG_ERR, "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) { + + syslog (LOG_ERR, "Can call one of function after finalization!\n"); + + return 1; + } + + return 0; + } + + return 1; +} + + +static void test2_signal (int sig) { + syslog (LOG_INFO,"%s\n", __FUNCTION__); + + test2_sig_delivered = 1; +} + +/* + * This tests recovery policy quit and callback. + */ +static int test2 (void) { + cs_error_t error; + unsigned int instance_id; + + syslog (LOG_INFO,"%s: initialize\n", __FUNCTION__); + error = sam_initialize (2000, SAM_RECOVERY_POLICY_QUIT); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't initialize SAM API. Error %d\n", error); + return 1; + } + syslog (LOG_INFO,"%s: register\n", __FUNCTION__); + error = sam_register (&instance_id); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't register. Error %d\n", error); + return 1; + } + + if (instance_id == 1) { + signal (SIGTERM, test2_signal); + + syslog (LOG_INFO,"%s iid %d: start\n", __FUNCTION__, instance_id); + error = sam_start (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't start hc. Error %d\n", error); + return 1; + } + + syslog (LOG_INFO,"%s iid %d: sleep 1\n", __FUNCTION__, instance_id); + sleep (1); + + syslog (LOG_INFO,"%s iid %d: hc send\n", __FUNCTION__, instance_id); + error = sam_hc_send (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't send hc. Error %d\n", error); + return 1; + } + + + syslog (LOG_INFO,"%s iid %d: wait for delivery of signal\n", __FUNCTION__, instance_id); + while (!test2_sig_delivered) { + sleep (1); + } + + syslog (LOG_INFO,"%s iid %d: wait for real kill\n", __FUNCTION__, instance_id); + + sleep (3); + } + + return 1; + +} + +/* + * Smoke test. Better to turn off coredump ;) This has no time limit, just restart process + * when it dies. + */ +static int test3 (void) { + cs_error_t error; + unsigned int instance_id; + int tmp1, tmp2, tmp3; + + syslog (LOG_INFO,"%s: initialize\n", __FUNCTION__); + error = sam_initialize (0, SAM_RECOVERY_POLICY_RESTART); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't initialize SAM API. Error %d\n", error); + return 1; + } + syslog (LOG_INFO,"%s: register\n", __FUNCTION__); + error = sam_register (&instance_id); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't register. Error %d\n", error); + return 1; + } + + if (instance_id < 100) { + syslog (LOG_INFO,"%s iid %d: start\n", __FUNCTION__, instance_id); + error = sam_start (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't start hc. Error %d\n", error); + return 1; + } + + syslog (LOG_INFO,"%s iid %d: divide by zero\n", __FUNCTION__, instance_id); + tmp2 = rand (); + tmp3 = 0; + tmp1 = tmp2 / tmp3; + + return 1; + } + + return 0; + +} + +static int test4_hc_cb (void) +{ + syslog (LOG_INFO,"%s %d\n", __FUNCTION__, ++test4_hc_cb_count); + + if (test4_hc_cb_count > 10) + return 1; + + return 0; +} +/* + * Test event driven healtchecking. + */ +static int test4 (void) +{ + cs_error_t error; + unsigned int instance_id; + + syslog (LOG_INFO,"%s: initialize\n", __FUNCTION__); + error = sam_initialize (100, SAM_RECOVERY_POLICY_RESTART); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't initialize SAM API. Error %d\n", error); + return 1; + } + syslog (LOG_INFO,"%s: register\n", __FUNCTION__); + error = sam_register (&instance_id); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't register. Error %d\n", error); + return 1; + } + + if (instance_id == 1) { + syslog (LOG_INFO,"%s iid %d: hc callback register\n", __FUNCTION__, instance_id); + error = sam_hc_callback_register (test4_hc_cb); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't register hc cb. Error %d\n", error); + return 1; + } + + + syslog (LOG_INFO,"%s iid %d: start\n", __FUNCTION__, instance_id); + error = sam_start (); + if (error != CS_OK) { + syslog (LOG_ERR, "Can't start hc. Error %d\n", error); + return 1; + } + + sleep (2); + + syslog (LOG_INFO,"%s iid %d: Failed. Wasn't killed.\n", __FUNCTION__, instance_id); + return 1; + } + + if (instance_id == 2) { + return 0; + } + + return 1; +} + +static void do_command (int sock, char* func, char*args[], int num_args) +{ + char response[100]; + pid_t pid; + int err; + int stat; + int please_wait = 1; + + snprintf (response, 100, "%s", FAIL_STR); + + if (parse_debug) + syslog (LOG_INFO,"RPC:%s() called.", func); + + pid = fork (); + + if (pid == -1) { + syslog (LOG_ERR, "Can't fork\n"); + send (sock, response, strlen (response) + 1, 0); + return; + } + + if (pid == 0) { + if (strcmp ("test1", func) == 0) { + err = test1 (); + } else if (strcmp ("test2", func) == 0) { + err = test2 (); + } else if (strcmp ("test3", func) == 0) { + err = test3 (); + } else if (strcmp ("test4", func) == 0) { + err = test4 (); + } else { + err = -1; + please_wait = 0; + syslog (LOG_ERR,"%s RPC:%s not supported!", __func__, func); + snprintf (response, 100, "%s", NOT_SUPPORTED_STR); + } + } + + if (please_wait) { + waitpid (pid, &stat, 0); + + if (WEXITSTATUS (stat) == 0) { + snprintf (response, 100, "%s", OK_STR); + } else { + snprintf (response, 100, "%s", FAIL_STR); + } + } + send (sock, response, strlen (response) + 1, 0); +} + + +int main (int argc, char *argv[]) +{ + int ret; + + openlog (NULL, LOG_CONS|LOG_PID, LOG_DAEMON); + syslog (LOG_ERR, "sam_test_agent STARTING"); + + parse_debug = 1; + ret = test_agent_run (9036, do_command); + syslog (LOG_ERR, "sam_test_agent EXITING"); + + return ret; +} + + + + + + + + + diff --git a/cts/agents/syncv2.c b/cts/agents/syncv2.c new file mode 100644 index 00000000..e5645a4c --- /dev/null +++ b/cts/agents/syncv2.c @@ -0,0 +1,309 @@ +/* + * Copyright (c) 2010 Red Hat, Inc. + * + * All rights reserved. + * + * Author: Angus Salkeld + * + * 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 MontaVista Software, 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. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../exec/tlist.h" + +LOGSYS_DECLARE_SUBSYS ("TST2"); + +/* + * Service Interfaces required by service_message_handler struct + */ +static int tst_sv2_exec_init_fn ( + struct corosync_api_v1 *corosync_api); + +static void tst_sv2_confchg_fn ( + enum totem_configuration_type configuration_type, + const unsigned int *member_list, size_t member_list_entries, + const unsigned int *left_list, size_t left_list_entries, + const unsigned int *joined_list, size_t joined_list_entries, + const struct memb_ring_id *ring_id); + +static int tst_sv2_lib_init_fn (void *conn); +static int tst_sv2_lib_exit_fn (void *conn); +static struct corosync_api_v1 *api; + +static void tst_sv2_sync_init_v2 ( + const unsigned int *member_list, + size_t member_list_entries, + const struct memb_ring_id *ring_id); + +static int tst_sv2_sync_process (void); + +static void tst_sv2_sync_activate (void); + +static void tst_sv2_sync_abort (void); + +struct corosync_service_engine tst_sv2_service_engine = { + .name = "corosync test synv2 service", + .id = TST_SV2_SERVICE, + .priority = 1, + .private_data_size = 0, + .flow_control = CS_LIB_FLOW_CONTROL_NOT_REQUIRED, + .lib_init_fn = tst_sv2_lib_init_fn, + .lib_exit_fn = tst_sv2_lib_exit_fn, + .lib_engine = NULL, + .lib_engine_count = 0, + .exec_engine = NULL, + .exec_engine_count = 0, + .confchg_fn = tst_sv2_confchg_fn, + .exec_init_fn = tst_sv2_exec_init_fn, + .exec_dump_fn = NULL, + .sync_mode = CS_SYNC_V2, + .sync_init = tst_sv2_sync_init_v2, + .sync_process = tst_sv2_sync_process, + .sync_activate = tst_sv2_sync_activate, + .sync_abort = tst_sv2_sync_abort +}; + +static unsigned int my_member_list[PROCESSOR_COUNT_MAX]; + +static unsigned int my_member_list_entries; + +static unsigned int my_old_member_list[PROCESSOR_COUNT_MAX]; + +static unsigned int my_old_member_list_entries = 0; +static int num_sync_processes = 0; + +static DECLARE_LIST_INIT (confchg_notify); + +/* + * Dynamic loading descriptor + */ + +static struct corosync_service_engine *tst_sv2_get_service_engine_ver0 (void); + +static struct corosync_service_engine_iface_ver0 tst_sv2_service_engine_iface = { + .corosync_get_service_engine_ver0 = tst_sv2_get_service_engine_ver0 +}; + +static struct lcr_iface corosync_tst_sv2_ver0[1] = { + { + .name = "corosync_tst_sv2", + .version = 0, + .versions_replace = 0, + .versions_replace_count = 0, + .dependencies = 0, + .dependency_count = 0, + .constructor = NULL, + .destructor = NULL, + .interfaces = NULL, + } +}; + +static struct lcr_comp tst_sv2_comp_ver0 = { + .iface_count = 1, + .ifaces = corosync_tst_sv2_ver0 +}; + +static struct corosync_service_engine *tst_sv2_get_service_engine_ver0 (void) +{ + return (&tst_sv2_service_engine); +} + +#ifdef COROSYNC_SOLARIS +void corosync_lcr_component_register (void); + +void corosync_lcr_component_register (void) { +#else +__attribute__ ((constructor)) static void corosync_lcr_component_register (void) { +#endif + lcr_interfaces_set (&corosync_tst_sv2_ver0[0], &tst_sv2_service_engine_iface); + + lcr_component_register (&tst_sv2_comp_ver0); +} + +static int tst_sv2_exec_init_fn ( + struct corosync_api_v1 *corosync_api) +{ +#ifdef COROSYNC_SOLARIS + logsys_subsys_init(); +#endif + api = corosync_api; + + return 0; +} + +static void tst_sv2_confchg_fn ( + enum totem_configuration_type configuration_type, + const unsigned int *member_list, size_t member_list_entries, + const unsigned int *left_list, size_t left_list_entries, + const unsigned int *joined_list, size_t joined_list_entries, + const struct memb_ring_id *ring_id) +{ + int j; + for (j = 0; j < left_list_entries; j++) { + log_printf (LOGSYS_LEVEL_INFO, + "Member left: %s", api->totem_ifaces_print (left_list[j])); + } + for (j = 0; j < joined_list_entries; j++) { + log_printf (LOGSYS_LEVEL_INFO, + "Member joined: %s", api->totem_ifaces_print (joined_list[j])); + } +} + +static int tst_sv2_lib_init_fn (void *conn) +{ + return (0); +} + +static int tst_sv2_lib_exit_fn (void *conn) +{ + return (0); +} + + +static void tst_sv2_sync_init_v2 ( + const unsigned int *member_list, + size_t member_list_entries, + const struct memb_ring_id *ring_id) +{ + unsigned int lowest_nodeid = 0xffffffff; + int i, j; + int found; + + num_sync_processes = 0; + + memcpy (my_member_list, member_list, member_list_entries * + sizeof (unsigned int)); + my_member_list_entries = member_list_entries; + + for (i = 0; i < my_member_list_entries; i++) { + if (my_member_list[i] < lowest_nodeid) { + lowest_nodeid = my_member_list[i]; + } + } + + log_printf (LOGSYS_LEVEL_INFO, + "tst_sv2_sync_init_v2 %s", + api->totem_ifaces_print (lowest_nodeid)); + + /* look for new (joined) nodes */ + for (j = 0; j < member_list_entries; j++) { + found = 0; + for (i = 0; i < my_old_member_list_entries; i++) { + if (my_old_member_list[i] == member_list[j]) { + found = 1; + break; + } + } + if (found == 0) { + log_printf (LOGSYS_LEVEL_INFO, + "sync: node joined %s", + api->totem_ifaces_print (member_list[j])); + } + } + /* look for old (left) nodes */ + for (i = 0; i < my_old_member_list_entries; i++) { + found = 0; + for (j = 0; j < member_list_entries; j++) { + if (my_old_member_list[i] == member_list[j]) { + found = 1; + break; + } + } + if (found == 0) { + log_printf (LOGSYS_LEVEL_INFO, + "sync: node left %s", + api->totem_ifaces_print (my_old_member_list[i])); + } + } + +} + +static int tst_sv2_sync_process (void) +{ + num_sync_processes++; + + log_printf (LOGSYS_LEVEL_INFO, "sync: process %d", num_sync_processes); + + if (num_sync_processes > 3) { + return 0; + } else { + return 1; + } +} + +static void tst_sv2_sync_activate (void) +{ + memcpy (my_old_member_list, my_member_list, + my_member_list_entries * sizeof (unsigned int)); + my_old_member_list_entries = my_member_list_entries; + + if (num_sync_processes <= 3) { + log_printf (LOGSYS_LEVEL_ERROR, + "sync: activate called before process is done %d", + num_sync_processes); + } else { + log_printf (LOGSYS_LEVEL_INFO, + "sync: activate correctly %d", + num_sync_processes); + } + + num_sync_processes = 0; +} + +static void tst_sv2_sync_abort (void) +{ + log_printf (LOGSYS_LEVEL_INFO, "sync: abort"); +} + diff --git a/cts/agents/votequorum_test_agent.c b/cts/agents/votequorum_test_agent.c new file mode 100644 index 00000000..ab9d96eb --- /dev/null +++ b/cts/agents/votequorum_test_agent.c @@ -0,0 +1,222 @@ +/* + * Copyright (c) 2010 Red Hat Inc + * + * All rights reserved. + * + * Author: Angus Salkeld + * + * 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 MontaVista Software, 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. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include "common_test_agent.h" + + +static void getinfo (int sock) +{ + votequorum_callbacks_t callbacks; + int ret; + struct votequorum_info info; + char response[100]; + votequorum_handle_t g_handle; + + callbacks.votequorum_notify_fn = NULL; + callbacks.votequorum_expectedvotes_notify_fn = NULL; + + ret = votequorum_initialize(&g_handle, &callbacks); + if (ret != CS_OK) { + snprintf (response, 100, "%s", FAIL_STR); + syslog (LOG_ERR, "votequorum_initialize FAILED: %d\n", ret); + goto send_response; + } + + ret = votequorum_getinfo(g_handle, 0, &info); + if (ret != CS_OK) { + snprintf (response, 100, "%s", FAIL_STR); + syslog (LOG_ERR, "votequorum_getinfo FAILED: %d\n", ret); + goto send_response; + } + + snprintf (response, 100, "%d:%d:%d:%d:%d", + info.node_votes, + info.node_expected_votes, + info.highest_expected, + info.total_votes, + info.quorum); + +send_response: + votequorum_finalize (g_handle); + send (sock, response, strlen (response), 0); +} + + +static void setexpected (int sock, char *arg) +{ + votequorum_callbacks_t callbacks; + int ret; + char response[100]; + votequorum_handle_t g_handle; + + callbacks.votequorum_notify_fn = NULL; + callbacks.votequorum_expectedvotes_notify_fn = NULL; + + ret = votequorum_initialize(&g_handle, &callbacks); + if (ret != CS_OK) { + snprintf (response, 100, "%s", FAIL_STR); + syslog (LOG_ERR, "votequorum_initialize FAILED: %d\n", ret); + goto send_response; + } + + ret = votequorum_setexpected (g_handle, atoi(arg)); + if (ret != CS_OK) { + snprintf (response, 100, "%s", FAIL_STR); + syslog (LOG_ERR, "set expected votes FAILED: %d\n", ret); + goto send_response; + } + + snprintf (response, 100, "%s", OK_STR); + +send_response: + votequorum_finalize (g_handle); + send (sock, response, strlen (response) + 1, 0); +} + +static void setvotes (int sock, char *arg) +{ + votequorum_callbacks_t callbacks; + int ret; + char response[100]; + votequorum_handle_t g_handle; + + callbacks.votequorum_notify_fn = NULL; + callbacks.votequorum_expectedvotes_notify_fn = NULL; + + ret = votequorum_initialize(&g_handle, &callbacks); + if (ret != CS_OK) { + snprintf (response, 100, "%s", FAIL_STR); + syslog (LOG_ERR, "votequorum_initialize FAILED: %d\n", ret); + goto send_response; + } + + ret = votequorum_setvotes (g_handle, 0, atoi(arg)); + if (ret != CS_OK) { + snprintf (response, 100, "%s", FAIL_STR); + syslog (LOG_ERR, "set votes FAILED: %d\n", ret); + goto send_response; + } + + snprintf (response, 100, "%s", OK_STR); + +send_response: + votequorum_finalize (g_handle); + send (sock, response, strlen (response), 0); +} + + +static void getquorate (int sock) +{ + int ret; + int quorate; + char response[100]; + quorum_handle_t handle; + + ret = quorum_initialize (&handle, NULL); + if (ret != CS_OK) { + snprintf (response, 100, "%s", FAIL_STR); + syslog (LOG_ERR, "quorum_initialize FAILED: %d\n", ret); + goto send_response; + } + + ret = quorum_getquorate (handle, &quorate); + if (ret != CS_OK) { + snprintf (response, 100, "%s", FAIL_STR); + syslog (LOG_ERR, "getquorate FAILED: %d\n", ret); + goto send_response; + } + + snprintf (response, 100, "%d", quorate); + +send_response: + quorum_finalize (handle); + send (sock, response, strlen (response), 0); +} + +static void do_command (int sock, char* func, char*args[], int num_args) +{ + char response[100]; + + if (parse_debug) + syslog (LOG_DEBUG,"RPC:%s() called.", func); + + if (strcmp ("votequorum_getinfo", func) == 0) { + getinfo (sock); + } else if (strcmp ("votequorum_setvotes", func) == 0) { + setvotes (sock, args[0]); + } else if (strcmp ("votequorum_setexpected", func) == 0) { + setexpected (sock, args[0]); + } else if (strcmp ("quorum_getquorate", func) == 0) { + getquorate (sock); + } else { + syslog (LOG_ERR,"%s RPC:%s not supported!", __func__, func); + snprintf (response, 100, "%s", NOT_SUPPORTED_STR); + send (sock, response, strlen (response), 0); + } +} + + +int main (int argc, char *argv[]) +{ + int ret; + + openlog (NULL, LOG_CONS|LOG_PID, LOG_DAEMON); + syslog (LOG_ERR, "votequorum_test_agent STARTING"); + + parse_debug = 1; + ret = test_agent_run (9037, do_command); + syslog (LOG_ERR, "votequorum_test_agent EXITING"); + + return ret; +} + + -- 2.39.5