manyi/library/djmemcache/backend.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python
from django.core.cache.backends.base import DEFAULT_TIMEOUT

from library.pymemcache.serde import python_memcache_serializer, python_memcache_deserializer

try:
    import cPickle as pickle
except ImportError:
    import pickle
from . import client
from django.core.cache.backends.memcached import BaseMemcachedCache


class PyMemcacheCache(BaseMemcachedCache):
    """An implementation of a cache binding using pymemcache."""

    def __init__(self, server, params):
        BaseMemcachedCache.__init__(
            self,
            server,
            params,
            library = client,
            value_not_found_exception = ValueError
        )
        self._client = None

    @property
    def _cache(self):
        if not self._client:
            kwargs = {
                'serializer': python_memcache_serializer,
                'deserializer': python_memcache_deserializer,
            }

            if self._options:
                for key, value in self._options.items():
                    kwargs[key.lower()] = value

            # default use_pooling
            if "use_pooling" not in kwargs:
                kwargs["use_pooling"] = True
            # if "ignore_exc" not in kwargs:
            #     kwargs["ignore_exc"] = True

            servers = []
            for server in self._servers:
                host, port = server.split(":")
                servers.append((host, int(port)))
            self._client = self._lib.Client(servers, **kwargs)

        return self._client

    def get(self, key, default = None, version = None, ignore_exc = True):
        key = self.make_key(key, version = version)
        val = self._cache.get(key, ignore_exc = ignore_exc)
        if val is None:
            return default
        return val

    def cas(self, key, value, cas, timeout = DEFAULT_TIMEOUT):
        key = self.make_key(key)

        if cas is None:
            return self._cache.set(key, value, self.get_backend_timeout(timeout))
        else:
            return self._cache.cas(key, value, cas, self.get_backend_timeout(timeout))

    def gets(self, key, ignore_exc = False):
        key = self.make_key(key)
        return self._cache.gets(key, ignore_exc = ignore_exc)