void
test_pipeline_uniforms (void)
{
TestState state;
init_state (&state);
cogl_framebuffer_orthographic (test_fb,
0, 0,
cogl_framebuffer_get_width (test_fb),
cogl_framebuffer_get_height (test_fb),
-1,
100);
paint (&state);
validate_result ();
/* Try the test again after querying the location of a large
number of uniforms. This should verify that the bitmasks
still work even if they have to allocate a separate array to
store the bits */
init_long_pipeline_state (&state);
paint (&state);
paint_long_pipeline (&state);
validate_result ();
validate_long_pipeline_result ();
destroy_state (&state);
if (cogl_test_verbose ())
g_print ("OK\n");
}
void
test_just_vertex_shader (void)
{
TestState state;
cogl_framebuffer_orthographic (test_fb,
0, 0,
cogl_framebuffer_get_width (test_fb),
cogl_framebuffer_get_height (test_fb),
-1,
100);
/* XXX: we have to push/pop a framebuffer since this test currently
* uses the legacy cogl_rectangle() api. */
cogl_push_framebuffer (test_fb);
paint_legacy (&state);
validate_result (test_fb);
paint (&state);
validate_result (test_fb);
cogl_pop_framebuffer ();
if (cogl_test_verbose ())
g_print ("OK\n");
}
static void
paint (TestState *state)
{
CoglPipeline *pipeline;
paint_test_backface_culling (state, test_fb);
/*
* Now repeat the test but rendered to an offscreen
* framebuffer. Note that by default the conformance tests are
* always run to an offscreen buffer but we might as well have this
* check anyway in case it is being run with COGL_TEST_ONSCREEN=1
*/
paint_test_backface_culling (state, state->offscreen);
/* Copy the result of the offscreen rendering for validation and
* also so we can have visual feedback. */
pipeline = cogl_pipeline_new (test_ctx);
cogl_pipeline_set_layer_texture (pipeline, 0, state->offscreen_tex);
cogl_framebuffer_draw_rectangle (test_fb,
pipeline,
0, TEXTURE_RENDER_SIZE * 16,
state->width,
state->height + TEXTURE_RENDER_SIZE * 16);
cogl_object_unref (pipeline);
validate_result (test_fb, 0);
validate_result (test_fb, 16);
}
bool my_visitor2(int n, node_id ni1[], node_id ni2[], void *usr_data)
{
int *d = (int *)usr_data;
ControlFlowGraph * cfg = (ControlFlowGraph*)d[0];
PCBitSet lib_info = (PCBitSet)d[3];
int startEA = d[1];
if (!lib_info->isset(ni2[0]))
{
extern long found_c;
InterlockedExchangeAdd(&found_c, 1);
printf("1\t0\t%08X\t%s\n", cfg->instructions[ni2[0]].diasm.EIP - cfg->instructions[0].diasm.EIP + startEA, (char*)d[2]);
if (show_dump)
{
//int offset = startEA - cfg->instructions[0].diasm.EIP;
//BasicBlock* bb =
for (int i = 0; i < n; i++)
{
printf("%08X %s\n", cfg->instructions[ni2[i]].diasm.EIP, cfg->instructions[ni2[i]].diasm.CompleteInstr);
}
bool f = validate_result(cfg, n, ni2);
printf(f ? "OK\n" : "Failed\n");
printf("\n\n");
}
lib_info->set(ni2[0]);
}
return false;// is_full;
}
/*
* GPHD_HA_load_nodes
*
* Load the Namenode High-Availability properties set for a given
* HA nameservice from the HDFS client configuration files
* TODO:
* This is a temporary solution that will be removed once the PXF servlet
* will stop using the HDFS namenode/datanodes as a hosting application
* server and will move to an independent stand-alone application server
*/
NNHAConf*
GPHD_HA_load_nodes(const char *nameservice)
{
NNHAConf *conf = load_hdfs_client_config(nameservice);
validate_result(conf);
return conf;
}
void record_full_timings(TimingType & timings,
F functor,
TestConfig & config,
TestData & data)
{
typedef typename TestData::value_type ScalarType;
double result = 0;
functor(data); //startup run (ensures kernel compilation)
for (unsigned int work_groups = config.min_work_groups(); work_groups <= config.max_work_groups(); work_groups *= 2) //iterate over number of work groups (compute units)
{
for (unsigned int local_workers = config.min_local_size(); local_workers <= config.max_local_size(); local_workers *= 2) //iterate over local thread number
{
//set parameter:
set_kernel_params(config.program_name(), config.kernel_name(), work_groups, local_workers);
//std::cout << "Benchmarking kernel " << config.kernel_name() << std::endl;
result = execute(functor, data);
//check for valid result: (kernels have an automatic fallback to smaller values included)
if (!validate_result(config.program_name(), config.kernel_name(), work_groups, local_workers))
{
std::cout << "Kernel start failed for kernel " << config.kernel_name() << " [" << work_groups << " groups, " << local_workers << " per group]" << std::endl;
break;
}
else
timings[result] = std::make_pair(work_groups * local_workers, local_workers);
}
}
}
static void
paint (TestState *state)
{
float stage_viewport[4];
CoglMatrix stage_projection;
CoglMatrix stage_modelview;
paint_test_backface_culling (state);
/*
* Now repeat the test but rendered to an offscreen
* framebuffer. Note that by default the conformance tests are
* always run to an offscreen buffer but we might as well have this
* check anyway in case it is being run with COGL_TEST_ONSCREEN=1
*/
cogl_get_viewport (stage_viewport);
cogl_get_projection_matrix (&stage_projection);
cogl_get_modelview_matrix (&stage_modelview);
cogl_push_framebuffer (state->offscreen);
cogl_set_viewport (stage_viewport[0],
stage_viewport[1],
stage_viewport[2],
stage_viewport[3]);
cogl_set_projection_matrix (&stage_projection);
cogl_set_modelview_matrix (&stage_modelview);
paint_test_backface_culling (state);
cogl_pop_framebuffer ();
/* Incase we want feedback of what was drawn offscreen we draw it
* to the stage... */
cogl_set_source_texture (state->offscreen_tex);
cogl_rectangle (0, TEXTURE_RENDER_SIZE * 16,
stage_viewport[2],
stage_viewport[3] + TEXTURE_RENDER_SIZE * 16);
validate_result (0);
validate_result (16);
}
void
test_cogl_pipeline_uniforms (TestUtilsGTestFixture *fixture,
void *user_data)
{
TestUtilsSharedState *shared_state = user_data;
/* If shaders aren't supported then we can't run the test */
if (cogl_features_available (COGL_FEATURE_SHADERS_GLSL))
{
TestState state;
init_state (&state);
cogl_ortho (/* left, right */
0, cogl_framebuffer_get_width (shared_state->fb),
/* bottom, top */
cogl_framebuffer_get_height (shared_state->fb), 0,
/* z near, far */
-1, 100);
paint (&state);
validate_result ();
/* Try the test again after querying the location of a large
number of uniforms. This should verify that the bitmasks
still work even if they have to allocate a separate array to
store the bits */
init_long_pipeline_state (&state);
paint (&state);
paint_long_pipeline (&state);
validate_result ();
validate_long_pipeline_result ();
destroy_state (&state);
if (g_test_verbose ())
g_print ("OK\n");
}
else if (g_test_verbose ())
g_print ("Skipping\n");
}
static void
on_paint (ClutterActor *actor, TestState *state)
{
int frame_num;
/* XXX: Experiments have shown that for some buggy drivers, when using
* glReadPixels there is some kind of race, so we delay our test for a
* few frames and a few seconds:
*/
/* Need to increment frame first because clutter_stage_read_pixels
fires a redraw */
frame_num = state->frame++;
if (frame_num == 2)
validate_result (state);
else if (frame_num < 2)
g_usleep (G_USEC_PER_SEC);
}
static void
on_paint (ClutterActor *actor, TestState *state)
{
/* Draw a faded blue triangle */
cogl_vertex_buffer_enable (state->buffer, "gl_Color::blue");
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
/* Draw a red triangle */
/* Here we are testing that the disable attribute works; if it doesn't
* the triangle will remain faded blue */
cogl_translate (100, 0, 0);
cogl_vertex_buffer_disable (state->buffer, "gl_Color::blue");
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
/* Draw a faded blue triangle */
/* Here we are testing that the re-enable works; if it doesn't
* the triangle will remain red */
cogl_translate (100, 0, 0);
cogl_vertex_buffer_enable (state->buffer, "gl_Color::blue");
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
/* Draw a textured triangle */
cogl_translate (100, 0, 0);
cogl_vertex_buffer_disable (state->buffer, "gl_Color::blue");
cogl_set_source (state->material);
cogl_material_set_color4ub (state->material, 0xff, 0xff, 0xff, 0xff);
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
validate_result (state);
}
void
test_just_vertex_shader (void)
{
TestState state;
cogl_framebuffer_orthographic (test_fb,
0, 0,
cogl_framebuffer_get_width (test_fb),
cogl_framebuffer_get_height (test_fb),
-1,
100);
paint (&state);
validate_result (test_fb);
if (cogl_test_verbose ())
g_print ("OK\n");
}
static void
on_paint (ClutterActor *actor, TestState *state)
{
/* Draw a faded blue triangle */
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
/* XXX: Experiments have shown that for some buggy drivers, when using
* glReadPixels there is some kind of race, so we delay our test for a
* few frames and a few seconds:
*/
if (state->frame >= 2)
validate_result (state);
else
g_usleep (G_USEC_PER_SEC);
state->frame++;
}
void
test_texture_3d (void)
{
TestState state;
state.fb_width = cogl_framebuffer_get_width (test_fb);
state.fb_height = cogl_framebuffer_get_height (test_fb);
cogl_framebuffer_orthographic (test_fb,
0, 0, /* x_1, y_1 */
state.fb_width, /* x_2 */
state.fb_height /* y_2 */,
-1, 100 /* near/far */);
draw_frame (&state);
validate_result ();
test_multi_texture (&state);
if (cogl_test_verbose ())
g_print ("OK\n");
}
void
test_npot_texture (void)
{
if (test_verbose ())
{
if (cg_has_feature (test_dev, CG_FEATURE_ID_TEXTURE_NPOT))
c_print ("NPOT textures are supported\n");
else
c_print ("NPOT textures are not supported\n");
}
cg_framebuffer_orthographic (test_fb,
0, 0,
cg_framebuffer_get_width (test_fb),
cg_framebuffer_get_height (test_fb),
-1,
100);
paint ();
validate_result ();
if (test_verbose ())
c_print ("OK\n");
}
int main()
{
std::cout << "start readin";
std::cout.flush();
set_data set_data = read_in_set_data("testdatafile");
// set_data set_data = create_random_set_data(29000000,29000000);
std::cout << " --- Done" << std::endl;
std::cout << "init setcover";
std::cout.flush();
set_cover setcover(set_data.set_count,
set_data.uniqu_element_count,
set_data.max_weight,
set_data.all_element_count,
set_data.element_size_lookup
);
for(int i = 0; i < set_data.set_count; i++){
setcover.add_set(i+1, set_data.set_sizes[i]
,(const unsigned int*)set_data.sets[i],
(const unsigned short*)set_data.weights[i],
set_data.set_sizes[i]);
free(set_data.sets[i]);
free(set_data.weights[i]);
}
std::cout << " --- Done" << std::endl;
// readInData("/Users/aluucard/Documents/workspace/graphcluster/graphcluster/test_data/graphdb_final",
// "/Users/aluucard/Documents/workspace/graphcluster/graphcluster/test_data/graphdb_final.index");
std::cout << "execute setcover" ;
std::cout.flush();
std::list<set *> ret= setcover.execute_set_cover();
std::cout << " --- Done" << std::endl;
std::cout << "validate result ";
if(validate_result(&ret,set_data.uniqu_element_count))
std::cout << " VALID ";
else
std::cout << " NOT VALID ";
std::cout << " --- Done" << std::endl;
std::cout << "write result setcover" << std::endl;
std::cout.flush();
std::list<set *>::const_iterator iterator;
for (iterator = ret.begin(); iterator != ret.end(); ++iterator) {
std::cout << "set id " << (*iterator)->set_id << " Element: ";
set::element * element =(*iterator)->elements;
do{
std::cout << element->element_id << ", ";
}while((element=element->next)!=NULL);
std::cout << std::endl;
}
}
void poll_host(int host_id) {
char query1[BUFSIZE];
char query2[BUFSIZE];
char *query3;
char query4[BUFSIZE];
char errstr[512];
int num_rows;
int host_status;
int assert_fail = 0;
char *poll_result = NULL;
char logmessage[LOGSIZE];
char update_sql[BUFSIZE];
reindex_t *reindex;
target_t *entry;
host_t *host;
ping_t *ping;
MYSQL mysql;
MYSQL_RES *result;
MYSQL_ROW row;
/* allocate host and ping structures with appropriate values */
host = (host_t *) malloc(sizeof(host_t));
ping = (ping_t *) malloc(sizeof(ping_t));
#ifndef OLD_MYSQL
mysql_thread_init();
#endif
snprintf(query1, sizeof(query1), "select action,hostname,snmp_community,snmp_version,snmp_username,snmp_password,rrd_name,rrd_path,arg1,arg2,arg3,local_data_id,rrd_num,snmp_port,snmp_timeout from poller_item where host_id=%i order by rrd_path,rrd_name", host_id);
snprintf(query2, sizeof(query2), "select id, hostname,snmp_community,snmp_version,snmp_port,snmp_timeout,status,status_event_count,status_fail_date,status_rec_date,status_last_error,min_time,max_time,cur_time,avg_time,total_polls,failed_polls,availability from host where id=%i", host_id);
snprintf(query4, sizeof(query4), "select data_query_id,action,op,assert_value,arg1 from poller_reindex where host_id=%i", host_id);
db_connect(set.dbdb, &mysql);
/* get data about this host */
result = db_query(&mysql, query2);
num_rows = (int)mysql_num_rows(result);
if (num_rows != 1) {
snprintf(logmessage, LOGSIZE, "Host[%i] ERROR: Unknown Host ID", host_id);
cacti_log(logmessage);
return;
}
row = mysql_fetch_row(result);
/* populate host structure */
host->id = atoi(row[0]);
if (row[1] != NULL) snprintf(host->hostname, sizeof(host->hostname), "%s", row[1]);
if (row[2] != NULL) snprintf(host->snmp_community, sizeof(host->snmp_community), "%s", row[2]);
host->snmp_version = atoi(row[3]);
host->snmp_port = atoi(row[4]);
host->snmp_timeout = atoi(row[5]);
if (row[6] != NULL) host->status = atoi(row[6]);
host->status_event_count = atoi(row[7]);
snprintf(host->status_fail_date, sizeof(host->status_fail_date), "%s", row[8]);
snprintf(host->status_rec_date, sizeof(host->status_rec_date), "%s", row[9]);
snprintf(host->status_last_error, sizeof(host->status_last_error), "%s", row[10]);
host->min_time = atof(row[11]);
host->max_time = atof(row[12]);
host->cur_time = atof(row[13]);
host->avg_time = atof(row[14]);
host->total_polls = atoi(row[15]);
host->failed_polls = atoi(row[16]);
host->availability = atof(row[17]);
host->ignore_host = 0;
/* initialize SNMP */
snmp_host_init(host);
/* perform a check to see if the host is alive by polling it's SysDesc
* if the host down from an snmp perspective, don't poll it.
* function sets the ignore_host bit */
if ((set.availability_method == AVAIL_SNMP) && (host->snmp_community == "")) {
update_host_status(HOST_UP, host, ping, set.availability_method);
if (set.verbose >= POLLER_VERBOSITY_MEDIUM) {
snprintf(logmessage, LOGSIZE, "Host[%s] No host availability check possible for '%s'\n", host->id, host->hostname);
cacti_log(logmessage);
}
} else {
if (ping_host(host, ping) == HOST_UP) {
update_host_status(HOST_UP, host, ping, set.availability_method);
} else {
host->ignore_host = 1;
update_host_status(HOST_DOWN, host, ping, set.availability_method);
}
}
/* update host table */
snprintf(update_sql, sizeof(update_sql), "update host set status='%i',status_event_count='%i', status_fail_date='%s',status_rec_date='%s',status_last_error='%s',min_time='%f',max_time='%f',cur_time='%f',avg_time='%f',total_polls='%i',failed_polls='%i',availability='%.4f' where id='%i'\n",
host->status,
host->status_event_count,
host->status_fail_date,
host->status_rec_date,
host->status_last_error,
host->min_time,
host->max_time,
host->cur_time,
host->avg_time,
host->total_polls,
host->failed_polls,
host->availability,
host->id);
db_insert(&mysql, update_sql);
/* do the reindex check for this host */
if (!host->ignore_host) {
reindex = (reindex_t *) malloc(sizeof(reindex_t));
result = db_query(&mysql, query4);
num_rows = (int)mysql_num_rows(result);
if (num_rows > 0) {
if (set.verbose == POLLER_VERBOSITY_DEBUG) {
snprintf(logmessage, LOGSIZE, "Host[%i] RECACHE: Processing %i items in the auto reindex cache for '%s'\n", host->id, num_rows, host->hostname);
cacti_log(logmessage);
}
while ((row = mysql_fetch_row(result))) {
assert_fail = 0;
reindex->data_query_id = atoi(row[0]);
reindex->action = atoi(row[1]);
if (row[2] != NULL) snprintf(reindex->op, sizeof(reindex->op), "%s", row[2]);
if (row[3] != NULL) snprintf(reindex->assert_value, sizeof(reindex->assert_value), "%s", row[3]);
if (row[4] != NULL) snprintf(reindex->arg1, sizeof(reindex->arg1), "%s", row[4]);
switch(reindex->action) {
case POLLER_ACTION_SNMP: /* snmp */
poll_result = snmp_get(host, reindex->arg1);
break;
case POLLER_ACTION_SCRIPT: /* script (popen) */
poll_result = exec_poll(host, reindex->arg1);
break;
}
/* assume ok if host is up and result wasn't obtained */
if (!strcmp(poll_result,"U")) {
assert_fail = 0;
} else if ((!strcmp(reindex->op, "=")) && (strcmp(reindex->assert_value,poll_result) != 0)) {
snprintf(logmessage, LOGSIZE, "ASSERT: '%s=%s' failed. Recaching host '%s', data query #%i\n", reindex->assert_value, poll_result, host->hostname, reindex->data_query_id);
cacti_log(logmessage);
query3 = (char *)malloc(128);
snprintf(query3, 128, "insert into poller_command (poller_id,time,action,command) values (0,NOW(),%i,'%i:%i')", POLLER_COMMAND_REINDEX, host_id, reindex->data_query_id);
db_insert(&mysql, query3);
free(query3);
assert_fail = 1;
} else if ((!strcmp(reindex->op, ">")) && (strtoll(reindex->assert_value, (char **)NULL, 10) <= strtoll(poll_result, (char **)NULL, 10))) {
snprintf(logmessage, LOGSIZE, "ASSERT: '%s>%s' failed. Recaching host '%s', data query #%i\n", reindex->assert_value, poll_result, host->hostname, reindex->data_query_id);
cacti_log(logmessage);
query3 = (char *)malloc(128);
snprintf(query3, 128, "insert into poller_command (poller_id,time,action,command) values (0,NOW(),%i,'%i:%i')", POLLER_COMMAND_REINDEX, host_id, reindex->data_query_id);
db_insert(&mysql, query3);
free(query3);
assert_fail = 1;
} else if ((!strcmp(reindex->op, "<")) && (strtoll(reindex->assert_value, (char **)NULL, 10) >= strtoll(poll_result, (char **)NULL, 10))) {
snprintf(logmessage, LOGSIZE, "ASSERT: '%s<%s' failed. Recaching host '%s', data query #%i\n", reindex->assert_value, poll_result, host->hostname, reindex->data_query_id);
cacti_log(logmessage);
query3 = (char *)malloc(128);
snprintf(query3, 128, "insert into poller_command (poller_id,time,action,command) values (0,NOW(),%i,'%i:%i')", POLLER_COMMAND_REINDEX, host_id, reindex->data_query_id);
db_insert(&mysql, query3);
free(query3);
assert_fail = 1;
}
/* update 'poller_reindex' with the correct information if:
* 1) the assert fails
* 2) the OP code is > or < meaning the current value could have changed without causing
* the assert to fail */
if ((assert_fail == 1) || (!strcmp(reindex->op, ">")) || (!strcmp(reindex->op, ">"))) {
query3 = (char *)malloc(255);
snprintf(query3, 255, "update poller_reindex set assert_value='%s' where host_id='%i' and data_query_id='%i' and arg1='%s'", poll_result, host_id, reindex->data_query_id, reindex->arg1);
db_insert(&mysql, query3);
free(query3);
}
free(poll_result);
}
}
}
/* retreive each hosts polling items from poller cache */
entry = (target_t *) malloc(sizeof(target_t));
result = db_query(&mysql, query1);
num_rows = (int)mysql_num_rows(result);
while ((row = mysql_fetch_row(result)) && (!host->ignore_host)) {
/* initialize monitored object */
entry->target_id = 0;
entry->action = atoi(row[0]);
if (row[1] != NULL) snprintf(entry->hostname, sizeof(entry->hostname), "%s", row[1]);
if (row[2] != NULL) {
snprintf(entry->snmp_community, sizeof(entry->snmp_community), "%s", row[2]);
} else {
snprintf(entry->snmp_community, sizeof(entry->snmp_community), "%s", "");
}
entry->snmp_version = atoi(row[3]);
if (row[4] != NULL) snprintf(entry->snmp_username, sizeof(entry->snmp_username), "%s", row[4]);
if (row[5] != NULL) snprintf(entry->snmp_password, sizeof(entry->snmp_password), "%s", row[5]);
if (row[6] != NULL) snprintf(entry->rrd_name, sizeof(entry->rrd_name), "%s", row[6]);
if (row[7] != NULL) snprintf(entry->rrd_path, sizeof(entry->rrd_path), "%s", row[7]);
if (row[8] != NULL) snprintf(entry->arg1, sizeof(entry->arg1), "%s", row[8]);
if (row[9] != NULL) snprintf(entry->arg2, sizeof(entry->arg2), "%s", row[9]);
if (row[10] != NULL) snprintf(entry->arg3, sizeof(entry->arg3), "%s", row[10]);
entry->local_data_id = atoi(row[11]);
entry->rrd_num = atoi(row[12]);
entry->snmp_port = atoi(row[13]);
entry->snmp_timeout = atoi(row[14]);
snprintf(entry->result, sizeof(entry->result), "%s", "U");
if (!host->ignore_host) {
switch(entry->action) {
case POLLER_ACTION_SNMP: /* raw SNMP poll */
poll_result = snmp_get(host, entry->arg1);
snprintf(entry->result, sizeof(entry->result), "%s", poll_result);
free(poll_result);
if (host->ignore_host) {
snprintf(logmessage, LOGSIZE, "Host[%i] ERROR: SNMP timeout detected [%i milliseconds], ignoring host '%s'\n", host_id, host->snmp_timeout, host->hostname);
cacti_log(logmessage);
snprintf(entry->result, sizeof(entry->result), "%s", "U");
} else {
/* remove double or single quotes from string */
strncpy(entry->result, strip_quotes(entry->result), sizeof(entry->result));
/* detect erroneous non-numeric result */
if (!is_numeric(entry->result)) {
strncpy(errstr, entry->result,sizeof(errstr));
snprintf(logmessage, LOGSIZE, "Host[%i] WARNING: Result from SNMP not valid. Partial Result: %.20s...\n", host_id, errstr);
cacti_log(logmessage);
strncpy(entry->result, "U", sizeof(entry->result));
}
}
if (set.verbose >= POLLER_VERBOSITY_MEDIUM) {
snprintf(logmessage, LOGSIZE, "Host[%i] SNMP: v%i: %s, dsname: %s, oid: %s, value: %s\n", host_id, host->snmp_version, host->hostname, entry->rrd_name, entry->arg1, entry->result);
cacti_log(logmessage);
}
break;
case POLLER_ACTION_SCRIPT: /* execute script file */
poll_result = exec_poll(host, entry->arg1);
snprintf(entry->result, sizeof(entry->result), "%s", poll_result);
free(poll_result);
/* remove double or single quotes from string */
strncpy(entry->result, strip_quotes(entry->result), sizeof(entry->result));
/* detect erroneous result. can be non-numeric */
if (!validate_result(entry->result)) {
strncpy(errstr, (char *) strip_string_crlf(entry->result),sizeof(errstr));
snprintf(logmessage, LOGSIZE, "Host[%i] WARNING: Result from SCRIPT not valid. Partial Result: %.20s...\n", host_id, errstr);
cacti_log(logmessage);
strncpy(entry->result, "U", sizeof(entry->result));
}
if (set.verbose >= POLLER_VERBOSITY_MEDIUM) {
snprintf(logmessage, LOGSIZE, "Host[%i] SCRIPT: %s, output: %s\n", host_id, entry->arg1, entry->result);
cacti_log(logmessage);
}
break;
case POLLER_ACTION_PHP_SCRIPT_SERVER: /* execute script server */
poll_result = php_cmd(entry->arg1);
snprintf(entry->result, sizeof(entry->result), "%s", poll_result);
free(poll_result);
/* remove double or single quotes from string */
strncpy(entry->result, strip_quotes(entry->result), sizeof(entry->result));
/* detect erroneous result. can be non-numeric */
if (!validate_result(entry->result)) {
strncpy(errstr, entry->result, sizeof(errstr));
snprintf(logmessage, LOGSIZE, "Host[%i] WARNING: Result from SERVER not valid. Partial Result: %.20s...\n", host_id, errstr);
cacti_log(logmessage);
strncpy(entry->result, "U", sizeof(entry->result));
}
if (set.verbose >= POLLER_VERBOSITY_MEDIUM) {
snprintf(logmessage, LOGSIZE, "Host[%i] SERVER: %s, output: %s\n", host_id, entry->arg1, entry->result);
cacti_log(logmessage);
}
break;
default: /* unknown action, generate error */
snprintf(logmessage, LOGSIZE, "Host[%i] ERROR: Unknown Poller Action: %s\n", host_id, entry->arg1);
cacti_log(logmessage);
break;
}
}
if (entry->result != NULL) {
/* format database insert string */
query3 = (char *)malloc(sizeof(entry->result) + sizeof(entry->local_data_id) + 128);
snprintf(query3, (sizeof(entry->result) + sizeof(entry->local_data_id) + 128), "insert into poller_output (local_data_id,rrd_name,time,output) values (%i,'%s','%s','%s')", entry->local_data_id, entry->rrd_name, start_datetime, entry->result);
db_insert(&mysql, query3);
free(query3);
}
}
/* cleanup memory and prepare for function exit */
snmp_host_cleanup(host);
free(entry);
free(host);
free(ping);
mysql_free_result(result);
#ifndef OLD_MYSQL
mysql_thread_end();
#endif
mysql_close(&mysql);
if (set.verbose == POLLER_VERBOSITY_DEBUG) {
snprintf(logmessage, LOGSIZE, "Host[%i] DEBUG: HOST COMPLETE: About to Exit Host Polling Thread Function\n", host_id);
cacti_log(logmessage);
}
}
