/* 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); }