static eventer_t eventer_kqueue_impl_remove(eventer_t e) {
eventer_t removed = NULL;
if(e->mask & EVENTER_ASYNCH) {
mtevFatal(mtev_error, "error in eventer_kqueue_impl_remove: got unexpected EVENTER_ASYNCH mask\n");
}
if(e->mask & (EVENTER_READ | EVENTER_WRITE | EVENTER_EXCEPTION)) {
ev_lock_state_t lockstate;
lockstate = acquire_master_fd(e->fd);
mtevL(eventer_deb, "kqueue: remove(%d)\n", e->fd);
if(e == master_fds[e->fd].e) {
removed = e;
master_fds[e->fd].e = NULL;
if(e->mask & (EVENTER_READ | EVENTER_EXCEPTION))
ke_change(e->fd, EVFILT_READ, EV_DELETE | EV_DISABLE, e);
if(e->mask & (EVENTER_WRITE))
ke_change(e->fd, EVFILT_WRITE, EV_DELETE | EV_DISABLE, e);
} else
mtevL(eventer_deb, "kqueue: remove(%d) failed.\n", e->fd);
release_master_fd(e->fd, lockstate);
}
else if(e->mask & EVENTER_TIMER) {
removed = eventer_remove_timed(e);
}
else if(e->mask & EVENTER_RECURRENT) {
removed = eventer_remove_recurrent(e);
}
else {
mtevFatal(mtev_error, "error in eventer_kqueue_impl_remove: got unknown mask (0x%04x)\n",
e->mask);
}
return removed;
}
static void eventer_ports_impl_add(eventer_t e) {
mtevAssert(e->mask);
ev_lock_state_t lockstate;
const char *cbname;
cbname = eventer_name_for_callback_e(e->callback, e);
if(e->mask & EVENTER_ASYNCH) {
mtevL(eventer_deb, "debug: eventer_add asynch (%s)\n", cbname ? cbname : "???");
eventer_add_asynch(NULL, e);
return;
}
/* Recurrent delegation */
if(e->mask & EVENTER_RECURRENT) {
mtevL(eventer_deb, "debug: eventer_add recurrent (%s)\n", cbname ? cbname : "???");
eventer_add_recurrent(e);
return;
}
/* Timed events are simple */
if(e->mask & EVENTER_TIMER) {
eventer_add_timed(e);
return;
}
/* file descriptor event */
mtevL(eventer_deb, "debug: eventer_add fd (%s,%d,0x%04x)\n", cbname ? cbname : "???", e->fd, e->mask);
lockstate = acquire_master_fd(e->fd);
mtevAssert(e->whence.tv_sec == 0 && e->whence.tv_usec == 0);
master_fds[e->fd].e = e;
alter_fd(e, e->mask);
release_master_fd(e->fd, lockstate);
}
static lua_module_closure_t *noit_lua_setup_lmc(noit_module_t *mod, const char **obj) {
lua_module_closure_t *lmc;
struct module_conf *mc;
struct module_tls_conf *mtlsc;
mc = mtev_image_get_userdata(&mod->hdr);
if(obj) *obj = mc->object;
lmc = pthread_getspecific(mc->c->key);
if(lmc == NULL) {
int rv;
lmc = calloc(1, sizeof(*lmc));
lmc->pending = calloc(1, sizeof(*lmc->pending));
mtev_hash_init(lmc->pending);
lmc->owner = pthread_self();
lmc->resume = noit_lua_check_resume;
pthread_setspecific(mc->c->key, lmc);
mtevL(nldeb, "lua_state[%s]: new state\n", mod->hdr.name);
lmc->lua_state = mtev_lua_open(mod->hdr.name, lmc,
mc->c->script_dir, mc->c->cpath);
require(lmc->lua_state, rv, noit);
}
mtlsc = __get_module_tls_conf(&mod->hdr);
if(!mtlsc->loaded) {
if(mod->hdr.onload(&mod->hdr) == -1) {
return NULL;
}
mtlsc->loaded = 1;
}
mtevL(nldeb, "lua_state[%s]: %p\n", mod->hdr.name, lmc->lua_state);
return lmc;
}
int write_out_backing_fd(int ofd, int bfd) {
char *mmap_buf;
u_int16_t outlen;
struct stat buf;
if(fstat(bfd, &buf) == -1) {
mtevL(nldeb, "external: fstat error: %s\n", strerror(errno));
goto bail;
}
/* Our output length is limited to 64k (including a \0) */
/* So, we'll limit the mapping of the file to 0xfffe */
if(buf.st_size > 0xfffe) outlen = 0xfffe;
else outlen = buf.st_size & 0xffff;
/* If we have no length, we can skip all this nonsense */
if(outlen == 0) goto bail;
mmap_buf = mmap(NULL, outlen, PROT_READ, MAP_SHARED, bfd, 0);
if(mmap_buf == (char *)-1) {
mtevL(nldeb, "external: mmap error: %s\n", strerror(errno));
goto bail;
}
outlen++; /* no null on the end, but we're reporting one */
assert_write(ofd, &outlen, sizeof(outlen));
outlen--; /* set it back to write and munmap */
assert_write(ofd, mmap_buf, outlen);
assert_write(ofd, "", 1);
munmap(mmap_buf, outlen);
return outlen+1;
bail:
outlen = 1;
assert_write(ofd, &outlen, sizeof(outlen));
assert_write(ofd, "", 1);
return 1;
}
static int
generate_dh_params(eventer_t e, int mask, void *cl, struct timeval *now) {
int bits = (int)(intptr_t)cl;
if(mask != EVENTER_ASYNCH_WORK) return 0;
switch(bits) {
case 1024:
if(!dh1024_tmp) dh1024_tmp = load_dh_params(dh1024_file);
if(!dh1024_tmp) {
mtevL(mtev_notice, "Generating 1024 bit DH parameters.\n");
dh1024_tmp = DH_generate_parameters(1024, 2, NULL, NULL);
mtevL(mtev_notice, "Finished generating 1024 bit DH parameters.\n");
save_dh_params(dh1024_tmp, dh1024_file);
}
break;
case 2048:
if(!dh2048_tmp) dh2048_tmp = load_dh_params(dh2048_file);
if(!dh2048_tmp) {
mtevL(mtev_notice, "Generating 2048 bit DH parameters.\n");
dh2048_tmp = DH_generate_parameters(2048, 2, NULL, NULL);
mtevL(mtev_notice, "Finished generating 2048 bit DH parameters.\n");
save_dh_params(dh2048_tmp, dh2048_file);
}
break;
default:
mtevFatal(mtev_error, "Unexpected DH parameter request: %d\n", bits);
}
return 0;
}
static void
stratcon_datastore_journal(struct sockaddr *remote,
const char *remote_cn, char *line) {
interim_journal_t *ij = NULL;
char uuid_str[UUID_STR_LEN+1], *cp1, *cp2;
char rtype[256];
const char *fqdn = NULL, *dsn = NULL;
int storagenode_id = 0;
uuid_t checkid;
if(!line) {
mtevL(noit_error, "Error: Line not found for %s in stratcon_datastore_journal\n", remote_cn);
return;
}
cp1 = strchr(line, '\t');
*rtype = '\0';
if(cp1 && cp1 - line < sizeof(rtype) - 1) {
memcpy(rtype, line, cp1 - line);
rtype[cp1 - line] = '\0';
}
/* if it is a UUID based thing, find the storage node */
switch(*rtype) {
case 'C':
case 'S':
case 'M':
case 'D':
case 'B':
case 'H':
if((cp1 = strchr(cp1+1, '\t')) != NULL &&
(cp2 = strchr(cp1+1, '\t')) != NULL &&
(cp2-cp1 >= UUID_STR_LEN)) {
strlcpy(uuid_str, cp2 - UUID_STR_LEN, sizeof(uuid_str));
if(!uuid_parse(uuid_str, checkid)) {
ingestor->storage_node_lookup(uuid_str, remote_cn, NULL,
&storagenode_id, NULL,
&fqdn, &dsn);
ij = interim_journal_get(remote, remote_cn, storagenode_id, fqdn);
}
}
break;
case 'n':
ij = interim_journal_get(remote,remote_cn,0,NULL);
break;
default:
mtevL(noit_error, "Error: Line has bad type for %s in stratcon_datastore_journal (%s)\n", remote_cn, line);
break;
}
if(!ij) {
mtevL(ingest_err, "%d\t%s\n", storagenode_id, line);
}
else {
int len;
len = write(ij->fd, line, strlen(line));
if(len < 0) {
mtevL(noit_error, "write to %s failed: %s\n",
ij->filename, strerror(errno));
}
}
free(line);
return;
}
static int
noit_lua_module_onload(mtev_image_t *img) {
int rv;
lua_State *L;
lua_module_closure_t *lmc;
struct module_conf *mc;
mc = mtev_image_get_userdata(img);
lmc = lmc_tls_get(img);
L = lmc->lua_state;
if(!L) return -1;
lua_getglobal(L, "require");
lua_pushstring(L, mc->object);
rv = lua_pcall(L, 1, 1, 0);
if(rv) {
int i;
mtevL(nlerr, "lua: %s.onload failed\n", mc->object);
i = lua_gettop(L);
if(i>0) {
if(lua_isstring(L, i)) {
const char *err;
size_t len;
err = lua_tolstring(L, i, &len);
mtevL(nlerr, "lua: %s\n", err);
}
}
lua_pop(L,i);
return -1;
}
lua_pop(L, lua_gettop(L));
mtev_lua_pushmodule(L, mc->object);
if(lua_isnil(L, -1)) {
lua_pop(L, 1);
mtevL(nlerr, "lua: no such object %s\n", mc->object);
return -1;
}
lua_getfield(L, -1, "onload");
lua_remove(L, -2);
if(!lua_isfunction(L, -1)) {
lua_pop(L, 1);
/* No onload */
return 0;
}
noit_lua_setup_module(L, (noit_module_t *)img);
lua_pcall(L, 1, 1, 0);
if(lua_isnumber(L, -1)) {
int rv;
rv = lua_tointeger(L, -1);
lua_pop(L, 1);
return rv;
}
mtevL(nlerr, "%s.onload must return a integer not %s (%s)\n", mc->object, mtev_lua_type_name(lua_type(L,-1)), lua_tostring(L,-1));
lua_pop(L,1);
return -1;
}
void mtev_dso_post_init(void) {
if(dso_post_init_hook_invoke() == MTEV_HOOK_ABORT) {
mtevL(mtev_stderr, "Module post initialization phase failed.\n");
mtev_dso_load_failure_count++;
}
if(mtev_log_final_resolve() == mtev_false) {
mtevL(mtev_stderr, "Some loggers remain disconnected.\n");
}
}
static int
statsd_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
noit_module_t *self = (noit_module_t *)closure;
int packets_per_cycle;
statsd_mod_config_t *conf;
noit_check_t *parent = NULL;
conf = noit_module_get_userdata(self);
if(conf->primary_active) parent = noit_poller_lookup(conf->primary);
packets_per_cycle = MAX(conf->packets_per_cycle, 1);
for( ; packets_per_cycle > 0; packets_per_cycle--) {
noit_check_t *checks[MAX_CHECKS];
int nchecks = 0;
char ip[INET6_ADDRSTRLEN];
union {
struct sockaddr_in in;
struct sockaddr_in6 in6;
} addr;
socklen_t addrlen = sizeof(addr);
ssize_t len;
len = recvfrom(e->fd, conf->payload, conf->payload_len-1, 0,
(struct sockaddr *)&addr, &addrlen);
if(len < 0) {
if(errno != EAGAIN)
mtevL(nlerr, "statsd: recvfrom() -> %s\n", strerror(errno));
break;
}
switch(addr.in.sin_family) {
case AF_INET:
addrlen = sizeof(struct sockaddr_in);
inet_ntop(AF_INET, &((struct sockaddr_in *)&addr)->sin_addr, ip, addrlen);
break;
case AF_INET6:
addrlen = sizeof(struct sockaddr_in6);
inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&addr)->sin6_addr, ip, addrlen);
break;
default:
ip[0] = '\0';
}
conf->payload[len] = '\0';
nchecks = 0;
if(*ip)
nchecks = noit_poller_lookup_by_ip_module(ip, self->hdr.name,
checks, MAX_CHECKS-1);
mtevL(nldeb, "statsd(%d bytes) from '%s' -> %d checks%s\n", (int)len,
ip, (int)nchecks, parent ? " + a parent" : "");
if(parent) checks[nchecks++] = parent;
if(nchecks)
statsd_handle_payload(checks, nchecks, conf->payload, len);
}
return EVENTER_READ | EVENTER_EXCEPTION;
}
/*
* Helpers to create and destroy our context.
*/
static void
ssl_ctx_cache_node_free(ssl_ctx_cache_node *node) {
mtev_atomic32_t endval;
if(!node) return;
endval = mtev_atomic_dec32(&node->refcnt);
if(endval == 0) {
mtevL(eventer_deb, "ssl_ctx_cache_node_free(%p -> %d) freeing\n", node, endval);
SSL_CTX_free(node->internal_ssl_ctx);
free(node->key);
free(node);
}
else {
mtevL(eventer_deb, "ssl_ctx_cache_node_free(%p -> %d)\n", node, endval);
}
}
static int
check_test_sweeper(eventer_t e, int mask, void *closure,
struct timeval *now) {
int left = 0;
mtev_skiplist_node *iter = NULL;
sweeper_event = NULL;
iter = mtev_skiplist_getlist(&in_progress);
while(iter) {
struct check_test_closure *cl = iter->data;
/* advance here, we might delete */
mtev_skiplist_next(&in_progress,&iter);
if(NOIT_CHECK_DISABLED(cl->check)) {
if(NOIT_CHECK_SHOULD_RESOLVE(cl->check))
noit_check_resolve(cl->check);
if(NOIT_CHECK_RESOLVED(cl->check)) {
noit_module_t *m = noit_module_lookup(cl->check->module);
cl->check->flags &= ~NP_DISABLED;
if(NOIT_CHECK_SHOULD_RESOLVE(cl->check))
mtevL(nldeb, "translated to %s\n", cl->check->target_ip);
if(m) m->initiate_check(m, cl->check, 1, NULL);
}
left++;
}
else if(NOIT_CHECK_RUNNING(cl->check)) left++;
else
mtev_skiplist_remove(&in_progress, cl->restc,
(mtev_freefunc_t)rest_test_check_result);
}
if(left) check_test_schedule_sweeper();
return 0;
}
static int
child_main() {
/* reload our config, to make sure we have the most current */
if(mtev_conf_load(NULL) == -1) {
mtevL(mtev_error, "Cannot load config: '%s'\n", config_file);
exit(2);
}
eventer_init();
mtev_console_init(APPNAME);
mtev_http_rest_init();
mtev_capabilities_listener_init();
mtev_events_rest_init();
mtev_listener_init(APPNAME);
mtev_dso_init();
mtev_dso_post_init();
mtev_http_rest_register("GET", "/", "^(.*)$", my_rest_handler);
/* for 'echo-protocol' see websocket_client.js */
mtev_http_rest_websocket_register("/", "^(.*)$", "echo-protocol", my_websocket_msg_handler);
/* Lastly, spin up the event loop */
eventer_loop();
return 0;
}
int amqp_send_header(amqp_connection_state_t state) {
int ret = eintr_safe_write(state->sockfd, header(), 8);
if (ret < 0) {
mtevL(mtev_error, "Failed to write header in amqp_send_header, size 8\n");
}
return ret;
}
static void eventer_epoll_impl_update(eventer_t e, int mask) {
struct epoll_event _ev;
int ctl_op = EPOLL_CTL_MOD;
if(e->mask & EVENTER_TIMER) {
eventer_update_timed(e,mask);
return;
}
memset(&_ev, 0, sizeof(_ev));
_ev.data.fd = e->fd;
if(e->mask == 0) ctl_op = EPOLL_CTL_ADD;
e->mask = mask;
if(e->mask & (EVENTER_READ | EVENTER_WRITE | EVENTER_EXCEPTION)) {
struct epoll_spec *spec;
spec = eventer_get_spec_for_event(e);
if(e->mask & EVENTER_READ) _ev.events |= (EPOLLIN|EPOLLPRI);
if(e->mask & EVENTER_WRITE) _ev.events |= (EPOLLOUT);
if(e->mask & EVENTER_EXCEPTION) _ev.events |= (EPOLLERR|EPOLLHUP);
mtevL(eventer_deb, "epoll_ctl(%d, %s, %d)\n", spec->epoll_fd,
ctl_op == EPOLL_CTL_ADD ? "add" : "mod",
e->fd);
int epoll_rv = epoll_ctl(spec->epoll_fd, ctl_op, e->fd, &_ev);
if(epoll_rv != 0 &&
((ctl_op == EPOLL_CTL_ADD && errno == EEXIST) ||
(ctl_op == EPOLL_CTL_MOD && errno == ENOENT))) {
/* try the other way */
ctl_op = (ctl_op == EPOLL_CTL_ADD) ? EPOLL_CTL_MOD : EPOLL_CTL_ADD;
epoll_rv = epoll_ctl(spec->epoll_fd, ctl_op, e->fd, &_ev);
if (epoll_rv != 0) {
mtevFatal(mtev_error, "epoll_ctl(%d, %s, %d) -> %s\n",
spec->epoll_fd, ctl_op == EPOLL_CTL_ADD ? "add" : "mod",
e->fd, strerror(errno));
}
}
}
}
static void eventer_kqueue_impl_update(eventer_t e, int mask) {
if(e->mask & EVENTER_TIMER) {
eventer_update_timed(e, mask);
return;
}
mtevL(eventer_deb, "kqueue: update(%d, %x->%x)\n", e->fd, e->mask, mask);
/* Disable old, if they aren't active in the new */
if((e->mask & (EVENTER_READ | EVENTER_EXCEPTION)) &&
!(mask & (EVENTER_READ | EVENTER_EXCEPTION)))
ke_change(e->fd, EVFILT_READ, EV_DELETE | EV_DISABLE, e);
if((e->mask & (EVENTER_WRITE)) &&
!(mask & (EVENTER_WRITE)))
ke_change(e->fd, EVFILT_WRITE, EV_DELETE | EV_DISABLE, e);
/* Enable new, if the weren't in the old */
if((mask & (EVENTER_READ | EVENTER_EXCEPTION)) &&
!(e->mask & (EVENTER_READ | EVENTER_EXCEPTION)))
ke_change(e->fd, EVFILT_READ, EV_ADD | EV_ENABLE, e);
if((mask & (EVENTER_WRITE)) &&
!(e->mask & (EVENTER_WRITE)))
ke_change(e->fd, EVFILT_WRITE, EV_ADD | EV_ENABLE, e);
/* Switch */
e->mask = mask;
}
void mtev_hash_delete_all(mtev_hash_table *h, NoitHashFreeFunc keyfree, NoitHashFreeFunc datafree) {
void *entry = NULL;
ck_hs_iterator_t iterator = CK_HS_ITERATOR_INITIALIZER;
ck_hash_attr_t *data_struct;
if(!h) return;
if(h->u.hs.hf == NULL) {
mtevL(mtev_error, "warning: null hashtable in mtev_hash_delete_all... initializing\n");
mtev_stacktrace(mtev_error);
mtev_hash_init(h);
}
int count = mtev_hash_size(h);
LOCK(h);
while(ck_hs_next(&h->u.hs, &iterator, &entry)) {
data_struct = index_attribute_container((ck_key_t*)entry);
if (data_struct) {
if (keyfree) keyfree(data_struct->key_ptr);
if (datafree) datafree(data_struct->data);
free(data_struct);
}
}
ck_hs_reset_size(&h->u.hs, count);
UNLOCK(h);
}
static void
ke_change (register int const ident,
register int const filter,
register int const flags,
register eventer_t e) {
register struct kevent *kep;
KQUEUE_DECL;
KQUEUE_SETUP(e);
pthread_mutex_lock(&kqs->lock);
if (!ke_vec_a) {
kqs_init(kqs);
}
else if (ke_vec_used == ke_vec_a) {
ke_vec_a <<= 1;
ke_vec = (struct kevent *) realloc(ke_vec,
ke_vec_a * sizeof (struct kevent));
}
kep = &ke_vec[ke_vec_used++];
EV_SET(kep, ident, filter, flags, 0, 0, (void *)(vpsized_int)e->fd);
mtevL(eventer_deb, "debug: [t@%llx] ke_change(fd:%d, filt:%x, flags:%x)\n",
(vpsized_int)e->thr_owner, ident, filter, flags);
pthread_mutex_unlock(&kqs->lock);
}
static mtev_hook_return_t
zipkin_fq_publish(void *closure, int64_t traceid, int64_t spanid,
unsigned char *buf, size_t len) {
if(N_L_S_ON(debugls)) {
int blen;
char *b64buf;
b64buf = malloc(len*2);
blen = mtev_b64_encode(buf,len,b64buf,len*3);
b64buf[blen] = '\0';
mtevL(debugls,"%s\n", b64buf);
free(b64buf);
}
if(zc_client != NULL) {
char buff[128];
fq_msg *msg;
snprintf(buff, sizeof(buff), "%s%llx", zc_routing_prefix, (long long int)traceid);
msg = fq_msg_alloc(buf, len);
fq_msg_id(msg,NULL);
fq_msg_route(msg, buff, strlen(buff));
fq_msg_exchange(msg, zc_exchange, strlen(zc_exchange));
fq_client_publish(zc_client, msg);
fq_msg_free(msg);
}
return MTEV_HOOK_CONTINUE;
}
static int
child_main() {
/* reload our config, to make sure we have the most current */
if(mtev_conf_load(NULL) == -1) {
mtevL(mtev_error, "Cannot load config: '%s'\n", config_file);
exit(2);
}
eventer_init();
mtev_console_init(APPNAME);
mtev_capabilities_listener_init();
mtev_events_rest_init();
mtev_listener_init(APPNAME);
mtev_dso_init();
mtev_dso_post_init();
mtev_websocket_client_callbacks callbacks = {
websocket_ready_handler,
websocket_msg_handler,
websocket_cleanup_handler
};
(void)mtev_websocket_client_new("127.0.0.1", 8888, "/", "echo-protocol", &callbacks);
/* Lastly, spin up the event loop */
eventer_loop();
return 0;
}
static void
tragic_failure(mtev_dso_generic_t *self) {
lua_general_conf_t *conf = get_config(self);
if(conf->tragedy_terminates) {
mtevL(mtev_error, "Unrecoverable run-time error. Terminating.\n");
exit(-1);
}
}
static void
ssl_ctx_cache_remove(const char *key) {
mtevL(eventer_deb, "ssl_ctx_cache->remove(%s)\n", key);
pthread_mutex_lock(&ssl_ctx_cache_lock);
mtev_hash_delete(&ssl_ctx_cache, key, strlen(key),
NULL, (void (*)(void *))ssl_ctx_cache_node_free);
pthread_mutex_unlock(&ssl_ctx_cache_lock);
}
int mtev_hash_size(mtev_hash_table *h) {
if(h->u.hs.hf == NULL) {
mtevL(mtev_error, "warning: null hashtable in mtev_hash_size... initializing\n");
mtev_stacktrace(mtev_error);
mtev_hash_init(h);
}
return ck_hs_count(&h->u.hs);
}
static void finish_procs() {
struct proc_state *ps;
process_siglist();
mtevL(noit_debug, "%d done procs to cleanup\n", done_procs.size);
while((ps = mtev_skiplist_pop(&done_procs, NULL)) != NULL) {
mtevL(noit_debug, "finished %lld/%d\n", (long long int)ps->check_no, ps->pid);
if(ps->cancelled == 0) {
assert_write(out_fd, &ps->check_no,
sizeof(ps->check_no));
assert_write(out_fd, &ps->status,
sizeof(ps->status));
write_out_backing_fd(out_fd, ps->stdout_fd);
write_out_backing_fd(out_fd, ps->stderr_fd);
}
proc_state_free(ps);
}
}
void
mtev_capabilities_add_feature(const char *feature, const char *version) {
feature = strdup(feature);
if(version) version = strdup(version);
if(!mtev_hash_store(&features, feature, strlen(feature), (void *)version))
mtevL(mtev_error, "Feature conflict! %s version %s\n",
feature, version ? version : "unpecified");
}
void
stratcon_datastore_iep_check_preload() {
if(!ingestor) {
mtevL(noit_error, "No ingestor!\n");
exit(2);
}
ingestor->iep_check_preload();
}
int
stratcon_datastore_saveconfig(void *unused) {
if(!ingestor) {
mtevL(noit_error, "No ingestor!\n");
exit(2);
}
return ingestor->save_config();
}
static int
noit_rabbimq_submit(iep_thread_driver_t *dr,
const char *payload, size_t payloadlen) {
int rv;
amqp_bytes_t body;
struct amqp_driver *driver = (struct amqp_driver *)dr;
const char *routingkey = driver->routingkey;
body.len = payloadlen;
body.bytes = (char *)payload;
if(*payload == 'M' ||
*payload == 'S' ||
*payload == 'C' ||
(*payload == 'H' && payload[1] == '1') ||
(*payload == 'F' && payload[1] == '1') ||
(*payload == 'B' && (payload[1] == '1' || payload[1] == '2'))) {
char uuid_str[32 * 2 + 1];
int account_id, check_id;
if(extract_uuid_from_jlog(payload, payloadlen,
&account_id, &check_id, uuid_str)) {
if(*routingkey) {
char *replace;
int newlen = strlen(driver->routingkey) + 1 + sizeof(uuid_str) + 2 * 32;
replace = alloca(newlen);
snprintf(replace, newlen, "%s.%x.%x.%d.%d%s", driver->routingkey,
account_id%16, (account_id/16)%16, account_id,
check_id, uuid_str);
routingkey = replace;
}
}
}
rv = amqp_basic_publish(driver->connection, 1,
amqp_cstring_bytes(driver->exchange),
amqp_cstring_bytes(routingkey),
1, 0, NULL, body);
if(rv < 0) {
mtevL(mtev_error, "AMQP publish failed, disconnecting\n");
amqp_connection_close(driver->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(driver->connection);
if(driver->sockfd >= 0) close(driver->sockfd);
driver->sockfd = -1;
driver->connection = NULL;
return -1;
}
BUMPSTAT(publications);
noit_rabbitmq_heartbeat(driver);
noit_rabbitmq_read_frame(driver);
amqp_maybe_release_buffers(driver->connection);
if(driver->has_error) {
amqp_connection_close(driver->connection, AMQP_REPLY_SUCCESS);
amqp_destroy_connection(driver->connection);
if(driver->sockfd >= 0) close(driver->sockfd);
driver->sockfd = -1;
driver->connection = NULL;
return -1;
}
return 0;
}
static void ping_icmp_log_results(noit_module_t *self, noit_check_t *check) {
struct check_info *data;
double avail = 0.0, min = MAXFLOAT, max = 0.0, avg = 0.0, cnt;
int avail_needed = 100;
const char *config_val = NULL;
int i, points = 0;
char human_buffer[256];
struct timeval now, duration;
data = (struct check_info *)check->closure;
for(i=0; i<data->expected_count; i++) {
if(data->turnaround[i] >= 0.0) {
points++;
avg += data->turnaround[i];
if(data->turnaround[i] > max) max = data->turnaround[i];
if(data->turnaround[i] < min) min = data->turnaround[i];
}
}
cnt = data->expected_count;
if(points == 0) {
min = 0.0 / 0.0;
max = 0.0 / 0.0;
avg = 0.0 / 0.0;
}
else {
avail = (float)points /cnt;
avg /= (float)points;
}
if(mtev_hash_retr_str(check->config, "avail_needed", strlen("avail_needed"),
&config_val))
avail_needed = atoi(config_val);
snprintf(human_buffer, sizeof(human_buffer),
"cnt=%d,avail=%0.0f,min=%0.4f,max=%0.4f,avg=%0.4f",
(int)cnt, 100.0*avail, min, max, avg);
mtevL(nldeb, "ping_icmp(%s) [%s]\n", check->target_ip, human_buffer);
mtev_gettimeofday(&now, NULL);
sub_timeval(now, check->last_fire_time, &duration);
noit_stats_set_whence(check, &now);
noit_stats_set_duration(check, duration.tv_sec * 1000 + duration.tv_usec / 1000);
noit_stats_set_available(check, (avail > 0.0) ? NP_AVAILABLE : NP_UNAVAILABLE);
noit_stats_set_state(check, (avail < ((float)avail_needed / 100.0)) ? NP_BAD : NP_GOOD);
noit_stats_set_status(check, human_buffer);
noit_stats_set_metric(check, "count",
METRIC_INT32, &data->expected_count);
avail *= 100.0;
noit_stats_set_metric(check, "available", METRIC_DOUBLE, &avail);
noit_stats_set_metric(check, "minimum",
METRIC_DOUBLE, avail > 0.0 ? &min : NULL);
noit_stats_set_metric(check, "maximum",
METRIC_DOUBLE, avail > 0.0 ? &max : NULL);
noit_stats_set_metric(check, "average",
METRIC_DOUBLE, avail > 0.0 ? &avg : NULL);
noit_check_set_stats(check);
}
static void noit_rabbitmq_read_frame(struct amqp_driver *dr) {
struct pollfd p;
if(!dr->connection) return;
while(1) {
memset(&p, 0, sizeof(p));
p.fd = dr->sockfd;
p.events = POLLIN;
if(poll(&p, 1, 0)) {
int rv;
amqp_frame_t f;
rv = amqp_simple_wait_frame(dr->connection, &f);
if(rv > 0) {
if(f.frame_type == AMQP_FRAME_HEARTBEAT) {
BUMPSTAT(inbound_heartbeats);
mtevL(mtev_debug, "amqp <- hearbeat\n");
}
else if(f.frame_type == AMQP_FRAME_METHOD) {
BUMPSTAT(inbound_methods);
mtevL(mtev_error, "amqp <- method [%s]\n", amqp_method_name(f.payload.method.id));
dr->has_error = 1;
switch(f.payload.method.id) {
case AMQP_CHANNEL_CLOSE_METHOD: {
amqp_channel_close_t *m = (amqp_channel_close_t *) f.payload.method.decoded;
mtevL(mtev_error, "AMQP channel close error %d: %s\n",
m->reply_code, (char *)m->reply_text.bytes);
}
break;
case AMQP_CONNECTION_CLOSE_METHOD: {
amqp_connection_close_t *m = (amqp_connection_close_t *) f.payload.method.decoded;
mtevL(mtev_error, "AMQP connection close error %d: %s\n",
m->reply_code, (char *)m->reply_text.bytes);
}
break;
}
}
else {
mtevL(mtev_error, "amqp <- frame [%d]\n", f.frame_type);
}
}
else break;
}
else break;
}
}
int websocket_msg_handler(mtev_websocket_client_t *client, int opcode,
const unsigned char *msg, size_t msg_len) {
char buf[256];
size_t len;
snprintf(buf, msg_len, "%s", msg);
mtevL(mtev_error, "I received a message! %s\n", buf);
len = snprintf(buf, sizeof(buf), "%ld", lrand48());
mtev_websocket_client_send(client, opcode, buf, len);
return 0;
}
