Return to mod_magnet_cache.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src

Annotation of embedaddon/lighttpd/src/mod_magnet_cache.c, revision 1.1.1.1

1.1       misho       1: #include "mod_magnet_cache.h"
                      2: #include "stat_cache.h"
                      3: 
                      4: #include <stdlib.h>
                      5: #include <time.h>
                      6: #include <assert.h>
                      7: 
                      8: #ifdef HAVE_LUA_H
                      9: #include <lualib.h>
                     10: #include <lauxlib.h>
                     11: 
                     12: static script *script_init() {
                     13:        script *sc;
                     14: 
                     15:        sc = calloc(1, sizeof(*sc));
                     16:        sc->name = buffer_init();
                     17:        sc->etag = buffer_init();
                     18: 
                     19:        return sc;
                     20: }
                     21: 
                     22: static void script_free(script *sc) {
                     23:        if (!sc) return;
                     24: 
                     25:        lua_pop(sc->L, 1); /* the function copy */
                     26: 
                     27:        buffer_free(sc->name);
                     28:        buffer_free(sc->etag);
                     29: 
                     30:        lua_close(sc->L);
                     31: 
                     32:        free(sc);
                     33: }
                     34: 
                     35: script_cache *script_cache_init() {
                     36:        script_cache *p;
                     37: 
                     38:        p = calloc(1, sizeof(*p));
                     39: 
                     40:        return p;
                     41: }
                     42: 
                     43: void script_cache_free(script_cache *p) {
                     44:        size_t i;
                     45: 
                     46:        if (!p) return;
                     47: 
                     48:        for (i = 0; i < p->used; i++) {
                     49:                script_free(p->ptr[i]);
                     50:        }
                     51: 
                     52:        free(p->ptr);
                     53: 
                     54:        free(p);
                     55: }
                     56: 
                     57: lua_State *script_cache_get_script(server *srv, connection *con, script_cache *cache, buffer *name) {
                     58:        size_t i;
                     59:        script *sc = NULL;
                     60:        stat_cache_entry *sce;
                     61: 
                     62:        for (i = 0; i < cache->used; i++) {
                     63:                sc = cache->ptr[i];
                     64: 
                     65:                if (buffer_is_equal(name, sc->name)) {
                     66:                        sc->last_used = time(NULL);
                     67: 
                     68:                        /* oops, the script failed last time */
                     69: 
                     70:                        if (lua_gettop(sc->L) == 0) break;
                     71: 
                     72:                        if (HANDLER_ERROR == stat_cache_get_entry(srv, con, sc->name, &sce)) {
                     73:                                lua_pop(sc->L, 1); /* pop the old function */
                     74:                                break;
                     75:                        }
                     76: 
                     77:                        if (!buffer_is_equal(sce->etag, sc->etag)) {
                     78:                                /* the etag is outdated, reload the function */
                     79:                                lua_pop(sc->L, 1);
                     80:                                break;
                     81:                        }
                     82: 
                     83:                        assert(lua_isfunction(sc->L, -1));
                     84:                        lua_pushvalue(sc->L, -1); /* copy the function-reference */
                     85: 
                     86:                        return sc->L;
                     87:                }
                     88: 
                     89:                sc = NULL;
                     90:        }
                     91: 
                     92:        /* if the script was script already loaded but either got changed or
                     93:         * failed to load last time */
                     94:        if (sc == NULL) {
                     95:                sc = script_init();
                     96: 
                     97:                if (cache->size == 0) {
                     98:                        cache->size = 16;
                     99:                        cache->ptr = malloc(cache->size * sizeof(*(cache->ptr)));
                    100:                } else if (cache->used == cache->size) {
                    101:                        cache->size += 16;
                    102:                        cache->ptr = realloc(cache->ptr, cache->size * sizeof(*(cache->ptr)));
                    103:                }
                    104: 
                    105:                cache->ptr[cache->used++] = sc;
                    106: 
                    107:                buffer_copy_string_buffer(sc->name, name);
                    108: 
                    109:                sc->L = luaL_newstate();
                    110:                luaL_openlibs(sc->L);
                    111:        }
                    112: 
                    113:        sc->last_used = time(NULL);
                    114: 
                    115:        if (0 != luaL_loadfile(sc->L, name->ptr)) {
                    116:                /* oops, an error, return it */
                    117: 
                    118:                return sc->L;
                    119:        }
                    120: 
                    121:        if (HANDLER_GO_ON == stat_cache_get_entry(srv, con, sc->name, &sce)) {
                    122:                buffer_copy_string_buffer(sc->etag, sce->etag);
                    123:        }
                    124: 
                    125:        /**
                    126:         * pcall() needs the function on the stack
                    127:         *
                    128:         * as pcall() will pop the script from the stack when done, we have to
                    129:         * duplicate it here
                    130:         */
                    131:        assert(lua_isfunction(sc->L, -1));
                    132:        lua_pushvalue(sc->L, -1); /* copy the function-reference */
                    133: 
                    134:        return sc->L;
                    135: }
                    136: 
                    137: #endif