#!/usr/bin/python # -*- coding: utf-8 -*- """ Libervia: a Salut à Toi frontend Copyright (C) 2011, 2012, 2013 Jérôme Poisson This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see . """ from twisted.application import internet, service from twisted.internet import glib2reactor glib2reactor.install() from twisted.internet import reactor, defer from twisted.web import server from twisted.web import error as weberror from twisted.web.static import File from twisted.web.resource import Resource, NoResource from twisted.web.util import Redirect 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 from logging import debug, info, warning, error import re, glob import os.path, sys import tempfile, shutil, uuid from server_side.blog import MicroBlog from zope.interface import Interface, Attribute, implements #import time TIMEOUT = 300 #Session's time out, after that the user will be disconnected LIBERVIA_DIR = "output/" MEDIA_DIR = "media/" AVATARS_DIR = "avatars/" CARDS_DIR = "games/cards/tarot" 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 ProtectedFile(File): """A File class which doens't show directory listing""" def directoryListing(self): return NoResource() class SATActionIDHandler(object): """Manage SàT action action_id lifecycle""" ID_LIFETIME = 30 #after this time (in seconds), action_id will be suppressed and action result will be ignored def __init__(self): self.waiting_ids = {} def waitForId(self, callback, action_id, profile, *args, **kwargs): """Wait for an action result @param callback: method to call when action gave a result back @param action_id: action_id to wait for @param profile: %(doc_profile)s @param *args: additional argument to pass to callback @param **kwargs: idem""" action_tuple = (action_id, profile) self.waiting_ids[action_tuple] = (callback, args, kwargs) reactor.callLater(self.ID_LIFETIME, self.purgeID, action_tuple) def purgeID(self, action_tuple): """Called when an action_id has not be handled in time""" if action_tuple in self.waiting_ids: warning ("action of action_id %s [%s] has not been managed, action_id is now ignored" % action_tuple) del self.waiting_ids[action_tuple] def actionResultCb(self, answer_type, action_id, data, profile): """Manage the actionResult signal""" action_tuple = (action_id, profile) if action_tuple in self.waiting_ids: callback, args, kwargs = self.waiting_ids[action_tuple] del self.waiting_ids[action_tuple] callback(answer_type, action_id, data, *args, **kwargs) 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() profile = ISATSession(self.session).profile if not profile: #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""" sat_session = ISATSession(self.session) profile = sat_session.profile sat_session.jid = JID(self.sat_host.bridge.getParamA("JabberID", "Connection", profile_key=profile)) return sat_session.jid.full() def jsonrpc_disconnect(self): """Disconnect the profile""" sat_session = ISATSession(self.session) profile = sat_session.profile self.sat_host.bridge.disconnect(profile) def jsonrpc_getContacts(self): """Return all passed args.""" profile = ISATSession(self.session).profile return self.sat_host.bridge.getContacts(profile) def jsonrpc_addContact(self, entity, name, groups): """Subscribe to contact presence, and add it to the given groups""" profile = ISATSession(self.session).profile self.sat_host.bridge.addContact(entity, profile) self.sat_host.bridge.updateContact(entity, name, groups, profile) def jsonrpc_delContact(self, entity): """Remove contact from contacts list""" profile = ISATSession(self.session).profile self.sat_host.bridge.delContact(entity, profile) def jsonrpc_updateContact(self, entity, name, groups): """Update contact's roster item""" profile = ISATSession(self.session).profile self.sat_host.bridge.updateContact(entity, name, groups, profile) def jsonrpc_subscription(self, sub_type, entity, name, groups): """Confirm (or infirm) subscription, and setup user roster in case of subscription""" profile = ISATSession(self.session).profile self.sat_host.bridge.subscription(sub_type, entity, profile) if sub_type == 'subscribed': self.sat_host.bridge.updateContact(entity, name, groups, profile) def jsonrpc_getWaitingSub(self): """Return list of room already joined by user""" profile = ISATSession(self.session).profile return self.sat_host.bridge.getWaitingSub(profile) def jsonrpc_setStatus(self, status): """Change the status""" profile = ISATSession(self.session).profile self.sat_host.bridge.setPresence('', '', 0, {'':status}, profile) def jsonrpc_sendMessage(self, to_jid, msg, subject, _type): """send message""" profile = ISATSession(self.session).profile return self.sat_host.bridge.sendMessage(to_jid, msg, subject, _type, profile) def jsonrpc_sendMblog(self, _type, dest, text): """ Send microblog message @param _type: one of "PUBLIC", "GROUP" @param dest: destinees (list of groups, ignored for "PUBLIC") @param text: microblog's text """ profile = ISATSession(self.session).profile if _type in ("PUBLIC", "GROUP") and text: if _type == "PUBLIC": #This text if for the public microblog print "sending public blog" return self.sat_host.bridge.sendGroupBlog("PUBLIC", [], text, {'allow_comments': 'True'}, profile) else: print "sending group blog" return self.sat_host.bridge.sendGroupBlog("GROUP", [dest], text, {'allow_comments': 'True'}, profile) else: raise Exception("Invalid data") def jsonrpc_sendMblogComment(self, node, text): """ Send microblog message @param node: url of the comments node @param text: comment """ profile = ISATSession(self.session).profile if node and text: return self.sat_host.bridge.sendGroupBlogComment(node, text, profile) else: raise Exception("Invalid data") def jsonrpc_getLastMblogs(self, publisher_jid, max_item): """Get last microblogs posted by a contact @param publisher_jid: jid of the publisher @param max_item: number of items to ask @return list of microblog data (dict)""" profile = ISATSession(self.session).profile d = defer.Deferred() self.sat_host.bridge.getLastGroupBlogs(publisher_jid, max_item, profile, callback=d.callback, errback=d.errback) return d def jsonrpc_getMassiveLastMblogs(self, publishers_type, publishers_list, max_item): """Get lasts microblogs posted by several contacts at once @param publishers_type: one of "ALL", "GROUP", "JID" @param publishers_list: list of publishers type (empty list of all, list of groups or list of jids) @param max_item: number of items to ask @return: dictionary key=publisher's jid, value=list of microblog data (dict)""" profile = ISATSession(self.session).profile d = defer.Deferred() self.sat_host.bridge.getMassiveLastGroupBlogs(publishers_type, publishers_list, max_item, profile, callback=d.callback, errback=d.errback) self.sat_host.bridge.massiveSubscribeGroupBlogs(publishers_type, publishers_list, profile) return d def jsonrpc_getMblogComments(self, service, node): """Get all comments of given node @param service: jid of the service hosting the node @param node: comments node """ profile = ISATSession(self.session).profile d = defer.Deferred() self.sat_host.bridge.getGroupBlogComments(service, node, profile, callback=d.callback, errback=d.errback) return d def jsonrpc_getPresenceStatus(self): """Get Presence information for connected contacts""" profile = ISATSession(self.session).profile return self.sat_host.bridge.getPresenceStatus(profile) def jsonrpc_getHistory(self, from_jid, to_jid, size, between): """Return history for the from_jid/to_jid couple""" sat_session = ISATSession(self.session) profile = sat_session.profile sat_jid = sat_session.jid if not sat_jid: error("No jid saved for this profile") return {} 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 {} d = defer.Deferred() self.sat_host.bridge.getHistory(from_jid, to_jid, size, between, profile, callback=d.callback, errback=d.errback) def show(result_dbus): result = [] for line in result_dbus: #XXX: we have to do this stupid thing because Python D-Bus use its own types instead of standard types # and txJsonRPC doesn't accept D-Bus types, resulting in a empty query timestamp, from_jid, to_jid, message, mess_type = line result.append((float(timestamp), unicode(from_jid), unicode(to_jid), unicode(message), unicode(mess_type))) return result d.addCallback(show) return d def jsonrpc_joinMUC(self, room_jid, nick): """Join a Multi-User Chat room""" profile = ISATSession(self.session).profile try: room_jid = JID(room_jid) except: warning('Invalid room jid') return self.sat_host.bridge.joinMUC(room_jid.userhost(), nick, {}, profile) def jsonrpc_mucLeave(self, room_jid): """Quit a Multi-User Chat room""" profile = ISATSession(self.session).profile try: room_jid = JID(room_jid) except: warning('Invalid room jid') return self.sat_host.bridge.mucLeave(room_jid.userhost(), profile) def jsonrpc_getRoomsJoined(self): """Return list of room already joined by user""" profile = ISATSession(self.session).profile return self.sat_host.bridge.getRoomsJoined(profile) def jsonrpc_launchTarotGame(self, other_players): """Create a room, invite the other players and start a Tarot game""" 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""" _join = os.path.join _media_dir = _join(self.sat_host.media_dir,'') return map(lambda x: _join(MEDIA_DIR, x[len(_media_dir):]),glob.glob(_join(_media_dir,CARDS_DIR,'*_*.png'))); def jsonrpc_tarotGameReady(self, player, referee): """Tell to the server that we are ready to start the game""" profile = ISATSession(self.session).profile self.sat_host.bridge.tarotGameReady(player, referee, profile) def jsonrpc_tarotGameContratChoosed(self, player_nick, referee, contrat): """Tell to the server that we are ready to start the game""" 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 the cards we want to put on the table""" profile = ISATSession(self.session).profile self.sat_host.bridge.tarotGamePlayCards(player_nick, referee, cards, profile) def jsonrpc_launchRadioCollective(self, invited): """Create a room, invite people, and start a radio collective""" profile = ISATSession(self.session).profile self.sat_host.bridge.radiocolLaunch(invited, profile) def jsonrpc_getEntityData(self, jid, keys): """Get cached data for an entit @param jid: jid of contact from who we want data @param keys: name of data we want (list) @return: requested data""" profile = ISATSession(self.session).profile return self.sat_host.bridge.getEntityData(jid, keys, profile) def jsonrpc_getCard(self, jid): """Get VCard for entiry @param jid: jid of contact from who we want data @return: id to retrieve the profile""" profile = ISATSession(self.session).profile return self.sat_host.bridge.getCard(jid, profile) #def jsonrpc_getParamsUI(self): # """Return the parameters XMLUI for profile""" # profile = ISATSession(self.session).profile # d = defer.Deferred() # self.sat_host.bridge.getParamsUI(profile, callback=d.callback, errback=d.errback) # #d.addCallback(lambda result: unicode(result)) # return d #def jsonrpc_setParam(self, name, value, category): # profile = ISATSession(self.session).profile # return self.sat_host.bridge.setParam(name, value, category, profile) def jsonrpc_launchAction(self, action_type, data): profile = ISATSession(self.session).profile return self.sat_host.bridge.launchAction(action_type, data, 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""" def __init__(self, sat_host): jsonrpc.JSONRPC.__init__(self) self.sat_host=sat_host self.profiles_waiting={} self.request=None def getWaitingRequest(self, profile): """Tell if a profile is trying to log in""" if self.profiles_waiting.has_key(profile): 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 - except login, every method is jsonrpc - user doesn't need to be authentified for isRegistered, but must be for all other methods """ if request.postpath==['login']: 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 profile = ISATSession(_session).profile if not profile: #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 login(self, request): """ this method is called with the POST information from the registering form it test if the password is ok, and log in if it's the case, else it return an error @param request: request of the register formulaire, must have "login" and "password" as arguments @return: A constant indicating the state: - BAD REQUEST: something is wrong in the request (bad arguments, profile_key for login) - AUTH ERROR: either the profile or the password is wrong - ALREADY WAITING: a request has already be made for this profile - server.NOT_DONE_YET: the profile is being processed, the return value will be given by self._logged or self._logginError """ try: if request.args['submit_type'][0] == 'login': _login = request.args['login'][0] if _login.startswith('@'): raise Exception('No profile_key allowed') _pass = request.args['login_password'][0] elif request.args['submit_type'][0] == 'register': return self._registerNewAccount(request) else: raise Exception('Unknown submit type') except KeyError: return "BAD REQUEST" _profile_check = self.sat_host.bridge.getProfileName(_login) def profile_pass_cb(_profile_pass): if not _profile_check or _profile_check != _login or _profile_pass != _pass: request.write("AUTH ERROR") request.finish() return if self.profiles_waiting.has_key(_login): request.write("ALREADY WAITING") request.finish() return if self.sat_host.bridge.isConnected(_login): request.write(self._logged(_login, request, finish=False)) request.finish() return self.profiles_waiting[_login] = request d = defer.Deferred() self.sat_host.bridge.asyncConnect(_login, lambda: d.callback(None), d.errback) return d def profile_pass_errback(ignore): error("INTERNAL ERROR: can't check profile password") request.write("AUTH ERROR") request.finish() d = defer.Deferred() self.sat_host.bridge.asyncGetParamA("Password", "Connection", profile_key=_login, callback=d.callback, errback=d.errback) d.addCallbacks(profile_pass_cb, profile_pass_errback) return server.NOT_DONE_YET def _postAccountCreation(self, answer_type, id, data, profile): """Called when a account has just been created, setup stuff has microblog access""" def _connected(ignore): mblog_d = defer.Deferred() self.sat_host.bridge.setMicroblogAccess("open", profile, lambda: mblog_d.callback(None), mblog_d.errback) mblog_d.addBoth(lambda ignore: self.sat_host.bridge.disconnect(profile)) d = defer.Deferred() self.sat_host.bridge.asyncConnect(profile, lambda: d.callback(None), d.errback) d.addCallback(_connected) def _registerNewAccount(self, request): """Create a new account, or return error @param request: initial login request @return: "REGISTRATION" in case of success""" #TODO: must be moved in SàT core try: profile = login = request.args['register_login'][0] password = request.args['register_password'][0] #FIXME: password is ignored so far email = request.args['email'][0] except KeyError: return "BAD REQUEST" if not re.match(r'^[a-z0-9_-]+$', login, re.IGNORECASE) or \ not re.match(r'^.+@.+\..+', email, re.IGNORECASE): return "BAD REQUEST" def registered(result): request.write('REGISTRATION') request.finish() #import pudb #pudb.set_trace() def registeringError(failure): reason = str(failure.value) if reason == "CONFLICT": request.write('ALREADY EXISTS') elif reason == "INTERNAL": request.write('INTERNAL') else: #import pdb #pdb.set_trace() error('Unknown registering error: %s' % (reason,)) request.write('Unknown error (%s)' % reason) request.finish() d = defer.Deferred() self.sat_host.bridge.registerSatAccount(email, password, profile, lambda: d.callback(None), d.errback) 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, finish=True): """Set everything when a user just logged and return "LOGGED" to the requester""" def result(answer): if finish: request.write(answer) request.finish() else: return answer self.__cleanWaiting(profile) _session = request.getSession() sat_session = ISATSession(_session) if sat_session.profile: error (('/!\\ Session has already a profile, this should NEVER happen !')) return result('SESSION_ACTIVE') sat_session.profile = profile self.sat_host.prof_connected.add(profile) def onExpire(): info ("Session expired (profile=%s)" % (profile,)) try: #We purge the queue del self.sat_host.signal_handler.queue[profile] except KeyError: pass #and now we disconnect the profile self.sat_host.bridge.disconnect(profile) _session.notifyOnExpire(onExpire) d = defer.Deferred() return result('LOGGED') def _logginError(self, login, request, error_type): """Something went wrong during loggin, return an error""" self.__cleanWaiting(login) return error_type def jsonrpc_isConnected(self): _session = self.request.getSession() profile = ISATSession(_session).profile return self.sat_host.bridge.isConnected(profile) def jsonrpc_connect(self): _session = self.request.getSession() 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() profile = ISATSession(_session).profile return bool(profile) class SignalHandler(jsonrpc.JSONRPC): def __init__(self, sat_host): Resource.__init__(self) self.register=None self.sat_host=sat_host self.signalDeferred = {} self.queue = {} def plugRegister(self, register): self.register = register 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 = 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(signal, profile): _session.unlock() try: source_defer = self.signalDeferred[profile] if source_defer.called and source_defer.result[0] == "disconnected": info(u"[%s] disconnected" % (profile,)) _session.expire() except IndexError: error("Deferred result should be a tuple with fonction name first") self.signalDeferred[profile] = defer.Deferred() self.request.notifyFinish().addBoth(unlock, profile) 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""" def genericCb(*args): profile = args[-1] if not profile in self.sat_host.prof_connected: return if profile in self.signalDeferred: self.signalDeferred[profile].callback((function_name,args[:-1])) del self.signalDeferred[profile] else: if not self.queue.has_key(profile): self.queue[profile] = [] 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) if request: self.register._logged(profile, request) def disconnected(self, profile): if not profile in self.sat_host.prof_connected: error("'disconnected' signal received for a not connected profile") return self.sat_host.prof_connected.remove(profile) if profile in self.signalDeferred: self.signalDeferred[profile].callback(("disconnected",)) del self.signalDeferred[profile] else: if not self.queue.has_key(profile): self.queue[profile] = [] self.queue[profile].append(("disconnected",)) def connectionError(self, error_type, profile): assert(self.register) #register must be plugged request = self.register.getWaitingRequest(profile) if request: #The user is trying to log in if error_type == "AUTH_ERROR": _error_t = "AUTH ERROR" else: _error_t = "UNKNOWN" self.register._logginError(profile, request, _error_t) def render(self, request): """ Render method wich reject access if user is not identified """ _session = request.getSession() parsed = jsonrpclib.loads(request.content.read()) profile = ISATSession(_session).profile if not profile: #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) class UploadManager(Resource): """This class manage the upload of a file It redirect the stream to SàT core backend""" isLeaf = True NAME = 'path' #name use by the FileUpload def __init__(self, sat_host): self.sat_host=sat_host self.upload_dir = tempfile.mkdtemp() self.sat_host.addCleanup(shutil.rmtree, self.upload_dir) def getTmpDir(self): return self.upload_dir def _getFileName(self, request): """Generate unique filename for a file""" raise NotImplementedError def _fileWritten(self, request, filepath): """Called once the file is actually written on disk""" raise NotImplementedError def render(self, request): """ Render method with some hacks: - if login is requested, try to login with form data - except login, every method is jsonrpc - user doesn't need to be authentified for isRegistered, but must be for all other methods """ #start = time.time() filename = self._getFileName(request) filepath = os.path.join(self.upload_dir, filename) #FIXME: the uploaded file is fully loaded in memory at form parsing time so far # (see twisted.web.http.Request.requestReceived). A custom requestReceived should # be written in the futur. In addition, it is not yet possible to get progression informations # (see http://twistedmatrix.com/trac/ticket/288) with open(filepath,'w') as f: f.write(request.args[self.NAME][0]) self._fileWritten(request, filepath) #end = time.time() #print "time spent in render: %fs" % (end - start) return "OK" class UploadManagerRadioCol(UploadManager): NAME = 'song' def _getFileName(self, request): return "%s.ogg" % str(uuid.uuid4()) #XXX: chromium doesn't seem to play song without the .ogg extension, even with audio/ogg mime-type def _fileWritten(self, request, filepath): """Called once the file is actually written on disk""" profile = ISATSession(request.getSession()).profile self.sat_host.bridge.radiocolSongAdded(request.args['referee'][0], filepath, profile) class UploadManagerAvatar(UploadManager): NAME = 'avatar_path' def _getFileName(self, request): return str(uuid.uuid4()) def _fileWritten(self, request, filepath): """Called once the file is actually written on disk""" profile = ISATSession(request.getSession()).profile print u"fichier écrit:", filepath self.sat_host.bridge.setAvatar(filepath, profile) class Libervia(service.Service): def __init__(self): self._cleanup = [] root = ProtectedFile(LIBERVIA_DIR) self.signal_handler = SignalHandler(self) _register = Register(self) _upload_radiocol = UploadManagerRadioCol(self) _upload_avatar = UploadManagerAvatar(self) self.signal_handler.plugRegister(_register) self.sessions = {} #key = session value = user self.prof_connected = set() #Profiles connected self.action_handler = SATActionIDHandler() ## bridge ## try: self.bridge=DBusBridgeFrontend() except BridgeExceptionNoService: print(u"Can't connect to SàT backend, are you sure it's launched ?") sys.exit(1) self.bridge.register("connected", self.signal_handler.connected) self.bridge.register("disconnected", self.signal_handler.disconnected) self.bridge.register("connectionError", self.signal_handler.connectionError) self.bridge.register("actionResult", self.action_handler.actionResultCb) #core for signal_name in ['presenceUpdate', 'newMessage', 'subscribe', 'contactDeleted', 'newContact', 'entityDataUpdated']: self.bridge.register(signal_name, self.signal_handler.getGenericCb(signal_name)) #plugins for signal_name in ['personalEvent', 'roomJoined', 'roomUserJoined', 'roomUserLeft', 'tarotGameStarted', 'tarotGameNew', 'tarotGameChooseContrat', 'tarotGameShowCards', 'tarotGameInvalidCards', 'tarotGameCardsPlayed', 'tarotGameYourTurn', 'tarotGameScore', 'radiocolStarted', 'radiocolPreload', 'radiocolPlay', 'radiocolNoUpload', 'radiocolUploadOk', 'radiocolSongRejected']: self.bridge.register(signal_name, self.signal_handler.getGenericCb(signal_name), "plugin") self.media_dir = self.bridge.getConfig('','media_dir') self.local_dir = self.bridge.getConfig('','local_dir') root.putChild('', Redirect('libervia.html')) root.putChild('json_signal_api', self.signal_handler) root.putChild('json_api', MethodHandler(self)) root.putChild('register_api', _register) root.putChild('upload_radiocol', _upload_radiocol) root.putChild('upload_avatar', _upload_avatar) root.putChild('blog', MicroBlog(self)) root.putChild('css', ProtectedFile("server_css/")) root.putChild(os.path.dirname(MEDIA_DIR), ProtectedFile(self.media_dir)) root.putChild(os.path.dirname(AVATARS_DIR), ProtectedFile(os.path.join(self.local_dir, AVATARS_DIR))) root.putChild('radiocol', ProtectedFile(_upload_radiocol.getTmpDir(), defaultType="audio/ogg")) #We cheat for PoC because we know we are on the same host, so we use directly upload dir self.site = server.Site(root) self.site.sessionFactory = LiberviaSession def addCleanup(self, callback, *args, **kwargs): """Add cleaning method to call when service is stopped cleaning method will be called in reverse order of they insertion @param callback: callable to call on service stop @param *args: list of arguments of the callback @param **kwargs: list of keyword arguments of the callback""" self._cleanup.insert(0, (callback, args, kwargs)) def startService(self): reactor.listenTCP(8080, self.site) def stopService(self): print "launching cleaning methods" for callback, args, kwargs in self._cleanup: callback(*args, **kwargs) def run(self): reactor.run() def stop(self): reactor.stop() registerAdapter(SATSession, server.Session, ISATSession) application = service.Application('Libervia') service = Libervia() service.setServiceParent(application)