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 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()
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'