int main(int argc, char **argv)
{
unsigned long k;
struct test_data *td;
t_set_colors(0);
t_start("fanout tests");
run_tests(10, 64);
run_tests(512, 64);
run_tests(64, 64);
run_tests(511, 17);
destroyed = 0;
fot = fanout_create(512);
ok_int(fanout_remove(fot, 12398) == NULL, 1,
"remove on empty table must yield NULL");
ok_int(fanout_get(fot, 123887987) == NULL, 1,
"get on empty table must yield NULL");
for (k = 0; k < 16385; k++) {
struct test_data *tdata = calloc(1, sizeof(*td));
tdata->key = k;
asprintf(&tdata->name, "%lu", k);
fanout_add(fot, k, tdata);
}
td = fanout_get(fot, k - 1);
ok_int(td != NULL, 1, "get must get what add inserts");
ok_int(fanout_remove(fot, k + 1) == NULL, 1,
"remove on non-inserted key must yield NULL");
ok_int(fanout_get(fot, k + 1) == NULL, 1,
"get on non-inserted must yield NULL");
fanout_destroy(fot, pdest);
ok_int((int)destroyed, (int)k, "destroy counter while free()'ing");
return t_end();
}
static void run_tests(int ntests, int fo_size)
{
struct tcase *tc;
unsigned long last_ptr, *ptr;
int i, added = 0, removed = 0;
fanout_table *fo;
last_ptr = ntests;
fo = fanout_create(fo_size);
tc = calloc(ntests, sizeof(*tc));
for (i = 0; i < ntests; i++) {
tc[i].value = i;
if (!fanout_add(fo, tc[i].key, &tc[i].value))
added++;
}
ok_int(added, ntests, "Adding stuff must work");
while ((ptr = (unsigned long *)fanout_remove(fo, 0))) {
ok_int((int)*ptr, (int)last_ptr - 1, "Removing a bunch of them");
removed++;
last_ptr = *ptr;
}
ok_int(added, removed, "Removing should work as well as adding");
fanout_destroy(fo, destructor);
ok_int(destroyed, 0, "Expected no entries in destructor");
fo = fanout_create(fo_size);
for (i = 0; i < ntests; i++) {
tc[i].value = i;
if (!fanout_add(fo, tc[i].key, &tc[i].value))
added++;
}
fanout_destroy(fo, destructor);
ok_int(destroyed, ntests, "Expected ntest entries in destructor");
destroyed = 0;
free(tc);
}
void report_fanout_set_parameter(struct Ferret *ferret, const char *name, const char *value)
{
if (ferret->report_fanout == 0)
ferret->report_fanout = fanout_create();
if (strcmp(name, "addr") == 0) {
struct ParsedIpAddress addr;
unsigned offset = 0;
//unsigned is_exclude = 0;
struct filter *filters;
unsigned *filter_count;
if (value[0] == '!') {
//is_exclude = 1;
filters = ferret->report_fanout->exclude_filters;
filter_count = &ferret->report_fanout->exclude_count;
value++;
} else {
filters = ferret->report_fanout->include_filters;
filter_count = &ferret->report_fanout->include_count;
}
if (parse_ip_address(value, &offset, (unsigned)strlen(value), &addr)) {
if (*filter_count > sizeof(ferret->report_fanout->include_filters)/sizeof(ferret->report_fanout->include_filters[0]))
fprintf(stderr, "too many: report.fanout.%s=%s\n", name, value);
else if (addr.version != 4) {
fprintf(stderr, "only support IPv4 addresses for this feature at this time\n");
} else {
int64_t mask = -1;
mask ^= 0xFFFFFFFF;
mask >>= addr.prefix_length;
filters[*filter_count].ip = addr.address[0]<<24 | addr.address[1]<<16 | addr.address[2]<<8 | addr.address[3];
filters[*filter_count].mask = (unsigned)mask;
(*filter_count)++;
}
} else
fprintf(stderr, "bad IP address: report.fanout.%s=%s\n", name, value);
} else
/* a service for registering workers */
static int register_worker(int sd, char *buf, unsigned int len)
{
int i, is_global = 1;
struct kvvec *info;
struct wproc_worker *worker;
logit(NSLOG_INFO_MESSAGE, TRUE, "wproc: Registry request: %s\n", buf);
if (!(worker = calloc(1, sizeof(*worker)))) {
logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: Failed to allocate worker: %s\n", strerror(errno));
return 500;
}
info = buf2kvvec(buf, len, '=', ';', 0);
if (info == NULL) {
free(worker);
logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: Failed to parse registration request\n");
return 500;
}
worker->sd = sd;
worker->ioc = iocache_create(1 * 1024 * 1024);
iobroker_unregister(nagios_iobs, sd);
iobroker_register(nagios_iobs, sd, worker, handle_worker_result);
for(i = 0; i < info->kv_pairs; i++) {
struct key_value *kv = &info->kv[i];
if (!strcmp(kv->key, "name")) {
worker->name = strdup(kv->value);
}
else if (!strcmp(kv->key, "pid")) {
worker->pid = atoi(kv->value);
}
else if (!strcmp(kv->key, "max_jobs")) {
worker->max_jobs = atoi(kv->value);
}
else if (!strcmp(kv->key, "plugin")) {
struct wproc_list *command_handlers;
is_global = 0;
if (!(command_handlers = dkhash_get(specialized_workers, kv->value, NULL))) {
command_handlers = calloc(1, sizeof(struct wproc_list));
command_handlers->wps = calloc(1, sizeof(struct wproc_worker**));
command_handlers->len = 1;
command_handlers->wps[0] = worker;
dkhash_insert(specialized_workers, strdup(kv->value), NULL, command_handlers);
}
else {
command_handlers->len++;
command_handlers->wps = realloc(command_handlers->wps, command_handlers->len * sizeof(struct wproc_worker**));
command_handlers->wps[command_handlers->len - 1] = worker;
}
worker->wp_list = command_handlers;
}
}
if (!worker->max_jobs) {
/*
* each worker uses two filedescriptors per job, one to
* connect to the master and about 13 to handle libraries
* and memory allocation, so this guesstimate shouldn't
* be too far off (for local workers, at least).
*/
worker->max_jobs = (iobroker_max_usable_fds() / 2) - 50;
}
worker->jobs = fanout_create(worker->max_jobs);
if (is_global) {
workers.len++;
workers.wps = realloc(workers.wps, workers.len * sizeof(struct wproc_worker *));
workers.wps[workers.len - 1] = worker;
worker->wp_list = &workers;
}
wproc_num_workers_online++;
kvvec_destroy(info, 0);
nsock_printf_nul(sd, "OK");
/* signal query handler to release its iocache for this one */
return QH_TAKEOVER;
}
/* initializes scheduled downtime data */
int initialize_downtime_data(void) {
log_debug_info(DEBUGL_FUNCTIONS, 0, "initialize_downtime_data()\n");
dt_fanout = fanout_create(16384);
next_downtime_id = 1;
return dt_fanout ? OK : ERROR;
}
