libervia-web: src/server/server.py comparison

comparison src/server/server.py @ 554:471b6babe960

server_side: set a timeout to reset the waiting connection requests after 5 minutes

author	souliane <souliane@mailoo.org>
date	Sun, 21 Sep 2014 14:09:59 +0200
parents	8492c2bb463b
children	db1b330c1eb1

comparison

equal deleted inserted replaced

-:8492c2bb463b
+:471b6babe960
 """Tell the backend to leave OTR handling to Libervia."""
 profile = ISATSession(self.session).profile
 return self.sat_host.bridge.skipOTR(profile)
+class WaitingRequests(dict):
+def setRequest(self, request, profile):
+"""Add the given profile to the waiting list.
+@param request (server.Request): the connection request
+@param profile (str): %(doc_profile)s
+"""
+dc = reactor.callLater(C.TIMEOUT, self.purgeRequest, profile)
+self[profile] = (request, dc)
+def purgeRequest(self, profile):
+"""Remove the given profile from the waiting list.
+@param profile (str): %(doc_profile)s
+"""
+try:
+dc = self[profile][1]
+except KeyError:
+return
+if dc.active():
+dc.cancel()
+del self[profile]
+def getRequest(self, profile):
+"""Get the waiting request for the given profile.
+@param profile (str): %(doc_profile)s
+@return: the waiting request or None
+"""
+return self[profile][0] if profile in self else None
 class Register(JSONRPCMethodManager):
 """This class manage the registration procedure with SàT
 It provide an api for the browser, check password and setup the web server"""
 def __init__(self, sat_host):
 JSONRPCMethodManager.__init__(self, sat_host)
 self.profiles_waiting = {}
 self.request = None
+self.waiting_profiles = WaitingRequests()
-def getWaitingRequest(self, profile):
-"""Tell if a profile is trying to log in"""
-if profile in self.profiles_waiting:
-return self.profiles_waiting[profile]
-else:
-return None
 def render(self, request):
 """
 Render method with some hacks:
 - if login is requested, try to login with form data
 if ((not profile_check or profile_check != login_) or
 (not password_ and profile_check not in self.sat_host.empty_password_allowed_warning_dangerous_list)):
 return C.PROFILE_AUTH_ERROR
 # profiles with empty passwords are restricted to local frontends
-if login_ in self.profiles_waiting:
+if self.waiting_profiles.getRequest(login_):
 return C.ALREADY_WAITING
 def auth_eb(failure):
 fault = failure.value.faultString
-self.__cleanWaiting(login_)
+self.waiting_profiles.purgeRequest(login_)
 if fault == 'PasswordError':
 log.info("Profile %s doesn't exist or the submitted password is wrong" % login_)
 request.write(C.PROFILE_AUTH_ERROR)
 elif fault == 'SASLAuthError':
 log.info("The XMPP password of profile %s is wrong" % login_)
 else:
 log.error('Unmanaged fault string %s in errback for the connection of profile %s' % (fault, login_))
 request.write(C.UNKNOWN_ERROR % fault)
 request.finish()
-self.profiles_waiting[login_] = request
+self.waiting_profiles.setRequest(request, login_)
 d = self.asyncBridgeCall("asyncConnect", login_, password_)
 d.addCallbacks(lambda connected: self._logged(login_, request) if connected else None, auth_eb)
 return server.NOT_DONE_YET
 def _registerNewAccount(self, request):
 """Create a new account, or return error
 @param request: request of the register form
 @return: a constant indicating the state:
 d = self.asyncBridgeCall("registerSatAccount", email, password, profile)
 d.addCallback(registered)
 d.addErrback(registeringError)
 return server.NOT_DONE_YET
-def __cleanWaiting(self, login):
-"""Remove login from waiting queue"""
-try:
-del self.profiles_waiting[login]
-except KeyError:
-pass
 def _logged(self, profile, request):
 """Set everything when a user just logged in
 @param profile
 @param request
 @return: a constant indicating the state:
 - C.PROFILE_LOGGED
 - C.SESSION_ACTIVE
 """
-self.__cleanWaiting(profile)
+self.waiting_profiles.purgeRequest(profile)
 _session = request.getSession()
 sat_session = ISATSession(_session)
 if sat_session.profile:
 log.error(('/!\\ Session has already a profile, this should NEVER happen!'))
 request.write(C.SESSION_ACTIVE)
 return self.sat_host.bridge.isConnected(profile)
 def jsonrpc_asyncConnect(self):
 _session = self.request.getSession()
 profile = ISATSession(_session).profile
-if profile in self.profiles_waiting:
+if self.waiting_profiles.getRequest(profile):
 raise jsonrpclib.Fault(1, C.ALREADY_WAITING)  # FIXME: define some standard error codes for libervia
-self.profiles_waiting[profile] = self.request
+self.waiting_profiles.setRequest(self.request, profile)
 self.sat_host.bridge.asyncConnect(profile)
 return server.NOT_DONE_YET
 def jsonrpc_isRegistered(self):
 """
 self.queue[profile].append((function_name, args[:-1]))
 return genericCb
 def connected(self, profile):
 assert(self.register)  # register must be plugged
-request = self.register.getWaitingRequest(profile)
+request = self.register.waiting_profiles.getRequest(profile)
 if request:
 self.register._logged(profile, request)
 def disconnected(self, profile):
 if not profile in self.sat_host.prof_connected:

Mercurial > libervia-web

comparison src/server/server.py @ 554:471b6babe960