libervia-web: libervia.tac comparison

comparison libervia.tac @ 219:36673d19c87e

server side: better async bridge calls handling

author	Goffi <goffi@goffi.org>
date	Sat, 21 Sep 2013 14:58:21 +0200
parents	4e6467efd6bf
children	e632f77c4219

comparison

equal deleted inserted replaced

-:4e6467efd6bf
+:36673d19c87e
 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.python.failure import Failure
 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
 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):
+class JSONRPCMethodManager(jsonrpc.JSONRPC):
 def __init__(self, sat_host):
 jsonrpc.JSONRPC.__init__(self)
 self.sat_host=sat_host
+def asyncBridgeCall(self, method_name, *args, **kwargs):
+"""Call an asynchrone bridge method and return a deferred
+@param method_name: name of the method as a unicode
+@return: a deferred which trigger the result
+"""
+d = defer.Deferred()
+def _callback(*args):
+if not args:
+d.callback(None)
+else:
+if len(args) != 1:
+Exception("Multiple return arguments not supported")
+d.callback(args[0])
+def _errback(result):
+d.errback(Failure(unicode(result)))
+kwargs["callback"] = d.callback
+kwargs["errback"] = _errback
+getattr(self.sat_host.bridge, method_name)(*args, **kwargs)
+return d
+class MethodHandler(JSONRPCMethodManager):
+def __init__(self, sat_host):
+JSONRPCMethodManager.__init__(self, sat_host)
 self.authorized_params = None
 def render(self, request):
 self.session = request.getSession()
 profile = ISATSession(self.session).profile
 """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()
+d = self.asyncBridgeCall("getLastGroupBlogs", publisher_jid, max_item, profile)
-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()
+d = self.asyncBridgeCall("getMassiveLastGroupBlogs", publishers_type, publishers_list, max_item, profile)
-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()
+d = self.asyncBridgeCall("getGroupBlogComments", service, node, profile)
-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"""
 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()
+d = self.asyncBridgeCall("getHistory", from_jid, to_jid, size, between, profile)
-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
 return self.sat_host.bridge.getCard(jid, profile)
 def jsonrpc_getParamsUI(self):
 """Return the parameters XML for profile"""
 profile = ISATSession(self.session).profile
-d = defer.Deferred()
+d = self.asyncBridgeCall("getParams", SECURITY_LIMIT, profile)
 def setAuthorizedParams(d):
 if self.authorized_params is None:
 self.authorized_params = {}
 for cat in minidom.parseString(d.encode('utf-8')).getElementsByTagName("category"):
 self.authorized_params[cat.getAttribute("name")] = params_list
 if self.authorized_params:
 return d
 else:
 return None
 d.addCallback(setAuthorizedParams)
 from sat.tools.xml_tools import paramsXml2xmlUI
 d.addCallback(lambda d: paramsXml2xmlUI(d) if d else "")
-self.sat_host.bridge.getParams(SECURITY_LIMIT, profile, callback=d.callback, errback=d.errback)
 return d
 def jsonrpc_setParam(self, name, value, category):
 profile = ISATSession(self.session).profile
 if category in self.authorized_params and name in self.authorized_params[category]:
 """
 profile = ISATSession(self.session).profile
 self.sat_host.bridge.chatStateComposing(to_jid_s, profile)
-class Register(jsonrpc.JSONRPC):
+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):
-jsonrpc.JSONRPC.__init__(self)
+JSONRPCMethodManager.__init__(self, sat_host)
-self.sat_host=sat_host
 self.profiles_waiting={}
 self.request=None
 def getWaitingRequest(self, profile):
 """Tell if a profile is trying to log in"""
 request.write(self._logged(_login, request, finish=False))
 request.finish()
 return
 self.profiles_waiting[_login] = request
-d = defer.Deferred()
+d = self.asyncBridgeCall("asyncConnect", _login)
-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()
+d = self.asyncBridgeCall("asyncGetParamA", "Password", "Connection", profile_key=_login)
-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()
+mblog_d = self.asyncBridgeCall("setMicroblogAccess", "open", profile)
-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()
+d = self.asyncBridgeCall("asyncConnect", profile)
-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
 error('Unknown registering error: %s' % (reason,))
 request.write('Unknown error (%s)' % reason)
 request.finish()
-d = defer.Deferred()
+d = self.asyncBridgeCall("registerSatAccount", email, password, profile)
-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):

Mercurial > libervia-web

comparison libervia.tac @ 219:36673d19c87e