cubicweb: comparison goa/appobjects/sessions.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 """
 def __init__(self, *args, **kwargs):
 super(GAEAuthenticationManager, self).__init__(*args, **kwargs)
 self._repo = self.config.repository(vreg=self.vreg)
 def authenticate(self, req, _login=None, _password=None):
 """authenticate user and return an established connection for this user
 :raise ExplicitLogin: if authentication is required (no authentication
 info found or wrong user/password)
 """
 if _login is not None:
 login, password = _login, _password
 """manage session data associated to a session identifier"""
 def __init__(self, *args, **kwargs):
 super(GAEPersistentSessionManager, self).__init__(*args, **kwargs)
 self._repo = self.config.repository(vreg=self.vreg)
 def get_session(self, req, sessionid):
 """return existing session for the given session identifier"""
 # search a record for the given session
 key = Key.from_path('CubicWebSession', 'key_' + sessionid, parent=None)
 try:
 record['login'] = cnx.login
 record['password'] = cnx.password
 record['anonymous_connection'] = cnx.anonymous_connection
 Put(record)
 return self._get_proxy(req, record, cnx, user)
 def close_session(self, proxy):
 """close session on logout or on invalid session detected (expired out,
 corrupted...)
 """
 proxy.close()
 def current_sessions(self):
 for record in Query('CubicWebSession').Run():
 yield ConnectionProxy(record)
 def _get_proxy(self, req, record, cnx, user):
 proxy = ConnectionProxy(record, cnx, user)
 user.req = req
 req.set_connection(proxy, user)
 return proxy
 class ConnectionProxy(object):
 def __init__(self, record, cnx=None, user=None):
 self.__record = record
 self.__cnx = cnx
 self.__user = user
 self.__data = None
 self.__is_dirty = False
 self.sessionid = record.key().name()[4:] # remove 'key_' prefix
 def __repr__(self):
 sstr = '<ConnectionProxy %s' % self.sessionid
 if self.anonymous_connection:
 sstr += ' (anonymous)'
 elif self.__user:
 sstr += ' for %s' % self.__user.login
 sstr += ', last used %s>' % strftime('%T', localtime(self.last_usage_time))
 return sstr
 def __getattribute__(self, name):
 try:
 return super(ConnectionProxy, self).__getattribute__(name)
 except AttributeError:
 return getattr(self.__cnx, name)
 def _set_last_usage_time(self, value):
 self.__is_dirty = True
 self.__record['last_usage_time'] = value
 def _get_last_usage_time(self):
 return self.__record['last_usage_time']
 last_usage_time = property(_get_last_usage_time, _set_last_usage_time)
 @property
 def anonymous_connection(self):
 # use get() for bw compat if sessions without anonymous information are
 # found. Set default to True to limit lifetime of those sessions.
 return self.__record.get('anonymous_connection', True)
 @property
 @cached
 def data(self):
 if self.__record.get('data') is not None:
 try:
 except:
 self.__is_dirty = True
 self.exception('corrupted session data for session %s',
 self.__cnx)
 return {}
 def get_session_data(self, key, default=None, pop=False):
 """return value associated to `key` in session data"""
 if pop:
 try:
 value = self.data.pop(key)
 return value
 except KeyError:
 return default
 else:
 return self.data.get(key, default)
 def set_session_data(self, key, value):
 """set value associated to `key` in session data"""
 self.data[key] = value
 self.__is_dirty = True
 def del_session_data(self, key):
 """remove value associated to `key` in session data"""
 try:
 del self.data[key]
 self.__is_dirty = True
 except KeyError:
 pass
 def commit(self):
 if self.__is_dirty:
 self.__save()
 self.__cnx.commit()
 def close(self):
 if self.__cnx is not None:
 self.__cnx.close()
 Delete(self.__record)
 def __save(self):
 if self.__is_dirty:
 self.__record['data'] = Blob(dumps(self.data))
 Put(self.__record)
 self.__is_dirty = False
 def user(self, req=None, props=None):
 """return the User object associated to this connection"""
 return self.__user
 import logging
 from cubicweb import set_log_methods
 set_log_methods(ConnectionProxy, logging.getLogger('cubicweb.web.goa.session'))
 from cubicweb.web import application
 class SessionsCleaner(StartupView):
 id = 'cleansessions'
 __select__ = none_rset() & match_user_groups('managers')
 def call(self):
 # clean web session
 session_manager = application.SESSION_MANAGER
 nbclosed, remaining = session_manager.clean_sessions()
 self.w(u'<div class="message">')
 nbclosed = repo.clean_sessions()
 self.w(u'%s repository sessions closed<br/>\n' % nbclosed)
 self.w(u'%s remaining sessions<br/>\n' % remaining)
 self.w(u'</div>')
 def registration_callback(vreg):
 vreg.register(SessionsCleaner)
 vreg.register(GAEAuthenticationManager, clear=True)
 vreg.register(GAEPersistentSessionManager, clear=True)

branch	tls-sprint
changeset 1802	d628defebc17
parent 1131	544609e83317
child 1977	606923dff11b