--- /dev/null
+/*
+ * 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 <config.h>
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/un.h>
+#include <sys/wait.h>
+#include <syslog.h>
+
+#include <corosync/corotypes.h>
+#include <corosync/sam.h>
+#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;
+}
+
+
+
+
+
+
+
+
+
--- /dev/null
+/*
+ * Copyright (c) 2010 Red Hat, Inc.
+ *
+ * All rights reserved.
+ *
+ * Author: Angus Salkeld <asalkeld@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 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 <config.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+
+#include <corosync/swab.h>
+#include <corosync/corotypes.h>
+#include <corosync/coroipc_types.h>
+#include <corosync/corodefs.h>
+#include <corosync/lcr/lcr_comp.h>
+#include <corosync/mar_gen.h>
+#include <corosync/engine/coroapi.h>
+#include <corosync/list.h>
+#include <corosync/engine/logsys.h>
+
+#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");
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2010 Red Hat Inc
+ *
+ * All rights reserved.
+ *
+ * Author: Angus Salkeld <asalkeld@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 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 <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/un.h>
+#include <syslog.h>
+
+#include <corosync/corotypes.h>
+#include <corosync/votequorum.h>
+#include <corosync/quorum.h>
+#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;
+}
+
+
projects / mirror_corosync.git / commitdiff