void *writer(void *unused) {
jlog_ctx *ctx;
int i;
char foo[72];
ctx = jlog_new(LOGNAME);
memset(foo, 'X', sizeof(foo)-1);
foo[sizeof(foo)-1] = '\0';
if(jlog_ctx_open_writer(ctx) != 0) {
fprintf(stderr, "jlog_ctx_open_writer failed: %d %s\n", jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
croak();
}
#ifdef TEST_UNIT_LIMIT
newsize = 1024*1024 + (((intptr_t)unused) % (1024 * 1024));
fprintf(stderr, "writer setting new unit_limit to %d\n", (int)newsize);
jlog_ctx_alter_journal_size(ctx, newsize);
#endif
for(i=0;i<10000;i++) {
int rv;
rv = jlog_ctx_write(ctx, foo, strlen(foo));
if(rv != 0) {
fprintf(stderr, "jlog_ctx_write_message failed: %d %s\n", jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
/* abort(); */
}
usleep(100);
}
fprintf(stderr, "writer thinks unit_limit is %d\n", ctx->meta->unit_limit);
jlog_ctx_close(ctx);
writer_done = 1;
return 0;
}
static fqd_queue_impl_data queue_jlog_setup(fq_rk *qname, uint32_t *count) {
char qpath[PATH_MAX];
jlog_id chkpt;
struct queue_jlog *d;
d = calloc(1, sizeof(*d));
d->auto_chkpt = true;
fqd_config_construct_queue_path(qpath, sizeof(qpath), qname);
d->qpath = strdup(qpath);
d->writer = jlog_new(d->qpath);
if(jlog_ctx_open_writer(d->writer) != 0) {
jlog_ctx_close(d->writer);
d->writer = jlog_new(d->qpath);
if(jlog_ctx_init(d->writer) != 0) {
fq_debug(FQ_DEBUG_IO, "jlog init: %s\n", jlog_ctx_err_string(d->writer));
goto bail;
}
jlog_ctx_close(d->writer);
d->writer = jlog_new(d->qpath);
if(jlog_ctx_open_writer(d->writer) != 0) {
fq_debug(FQ_DEBUG_IO, "jlog writer: %s\n", jlog_ctx_err_string(d->writer));
goto bail;
}
}
d->reader = jlog_new(d->qpath);
if(jlog_get_checkpoint(d->reader, "fq", &chkpt) != 0) {
if(jlog_ctx_add_subscriber(d->reader, "fq", JLOG_BEGIN) != 0) {
fq_debug(FQ_DEBUG_IO, "jlog add sub: %s\n", jlog_ctx_err_string(d->reader));
goto bail;
}
}
if(jlog_ctx_open_reader(d->reader, "fq") != 0) {
fq_debug(FQ_DEBUG_IO, "jlog: %s\n", jlog_ctx_err_string(d->reader));
goto bail;
}
uuid_generate(d->uuid);
write_sig(d);
*count = 0;
(void)qname;
return d;
bail:
if(d->writer) jlog_ctx_close(d->writer);
if(d->reader) jlog_ctx_close(d->reader);
free(d->qpath);
free(d);
return NULL;
}
static int rest_show_feed(noit_http_rest_closure_t *restc,
int npats, char **pats) {
noit_http_session_ctx *ctx = restc->http_ctx;
const char *err = "unknown error";
const char *jpath_with_sub;
char jlogpath[PATH_MAX], *cp, **subs = NULL;
int nsubs, i;
noit_log_stream_t feed;
jlog_ctx *jctx = NULL;
xmlDocPtr doc = NULL;
xmlNodePtr root = NULL, subnodes;
feed = noit_log_stream_find("feed");
if(!feed) { err = "cannot find feed"; goto error; }
jpath_with_sub = noit_log_stream_get_path(feed);
strlcpy(jlogpath, jpath_with_sub, sizeof(jlogpath));
cp = strchr(jlogpath, '(');
if(cp) *cp = '\0';
jctx = jlog_new(jlogpath);
if((nsubs = jlog_ctx_list_subscribers(jctx, &subs)) == -1) {
err = jlog_ctx_err_string(jctx);
goto error;
}
doc = xmlNewDoc((xmlChar *)"1.0");
root = xmlNewDocNode(doc, NULL, (xmlChar *)"feed", NULL);
xmlDocSetRootElement(doc, root);
subnodes = xmlNewNode(NULL, (xmlChar *)"subscribers");
for(i=0; i<nsubs; i++) {
xmlNewChild(subnodes, NULL, (xmlChar *)"subscriber", (xmlChar *)subs[i]);
}
xmlAddChild(root, subnodes);
noit_http_response_ok(restc->http_ctx, "text/xml");
noit_http_response_xml(restc->http_ctx, doc);
noit_http_response_end(restc->http_ctx);
if(subs) jlog_ctx_list_subscribers_dispose(jctx, subs);
xmlFreeDoc(doc);
jlog_ctx_close(jctx);
return 0;
error:
if(doc) xmlFreeDoc(doc);
if(subs) jlog_ctx_list_subscribers_dispose(jctx, subs);
noit_http_response_server_error(ctx, "text/plain");
noit_http_response_append(ctx, err, strlen(err));
noit_http_response_end(ctx);
if(jctx) jlog_ctx_close(jctx);
return 0;
}
int jlog_logio_asynch_write(asynch_log_ctx *actx, asynch_log_line *line) {
int rv;
jlog_ctx *log = actx->userdata;
rv = jlog_ctx_write(log, line->buf_dynamic ?
line->buf_dynamic :
line->buf_static,
line->len);
if(rv == -1) {
noitL(noit_error, "jlog_ctx_write failed(%d): %s\n",
jlog_ctx_errno(log), jlog_ctx_err_string(log));
}
return rv;
}
static int rest_delete_feed(noit_http_rest_closure_t *restc,
int npats, char **pats) {
noit_http_session_ctx *ctx = restc->http_ctx;
const char *err = "unknown error";
const char *jpath_with_sub;
char jlogpath[PATH_MAX], *cp;
int rv;
noit_log_stream_t feed;
jlog_ctx *jctx;
feed = noit_log_stream_find("feed");
if(!feed) { err = "cannot find feed"; goto error; }
jpath_with_sub = noit_log_stream_get_path(feed);
strlcpy(jlogpath, jpath_with_sub, sizeof(jlogpath));
cp = strchr(jlogpath, '(');
if(cp) *cp = '\0';
jctx = jlog_new(jlogpath);
rv = jlog_ctx_remove_subscriber(jctx, pats[0]);
jlog_ctx_close(jctx);
if(rv < 0) {
err = jlog_ctx_err_string(jctx);
goto error;
}
/* removed or note, we should do a sweeping cleanup */
jlog_clean(jlogpath);
if(rv == 0) {
noit_http_response_not_found(ctx, "text/plain");
noit_http_response_end(ctx);
return 0;
}
noit_http_response_standard(ctx, 204, "OK", "text/plain");
noit_http_response_end(ctx);
return 0;
error:
noit_http_response_server_error(ctx, "text/plain");
noit_http_response_append(ctx, err, strlen(err));
noit_http_response_end(ctx);
return 0;
}
static void *
jlog_logio_asynch_writer(void *vls) {
noit_log_stream_t ls = vls;
jlog_asynch_ctx *actx = ls->op_ctx;
jlog_line *iter = NULL;
int gen;
gen = noit_atomic_inc32(&actx->gen);
noitL(noit_error, "starting asynchronous jlog writer[%d/%p]\n",
(int)getpid(), (void *)pthread_self());
while(gen == actx->gen) {
pthread_rwlock_t *lock;
int fast = 0, max = 1000;
jlog_line *line;
lock = ls->lock;
if(lock) pthread_rwlock_rdlock(lock);
while(max > 0 && NULL != (line = jlog_asynch_pop(actx, &iter))) {
if(jlog_ctx_write(actx->log, line->buf_dynamic ?
line->buf_dynamic :
line->buf_static,
line->len) == -1) {
noitL(noit_error, "jlog_ctx_write failed(%d): %s\n",
jlog_ctx_errno(actx->log), jlog_ctx_err_string(actx->log));
abort();
}
if(line->buf_dynamic != NULL) free(line->buf_dynamic);
free(line);
fast = 1;
max--;
}
if(lock) pthread_rwlock_unlock(lock);
if(max > 0) {
/* we didn't hit our limit... so we ran the queue dry */
/* 200ms if there was nothing, 10ms otherwise */
usleep(fast ? 10000 : 200000);
}
}
noitL(noit_error, "stopping asynchronous jlog writer[%d/%p]\n",
(int)getpid(), (void *)pthread_self());
pthread_exit((void *)0);
}
void jcreate(jlog_safety s) {
jlog_ctx *ctx;
const char *label = NULL;
switch (s) {
case JLOG_ALMOST_SAFE: label = "almost safe"; break;
case JLOG_UNSAFE: label = "unsafe"; break;
case JLOG_SAFE: label = "safe"; break;
}
fprintf(stderr, "jcreate %s in %s mode\n", LOGNAME, label);
ctx = jlog_new(LOGNAME);
jlog_ctx_alter_journal_size(ctx, 102400);
jlog_ctx_alter_safety(ctx, s);
if(jlog_ctx_init(ctx) != 0) {
fprintf(stderr, "jlog_ctx_init failed: %d %s\n", jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
if(jlog_ctx_err(ctx) != JLOG_ERR_CREATE_EXISTS) exit(0);
} else {
jlog_ctx_add_subscriber(ctx, MASTER, JLOG_BEGIN);
}
jlog_ctx_close(ctx);
}
static int
jlog_logio_open(noit_log_stream_t ls) {
char path[PATH_MAX], *sub, **subs, *p;
jlog_asynch_ctx *actx;
jlog_ctx *log = NULL;
pthread_attr_t tattr;
int i, listed, found;
if(jlog_lspath_to_fspath(ls, path, sizeof(path), &sub) <= 0) return -1;
log = jlog_new(path);
if(!log) return -1;
jlog_set_error_func(log, noit_log_jlog_err, ls);
/* Open the writer. */
if(jlog_ctx_open_writer(log)) {
/* If that fails, we'll give one attempt at initiailizing it. */
/* But, since we attempted to open it as a writer, it is tainted. */
/* path: close, new, init, close, new, writer, add subscriber */
jlog_ctx_close(log);
log = jlog_new(path);
jlog_set_error_func(log, noit_log_jlog_err, ls);
if(jlog_ctx_init(log)) {
noitL(noit_error, "Cannot init jlog writer: %s\n",
jlog_ctx_err_string(log));
jlog_ctx_close(log);
return -1;
}
/* After it is initialized, we can try to reopen it as a writer. */
jlog_ctx_close(log);
log = jlog_new(path);
jlog_set_error_func(log, noit_log_jlog_err, ls);
if(jlog_ctx_open_writer(log)) {
noitL(noit_error, "Cannot open jlog writer: %s\n",
jlog_ctx_err_string(log));
jlog_ctx_close(log);
return -1;
}
}
/* Add or remove subscribers according to the current configuration. */
listed = jlog_ctx_list_subscribers(log, &subs);
if(listed == -1) {
noitL(noit_error, "Cannot list jlog subscribers: %s\n",
jlog_ctx_err_string(log));
return -1;
}
if(sub) {
/* Match all configured subscribers against jlog's list. */
for(p=strtok(sub, ",");p;p=strtok(NULL, ",")) {
for(i=0;i<listed;i++) {
if((subs[i]) && (strcmp(p, subs[i]) == 0)) {
free(subs[i]);
subs[i] = NULL;
break;
}
}
if(i == listed)
jlog_ctx_add_subscriber(log, p, JLOG_BEGIN);
}
/* Remove all unmatched subscribers. */
for(i=0;i<listed;i++) {
if(subs[i]) {
jlog_ctx_remove_subscriber(log, subs[i]);
free(subs[i]);
subs[i] = NULL;
}
}
free(subs);
subs = NULL;
} else {
/* Remove all subscribers other than DEFAULT_JLOG_SUBSCRIBER. */
found = 0;
for(i=0;i<listed;i++) {
if((subs[i]) && (strcmp(DEFAULT_JLOG_SUBSCRIBER, subs[i]) == 0)) {
found = 1;
continue;
}
jlog_ctx_remove_subscriber(log, subs[i]);
}
/* Add DEFAULT_JLOG_SUBSCRIBER if it wasn't already on the jlog's list. */
if(!found)
jlog_ctx_add_subscriber(log, DEFAULT_JLOG_SUBSCRIBER, JLOG_BEGIN);
jlog_ctx_list_subscribers_dispose(log, subs);
}
actx = calloc(1, sizeof(*actx));
actx->log = log;
ls->op_ctx = actx;
pthread_attr_init(&tattr);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
if(pthread_create(&actx->writer, NULL, jlog_logio_asynch_writer, ls) != 0)
return -1;
/* We do this to clean things up */
jlog_logio_reopen(ls);
return 0;
}
static fq_msg *queue_jlog_dequeue(fqd_queue_impl_data f) {
struct queue_jlog *d = (struct queue_jlog *)f;
jlog_message msg;
fq_msg *m;
if(d->count == 0 && d->last_seen_nenqueued == d->nenqueued) return NULL;
retry:
if(d->count <= 0) {
d->count = jlog_ctx_read_interval(d->reader, &d->start, &d->finish);
fq_debug(FQ_DEBUG_IO, "jlog read batch count -> %d\n", d->count);
if(d->count < 0) {
char idxfile[PATH_MAX];
fq_debug(FQ_DEBUG_IO, "jlog_ctx_read_interval: %s\n",
jlog_ctx_err_string(d->reader));
switch (jlog_ctx_err(d->reader)) {
case JLOG_ERR_FILE_CORRUPT:
case JLOG_ERR_IDX_CORRUPT:
jlog_repair_datafile(d->reader, d->start.log);
jlog_repair_datafile(d->reader, d->start.log + 1);
fq_debug(FQ_DEBUG_IO,
"jlog reconstructed, deleting corresponding index.\n");
STRSETDATAFILE(d->reader, idxfile, d->start.log);
strncpy(idxfile + strlen(idxfile), INDEX_EXT, sizeof(idxfile) - strlen(idxfile));
unlink(idxfile);
STRSETDATAFILE(d->reader, idxfile, d->start.log + 1);
strncpy(idxfile + strlen(idxfile), INDEX_EXT, sizeof(idxfile) - strlen(idxfile));
unlink(idxfile);
break;
default:
break;
}
}
if(d->count <= 0) return NULL;
}
if(jlog_ctx_read_message(d->reader, &d->start, &msg) == -1) {
d->count = 0;
return NULL;
}
if(d->last_dequeued.log > d->start.log ||
(d->last_dequeued.log == d->start.log &&
d->last_dequeued.marker > d->start.marker)) {
d->count--;
JLOG_ID_ADVANCE(&d->start);
goto retry;
}
if(msg.mess_len < sizeof(fq_msg)-1)
m = NULL;
else {
off_t expected_len;
uint32_t payload_len;
m = (fq_msg *)msg.mess;
memcpy(&payload_len, &m->payload_len, sizeof(m->payload_len));
expected_len = offsetof(fq_msg, payload) + payload_len;
if(expected_len != msg.mess_len) m = NULL;
else {
m = malloc(expected_len);
memcpy(m, msg.mess, expected_len);
m->sender_msgid.id.u32.p3 = d->start.log;
m->sender_msgid.id.u32.p4 = d->start.marker;
}
}
d->count--;
fq_debug(FQ_DEBUG_IO, "jlog batch count -> %d\n", d->count);
if(d->count == 0) {
if(d->auto_chkpt) {
jlog_ctx_read_checkpoint(d->reader, &d->start);
}
}
d->last_dequeued = d->start;
JLOG_ID_ADVANCE(&d->start);
ck_pr_inc_uint(&d->last_seen_nenqueued);
return m;
}
/*
* returns -1 when the incoming checkpoint is out of range of the log
* returns -2 if there was an error actually setting the checkpoint
*/
static int queue_log_add_checkpoint(fqd_queue_impl_data data, const char *name, const fq_msgid *id)
{
struct queue_jlog *d = (struct queue_jlog *)data;
jlog_id jid = {
.log = id->id.u32.p1,
.marker = id->id.u32.p2
};
/* ensure the checkpoint makes sense */
jlog_id first = {
.log = 0,
.marker = 0
};
jlog_id last = {
.log = 0,
.marker = 0
};
jlog_ctx_first_log_id(d->reader, &first);
jlog_ctx_last_log_id(d->reader, &last);
if (! (jid.log >= first.log && jid.log <= last.log &&
jid.marker >= first.marker && jid.marker <= last.marker)) {
return -1;
}
char **subs;
int sub_count = jlog_ctx_list_subscribers(d->reader, &subs);
int have_it = 0;
for (int i = 0; i < sub_count; i++) {
have_it += strcmp(subs[i], name) == 0 ? 1 : 0;
}
if (have_it == 0) {
jlog_ctx_add_subscriber(d->reader, name, JLOG_BEGIN);
}
if (jlog_ctx_read_checkpoint(d->reader, &jid) == -1) {
/*
If we failed to checkpoint we are in a situation where the 'add_subscriber' call above put
them at the beginning of the log so we have to remove the subscriber if we just added them
However, if they already existed and had a previous good checkpoint, leave it alone
*/
if (have_it == 0) {
jlog_ctx_remove_subscriber(d->reader, name);
}
return -2;
}
return 0;
}
/*
* return -1 if the subscriber doesn't exist
* return 0 on success
*/
static int queue_log_remove_checkpoint(fqd_queue_impl_data data, const char *name)
{
struct queue_jlog *d = (struct queue_jlog *)data;
if (jlog_ctx_remove_subscriber(d->reader, name) == 0) {
return -1;
}
return 0;
}
/*
* return -1 if the subscriber doesn't exist
* return -2 if we can't reset the checkpoint
* return 0 on success
*/
static int queue_log_reset_to_checkpoint(fqd_queue_impl_data data, const char *name)
{
struct queue_jlog *d = (struct queue_jlog *)data;
char **subs;
int sub_count = jlog_ctx_list_subscribers(d->reader, &subs);
int have_it = 0;
for (int i = 0; i < sub_count; i++) {
have_it += strcmp(subs[i], name) == 0 ? 1 : 0;
}
if (have_it == 0) {
return -1;
}
jlog_id checkpoint;
if (jlog_get_checkpoint(d->reader, name, &checkpoint) == -1) {
return -2;
}
if (jlog_ctx_read_checkpoint(d->reader, &checkpoint) == -1) {
return -2;
}
return 0;
}
static int write_sig(struct queue_jlog *d) {
char sigfile[PATH_MAX];
int fd;
snprintf(sigfile, sizeof(sigfile), "%s/.sig", d->qpath);
fd = open(sigfile, O_CREAT|O_TRUNC|O_WRONLY, 0640);
if(fd < 0) return -1;
write(fd, d->uuid, 16);
close(fd);
return 0;
}
static int read_sig(struct queue_jlog *d, uuid_t out) {
char sigfile[PATH_MAX];
int fd, rv;
snprintf(sigfile, sizeof(sigfile), "%s/.sig", d->qpath);
fd = open(sigfile, O_RDONLY);
if(fd < 0) return -1;
rv = read(fd, out, 16);
close(fd);
return (rv == 16) ? 0 : -1;
}
static fqd_queue_impl_data queue_jlog_setup(fq_rk *qname, uint32_t *count) {
char qpath[PATH_MAX];
jlog_id chkpt;
struct queue_jlog *d;
d = calloc(1, sizeof(*d));
d->auto_chkpt = true;
fqd_config_construct_queue_path(qpath, sizeof(qpath), qname);
d->qpath = strdup(qpath);
d->writer = jlog_new(d->qpath);
jlog_ctx_set_pre_commit_buffer_size(d->writer, 1024 * 1024);
jlog_ctx_set_multi_process(d->writer, 0);
jlog_ctx_set_use_compression(d->writer, 1);
if(jlog_ctx_open_writer(d->writer) != 0) {
jlog_ctx_close(d->writer);
d->writer = jlog_new(d->qpath);
jlog_ctx_set_pre_commit_buffer_size(d->writer, 1024 * 1024);
jlog_ctx_set_multi_process(d->writer, 0);
jlog_ctx_set_use_compression(d->writer, 1);
if(jlog_ctx_init(d->writer) != 0) {
fq_debug(FQ_DEBUG_IO, "jlog init: %s\n", jlog_ctx_err_string(d->writer));
goto bail;
}
jlog_ctx_close(d->writer);
d->writer = jlog_new(d->qpath);
jlog_ctx_set_pre_commit_buffer_size(d->writer, 1024 * 1024);
jlog_ctx_set_multi_process(d->writer, 0);
jlog_ctx_set_use_compression(d->writer, 1);
if(jlog_ctx_open_writer(d->writer) != 0) {
fq_debug(FQ_DEBUG_IO, "jlog writer: %s\n", jlog_ctx_err_string(d->writer));
goto bail;
}
}
/* 128MB journal chunks */
jlog_ctx_alter_journal_size(d->writer, 128 * 1024 * 1024);
d->reader = jlog_new(d->qpath);
if(jlog_get_checkpoint(d->reader, "fq", &chkpt) != 0) {
if(jlog_ctx_add_subscriber(d->reader, "fq", JLOG_BEGIN) != 0) {
fq_debug(FQ_DEBUG_IO, "jlog add sub: %s\n", jlog_ctx_err_string(d->reader));
goto bail;
}
}
if(jlog_ctx_open_reader(d->reader, "fq") != 0) {
fq_debug(FQ_DEBUG_IO, "jlog: %s\n", jlog_ctx_err_string(d->reader));
goto bail;
}
uuid_generate(d->uuid);
write_sig(d);
*count = d->count = jlog_ctx_read_interval(d->reader, &d->start, &d->finish);
(void)qname;
return d;
bail:
if(d->writer) jlog_ctx_close(d->writer);
if(d->reader) jlog_ctx_close(d->reader);
free(d->qpath);
free(d);
return NULL;
}
int
noit_jlog_handler(eventer_t e, int mask, void *closure,
struct timeval *now) {
eventer_t newe;
pthread_t tid;
pthread_attr_t tattr;
int newmask = EVENTER_READ | EVENTER_EXCEPTION;
acceptor_closure_t *ac = closure;
noit_jlog_closure_t *jcl = ac->service_ctx;
char errbuff[256];
const char *errstr = "unknown error";
if(mask & EVENTER_EXCEPTION || (jcl && jcl->wants_shutdown)) {
int len, nlen;
socket_error:
/* Exceptions cause us to simply snip the connection */
len = strlen(errstr);
nlen = htonl(0 - len);
e->opset->write(e->fd, &nlen, sizeof(nlen), &newmask, e);
e->opset->write(e->fd, errstr, strlen(errstr), &newmask, e);
eventer_remove_fd(e->fd);
e->opset->close(e->fd, &newmask, e);
if(jcl) noit_jlog_closure_free(jcl);
acceptor_closure_free(ac);
return 0;
}
if(!ac->service_ctx) {
noit_log_stream_t ls;
const char *logname, *type;
int first_attempt = 1;
char path[PATH_MAX], subscriber[256], *sub;
jcl = ac->service_ctx = noit_jlog_closure_alloc();
if(!noit_hash_retr_str(ac->config,
"log_transit_feed_name",
strlen("log_transit_feed_name"),
&logname)) {
errstr = "No 'log_transit_feed_name' specified in log_transit.";
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
ls = noit_log_stream_find(logname);
if(!ls) {
snprintf(errbuff, sizeof(errbuff),
"Could not find log '%s' for log_transit.", logname);
errstr = errbuff;
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
type = noit_log_stream_get_type(ls);
if(!type || strcmp(type, "jlog")) {
snprintf(errbuff, sizeof(errbuff),
"Log '%s' for log_transit is not a jlog.", logname);
errstr = errbuff;
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
if(ac->cmd == NOIT_JLOG_DATA_FEED) {
if(!ac->remote_cn) {
errstr = "jlog transit started to unidentified party.";
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
strlcpy(subscriber, ac->remote_cn, sizeof(subscriber));
jcl->feed_stats = noit_jlog_feed_stats(subscriber);
}
else {
jcl->feed_stats = noit_jlog_feed_stats("~");
snprintf(subscriber, sizeof(subscriber),
"~%07d", noit_atomic_inc32(&tmpfeedcounter));
}
jcl->subscriber = strdup(subscriber);
strlcpy(path, noit_log_stream_get_path(ls), sizeof(path));
sub = strchr(path, '(');
if(sub) {
char *esub = strchr(sub, ')');
if(esub) {
*esub = '\0';
*sub++ = '\0';
}
}
jcl->jlog = jlog_new(path);
if(ac->cmd == NOIT_JLOG_DATA_TEMP_FEED) {
add_sub:
if(jlog_ctx_add_subscriber(jcl->jlog, jcl->subscriber, JLOG_END) == -1) {
snprintf(errbuff, sizeof(errbuff),
"jlog reader[%s] error: %s", jcl->subscriber,
jlog_ctx_err_string(jcl->jlog));
errstr = errbuff;
noitL(noit_error, "%s\n", errstr);
}
}
if(jlog_ctx_open_reader(jcl->jlog, jcl->subscriber) == -1) {
if(sub && !strcmp(sub, "*")) {
if(first_attempt) {
jlog_ctx_close(jcl->jlog);
jcl->jlog = jlog_new(path);
first_attempt = 0;
goto add_sub;
}
}
snprintf(errbuff, sizeof(errbuff),
"jlog reader[%s] error: %s", jcl->subscriber,
jlog_ctx_err_string(jcl->jlog));
errstr = errbuff;
noitL(noit_error, "%s\n", errstr);
goto socket_error;
}
}
/* The jlog stuff is disk I/O and can block us.
* We'll create a new thread to just handle this connection.
*/
eventer_remove_fd(e->fd);
newe = eventer_alloc();
memcpy(newe, e, sizeof(*e));
pthread_attr_init(&tattr);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
gettimeofday(&jcl->feed_stats->last_connection, NULL);
noit_atomic_inc32(&jcl->feed_stats->connections);
if(pthread_create(&tid, &tattr, noit_jlog_thread_main, newe) == 0) {
return 0;
}
/* Undo our dup */
eventer_free(newe);
/* Creating the thread failed, close it down and deschedule. */
e->opset->close(e->fd, &newmask, e);
return 0;
}
void *
noit_jlog_thread_main(void *e_vptr) {
int mask, bytes_read;
eventer_t e = e_vptr;
acceptor_closure_t *ac = e->closure;
noit_jlog_closure_t *jcl = ac->service_ctx;
char inbuff[sizeof(jlog_id)];
eventer_set_fd_blocking(e->fd);
while(1) {
jlog_id client_chkpt;
int sleeptime = (ac->cmd == NOIT_JLOG_DATA_TEMP_FEED) ?
1 : DEFAULT_SECONDS_BETWEEN_BATCHES;
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];
noitL(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);
noitL(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;
sleeptime = 0;
}
if(jcl->count > 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))) {
noitL(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;
}
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"
*/
noitL(noit_error, "jlog client %s disconnected while idle\n",
ac->remote_cn);
goto alldone;
}
}
if(sleeptime) sleep(sleeptime);
}
alldone:
e->opset->close(e->fd, &mask, e);
noit_atomic_dec32(&jcl->feed_stats->connections);
noit_jlog_closure_free(jcl);
acceptor_closure_free(ac);
return NULL;
}
static int
process_jlog(const char *file, const char *sub)
{
jlog_ctx *log = jlog_new(file);
if (add_subscriber) {
if (jlog_ctx_add_subscriber(log, add_subscriber, JLOG_BEGIN)) {
fprintf(stderr, "Could not add subscriber '%s': %s\n", add_subscriber,
jlog_ctx_err_string(log));
} else {
OUT("Added subscriber '%s'\n", add_subscriber);
}
}
if (remove_subscriber) {
if (jlog_ctx_remove_subscriber(log, remove_subscriber) <= 0) {
fprintf(stderr, "Could not erase subscriber '%s': %s\n",
remove_subscriber, jlog_ctx_err_string(log));
} else {
OUT("Erased subscriber '%s'\n", remove_subscriber);
}
}
if (!sub) {
if (jlog_ctx_open_writer(log)) {
fprintf(stderr, "error opening '%s'\n", file);
return 0;
}
} else {
if (jlog_ctx_open_reader(log, sub)) {
fprintf(stderr, "error opening '%s'\n", file);
return 0;
}
}
if (show_progress) {
char buff[20], buff2[20], buff3[20];
jlog_id id, id2, id3;
jlog_get_checkpoint(log, sub, &id);
if (jlog_ctx_last_log_id(log, &id3)) {
fprintf(stderr, "jlog_error: %s\n", jlog_ctx_err_string(log));
fprintf(stderr, "error calling jlog_ctx_last_log_id\n");
}
jlog_snprint_logid(buff, sizeof(buff), &id);
jlog_snprint_logid(buff3, sizeof(buff3), &id3);
OUT("--------------------\n"
" Perspective of the '%s' subscriber\n"
" current checkpoint: %s\n"
" Last write: %s\n", sub, buff, buff3);
if (jlog_ctx_read_interval(log, &id, &id2) < 0) {
fprintf(stderr, "jlog_error: %s\n", jlog_ctx_err_string(log));
}
jlog_snprint_logid(buff, sizeof(buff), &id);
jlog_snprint_logid(buff2, sizeof(buff2), &id2);
OUT(" next interval: [%s, %s]\n"
"--------------------\n\n", buff, buff2);
}
if (show_subscribers) {
char **list;
int i;
jlog_ctx_list_subscribers(log, &list);
for (i = 0; list[i]; i++) {
char buff[20];
jlog_id id;
jlog_get_checkpoint(log, list[i], &id);
jlog_snprint_logid(buff, sizeof(buff), &id);
OUT("\t%32s @ %s\n", list[i], buff);
}
jlog_ctx_list_subscribers_dispose(log, list);
}
if (show_files) {
struct dirent *de;
DIR *dir;
dir = opendir(file);
if (!dir) {
fprintf(stderr, "error opening '%s'\n", file);
return 0;
}
while ((de = readdir(dir)) != NULL) {
uint32_t logid;
if (is_datafile(de->d_name, &logid)) {
char fullfile[MAXPATHLEN];
char fullidx[MAXPATHLEN];
struct stat sb;
int readers;
snprintf(fullfile, sizeof(fullfile), "%s/%s", file, de->d_name);
snprintf(fullidx, sizeof(fullidx), "%s/%s" INDEX_EXT, file, de->d_name);
if (stat(fullfile, &sb)) {
OUT("\t%8s [error stat(2)ing file: %s\n", de->d_name, strerror(errno));
} else {
readers = __jlog_pending_readers(log, logid);
OUT("\t%8s [%ju bytes] %d pending readers\n", de->d_name, sb.st_size, readers);
if (show_index_info) {
if (stat(fullidx, &sb)) {
OUT("\t\t idx: none\n");
} else {
uint32_t marker;
int closed;
if (jlog_idx_details(log, logid, &marker, &closed)) {
OUT("\t\t idx: error\n");
} else {
OUT("\t\t idx: %u messages (%08x), %s\n", marker, marker, closed ? "closed" : "open");
}
}
}
if (analyze_datafiles) {
analyze_datafile(log, logid);
}
if (readers == 0 && cleanup) {
unlink(fullfile);
unlink(fullidx);
}
}
}
}
closedir(dir);
}
jlog_ctx_close(log);
}
int main(int argc, char **argv) {
int i;
char *toremove = NULL;
jlog_safety safety = JLOG_ALMOST_SAFE;
pthread_t tid[THRCNT], wtid[WTHRCNT];
void *foo;
#if _WIN32
mem_init();
#endif
if(argc == 3) {
if(!strcmp(argv[1], "safety")) {
if(!strcmp(argv[2], "unsafe"))
safety = JLOG_UNSAFE;
else if(!strcmp(argv[2], "almost_safe"))
safety = JLOG_ALMOST_SAFE;
else if(!strcmp(argv[2], "safe"))
safety = JLOG_SAFE;
else {
fprintf(stderr, "invalid safety option\n");
usage();
}
} else if(!strcmp(argv[1], "only")) {
if(!strcmp(argv[2], "read")) only_read = 1;
else if(!strcmp(argv[2], "write")) only_write = 1;
else usage();
} else if(!strcmp(argv[1], "remove")) {
toremove = argv[2];
} else {
usage();
}
} else if(argc < 3 || argc > 3) {
usage();
}
jcreate(safety);
if(toremove) {
jlog_ctx *ctx;
ctx = jlog_new(LOGNAME);
if(jlog_ctx_open_writer(ctx) != 0) {
fprintf(stderr, "jlog_ctx_open_writer failed: %d %s\n", jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
croak();
}
jlog_ctx_remove_subscriber(ctx, argv[2]);
jlog_ctx_close(ctx);
exit(0);
}
if(!only_write) {
for(i=0; i<THRCNT; i++) {
pthread_create(&tid[i], NULL, reader, (void *)(uintptr_t)i);
fprintf(stderr, "[%d] started reader\n", (int)(uintptr_t)tid[i]);
}
}
if(!only_read) {
fprintf(stderr, "starting writers..\n");
for(i=0; i<WTHRCNT; i++) {
pthread_create(&wtid[i], NULL, writer, (void *)(uintptr_t)i);
fprintf(stderr, "[%d] started writer\n", (int)(uintptr_t)wtid[i]);
}
} else {
sleep(5);
writer_done = 1;
}
if(!only_write) {
for(i=0; i<THRCNT; i++) {
pthread_join(tid[i], &foo);
fprintf(stderr, "[%d] joined, read %d\n", i, (int)(uintptr_t)foo);
}
}
if(!only_read) {
for(i=0; i<WTHRCNT; i++) {
pthread_join(wtid[i], &foo);
fprintf(stderr, "[%d] joined, write %d\n", i, (int)(uintptr_t)foo);
}
}
if(error) fprintf(stderr, "errors occurred\n");
return 0;
}
void *reader(void *unused) {
jlog_ctx *ctx;
char subname[32];
int tcount = 0, fcount = 0;
int prev_err = 0;
int subno = (int)(uintptr_t)unused;
snprintf(subname, sizeof(subname), "sub-%02d", subno);
reader_retry:
ctx = jlog_new(LOGNAME);
if(jlog_ctx_open_reader(ctx, subname) != 0) {
if(prev_err == 0) {
prev_err = jlog_ctx_err(ctx);
jlog_ctx_close(ctx);
ctx = jlog_new(LOGNAME);
if(prev_err == JLOG_ERR_INVALID_SUBSCRIBER) {
fprintf(stderr, "[%02d] invalid subscriber, init...\n", subno);
if(jlog_ctx_open_writer(ctx) != 0) {
fprintf(stderr, "[%02d] jlog_ctx_open_writer failed: %d %s\n", subno, jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
} else {
if(jlog_ctx_add_subscriber(ctx, subname, JLOG_BEGIN) != 0) {
fprintf(stderr, "[%02d] jlog_ctx_add_subscriber failed: %d %s\n", subno, jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
} else {
jlog_ctx_close(ctx);
goto reader_retry;
}
}
}
}
fprintf(stderr, "[%02d] jlog_ctx_open_reader failed: %d %s\n", subno, jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
croak();
}
fprintf(stderr, "[%02d] reader started\n", subno);
while(1) {
char begins[20], ends[20];
jlog_id begin, end;
int count;
jlog_message message;
if((count = jlog_ctx_read_interval(ctx, &begin, &end)) == -1) {
fprintf(stderr, "jlog_ctx_read_interval failed: %d %s\n", jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
croak();
}
jlog_snprint_logid(begins, sizeof(begins), &begin);
jlog_snprint_logid(ends, sizeof(ends), &end);
if(count > 0) {
int i;
//fprintf(stderr, "[%02d] reader (%s, %s] count: %d\n", subno, begins, ends, count);
for(i=0; i<count; i++, JLOG_ID_ADVANCE(&begin)) {
end = begin;
if(jlog_ctx_read_message(ctx, &begin, &message) != 0) {
if(jlog_ctx_err(ctx) == JLOG_ERR_CLOSE_LOGID) {
/* fine */
} else {
fcount++;
jlog_snprint_logid(begins, sizeof(begins), &begin);
fprintf(stderr, "[%02d] read failed @ %s: %d %s\n", subno, begins, jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
}
} else {
tcount++;
jlog_snprint_logid(begins, sizeof(begins), &begin);
/* fprintf(stderr, "[%02d] read: [%s]\n\t'%.*s'\n", subno, begins,
message.mess_len, (char *)message.mess); */
}
}
if(jlog_ctx_read_checkpoint(ctx, &end) != 0) {
fprintf(stderr, "[%02d] checkpoint failed: %d %s\n", subno, jlog_ctx_err(ctx), jlog_ctx_err_string(ctx));
} else {
fprintf(stderr, "[%02d] \tcheckpointed...\n", subno);
}
} else {
if(writer_done == 1) break;
}
}
fprintf(stderr, "[%02d] reader read %d, failed %d\n", subno, tcount, fcount);
jlog_ctx_close(ctx);
return (void *)(uintptr_t)tcount;
}