int
stratcon_realtime_http_postresolve(eventer_t e, int mask, void *closure,
struct timeval *now) {
noit_http_session_ctx *ctx = closure;
realtime_context *rc = ctx->dispatcher_closure;
struct realtime_tracker *node;
for(node = rc->checklist; node; node = node->next) {
if(node->noit) {
realtime_recv_ctx_t *rrctx;
rrctx = calloc(1, sizeof(*rrctx));
rrctx->ctx = ctx;
rrctx->rt = node;
stratcon_streamer_connection(NULL, node->noit,
stratcon_realtime_recv_handler,
NULL, rrctx,
free_realtime_recv_ctx);
}
else
noit_atomic_dec32(&ctx->ref_cnt);
}
if(ctx->ref_cnt == 1) {
noit_http_response_end(ctx);
clear_realtime_context(rc);
if(ctx->conn.e) eventer_trigger(ctx->conn.e, EVENTER_WRITE);
}
return 0;
}
static int
stratcon_datastore_journal_sync(eventer_t e, int mask, void *closure,
struct timeval *now) {
noit_hash_iter iter = NOIT_HASH_ITER_ZERO;
const char *k;
int klen;
void *vij;
interim_journal_t *ij;
syncset_t *syncset = closure;
if((mask & EVENTER_ASYNCH) == EVENTER_ASYNCH) {
if(syncset->completion) {
eventer_add(syncset->completion);
eventer_trigger(syncset->completion, EVENTER_READ | EVENTER_WRITE);
}
free(syncset);
return 0;
}
if(!((mask & EVENTER_ASYNCH_WORK) == EVENTER_ASYNCH_WORK)) return 0;
noitL(ds_deb, "Syncing journal sets...\n");
if (syncset->ws) {
while(noit_hash_next(syncset->ws, &iter, &k, &klen, &vij)) {
char tmppath[PATH_MAX], id_str[32];
int suffix_idx;
ij = vij;
noitL(ds_deb, "Syncing journal set [%s,%s,%s]\n",
ij->remote_str, ij->remote_cn, ij->fqdn);
strlcpy(tmppath, ij->filename, sizeof(tmppath));
suffix_idx = strlen(ij->filename) - 4; /* . t m p */
ij->filename[suffix_idx] = '\0';
if(rename(tmppath, ij->filename) != 0) {
if(errno == EEXIST) {
unlink(ij->filename);
if(rename(tmppath, ij->filename) != 0) goto rename_failed;
}
else {
rename_failed:
noitL(noit_error, "rename failed(%s): (%s->%s)\n", strerror(errno),
tmppath, ij->filename);
exit(-1);
}
}
fsync(ij->fd);
close(ij->fd);
ij->fd = -1;
snprintf(id_str, sizeof(id_str), "%d", ij->storagenode_id);
stratcon_ingest(ij->filename, ij->remote_str,
ij->remote_cn, id_str);
}
noit_hash_destroy(syncset->ws, free, interim_journal_free);
free(syncset->ws);
}
else {
noitL(noit_error, "attempted to sync non-existing working set\n");
}
return 0;
}
static void
free_realtime_recv_ctx(void *vctx) {
realtime_recv_ctx_t *rrctx = vctx;
noit_http_session_ctx *ctx = rrctx->ctx;
realtime_context *rc = ctx->dispatcher_closure;
if(noit_atomic_dec32(&ctx->ref_cnt) == 1) {
noit_http_response_end(ctx);
clear_realtime_context(rc);
if(ctx->conn.e) eventer_trigger(ctx->conn.e, EVENTER_WRITE | EVENTER_EXCEPTION);
}
free(rrctx);
}
static void
rest_test_check_result(struct check_test_closure *cl) {
mtev_http_session_ctx *ctx = cl->restc->http_ctx;
mtevL(nlerr, "Flushing check test result\n");
if(cl->restc->call_closure_free)
cl->restc->call_closure_free(cl->restc->call_closure);
cl->restc->call_closure_free = NULL;
cl->restc->call_closure = NULL;
cl->restc->fastpath = NULL;
if(ctx) {
eventer_t conne;
if(cl->output == WANTS_JSON) {
struct json_object *doc;
const char *jsonstr;
doc = noit_check_state_as_json(cl->check, 1);
mtev_http_response_ok(ctx, "application/json");
jsonstr = json_object_to_json_string(doc);
mtev_http_response_append(ctx, jsonstr, strlen(jsonstr));
mtev_http_response_append(ctx, "\n", 1);
json_object_put(doc);
} else {
xmlDocPtr doc = NULL;
xmlNodePtr root, state;
doc = xmlNewDoc((xmlChar *)"1.0");
root = xmlNewDocNode(doc, NULL, (xmlChar *)"check", NULL);
xmlDocSetRootElement(doc, root);
state = noit_check_state_as_xml(cl->check, 1);
xmlAddChild(root, state);
mtev_http_response_ok(ctx, "text/xml");
mtev_http_response_xml(ctx, doc);
xmlFreeDoc(doc);
}
mtev_http_response_end(ctx);
conne = mtev_http_connection_event(mtev_http_session_connection(ctx));
if(conne) {
// The event already exists, why re-add it? Did we want to update it?
//eventer_add(conne);
eventer_trigger(conne, EVENTER_READ | EVENTER_WRITE);
}
}
noit_poller_free_check(cl->check);
free(cl);
}
static int
lua_web_resume(mtev_lua_resume_info_t *ri, int nargs) {
const char *err = NULL;
int status, base, rv = 0;
mtev_lua_resume_rest_info_t *ctx = ri->context_data;
mtev_http_rest_closure_t *restc = ctx->restc;
eventer_t conne = mtev_http_connection_event(mtev_http_session_connection(restc->http_ctx));
assert(pthread_equal(pthread_self(), ri->bound_thread));
#if LUA_VERSION_NUM >= 502
status = lua_resume(ri->coro_state, ri->lmc->lua_state, nargs);
#else
status = lua_resume(ri->coro_state, nargs);
#endif
switch(status) {
case 0: break;
case LUA_YIELD:
lua_gc(ri->coro_state, LUA_GCCOLLECT, 0);
return 0;
default: /* The complicated case */
ctx->httpcode = 500;
base = lua_gettop(ri->coro_state);
if(base>=0) {
if(lua_isstring(ri->coro_state, base-1)) {
err = lua_tostring(ri->coro_state, base-1);
mtevL(mtev_error, "err -> %s\n", err);
if(!ctx->err) ctx->err = strdup(err);
}
}
rv = -1;
}
lua_web_restc_fastpath(restc, 0, NULL);
eventer_add(conne);
eventer_trigger(conne, EVENTER_READ|EVENTER_WRITE);
return rv;
}
static void
rest_test_check_result(struct check_test_closure *cl) {
xmlDocPtr doc = NULL;
xmlNodePtr root, state;
noit_http_session_ctx *ctx = cl->restc->http_ctx;
noitL(nlerr, "Flushing check test result\n");
if(cl->restc->call_closure_free)
cl->restc->call_closure_free(cl->restc->call_closure);
cl->restc->call_closure_free = NULL;
cl->restc->call_closure = NULL;
cl->restc->fastpath = NULL;
if(ctx) {
eventer_t conne = noit_http_connection_event(noit_http_session_connection(ctx));
doc = xmlNewDoc((xmlChar *)"1.0");
root = xmlNewDocNode(doc, NULL, (xmlChar *)"check", NULL);
xmlDocSetRootElement(doc, root);
state = noit_check_state_as_xml(cl->check);
xmlAddChild(root, state);
noit_http_response_ok(ctx, "text/xml");
noit_http_response_xml(ctx, doc);
noit_http_response_end(ctx);
if(conne) {
// The event already exists, why re-add it? Did we want to update it?
//eventer_add(conne);
eventer_trigger(conne, EVENTER_READ | EVENTER_WRITE);
}
}
noit_poller_free_check(cl->check);
xmlFreeDoc(doc);
free(cl);
}
