Merge lp:~brianaker/gearmand/test-reply into lp:gearmand

Proposed by Brian Aker
Status: Merged
Merged at revision: 874
Proposed branch: lp:~brianaker/gearmand/test-reply
Merge into: lp:gearmand
Diff against target: 313 lines (+137/-17)
8 files modified
ChangeLog (+1/-0)
libgearman-1.0/client.h (+3/-0)
libgearman/client.cc (+15/-13)
libgearman/log.cc (+5/-0)
libgearman/worker.cc (+8/-0)
tests/libgearman-1.0/worker_test.cc (+92/-4)
tests/start_worker.cc (+2/-0)
tests/start_worker.h (+11/-0)
To merge this branch: bzr merge lp:~brianaker/gearmand/test-reply
Reviewer Review Type Date Requested Status
Tangent Trunk Pending
Review via email: mp+185706@code.launchpad.net
To post a comment you must log in.

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
=== modified file 'ChangeLog'
--- ChangeLog 2013-09-05 23:41:08 +0000
+++ ChangeLog 2013-09-16 06:07:37 +0000
@@ -3,6 +3,7 @@
3* Improve compile time.3* Improve compile time.
4* Fix for NOOP failure (bad worker causes early exit of loop).4* Fix for NOOP failure (bad worker causes early exit of loop).
5* Fix for postgres (use INFORMATION_SCHEMA).5* Fix for postgres (use INFORMATION_SCHEMA).
6* Added gearman_client_has_active_tasks() so that you can see if a client has active tasks that it is working on.
67
71.1.9 Fri Aug 2 02:39:25 EDT 201381.1.9 Fri Aug 2 02:39:25 EDT 2013
8* Added gearman_task_is_finished()9* Added gearman_task_is_finished()
910
=== modified file 'libgearman-1.0/client.h'
--- libgearman-1.0/client.h 2012-11-19 10:43:50 +0000
+++ libgearman-1.0/client.h 2013-09-16 06:07:37 +0000
@@ -713,6 +713,9 @@
713GEARMAN_API713GEARMAN_API
714bool gearman_client_has_tasks(const gearman_client_st *client);714bool gearman_client_has_tasks(const gearman_client_st *client);
715715
716GEARMAN_API
717bool gearman_client_has_active_tasks(gearman_client_st *client);
718
716/** @} */719/** @} */
717720
718#ifdef __cplusplus721#ifdef __cplusplus
719722
=== modified file 'libgearman/client.cc'
--- libgearman/client.cc 2013-08-20 09:27:42 +0000
+++ libgearman/client.cc 2013-09-16 06:07:37 +0000
@@ -712,26 +712,28 @@
712 return count;712 return count;
713}713}
714714
715#if 0715bool gearman_client_has_active_tasks(gearman_client_st *client_shell)
716static bool _active_tasks(gearman_client_st *client_shell)
717{716{
718 assert(client_shell);717 if (client_shell and client_shell->impl())
719 gearman_task_st *search= client_shell->impl()->task_list;
720
721 if (not search)
722 return false;
723
724 do
725 {718 {
726 if (gearman_task_is_active(search))719 Client* client= client_shell->impl();
720
721 if (client->task_list and client->task_list->impl())
727 {722 {
728 return true;723 gearman_task_st* search= client->task_list;
724
725 do
726 {
727 if (gearman_task_is_active(search))
728 {
729 return true;
730 }
731 } while ((search= search->impl()->next));
729 }732 }
730 } while ((search= search->next));733 }
731734
732 return false;735 return false;
733}736}
734#endif
735737
736const char *gearman_client_do_job_handle(gearman_client_st *self)738const char *gearman_client_do_job_handle(gearman_client_st *self)
737{739{
738740
=== modified file 'libgearman/log.cc'
--- libgearman/log.cc 2013-05-12 21:37:25 +0000
+++ libgearman/log.cc 2013-09-16 06:07:37 +0000
@@ -98,6 +98,7 @@
9898
99void gearman_log_debug(gearman_universal_st& gearman, const char *format, ...)99void gearman_log_debug(gearman_universal_st& gearman, const char *format, ...)
100{100{
101#if defined(DEBUG) && DEBUG
101 va_list args;102 va_list args;
102103
103 if (gearman.verbose >= GEARMAN_VERBOSE_DEBUG)104 if (gearman.verbose >= GEARMAN_VERBOSE_DEBUG)
@@ -106,5 +107,9 @@
106 __logger(gearman, GEARMAN_VERBOSE_DEBUG, format, args);107 __logger(gearman, GEARMAN_VERBOSE_DEBUG, format, args);
107 va_end(args);108 va_end(args);
108 }109 }
110#else
111 (void)gearman;
112 (void)format;
113#endif
109}114}
110#pragma GCC diagnostic pop115#pragma GCC diagnostic pop
111116
=== modified file 'libgearman/worker.cc'
--- libgearman/worker.cc 2013-08-31 03:16:21 +0000
+++ libgearman/worker.cc 2013-09-16 06:07:37 +0000
@@ -47,6 +47,8 @@
4747
48#include "libgearman/assert.hpp"48#include "libgearman/assert.hpp"
4949
50#include "libgearman/log.hpp"
51
50#include <cstdio>52#include <cstdio>
51#include <cstdlib>53#include <cstdlib>
52#include <cstring>54#include <cstring>
@@ -847,6 +849,11 @@
847 return NULL;849 return NULL;
848 }850 }
849851
852 if (worker->job()->impl()->assigned.command == GEARMAN_COMMAND_NOOP)
853 {
854 gearman_log_debug(worker->universal, "Recieved NOOP");
855 }
856
850 if (worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN or857 if (worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN or
851 worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_ALL or858 worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_ALL or
852 worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_UNIQ)859 worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_UNIQ)
@@ -1124,6 +1131,7 @@
1124 switch (worker->work_function->callback(worker->work_job(),1131 switch (worker->work_function->callback(worker->work_job(),
1125 static_cast<void *>(worker->work_function->context)))1132 static_cast<void *>(worker->work_function->context)))
1126 {1133 {
1134 // @todo look at this from a "what should we do" view.
1127 case GEARMAN_FUNCTION_INVALID_ARGUMENT:1135 case GEARMAN_FUNCTION_INVALID_ARGUMENT:
1128 // worker returned an invalid response, gearman_return_t1136 // worker returned an invalid response, gearman_return_t
1129 case GEARMAN_FUNCTION_FATAL:1137 case GEARMAN_FUNCTION_FATAL:
11301138
=== modified file 'tests/libgearman-1.0/worker_test.cc'
--- tests/libgearman-1.0/worker_test.cc 2013-09-15 22:55:59 +0000
+++ tests/libgearman-1.0/worker_test.cc 2013-09-16 06:07:37 +0000
@@ -673,7 +673,7 @@
673673
674// The idea is to return GEARMAN_ERROR until we hit limit, then return674// The idea is to return GEARMAN_ERROR until we hit limit, then return
675// GEARMAN_SUCCESS675// GEARMAN_SUCCESS
676static gearman_return_t GEARMAN_ERROR_worker(gearman_job_st* job, void *context)676static gearman_return_t GEARMAN_ERROR_limit_worker(gearman_job_st* job, void *context)
677{677{
678 assert(gearman_job_workload_size(job) == 0);678 assert(gearman_job_workload_size(job) == 0);
679 assert(gearman_job_workload(job) == NULL);679 assert(gearman_job_workload(job) == NULL);
@@ -694,6 +694,13 @@
694 return GEARMAN_SUCCESS;694 return GEARMAN_SUCCESS;
695}695}
696696
697static gearman_return_t GEARMAN_ERROR_worker(gearman_job_st*, void* context)
698{
699 size_t *ret= (size_t*)context;
700 *ret= (*ret) +1;
701 return GEARMAN_ERROR;
702}
703
697static gearman_return_t error_return_worker(gearman_job_st* job, void *)704static gearman_return_t error_return_worker(gearman_job_st* job, void *)
698{705{
699 assert(sizeof(gearman_return_t) == gearman_job_workload_size(job));706 assert(sizeof(gearman_return_t) == gearman_job_workload_size(job));
@@ -778,13 +785,91 @@
778 return TEST_SUCCESS;785 return TEST_SUCCESS;
779}786}
780787
788static test_return_t GEARMAN_ERROR_check_retry_TEST(void *)
789{
790 libgearman::Client client(libtest::default_port());
791 ASSERT_EQ(GEARMAN_SUCCESS, gearman_client_echo(&client, test_literal_param(__func__)));
792
793 size_t count= 0;
794 gearman_function_t GEARMAN_ERROR_FN= gearman_function_create(GEARMAN_ERROR_worker);
795 std::auto_ptr<worker_handle_st> handle(test_worker_start(libtest::default_port(),
796 NULL,
797 __func__,
798 GEARMAN_ERROR_FN,
799 &count,
800 gearman_worker_options_t(),
801 0)); // timeout
802
803 gearman_task_st *task= gearman_execute(&client,
804 test_literal_param(__func__),
805 NULL, 0, // unique
806 NULL, // gearman_task_attr_t
807 NULL, // gearman_argument_t
808 NULL); // context
809 ASSERT_NOT_NULL(task);
810
811 gearman_return_t ret;
812 do {
813 ret= gearman_client_run_tasks(&client);
814 ASSERT_TRUE(gearman_success(ret) or ret == GEARMAN_IO_WAIT);
815 } while (gearman_client_has_active_tasks(&client));
816
817 ASSERT_EQ(GEARMAN_WORK_FAIL, gearman_task_return(task));
818 ASSERT_EQ(count, 30);
819
820 return TEST_SUCCESS;
821}
822
823static test_return_t GEARMAN_ERROR_always_return_TEST(void *)
824{
825 libgearman::Client client(libtest::default_port());
826 ASSERT_EQ(GEARMAN_SUCCESS, gearman_client_echo(&client, test_literal_param(__func__)));
827
828 size_t count= 0;
829 gearman_function_t GEARMAN_ERROR_FN= gearman_function_create(GEARMAN_ERROR_worker);
830 std::auto_ptr<worker_handle_st> handle(test_worker_start(libtest::default_port(),
831 NULL,
832 __func__,
833 GEARMAN_ERROR_FN,
834 &count,
835 gearman_worker_options_t(),
836 0)); // timeout
837
838 std::vector<gearman_task_st*> tasks;
839 for (size_t x= 0; x < 24; x++)
840 {
841 gearman_task_st *task= gearman_execute(&client,
842 test_literal_param(__func__),
843 NULL, 0, // unique
844 NULL, // gearman_task_attr_t
845 NULL, // gearman_argument_t
846 NULL); // context
847 test_truth(task);
848 tasks.push_back(task);
849 }
850
851 gearman_return_t ret;
852 do {
853 ret= gearman_client_run_tasks(&client);
854 ASSERT_TRUE(gearman_success(ret) or ret == GEARMAN_IO_WAIT);
855 } while (gearman_client_has_active_tasks(&client));
856
857 for (std::vector<gearman_task_st*>::iterator iter= tasks.begin(); iter != tasks.end(); iter++)
858 {
859 ASSERT_TRUE(*iter);
860 ASSERT_EQ(GEARMAN_WORK_FAIL, gearman_task_return(*iter));
861 }
862
863 return TEST_SUCCESS;
864}
865
781static test_return_t GEARMAN_ERROR_return_TEST(void *)866static test_return_t GEARMAN_ERROR_return_TEST(void *)
782{867{
783 libgearman::Client client(libtest::default_port());868 libgearman::Client client(libtest::default_port());
784 ASSERT_EQ(GEARMAN_SUCCESS, gearman_client_echo(&client, test_literal_param(__func__)));869 ASSERT_EQ(GEARMAN_SUCCESS, gearman_client_echo(&client, test_literal_param(__func__)));
785870
786 size_t count= 0;871 size_t count= 0;
787 gearman_function_t GEARMAN_ERROR_FN= gearman_function_create(GEARMAN_ERROR_worker);872 gearman_function_t GEARMAN_ERROR_FN= gearman_function_create(GEARMAN_ERROR_limit_worker);
788 std::auto_ptr<worker_handle_st> handle(test_worker_start(libtest::default_port(),873 std::auto_ptr<worker_handle_st> handle(test_worker_start(libtest::default_port(),
789 NULL,874 NULL,
790 __func__,875 __func__,
@@ -1705,10 +1790,11 @@
17051790
1706static void *world_create(server_startup_st& servers, test_return_t&)1791static void *world_create(server_startup_st& servers, test_return_t&)
1707{1792{
1708 ASSERT_TRUE(server_startup(servers, "gearmand", libtest::default_port(), NULL));1793 const char *argv[]= { "--job-retries=30", NULL };
1794 ASSERT_TRUE(server_startup(servers, "gearmand", libtest::default_port(), argv));
17091795
1710 second_port= libtest::get_free_port();1796 second_port= libtest::get_free_port();
1711 ASSERT_TRUE(server_startup(servers, "gearmand", second_port, NULL));1797 ASSERT_TRUE(server_startup(servers, "gearmand", second_port, argv));
17121798
1713 return &servers;1799 return &servers;
1714}1800}
@@ -1740,6 +1826,8 @@
1740 {"gearman_return_t worker return coverage", 0, error_return_TEST },1826 {"gearman_return_t worker return coverage", 0, error_return_TEST },
1741 {"gearman_return_t GEARMAN_FAIL worker coverage", 0, GEARMAN_FAIL_return_TEST },1827 {"gearman_return_t GEARMAN_FAIL worker coverage", 0, GEARMAN_FAIL_return_TEST },
1742 {"gearman_return_t GEARMAN_ERROR worker coverage", 0, GEARMAN_ERROR_return_TEST },1828 {"gearman_return_t GEARMAN_ERROR worker coverage", 0, GEARMAN_ERROR_return_TEST },
1829 {"gearman_return_t GEARMAN_ERROR worker always errors", 0, GEARMAN_ERROR_always_return_TEST },
1830 {"gearman_return_t GEARMAN_ERROR worker always errors check retry", 0, GEARMAN_ERROR_check_retry_TEST },
1743 {"gearman_client_run_tasks()", 0, gearman_client_run_tasks_increase_TEST },1831 {"gearman_client_run_tasks()", 0, gearman_client_run_tasks_increase_TEST },
1744 {"gearman_client_run_tasks() GEARMAN_CLIENT_NON_BLOCKING", 0, gearman_client_run_tasks_increase_GEARMAN_CLIENT_NON_BLOCKING_TEST },1832 {"gearman_client_run_tasks() GEARMAN_CLIENT_NON_BLOCKING", 0, gearman_client_run_tasks_increase_GEARMAN_CLIENT_NON_BLOCKING_TEST },
1745 {"gearman_client_run_tasks() chunked", 0, gearman_client_run_tasks_increase_chunk_TEST },1833 {"gearman_client_run_tasks() chunked", 0, gearman_client_run_tasks_increase_chunk_TEST },
17461834
=== modified file 'tests/start_worker.cc'
--- tests/start_worker.cc 2013-07-24 10:58:57 +0000
+++ tests/start_worker.cc 2013-09-16 06:07:37 +0000
@@ -224,6 +224,7 @@
224224
225 if (ret != GEARMAN_SUCCESS and ret != GEARMAN_INVALID_ARGUMENT and ret != GEARMAN_WORK_FAIL)225 if (ret != GEARMAN_SUCCESS and ret != GEARMAN_INVALID_ARGUMENT and ret != GEARMAN_WORK_FAIL)
226 {226 {
227 context->handle->error();
227#if 0228#if 0
228 Error << context->function_name << ": " << gearman_strerror(ret) << ": " << gearman_worker_error(&worker);229 Error << context->function_name << ": " << gearman_strerror(ret) << ": " << gearman_worker_error(&worker);
229#endif230#endif
@@ -276,6 +277,7 @@
276worker_handle_st::worker_handle_st() :277worker_handle_st::worker_handle_st() :
277 failed_startup(false),278 failed_startup(false),
278 _shutdown(false),279 _shutdown(false),
280 _error_count(0),
279 _worker_id(gearman_id_t()),281 _worker_id(gearman_id_t()),
280 _sync_point(2)282 _sync_point(2)
281{283{
282284
=== modified file 'tests/start_worker.h'
--- tests/start_worker.h 2013-04-03 04:16:08 +0000
+++ tests/start_worker.h 2013-09-16 06:07:37 +0000
@@ -66,8 +66,19 @@
66 volatile bool failed_startup;66 volatile bool failed_startup;
67 boost::shared_ptr<libtest::thread::Thread> _thread;67 boost::shared_ptr<libtest::thread::Thread> _thread;
6868
69 void error(gearman_return_t)
70 {
71 _error_count++;
72 }
73
74 bool error()
75 {
76 return _error_count;
77 }
78
69private:79private:
70 bool _shutdown;80 bool _shutdown;
81 uint64_t _error_count;
71 libtest::thread::Mutex _shutdown_lock;82 libtest::thread::Mutex _shutdown_lock;
72 gearman_id_t _worker_id;83 gearman_id_t _worker_id;
73 libtest::thread::Barrier _sync_point;84 libtest::thread::Barrier _sync_point;

Subscribers

People subscribed via source and target branches

to all changes: