static gpointer
_thread_cb_events(gpointer d)
{
struct network_server_s *srv = d;
time_t now, last;
metautils_ignore_signals();
GRID_INFO("EVENTS thread starting pfd=%d", srv->epollfd);
now = last = network_server_bogonow(srv);
while (srv->flag_continue) {
_manage_events(srv);
now = network_server_bogonow(srv);
if (now > last + 30 || now < last) {
_server_shutdown_inactive_connections(srv);
last = now;
}
}
/* XXX the server connections are being closed in the main thread that
* received the exit signal. They will be removed automatically from
* the epoll pool.*/
while (0 < srv->cnx_clients) {
_manage_events(srv);
_server_shutdown_inactive_connections(srv);
}
return d;
}
static gpointer
_worker_queue (gpointer p)
{
metautils_ignore_signals();
struct sqlx_service_s *ss = PSRV(p);
if (ss && ss->events_queue)
oio_events_queue__run (ss->events_queue, _event_running);
return p;
}
static gpointer
_thread_cb_worker(gpointer td)
{
struct grid_stats_holder_s *local_stats = NULL;
time_t last_update, last_not_idle;
struct network_server_s *srv = td;
metautils_ignore_signals();
_thread_maybe_become_first(srv);
last_update = last_not_idle = network_server_bogonow(srv);
local_stats = grid_stats_holder_init();
GRID_DEBUG("Thread starting for srv %p", srv);
while (srv->flag_continue || srv->cnx_clients > 0) {
struct network_client_s *clt = get_next_client(srv);
if (!clt) {
gboolean expired = network_server_bogonow(srv) >
(last_not_idle + srv->workers_max_idle_delay);
if (expired && _thread_can_die(srv)) {
GRID_DEBUG("Thread idle for too long, exiting!");
goto label_exit;
}
}
else { /* something happened */
EXTRA_ASSERT(clt->server == srv);
_thread_become_active(srv);
last_not_idle = network_server_bogonow(srv);
clt->local_stats = local_stats;
_work_on_client(srv, clt);
_thread_become_inactive(srv);
}
/* periodically merge the local stats in the main stats */
if (last_update < network_server_bogonow(srv)) {
grid_stats_holder_increment_merge(srv->stats, local_stats);
grid_stats_holder_zero(local_stats);
last_update = network_server_bogonow(srv);
}
}
/* thread exiting due to a server stop */
GRID_DEBUG("Thread exiting for srv %p", srv);
_thread_stop(srv);
label_exit:
if (local_stats) {
grid_stats_holder_increment_merge(srv->stats, local_stats);
grid_stats_holder_clean(local_stats);
}
return td;
}
static gpointer
_worker_clients(gpointer p)
{
metautils_ignore_signals();
while (grid_main_is_running()) {
GError *err = gridd_client_pool_round(PSRV(p)->clients_pool, 1);
if (err != NULL) {
GRID_ERROR("Clients error : (%d) %s", err->code, err->message);
g_clear_error(&err);
grid_main_stop();
}
}
return p;
}
static gpointer
_gtq_worker(gpointer p)
{
metautils_ignore_signals();
struct grid_task_queue_s *gtq = p;
GRID_DEBUG("TaskQueue started [%s]", gtq->name);
while (!gtq->stopped) {
g_usleep(G_USEC_PER_SEC);
grid_task_queue_fire(gtq);
}
GRID_DEBUG("TaskQueue exiting [%s]", gtq->name);
return gtq;
}
// TODO: factorize with the similar function in sqliterepo/synchro.h
static void
zk_main_watch(zhandle_t *zh, int type, int state, const char *path,
void *watcherCtx)
{
metautils_ignore_signals();
GRID_DEBUG("%s(%p,%d,%d,%s,%p)", __FUNCTION__,
zh, type, state, path, watcherCtx);
struct zk_manager_s *manager = watcherCtx;
const char *zkurl = manager->zk_url;
if (type != ZOO_SESSION_EVENT)
return;
if (state == ZOO_EXPIRED_SESSION_STATE) {
GRID_WARN("Zookeeper: (re)connecting to [%s]", zkurl);
if (manager->zh)
zookeeper_close(manager->zh);
/* XXX(jfs): forget the previous ID and reconnect */
manager->zh = zookeeper_init(manager->zk_url, zk_main_watch,
SQLX_SYNC_DEFAULT_ZK_TIMEOUT, NULL, manager, 0);
if (!manager->zh) {
GRID_ERROR("ZooKeeper init failure: (%d) %s",
errno, strerror(errno));
abort();
}
}
else if (state == ZOO_AUTH_FAILED_STATE) {
GRID_WARN("Zookeeper: auth problem to [%s]", zkurl);
}
else if (state == ZOO_ASSOCIATING_STATE) {
GRID_DEBUG("Zookeeper: associating to [%s]", zkurl);
}
else if (state == ZOO_CONNECTED_STATE) {
GRID_INFO("Zookeeper: connected to [%s]", zkurl);
}
else {
GRID_INFO("Zookeeper: unmanaged event [%s]", zkurl);
}
}
