/* create the gearman duplicate client */
int create_client_dup( gm_server_t * server_list[GM_LISTSIZE], gearman_client_st *client ) {
gearman_return_t ret;
int x = 0;
gm_log( GM_LOG_TRACE, "create_client_dup()\n" );
signal(SIGPIPE, SIG_IGN);
client = gearman_client_create(client);
if ( client == NULL ) {
gm_log( GM_LOG_ERROR, "Memory allocation failure on client creation\n" );
return GM_ERROR;
}
while ( server_list[x] != NULL ) {
ret = gearman_client_add_server( client, server_list[x]->host, server_list[x]->port );
if ( ret != GEARMAN_SUCCESS ) {
gm_log( GM_LOG_ERROR, "client error: %s\n", gearman_client_error( client ) );
return GM_ERROR;
}
x++;
}
current_client_dup = client;
return GM_OK;
}
/* create the gearman client */
int create_client( char ** server_list, gearman_client_st *client ) {
gearman_return_t ret;
int x = 0;
gm_log( GM_LOG_TRACE, "create_client()\n" );
signal(SIGPIPE, SIG_IGN);
client = gearman_client_create(client);
if ( client == NULL ) {
gm_log( GM_LOG_ERROR, "Memory allocation failure on client creation\n" );
return GM_ERROR;
}
while ( server_list[x] != NULL ) {
char * server = strdup( server_list[x] );
char * server_c = server;
char * host = strsep( &server, ":" );
char * port_val = strsep( &server, "\x0" );
in_port_t port = GM_SERVER_DEFAULT_PORT;
if(port_val != NULL) {
port = ( in_port_t ) atoi( port_val );
}
ret = gearman_client_add_server( client, host, port );
if ( ret != GEARMAN_SUCCESS ) {
gm_log( GM_LOG_ERROR, "client error: %s\n", gearman_client_error( client ) );
free(server_c);
return GM_ERROR;
}
free(server_c);
x++;
}
assert(x != 0);
current_client = client;
return GM_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;
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 );
}
/* create a task and send it */
int add_job_to_queue( gearman_client_st *client, char ** server_list, char * queue, char * uniq, char * data, int priority, int retries, int transport_mode, int send_now ) {
gearman_task_st *task = NULL;
gearman_return_t ret1, ret2;
char * crypted_data;
int size, free_uniq;
struct timeval now;
/* check too long queue names */
if(strlen(queue) > 63) {
gm_log( GM_LOG_ERROR, "queue name too long: '%s'\n", queue );
return GM_ERROR;
}
/* cut off to long uniq ids */
free_uniq = 0;
if(uniq != NULL && strlen(uniq) > 63) {
uniq = strndup(uniq, 63);
free_uniq = 1;
}
signal(SIGPIPE, SIG_IGN);
gm_log( GM_LOG_TRACE, "add_job_to_queue(%s, %s, %d, %d, %d, %d)\n", queue, uniq, priority, retries, transport_mode, send_now );
gm_log( GM_LOG_TRACE, "%d --->%s<---\n", strlen(data), data );
crypted_data = malloc(GM_BUFFERSIZE);
size = mod_gm_encrypt(&crypted_data, data, transport_mode);
gm_log( GM_LOG_TRACE, "%d +++>\n%s\n<+++\n", size, crypted_data );
#ifdef GM_DEBUG
/* verify decrypted string is equal to the original */
char * test;
test = malloc(GM_BUFFERSIZE);
mod_gm_decrypt(&test, crypted_data, transport_mode);
gm_log( GM_LOG_TRACE, "%d ===>\n%s\n<===\n", size, test );
if(strcmp(test, data)) {
gm_log( GM_LOG_ERROR, "%d --->%s<---\n", strlen(data), data );
gm_log( GM_LOG_ERROR, "%d ===>\n%s\n<===\n", size, test );
fprintf(stderr, "encrypted string does not match\n");
exit(EXIT_FAILURE);
}
#endif
if( priority == GM_JOB_PRIO_LOW ) {
task = gearman_client_add_task_low_background( client, NULL, NULL, queue, uniq, ( void * )crypted_data, ( size_t )size, &ret1 );
gearman_task_give_workload(task,crypted_data,size);
}
else if( priority == GM_JOB_PRIO_NORMAL ) {
task = gearman_client_add_task_background( client, NULL, NULL, queue, uniq, ( void * )crypted_data, ( size_t )size, &ret1 );
gearman_task_give_workload(task,crypted_data,size);
}
else if( priority == GM_JOB_PRIO_HIGH ) {
task = gearman_client_add_task_high_background( client, NULL, NULL, queue, uniq, ( void * )crypted_data, ( size_t )size, &ret1 );
gearman_task_give_workload(task,crypted_data,size);
}
else {
gm_log( GM_LOG_ERROR, "add_job_to_queue() wrong priority: %d\n", priority );
}
if(send_now != TRUE)
return GM_OK;
ret2 = gearman_client_run_tasks( client );
gearman_client_task_free_all( client );
if( ret1 != GEARMAN_SUCCESS
|| ret2 != GEARMAN_SUCCESS
|| task == NULL
|| ( gearman_client_error(client) != NULL && atof(gearman_version()) == 0.14 )
) {
/* log the error */
if(retries == 0) {
gettimeofday(&now,NULL);
/* only log the first error, otherwise we would fill the log very quickly */
if( mod_gm_con_errors == 0 ) {
gettimeofday(&mod_gm_error_time,NULL);
gm_log( GM_LOG_ERROR, "sending job to gearmand failed: %s\n", gearman_client_error(client) );
}
/* or every minute to give an update */
else if( now.tv_sec >= mod_gm_error_time.tv_sec + 60) {
gettimeofday(&mod_gm_error_time,NULL);
gm_log( GM_LOG_ERROR, "sending job to gearmand failed: %s (%i lost jobs so far)\n", gearman_client_error(client), mod_gm_con_errors );
}
mod_gm_con_errors++;
}
/* recreate client, otherwise gearman sigsegvs */
gearman_client_free( client );
create_client( server_list, client );
/* retry as long as we have retries */
if(retries > 0) {
retries--;
gm_log( GM_LOG_TRACE, "add_job_to_queue() retrying... %d\n", retries );
return(add_job_to_queue( client, server_list, queue, uniq, data, priority, retries, transport_mode, send_now ));
}
/* no more retries... */
else {
gm_log( GM_LOG_TRACE, "add_job_to_queue() finished with errors: %d %d\n", ret1, ret2 );
return GM_ERROR;
}
}
/* reset error counter */
mod_gm_con_errors = 0;
if(free_uniq)
free(uniq);
gm_log( GM_LOG_TRACE, "add_job_to_queue() finished sucessfully: %d %d\n", ret1, ret2 );
return GM_OK;
}
int main(int argc, char *argv[])
{
int c;
char *host= NULL;
in_port_t port= 0;
gearman_return_t ret;
gearman_client_st client;
char *result;
size_t result_size;
uint32_t numerator;
uint32_t denominator;
while ((c = getopt(argc, argv, "h:p:")) != -1)
{
switch(c)
{
case 'h':
host= optarg;
break;
case 'p':
port= (in_port_t)atoi(optarg);
break;
default:
usage(argv[0]);
exit(1);
}
}
if (argc != (optind + 1))
{
usage(argv[0]);
exit(1);
}
if (gearman_client_create(&client) == NULL)
{
fprintf(stderr, "Memory allocation failure on client creation\n");
exit(1);
}
ret= gearman_client_add_server(&client, host, port);
if (ret != GEARMAN_SUCCESS)
{
fprintf(stderr, "%s\n", gearman_client_error(&client));
exit(1);
}
while (1)
{
result= (char *)gearman_client_do(&client, "reverse", NULL,
(void *)argv[optind],
(size_t)strlen(argv[optind]),
&result_size, &ret);
if (ret == GEARMAN_WORK_DATA)
{
printf("Data=%.*s\n", (int)result_size, result);
free(result);
continue;
}
else if (ret == GEARMAN_WORK_STATUS)
{
gearman_client_do_status(&client, &numerator, &denominator);
printf("Status: %u/%u\n", numerator, denominator);
continue;
}
else if (ret == GEARMAN_SUCCESS)
{
printf("Result=%.*s\n", (int)result_size, result);
free(result);
}
else if (ret == GEARMAN_WORK_FAIL)
fprintf(stderr, "Work failed\n");
else
fprintf(stderr, "%s\n", gearman_client_error(&client));
break;
}
gearman_client_free(&client);
return 0;
}
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;
}
