static int noit_httptrap_init(noit_module_t *self) {
const char *config_val;
httptrap_mod_config_t *conf;
conf = noit_module_get_userdata(self);
conf->asynch_metrics = mtev_true;
if(mtev_hash_retr_str(conf->options,
"asynch_metrics", strlen("asynch_metrics"),
(const char **)&config_val)) {
if(!strcasecmp(config_val, "false") || !strcasecmp(config_val, "off"))
conf->asynch_metrics = mtev_false;
}
httptrap_surrogate = mtev_false;
if(mtev_hash_retr_str(conf->options,
"surrogate", strlen("surrogate"),
(const char **)&config_val)) {
if(!strcasecmp(config_val, "true") || !strcasecmp(config_val, "on"))
httptrap_surrogate = mtev_true;
}
noit_module_set_userdata(self, conf);
/* register rest handler */
mtev_http_rest_register("PUT", "/module/httptrap/",
"^(" UUID_REGEX ")/([^/]*).*$",
rest_httptrap_handler);
mtev_http_rest_register("POST", "/module/httptrap/",
"^(" UUID_REGEX ")/([^/]*).*$",
rest_httptrap_handler);
return 0;
}
static int noit_statsd_config(noit_module_t *self, noit_hash_table *options) {
statsd_mod_config_t *conf;
conf = noit_module_get_userdata(self);
if(conf) {
if(conf->options) {
noit_hash_destroy(conf->options, free, free);
free(conf->options);
}
}
else
conf = calloc(1, sizeof(*conf));
conf->options = options;
noit_module_set_userdata(self, conf);
return 1;
}
static int external_config(noit_module_t *self, noit_hash_table *options) {
external_data_t *data;
data = noit_module_get_userdata(self);
if(data) {
if(data->options) {
noit_hash_destroy(data->options, free, free);
free(data->options);
}
}
else
data = calloc(1, sizeof(*data));
data->options = options;
if(!data->options) data->options = calloc(1, sizeof(*data->options));
noit_module_set_userdata(self, data);
return 1;
}
static int external_init(noit_module_t *self) {
external_data_t *data;
data = noit_module_get_userdata(self);
if(!data) data = malloc(sizeof(*data));
data->nlerr = noit_log_stream_find("error/external");
data->nldeb = noit_log_stream_find("debug/external");
data->jobq = calloc(1, sizeof(*data->jobq));
eventer_jobq_init(data->jobq, "external");
data->jobq->backq = eventer_default_backq();
eventer_jobq_increase_concurrency(data->jobq);
if(socketpair(AF_UNIX, SOCK_STREAM, 0, data->pipe_n2e) != 0 ||
socketpair(AF_UNIX, SOCK_STREAM, 0, data->pipe_e2n) != 0) {
noitL(noit_error, "external: pipe() failed: %s\n", strerror(errno));
return -1;
}
data->child = fork();
if(data->child == -1) {
/* No child, bail. */
noitL(noit_error, "external: fork() failed: %s\n", strerror(errno));
return -1;
}
/* parent must close the read side of n2e and the write side of e2n */
/* The child must do the opposite */
close(data->pipe_n2e[(data->child == 0) ? 1 : 0]);
close(data->pipe_e2n[(data->child == 0) ? 0 : 1]);
/* Now the parent must set its bits non-blocking, the child need not */
if(data->child != 0) {
/* in the parent */
if(eventer_set_fd_nonblocking(data->pipe_e2n[0]) == -1) {
close(data->pipe_n2e[1]);
close(data->pipe_e2n[0]);
noitL(noit_error,
"external: could not set pipe non-blocking: %s\n",
strerror(errno));
return -1;
}
eventer_t newe;
newe = eventer_alloc();
newe->fd = data->pipe_e2n[0];
newe->mask = EVENTER_READ | EVENTER_EXCEPTION;
newe->callback = external_handler;
newe->closure = self;
eventer_add(newe);
}
else {
const char *user = NULL, *group = NULL;
if(data->options) {
noit_hash_retr_str(data->options, "user", 4, &user);
noit_hash_retr_str(data->options, "group", 4, &group);
}
noit_security_usergroup(user, group, noit_false);
exit(external_child(data));
}
noit_module_set_userdata(self, data);
return 0;
}
static int noit_statsd_init(noit_module_t *self) {
unsigned short port = 8125;
int packets_per_cycle = 100;
int payload_len = 256*1024;
struct sockaddr_in skaddr;
int sockaddr_len;
const char *config_val;
statsd_mod_config_t *conf;
conf = noit_module_get_userdata(self);
eventer_name_callback("statsd/statsd_handler", statsd_handler);
if(noit_hash_retr_str(conf->options, "check", strlen("check"),
(const char **)&config_val)) {
if(uuid_parse((char *)config_val, conf->primary) != 0)
noitL(noit_error, "statsd check isn't a UUID\n");
conf->primary_active = 1;
conf->check = NULL;
}
if(noit_hash_retr_str(conf->options, "port", strlen("port"),
(const char **)&config_val)) {
port = atoi(config_val);
}
conf->port = port;
if(noit_hash_retr_str(conf->options, "packets_per_cycle",
strlen("packets_per_cycle"),
(const char **)&config_val)) {
packets_per_cycle = atoi(config_val);
}
conf->packets_per_cycle = packets_per_cycle;
conf->payload_len = payload_len;
conf->payload = malloc(conf->payload_len);
if(!conf->payload) {
noitL(noit_error, "statsd malloc() failed\n");
return -1;
}
conf->ipv4_fd = socket(PF_INET, NE_SOCK_CLOEXEC|SOCK_DGRAM, IPPROTO_UDP);
if(conf->ipv4_fd < 0) {
noitL(noit_error, "statsd: socket failed: %s\n", strerror(errno));
return -1;
}
else {
if(eventer_set_fd_nonblocking(conf->ipv4_fd)) {
close(conf->ipv4_fd);
conf->ipv4_fd = -1;
noitL(noit_error,
"collectd: could not set socket non-blocking: %s\n",
strerror(errno));
return -1;
}
}
memset(&skaddr, 0, sizeof(skaddr));
skaddr.sin_family = AF_INET;
skaddr.sin_addr.s_addr = htonl(INADDR_ANY);
skaddr.sin_port = htons(conf->port);
sockaddr_len = sizeof(skaddr);
if(bind(conf->ipv4_fd, (struct sockaddr *)&skaddr, sockaddr_len) < 0) {
noitL(noit_error, "bind failed[%d]: %s\n", conf->port, strerror(errno));
close(conf->ipv4_fd);
return -1;
}
if(conf->ipv4_fd >= 0) {
eventer_t newe;
newe = eventer_alloc();
newe->fd = conf->ipv4_fd;
newe->mask = EVENTER_READ | EVENTER_EXCEPTION;
newe->callback = statsd_handler;
newe->closure = self;
eventer_add(newe);
}
conf->ipv6_fd = socket(AF_INET6, NE_SOCK_CLOEXEC|SOCK_DGRAM, IPPROTO_UDP);
if(conf->ipv6_fd < 0) {
noitL(noit_error, "statsd: IPv6 socket failed: %s\n",
strerror(errno));
}
else {
if(eventer_set_fd_nonblocking(conf->ipv6_fd)) {
close(conf->ipv6_fd);
conf->ipv6_fd = -1;
noitL(noit_error,
"statsd: could not set socket non-blocking: %s\n",
strerror(errno));
}
else {
struct sockaddr_in6 skaddr6;
struct in6_addr in6addr_any;
sockaddr_len = sizeof(skaddr6);
memset(&skaddr6, 0, sizeof(skaddr6));
skaddr6.sin6_family = AF_INET6;
memset(&in6addr_any, 0, sizeof(in6addr_any));
skaddr6.sin6_addr = in6addr_any;
skaddr6.sin6_port = htons(conf->port);
if(bind(conf->ipv6_fd, (struct sockaddr *)&skaddr6, sockaddr_len) < 0) {
noitL(noit_error, "bind(IPv6) failed[%d]: %s\n",
conf->port, strerror(errno));
close(conf->ipv6_fd);
conf->ipv6_fd = -1;
}
}
}
if(conf->ipv6_fd >= 0) {
eventer_t newe;
newe = eventer_alloc();
newe->fd = conf->ipv6_fd;
newe->mask = EVENTER_READ | EVENTER_EXCEPTION;
newe->callback = statsd_handler;
newe->closure = self;
eventer_add(newe);
}
noit_module_set_userdata(self, conf);
return 0;
}
