def handle(self, *args, **kwargs):
server = SessionStore().server
now = datetime.datetime.now()
self.sessions = Session.objects.filter(
expire_date__gte=now,
).values_list(
'session_key',
'session_data',
'expire_date',
)
self.start_progressbar()
pipe = server.pipeline(transaction=False)
for i, session in enumerate(self.sessions.iterator()):
session_key, session_data, expire_date = session
if i % CHUNK_SIZE == 0:
gc.collect()
if expire_date < now:
# this session is old, let's ignore it
continue
# convert the expire date to a ttl in seconds
delta = expire_date - now
ttl = (delta.days * 24 * 60 * 60) + delta.seconds
# set the key, value and ttl
pipe.set(session_key, session_data)
pipe.expire(session_key, ttl)
self.update_progressbar(i)
# execute all commands in 1 big pipeline
pipe.execute()
self.end_progressbar()
def process_request(self, request):
session_key = request.META.get('HTTP_SESSION_ID', None)
if not hasattr(request, 'user'):
if sessionStore.exists(session_key):
request.session = SessionStore(session_key)
user_id = int(request.session["_auth_user_id"])
request.user = User.objects.get(id=user_id)
else:
request.user = AnonymousUser()
# TODO
request.session = SessionStore()
def get_logged_users():
# Query all non-expired sessions
redconn = Redis()
store = SessionStore()
sessions = [redconn.get(key) for key in redconn.keys()]
uid_list = []
# Build a list of user ids from that query
for session_data in sessions:
data = store.decode(session_data)
uid_list.append(data.get('_auth_user_id', None))
# Query all logged in users based on id list
return User.objects.filter(id__in=uid_list)
def open(self):
session_key = self.get_cookie(settings.SESSION_COOKIE_NAME)
if sessionStore.exists(session_key):
self.ip = self.get_client_ip()
session = SessionStore(session_key)
self.user_id = int(session["_auth_user_id"])
log_params = {
'user_id': str(self.user_id).zfill(3),
'id': self.id,
'ip': self.ip
}
self._logger = logging.LoggerAdapter(base_logger, log_params)
self.logger.debug("!! Incoming connection, session %s, thread hash %s", session_key, self.id)
self.async_redis.connect()
user_db = self.do_db(User.objects.get, id=self.user_id) # everything but 0 is a registered user
self.sender_name = user_db.username
self.sex = user_db.sex_str
user_rooms = self.get_users_in_current_user_rooms()
self.safe_write(self.default(user_rooms, Actions.ROOMS, HandlerNames.CHANNELS))
# get all missed messages
self.channels = [] # py2 doesn't support clear()
self.channels.append(self.channel)
for room_id in user_rooms:
self.channels.append(room_id)
self.listen(self.channels)
off_messages = self.get_offline_messages()
for room_id in user_rooms:
self.add_online_user(room_id, off_messages.get(room_id))
self.logger.info("!! User %s subscribes for %s", self.sender_name, self.channels)
self.connected = True
Thread(target=self.save_ip).start()
else:
self.logger.warning('!! Session key %s has been rejected', str(session_key))
self.close(403, "Session key %s has been rejected" % session_key)
def test_actual_expiry(self):
sesssion = RedisSessionStore()
sesssion.set_expiry(1)
# Test if the expiry age is set correctly
self.assertEqual(sesssion.get_expiry_age(), 1)
sesssion['key'] = 'expiring_value'
sesssion.save()
key = sesssion.session_key
self.assertTrue(sesssion.exists(key))
time.sleep(2)
self.assertFalse(sesssion.exists(key))
def open(self):
session_key = self.get_cookie(settings.SESSION_COOKIE_NAME)
if sessionStore.exists(session_key):
self.ip = self.get_client_ip()
session = SessionStore(session_key)
self.user_id = int(session["_auth_user_id"])
self.generate_self_id()
log_params = {'id': self.id, 'ip': self.ip}
self._logger = logging.LoggerAdapter(parent_logger, log_params)
cookies = [
"{}={}".format(k, self.request.cookies[k].value)
for k in self.request.cookies
]
self.logger.debug(
"!! Incoming connection, session %s, thread hash %s, cookies: %s",
session_key, self.id, ";".join(cookies))
self.async_redis.connect()
user_db = do_db(User.objects.get, id=self.user_id)
self.sender_name = user_db.username
self.sex = user_db.sex_str
user_rooms = get_users_in_current_user_rooms(self.user_id)
# get all missed messages
self.channels = [] # py2 doesn't support clear()
self.channels.append(self.channel)
self.channels.append(self.id)
rooms_online = {}
was_online = False
for room_id in user_rooms:
self.channels.append(room_id)
rooms_online[room_id] = self.get_is_online(room_id)
was_online = was_online or rooms_online[room_id][0]
self.listen(self.channels)
off_messages, history = self.get_offline_messages(
user_rooms, was_online, self.get_argument('history', False))
for room_id in user_rooms:
user_rooms[room_id][
VarNames.LOAD_MESSAGES_HISTORY] = history.get(room_id)
user_rooms[room_id][
VarNames.LOAD_MESSAGES_OFFLINE] = off_messages.get(room_id)
self.ws_write(self.set_room(user_rooms))
for room_id in user_rooms:
self.async_redis_publisher.sadd(room_id, self.id)
self.add_online_user(room_id, rooms_online[room_id][0],
rooms_online[room_id][1])
self.logger.info("!! User %s subscribes for %s", self.sender_name,
self.channels)
self.connected = True
# self.save_ip()
else:
self.logger.warning('!! Session key %s has been rejected',
str(session_key))
self.close(403, "Session key %s has been rejected" % session_key)
def background_post_register_actions(context):
""" Do whatever needed after a new user just registered on the
application landing page. """
meta = context['meta']
user = LandingUser.objects.get(id=context['new_user_id'])
# Classic Django
#session = Session.objects.get(pk=context['session_key'])
# redis_sessions.
session = SessionStore(session_key=context['session_key'])
has_invites_left = get_beta_invites_left(True) > 0
send_email_with_db_content(
context,
'landing_thanks' if has_invites_left else 'landing_waiting_list')
user.register_data = {
'language':
meta.get('HTTP_ACCEPT_LANGUAGE', ''),
'user_agent':
meta.get('HTTP_USER_AGENT', ''),
'encoding':
meta.get('HTTP_ACCEPT_ENCODING', ''),
'remote_addr':
meta.get('HTTP_X_FORWARDED_FOR', meta.get('REMOTE_ADDR', '')),
'referer':
session.get('INITIAL_REFERER', ''),
}
user.save()
try:
del session['INITIAL_REFERER']
except KeyError:
pass
def test_generate_drobox_auth(self):
"""
The ``generate_drobox_auth`` method should add the Dropbox auth URL
and access token to the session.
"""
# Make sure the DropboxConfig class works
session = DropboxConfig.get_session()
self.assertNotEqual(session, None)
# Call the method and make sure dropbox_auth_url and
# request token were set
s = SessionStore()
view = URLUploadFormView()
view.generate_drobox_auth(s)
# The keys that the method should have generated exist
self.assertTrue('dropbox_auth_url' in s.keys())
self.assertTrue('request_token' in s.keys())
# There is a valid dropbox URL
parsed = urlparse(s['dropbox_auth_url'])
self.assertEqual(parsed.netloc, 'www.dropbox.com')
def test_with_redis_url_config():
settings.SESSION_REDIS_URL = 'redis://localhost'
from redis_sessions.session import SessionStore
redis_session = SessionStore()
server = redis_session.server
host = server.connection_pool.connection_kwargs.get('host')
port = server.connection_pool.connection_kwargs.get('port')
db = server.connection_pool.connection_kwargs.get('db')
eq_(host, 'localhost')
eq_(port, 6379)
eq_(db, 0)
def background_post_register_actions(context):
""" Do whatever needed after a new user just registered on the
application landing page. """
meta = context['meta']
user = LandingUser.objects.get(id=context['new_user_id'])
# Classic Django
#session = Session.objects.get(pk=context['session_key'])
# redis_sessions.
session = SessionStore(session_key=context['session_key'])
has_invites_left = get_beta_invites_left(True) > 0
send_email_with_db_content(context,
'landing_thanks'
if has_invites_left
else 'landing_waiting_list')
user.register_data = {
'language': meta.get('HTTP_ACCEPT_LANGUAGE', ''),
'user_agent': meta.get('HTTP_USER_AGENT', ''),
'encoding': meta.get('HTTP_ACCEPT_ENCODING', ''),
'remote_addr': meta.get('HTTP_X_FORWARDED_FOR',
meta.get('REMOTE_ADDR', '')),
'referer': session.get('INITIAL_REFERER', ''),
}
user.save()
try:
del session['INITIAL_REFERER']
except KeyError:
pass
def test_with_redis_url_config(self):
settings.SESSION_REDIS_URL = 'redis://redis'
from redis_sessions.session import SessionStore
redis_session = SessionStore()
server = redis_session.server
host = server.connection_pool.connection_kwargs.get('host')
port = server.connection_pool.connection_kwargs.get('port')
db = server.connection_pool.connection_kwargs.get('db')
self.assertEqual(host, 'redis')
self.assertEqual(port, 6379)
self.assertEqual(db, 0)
def test_one_connection_is_used():
session = SessionStore('session_key_1')
session['key1'] = 'value1'
session.save()
redis_server = session.server
set_client_name_1 = 'client_name_' + str(randint(1, 1000))
redis_server.client_setname(set_client_name_1)
client_name_1 = redis_server.client_getname()
eq_(set_client_name_1, client_name_1)
del session
session = SessionStore('session_key_2')
session['key2'] = 'value2'
session.save()
redis_server = session.server
client_name_2 = redis_server.client_getname()
eq_(client_name_1, client_name_2)
def test_with_unix_url_config():
pass
# Uncomment this in `redis.conf`:
#
# unixsocket /tmp/redis.sock
# unixsocketperm 755
settings.SESSION_REDIS_URL = 'unix:///tmp/redis.sock'
from redis_sessions.session import SessionStore
redis_session = SessionStore()
server = redis_session.server
host = server.connection_pool.connection_kwargs.get('host')
port = server.connection_pool.connection_kwargs.get('port')
db = server.connection_pool.connection_kwargs.get('db')
eq_(host, 'localhost')
eq_(port, 6379)
eq_(db, 0)
def test_one_connection_is_used():
session = SessionStore('session_key_1')
session['key1'] = 'value1'
session.save()
redis_server = session.server
set_client_name_1 = 'client_name_' + str(randint(1, 1000))
redis_server.client_setname(set_client_name_1)
client_name_1 = redis_server.client_getname()
eq_(set_client_name_1, client_name_1)
del session
session = SessionStore('session_key_2')
session['key2'] = 'value2'
session.save()
redis_server = session.server
client_name_2 = redis_server.client_getname()
eq_(client_name_1, client_name_2)
def open(self):
session_key = self.get_argument('sessionId', None)
try:
if session_key is None:
raise Error401()
session = SessionStore(session_key)
try:
self.user_id = int(session["_auth_user_id"])
except:
raise Error401()
self.ip = self.get_client_ip()
user_db = do_db(UserProfile.objects.get, id=self.user_id)
self.generate_self_id()
self._logger = logging.LoggerAdapter(parent_logger, {
'id': self.id,
'ip': self.ip
})
cookies = [
"{}={}".format(k, self.request.cookies[k].value)
for k in self.request.cookies
]
self.logger.debug(
"!! Incoming connection, session %s, thread hash %s, cookies: %s",
session_key, self.id, ";".join(cookies))
self.async_redis.connect()
self.async_redis_publisher.sadd(RedisPrefix.ONLINE_VAR, self.id)
# since we add user to online first, latest trigger will always show correct online
was_online, online = self.get_online_and_status_from_redis()
user_rooms_query = Room.objects.filter(users__id=self.user_id, disabled=False) \
.values('id', 'name', 'roomusers__notifications', 'roomusers__volume')
room_users = [{
VarNames.ROOM_ID:
room['id'],
VarNames.ROOM_NAME:
room['name'],
VarNames.NOTIFICATIONS:
room['roomusers__notifications'],
VarNames.VOLUME:
room['roomusers__volume'],
VarNames.ROOM_USERS: []
} for room in user_rooms_query]
user_rooms_dict = {
room[VarNames.ROOM_ID]: room
for room in room_users
}
room_ids = [room_id[VarNames.ROOM_ID] for room_id in room_users]
rooms_users = RoomUsers.objects.filter(
room_id__in=room_ids).values('user_id', 'room_id')
for ru in rooms_users:
user_rooms_dict[ru['room_id']][VarNames.ROOM_USERS].append(
ru['user_id'])
# get all missed messages
self.channels = room_ids # py2 doesn't support clear()
self.channels.append(self.channel)
self.channels.append(self.id)
self.listen(self.channels)
off_messages, history = self.get_offline_messages(
room_users, was_online, self.get_argument('history', False))
for room in room_users:
room_id = room[VarNames.ROOM_ID]
h = history.get(room_id)
o = off_messages.get(room_id)
if h:
room[VarNames.LOAD_MESSAGES_HISTORY] = h
if o:
room[VarNames.LOAD_MESSAGES_OFFLINE] = o
if settings.SHOW_COUNTRY_CODE:
fetched_users = User.objects.annotate(
user_c=Count('id')).values(
'id', 'username', 'sex',
'userjoinedinfo__ip__country_code',
'userjoinedinfo__ip__country',
'userjoinedinfo__ip__region',
'userjoinedinfo__ip__city')
user_dict = [
RedisPrefix.set_js_user_structure_flag(
user['id'], user['username'], user['sex'],
user['userjoinedinfo__ip__country_code'],
user['userjoinedinfo__ip__country'],
user['userjoinedinfo__ip__region'],
user['userjoinedinfo__ip__city'])
for user in fetched_users
]
else:
fetched_users = User.objects.values('id', 'username', 'sex')
user_dict = [
RedisPrefix.set_js_user_structure(user['id'],
user['username'],
user['sex'])
for user in fetched_users
]
if self.user_id not in online:
online.append(self.user_id)
self.ws_write(self.set_room(room_users, user_dict, online,
user_db))
if not was_online: # if a new tab has been opened
online_user_names_mes = self.room_online_login(
online, user_db.username, user_db.sex_str)
self.logger.info(
'!! First tab, sending refresh online for all')
self.publish(online_user_names_mes, settings.ALL_ROOM_ID)
self.logger.info("!! User %s subscribes for %s", self.user_id,
self.channels)
self.connected = True
except Error401:
self.logger.warning('!! Session key %s has been rejected' %
session_key)
self.close(403, "Session key %s has been rejected" % session_key)
def test_session_load_does_not_create_record():
session = SessionStore('someunknownkey')
session.load()
eq_(redis_session.exists(redis_session.session_key), False)
from redis_sessions.session import SessionStore
from redis_sessions.session import RedisServer
from redis_sessions import settings
import time
from nose.tools import eq_, assert_false
from random import randint
## Dev
import redis
import timeit
redis_session = SessionStore()
def test_modify_and_keys():
eq_(redis_session.modified, False)
redis_session['test'] = 'test_me'
eq_(redis_session.modified, True)
eq_(redis_session['test'], 'test_me')
def test_session_load_does_not_create_record():
session = SessionStore('someunknownkey')
session.load()
eq_(redis_session.exists(redis_session.session_key), False)
def test_save_and_delete():
redis_session['key'] = 'value'
redis_session.save()
def __init__(self, sessionId):
self.store = SessionStore(sessionId)
self.sessionId = sessionId
class SessionEnv(object):
def __init__(self, sessionId):
self.store = SessionStore(sessionId)
self.sessionId = sessionId
def setParam(self, key, value):
self.store[key] = value
def getParam(self, key, default=''):
return self.store.get(key, default)
def isSessionKeyExists(self):
return self.store.exists(self.sessionId)
def isNewSession(self, new_sid):
if self.store.load().get('sid') == new_sid:
return False
else:
return True
def getSesKey(self):
return self.store.session_key
def saveParam(self):
self.store.save()
def removeSession(self):
self.store.delete(self.sessionId)
def createNewSession(self):
if not self.store.session_key:
self.store.create()
else:
self.store.save()
class SessionEnv(object):
def __init__(self, sessionId):
self.store = SessionStore(sessionId)
self.sessionId = sessionId
def setParam(self, key, value):
self.store[key] = value
def getParam(self, key, default=''):
return self.store.get(key, default)
def isSessionKeyExists(self):
return self.store.exists(self.sessionId)
def isNewSession(self, new_sid):
if self.store.load().get('sid') == new_sid:
return False
else:
return True
def getSesKey(self):
return self.store.session_key
def saveParam(self):
self.store.save()
def removeSession(self):
self.store.delete(self.sessionId)
def createNewSession(self):
if not self.store.session_key:
self.store.create()
else:
self.store.save()
try: # py2 from urlparse import urlparse from urllib import urlopen except ImportError: # py3 from urllib.parse import urlparse from urllib.request import urlopen from chat.settings import MAX_MESSAGE_SIZE, ALL_ROOM_ID, GENDERS, UPDATE_LAST_READ_MESSAGE, SELECT_SELF_ROOM from chat.models import User, Message, Room, IpAddress, get_milliseconds, UserJoinedInfo, RoomUsers PY3 = sys.version > '3' str_type = str if PY3 else basestring api_url = getattr(settings, "IP_API_URL", None) sessionStore = SessionStore() base_logger = logging.getLogger(__name__) # TODO https://github.com/leporo/tornado-redis#connection-pool-support #CONNECTION_POOL = tornadoredis.ConnectionPool( # max_connections=500, # wait_for_available=True) class Actions(object): LOGIN = '******' LOGOUT = 'removeOnlineUser' SEND_MESSAGE = 'sendMessage' PRINT_MESSAGE = 'printMessage' CALL = 'call'
def test_session_load_does_not_create_record():
session = SessionStore('someunknownkey')
session.load()
eq_(redis_session.exists(redis_session.session_key), False)
def __init__(self, sessionId):
self.store = SessionStore(sessionId)
self.sessionId = sessionId
