|
|
|
|
@ -3,6 +3,7 @@
|
|
|
|
|
#include <lighttpd/plugin_core.h>
|
|
|
|
|
|
|
|
|
|
static void li_server_listen_cb(struct ev_loop *loop, ev_io *w, int revents);
|
|
|
|
|
static void li_server_stop(liServer *srv);
|
|
|
|
|
|
|
|
|
|
static liServerSocket* server_socket_new(int fd) {
|
|
|
|
|
liServerSocket *sock = g_slice_new0(liServerSocket);
|
|
|
|
|
@ -58,18 +59,15 @@ static void server_setup_free(gpointer _ss) {
|
|
|
|
|
|
|
|
|
|
static void sigint_cb(struct ev_loop *loop, struct ev_signal *w, int revents) {
|
|
|
|
|
liServer *srv = (liServer*) w->data;
|
|
|
|
|
UNUSED(loop);
|
|
|
|
|
UNUSED(revents);
|
|
|
|
|
|
|
|
|
|
if (g_atomic_int_get(&srv->state) != LI_SERVER_STOPPING) {
|
|
|
|
|
if (g_atomic_int_get(&srv->dest_state) != LI_SERVER_DOWN) {
|
|
|
|
|
INFO(srv, "%s", "Got signal, shutdown");
|
|
|
|
|
li_server_stop(srv);
|
|
|
|
|
li_server_goto_state(srv, LI_SERVER_DOWN);
|
|
|
|
|
} else {
|
|
|
|
|
INFO(srv, "%s", "Got second signal, force shutdown");
|
|
|
|
|
|
|
|
|
|
/* reset default behaviour which will kill us the third time */
|
|
|
|
|
UNCATCH_SIGNAL(loop, INT);
|
|
|
|
|
UNCATCH_SIGNAL(loop, TERM);
|
|
|
|
|
UNCATCH_SIGNAL(loop, PIPE);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -82,7 +80,8 @@ liServer* li_server_new(const gchar *module_dir) {
|
|
|
|
|
liServer* srv = g_slice_new0(liServer);
|
|
|
|
|
|
|
|
|
|
srv->magic = LIGHTTPD_SERVER_MAGIC;
|
|
|
|
|
srv->state = LI_SERVER_STARTING;
|
|
|
|
|
srv->state = LI_SERVER_INIT;
|
|
|
|
|
srv->dest_state = LI_SERVER_RUNNING;
|
|
|
|
|
|
|
|
|
|
srv->workers = g_array_new(FALSE, TRUE, sizeof(liWorker*));
|
|
|
|
|
srv->worker_count = 0;
|
|
|
|
|
@ -115,6 +114,7 @@ liServer* li_server_new(const gchar *module_dir) {
|
|
|
|
|
log_init(srv);
|
|
|
|
|
|
|
|
|
|
srv->io_timeout = 300; /* default I/O timeout */
|
|
|
|
|
srv->keep_alive_queue_timeout = 5;
|
|
|
|
|
|
|
|
|
|
return srv;
|
|
|
|
|
}
|
|
|
|
|
@ -310,75 +310,69 @@ static void li_server_listen_cb(struct ev_loop *loop, ev_io *w, int revents) {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* main worker only */
|
|
|
|
|
void li_server_listen(liServer *srv, int fd) {
|
|
|
|
|
liServerSocket *sock = server_socket_new(fd);
|
|
|
|
|
|
|
|
|
|
sock->srv = srv;
|
|
|
|
|
g_ptr_array_add(srv->sockets, sock);
|
|
|
|
|
|
|
|
|
|
if (g_atomic_int_get(&srv->state) == LI_SERVER_RUNNING) ev_io_start(srv->main_worker->loop, &sock->watcher);
|
|
|
|
|
if (LI_SERVER_RUNNING == srv->state || LI_SERVER_WARMUP == srv->state) ev_io_start(srv->main_worker->loop, &sock->watcher);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void li_server_start(liServer *srv) {
|
|
|
|
|
static void li_server_start_listen(liServer *srv) {
|
|
|
|
|
guint i;
|
|
|
|
|
liServerState srvstate = g_atomic_int_get(&srv->state);
|
|
|
|
|
if (srvstate == LI_SERVER_STOPPING || srvstate == LI_SERVER_RUNNING) return; /* no restart after stop */
|
|
|
|
|
g_atomic_int_set(&srv->state, LI_SERVER_RUNNING);
|
|
|
|
|
|
|
|
|
|
if (!srv->mainaction) {
|
|
|
|
|
ERROR(srv, "%s", "No action handlers defined");
|
|
|
|
|
li_server_stop(srv);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
srv->keep_alive_queue_timeout = 5;
|
|
|
|
|
|
|
|
|
|
li_plugins_prepare_callbacks(srv);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < srv->sockets->len; i++) {
|
|
|
|
|
liServerSocket *sock = g_ptr_array_index(srv->sockets, i);
|
|
|
|
|
ev_io_start(srv->main_worker->loop, &sock->watcher);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
srv->started = ev_now(srv->main_worker->loop);
|
|
|
|
|
{
|
|
|
|
|
GString *str = li_worker_current_timestamp(srv->main_worker, LI_LOCALTIME, LI_TS_FORMAT_DEFAULT);
|
|
|
|
|
srv->started = ev_now(srv->main_worker->loop);
|
|
|
|
|
srv->started_str = g_string_new_len(GSTR_LEN(str));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
log_thread_start(srv);
|
|
|
|
|
|
|
|
|
|
li_worker_run(srv->main_worker);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void li_server_stop(liServer *srv) {
|
|
|
|
|
static void li_server_stop_listen(liServer *srv) {
|
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
if (g_atomic_int_get(&srv->state) == LI_SERVER_STOPPING) return;
|
|
|
|
|
g_atomic_int_set(&srv->state, LI_SERVER_STOPPING);
|
|
|
|
|
for (i = 0; i < srv->sockets->len; i++) {
|
|
|
|
|
liServerSocket *sock = g_ptr_array_index(srv->sockets, i);
|
|
|
|
|
ev_io_stop(srv->main_worker->loop, &sock->watcher);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (srv->main_worker) {
|
|
|
|
|
for (i = 0; i < srv->sockets->len; i++) {
|
|
|
|
|
liServerSocket *sock = g_ptr_array_index(srv->sockets, i);
|
|
|
|
|
ev_io_stop(srv->main_worker->loop, &sock->watcher);
|
|
|
|
|
}
|
|
|
|
|
/* suspend all workers (close keep-alive connections) */
|
|
|
|
|
for (i = 0; i < srv->worker_count; i++) {
|
|
|
|
|
liWorker *wrk;
|
|
|
|
|
wrk = g_array_index(srv->workers, liWorker*, i);
|
|
|
|
|
li_worker_suspend(srv->main_worker, wrk);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* stop all workers */
|
|
|
|
|
for (i = 0; i < srv->worker_count; i++) {
|
|
|
|
|
liWorker *wrk;
|
|
|
|
|
wrk = g_array_index(srv->workers, liWorker*, i);
|
|
|
|
|
li_worker_stop(srv->main_worker, wrk);
|
|
|
|
|
}
|
|
|
|
|
static void li_server_stop(liServer *srv) {
|
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < srv->sockets->len; i++) {
|
|
|
|
|
liServerSocket *sock = g_ptr_array_index(srv->sockets, i);
|
|
|
|
|
ev_io_stop(srv->main_worker->loop, &sock->watcher);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
log_thread_wakeup(srv);
|
|
|
|
|
/* stop all workers */
|
|
|
|
|
for (i = 0; i < srv->worker_count; i++) {
|
|
|
|
|
liWorker *wrk;
|
|
|
|
|
wrk = g_array_index(srv->workers, liWorker*, i);
|
|
|
|
|
li_worker_stop(srv->main_worker, wrk);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void li_server_exit(liServer *srv) {
|
|
|
|
|
li_server_stop(srv);
|
|
|
|
|
|
|
|
|
|
g_atomic_int_set(&srv->exiting, TRUE);
|
|
|
|
|
g_atomic_int_set(&srv->state, LI_SERVER_DOWN);
|
|
|
|
|
g_atomic_int_set(&srv->dest_state, LI_SERVER_DOWN);
|
|
|
|
|
|
|
|
|
|
/* exit all workers */
|
|
|
|
|
{
|
|
|
|
|
@ -444,3 +438,206 @@ guint li_server_ts_format_add(liServer *srv, GString* format) {
|
|
|
|
|
g_array_append_val(srv->ts_formats, format);
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* state machine: call this functions only in the main worker context */
|
|
|
|
|
/* Note: main worker doesn't need atomic read for state */
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
case LI_SERVER_INIT:
|
|
|
|
|
case LI_SERVER_LOADING:
|
|
|
|
|
case LI_SERVER_SUSPENDED:
|
|
|
|
|
case LI_SERVER_WARMUP:
|
|
|
|
|
case LI_SERVER_RUNNING:
|
|
|
|
|
case LI_SERVER_SUSPENDING:
|
|
|
|
|
case LI_SERVER_STOPPING:
|
|
|
|
|
case LI_SERVER_DOWN:
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static const gchar* li_server_state_string(liServerState state) {
|
|
|
|
|
switch (state) {
|
|
|
|
|
case LI_SERVER_INIT: return "init";
|
|
|
|
|
case LI_SERVER_LOADING: return "loading";
|
|
|
|
|
case LI_SERVER_SUSPENDED: return "suspended";
|
|
|
|
|
case LI_SERVER_WARMUP: return "warmup";
|
|
|
|
|
case LI_SERVER_RUNNING: return "running";
|
|
|
|
|
case LI_SERVER_SUSPENDING: return "suspending";
|
|
|
|
|
case LI_SERVER_STOPPING: return "stopping";
|
|
|
|
|
case LI_SERVER_DOWN: return "down";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return "<unkown>";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* next state in the machine we want to reach to reach */
|
|
|
|
|
static liServerState li_server_next_state(liServer *srv) {
|
|
|
|
|
switch (srv->state) {
|
|
|
|
|
case LI_SERVER_INIT:
|
|
|
|
|
return LI_SERVER_LOADING;
|
|
|
|
|
case LI_SERVER_LOADING:
|
|
|
|
|
if (LI_SERVER_DOWN == srv->dest_state) return LI_SERVER_STOPPING;
|
|
|
|
|
return LI_SERVER_SUSPENDED;
|
|
|
|
|
case LI_SERVER_SUSPENDED:
|
|
|
|
|
switch (srv->dest_state) {
|
|
|
|
|
case LI_SERVER_INIT:
|
|
|
|
|
case LI_SERVER_LOADING:
|
|
|
|
|
case LI_SERVER_SUSPENDED:
|
|
|
|
|
return LI_SERVER_SUSPENDED;
|
|
|
|
|
case LI_SERVER_WARMUP:
|
|
|
|
|
case LI_SERVER_RUNNING:
|
|
|
|
|
case LI_SERVER_SUSPENDING:
|
|
|
|
|
return LI_SERVER_WARMUP;
|
|
|
|
|
case LI_SERVER_STOPPING:
|
|
|
|
|
case LI_SERVER_DOWN:
|
|
|
|
|
return LI_SERVER_STOPPING;
|
|
|
|
|
}
|
|
|
|
|
return LI_SERVER_DOWN;
|
|
|
|
|
case LI_SERVER_WARMUP:
|
|
|
|
|
if (LI_SERVER_WARMUP == srv->dest_state) return LI_SERVER_WARMUP;
|
|
|
|
|
return LI_SERVER_RUNNING;
|
|
|
|
|
case LI_SERVER_RUNNING:
|
|
|
|
|
if (LI_SERVER_RUNNING == srv->dest_state) return LI_SERVER_RUNNING;
|
|
|
|
|
return LI_SERVER_SUSPENDING;
|
|
|
|
|
case LI_SERVER_SUSPENDING:
|
|
|
|
|
if (LI_SERVER_RUNNING == srv->dest_state) return LI_SERVER_RUNNING;
|
|
|
|
|
if (LI_SERVER_SUSPENDING == srv->dest_state) return LI_SERVER_SUSPENDING;
|
|
|
|
|
return LI_SERVER_SUSPENDED;
|
|
|
|
|
case LI_SERVER_STOPPING:
|
|
|
|
|
case LI_SERVER_DOWN:
|
|
|
|
|
return LI_SERVER_DOWN;
|
|
|
|
|
}
|
|
|
|
|
return LI_SERVER_DOWN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void li_server_start_transition(liServer *srv, liServerState state) {
|
|
|
|
|
guint i;
|
|
|
|
|
DEBUG(srv, "Try reaching state: %s (dest: %s)", li_server_state_string(state), li_server_state_string(srv->dest_state));
|
|
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
|
case LI_SERVER_INIT:
|
|
|
|
|
case LI_SERVER_LOADING:
|
|
|
|
|
case LI_SERVER_SUSPENDED:
|
|
|
|
|
/* TODO: wait for prepare / suspended */
|
|
|
|
|
li_server_reached_state(srv, LI_SERVER_SUSPENDED);
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_WARMUP:
|
|
|
|
|
li_server_start_listen(srv);
|
|
|
|
|
li_plugins_start_listen(srv);
|
|
|
|
|
li_server_reached_state(srv, LI_SERVER_WARMUP);
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_RUNNING:
|
|
|
|
|
if (LI_SERVER_WARMUP == srv->state) {
|
|
|
|
|
li_plugins_start_log(srv);
|
|
|
|
|
li_server_reached_state(srv, LI_SERVER_RUNNING);
|
|
|
|
|
} else if (LI_SERVER_SUSPENDING == srv->state) {
|
|
|
|
|
li_server_start_listen(srv);
|
|
|
|
|
li_plugins_start_listen(srv);
|
|
|
|
|
li_server_reached_state(srv, LI_SERVER_RUNNING);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_SUSPENDING:
|
|
|
|
|
li_server_stop_listen(srv);
|
|
|
|
|
li_plugins_stop_listen(srv);
|
|
|
|
|
/* wait for closed connections and plugins */
|
|
|
|
|
/* TODO: wait */
|
|
|
|
|
li_server_reached_state(srv, LI_SERVER_SUSPENDING);
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_STOPPING:
|
|
|
|
|
/* stop all workers */
|
|
|
|
|
for (i = 0; i < srv->worker_count; i++) {
|
|
|
|
|
liWorker *wrk;
|
|
|
|
|
wrk = g_array_index(srv->workers, liWorker*, i);
|
|
|
|
|
li_worker_stop(srv->main_worker, wrk);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
log_thread_wakeup(srv);
|
|
|
|
|
li_server_reached_state(srv, LI_SERVER_STOPPING);
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_DOWN:
|
|
|
|
|
/* wait */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void li_server_goto_state(liServer *srv, liServerState state) {
|
|
|
|
|
if (srv->dest_state == LI_SERVER_DOWN || srv->dest_state == state) return; /* cannot undo this */
|
|
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
|
case LI_SERVER_INIT:
|
|
|
|
|
case LI_SERVER_LOADING:
|
|
|
|
|
case LI_SERVER_SUSPENDING:
|
|
|
|
|
case LI_SERVER_STOPPING:
|
|
|
|
|
return; /* invalid dest states */
|
|
|
|
|
case LI_SERVER_WARMUP:
|
|
|
|
|
case LI_SERVER_RUNNING:
|
|
|
|
|
case LI_SERVER_SUSPENDED:
|
|
|
|
|
case LI_SERVER_DOWN:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_atomic_int_set(&srv->dest_state, state);
|
|
|
|
|
|
|
|
|
|
if (srv->dest_state != srv->state) {
|
|
|
|
|
liServerState want_state = li_server_next_state(srv);
|
|
|
|
|
li_server_start_transition(srv, want_state);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void li_server_reached_state(liServer *srv, liServerState state) {
|
|
|
|
|
liServerState want_state = li_server_next_state(srv);
|
|
|
|
|
liServerState old_state = srv->state;
|
|
|
|
|
|
|
|
|
|
if (state != want_state) return;
|
|
|
|
|
if (state == srv->state) return;
|
|
|
|
|
|
|
|
|
|
g_atomic_int_set(&srv->state, state);
|
|
|
|
|
DEBUG(srv, "Reached state: %s (dest: %s)", li_server_state_string(state), li_server_state_string(srv->dest_state));
|
|
|
|
|
|
|
|
|
|
switch (srv->state) {
|
|
|
|
|
case LI_SERVER_INIT:
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_LOADING:
|
|
|
|
|
li_plugins_prepare_callbacks(srv);
|
|
|
|
|
li_server_worker_init(srv);
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
GString *str = li_worker_current_timestamp(srv->main_worker, LI_LOCALTIME, LI_TS_FORMAT_DEFAULT);
|
|
|
|
|
srv->started = ev_now(srv->main_worker->loop);
|
|
|
|
|
srv->started_str = g_string_new_len(GSTR_LEN(str));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
log_thread_start(srv);
|
|
|
|
|
|
|
|
|
|
li_plugins_prepare(srv);
|
|
|
|
|
/* wait for plugins to report success */
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_SUSPENDED:
|
|
|
|
|
if (LI_SERVER_SUSPENDING == old_state) {
|
|
|
|
|
li_plugins_stop_log(srv);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_WARMUP:
|
|
|
|
|
case LI_SERVER_RUNNING:
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_SUSPENDING:
|
|
|
|
|
case LI_SERVER_STOPPING:
|
|
|
|
|
break;
|
|
|
|
|
case LI_SERVER_DOWN:
|
|
|
|
|
/* li_server_exit(srv); */
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (srv->acon) {
|
|
|
|
|
GString *data = g_string_new(li_server_state_string(srv->state));
|
|
|
|
|
GError *err = NULL;
|
|
|
|
|
|
|
|
|
|
if (!li_angel_send_simple_call(srv->acon, CONST_STR_LEN("core"), CONST_STR_LEN("reached-state"), data, &err)) {
|
|
|
|
|
GERROR(srv, err, "%s", "couldn't send state update to angel");
|
|
|
|
|
g_error_free(err);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (srv->dest_state != srv->state) {
|
|
|
|
|
want_state = li_server_next_state(srv);
|
|
|
|
|
li_server_start_transition(srv, want_state);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
