1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
import redis
try:
from django.utils.encoding import force_unicode
except ImportError: # Python 3.*
from django.utils.encoding import force_str as force_unicode
from django.contrib.sessions.backends.base import SessionBase, CreateError
from redis_sessions import settings
class RedisServer():
__redis = {}
def __init__(self, session_key):
self.session_key = session_key
self.connection_key = ''
if settings.SESSION_REDIS_SENTINEL_LIST is not None:
self.connection_type = 'sentinel'
if settings.SESSION_REDIS_CONNECTION_OBJECT is not None:
self.connection_type = 'connection_object'
else:
if settings.SESSION_REDIS_POOL is not None:
server_key, server = self.get_server(session_key, settings.SESSION_REDIS_POOL)
self.connection_key = str(server_key)
settings.SESSION_REDIS_HOST = getattr(server, 'host', 'localhost')
settings.SESSION_REDIS_PORT = getattr(server, 'port', 6379)
settings.SESSION_REDIS_DB = getattr(server, 'db', 0)
settings.SESSION_REDIS_PASSWORD = getattr(server, 'password', None)
settings.SESSION_REDIS_URL = getattr(server, 'url', None)
settings.SESSION_REDIS_UNIX_DOMAIN_SOCKET_PATH = getattr(server,'unix_domain_socket_path', None)
if settings.SESSION_REDIS_URL is not None:
self.connection_type = 'redis_url'
elif settings.SESSION_REDIS_UNIX_DOMAIN_SOCKET_PATH is not None:
self.connection_type = 'redis_unix_url'
elif settings.SESSION_REDIS_HOST is not None:
self.connection_type = 'redis_host'
self.connection_key += self.connection_type
def get_server(self, key, servers_pool):
total_weight = sum([row.get('weight', 1) for row in servers_pool])
pos = 0
for i in range(3, -1, -1):
pos = pos * 2 ** 8 + ord(key[i])
pos = pos % total_weight
pool = iter(servers_pool)
server = next(pool)
server_key = 0
i = 0
while i < total_weight:
if i <= pos < (i + server.get('weight', 1)):
return server_key, server
i += server.get('weight', 1)
server = next(pool)
server_key += 1
return
def get(self):
if self.connection_key in self.__redis:
return self.__redis[self.connection_key]
if self.connection_type == 'connection_object':
self.__redis[self.connection_key] = settings.SESSION_REDIS_CONNECTION_OBJECT
elif self.connection_type == 'sentinel':
from redis.sentinel import Sentinel
self.__redis[self.connection_key] = Sentinel(
settings.SESSION_REDIS_SENTINEL_LIST,
socket_timeout=settings.SESSION_REDIS_SOCKET_TIMEOUT,
retry_on_timeout=settings.SESSION_REDIS_RETRY_ON_TIMEOUT,
db=getattr(settings, 'SESSION_REDIS_DB', 0),
password=getattr(settings, 'SESSION_REDIS_PASSWORD', None)
).master_for(settings.SESSION_REDIS_SENTINEL_MASTER_ALIAS)
elif self.connection_type == 'redis_url':
self.__redis[self.connection_key] = redis.StrictRedis.from_url(
settings.SESSION_REDIS_URL,
socket_timeout=settings.SESSION_REDIS_SOCKET_TIMEOUT
)
elif self.connection_type == 'redis_host':
self.__redis[self.connection_key] = redis.StrictRedis(
host=settings.SESSION_REDIS_HOST,
port=settings.SESSION_REDIS_PORT,
socket_timeout=settings.SESSION_REDIS_SOCKET_TIMEOUT,
retry_on_timeout=settings.SESSION_REDIS_RETRY_ON_TIMEOUT,
db=settings.SESSION_REDIS_DB,
password=settings.SESSION_REDIS_PASSWORD
)
elif self.connection_type == 'redis_unix_url':
self.__redis[self.connection_key] = redis.StrictRedis(
unix_socket_path=settings.SESSION_REDIS_UNIX_DOMAIN_SOCKET_PATH,
socket_timeout=settings.SESSION_REDIS_SOCKET_TIMEOUT,
retry_on_timeout=settings.SESSION_REDIS_RETRY_ON_TIMEOUT,
db=settings.SESSION_REDIS_DB,
password=settings.SESSION_REDIS_PASSWORD,
)
return self.__redis[self.connection_key]
class SessionStore(SessionBase):
"""
Implements Redis database session store.
"""
def __init__(self, session_key=None):
super(SessionStore, self).__init__(session_key)
self.server = RedisServer(session_key).get()
def load(self):
try:
session_data = self.server.get(
self.get_real_stored_key(self._get_or_create_session_key())
)
return self.decode(force_unicode(session_data))
except:
self._session_key = None
return {}
def exists(self, session_key):
return self.server.exists(self.get_real_stored_key(session_key))
def create(self):
while True:
self._session_key = self._get_new_session_key()
try:
self.save(must_create=True)
except CreateError:
# Key wasn't unique. Try again.
continue
self.modified = True
return
def save(self, must_create=False):
if self.session_key is None:
return self.create()
if must_create and self.exists(self._get_or_create_session_key()):
raise CreateError
data = self.encode(self._get_session(no_load=must_create))
if redis.VERSION[0] >= 2:
self.server.setex(
self.get_real_stored_key(self._get_or_create_session_key()),
self.get_expiry_age(),
data
)
else:
self.server.set(
self.get_real_stored_key(self._get_or_create_session_key()),
data
)
self.server.expire(
self.get_real_stored_key(self._get_or_create_session_key()),
self.get_expiry_age()
)
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.server.delete(self.get_real_stored_key(session_key))
except:
pass
@classmethod
def clear_expired(cls):
pass
def get_real_stored_key(self, session_key):
"""Return the real key name in redis storage
@return string
"""
prefix = settings.SESSION_REDIS_PREFIX
if not prefix:
return session_key
return ':'.join([prefix, session_key])
|
