void *doing_work(gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr){
int workloadsize;
/* contect is unused */
context = context;
workloadsize = gearman_job_workload_size(job); //how big is the workload?
//Copy the workload into a usable string
char workload[workloadsize];
strncpy(workload, (const char*)gearman_job_workload(job), workloadsize);
//Do your work here
puts(workload);
//Not passing any result information back at the moment
result_size = 0;
/* Should do some checks to monitor for fails
* all we're doing here is just printing the workload
*/
*ret_ptr = GEARMAN_SUCCESS;
return;
}
/*
* Create one pair(key, value), (U_{UserName}, U_Id)
*/
void *sync_UserInfo(gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr) {
uint8_t *result, i;
const uint8_t *workload;
char userId[20] = {0}, userName[20] = {0};
char UUserName[20] = {0};
char json_buffer[CMD_LENGTH] = {0};
workload = gearman_job_workload(job);
*result_size = gearman_job_workload_size(job);
result = malloc(*result_size);
printf(" sync_UserInfo : %s\n", workload);
for (i = 0;i < *result_size;i ++) {
json_buffer[i] = (char)workload[i];
}
parserJsonTokener(json_buffer, userId, userName, USERINFO);
printf("userId:%s, userName:%s\n", userId, userName);
sprintf(UUserName, "U_%s", userName);
if (-1 == set_key_toredis(UUserName, userId)) {
//return -2;
return result;
}
*ret_ptr = GEARMAN_SUCCESS;
return result;
}
//#include <boost/program_options.hpp>
static gearman_return_t worker_function(gearman_job_st *job, void *context)
{
const char *workload= (const char *)gearman_job_workload(job);
const size_t workload_size= gearman_job_workload_size(job);
std::cout << "Recieved " << workload_size << " bytes" << std::endl;
////
char *result=new char[workload_size];
memcpy(result,workload,workload_size);
/*
*if (gearman_failed(gearman_job_send_data(job, &result[y], 1)))
{
return GEARMAN_ERROR;
}
if (gearman_failed(gearman_job_send_status(job, (uint32_t)y, (uint32_t)workload_size)))
{
return GEARMAN_ERROR;
}
// Notice that we send based on y divided by zero.
if (gearman_failed(gearman_job_send_status(job, (uint32_t)workload_size, (uint32_t)workload_size)))
{
return GEARMAN_ERROR;
}
*/
if (gearman_failed(gearman_job_send_data(job, &result[0], workload_size)))
{
return GEARMAN_ERROR;
}
}
void *syncToRedis(gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr) {
uint8_t *result;
const uint8_t *workload;
workload = gearman_job_workload(job);
*result_size = gearman_job_workload_size(job);
result = malloc(*result_size);
printf(" aaa : %s\n", workload);
return result;
}
/* answer status querys */
void *return_status( gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr ) {
int wsize;
char workload[GM_BUFFERSIZE];
int *shm;
char * result;
gm_log( GM_LOG_TRACE, "return_status()\n" );
/* contect is unused */
context = context;
/* get the data */
wsize = gearman_job_workload_size(job);
strncpy(workload, (const char*)gearman_job_workload(job), wsize);
workload[wsize] = '\0';
gm_log( GM_LOG_TRACE, "got status job %s\n", gearman_job_handle( job ) );
gm_log( GM_LOG_TRACE, "%d +++>\n%s\n<+++\n", strlen(workload), workload );
/* set result pointer to success */
*ret_ptr= GEARMAN_SUCCESS;
/* set size of result */
result = malloc(GM_BUFFERSIZE);
*result_size = GM_BUFFERSIZE;
/* give us 10 seconds to get state */
signal(SIGALRM, exit_sighandler);
alarm(10);
/* Now we attach the segment to our data space. */
if ((shm = shmat(shmid, NULL, 0)) == (int *) -1) {
perror("shmat");
*result_size = 0;
alarm(0);
free(result);
return NULL;
}
snprintf(result, GM_BUFFERSIZE, "%s has %i worker and is working on %i jobs. Version: %s|worker=%i;;;%i;%i jobs=%ic", hostname, shm[SHM_WORKER_TOTAL], shm[SHM_WORKER_RUNNING], GM_VERSION, shm[SHM_WORKER_TOTAL], mod_gm_opt->min_worker, mod_gm_opt->max_worker, shm[SHM_JOBS_DONE] );
/* and increase job counter */
shm[SHM_JOBS_DONE]++;
/* detach from shared memory */
if(shmdt(shm) < 0)
perror("shmdt");
alarm(0);
return((void*)result);
}
/*
* Create two pairs(key, value), (R_{DeviceId}, UserId) and (RP_{UserId}, DeviceId)
*/
void *sync_UserAndDeviceRelationShip(gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr) {
uint8_t *result, i;
const uint8_t *workload;
char userId[20] = {0}, deviceId[20] = {0};
char RPUserId[20] = {0}, RDeviceId[20] = {0};
char json_buffer[CMD_LENGTH] = {0};
struct json_object *json_object = NULL;
struct json_object *userIdTokener = NULL;
struct json_object *deviceIdTokener = NULL;
workload = gearman_job_workload(job);
*result_size = gearman_job_workload_size(job);
result = malloc(*result_size);
printf(" sync_UserAndDeviceRelationShip : %s\n", workload);
for (i = 0;i < *result_size;i ++) {
json_buffer[i] = (char)workload[i];
}
parserJsonTokener(json_buffer, userId, deviceId, USERANDDEVICERELATIONSHIP);
printf("userId:%s, deviceId:%s\n", userId, deviceId);
sprintf(RPUserId, "RP_%s", userId);
if (-1 == set_key_toredis(RPUserId, deviceId)) {
//return -2;
return result;
}
sprintf(RDeviceId, "R_%s", deviceId);
if (-1 == set_key_toredis(RDeviceId, userId)) {
//return -2;
return result;
}
*ret_ptr = GEARMAN_SUCCESS;
return result;
}
void *get_results( gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr ) {
int wsize;
char workload[GM_BUFFERSIZE];
char *decrypted_data;
/* contect is unused */
context = context;
/* set size of result */
*result_size = 0;
/* set result pointer to success */
*ret_ptr = GEARMAN_SUCCESS;
/* get the data */
wsize = gearman_job_workload_size(job);
strncpy(workload, (const char*)gearman_job_workload(job), wsize);
workload[wsize] = '\x0';
/* decrypt data */
decrypted_data = malloc(GM_BUFFERSIZE);
mod_gm_decrypt(&decrypted_data, workload, mod_gm_opt->transportmode);
if(decrypted_data == NULL) {
*ret_ptr = GEARMAN_WORK_FAIL;
return NULL;
}
like(decrypted_data, "host_name=host1", "output contains host_name");
like(decrypted_data, "output=", "output contains output");
if(last_result != NULL)
free(last_result);
last_result = decrypted_data;
return NULL;
}
/* get a job */
void *get_job( gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr ) {
sigset_t block_mask;
int wsize, valid_lines;
char workload[GM_BUFFERSIZE];
char * decrypted_data;
char * decrypted_data_c;
char * decrypted_orig;
char *ptr;
/* reset timeout for now, will be set befor execution again */
alarm(0);
signal(SIGALRM, SIG_IGN);
jobs_done++;
/* send start signal to parent */
set_state(GM_JOB_START);
gm_log( GM_LOG_TRACE, "get_job()\n" );
/* contect is unused */
context = context;
/* set size of result */
*result_size = 0;
/* reset sleep time */
sleep_time_after_error = 1;
/* ignore sigterms while running job */
sigemptyset(&block_mask);
sigaddset(&block_mask, SIGTERM);
sigprocmask(SIG_BLOCK, &block_mask, NULL);
/* get the data */
current_gearman_job = job;
wsize = gearman_job_workload_size(job);
strncpy(workload, (const char*)gearman_job_workload(job), wsize);
workload[wsize] = '\0';
gm_log( GM_LOG_TRACE, "got new job %s\n", gearman_job_handle( job ) );
gm_log( GM_LOG_TRACE, "%d +++>\n%s\n<+++\n", strlen(workload), workload );
/* decrypt data */
decrypted_data = malloc(GM_BUFFERSIZE);
decrypted_data_c = decrypted_data;
mod_gm_decrypt(&decrypted_data, workload, mod_gm_opt->transportmode);
decrypted_orig = strdup(decrypted_data);
if(decrypted_data == NULL) {
*ret_ptr = GEARMAN_WORK_FAIL;
free(decrypted_orig);
return NULL;
}
gm_log( GM_LOG_TRACE, "%d --->\n%s\n<---\n", strlen(decrypted_data), decrypted_data );
/* set result pointer to success */
*ret_ptr= GEARMAN_SUCCESS;
exec_job = ( gm_job_t * )malloc( sizeof *exec_job );
set_default_job(exec_job, mod_gm_opt);
valid_lines = 0;
while ( (ptr = strsep(&decrypted_data, "\n" )) != NULL ) {
char *key = strsep( &ptr, "=" );
char *value = strsep( &ptr, "\x0" );
if ( key == NULL )
continue;
if ( value == NULL || !strcmp( value, "") )
break;
if ( !strcmp( key, "host_name" ) ) {
exec_job->host_name = strdup(value);
valid_lines++;
} else if ( !strcmp( key, "service_description" ) ) {
exec_job->service_description = strdup(value);
valid_lines++;
} else if ( !strcmp( key, "type" ) ) {
exec_job->type = strdup(value);
valid_lines++;
} else if ( !strcmp( key, "result_queue" ) ) {
exec_job->result_queue = strdup(value);
valid_lines++;
} else if ( !strcmp( key, "check_options" ) ) {
exec_job->check_options = atoi(value);
valid_lines++;
} else if ( !strcmp( key, "scheduled_check" ) ) {
exec_job->scheduled_check = atoi(value);
valid_lines++;
} else if ( !strcmp( key, "reschedule_check" ) ) {
exec_job->reschedule_check = atoi(value);
valid_lines++;
} else if ( !strcmp( key, "latency" ) ) {
exec_job->latency = atof(value);
valid_lines++;
} else if ( !strcmp( key, "next_check" ) ) {
string2timeval(value, &exec_job->next_check);
valid_lines++;
} else if ( !strcmp( key, "start_time" ) ) {
/* for compatibility reasons... (used by older mod-gearman neb modules) */
string2timeval(value, &exec_job->next_check);
string2timeval(value, &exec_job->core_time);
valid_lines++;
} else if ( !strcmp( key, "core_time" ) ) {
string2timeval(value, &exec_job->core_time);
valid_lines++;
} else if ( !strcmp( key, "timeout" ) ) {
exec_job->timeout = atoi(value);
valid_lines++;
} else if ( !strcmp( key, "command_line" ) ) {
exec_job->command_line = strdup(value);
valid_lines++;
}
}
#ifdef GM_DEBUG
if(exec_job->next_check.tv_sec < 10000)
write_debug_file(&decrypted_orig);
#endif
if(valid_lines == 0) {
gm_log( GM_LOG_ERROR, "discarded invalid job (%s), check your encryption settings\n", gearman_job_handle( job ) );
} else {
do_exec_job();
}
current_gearman_job = NULL;
/* start listening to SIGTERMs */
sigprocmask(SIG_UNBLOCK, &block_mask, NULL);
free(decrypted_orig);
free(decrypted_data_c);
free_job(exec_job);
/* send finish signal to parent */
set_state(GM_JOB_END);
if(mod_gm_opt->max_jobs > 0 && jobs_done >= mod_gm_opt->max_jobs) {
gm_log( GM_LOG_TRACE, "jobs done: %i -> exiting...\n", jobs_done );
clean_worker_exit(0);
_exit( EXIT_SUCCESS );
}
return NULL;
}
void *do_parse(gearman_job_st *job, void *context, size_t *result_size,
gearman_return_t *ret_ptr) {
int yv;
char *buf;
JSONEncoder json = JSONEncoder();
buf = strdup((char *) gearman_job_workload(job));
yy_scan_string(buf);
// on EOF yylex will return 0
while ((yv = yylex()) != 0) {
int token = yv;
char *value = (char*) yysval.sval;
switch (token) {
case LIKES:
switchOn(LIKES);
break;
case HATES:
switchOn(HATES);
break;
case FROM:
switchOn(FROM);
break;
case MOODS:
switchOn(MOODS);
break;
case INFO:
switchOn(INFO);
break;
case VALUE:
Data *data = Data::getInstance();
switch (getState()) {
case LIKES:
data->likes.push_back(value);
break;
case HATES:
data->hates.push_back(value);
break;
case INFO:
data->info.push_back(value);
break;
case MOODS:
data->moods.push_back(value);
break;
case FROM:
data->from.push_back(value);
break;
default:
data->vals.push_back(value); //push all the vals to a list if no identifier is present
break;
}
}
}
char* result = strdup(json.encodeParsed());
*result_size = strlen(result);
*ret_ptr = GEARMAN_SUCCESS;
Data::getInstance()->free();
state=0;
return result;
}
/* put back the result into the core */
void *get_results( gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr ) {
int wsize;
char workload[GM_BUFFERSIZE];
char *decrypted_data;
char *decrypted_data_c;
#ifdef GM_DEBUG
char *decrypted_orig;
#endif
struct timeval now, core_start_time;
check_result * chk_result;
int active_check = TRUE;
char *ptr;
double now_f, core_starttime_f, starttime_f, finishtime_f, exec_time, latency;
/* for calculating real latency */
gettimeofday(&now,NULL);
/* contect is unused */
context = context;
/* set size of result */
*result_size = 0;
/* set result pointer to success */
*ret_ptr = GEARMAN_SUCCESS;
/* get the data */
wsize = gearman_job_workload_size(job);
strncpy(workload, (const char*)gearman_job_workload(job), wsize);
workload[wsize] = '\x0';
gm_log( GM_LOG_TRACE, "got result %s\n", gearman_job_handle( job ));
gm_log( GM_LOG_TRACE, "%d +++>\n%s\n<+++\n", strlen(workload), workload );
/* decrypt data */
decrypted_data = malloc(GM_BUFFERSIZE);
decrypted_data_c = decrypted_data;
mod_gm_decrypt(&decrypted_data, workload, mod_gm_opt->transportmode);
if(decrypted_data == NULL) {
*ret_ptr = GEARMAN_WORK_FAIL;
return NULL;
}
gm_log( GM_LOG_TRACE, "%d --->\n%s\n<---\n", strlen(decrypted_data), decrypted_data );
#ifdef GM_DEBUG
decrypted_orig = strdup(decrypted_data);
#endif
/*
* save this result to a file, so when nagios crashes,
* we have at least the crashed package
*/
if(mod_gm_opt->debug_result == GM_ENABLED) {
FILE * fd;
fd = fopen( "/tmp/last_result_received.txt", "w+" );
if(fd == NULL)
perror("fopen");
fputs( decrypted_data, fd );
fclose( fd );
}
/* nagios will free it after processing */
if ( ( chk_result = ( check_result * )malloc( sizeof *chk_result ) ) == 0 ) {
*ret_ptr = GEARMAN_WORK_FAIL;
return NULL;
}
init_check_result(chk_result);
chk_result->scheduled_check = TRUE;
chk_result->reschedule_check = TRUE;
chk_result->output_file = 0;
chk_result->output_file_fd = -1;
core_start_time.tv_sec = 0;
core_start_time.tv_usec = 0;
while ( (ptr = strsep(&decrypted_data, "\n" )) != NULL ) {
char *key = strsep( &ptr, "=" );
char *value = strsep( &ptr, "\x0" );
if ( key == NULL )
continue;
if ( !strcmp( key, "output" ) ) {
if ( value == NULL ) {
chk_result->output = strdup("(null)");
}
else {
chk_result->output = strdup( value );
}
}
if ( value == NULL || !strcmp( value, "") )
break;
if ( !strcmp( key, "host_name" ) ) {
chk_result->host_name = strdup( value );
} else if ( !strcmp( key, "service_description" ) ) {
chk_result->service_description = strdup( value );
} else if ( !strcmp( key, "check_options" ) ) {
chk_result->check_options = atoi( value );
} else if ( !strcmp( key, "scheduled_check" ) ) {
chk_result->scheduled_check = atoi( value );
} else if ( !strcmp( key, "type" ) && !strcmp( value, "passive" ) ) {
active_check=FALSE;
} else if ( !strcmp( key, "reschedule_check" ) ) {
chk_result->reschedule_check = atoi( value );
} else if ( !strcmp( key, "exited_ok" ) ) {
chk_result->exited_ok = atoi( value );
} else if ( !strcmp( key, "early_timeout" ) ) {
chk_result->early_timeout = atoi( value );
} else if ( !strcmp( key, "return_code" ) ) {
chk_result->return_code = atoi( value );
} else if ( !strcmp( key, "core_start_time" ) ) {
string2timeval(value, &core_start_time);
} else if ( !strcmp( key, "start_time" ) ) {
string2timeval(value, &chk_result->start_time);
} else if ( !strcmp( key, "finish_time" ) ) {
string2timeval(value, &chk_result->finish_time);
} else if ( !strcmp( key, "latency" ) ) {
chk_result->latency = atof( value );
}
}
if ( chk_result->host_name == NULL || chk_result->output == NULL ) {
*ret_ptr= GEARMAN_WORK_FAIL;
gm_log( GM_LOG_ERROR, "discarded invalid result\n" );
return NULL;
}
if ( chk_result->service_description != NULL ) {
chk_result->object_check_type = SERVICE_CHECK;
chk_result->check_type = SERVICE_CHECK_ACTIVE;
if(active_check == FALSE )
chk_result->check_type = SERVICE_CHECK_PASSIVE;
} else {
chk_result->object_check_type = HOST_CHECK;
chk_result->check_type = HOST_CHECK_ACTIVE;
if(active_check == FALSE )
chk_result->check_type = HOST_CHECK_PASSIVE;
}
/* fill some maybe missing options */
if(chk_result->start_time.tv_sec == 0) {
chk_result->start_time.tv_sec = (unsigned long)time(NULL);
}
if(chk_result->finish_time.tv_sec == 0) {
chk_result->finish_time.tv_sec = (unsigned long)time(NULL);
}
if(core_start_time.tv_sec == 0) {
core_start_time.tv_sec = (unsigned long)time(NULL);
}
/* calculate real latency */
now_f = (double)now.tv_sec + (double)now.tv_usec / 1000000;
core_starttime_f = (double)core_start_time.tv_sec + (double)core_start_time.tv_usec / 1000000;
starttime_f = (double)chk_result->start_time.tv_sec + (double)chk_result->start_time.tv_usec / 1000000;
finishtime_f = (double)chk_result->finish_time.tv_sec + (double)chk_result->finish_time.tv_usec / 1000000;
exec_time = finishtime_f - starttime_f;
latency = now_f - exec_time - core_starttime_f;
if(latency < 0)
latency = 0;
if(chk_result->latency < 0)
chk_result->latency = 0;
chk_result->latency += latency;
#ifdef GM_DEBUG
if(chk_result->latency > 1000)
write_debug_file(&decrypted_orig);
#endif
/* this check is not a freshnes check */
chk_result->check_options = chk_result->check_options & ! CHECK_OPTION_FRESHNESS_CHECK;
if ( chk_result->service_description != NULL ) {
#ifdef GM_DEBUG
/* does this services exist */
service * svc = find_service( chk_result->host_name, chk_result->service_description );
if(svc == NULL) {
write_debug_file(&decrypted_orig);
gm_log( GM_LOG_ERROR, "service '%s' on host '%s' could not be found\n", chk_result->service_description, chk_result->host_name );
return NULL;
}
#endif
gm_log( GM_LOG_DEBUG, "service job completed: %s %s: %d\n", chk_result->host_name, chk_result->service_description, chk_result->return_code );
} else {
#ifdef GM_DEBUG
/* does this host exist */
host * hst = find_host( chk_result->host_name );
if(hst == NULL) {
write_debug_file(&decrypted_orig);
gm_log( GM_LOG_ERROR, "host '%s' could not be found\n", chk_result->host_name );
return NULL;
}
#endif
gm_log( GM_LOG_DEBUG, "host job completed: %s: %d\n", chk_result->host_name, chk_result->return_code );
}
/* add result to result list */
mod_gm_add_result_to_list( chk_result );
/* reset pointer */
chk_result = NULL;
free(decrypted_data_c);
#ifdef GM_DEBUG
free(decrypted_orig);
#endif
return NULL;
}
