static int receive_command(int sd, int events, void *discard)
{
int ioc_ret;
char *buf;
unsigned long size;
if (!ioc) {
ioc = iocache_create(512 * 1024);
}
ioc_ret = iocache_read(ioc, sd);
/* master closed the connection, so we exit */
if (ioc_ret == 0) {
iobroker_close(iobs, sd);
exit_worker();
}
if (ioc_ret < 0) {
/* XXX: handle this somehow */
}
#if 0
/* debug-volley */
buf = iocache_use_size(ioc, ioc_ret);
write(master_sd, buf, ioc_ret);
return 0;
#endif
/*
* now loop over all inbound messages in the iocache.
* Since KV_TERMINATOR is a nul-byte, they're separated by 3 nuls
*/
while ((buf = iocache_use_delim(ioc, MSG_DELIM, MSG_DELIM_LEN_RECV, &size))) {
struct kvvec *kvv;
/* we must copy vars here, as we preserve them for the response */
kvv = buf2kvvec(buf, (unsigned int)size, KV_SEP, PAIR_SEP, KVVEC_COPY);
if (kvv)
spawn_job(kvv);
}
return 0;
}
/* 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;
}
int main(int argc, char **argv)
{
int i, j;
struct kvvec *kvv, *kvv2, *kvv3;
struct kvvec_buf *kvvb, *kvvb2;
struct kvvec k = KVVEC_INITIALIZER;
t_set_colors(0);
t_start("key/value vector tests");
kvv = kvvec_create(1);
kvv2 = kvvec_create(1);
kvv3 = kvvec_create(1);
add_vars(kvv, test_data, 1239819);
add_vars(kvv, (const char **)argv + 1, argc - 1);
kvvec_sort(kvv);
kvvec_foreach(kvv, NULL, walker);
/* kvvec2buf -> buf2kvvec -> kvvec2buf -> buf2kvvec conversion */
kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC);
kvv3 = buf2kvvec(kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_COPY);
kvvb2 = kvvec2buf(kvv3, KVSEP, PAIRSEP, OVERALLOC);
buf2kvvec_prealloc(kvv2, kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_ASSIGN);
kvvec_foreach(kvv2, kvv, walker);
kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC);
test(kvv->kv_pairs == kvv2->kv_pairs, "pairs should be identical");
for (i = 0; i < kvv->kv_pairs; i++) {
struct key_value *kv1, *kv2;
kv1 = &kvv->kv[i];
if (i >= kvv2->kv_pairs) {
t_fail("missing var %d in kvv2", i);
printf("[%s=%s] (%d+%d)\n", kv1->key, kv1->value, kv1->key_len, kv1->value_len);
continue;
}
kv2 = &kvv2->kv[i];
if (!test(!kv_compare(kv1, kv2), "kv pair %d must match", i)) {
printf("%d failed: [%s=%s] (%d+%d) != [%s=%s (%d+%d)]\n",
i,
kv1->key, kv1->value, kv1->key_len, kv1->value_len,
kv2->key, kv2->value, kv2->key_len, kv2->value_len);
}
}
test(kvvb2->buflen == kvvb->buflen, "buflens must match");
test(kvvb2->bufsize == kvvb->bufsize, "bufsizes must match");
if (kvvb2->buflen == kvvb->buflen && kvvb2->bufsize == kvvb->bufsize &&
!memcmp(kvvb2->buf, kvvb->buf, kvvb->bufsize))
{
t_pass("kvvec -> buf -> kvvec conversion works flawlessly");
} else {
t_fail("kvvec -> buf -> kvvec conversion failed :'(");
}
free(kvvb->buf);
free(kvvb);
free(kvvb2->buf);
free(kvvb2);
kvvec_destroy(kvv, 1);
kvvec_destroy(kvv3, KVVEC_FREE_ALL);
for (j = 0; pair_term_missing[j]; j++) {
buf2kvvec_prealloc(&k, strdup(pair_term_missing[j]), strlen(pair_term_missing[j]), '=', ';', KVVEC_COPY);
for (i = 0; i < k.kv_pairs; i++) {
struct key_value *kv = &k.kv[i];
test(kv->key_len == kv->value_len, "%d.%d; key_len=%d; value_len=%d (%s = %s)",
j, i, kv->key_len, kv->value_len, kv->key, kv->value);
test(kv->value_len == strlen(kv->value),
"%d.%d; kv->value_len(%d) == strlen(%s)(%d)",
j, i, kv->value_len, kv->value, (int)strlen(kv->value));
}
}
t_end();
return 0;
}
