libervia-backend: src/core/sat

comparison src/core/sat_main.py @ 759:93bd868b8fb6

backend, frontends: callbacks refactoring: - launchAction is now async, and return a dictionary for its result - no more action_id, actionResult* are deprecated - callback system is about to be unified

author	Goffi <goffi@goffi.org>
date	Tue, 24 Dec 2013 15:19:08 +0100
parents	e3ad48a2aab2
children	e1c64a5b4588

comparison

equal deleted inserted replaced

-:86224a13cc1d
+:93bd868b8fb6
 from sat.core import exceptions
 from sat.memory.memory import Memory
 from sat.tools.xml_tools import tupleList2dataForm
 from sat.tools.misc import TriggerManager
 from glob import glob
+from uuid import uuid4
 try:
 from twisted.words.protocols.xmlstream import XMPPHandler
 except ImportError:
 from wokkel.subprotocols import XMPPHandler
 error(_('Trying to redefine a constant'))
 raise Exception
 CONST[name] = value
 def __init__(self):
-#TODO: standardize callback system
+self._cb_map = {}  # map from callback_id to callbacks
+self.__private_data = {}  # used for internal callbacks (key = id) FIXME: to be removed
-self.__general_cb_map = {}  # callback called for general reasons (key = name)
-self.__private_data = {}  # used for internal callbacks (key = id)
 self.profiles = {}
 self.plugins = {}
 self.menus = {}  # dynamic menus. key: (type, category, name), value: menu data (dictionnary)
 self.memory = Memory(self)
 self.bridge.register("subscription", self.subscription)
 self.bridge.register("addContact", self.addContact)
 self.bridge.register("updateContact", self.updateContact)
 self.bridge.register("delContact", self.delContact)
 self.bridge.register("isConnected", self.isConnected)
-self.bridge.register("launchAction", self.launchAction)
+self.bridge.register("launchAction", self.launchCallback)
 self.bridge.register("confirmationAnswer", self.confirmationAnswer)
 self.bridge.register("getProgress", self.getProgress)
 self.bridge.register("getMenus", self.getMenus)
 self.bridge.register("getMenuHelp", self.getMenuHelp)
 self.bridge.register("asyncCallMenu", self.callMenu)
 connector = reactor.connectTCP(server, port, serverRegistrer)
 serverRegistrer.clientConnectionLost = lambda conn, reason: connector.disconnect()
 return next_id
-def registerNewAccountCB(self, id, data, profile):
+def registerNewAccountCB(self, data, profile):
+# FIXME: to be removed/redone elsewhere
 user = jid.parse(self.memory.getParamA("JabberID", "Connection", profile_key=profile))[0]
 password = self.memory.getParamA("Password", "Connection", profile_key=profile)
 server = self.memory.getParamA("Server", "Connection", profile_key=profile)
 if not user or not password or not server:
 self.askConfirmation(
 confirm_id, "YES/NO",
 {"message": _("Are you sure to register new account [%(user)s] to server %(server)s ?") % {'user': user, 'server': server, 'profile': profile}},
 self.regisConfirmCB, profile)
 print "===============+++++++++++ REGISTER NEW ACCOUNT++++++++++++++============"
-print "id=", id
-print "data=", data
 def regisConfirmCB(self, id, accepted, data, profile):
 print _("register Confirmation CB ! (%s)") % str(accepted)
 action_id, profile = self.__private_data[id]
 del self.__private_data[id]
 """submit a form
 @param target: target jid where we are submitting
 @param fields: list of tuples (name, value)
 @return: tuple: (id, deferred)
 """
+# FIXME: to be removed
 profile = self.memory.getProfileName(profile_key)
 assert(profile)
 to_jid = jid.JID(target)
 return
 if profile not in self.profiles:
 return False
 return self.profiles[profile].isConnected()
-def launchAction(self, type, data, profile_key):
-"""Launch a specific action asked by client
-@param type: action type (button)
-@param data: needed data to launch the action
-@return: action id for result, or empty string in case or error
-"""
-profile = self.memory.getProfileName(profile_key)
-if not profile:
-error(_('trying to launch action with a non-existant profile'))
-raise Exception  # TODO: raise a proper exception
-if type == "button":
-try:
-cb_name = data['callback_id']
-except KeyError:
-error(_("Incomplete data"))
-return ""
-id = sat_next_id()
-self.callGeneralCB(cb_name, id, data, profile=profile)
-return id
-else:
-error(_("Unknown action type"))
-return ""
 ## jabber methods ##
 def getWaitingConf(self, profile_key=None):
 assert(profile_key)
 @param conf_id: conf_id used to get answer
 @param conf_type: confirmation conf_type ("YES/NO", "FILE_TRANSFER")
 @param data: data (depend of confirmation conf_type)
 @param cb: callback called with the answer
 """
+# FIXME: use XMLUI and *callback methods for dialog
 client = self.getClient(profile)
 if not client:
 raise exceptions.ProfileUnknownError(_("Asking confirmation a non-existant profile"))
 if conf_id in client._waiting_conf:
 error(_("Attempt to register two callbacks for the same confirmation"))
 except KeyError:
 pass
 #debug("Requested progress for unknown progress_id")
 return data
-def registerGeneralCB(self, name, CB):
+def registerCallback(self, callback, *args, **kwargs):
-"""Register a callback called for general reason"""
+""" Register a callback.
-self.__general_cb_map[name] = CB
+Use with_data=True in kwargs if the callback use the optional data dict
+use force_id=id to avoid generated id. Can lead to name conflict, avoid if possible
-def removeGeneralCB(self, name):
+@param callback: any callable
-"""Remove a general callback"""
+@return: id of the registered callback
-if name not in self.__general_cb_map:
+"""
-error(_("Trying to remove an unknow general callback"))
+callback_id = kwargs.pop('force_id', None)
+if callback_id is None:
+callback_id = str(uuid4())
 else:
-del self.__general_cb_map[name]
+if callback_id in self._cb_map:
+raise exceptions.ConflictError(_(u"id already registered"))
-def callGeneralCB(self, name, *args, **kwargs):
+self._cb_map[callback_id] = (callback, args, kwargs)
-"""Call general function back"""
+return callback_id
+def removeCallback(self, callback_id):
+""" Remove a previously registered callback
+@param callback_id: id returned by [registerCallback] """
+del self._cb_map[callback_id]
+def launchCallback(self, callback_id, data=None, profile_key="@NONE@"):
+"""Launch a specific callback
+@param callback_id: id of the action (callback) to launch
+@param data: optional data
+@profile_key: %(doc_profile_key)s
+@return: a deferred which fire a dict where key can be:
+- xmlui: a XMLUI need to be displayed
+"""
+profile = self.memory.getProfileName(profile_key)
+if not profile:
+raise exceptions.ProfileUnknownError(_('trying to launch action with a non-existant profile'))
 try:
-return self.__general_cb_map[name](*args, **kwargs)
+callback, args, kwargs = self._cb_map[callback_id]
 except KeyError:
-error(_("Trying to call unknown function (%s)") % name)
+raise exceptions.DataError("Unknown callback id")
-return None
+if kwargs.get("with_data", False):
+if data is None:
+raise exceptions.DataError("Required data for this callback is missing")
+args,kwargs=list(args)[:],kwargs.copy() # we don't want to modify the original (kw)args
+args.insert(0, data)
+kwargs["profile"] = profile
+del kwargs["with_data"]
+return defer.maybeDeferred(callback, *args, **kwargs)
 #Menus management
 def importMenu(self, category, name, callback, callback_args=None, callback_kwargs=None, help_string="", type_="NORMAL"):
 """register a new menu for frontends
 @param name: name of the menu to call
 @param type_: type of the menu to call
 @param profile_key: %(doc_profile_key)s
 @return: XMLUI or empty string if it's a one shot menu
 """
+# TODO: menus should use launchCallback
 profile = self.memory.getProfileName(profile_key)
 if not profile:
 raise exceptions.ProfileUnknownError
 menu_data = self.menus[(type_, category, name)]
 callback = menu_data['callback']

Mercurial > libervia-backend

comparison src/core/sat_main.py @ 759:93bd868b8fb6