static void *client_thread(void *object)
{
(void)object;
gearman_return_t rc;
gearman_client_st client;
gearman_client_st *client_ptr;
size_t result_size;
client_ptr= gearman_client_create(&client);
if (client_ptr == NULL)
abort(); // This would be pretty bad.
rc= gearman_client_add_server(&client, NULL, CLIENT_TEST_PORT);
if (rc != GEARMAN_SUCCESS)
pthread_exit(0);
gearman_client_set_timeout(&client, 400);
for (size_t x= 0; x < 5; x++)
{
(void) gearman_client_do(&client, "client_test_temp", NULL, NULL, 0,
&result_size, &rc);
}
gearman_client_free(client_ptr);
pthread_exit(0);
}
/* send job to worker and check result */
int check_worker(char * queue, char * to_send, char * expect) {
gearman_return_t ret;
char * result;
size_t result_size;
char * job_handle;
const char * unique_job_id;
if (opt_unique_id == NULL) {
unique_job_id = "check";
}
else {
unique_job_id = opt_unique_id;
}
/* create client */
if ( create_client( server_list, &client ) != GM_OK ) {
printf("%s UNKNOWN - cannot create gearman client\n", PLUGIN_NAME);
return( STATE_UNKNOWN );
}
gearman_client_set_timeout(&client, (opt_timeout-1)*1000/server_list_num);
while (1) {
if (send_async) {
result = gm_strdup("sending background job succeded");
job_handle = gm_malloc(GEARMAN_JOB_HANDLE_SIZE * sizeof(char));
ret= gearman_client_do_high_background( &client,
queue,
unique_job_id,
(void *)to_send,
(size_t)strlen(to_send),
job_handle);
free(job_handle);
}
else {
result= (char *)gearman_client_do_high( &client,
queue,
unique_job_id,
(void *)to_send,
(size_t)strlen(to_send),
&result_size,
&ret);
}
if (ret == GEARMAN_WORK_DATA) {
free(result);
continue;
}
else if (ret == GEARMAN_WORK_STATUS) {
continue;
}
else if (ret == GEARMAN_SUCCESS) {
gearman_client_free(&client);
}
else if (ret == GEARMAN_WORK_FAIL) {
printf("%s CRITICAL - Job failed\n", PLUGIN_NAME);
gearman_client_free(&client);
return( STATE_CRITICAL );
}
else {
printf("%s CRITICAL - Job failed: %s\n", PLUGIN_NAME, gearman_client_error(&client));
gearman_client_free(&client);
return( STATE_CRITICAL );
}
break;
}
if( !send_async && expect != NULL && result != NULL ) {
if( strstr(result, expect) != NULL) {
printf("%s OK - send worker '%s' response: '%s'\n", PLUGIN_NAME, to_send, result);
return( STATE_OK );
}
else {
printf("%s CRITICAL - send worker: '%s' response: '%s', expected '%s'\n", PLUGIN_NAME, to_send, result, expect);
return( STATE_CRITICAL );
}
}
printf("%s OK - %s\n", PLUGIN_NAME, result );
return( STATE_OK );
}
/* send job to worker and check result */
int check_worker(char * queue, char * to_send, char * expect) {
gearman_return_t ret;
char * result;
size_t result_size;
char * job_handle;
char unique_name[22];
struct timeval tv;
/* create client */
if ( create_client( server_list, &client ) != GM_OK ) {
printf("%s UNKNOWN - cannot create gearman client\n", PLUGIN_NAME);
return( STATE_UNKNOWN );
}
gearman_client_set_timeout(&client, (opt_timeout-1)*1000/server_list_num);
while (1) {
gettimeofday(&tv, NULL);
sprintf(unique_name, "check_%010lu%06lu", tv.tv_sec, tv.tv_usec);
if (send_async) {
result = "";
job_handle = malloc(GEARMAN_JOB_HANDLE_SIZE * sizeof(char));
ret= gearman_client_do_high_background( &client,
queue,
unique_name,
(void *)to_send,
(size_t)strlen(to_send),
job_handle);
free(job_handle);
}
else {
result= (char *)gearman_client_do_high( &client,
queue,
unique_name,
(void *)to_send,
(size_t)strlen(to_send),
&result_size,
&ret);
}
if (ret == GEARMAN_WORK_DATA) {
free(result);
continue;
}
else if (ret == GEARMAN_WORK_STATUS) {
continue;
}
else if (ret == GEARMAN_SUCCESS) {
gearman_client_free(&client);
}
else if (ret == GEARMAN_WORK_FAIL) {
printf("%s CRITICAL - Job failed\n", PLUGIN_NAME);
gearman_client_free(&client);
return( STATE_CRITICAL );
}
else {
printf("%s CRITICAL - Job failed: %s\n", PLUGIN_NAME, gearman_client_error(&client));
gearman_client_free(&client);
return( STATE_CRITICAL );
}
break;
}
if( !send_async && expect != NULL && result != NULL ) {
if( strstr(result, expect) != NULL) {
printf("%s OK - send worker '%s' response: '%s'\n", PLUGIN_NAME, to_send, result);
return( STATE_OK );
}
else {
printf("%s CRITICAL - send worker: '%s' response: '%s', expected '%s'\n", PLUGIN_NAME, to_send, result, expect);
return( STATE_CRITICAL );
}
}
printf("%s OK - %s\n", PLUGIN_NAME, result );
return( STATE_OK );
}
int main()
{
gearman_client_st client;
if (gearman_client_create(&client) == NULL)
{
std::cerr << "Memory allocation failure on client creation" << std::endl;
return EXIT_FAILURE;
}
//
int timeout=-1;
//
if (timeout >= 0)
{
gearman_client_set_timeout(&client, timeout);
}
gearman_return_t ret= gearman_client_add_server(&client, "localhost", GEARMAN_DEFAULT_TCP_PORT);
if (ret != GEARMAN_SUCCESS)
{
std::cerr<<(gearman_client_error(&client));
return EXIT_FAILURE;
}
if (gearman_failed(gearman_client_set_identifier(&client, "client1", strlen("client1"))))
{
std::cerr<<(gearman_client_error(&client));
return EXIT_FAILURE;
}
int exit_code= EXIT_SUCCESS;
int count=1; //if status is to be returned then don't change count on status receive
do
{
size_t result_size;
char *result;
result= (char *)gearman_client_do(&client, "make_call", NULL,
"scheme-string", strlen("scheme-string"),
&result_size, &ret);
if (ret == GEARMAN_WORK_DATA)
{
std::cout.write(result, result_size);
free(result);
continue;
}
else if (ret == GEARMAN_WORK_STATUS)
{
uint32_t numerator;
uint32_t denominator;
gearman_client_do_status(&client, &numerator, &denominator);
std::clog << "Status: " << numerator << "/" << denominator << std::endl;
continue;
}
else if (ret == GEARMAN_SUCCESS)
{
std::cout.write(result, result_size);
free(result);
}
else if (ret == GEARMAN_WORK_FAIL)
{
std::cerr<<("Work failed");
exit_code= EXIT_FAILURE;
break;
}
else
{
std::cerr<<(gearman_client_error(&client));
exit_code= EXIT_FAILURE;
break;
}
--count;
} while (count);
gearman_client_free(&client);
return exit_code;
}