/* not every context has srv ready, extract from context instead */
static void mc_ctx_release(liServer *_srv, gpointer param) {
memcached_ctx *ctx = param;
liServer *srv;
guint i;
UNUSED(_srv);
if (NULL == ctx) return;
srv = ctx->srv;
assert(g_atomic_int_get(&ctx->refcount) > 0);
if (!g_atomic_int_dec_and_test(&ctx->refcount)) return;
if (ctx->worker_client_ctx) {
for (i = 0; i < srv->worker_count; i++) {
li_memcached_con_release(ctx->worker_client_ctx[i]);
}
g_slice_free1(sizeof(liMemcachedCon*) * srv->worker_count, ctx->worker_client_ctx);
}
li_sockaddr_clear(&ctx->addr);
li_pattern_free(ctx->pattern);
li_action_release(srv, ctx->act_found);
li_action_release(srv, ctx->act_miss);
if (ctx->mconf_link.data) { /* still in LI_SERVER_INIT */
memcached_config *mconf = ctx->p->data;
g_queue_unlink(&mconf->prepare_ctx, &ctx->mconf_link);
ctx->mconf_link.data = NULL;
}
ctx->srv = NULL;
g_slice_free(memcached_ctx, ctx);
}
void li_value_clear(liValue *val) {
if (NULL == val) return;
switch (val->type) {
case LI_VALUE_NONE:
case LI_VALUE_BOOLEAN:
case LI_VALUE_NUMBER:
/* Nothing to free */
break;
case LI_VALUE_STRING:
g_string_free(val->data.string, TRUE);
break;
case LI_VALUE_LIST:
li_value_list_free(val->data.list);
break;
case LI_VALUE_HASH:
g_hash_table_destroy(val->data.hash);
break;
case LI_VALUE_ACTION:
li_action_release(val->data.val_action.srv, val->data.val_action.action);
break;
case LI_VALUE_CONDITION:
li_condition_release(val->data.val_cond.srv, val->data.val_cond.cond);
break;
}
_li_value_clear(val);
}
static void balancer_free(liServer *srv, balancer *b) {
guint i;
if (!b) return;
g_mutex_free(b->lock);
ev_timer_stop(b->wrk->loop, &b->backlog_timer);
li_ev_safe_ref_and_stop(ev_async_stop, b->wrk->loop, &b->async);
for (i = 0; i < b->backends->len; i++) {
backend *be = &g_array_index(b->backends, backend, i);
li_action_release(srv, be->act);
}
g_array_free(b->backends, TRUE);
g_slice_free(balancer, b);
}
static void balancer_free(liServer *srv, balancer *b) {
guint i;
if (!b) return;
g_mutex_free(b->lock);
li_event_clear(&b->backlog_timer);
li_event_clear(&b->async);
for (i = 0; i < b->backends->len; i++) {
backend *be = &g_array_index(b->backends, backend, i);
li_action_release(srv, be->act);
}
g_array_free(b->backends, TRUE);
g_slice_free(balancer, b);
}
void li_value_clear(liValue *val) {
if (NULL == val) return;
switch (val->type) {
case LI_VALUE_ACTION:
li_action_release(val->data.val_action.srv, val->data.val_action.action);
_li_value_clear(val);
break;
case LI_VALUE_CONDITION:
li_condition_release(val->data.val_cond.srv, val->data.val_cond.cond);
_li_value_clear(val);
break;
default:
li_common_value_clear_(val);
}
}
static liHandlerResult lua_handle(liVRequest *vr, gpointer param, gpointer *context) {
lua_config *conf = (lua_config*) param;
lua_worker_config *wc;
gboolean timeout = FALSE;
liHandlerResult res;
UNUSED(context);
wc = &conf->worker_config[vr->wrk->ndx];
if (wc->act) timeout = (conf->ttl > 0 && wc->ts_loaded + conf->ttl < li_cur_ts(vr->wrk));
if (!wc->act || timeout) {
int err;
struct stat st;
time_t last_load;
res = li_stat_cache_get(vr, conf->filename, &st, &err, NULL);
switch (res) {
case LI_HANDLER_ERROR:
VR_ERROR(vr, "lua.handler: couldn't stat file '%s': %s", conf->filename->str, g_strerror(err));
return LI_HANDLER_ERROR;
case LI_HANDLER_WAIT_FOR_EVENT:
return LI_HANDLER_WAIT_FOR_EVENT;
default:
break;
}
last_load = wc->ts_loaded;
wc->ts_loaded = li_cur_ts(vr->wrk);
if (timeout && st.st_mtime <= last_load) {
goto loaded;
}
li_action_release(vr->wrk->srv, wc->act);
wc->act = NULL;
if (!li_config_lua_load(&vr->wrk->LL, vr->wrk->srv, vr->wrk, conf->filename->str, &wc->act, FALSE, conf->args) || !wc->act) {
VR_ERROR(vr, "lua.handler: couldn't load '%s'", conf->filename->str);
return LI_HANDLER_ERROR;
}
}
loaded:
li_action_enter(vr, wc->act);
return LI_HANDLER_GO_ON;
}
void li_release_optionptr(liServer *srv, liOptionPtrValue *value) {
liServerOptionPtr *sopt;
LI_FORCE_ASSERT(NULL != srv);
if (NULL == value) return;
LI_FORCE_ASSERT(g_atomic_int_get(&value->refcount) > 0);
if (!g_atomic_int_dec_and_test(&value->refcount)) return;
sopt = value->sopt;
value->sopt = NULL;
if (!sopt->free_option) {
switch (sopt->type) {
case LI_VALUE_NONE:
case LI_VALUE_BOOLEAN:
case LI_VALUE_NUMBER:
/* Nothing to free */
break;
case LI_VALUE_STRING:
if (value->data.string)
g_string_free(value->data.string, TRUE);
break;
case LI_VALUE_LIST:
if (value->data.list)
li_value_list_free(value->data.list);
break;
case LI_VALUE_ACTION:
if (value->data.action)
li_action_release(srv, value->data.action);
break;
case LI_VALUE_CONDITION:
if (value->data.cond)
li_condition_release(srv, value->data.cond);
break;
}
} else {
sopt->free_option(srv, sopt->p, sopt->module_index, value->data.ptr);
}
g_slice_free(liOptionPtrValue, value);
}
static void mod_limit_context_free(liServer *srv, mod_limit_context *ctx) {
if (ctx->mutex)
g_mutex_free(ctx->mutex);
if (ctx->action_limit_reached) {
li_action_release(srv, ctx->action_limit_reached);
}
switch (ctx->type) {
case ML_TYPE_CON:
break;
case ML_TYPE_CON_IP:
li_radixtree_free(ctx->pool.con_ip, NULL, NULL);
break;
case ML_TYPE_REQ:
break;
case ML_TYPE_REQ_IP:
li_radixtree_free(ctx->pool.req_ip, NULL, NULL);
break;
}
g_slice_free(mod_limit_context, ctx);
}
static void lua_config_free(liServer *srv, gpointer param) {
lua_config *conf = (lua_config*) param;
UNUSED(srv);
if (conf->worker_config) {
lua_worker_config *wc = conf->worker_config;
guint i;
for (i = 0; i < srv->worker_count; i++) {
li_action_release(srv, wc[i].act);
}
g_slice_free1(sizeof(lua_worker_config) * srv->worker_count, wc);
}
g_string_free(conf->filename, TRUE);
li_value_free(conf->args);
if (conf->mconf_link.data) { /* still in LI_SERVER_INIT */
module_config *mc = conf->p->data;
g_queue_unlink(&mc->lua_configs, &conf->mconf_link);
conf->mconf_link.data = NULL;
}
g_slice_free(lua_config, conf);
}
