void noit_lua_init_dns() {
int i;
const struct dns_nameval *nv;
struct dns_ctx *pctx;
/* HASH the rr types */
for(i=0, nv = dns_type_index(i); nv->name; nv = dns_type_index(++i))
noit_hash_store(&dns_rtypes,
nv->name, strlen(nv->name),
(void *)nv);
/* HASH the class types */
for(i=0, nv = dns_class_index(i); nv->name; nv = dns_class_index(++i))
noit_hash_store(&dns_ctypes,
nv->name, strlen(nv->name),
(void *)nv);
eventer_name_callback("lua/dns_eventer", noit_lua_dns_eventer);
eventer_name_callback("lua/dns_timeouts", noit_lua_dns_timeouts);
if (dns_init(NULL, 0) < 0 || (pctx = dns_new(NULL)) == NULL) {
noitL(noit_error, "Unable to initialize dns subsystem\n");
}
else
dns_free(pctx);
}
void noit_http_rest_init() {
noit_http_init();
eventer_name_callback("noit_wire_rest_api/1.0", noit_http_rest_handler);
eventer_name_callback("http_rest_api", noit_http_rest_raw_handler);
noit_http_rest_load_rules();
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_DELETE,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_MERGE,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_GET,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_HEAD,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_POST,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_PUT,
noit_http_rest_handler);
}
static int dns_onload(noit_image_t *self) {
nlerr = noit_log_stream_find("error/dns");
nldeb = noit_log_stream_find("debug/dns");
if(!nlerr) nlerr = noit_stderr;
if(!nldeb) nldeb = noit_debug;
eventer_name_callback("dns/dns_eventer_callback", dns_eventer_callback);
eventer_name_callback("dns/dns_check_timeout", dns_check_timeout);
eventer_name_callback("dns/dns_invoke_timeouts", dns_invoke_timeouts);
return 0;
}
static int ssh2_onload(noit_image_t *self) {
nlerr = noit_log_stream_find("error/ssh2");
nldeb = noit_log_stream_find("debug/ssh2");
if(!nlerr) nlerr = noit_stderr;
if(!nldeb) nldeb = noit_debug;
eventer_name_callback("http/ssh2_connect_complete", ssh2_connect_complete);
eventer_name_callback("http/ssh2_drive_session", ssh2_drive_session);
return 0;
}
void
noit_listener_init(const char *toplevel) {
nlerr = noit_log_stream_find("error/listener");
nldeb = noit_log_stream_find("debug/listener");
if(!nlerr) nlerr = noit_error;
if(!nldeb) nldeb = noit_debug;
eventer_name_callback_ext("noit_listener_acceptor", noit_listener_acceptor,
noit_listener_details, NULL);
eventer_name_callback("noit_listener_accept_ssl", noit_listener_accept_ssl);
eventer_name_callback("control_dispatch", noit_control_dispatch);
noit_listener_reconfig(toplevel);
}
void
stratcon_realtime_http_init(const char *toplevel) {
eventer_name_callback("stratcon_realtime_http",
stratcon_realtime_http_handler);
eventer_name_callback("stratcon_realtime_recv",
stratcon_realtime_recv_handler);
assert(noit_http_rest_register_auth(
"GET", "/data/",
"^((?:" UUID_REGEX "(?:@\\d+)?)(?:/" UUID_REGEX "(?:@\\d+)?)*)$",
rest_stream_data, noit_http_rest_access
) == 0);
assert(noit_http_rest_register_auth(
"GET", "/", "^(.*)$", noit_rest_simple_file_handler, noit_http_rest_access
) == 0);
}
void
noit_capabilities_listener_init() {
eventer_name_callback("capabilities_transit/1.0", noit_capabilities_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CAPABILITIES_SERVICE,
noit_capabilities_handler);
}
void
noit_jlog_listener_init() {
xmlNodePtr node;
eventer_name_callback("log_transit/1.0", noit_jlog_handler);
mtev_control_dispatch_delegate(mtev_control_dispatch,
NOIT_JLOG_DATA_FEED,
noit_jlog_handler);
mtev_control_dispatch_delegate(mtev_control_dispatch,
NOIT_JLOG_DATA_TEMP_FEED,
noit_jlog_handler);
node = mtev_conf_get_section(NULL, "//logs");
if (node) {
mtev_conf_get_int(node, "//jlog/max_msg_batch_lines", &MAX_ROWS_AT_ONCE);
mtev_conf_get_int(node, "//jlog/default_mseconds_between_batches", &DEFAULT_MSECONDS_BETWEEN_BATCHES);
mtev_conf_get_int(node, "//jlog/default_transient_mseconds_between_batches", &DEFAULT_TRANSIENT_MSECONDS_BETWEEN_BATCHES);
}
mtevAssert(mtev_http_rest_register_auth(
"GET", "/", "^feed$",
rest_show_feed, mtev_http_rest_client_cert_auth
) == 0);
mtevAssert(mtev_http_rest_register_auth(
"DELETE", "/feed/", "^(.+)$",
rest_delete_feed, mtev_http_rest_client_cert_auth
) == 0);
mtevAssert(mtev_http_rest_register_auth(
"PUT", "/", "^feed$",
rest_add_feed, mtev_http_rest_client_cert_auth
) == 0);
}
void
noit_livestream_listener_init() {
noit_register_logops("noit_livestream", &noit_livestream_logio_ops);
eventer_name_callback("livestream_transit/1.0", noit_livestream_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_LIVESTREAM_DATA_FEED,
noit_livestream_handler);
}
static int mysql_onload(mtev_image_t *self) {
nlerr = mtev_log_stream_find("error/mysql");
nldeb = mtev_log_stream_find("debug/mysql");
if(!nlerr) nlerr = noit_stderr;
if(!nldeb) nldeb = noit_debug;
eventer_name_callback("mysql/mysql_drive_session", mysql_drive_session);
return 0;
}
void
mtev_capabilities_listener_init() {
eventer_name_callback("capabilities_transit/1.0", mtev_capabilities_handler);
mtev_control_dispatch_delegate(mtev_control_dispatch,
MTEV_CAPABILITIES_SERVICE,
mtev_capabilities_handler);
assert(mtev_http_rest_register("GET", "/", "capa(\\.json)?",
mtev_capabilities_rest) == 0);
}
static int test_abort_onload(noit_image_t *self) {
nlerr = noit_log_stream_find("error/test_abort");
nldeb = noit_log_stream_find("debug/test_abort");
if(!nlerr) nlerr = noit_stderr;
if(!nldeb) nldeb = noit_debug;
eventer_name_callback("http/test_abort_drive_session", test_abort_drive_session);
return 0;
}
static int postgres_onload(noit_image_t *self) {
nlerr = noit_log_stream_find("error/postgres");
nldeb = noit_log_stream_find("debug/postgres");
if(!nlerr) nlerr = noit_stderr;
if(!nldeb) nldeb = noit_debug;
eventer_name_callback("http/postgres_drive_session", postgres_drive_session);
return 0;
}
static int selfcheck_onload(noit_image_t *self) {
nlerr = noit_log_stream_find("error/selfcheck");
nldeb = noit_log_stream_find("debug/selfcheck");
if(!nlerr) nlerr = noit_stderr;
if(!nldeb) nldeb = noit_debug;
eventer_name_callback("selfcheck/selfcheck_log_size", selfcheck_log_size);
return 0;
}
void
noit_console_init(const char *progname) {
if(progname) {
char buff[32];
snprintf(buff, sizeof(buff), "%s# ", progname);
noit_console_set_default_prompt(buff);
}
el_multi_init();
signal(SIGTTOU, SIG_IGN);
noit_register_logops("noit_console", &noit_console_logio_ops);
eventer_name_callback("noit_console", noit_console_handler);
}
void noit_http_rest_init() {
noit_http_init();
eventer_name_callback("noit_wire_rest_api/1.0", noit_http_rest_handler);
eventer_name_callback("http_rest_api", noit_http_rest_raw_handler);
/* some default mime types */
#define ADD_MIME_TYPE(ext, type) \
noit_hash_store(&mime_type_defaults, strdup(ext), strlen(ext), strdup(type))
ADD_MIME_TYPE("html", "text/html");
ADD_MIME_TYPE("htm", "text/html");
ADD_MIME_TYPE("js", "text/javascript");
ADD_MIME_TYPE("css", "text/css");
ADD_MIME_TYPE("ico", "image/x-icon");
ADD_MIME_TYPE("gif", "image/gif");
ADD_MIME_TYPE("png", "image/png");
ADD_MIME_TYPE("jpg", "image/jpg");
ADD_MIME_TYPE("jpeg", "image/jpg");
ADD_MIME_TYPE("json", "application/javascript");
noit_http_rest_load_rules();
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_DELETE,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_MERGE,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_GET,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_HEAD,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_POST,
noit_http_rest_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_CONTROL_PUT,
noit_http_rest_handler);
}
void
noit_poller_init() {
noit_check_tools_init();
noit_skiplist_init(&polls_by_name);
noit_skiplist_set_compare(&polls_by_name, __check_name_compare,
__check_name_compare);
noit_skiplist_init(&watchlist);
noit_skiplist_set_compare(&watchlist, __watchlist_compare,
__watchlist_compare);
register_console_check_commands();
eventer_name_callback("check_recycle_bin_processor",
check_recycle_bin_processor);
eventer_add_in_s_us(check_recycle_bin_processor, NULL, 60, 0);
noit_poller_reload(NULL);
}
void
noit_jlog_listener_init() {
eventer_name_callback("log_transit/1.0", noit_jlog_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_JLOG_DATA_FEED,
noit_jlog_handler);
noit_control_dispatch_delegate(noit_control_dispatch,
NOIT_JLOG_DATA_TEMP_FEED,
noit_jlog_handler);
assert(noit_http_rest_register_auth(
"GET", "/", "^feed$",
rest_show_feed, noit_http_rest_client_cert_auth
) == 0);
assert(noit_http_rest_register_auth(
"DELETE", "/feed/", "^(.+)$",
rest_delete_feed, noit_http_rest_client_cert_auth
) == 0);
}
void noit_check_resolver_init() {
eventer_t e;
if(dns_init(NULL, 0) < 0)
noitL(noit_error, "dns initialization failed.\n");
dns_ctx = dns_new(NULL);
if(dns_init(dns_ctx, 0) != 0 ||
dns_open(dns_ctx) < 0) {
noitL(noit_error, "dns initialization failed.\n");
}
eventer_name_callback("dns_cache_callback", dns_cache_callback);
dns_set_tmcbck(dns_ctx, dns_cache_utm_fn, dns_ctx);
e = eventer_alloc();
e->mask = EVENTER_READ | EVENTER_EXCEPTION;
e->closure = dns_ctx;
e->callback = dns_cache_callback;
e->fd = dns_sock(dns_ctx);
eventer_add(e);
noit_skiplist_init(&nc_dns_cache);
noit_skiplist_set_compare(&nc_dns_cache, name_lookup, name_lookup_k);
noit_skiplist_add_index(&nc_dns_cache, refresh_idx, refresh_idx_k);
noit_check_resolver_loop(NULL, 0, NULL, NULL);
register_console_dns_cache_commands();
}
static int external_onload(noit_image_t *self) {
eventer_name_callback("external/timeout", external_timeout);
eventer_name_callback("external/handler", external_handler);
return 0;
}
void
noit_check_tools_init() {
noit_check_tools_shared_init();
eventer_name_callback("noit_check_recur_handler", noit_check_recur_handler);
}
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;
}
void noit_check_resolver_init() {
int cnt;
mtev_conf_section_t *servers, *searchdomains;
eventer_t e;
if(dns_init(NULL, 0) < 0)
mtevL(noit_error, "dns initialization failed.\n");
dns_ctx = dns_new(NULL);
if(dns_init(dns_ctx, 0) != 0) {
mtevL(noit_error, "dns initialization failed.\n");
exit(-1);
}
/* Optional servers */
servers = mtev_conf_get_sections(NULL, "//resolver//server", &cnt);
if(cnt) {
int i;
char server[128];
dns_add_serv(dns_ctx, NULL); /* reset */
for(i=0;i<cnt;i++) {
if(mtev_conf_get_stringbuf(servers[i], "self::node()",
server, sizeof(server))) {
if(dns_add_serv(dns_ctx, server) < 0) {
mtevL(noit_error, "Failed adding DNS server: %s\n", server);
}
}
}
free(servers);
}
searchdomains = mtev_conf_get_sections(NULL, "//resolver//search", &cnt);
if(cnt) {
int i;
char search[128];
dns_add_srch(dns_ctx, NULL); /* reset */
for(i=0;i<cnt;i++) {
if(mtev_conf_get_stringbuf(searchdomains[i], "self::node()",
search, sizeof(search))) {
if(dns_add_srch(dns_ctx, search) < 0) {
mtevL(noit_error, "Failed adding DNS search path: %s\n", search);
}
else if(dns_search_flag) dns_search_flag = 0; /* enable search */
}
}
free(searchdomains);
}
if(mtev_conf_get_int(NULL, "//resolver/@ndots", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_NDOTS, cnt);
if(mtev_conf_get_int(NULL, "//resolver/@ntries", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_NTRIES, cnt);
if(mtev_conf_get_int(NULL, "//resolver/@timeout", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_TIMEOUT, cnt);
if(dns_open(dns_ctx) < 0) {
mtevL(noit_error, "dns open failed.\n");
exit(-1);
}
eventer_name_callback("dns_cache_callback", dns_cache_callback);
dns_set_tmcbck(dns_ctx, dns_cache_utm_fn, dns_ctx);
e = eventer_alloc();
e->mask = EVENTER_READ | EVENTER_EXCEPTION;
e->closure = dns_ctx;
e->callback = dns_cache_callback;
e->fd = dns_sock(dns_ctx);
eventer_add(e);
mtev_skiplist_init(&nc_dns_cache);
mtev_skiplist_set_compare(&nc_dns_cache, name_lookup, name_lookup_k);
mtev_skiplist_add_index(&nc_dns_cache, refresh_idx, refresh_idx_k);
/* maybe load it from cache */
if(noit_resolver_cache_load_hook_exists()) {
struct timeval now;
char *key;
void *data;
int len;
gettimeofday(&now, NULL);
while(noit_resolver_cache_load_hook_invoke(&key, &data, &len) == MTEV_HOOK_CONTINUE) {
dns_cache_node *n;
n = calloc(1, sizeof(*n));
if(dns_cache_node_deserialize(n, data, len) >= 0) {
n->target = strdup(key);
/* if the TTL indicates that it will expire in less than 60 seconds
* (including stuff that should have already expired), then fudge
* the last_updated time to make it expire some random time within
* the next 60 seconds.
*/
if(n->last_needed > now.tv_sec || n->last_updated > now.tv_sec)
break; /* impossible */
n->last_needed = now.tv_sec;
if(n->last_updated + n->ttl < now.tv_sec + 60) {
int fudge = MIN(60, n->ttl) + 1;
n->last_updated = now.tv_sec - n->ttl + (lrand48() % fudge);
}
DCLOCK();
mtev_skiplist_insert(&nc_dns_cache, n);
DCUNLOCK();
n = NULL;
}
else {
mtevL(noit_error, "Failed to deserialize resolver cache record.\n");
}
if(n) dns_cache_node_free(n);
if(key) free(key);
if(data) free(data);
}
}
noit_check_resolver_loop(NULL, 0, NULL, NULL);
register_console_dns_cache_commands();
mtev_hash_init(&etc_hosts_cache);
noit_check_etc_hosts_cache_refresh(NULL, 0, NULL, NULL);
}
