Merge lp:~brianaker/gearmand/test-reply into lp:gearmand
- test-reply
- Merge into 1.2
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 |
Related bugs: |
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
Tangent Trunk | Pending | ||
Review via email: mp+185706@code.launchpad.net |
Commit message
Description of the change
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
1 | === modified file 'ChangeLog' | |||
2 | --- ChangeLog 2013-09-05 23:41:08 +0000 | |||
3 | +++ ChangeLog 2013-09-16 06:07:37 +0000 | |||
4 | @@ -3,6 +3,7 @@ | |||
5 | 3 | * Improve compile time. | 3 | * Improve compile time. |
6 | 4 | * Fix for NOOP failure (bad worker causes early exit of loop). | 4 | * Fix for NOOP failure (bad worker causes early exit of loop). |
7 | 5 | * Fix for postgres (use INFORMATION_SCHEMA). | 5 | * Fix for postgres (use INFORMATION_SCHEMA). |
8 | 6 | * Added gearman_client_has_active_tasks() so that you can see if a client has active tasks that it is working on. | ||
9 | 6 | 7 | ||
10 | 7 | 1.1.9 Fri Aug 2 02:39:25 EDT 2013 | 8 | 1.1.9 Fri Aug 2 02:39:25 EDT 2013 |
11 | 8 | * Added gearman_task_is_finished() | 9 | * Added gearman_task_is_finished() |
12 | 9 | 10 | ||
13 | === modified file 'libgearman-1.0/client.h' | |||
14 | --- libgearman-1.0/client.h 2012-11-19 10:43:50 +0000 | |||
15 | +++ libgearman-1.0/client.h 2013-09-16 06:07:37 +0000 | |||
16 | @@ -713,6 +713,9 @@ | |||
17 | 713 | GEARMAN_API | 713 | GEARMAN_API |
18 | 714 | bool gearman_client_has_tasks(const gearman_client_st *client); | 714 | bool gearman_client_has_tasks(const gearman_client_st *client); |
19 | 715 | 715 | ||
20 | 716 | GEARMAN_API | ||
21 | 717 | bool gearman_client_has_active_tasks(gearman_client_st *client); | ||
22 | 718 | |||
23 | 716 | /** @} */ | 719 | /** @} */ |
24 | 717 | 720 | ||
25 | 718 | #ifdef __cplusplus | 721 | #ifdef __cplusplus |
26 | 719 | 722 | ||
27 | === modified file 'libgearman/client.cc' | |||
28 | --- libgearman/client.cc 2013-08-20 09:27:42 +0000 | |||
29 | +++ libgearman/client.cc 2013-09-16 06:07:37 +0000 | |||
30 | @@ -712,26 +712,28 @@ | |||
31 | 712 | return count; | 712 | return count; |
32 | 713 | } | 713 | } |
33 | 714 | 714 | ||
36 | 715 | #if 0 | 715 | bool gearman_client_has_active_tasks(gearman_client_st *client_shell) |
35 | 716 | static bool _active_tasks(gearman_client_st *client_shell) | ||
37 | 717 | { | 716 | { |
45 | 718 | assert(client_shell); | 717 | if (client_shell and client_shell->impl()) |
39 | 719 | gearman_task_st *search= client_shell->impl()->task_list; | ||
40 | 720 | |||
41 | 721 | if (not search) | ||
42 | 722 | return false; | ||
43 | 723 | |||
44 | 724 | do | ||
46 | 725 | { | 718 | { |
48 | 726 | if (gearman_task_is_active(search)) | 719 | Client* client= client_shell->impl(); |
49 | 720 | |||
50 | 721 | if (client->task_list and client->task_list->impl()) | ||
51 | 727 | { | 722 | { |
53 | 728 | return true; | 723 | gearman_task_st* search= client->task_list; |
54 | 724 | |||
55 | 725 | do | ||
56 | 726 | { | ||
57 | 727 | if (gearman_task_is_active(search)) | ||
58 | 728 | { | ||
59 | 729 | return true; | ||
60 | 730 | } | ||
61 | 731 | } while ((search= search->impl()->next)); | ||
62 | 729 | } | 732 | } |
64 | 730 | } while ((search= search->next)); | 733 | } |
65 | 731 | 734 | ||
66 | 732 | return false; | 735 | return false; |
67 | 733 | } | 736 | } |
68 | 734 | #endif | ||
69 | 735 | 737 | ||
70 | 736 | const char *gearman_client_do_job_handle(gearman_client_st *self) | 738 | const char *gearman_client_do_job_handle(gearman_client_st *self) |
71 | 737 | { | 739 | { |
72 | 738 | 740 | ||
73 | === modified file 'libgearman/log.cc' | |||
74 | --- libgearman/log.cc 2013-05-12 21:37:25 +0000 | |||
75 | +++ libgearman/log.cc 2013-09-16 06:07:37 +0000 | |||
76 | @@ -98,6 +98,7 @@ | |||
77 | 98 | 98 | ||
78 | 99 | void gearman_log_debug(gearman_universal_st& gearman, const char *format, ...) | 99 | void gearman_log_debug(gearman_universal_st& gearman, const char *format, ...) |
79 | 100 | { | 100 | { |
80 | 101 | #if defined(DEBUG) && DEBUG | ||
81 | 101 | va_list args; | 102 | va_list args; |
82 | 102 | 103 | ||
83 | 103 | if (gearman.verbose >= GEARMAN_VERBOSE_DEBUG) | 104 | if (gearman.verbose >= GEARMAN_VERBOSE_DEBUG) |
84 | @@ -106,5 +107,9 @@ | |||
85 | 106 | __logger(gearman, GEARMAN_VERBOSE_DEBUG, format, args); | 107 | __logger(gearman, GEARMAN_VERBOSE_DEBUG, format, args); |
86 | 107 | va_end(args); | 108 | va_end(args); |
87 | 108 | } | 109 | } |
88 | 110 | #else | ||
89 | 111 | (void)gearman; | ||
90 | 112 | (void)format; | ||
91 | 113 | #endif | ||
92 | 109 | } | 114 | } |
93 | 110 | #pragma GCC diagnostic pop | 115 | #pragma GCC diagnostic pop |
94 | 111 | 116 | ||
95 | === modified file 'libgearman/worker.cc' | |||
96 | --- libgearman/worker.cc 2013-08-31 03:16:21 +0000 | |||
97 | +++ libgearman/worker.cc 2013-09-16 06:07:37 +0000 | |||
98 | @@ -47,6 +47,8 @@ | |||
99 | 47 | 47 | ||
100 | 48 | #include "libgearman/assert.hpp" | 48 | #include "libgearman/assert.hpp" |
101 | 49 | 49 | ||
102 | 50 | #include "libgearman/log.hpp" | ||
103 | 51 | |||
104 | 50 | #include <cstdio> | 52 | #include <cstdio> |
105 | 51 | #include <cstdlib> | 53 | #include <cstdlib> |
106 | 52 | #include <cstring> | 54 | #include <cstring> |
107 | @@ -847,6 +849,11 @@ | |||
108 | 847 | return NULL; | 849 | return NULL; |
109 | 848 | } | 850 | } |
110 | 849 | 851 | ||
111 | 852 | if (worker->job()->impl()->assigned.command == GEARMAN_COMMAND_NOOP) | ||
112 | 853 | { | ||
113 | 854 | gearman_log_debug(worker->universal, "Recieved NOOP"); | ||
114 | 855 | } | ||
115 | 856 | |||
116 | 850 | if (worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN or | 857 | if (worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN or |
117 | 851 | worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_ALL or | 858 | worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_ALL or |
118 | 852 | worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_UNIQ) | 859 | worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_UNIQ) |
119 | @@ -1124,6 +1131,7 @@ | |||
120 | 1124 | switch (worker->work_function->callback(worker->work_job(), | 1131 | switch (worker->work_function->callback(worker->work_job(), |
121 | 1125 | static_cast<void *>(worker->work_function->context))) | 1132 | static_cast<void *>(worker->work_function->context))) |
122 | 1126 | { | 1133 | { |
123 | 1134 | // @todo look at this from a "what should we do" view. | ||
124 | 1127 | case GEARMAN_FUNCTION_INVALID_ARGUMENT: | 1135 | case GEARMAN_FUNCTION_INVALID_ARGUMENT: |
125 | 1128 | // worker returned an invalid response, gearman_return_t | 1136 | // worker returned an invalid response, gearman_return_t |
126 | 1129 | case GEARMAN_FUNCTION_FATAL: | 1137 | case GEARMAN_FUNCTION_FATAL: |
127 | 1130 | 1138 | ||
128 | === modified file 'tests/libgearman-1.0/worker_test.cc' | |||
129 | --- tests/libgearman-1.0/worker_test.cc 2013-09-15 22:55:59 +0000 | |||
130 | +++ tests/libgearman-1.0/worker_test.cc 2013-09-16 06:07:37 +0000 | |||
131 | @@ -673,7 +673,7 @@ | |||
132 | 673 | 673 | ||
133 | 674 | // The idea is to return GEARMAN_ERROR until we hit limit, then return | 674 | // The idea is to return GEARMAN_ERROR until we hit limit, then return |
134 | 675 | // GEARMAN_SUCCESS | 675 | // GEARMAN_SUCCESS |
136 | 676 | static gearman_return_t GEARMAN_ERROR_worker(gearman_job_st* job, void *context) | 676 | static gearman_return_t GEARMAN_ERROR_limit_worker(gearman_job_st* job, void *context) |
137 | 677 | { | 677 | { |
138 | 678 | assert(gearman_job_workload_size(job) == 0); | 678 | assert(gearman_job_workload_size(job) == 0); |
139 | 679 | assert(gearman_job_workload(job) == NULL); | 679 | assert(gearman_job_workload(job) == NULL); |
140 | @@ -694,6 +694,13 @@ | |||
141 | 694 | return GEARMAN_SUCCESS; | 694 | return GEARMAN_SUCCESS; |
142 | 695 | } | 695 | } |
143 | 696 | 696 | ||
144 | 697 | static gearman_return_t GEARMAN_ERROR_worker(gearman_job_st*, void* context) | ||
145 | 698 | { | ||
146 | 699 | size_t *ret= (size_t*)context; | ||
147 | 700 | *ret= (*ret) +1; | ||
148 | 701 | return GEARMAN_ERROR; | ||
149 | 702 | } | ||
150 | 703 | |||
151 | 697 | static gearman_return_t error_return_worker(gearman_job_st* job, void *) | 704 | static gearman_return_t error_return_worker(gearman_job_st* job, void *) |
152 | 698 | { | 705 | { |
153 | 699 | assert(sizeof(gearman_return_t) == gearman_job_workload_size(job)); | 706 | assert(sizeof(gearman_return_t) == gearman_job_workload_size(job)); |
154 | @@ -778,13 +785,91 @@ | |||
155 | 778 | return TEST_SUCCESS; | 785 | return TEST_SUCCESS; |
156 | 779 | } | 786 | } |
157 | 780 | 787 | ||
158 | 788 | static test_return_t GEARMAN_ERROR_check_retry_TEST(void *) | ||
159 | 789 | { | ||
160 | 790 | libgearman::Client client(libtest::default_port()); | ||
161 | 791 | ASSERT_EQ(GEARMAN_SUCCESS, gearman_client_echo(&client, test_literal_param(__func__))); | ||
162 | 792 | |||
163 | 793 | size_t count= 0; | ||
164 | 794 | gearman_function_t GEARMAN_ERROR_FN= gearman_function_create(GEARMAN_ERROR_worker); | ||
165 | 795 | std::auto_ptr<worker_handle_st> handle(test_worker_start(libtest::default_port(), | ||
166 | 796 | NULL, | ||
167 | 797 | __func__, | ||
168 | 798 | GEARMAN_ERROR_FN, | ||
169 | 799 | &count, | ||
170 | 800 | gearman_worker_options_t(), | ||
171 | 801 | 0)); // timeout | ||
172 | 802 | |||
173 | 803 | gearman_task_st *task= gearman_execute(&client, | ||
174 | 804 | test_literal_param(__func__), | ||
175 | 805 | NULL, 0, // unique | ||
176 | 806 | NULL, // gearman_task_attr_t | ||
177 | 807 | NULL, // gearman_argument_t | ||
178 | 808 | NULL); // context | ||
179 | 809 | ASSERT_NOT_NULL(task); | ||
180 | 810 | |||
181 | 811 | gearman_return_t ret; | ||
182 | 812 | do { | ||
183 | 813 | ret= gearman_client_run_tasks(&client); | ||
184 | 814 | ASSERT_TRUE(gearman_success(ret) or ret == GEARMAN_IO_WAIT); | ||
185 | 815 | } while (gearman_client_has_active_tasks(&client)); | ||
186 | 816 | |||
187 | 817 | ASSERT_EQ(GEARMAN_WORK_FAIL, gearman_task_return(task)); | ||
188 | 818 | ASSERT_EQ(count, 30); | ||
189 | 819 | |||
190 | 820 | return TEST_SUCCESS; | ||
191 | 821 | } | ||
192 | 822 | |||
193 | 823 | static test_return_t GEARMAN_ERROR_always_return_TEST(void *) | ||
194 | 824 | { | ||
195 | 825 | libgearman::Client client(libtest::default_port()); | ||
196 | 826 | ASSERT_EQ(GEARMAN_SUCCESS, gearman_client_echo(&client, test_literal_param(__func__))); | ||
197 | 827 | |||
198 | 828 | size_t count= 0; | ||
199 | 829 | gearman_function_t GEARMAN_ERROR_FN= gearman_function_create(GEARMAN_ERROR_worker); | ||
200 | 830 | std::auto_ptr<worker_handle_st> handle(test_worker_start(libtest::default_port(), | ||
201 | 831 | NULL, | ||
202 | 832 | __func__, | ||
203 | 833 | GEARMAN_ERROR_FN, | ||
204 | 834 | &count, | ||
205 | 835 | gearman_worker_options_t(), | ||
206 | 836 | 0)); // timeout | ||
207 | 837 | |||
208 | 838 | std::vector<gearman_task_st*> tasks; | ||
209 | 839 | for (size_t x= 0; x < 24; x++) | ||
210 | 840 | { | ||
211 | 841 | gearman_task_st *task= gearman_execute(&client, | ||
212 | 842 | test_literal_param(__func__), | ||
213 | 843 | NULL, 0, // unique | ||
214 | 844 | NULL, // gearman_task_attr_t | ||
215 | 845 | NULL, // gearman_argument_t | ||
216 | 846 | NULL); // context | ||
217 | 847 | test_truth(task); | ||
218 | 848 | tasks.push_back(task); | ||
219 | 849 | } | ||
220 | 850 | |||
221 | 851 | gearman_return_t ret; | ||
222 | 852 | do { | ||
223 | 853 | ret= gearman_client_run_tasks(&client); | ||
224 | 854 | ASSERT_TRUE(gearman_success(ret) or ret == GEARMAN_IO_WAIT); | ||
225 | 855 | } while (gearman_client_has_active_tasks(&client)); | ||
226 | 856 | |||
227 | 857 | for (std::vector<gearman_task_st*>::iterator iter= tasks.begin(); iter != tasks.end(); iter++) | ||
228 | 858 | { | ||
229 | 859 | ASSERT_TRUE(*iter); | ||
230 | 860 | ASSERT_EQ(GEARMAN_WORK_FAIL, gearman_task_return(*iter)); | ||
231 | 861 | } | ||
232 | 862 | |||
233 | 863 | return TEST_SUCCESS; | ||
234 | 864 | } | ||
235 | 865 | |||
236 | 781 | static test_return_t GEARMAN_ERROR_return_TEST(void *) | 866 | static test_return_t GEARMAN_ERROR_return_TEST(void *) |
237 | 782 | { | 867 | { |
238 | 783 | libgearman::Client client(libtest::default_port()); | 868 | libgearman::Client client(libtest::default_port()); |
239 | 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__))); |
240 | 785 | 870 | ||
241 | 786 | size_t count= 0; | 871 | size_t count= 0; |
243 | 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); |
244 | 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(), |
245 | 789 | NULL, | 874 | NULL, |
246 | 790 | __func__, | 875 | __func__, |
247 | @@ -1705,10 +1790,11 @@ | |||
248 | 1705 | 1790 | ||
249 | 1706 | static void *world_create(server_startup_st& servers, test_return_t&) | 1791 | static void *world_create(server_startup_st& servers, test_return_t&) |
250 | 1707 | { | 1792 | { |
252 | 1708 | ASSERT_TRUE(server_startup(servers, "gearmand", libtest::default_port(), NULL)); | 1793 | const char *argv[]= { "--job-retries=30", NULL }; |
253 | 1794 | ASSERT_TRUE(server_startup(servers, "gearmand", libtest::default_port(), argv)); | ||
254 | 1709 | 1795 | ||
255 | 1710 | second_port= libtest::get_free_port(); | 1796 | second_port= libtest::get_free_port(); |
257 | 1711 | ASSERT_TRUE(server_startup(servers, "gearmand", second_port, NULL)); | 1797 | ASSERT_TRUE(server_startup(servers, "gearmand", second_port, argv)); |
258 | 1712 | 1798 | ||
259 | 1713 | return &servers; | 1799 | return &servers; |
260 | 1714 | } | 1800 | } |
261 | @@ -1740,6 +1826,8 @@ | |||
262 | 1740 | {"gearman_return_t worker return coverage", 0, error_return_TEST }, | 1826 | {"gearman_return_t worker return coverage", 0, error_return_TEST }, |
263 | 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 }, |
264 | 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 }, |
265 | 1829 | {"gearman_return_t GEARMAN_ERROR worker always errors", 0, GEARMAN_ERROR_always_return_TEST }, | ||
266 | 1830 | {"gearman_return_t GEARMAN_ERROR worker always errors check retry", 0, GEARMAN_ERROR_check_retry_TEST }, | ||
267 | 1743 | {"gearman_client_run_tasks()", 0, gearman_client_run_tasks_increase_TEST }, | 1831 | {"gearman_client_run_tasks()", 0, gearman_client_run_tasks_increase_TEST }, |
268 | 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 }, |
269 | 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 }, |
270 | 1746 | 1834 | ||
271 | === modified file 'tests/start_worker.cc' | |||
272 | --- tests/start_worker.cc 2013-07-24 10:58:57 +0000 | |||
273 | +++ tests/start_worker.cc 2013-09-16 06:07:37 +0000 | |||
274 | @@ -224,6 +224,7 @@ | |||
275 | 224 | 224 | ||
276 | 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) |
277 | 226 | { | 226 | { |
278 | 227 | context->handle->error(); | ||
279 | 227 | #if 0 | 228 | #if 0 |
280 | 228 | Error << context->function_name << ": " << gearman_strerror(ret) << ": " << gearman_worker_error(&worker); | 229 | Error << context->function_name << ": " << gearman_strerror(ret) << ": " << gearman_worker_error(&worker); |
281 | 229 | #endif | 230 | #endif |
282 | @@ -276,6 +277,7 @@ | |||
283 | 276 | worker_handle_st::worker_handle_st() : | 277 | worker_handle_st::worker_handle_st() : |
284 | 277 | failed_startup(false), | 278 | failed_startup(false), |
285 | 278 | _shutdown(false), | 279 | _shutdown(false), |
286 | 280 | _error_count(0), | ||
287 | 279 | _worker_id(gearman_id_t()), | 281 | _worker_id(gearman_id_t()), |
288 | 280 | _sync_point(2) | 282 | _sync_point(2) |
289 | 281 | { | 283 | { |
290 | 282 | 284 | ||
291 | === modified file 'tests/start_worker.h' | |||
292 | --- tests/start_worker.h 2013-04-03 04:16:08 +0000 | |||
293 | +++ tests/start_worker.h 2013-09-16 06:07:37 +0000 | |||
294 | @@ -66,8 +66,19 @@ | |||
295 | 66 | volatile bool failed_startup; | 66 | volatile bool failed_startup; |
296 | 67 | boost::shared_ptr<libtest::thread::Thread> _thread; | 67 | boost::shared_ptr<libtest::thread::Thread> _thread; |
297 | 68 | 68 | ||
298 | 69 | void error(gearman_return_t) | ||
299 | 70 | { | ||
300 | 71 | _error_count++; | ||
301 | 72 | } | ||
302 | 73 | |||
303 | 74 | bool error() | ||
304 | 75 | { | ||
305 | 76 | return _error_count; | ||
306 | 77 | } | ||
307 | 78 | |||
308 | 69 | private: | 79 | private: |
309 | 70 | bool _shutdown; | 80 | bool _shutdown; |
310 | 81 | uint64_t _error_count; | ||
311 | 71 | libtest::thread::Mutex _shutdown_lock; | 82 | libtest::thread::Mutex _shutdown_lock; |
312 | 72 | gearman_id_t _worker_id; | 83 | gearman_id_t _worker_id; |
313 | 73 | libtest::thread::Barrier _sync_point; | 84 | libtest::thread::Barrier _sync_point; |