Changeset 432

Timestamp:

07/09/2005 08:17:07 PM (3 years ago)

Author:

jan

Message:

added memcache support

Location:

branches/lighttpd-1.3.x/src

Files:

• Makefile.am (modified) (1 diff)
• mod_cml.c (modified) (4 diffs)
• mod_cml.h (modified) (3 diffs)
• mod_cml_funcs.c (modified) (3 diffs)
• mod_cml_logic.c (modified) (3 diffs)

branches/lighttpd-1.3.x/src/Makefile.am

@@ -72 +72 @@
 mod_cml_la_SOURCES = mod_cml.c mod_cml_funcs.c mod_cml_logic.c
 mod_cml_la_LDFLAGS = -module -export-dynamic -avoid-version -no-undefined
-mod_cml_la_LIBADD = $(MYSQL_LIBS) $(common_libadd)
+mod_cml_la_LIBADD = $(MEMCACHE_LIB) $(common_libadd)
 
 lib_LTLIBRARIES += mod_trigger_b4_dl.la

branches/lighttpd-1.3.x/src/mod_cml.c

@@ -51 +51 @@
                         buffer_free(s->ext);
                         
+                        buffer_free(s->mc_namespace);
+                        array_free(s->mc_hosts);
+                        
+#if defined(HAVE_MEMCACHE_H)
+                        if (s->mc) mc_free(s->mc);
+#endif
+                        
                         free(s);
                 }
@@ -78 +85 @@
         
         config_values_t cv[] = { 
-                { "cml.extension",            NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },       /* 0 */
+                { "cml.extension",              NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },       /* 0 */
+                { "cml.memcache-hosts",         NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION },        /* 1 */
+                { "cml.memcache-namespace",     NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },       /* 2 */
                 { NULL,                         NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
         };
@@ -91 +100 @@
                 s = malloc(sizeof(plugin_config));
                 s->ext    = buffer_init();
+                s->mc_hosts       = array_init();
+                s->mc_namespace   = buffer_init();
                 
                 cv[0].destination = s->ext;
+                cv[1].destination = s->mc_hosts;
+                cv[2].destination = s->mc_namespace;
                 
                 p->config_storage[i] = s;
@@ -98 +111 @@
                 if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
                         return HANDLER_ERROR;
+                }
+                
+                if (s->mc_hosts->used) {
+#if defined(HAVE_MEMCACHE_H)
+                        size_t k;
+                        s->mc = mc_new();
+                
+                        for (k = 0; k < s->mc_hosts->used; k++) {
+                                data_string *ds = (data_string *)s->mc_hosts->data[k];
+                                
+                                if (0 != mc_server_add4(s->mc, ds->value->ptr)) {
+                                        log_error_write(srv, __FILE__, __LINE__, "sb", 
+                                                        "connection to host failed:", 
+                                                        ds->value);
+                                        
+                                        return HANDLER_ERROR;
+                                }
+                        }
+#else
+                        log_error_write(srv, __FILE__, __LINE__, "s", 
+                                        "memcache support is not compiled in but cml.memcache-hosts is set, aborting");
+                        return HANDLER_ERROR;
+#endif
                 }
         }

branches/lighttpd-1.3.x/src/mod_cml.h

@@ -7 +7 @@
 
 #include "stream.h"
+
+#if defined(HAVE_MEMCACHE_H)
+#include <memcache.h>
+#endif
 
 #define plugin_data mod_cache_plugin_data
@@ -46 +50 @@
         buffer *ext;
         
+        array  *mc_hosts;
+        buffer *mc_namespace;
+#if defined(HAVE_MEMCACHE_H) 
+        struct memcache *mc;
+#endif
 } plugin_config;
 
@@ -87 +96 @@
 CACHE_FUNC_PROTO(f_unix_time_now);
 CACHE_FUNC_PROTO(f_file_mtime);
-CACHE_FUNC_PROTO(f_memcache_get);
 CACHE_FUNC_PROTO(f_memcache_exists);
+CACHE_FUNC_PROTO(f_memcache_get_string);
+CACHE_FUNC_PROTO(f_memcache_get_long);
 
 #endif

branches/lighttpd-1.3.x/src/mod_cml_funcs.c

@@ -62 +62 @@
 }
 
+#ifdef HAVE_MEMCACHE_H
 CACHE_FUNC_PROTO(f_memcache_exists) {
-        UNUSED(srv);
+        char *r;
+        
         UNUSED(con);
         
@@ -75 +77 @@
         
         tnode_prepare_long(result);
-        VAL_LONG(result) = 0;
+        
+        if (NULL == (r = mc_aget(p->conf.mc, 
+                                 CONST_BUF_LEN(p->params->ptr[0]->data.str)))) {
+                                
+                VAL_LONG(result) = 0;
+                return 0;
+        }
+        
+        free(r);
+        
+        VAL_LONG(result) = 1;
         
         return 0;
 }
 
-CACHE_FUNC_PROTO(f_memcache_get) {
-        UNUSED(srv);
+CACHE_FUNC_PROTO(f_memcache_get_string) {
+        char *r;
+        
         UNUSED(con);
         
@@ -91 +104 @@
         }
         
+        log_error_write(srv, __FILE__, __LINE__, "sb", 
+                                "f_memcache_get: couldn't find:", 
+                                p->params->ptr[0]->data.str);
+        
+        if (NULL == (r = mc_aget(p->conf.mc, 
+                                p->params->ptr[0]->data.str->ptr, p->params->ptr[0]->data.str->used - 1))) {
+                log_error_write(srv, __FILE__, __LINE__, "sb", 
+                                "f_memcache_get: couldn't find:", 
+                                p->params->ptr[0]->data.str);
+                return -1;
+        }
         tnode_prepare_string(result);
-        buffer_copy_string_buffer(VAL_STRING(result), p->params->ptr[0]->data.str);
+        buffer_copy_string(VAL_STRING(result), r);
+        
+        free(r);
         
         return 0;
 }
+
+CACHE_FUNC_PROTO(f_memcache_get_long) {
+        char *r;
+        
+        UNUSED(con);
+        
+        if (p->params->ptr[0]->type != T_NODE_VALUE_STRING) {
+                log_error_write(srv, __FILE__, __LINE__, "sd", 
+                                "f_memcache_get: I need a string:", 
+                                p->params->ptr[0]->type);
+                return -1;
+        }
+        
+        
+        
+        if (NULL == (r = mc_aget(p->conf.mc, 
+                                 CONST_BUF_LEN(p->params->ptr[0]->data.str)))) {
+                log_error_write(srv, __FILE__, __LINE__, "sb", 
+                                "f_memcache_get: couldn't find:", 
+                                p->params->ptr[0]->data.str);
+                return -1;
+        }
+        
+        tnode_prepare_long(result);
+        VAL_LONG(result) = strtol(r, NULL, 10);
+        
+        free(r);
+        
+        return 0;
+}
+#endif

branches/lighttpd-1.3.x/src/mod_cml_logic.c

@@ -166 +166 @@
                 { "file.mtime",     1, f_file_mtime },
                 { "unix.time.now",  0, f_unix_time_now },
+#ifdef HAVE_MEMCACHE_H
                 { "memcache.exits", 1, f_memcache_exists },
-                { "memcache.get",   1, f_memcache_get },
+                { "memcache.get_string",   1, f_memcache_get_string },
+                { "memcache.get_long",     1, f_memcache_get_long },
+#endif
                 { NULL, 0, NULL },
         };
@@ -481 +484 @@
         } else if (IS_STRING(t->l) && IS_STRING(t->r)) {
                 if (-1 == cache_ops_string(t, t->l, t->r)) {
-                        fprintf(stderr, "%s.%d: cache_ops_string failed\n", __FILE__, __LINE__);
+                        log_error_write(srv, __FILE__, __LINE__, "s", 
+                                        "cache_ops_string failed");
                         return -1;
                 }
         } else {
-                fprintf(stderr, "%s.%d: typemismatch\n",
-                        __FILE__, __LINE__);
+                log_error_write(srv, __FILE__, __LINE__, "s", 
+                                "typemismatch");
                 
                 return -1;
@@ -506 +510 @@
                 
                 if (-1 == cache_trigger_eval(srv, con, p, t)) {
-                        fprintf(stderr, "%s.%d: cache_trigger_eval failed\n", __FILE__, __LINE__);
+                        log_error_write(srv, __FILE__, __LINE__, "s", 
+                                        "cache_trigger_eval failed");
                         return -1;
                 }