void
noit_metric_director_message_deref(void *m) {
noit_metric_message_t *message = (noit_metric_message_t *)m;
if (mtev_atomic_dec32(&message->refcnt) == 0) {
noit_metric_director_free_message(message);
}
}
static void
filterset_free(void *vp) {
filterset_t *fs = vp;
filterrule_t *r;
if(mtev_atomic_dec32(&fs->ref_cnt) != 0) return;
mtevL(noit_debug, "Freeing filterset [%d]: %s\n", fs->ref_cnt, fs->name);
while(fs->rules) {
r = fs->rules->next;
filterrule_free(fs->rules);
fs->rules = r;
}
if(fs->name) free(fs->name);
free(fs);
}
/*
* 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);
}
}
void eventer_free(eventer_t e) {
if(mtev_atomic_dec32(&e->refcnt) == 0) {
mtev_atomic_dec64(&ealloccnt);
free(e);
}
}
void *
noit_jlog_thread_main(void *e_vptr) {
int mask, bytes_read, sleeptime, max_sleeptime;
eventer_t e = e_vptr;
acceptor_closure_t *ac = e->closure;
noit_jlog_closure_t *jcl = ac->service_ctx;
char inbuff[sizeof(jlog_id)];
mtev_memory_init_thread();
eventer_set_fd_blocking(e->fd);
max_sleeptime = DEFAULT_MSECONDS_BETWEEN_BATCHES;
if(ac->cmd == NOIT_JLOG_DATA_TEMP_FEED)
max_sleeptime = DEFAULT_TRANSIENT_MSECONDS_BETWEEN_BATCHES;
sleeptime = max_sleeptime;
while(1) {
jlog_id client_chkpt;
sleeptime = MIN(sleeptime, max_sleeptime);
jlog_get_checkpoint(jcl->jlog, ac->remote_cn, &jcl->chkpt);
jcl->count = jlog_ctx_read_interval(jcl->jlog, &jcl->start, &jcl->finish);
if(jcl->count < 0) {
char idxfile[PATH_MAX];
mtevL(noit_error, "jlog_ctx_read_interval: %s\n",
jlog_ctx_err_string(jcl->jlog));
switch (jlog_ctx_err(jcl->jlog)) {
case JLOG_ERR_FILE_CORRUPT:
case JLOG_ERR_IDX_CORRUPT:
jlog_repair_datafile(jcl->jlog, jcl->start.log);
jlog_repair_datafile(jcl->jlog, jcl->start.log + 1);
mtevL(noit_error,
"jlog reconstructed, deleting corresponding index.\n");
STRSETDATAFILE(jcl->jlog, idxfile, jcl->start.log);
strlcat(idxfile, INDEX_EXT, sizeof(idxfile));
unlink(idxfile);
STRSETDATAFILE(jcl->jlog, idxfile, jcl->start.log + 1);
strlcat(idxfile, INDEX_EXT, sizeof(idxfile));
unlink(idxfile);
goto alldone;
break;
default:
goto alldone;
}
}
if(jcl->count > MAX_ROWS_AT_ONCE) {
/* Artificially set down the range to make the batches a bit easier
* to handle on the stratcond/postgres end.
* However, we must have more data, so drop the sleeptime to 0
*/
jcl->count = MAX_ROWS_AT_ONCE;
jcl->finish.marker = jcl->start.marker + jcl->count;
}
if(jcl->count > 0) {
sleeptime = 0;
if(noit_jlog_push(e, jcl)) {
goto alldone;
}
/* Read our jlog_id accounting for possibly short reads */
bytes_read = 0;
while(bytes_read < sizeof(jlog_id)) {
int len;
if((len = e->opset->read(e->fd, inbuff + bytes_read,
sizeof(jlog_id) - bytes_read,
&mask, e)) <= 0)
goto alldone;
bytes_read += len;
}
memcpy(&client_chkpt, inbuff, sizeof(jlog_id));
/* Fix the endian */
client_chkpt.log = ntohl(client_chkpt.log);
client_chkpt.marker = ntohl(client_chkpt.marker);
if(memcmp(&jcl->chkpt, &client_chkpt, sizeof(jlog_id))) {
mtevL(noit_error,
"client %s submitted invalid checkpoint %u:%u expected %u:%u\n",
ac->remote_cn, client_chkpt.log, client_chkpt.marker,
jcl->chkpt.log, jcl->chkpt.marker);
goto alldone;
}
mtev_gettimeofday(&jcl->feed_stats->last_checkpoint, NULL);
jlog_ctx_read_checkpoint(jcl->jlog, &jcl->chkpt);
}
else {
/* we have nothing to write -- maybe we have no checks configured...
* If this is the case "forever", the remote might disconnect and
* we would never know. Do the painful work of detecting a
* disconnected client.
*/
struct pollfd pfd;
pfd.fd = e->fd;
pfd.events = POLLIN | POLLHUP | POLLRDNORM;
pfd.revents = 0;
if(poll(&pfd, 1, 0) != 0) {
/* normally, we'd recv PEEK|DONTWAIT. However, the client should
* not be writing to us. So, we know we can't have any legitimate
* data on this socket (true even though this is SSL). So, if we're
* here then "shit went wrong"
*/
mtevL(noit_error, "jlog client %s disconnected while idle\n",
ac->remote_cn);
goto alldone;
}
}
if(sleeptime) {
usleep(sleeptime * 1000); /* us -> ms */
}
sleeptime += 1000; /* 1 s */
}
alldone:
e->opset->close(e->fd, &mask, e);
mtev_atomic_dec32(&jcl->feed_stats->connections);
noit_jlog_closure_free(jcl);
acceptor_closure_free(ac);
mtev_memory_maintenance();
return NULL;
}
