Return to pa_vmemcached.C CVS log

Up to [parser3project] / parser3 / src / types

Annotation of parser3/src/types/pa_vmemcached.C, revision 1.1

1.1     ! moko        1: /** @file
        !             2:        Parser: memcached class.
        !             3: 
        !             4:        Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
        !             5:        Authors:
        !             6:                Ivan Poluyanov <ivan-poluyanov@yandex.ru>
        !             7:                Artem Stepanov <timofei1394@thesecure.in>
        !             8: */
        !             9: 
        !            10: #include "pa_vmemcached.h"
        !            11: #include "pa_value.h"
        !            12: #include "pa_vstring.h"
        !            13: #include "pa_vvoid.h"
        !            14: 
        !            15: volatile const char * IDENT_PA_VMEMCACHED_C="$Id: pa_vmemcached.C,v 1.19 2012-03-16 09:24:18 moko Exp $" IDENT_PA_VMEMCACHED_H;
        !            16: 
        !            17: #ifdef WIN32
        !            18: const char *memcached_library="libmemcached.dll";
        !            19: #else
        !            20: const char *memcached_library="libmemcached.so";
        !            21: #endif
        !            22: 
        !            23: void error(const char *step, memcached_st* m, memcached_return rc) {
        !            24:        const char* str=f_memcached_strerror(m, rc);
        !            25:        throw Exception("memcached", 0, "%s error: %s (%d)", step, str ? str : "<unknown>", rc);
        !            26: }
        !            27: 
        !            28: inline void check(const char *step, memcached_st* m, memcached_return rc) {
        !            29:        if(rc==MEMCACHED_SUCCESS)
        !            30:                return;
        !            31:        error(step, m, rc);
        !            32: }
        !            33: 
        !            34: void VMemcached::open(const String& connect_string, size_t aflags){
        !            35:        const char *library = memcached_library;
        !            36:        const char *memcached_status = memcached_load(library);
        !            37: 
        !            38:        if(memcached_status)
        !            39:                throw Exception("memcached", 0, "failed to load memcached library %s: %s", library, memcached_status);
        !            40: 
        !            41:        if(connect_string.is_empty())
        !            42:                throw Exception("memcached", 0, "server name must not be empty");
        !            43: 
        !            44:        fflags=aflags;
        !            45: 
        !            46:        fm=f_memcached_create(NULL);
        !            47: 
        !            48:        memcached_server_st* fservers = f_memcached_servers_parse(connect_string.cstr());
        !            49:        check("server_push", fm, f_memcached_server_push(fm, fservers));
        !            50: }
        !            51: 
        !            52: void VMemcached::remove(const String& aname){
        !            53:        if(aname.is_empty())
        !            54:                throw Exception("memcached", 0, "key must not be empty");
        !            55:        const char* key_cstr=aname.cstr();
        !            56: 
        !            57:        memcached_return rc=f_memcached_delete(fm, key_cstr, strlen(key_cstr), (time_t)0);
        !            58:        if(rc != MEMCACHED_SUCCESS && rc != MEMCACHED_NOTFOUND)
        !            59:                error("delete", fm, rc);
        !            60: }
        !            61: 
        !            62: Value* VMemcached::get_element(const String& aname) {
        !            63:        if(Value *result=VStateless_object::get_element(aname))
        !            64:                return result;
        !            65: 
        !            66:        const char* key=aname.cstr();
        !            67: 
        !            68:        size_t length;
        !            69:        memcached_return rc;
        !            70:        const char* val=f_memcached_get(fm, key, strlen(key), &length, &fflags, &rc);
        !            71: 
        !            72:        if(rc==MEMCACHED_SUCCESS)
        !            73:                return new VString(*new String(val, String::L_TAINTED, length));
        !            74:        else if(rc==MEMCACHED_NOTFOUND)
        !            75:                return new VVoid();
        !            76: 
        !            77:        error("get", fm, rc);
        !            78:        return 0; // calm down compiler
        !            79: }
        !            80: 
        !            81: 
        !            82: const VJunction* VMemcached::put_element(const String& aname, Value* avalue, bool /*replace*/){
        !            83:        if(aname.is_empty())
        !            84:                throw Exception("memcached", 0, "key must not be empty");
        !            85: 
        !            86:        Value* lvalue=0;
        !            87:        time_t ttl=0;
        !            88: 
        !            89:        if(HashStringValue* hash=avalue->get_hash()) {
        !            90:                if(Value* ttl_value=hash->get(expires_name))
        !            91:                        ttl=ttl_value->as_int();
        !            92:                if(lvalue=hash->get(value_name)){
        !            93:                        if(lvalue->get_junction())
        !            94:                                throw Exception("memcached", 0, VALUE_NAME " must not be code");
        !            95:                } else
        !            96:                        throw Exception("memcached", &aname, "put hash value must contain ." VALUE_NAME);
        !            97:        } else {
        !            98:                lvalue=avalue;
        !            99:        }
        !           100: 
        !           101:        const char* key=aname.cstr();
        !           102:        size_t key_size=strlen(key);
        !           103: 
        !           104:        if(key_size >= MEMCACHED_MAX_KEY)
        !           105:                throw Exception("memcached", 0, "key length exceeds limit (%d bytes)", MEMCACHED_MAX_KEY-1);
        !           106: 
        !           107:        const char* value = avalue->as_string().cstr();
        !           108:        size_t value_size=strlen(value);
        !           109: 
        !           110:        check("set", fm, f_memcached_set(
        !           111:                        fm,
        !           112:                        key,
        !           113:                        key_size,
        !           114:                        value,
        !           115:                        value_size,
        !           116:                        ttl,
        !           117:                        fflags));
        !           118: 
        !           119:        return PUT_ELEMENT_REPLACED_ELEMENT;
        !           120: }
        !           121: