A redis backend for Django Sessions, tested on Django 1.3+

redis_session.py

from django.contrib.sessions.backends.base import SessionBase, CreateError
from django.conf import settings
from django.utils.encoding import force_unicode
import redis
from redis.exceptions import ConnectionError


class SessionStore(SessionBase):
    """A redis-based session store."""

    def __init__(self, session_key=None):
        self.redis = redis.Redis(
            host=getattr(settings, 'REDIS_HOST', None),
            port=getattr(settings, 'REDIS_PORT', None),
            socket_timeout=getattr(settings, 'REDIS_TIMEOUT', None),
            db=getattr(settings, 'REDIS_DB', None)
        )
        super(SessionStore, self).__init__(session_key)

    def redis_session_key(self, session_key):
        return 'redissession:' + session_key

    def load(self):
        try:
            session_data = self.redis.get(self.redis_session_key(self.session_key))
        except ConnectionError:
            session_data = None
        if session_data is not None:
            return self.decode(force_unicode(session_data))
        else:
            self.create()
            return {}

    def create(self):
        for i in range(0, 10):
            self.session_key = self._get_new_session_key()
            try:
                self.save(must_create=True)
            except CreateError:
                continue
            except ConnectionError:
                continue
            self.modified = True
            return
        raise CreateError('Unable to create a new session key.')

    def save(self, must_create=False):
        session_data = self.encode(self._get_session(no_load=must_create))
        try:
            if must_create:
                result = self.redis.setnx(self.redis_session_key(self.session_key),
                    session_data)
                if not result:
                    raise CreateError
                self.redis.expire(self.redis_session_key(self.session_key),
                    self.get_expiry_age())
            else:
                self.redis.setex(self.redis_session_key(self.session_key),
                    session_data, self.get_expiry_age())
        except ConnectionError:
            raise CreateError

    def exists(self, session_key):
        try:
            return self.redis.exists(self.redis_session_key(session_key))
        except ConnectionError:
            return False

    def delete(self, session_key=None):
        if session_key is None:
            if self._session_key is None:
                return
            session_key = self._session_key
        try:
            self.redis.delete(self.redis_session_key(session_key))
        except ConnectionError:
            return