libervia-web: libervia.tac comparison

comparison libervia.tac @ 44:2744dd31e8a5

server side: Session management refactoring - Session is now managed in a more twisted-like way - Session time out managed - Session can now be locked, preventing for expiration - Session is locked when the getSignal request is active, preventing from expiration when the user has the page open but do nothing

author	Goffi <goffi@goffi.org>
date	Wed, 25 May 2011 14:24:41 +0200
parents	7782a786b2f0
children	7f106052326f

comparison

equal deleted inserted replaced

-:a7ff1e6f1229
+:2744dd31e8a5
 from twisted.web import server
 from twisted.web import error as weberror
 from twisted.web.static import File
 from twisted.web.resource import Resource
+from twisted.python.components import registerAdapter
 from twisted.words.protocols.jabber.jid import JID
 from txjsonrpc.web import jsonrpc
 from txjsonrpc import jsonrpclib
 from sat_frontends.bridge.DBus import DBusBridgeFrontend,BridgeExceptionNoService
 import re
 import glob
 import os.path
+import sys
 from server_side.blog import MicroBlog
+from zope.interface import Interface, Attribute, implements
-TIMEOUT = 120 #Session's time out, after that the user will be disconnected
+TIMEOUT = 10 #Session's time out, after that the user will be disconnected
 LIBERVIA_DIR = "output/"
 CARDS_DIR = "cards/"
+class ISATSession(Interface):
+profile = Attribute("Sat profile")
+jid = Attribute("JID associated with the profile")
+class SATSession(object):
+implements(ISATSession)
+def __init__(self, session):
+self.profile = None
+self.jid = None
+class LiberviaSession(server.Session):
+sessionTimeout = TIMEOUT
+def __init__(self, *args, **kwargs):
+self.__lock = False
+server.Session.__init__(self, *args, **kwargs)
+def lock(self):
+"""Prevent session from expiring"""
+self.__lock = True
+self._expireCall.reset(sys.maxint)
+def unlock(self):
+"""Allow session to expire again, and touch it"""
+self.__lock = False
+self.touch()
+def touch(self):
+if not self.__lock:
+server.Session.touch(self)
 class MethodHandler(jsonrpc.JSONRPC):
 def __init__(self, sat_host):
 jsonrpc.JSONRPC.__init__(self)
 self.sat_host=sat_host
 def render(self, request):
 self.session = request.getSession()
-try:
+profile = ISATSession(self.session).profile
-profile = self.session.sat_profile
+if not profile:
-except AttributeError:
 #user is not identified, we return a jsonrpc fault
 parsed = jsonrpclib.loads(request.content.read())
 fault = jsonrpclib.Fault(0, "Not allowed") #FIXME: define some standard error codes for libervia
 return jsonrpc.JSONRPC._cbRender(self, fault, request, parsed.get('id'), parsed.get('jsonrpc'))
 return jsonrpc.JSONRPC.render(self, request)
 def jsonrpc_getProfileJid(self):
 """Return the jid of the profile"""
-profile = self.session.sat_profile
+sat_session = ISATSession(self.session)
-self.session.sat_jid = self.sat_host.bridge.getParamA("JabberID", "Connection", profile_key=profile)
+profile = sat_session.profile
-return self.session.sat_jid
+sat_session.sat_jid = JID(self.sat_host.bridge.getParamA("JabberID", "Connection", profile_key=profile))
+return sat_session.sat_jid.full()
 def jsonrpc_getContacts(self):
 """Return all passed args."""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 return self.sat_host.bridge.getContacts(profile)
 def jsonrpc_setStatus(self, status):
 """Change the status"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 print "new status received:", status
 self.sat_host.bridge.setPresence('', '', 0, {'':status}, profile)
 def jsonrpc_sendMessage(self, to_jid, msg, subject, type):
 """send message"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 return self.sat_host.bridge.sendMessage(to_jid, msg, subject, type, profile)
 def jsonrpc_sendMblog(self, raw_text):
 """Parse raw_text of the microblog box, and send message consequently"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 match = re.match(r'@(.+?): *(.*$)', raw_text)
 if match:
 recip = match.group(1)
 text = match.group(2)
 if recip == '@' and text:
 else:
 return self.sat_host.bridge.sendGroupBlog([recip], text, profile)
 def jsonrpc_getPresenceStatus(self):
 """Get Presence information for connected contacts"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 return self.sat_host.bridge.getPresenceStatus(profile)
 def jsonrpc_getHistory(self, from_jid, to_jid, size):
 """Return history for the from_jid/to_jid couple"""
 #FIXME: this method should definitely be asynchrone, need to fix it !!!
-profile = self.session.sat_profile
+sat_session = ISATSession(self.session)
-try:
+profile = sat_session.profile
-_jid = JID(self.session.sat_jid)
+sat_jid = sat_session.jid
-except:
+if not sat_jid:
 error("No jid saved for this profile")
 return {}
-if JID(from_jid).userhost() != _jid.userhost() and JID(to_jid) != _jid.userhost():
+if JID(from_jid).userhost() != sat_jid.userhost() and JID(to_jid).userhost() != sat_jid.userhost():
 error("Trying to get history from a different jid, maybe a hack attempt ?")
 return {}
 return self.sat_host.bridge.getHistory(from_jid, to_jid, size)
 def jsonrpc_getRoomJoined(self):
 """Return list of room already joined by user"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 return self.sat_host.bridge.getRoomJoined(profile)
 def jsonrpc_launchTarotGame(self, other_players):
 """Create a room, invite the other players and start a Tarot game"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 self.sat_host.bridge.tarotGameLaunch(other_players, profile)
 def jsonrpc_getTarotCardsPaths(self):
 """Give the path of all the tarot cards"""
 return map(lambda x: x[len(LIBERVIA_DIR):],glob.glob(os.path.join(LIBERVIA_DIR,CARDS_DIR,'*_*.png')));
 def jsonrpc_tarotGameReady(self, player, referee):
 """Tell to the server that we are ready to start the game"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 self.sat_host.bridge.tarotGameReady(player, referee)
 def jsonrpc_tarotGameContratChoosed(self, player_nick, referee, contrat):
 """Tell to the server that we are ready to start the game"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 self.sat_host.bridge.tarotGameContratChoosed(player_nick, referee, contrat, profile)
 def jsonrpc_tarotGamePlayCards(self, player_nick, referee, cards):
 """Tell to the server that we are ready to start the game"""
-profile = self.session.sat_profile
+profile = ISATSession(self.session).profile
 self.sat_host.bridge.tarotGamePlayCards(player_nick, referee, cards, profile)
 class Register(jsonrpc.JSONRPC):
 """This class manage the registration procedure with SàT
 It provide an api for the browser, check password and setup the web server"""
 else:
 return None
 def _fillMblogNodes(self, result, session):
 """Fill the microblog nodes association for this session"""
-print "Filling session for %s with %s" % (session.sat_profile, result)
 session.sat_mblog_nodes = dict(result)
 def render(self, request):
 """
 Render method with some hacks:
 return self.login(request)
 _session = request.getSession()
 parsed = jsonrpclib.loads(request.content.read())
 if parsed.get("method")!="isRegistered":
 #if we don't call login or isRegistered, we need to be identified
-try:
+profile = ISATSession(_session).profile
-profile = _session.sat_profile
+if not profile:
-except AttributeError:
 #user is not identified, we return a jsonrpc fault
 fault = jsonrpclib.Fault(0, "Not allowed") #FIXME: define some standard error codes for libervia
 return jsonrpc.JSONRPC._cbRender(self, fault, request, parsed.get('id'), parsed.get('jsonrpc'))
 self.request = request
 return jsonrpc.JSONRPC.render(self, request)
 def _logged(self, profile, request, finish=True):
 """Set everything when a user just logged
 and return "LOGGED" to the requester"""
 self.__cleanWaiting(profile)
 _session = request.getSession()
-_session.sat_profile = profile
+sat_session = ISATSession(_session)
+if sat_session.profile:
+error (_('/!\\ Session has already a profile, this should NEVER happen !'))
+sat_session.profile = profile
 self.sat_host.prof_connected.add(profile)
 d = defer.Deferred()
 self.sat_host.bridge.getMblogNodes(profile, d.callback, d.errback)
 d.addCallback(self._fillMblogNodes, _session)
 if finish:
 self.__cleanWaiting(login)
 return error_type
 def jsonrpc_isConnected(self):
 _session = self.request.getSession()
-profile = _session.sat_profile
+profile = ISATSession(_session).profile
 return self.sat_host.bridge.isConnected(profile)
 def jsonrpc_connect(self):
 _session = self.request.getSession()
-profile = _session.sat_profile
+profile = ISATSession(_session).profile
 if self.profiles_waiting.has_key(profile):
 raise jsonrpclib.Fault('1','Already waiting') #FIXME: define some standard error codes for libervia
 self.profiles_waiting[profile] = self.request
 self.sat_host.bridge.connect(profile)
 return server.NOT_DONE_YET
 def jsonrpc_isRegistered(self):
 """Tell if the user is already registered"""
 _session = self.request.getSession()
-try:
+profile = ISATSession(_session).profile
-profile = _session.sat_profile
+return bool(profile)
-except AttributeError:
-return False
-return True
 class SignalHandler(jsonrpc.JSONRPC):
 def __init__(self, sat_host):
 Resource.__init__(self)
 def jsonrpc_getSignals(self):
 """Keep the connection alive until a signal is received, then send it
 @return: (signal, *signal_args)"""
 _session = self.request.getSession()
-profile = _session.sat_profile
+profile = ISATSession(_session).profile
 if profile in self.queue: #if we have signals to send in queue
 if self.queue[profile]:
 return self.queue[profile].pop(0)
 else:
 #the queue is empty, we delete the profile from queue
 del self.queue[profile]
+_session.lock() #we don't want the session to expire as long as this connection is active
+def unlock(ignore):
+_session.unlock()
 self.signalDeferred[profile] = defer.Deferred()
+self.request.notifyFinish().addBoth(unlock)
 return self.signalDeferred[profile]
 def getGenericCb(self, function_name):
 """Return a generic function which send all params to signalDeferred.callback
 function must have profile as last argument"""
 """
 Render method wich reject access if user is not identified
 """
 _session = request.getSession()
 parsed = jsonrpclib.loads(request.content.read())
-try:
+profile = ISATSession(_session).profile
-profile = _session.sat_profile
+if not profile:
-except AttributeError:
 #user is not identified, we return a jsonrpc fault
 fault = jsonrpclib.Fault(0, "Not allowed") #FIXME: define some standard error codes for libervia
 return jsonrpc.JSONRPC._cbRender(self, fault, request, parsed.get('id'), parsed.get('jsonrpc'))
 self.request = request
 return jsonrpc.JSONRPC.render(self, request)
 ## bridge ##
 try:
 self.bridge=DBusBridgeFrontend()
 except BridgeExceptionNoService:
 print(u"Can't connect to SàT backend, are you sure it's launched ?")
-import sys
 sys.exit(1)
 self.bridge.register("connected", self.signal_handler.connected)
 self.bridge.register("connectionError", self.signal_handler.connectionError)
 for signal_name in ['presenceUpdate', 'personalEvent', 'newMessage', 'roomJoined', 'roomUserJoined', 'roomUserLeft', 'tarotGameStarted', 'tarotGameNew',
 'tarotGameChooseContrat', 'tarotGameShowCards', 'tarotGameInvalidCards', 'tarotGameCardsPlayed', 'tarotGameYourTurn', 'tarotGameScore']:
 root.putChild('json_api', MethodHandler(self))
 root.putChild('register_api', _register)
 root.putChild('blog', MicroBlog(self))
 root.putChild('css', File("server_css/"))
 self.site = server.Site(root)
+self.site.sessionFactory = LiberviaSession
 def startService(self):
 reactor.listenTCP(8080, self.site)
 def run(self):
 def stop(self):
 reactor.stop()
+registerAdapter(SATSession, server.Session, ISATSession)
 application = service.Application('Libervia')
 service = Libervia()
 service.setServiceParent(application)

Mercurial > libervia-web

comparison libervia.tac @ 44:2744dd31e8a5