From 240ba43e0eb3583691428f8e392c7514b583e15f Mon Sep 17 00:00:00 2001 From: David Vossel Date: Thu, 20 Feb 2014 21:26:39 -0600 Subject: [PATCH] Fix testsuite ipc test artifacts --- libqb.spec | 9 +- test-timeout-fix.patch | 590 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 597 insertions(+), 2 deletions(-) create mode 100644 test-timeout-fix.patch diff --git a/libqb.spec b/libqb.spec index 2631570..01c01d2 100644 --- a/libqb.spec +++ b/libqb.spec @@ -1,12 +1,13 @@ Name: libqb Version: 0.17.0 -Release: 1%{?dist} +Release: 2%{?dist} Summary: An IPC library for high performance servers Group: System Environment/Libraries License: LGPLv2+ URL: http://www.libqb.org Source0: https://fedorahosted.org/releases/q/u/quarterback/%{name}-%{version}.tar.xz +Patch0: test-timeout-fix.patch BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) BuildRequires: libtool doxygen procps check-devel automake @@ -19,6 +20,7 @@ Initially these are IPC and poll. %prep %setup -q +%patch0 -p1 # Make sure the timestamps are correct find . -exec touch \{\} \; @@ -28,7 +30,7 @@ find . -exec touch \{\} \; make %{?_smp_mflags} %check -make check +make -j1 check %install rm -rf $RPM_BUILD_ROOT @@ -69,6 +71,9 @@ developing applications that use %{name}. %changelog +* Thu Feb 20 2014 David Vossel - 0.17.0-2 +Fix testsuite timing values + * Wed Feb 19 2014 David Vossel - 0.17.0-1 Fix: build: Allow 'make rpm' to work with lightweight tags for release candidates Fix: spec: reference correct url in spec file diff --git a/test-timeout-fix.patch b/test-timeout-fix.patch new file mode 100644 index 0000000..01d6b18 --- /dev/null +++ b/test-timeout-fix.patch @@ -0,0 +1,590 @@ +diff --git a/lib/Makefile.am b/lib/Makefile.am +index 91c6bd1..5bcdc22 100644 +--- a/lib/Makefile.am ++++ b/lib/Makefile.am +@@ -42,6 +42,8 @@ source_to_lint = util.c hdb.c ringbuffer.c ringbuffer_helper.c \ + libqb_la_SOURCES = $(source_to_lint) unix.c + libqb_la_LIBADD = @LTLIBOBJS@ + ++LDFLAGS = $(LDFLAGS_COPY:-Bsymbolic-functions=) ++ + if HAVE_SEM_TIMEDWAIT + else + libqb_la_SOURCES+=rpl_sem.c +diff --git a/tests/check_ipc.c b/tests/check_ipc.c +index 6a80fec..e0df9e7 100644 +--- a/tests/check_ipc.c ++++ b/tests/check_ipc.c +@@ -139,6 +139,7 @@ s1_msg_process_fn(qb_ipcs_connection_t *c, + int32_t m; + int32_t num; + struct qb_ipcs_connection_stats_2 *stats; ++ uint32_t max_size = MAX_MSG_SIZE; + + response.size = sizeof(struct qb_ipc_response_header); + response.error = 0; +@@ -148,8 +149,7 @@ s1_msg_process_fn(qb_ipcs_connection_t *c, + free(stats); + + /* crazy large message */ +- res = qb_ipcs_event_send(c, &response, +- MAX_MSG_SIZE*10); ++ res = qb_ipcs_event_send(c, &response, max_size*10); + ck_assert_int_eq(res, -EMSGSIZE); + + /* send one event before responding */ +@@ -157,6 +157,11 @@ s1_msg_process_fn(qb_ipcs_connection_t *c, + ck_assert_int_eq(res, sizeof(response)); + response.id++; + ++ /* There should be one more item in the event queue now. */ ++ stats = qb_ipcs_connection_stats_get_2(c, QB_FALSE); ++ ck_assert_int_eq(stats->event_q_length - num, 1); ++ free(stats); ++ + /* send response */ + response.id = IPC_MSG_RES_BULK_EVENTS; + res = qb_ipcs_response_send(c, &response, response.size); +@@ -175,9 +180,6 @@ s1_msg_process_fn(qb_ipcs_connection_t *c, + ck_assert_int_eq(res, sizeof(response)); + response.id++; + } +- stats = qb_ipcs_connection_stats_get_2(c, QB_FALSE); +- ck_assert_int_eq(stats->event_q_length - num, num_bulk_events); +- free(stats); + + } else if (req_pt->id == IPC_MSG_REQ_STRESS_EVENT) { + struct { +@@ -313,7 +315,7 @@ s1_connection_destroyed(qb_ipcs_connection_t *c) + static void + s1_connection_created(qb_ipcs_connection_t *c) + { +- int32_t max = MAX_MSG_SIZE; ++ uint32_t max = MAX_MSG_SIZE; + + if (send_event_on_created) { + struct qb_ipc_response_header response; +@@ -362,6 +364,7 @@ run_ipc_server(void) + .dispatch_mod = my_dispatch_mod, + .dispatch_del = my_dispatch_del, + }; ++ uint32_t max_size = MAX_MSG_SIZE; + + qb_loop_signal_add(my_loop, QB_LOOP_HIGH, SIGSTOP, + NULL, exit_handler, &handle); +@@ -374,7 +377,7 @@ run_ipc_server(void) + fail_if(s1 == 0); + + if (enforce_server_buffer) { +- qb_ipcs_enforce_buffer_size(s1, MAX_MSG_SIZE); ++ qb_ipcs_enforce_buffer_size(s1, max_size); + } + qb_ipcs_poll_handlers_set(s1, &ph); + +@@ -402,13 +405,70 @@ run_function_in_new_process(void (*run_ipc_server_fn)(void)) + return pid; + } + +-static int32_t +-stop_process(pid_t pid) ++static void ++request_server_exit(void) ++{ ++ struct qb_ipc_request_header req_header; ++ struct qb_ipc_response_header res_header; ++ struct iovec iov[1]; ++ int32_t res; ++ ++ /* ++ * tell the server to exit ++ */ ++ req_header.id = IPC_MSG_REQ_SERVER_FAIL; ++ req_header.size = sizeof(struct qb_ipc_request_header); ++ ++ iov[0].iov_len = req_header.size; ++ iov[0].iov_base = &req_header; ++ ++ ck_assert_int_eq(QB_TRUE, qb_ipcc_is_connected(conn)); ++ ++ res = qb_ipcc_sendv_recv(conn, iov, 1, ++ &res_header, ++ sizeof(struct qb_ipc_response_header), -1); ++ /* ++ * confirm we get -ENOTCONN or ECONNRESET ++ */ ++ if (res != -ECONNRESET && res != -ENOTCONN) { ++ qb_log(LOG_ERR, "id:%d size:%d", res_header.id, res_header.size); ++ ck_assert_int_eq(res, -ENOTCONN); ++ } ++} ++ ++static void ++kill_server(pid_t pid) + { +- /* wait a bit for the server to shutdown by it's self */ +- usleep(100000); + kill(pid, SIGTERM); + waitpid(pid, NULL, 0); ++} ++ ++static int32_t ++verify_graceful_stop(pid_t pid) ++{ ++ int wait_rc = 0; ++ int status = 0; ++ int rc = 0; ++ int tries; ++ ++ /* We need the server to be able to exit by itself */ ++ for (tries = 10; tries >= 0; tries--) { ++ sleep(1); ++ wait_rc = waitpid(pid, &status, WNOHANG); ++ if (wait_rc > 0) { ++ break; ++ } ++ } ++ ++ ck_assert_int_eq(wait_rc, pid); ++ rc = WIFEXITED(status); ++ if (rc) { ++ rc = WEXITSTATUS(status); ++ ck_assert_int_eq(rc, 0); ++ } else { ++ fail_if(rc == 0); ++ } ++ + return 0; + } + +@@ -425,6 +485,7 @@ send_and_check(int32_t req_id, uint32_t size, + struct qb_ipc_response_header res_header; + int32_t res; + int32_t try_times = 0; ++ uint32_t max_size = MAX_MSG_SIZE; + + request.hdr.id = req_id; + request.hdr.size = sizeof(struct qb_ipc_request_header) + size; +@@ -432,7 +493,7 @@ send_and_check(int32_t req_id, uint32_t size, + /* check that we can't send a message that is too big + * and we get the right return code. + */ +- res = qb_ipcc_send(conn, &request, MAX_MSG_SIZE*2); ++ res = qb_ipcc_send(conn, &request, max_size*2); + ck_assert_int_eq(res, -EMSGSIZE); + + repeat_send: +@@ -484,13 +545,14 @@ test_ipc_txrx(void) + int32_t c = 0; + size_t size; + pid_t pid; ++ uint32_t max_size = MAX_MSG_SIZE; + + pid = run_function_in_new_process(run_ipc_server); + fail_if(pid == -1); + sleep(1); + + do { +- conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); ++ conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); +@@ -503,7 +565,7 @@ test_ipc_txrx(void) + size = QB_MIN(sizeof(struct qb_ipc_request_header), 64); + for (j = 1; j < 19; j++) { + size *= 2; +- if (size >= MAX_MSG_SIZE) ++ if (size >= max_size) + break; + if (send_and_check(IPC_MSG_REQ_TX_RX, size, + recv_timeout, QB_TRUE) < 0) { +@@ -511,10 +573,17 @@ test_ipc_txrx(void) + } + } + if (turn_on_fc) { ++ /* can't signal server to shutdown if flow control is on */ + ck_assert_int_eq(fc_enabled, QB_TRUE); ++ qb_ipcc_disconnect(conn); ++ /* TODO - figure out why this sleep is necessary */ ++ sleep(1); ++ kill_server(pid); ++ } else { ++ request_server_exit(); ++ qb_ipcc_disconnect(conn); ++ verify_graceful_stop(pid); + } +- qb_ipcc_disconnect(conn); +- stop_process(pid); + } + + static void +@@ -527,13 +596,14 @@ test_ipc_exit(void) + int32_t c = 0; + int32_t j = 0; + pid_t pid; ++ uint32_t max_size = MAX_MSG_SIZE; + + pid = run_function_in_new_process(run_ipc_server); + fail_if(pid == -1); + sleep(1); + + do { +- conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); ++ conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); +@@ -554,8 +624,8 @@ test_ipc_exit(void) + sizeof(struct qb_ipc_response_header), -1); + ck_assert_int_eq(res, sizeof(struct qb_ipc_response_header)); + +- /* kill the server */ +- stop_process(pid); ++ request_server_exit(); ++ verify_graceful_stop(pid); + + /* + * wait a bit for the server to die. +@@ -674,13 +744,14 @@ test_ipc_dispatch(void) + int32_t c = 0; + pid_t pid; + int32_t size; ++ uint32_t max_size = MAX_MSG_SIZE; + + pid = run_function_in_new_process(run_ipc_server); + fail_if(pid == -1); + sleep(1); + + do { +- conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); ++ conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); +@@ -693,7 +764,7 @@ test_ipc_dispatch(void) + size = QB_MIN(sizeof(struct qb_ipc_request_header), 64); + for (j = 1; j < 19; j++) { + size *= 2; +- if (size >= MAX_MSG_SIZE) ++ if (size >= max_size) + break; + if (send_and_check(IPC_MSG_REQ_DISPATCH, size, + recv_timeout, QB_TRUE) < 0) { +@@ -701,8 +772,9 @@ test_ipc_dispatch(void) + } + } + ++ request_server_exit(); + qb_ipcc_disconnect(conn); +- stop_process(pid); ++ verify_graceful_stop(pid); + } + + START_TEST(test_ipc_disp_us) +@@ -781,22 +853,20 @@ count_bulk_events(int32_t fd, int32_t revents, void *data) + static void + test_ipc_bulk_events(void) + { +- struct qb_ipc_request_header req_header; +- struct qb_ipc_response_header res_header; +- struct iovec iov[1]; + int32_t c = 0; + int32_t j = 0; + pid_t pid; + int32_t res; + qb_loop_t *cl; + int32_t fd; ++ uint32_t max_size = MAX_MSG_SIZE; + + pid = run_function_in_new_process(run_ipc_server); + fail_if(pid == -1); + sleep(1); + + do { +- conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); ++ conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); +@@ -823,21 +893,9 @@ test_ipc_bulk_events(void) + qb_loop_run(cl); + ck_assert_int_eq(events_received, num_bulk_events); + +- req_header.id = IPC_MSG_REQ_SERVER_FAIL; +- req_header.size = sizeof(struct qb_ipc_request_header); +- +- iov[0].iov_len = req_header.size; +- iov[0].iov_base = &req_header; +- res = qb_ipcc_sendv_recv(conn, iov, 1, +- &res_header, +- sizeof(struct qb_ipc_response_header), -1); +- if (res != -ECONNRESET && res != -ENOTCONN) { +- qb_log(LOG_ERR, "id:%d size:%d", res_header.id, res_header.size); +- ck_assert_int_eq(res, -ENOTCONN); +- } +- ++ request_server_exit(); + qb_ipcc_disconnect(conn); +- stop_process(pid); ++ verify_graceful_stop(pid); + } + + static void +@@ -857,13 +915,14 @@ test_ipc_stress_test(void) + int32_t res; + qb_loop_t *cl; + int32_t fd; ++ uint32_t max_size = MAX_MSG_SIZE; + /* This looks strange, but it serves an important purpose. + * This test forces the server to enforce the MAX_MSG_SIZE + * limit from the server side, which overrides the client's + * buffer limit. To verify this functionality is working + * we set the client limit lower than what the server + * is enforcing. */ +- int32_t client_buf_size = MAX_MSG_SIZE - 1024; ++ int32_t client_buf_size = max_size - 1024; + int32_t real_buf_size; + + enforce_server_buffer = 1; +@@ -884,7 +943,7 @@ test_ipc_stress_test(void) + fail_if(conn == NULL); + + real_buf_size = qb_ipcc_get_buffer_size(conn); +- ck_assert_int_eq(real_buf_size, MAX_MSG_SIZE); ++ ck_assert_int_eq(real_buf_size, max_size); + + qb_log(LOG_DEBUG, "Testing %d iterations of EVENT msg passing.", num_stress_events); + +@@ -920,7 +979,7 @@ test_ipc_stress_test(void) + } + + qb_ipcc_disconnect(conn); +- stop_process(pid); ++ verify_graceful_stop(pid); + } + + START_TEST(test_ipc_stress_test_us) +@@ -954,6 +1013,7 @@ test_ipc_event_on_created(void) + int32_t res; + qb_loop_t *cl; + int32_t fd; ++ uint32_t max_size = MAX_MSG_SIZE; + + num_bulk_events = 1; + +@@ -962,7 +1022,7 @@ test_ipc_event_on_created(void) + sleep(1); + + do { +- conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); ++ conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); +@@ -984,8 +1044,9 @@ test_ipc_event_on_created(void) + qb_loop_run(cl); + ck_assert_int_eq(events_received, num_bulk_events); + ++ request_server_exit(); + qb_ipcc_disconnect(conn); +- stop_process(pid); ++ verify_graceful_stop(pid); + } + + START_TEST(test_ipc_event_on_created_us) +@@ -1009,13 +1070,14 @@ test_ipc_disconnect_after_created(void) + int32_t j = 0; + pid_t pid; + int32_t res; ++ uint32_t max_size = MAX_MSG_SIZE; + + pid = run_function_in_new_process(run_ipc_server); + fail_if(pid == -1); + sleep(1); + + do { +- conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); ++ conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); +@@ -1046,7 +1108,7 @@ test_ipc_disconnect_after_created(void) + ck_assert_int_eq(QB_FALSE, qb_ipcc_is_connected(conn)); + + qb_ipcc_disconnect(conn); +- stop_process(pid); ++ kill_server(pid); + } + + START_TEST(test_ipc_disconnect_after_created_us) +@@ -1063,20 +1125,17 @@ END_TEST + static void + test_ipc_server_fail(void) + { +- struct qb_ipc_request_header req_header; +- struct qb_ipc_response_header res_header; +- struct iovec iov[1]; +- int32_t res; + int32_t j; + int32_t c = 0; + pid_t pid; ++ uint32_t max_size = MAX_MSG_SIZE; + + pid = run_function_in_new_process(run_ipc_server); + fail_if(pid == -1); + sleep(1); + + do { +- conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); ++ conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); +@@ -1086,31 +1145,10 @@ test_ipc_server_fail(void) + } while (conn == NULL && c < 5); + fail_if(conn == NULL); + +- /* +- * tell the server to exit +- */ +- req_header.id = IPC_MSG_REQ_SERVER_FAIL; +- req_header.size = sizeof(struct qb_ipc_request_header); +- +- iov[0].iov_len = req_header.size; +- iov[0].iov_base = &req_header; +- +- ck_assert_int_eq(QB_TRUE, qb_ipcc_is_connected(conn)); +- +- res = qb_ipcc_sendv_recv(conn, iov, 1, +- &res_header, +- sizeof(struct qb_ipc_response_header), -1); +- /* +- * confirm we get -ENOTCONN or ECONNRESET +- */ +- if (res != -ECONNRESET && res != -ENOTCONN) { +- qb_log(LOG_ERR, "id:%d size:%d", res_header.id, res_header.size); +- ck_assert_int_eq(res, -ENOTCONN); +- } ++ request_server_exit(); + ck_assert_int_eq(QB_FALSE, qb_ipcc_is_connected(conn)); +- + qb_ipcc_disconnect(conn); +- stop_process(pid); ++ verify_graceful_stop(pid); + } + + START_TEST(test_ipc_server_fail_soc) +@@ -1181,6 +1219,7 @@ test_ipc_service_ref_count(void) + int32_t c = 0; + int32_t j = 0; + pid_t pid; ++ uint32_t max_size = MAX_MSG_SIZE; + + reference_count_test = QB_TRUE; + +@@ -1189,7 +1228,7 @@ test_ipc_service_ref_count(void) + sleep(1); + + do { +- conn = qb_ipcc_connect(ipc_name, MAX_MSG_SIZE); ++ conn = qb_ipcc_connect(ipc_name, max_size); + if (conn == NULL) { + j = waitpid(pid, NULL, WNOHANG); + ck_assert_int_eq(j, 0); +@@ -1201,8 +1240,7 @@ test_ipc_service_ref_count(void) + + sleep(5); + +- qb_ipcc_disconnect(conn); +- stop_process(pid); ++ kill_server(pid); + } + + +@@ -1265,22 +1303,22 @@ make_shm_suite(void) + + tc = tcase_create("ipc_server_fail_shm"); + tcase_add_test(tc, test_ipc_server_fail_shm); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_txrx_shm_block"); + tcase_add_test(tc, test_ipc_txrx_shm_block); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_txrx_shm_tmo"); + tcase_add_test(tc, test_ipc_txrx_shm_tmo); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_fc_shm"); + tcase_add_test(tc, test_ipc_fc_shm); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_dispatch_shm"); +@@ -1300,11 +1338,12 @@ make_shm_suite(void) + + tc = tcase_create("ipc_exit_shm"); + tcase_add_test(tc, test_ipc_exit_shm); +- tcase_set_timeout(tc, 3); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_event_on_created_shm"); + tcase_add_test(tc, test_ipc_event_on_created_shm); ++ tcase_set_timeout(tc, 10); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_service_ref_count_shm"); +@@ -1328,27 +1367,27 @@ make_soc_suite(void) + + tc = tcase_create("ipc_server_fail_soc"); + tcase_add_test(tc, test_ipc_server_fail_soc); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_txrx_us_block"); + tcase_add_test(tc, test_ipc_txrx_us_block); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_txrx_us_tmo"); + tcase_add_test(tc, test_ipc_txrx_us_tmo); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_fc_us"); + tcase_add_test(tc, test_ipc_fc_us); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_exit_us"); + tcase_add_test(tc, test_ipc_exit_us); +- tcase_set_timeout(tc, 6); ++ tcase_set_timeout(tc, 8); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_dispatch_us"); +@@ -1368,10 +1407,12 @@ make_soc_suite(void) + + tc = tcase_create("ipc_event_on_created_us"); + tcase_add_test(tc, test_ipc_event_on_created_us); ++ tcase_set_timeout(tc, 10); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_disconnect_after_created_us"); + tcase_add_test(tc, test_ipc_disconnect_after_created_us); ++ tcase_set_timeout(tc, 10); + suite_add_tcase(s, tc); + + tc = tcase_create("ipc_service_ref_count_us");