/**
* Check for un-ordered wavelength values in OI_WAVELENGTH.
*
* @param pOi pointer to oi_fits struct to check
* @param pResult pointer to oi_check_result struct to store result in
*
* @return oi_breach level indicating overall test result
*/
oi_breach_level check_waveorder(oi_fits *pOi, oi_check_result *pResult)
{
GList *link;
int i;
oi_wavelength *pWave;
const char desc[] = "OI_WAVELENGTH has wavelengths not in ascending order";
char location[FLEN_VALUE];
init_check_result(pResult);
link = pOi->wavelengthList;
while(link != NULL) {
pWave = link->data;
for(i=1; i<pWave->nwave; i++) {
if (pWave->eff_wave[i] < pWave->eff_wave[i-1] ||
(i+1 < pWave->nwave && pWave->eff_wave[i] > pWave->eff_wave[i+1])) {
g_snprintf(location, FLEN_VALUE, "OI_WAVELENGTH INSNAME=%s channel %d",
pWave->insname, i+1);
set_result(pResult, OI_BREACH_WARNING, desc, location);
}
}
link = link->next;
}
return pResult->level;
}
/**
* Check for unnormalised (i.e. significantly > 1) T3AMP values.
*
* @param pOi pointer to oi_fits struct to check
* @param pResult pointer to oi_check_result struct to store result in
*
* @return oi_breach level indicating overall test result
*/
oi_breach_level check_t3amp(oi_fits *pOi, oi_check_result *pResult)
{
GList *link;
int i, j;
oi_t3 *pT3;
oi_t3_record t3Rec;
const char desc[] =
"OI_T3 table may contain unnormalised triple product amplitude";
char location[FLEN_VALUE];
init_check_result(pResult);
link = pOi->t3List;
while(link != NULL) {
pT3 = link->data;
for(i=0; i<pT3->numrec; i++) {
t3Rec = pT3->record[i];
if(t3Rec.flag) continue;
for(j=0; j<pT3->nwave; j++) {
/* use one sigma in case error bars are overestimated */
if((t3Rec.t3amp[j] - 1.0) > 1*t3Rec.t3amperr[j]) {
g_snprintf(location, FLEN_VALUE, "OI_T3 #%d record %d channel %d",
g_list_position(pOi->t3List, link)+1, i+1, j+1);
set_result(pResult, OI_BREACH_NOT_OIFITS, desc, location);
}
}
}
link = link->next;
}
return pResult->level;
}
/**
* Check targets have unique identifiers
*
* @param pOi pointer to oi_fits struct to check
* @param pResult pointer to oi_check_result struct to store result in
*
* @return oi_breach level indicating overall test result
*/
oi_breach_level check_unique_targets(oi_fits *pOi, oi_check_result *pResult)
{
int i;
GList *idList;
target *pTarget;
const char desc[] = "Duplicate value of TARGET keyword in OI_TARGET";
char location[FLEN_VALUE];
init_check_result(pResult);
idList = NULL;
for(i=0; i<pOi->targets.ntarget; i++) {
pTarget = &pOi->targets.targ[i];
if(g_list_find_custom(idList, pTarget->target,
(GCompareFunc) strcmp) != NULL) {
/* Duplicate TARGET value */
g_snprintf(location, FLEN_VALUE, "TARGET_ID=%d TARGET='%s'",
pTarget->target_id, pTarget->target);
set_result(pResult, OI_BREACH_WARNING, desc, location);
} else {
/* prepend to list as faster than appending and order doesn't matter */
idList = g_list_prepend(idList, pTarget->target);
}
}
g_list_free(idList);
return pResult->level;
}
/**
* Check all referenced targets are present in OI_TARGET.
*
* @param pOi pointer to oi_fits struct to check
* @param pResult pointer to oi_check_result struct to store result in
*
* @return oi_breach level indicating overall test result
*/
oi_breach_level check_targets_present(oi_fits *pOi, oi_check_result *pResult)
{
GList *link;
int i;
oi_vis *pVis;
oi_vis2 *pVis2;
oi_t3 *pT3;
const char desc[] = "Reference to missing target record";
char location[FLEN_VALUE];
init_check_result(pResult);
/* Check OI_VIS tables */
link = pOi->visList;
while(link != NULL) {
pVis = link->data;
for(i=0; i<pVis->numrec; i++) {
if(oi_fits_lookup_target(pOi, pVis->record[i].target_id) == NULL) {
g_snprintf(location, FLEN_VALUE, "OI_VIS #%d record %d",
g_list_position(pOi->visList, link)+1, i+1);
set_result(pResult, OI_BREACH_NOT_OIFITS, desc, location);
}
}
link = link->next;
}
/* Check OI_VIS2 tables */
link = pOi->vis2List;
while(link != NULL) {
pVis2 = link->data;
for(i=0; i<pVis2->numrec; i++) {
if(oi_fits_lookup_target(pOi, pVis2->record[i].target_id) == NULL) {
g_snprintf(location, FLEN_VALUE, "OI_VIS2 #%d record %d",
g_list_position(pOi->vis2List, link)+1, i+1);
set_result(pResult, OI_BREACH_NOT_OIFITS, desc, location);
}
}
link = link->next;
}
/* Check OI_T3 tables */
link = pOi->t3List;
while(link != NULL) {
pT3 = link->data;
for(i=0; i<pT3->numrec; i++) {
if(oi_fits_lookup_target(pOi, pT3->record[i].target_id) == NULL) {
g_snprintf(location, FLEN_VALUE, "OI_T3 #%d record %d",
g_list_position(pOi->t3List, link)+1, i+1);
set_result(pResult, OI_BREACH_NOT_OIFITS, desc, location);
}
}
link = link->next;
}
return pResult->level;
}
static void process_status(json_t * payload) {
char * host_name, *service_description = NULL, *output = NULL;
check_result * newcr = NULL, t;
init_check_result(&t);
t.output_file = NULL;
t.output_file_fp = NULL;
if(get_values(payload,
"host_name", JSON_STRING, 1, &host_name,
"service_description", JSON_STRING, 0, &service_description,
"output", JSON_STRING, 1, &output,
"return_code", JSON_INTEGER, 1, &t.return_code,
"start_time", JSON_TIMEVAL, 0, &t.start_time,
"finish_time", JSON_TIMEVAL, 1, &t.finish_time,
"check_type", JSON_INTEGER, 1, &t.check_type,
"check_options", JSON_INTEGER, 0, &t.check_options,
"scheduled_check", JSON_INTEGER, 0, &t.scheduled_check,
"reschedule_check", JSON_INTEGER, 0, &t.reschedule_check,
"latency", JSON_REAL, 0, &t.latency,
"early_timeout", JSON_INTEGER, 0, &t.early_timeout,
"exited_ok", JSON_INTEGER, 0, &t.exited_ok,
NULL) != 0) {
json_decref(payload);
return;
}
service * service_target = NULL;
if(service_description)
service_target = find_service(host_name, service_description);
host * host_target = find_host(host_name);
if(host_target == NULL || (service_description && !service_target)) {
json_decref(payload);
return;
}
newcr = malloc(sizeof(check_result));
memcpy(newcr, &t, sizeof(check_result));
newcr->host_name = strdup(host_name);
if(service_target) {
newcr->service_description = strdup(service_description);
newcr->object_check_type = SERVICE_CHECK;
}
newcr->output = strdup(output);
json_decref(payload);
#ifdef HAVE_NAGIOS4
newcr->engine = &nagmq_check_engine;
process_check_result(newcr);
#else
#ifdef HAVE_ADD_CHECK_RESULT_ONE
add_check_result_to_list(newcr);
#elif defined(HAVE_ADD_CHECK_RESULT_TWO)
add_check_result_to_list(&check_result_list, newcr);
#endif
#endif
}
/* handle service check events */
static int handle_svc_check( int event_type, void *data ) {
host * hst = NULL;
service * svc = NULL;
char *raw_command=NULL;
char *processed_command=NULL;
nebstruct_service_check_data * svcdata;
int prio = GM_JOB_PRIO_LOW;
check_result * chk_result;
struct timeval core_time;
struct tm next_check;
char buffer1[GM_BUFFERSIZE];
gettimeofday(&core_time,NULL);
gm_log( GM_LOG_TRACE, "handle_svc_check(%i, data)\n", event_type );
svcdata = ( nebstruct_service_check_data * )data;
if ( event_type != NEBCALLBACK_SERVICE_CHECK_DATA )
return NEB_OK;
/* ignore non-initiate service checks */
if ( svcdata->type != NEBTYPE_SERVICECHECK_ASYNC_PRECHECK )
return NEB_OK;
/* get objects and set target function */
if((svc=svcdata->object_ptr)==NULL) {
gm_log( GM_LOG_ERROR, "Service handler received NULL service object pointer.\n" );
return NEBERROR_CALLBACKCANCEL;
}
/* find the host associated with this service */
if((hst=svc->host_ptr)==NULL) {
gm_log( GM_LOG_ERROR, "Service handler received NULL host object pointer.\n" );
return NEBERROR_CALLBACKCANCEL;
}
set_target_queue( hst, svc );
/* local check? */
if(!strcmp( target_queue, "" )) {
gm_log( GM_LOG_DEBUG, "passing by local servicecheck: %s - %s\n", svcdata->host_name, svcdata->service_description);
return NEB_OK;
}
gm_log( GM_LOG_DEBUG, "received job for queue %s: %s - %s\n", target_queue, svcdata->host_name, svcdata->service_description );
temp_buffer[0]='\x0';
/* as we have to intercept service checks so early
* (we cannot cancel checks otherwise)
* we have to do some service check logic here
* taken from checks.c:
*/
/* clear check options - we don't want old check options retained */
svc->check_options=CHECK_OPTION_NONE;
/* unset the freshening flag, otherwise only the first freshness check would be run */
svc->is_being_freshened=FALSE;
/* grab the host and service macro variables */
clear_volatile_macros();
grab_host_macros(hst);
grab_service_macros(svc);
/* get the raw command line */
get_raw_command_line(svc->check_command_ptr,svc->check_command,&raw_command,0);
if(raw_command==NULL){
gm_log( GM_LOG_ERROR, "Raw check command for service '%s' on host '%s' was NULL - aborting.\n", svc->description, svc->host_name );
return NEBERROR_CALLBACKCANCEL;
}
/* process any macros contained in the argument */
process_macros(raw_command, &processed_command, 0);
if(processed_command==NULL) {
gm_log( GM_LOG_ERROR, "Processed check command for service '%s' on host '%s' was NULL - aborting.\n", svc->description, svc->host_name);
my_free(raw_command);
return NEBERROR_CALLBACKCANCEL;
}
/* log latency */
if(mod_gm_opt->debug_level >= GM_LOG_DEBUG) {
localtime_r(&svc->next_check, &next_check);
strftime(buffer1, sizeof(buffer1), "%Y-%m-%d %H:%M:%S", &next_check );
gm_log( GM_LOG_DEBUG, "service: '%s' - '%s', next_check is at %s, latency so far: %i\n", svcdata->host_name, svcdata->service_description, buffer1, ((int)core_time.tv_sec - (int)svc->next_check));
}
/* increment number of service checks that are currently running... */
currently_running_service_checks++;
/* set the execution flag */
svc->is_executing=TRUE;
gm_log( GM_LOG_TRACE, "cmd_line: %s\n", processed_command );
snprintf( temp_buffer,GM_BUFFERSIZE-1,"type=service\nresult_queue=%s\nhost_name=%s\nservice_description=%s\nstart_time=%i.0\nnext_check=%i.0\ncore_time=%i.%i\ntimeout=%d\ncommand_line=%s\n\n\n",
mod_gm_opt->result_queue,
svcdata->host_name,
svcdata->service_description,
(int)svc->next_check,
(int)svc->next_check,
(int)core_time.tv_sec,
(int)core_time.tv_usec,
service_check_timeout,
processed_command
);
uniq[0]='\x0';
snprintf( uniq,GM_BUFFERSIZE-1,"%s-%s", svcdata->host_name, svcdata->service_description);
/* execute forced checks with high prio as they are propably user requested */
//if(check_result_info.check_options & CHECK_OPTION_FORCE_EXECUTION)
// prio = GM_JOB_PRIO_HIGH;
if(add_job_to_queue( &client,
mod_gm_opt->server_list,
target_queue,
(mod_gm_opt->use_uniq_jobs == GM_ENABLED ? uniq : NULL),
temp_buffer,
prio,
GM_DEFAULT_JOB_RETRIES,
mod_gm_opt->transportmode,
TRUE
) == GM_OK) {
gm_log( GM_LOG_TRACE, "handle_svc_check() finished successfully\n" );
}
else {
my_free(raw_command);
my_free(processed_command);
/* unset the execution flag */
svc->is_executing=FALSE;
/* decrement number of host checks that are currently running */
currently_running_service_checks--;
gm_log( GM_LOG_TRACE, "handle_svc_check() finished unsuccessfully\n" );
return NEBERROR_CALLBACKCANCEL;
}
/* clean up */
my_free(raw_command);
my_free(processed_command);
/* orphaned check - submit fake result to mark service as orphaned */
if(mod_gm_opt->orphan_service_checks == GM_ENABLED && svc->check_options & CHECK_OPTION_ORPHAN_CHECK) {
gm_log( GM_LOG_DEBUG, "service check for %s - %s orphaned\n", svc->host_name, svc->description );
if ( ( chk_result = ( check_result * )malloc( sizeof *chk_result ) ) == 0 )
return NEBERROR_CALLBACKCANCEL;
snprintf( temp_buffer,GM_BUFFERSIZE-1,"(service check orphaned, is the mod-gearman worker on queue '%s' running?)\n", target_queue);
init_check_result(chk_result);
chk_result->host_name = strdup( svc->host_name );
chk_result->service_description = strdup( svc->description );
chk_result->scheduled_check = TRUE;
chk_result->reschedule_check = TRUE;
chk_result->output_file = 0;
chk_result->output_file_fp = NULL;
chk_result->output = strdup(temp_buffer);
chk_result->return_code = mod_gm_opt->orphan_return;
chk_result->check_options = CHECK_OPTION_NONE;
chk_result->object_check_type = SERVICE_CHECK;
chk_result->check_type = SERVICE_CHECK_ACTIVE;
chk_result->start_time.tv_sec = (unsigned long)time(NULL);
chk_result->finish_time.tv_sec = (unsigned long)time(NULL);
chk_result->latency = 0;
mod_gm_add_result_to_list( chk_result );
chk_result = NULL;
}
/* tell naemon to not execute */
gm_log( GM_LOG_TRACE, "handle_svc_check() finished successfully -> %d\n", NEBERROR_CALLBACKOVERRIDE );
return NEBERROR_CALLBACKOVERRIDE;
}
/* handle host check events */
static int handle_host_check( int event_type, void *data ) {
nebstruct_host_check_data * hostdata;
char *raw_command=NULL;
char *processed_command=NULL;
host * hst;
check_result * chk_result;
int check_options;
struct timeval core_time;
struct tm next_check;
char buffer1[GM_BUFFERSIZE];
gettimeofday(&core_time,NULL);
gm_log( GM_LOG_TRACE, "handle_host_check(%i)\n", event_type );
if ( mod_gm_opt->do_hostchecks != GM_ENABLED )
return NEB_OK;
hostdata = ( nebstruct_host_check_data * )data;
gm_log( GM_LOG_TRACE, "---------------\nhost Job -> %i, %i\n", event_type, hostdata->type );
if ( event_type != NEBCALLBACK_HOST_CHECK_DATA )
return NEB_OK;
/* ignore non-initiate host checks */
if ( hostdata->type != NEBTYPE_HOSTCHECK_ASYNC_PRECHECK
&& hostdata->type != NEBTYPE_HOSTCHECK_SYNC_PRECHECK)
return NEB_OK;
/* get objects and set target function */
if((hst=hostdata->object_ptr)==NULL) {
gm_log( GM_LOG_ERROR, "Host handler received NULL host object pointer.\n" );
return NEBERROR_CALLBACKCANCEL;
}
set_target_queue( hst, NULL );
/* local check? */
if(!strcmp( target_queue, "" )) {
gm_log( GM_LOG_DEBUG, "passing by local hostcheck: %s\n", hostdata->host_name );
return NEB_OK;
}
gm_log( GM_LOG_DEBUG, "received job for queue %s: %s\n", target_queue, hostdata->host_name );
/* as we have to intercept host checks so early
* (we cannot cancel checks otherwise)
* we have to do some host check logic here
* taken from checks.c:
*/
/* clear check options - we don't want old check options retained */
check_options = hst->check_options;
hst->check_options = CHECK_OPTION_NONE;
/* unset the freshening flag, otherwise only the first freshness check would be run */
hst->is_being_freshened=FALSE;
/* adjust host check attempt */
adjust_host_check_attempt(hst,TRUE);
temp_buffer[0]='\x0';
/* grab the host macro variables */
clear_volatile_macros();
grab_host_macros(hst);
/* get the raw command line */
get_raw_command_line(hst->check_command_ptr,hst->check_command,&raw_command,0);
if(raw_command==NULL){
gm_log( GM_LOG_ERROR, "Raw check command for host '%s' was NULL - aborting.\n",hst->name );
return NEBERROR_CALLBACKCANCEL;
}
/* process any macros contained in the argument */
process_macros(raw_command,&processed_command,0);
if(processed_command==NULL){
gm_log( GM_LOG_ERROR, "Processed check command for host '%s' was NULL - aborting.\n",hst->name);
return NEBERROR_CALLBACKCANCEL;
}
/* log latency */
if(mod_gm_opt->debug_level >= GM_LOG_DEBUG) {
localtime_r(&hst->next_check, &next_check);
strftime(buffer1, sizeof(buffer1), "%Y-%m-%d %H:%M:%S", &next_check );
gm_log( GM_LOG_DEBUG, "host: '%s', next_check is at %s, latency so far: %i\n", hst->name, buffer1, ((int)core_time.tv_sec - (int)hst->next_check));
}
/* increment number of host checks that are currently running */
currently_running_host_checks++;
/* set the execution flag */
hst->is_executing=TRUE;
gm_log( GM_LOG_TRACE, "cmd_line: %s\n", processed_command );
snprintf( temp_buffer,GM_BUFFERSIZE-1,"type=host\nresult_queue=%s\nhost_name=%s\nstart_time=%i.0\nnext_check=%i.0\ntimeout=%d\ncore_time=%i.%i\ncommand_line=%s\n\n\n",
mod_gm_opt->result_queue,
hst->name,
(int)hst->next_check,
(int)hst->next_check,
host_check_timeout,
(int)core_time.tv_sec,
(int)core_time.tv_usec,
processed_command
);
if(add_job_to_queue( &client,
mod_gm_opt->server_list,
target_queue,
(mod_gm_opt->use_uniq_jobs == GM_ENABLED ? hst->name : NULL),
temp_buffer,
GM_JOB_PRIO_NORMAL,
GM_DEFAULT_JOB_RETRIES,
mod_gm_opt->transportmode,
TRUE
) == GM_OK) {
}
else {
my_free(raw_command);
my_free(processed_command);
/* unset the execution flag */
hst->is_executing=FALSE;
/* decrement number of host checks that are currently running */
currently_running_host_checks--;
gm_log( GM_LOG_TRACE, "handle_host_check() finished unsuccessfully -> %d\n", NEBERROR_CALLBACKCANCEL );
return NEBERROR_CALLBACKCANCEL;
}
/* clean up */
my_free(raw_command);
my_free(processed_command);
/* orphaned check - submit fake result to mark host as orphaned */
if(mod_gm_opt->orphan_host_checks == GM_ENABLED && check_options & CHECK_OPTION_ORPHAN_CHECK) {
gm_log( GM_LOG_DEBUG, "host check for %s orphaned\n", hst->name );
if ( ( chk_result = ( check_result * )malloc( sizeof *chk_result ) ) == 0 )
return NEBERROR_CALLBACKCANCEL;
snprintf( temp_buffer,GM_BUFFERSIZE-1,"(host check orphaned, is the mod-gearman worker on queue '%s' running?)\n", target_queue);
init_check_result(chk_result);
chk_result->host_name = strdup( hst->name );
chk_result->scheduled_check = TRUE;
chk_result->reschedule_check = TRUE;
chk_result->output_file = 0;
chk_result->output_file_fp = NULL;
chk_result->output = strdup(temp_buffer);
chk_result->return_code = mod_gm_opt->orphan_return;
chk_result->check_options = CHECK_OPTION_NONE;
chk_result->object_check_type = HOST_CHECK;
chk_result->check_type = HOST_CHECK_ACTIVE;
chk_result->start_time.tv_sec = (unsigned long)time(NULL);
chk_result->finish_time.tv_sec = (unsigned long)time(NULL);
chk_result->latency = 0;
mod_gm_add_result_to_list( chk_result );
chk_result = NULL;
}
/* tell naemon to not execute */
gm_log( GM_LOG_TRACE, "handle_host_check() finished successfully -> %d\n", NEBERROR_CALLBACKOVERRIDE );
return NEBERROR_CALLBACKOVERRIDE;
}
/* 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;
}
/**
* Check for negative error bars.
*
* @param pOi pointer to oi_fits struct to check
* @param pResult pointer to oi_check_result struct to store result in
*
* @return oi_breach level indicating overall test result
*/
oi_breach_level check_flagging(oi_fits *pOi, oi_check_result *pResult)
{
GList *link;
int i, j;
oi_vis *pVis;
oi_vis2 *pVis2;
oi_t3 *pT3;
const char desc[] = "Data table contains negative error bar";
char location[FLEN_VALUE];
init_check_result(pResult);
/* Check OI_VIS tables */
link = pOi->visList;
while(link != NULL) {
pVis = link->data;
for(i=0; i<pVis->numrec; i++) {
if(pVis->record[i].flag) continue;
for(j=0; j<pVis->nwave; j++) {
if(pVis->record[i].visamperr[j] < 0. ||
pVis->record[i].visphierr[j] < 0.) {
g_snprintf(location, FLEN_VALUE, "OI_VIS #%d record %d channel %d",
g_list_position(pOi->visList, link)+1, i+1, j+1);
set_result(pResult, OI_BREACH_NOT_OIFITS, desc, location);
}
}
}
link = link->next;
}
/* Check OI_VIS2 tables */
link = pOi->vis2List;
while(link != NULL) {
pVis2 = link->data;
for(i=0; i<pVis2->numrec; i++) {
if(pVis2->record[i].flag) continue;
for(j=0; j<pVis2->nwave; j++) {
if(pVis2->record[i].vis2err[j] < 0.) {
g_snprintf(location, FLEN_VALUE, "OI_VIS2 #%d record %d channel %d",
g_list_position(pOi->vis2List, link)+1, i+1, j+1);
set_result(pResult, OI_BREACH_NOT_OIFITS, desc, location);
}
}
}
link = link->next;
}
/* Check OI_T3 tables */
link = pOi->t3List;
while(link != NULL) {
pT3 = link->data;
for(i=0; i<pT3->numrec; i++) {
if(pT3->record[i].flag) continue;
for(j=0; j<pT3->nwave; j++) {
if(pT3->record[i].t3amperr[j] < 0. ||
pT3->record[i].t3phierr[j] < 0.) {
g_snprintf(location, FLEN_VALUE, "OI_T3 #%d record %d channel %d",
g_list_position(pOi->t3List, link)+1, i+1, j+1);
set_result(pResult, OI_BREACH_NOT_OIFITS, desc, location);
}
}
}
link = link->next;
}
return pResult->level;
}
