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; }