libervia-backend: src/core/sat

comparison src/core/sat_main.py @ 587:952322b1d490

Remove trailing whitespaces.

author	Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
date	Fri, 18 Jan 2013 17:55:34 +0100
parents	133078b82ca8
children	d1b4805124a1

comparison

equal deleted inserted replaced

-:6a718ede8be1
+:952322b1d490
 global sat_id
 sat_id+=1
 return "sat_id_"+str(sat_id)
 class SAT(service.Service):
 def get_next_id(self):
 return sat_next_id()
 def get_const(self, name):
 """Return a constant"""
 def set_const(self, name, value):
 """Save a constant"""
 if CONST.has_key(name):
 error(_('Trying to redefine a constant'))
 raise Exception
 CONST[name] = value
 def __init__(self):
 #TODO: standardize callback system
 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 = {} #used to know which new menus are wanted by plugins
 self.memory=Memory(self)
 local_dir = self.memory.getConfig('', 'local_dir')
 if not os.path.exists(local_dir):
 os.makedirs(local_dir)
 self.trigger = TriggerManager() #trigger are used to change SàT behaviour
 self.bridge=DBusBridge()
 self.bridge.register("getVersion", lambda: self.get_const('client_version'))
 self.bridge.register("getProfileName", self.memory.getProfileName)
 self.bridge.register("getProfilesList", self.memory.getProfilesList)
 self.bridge.register("getEntityData", lambda _jid, keys, profile: self.memory.getEntityData(jid.JID(_jid), keys, profile))
 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("callMenu", self.callMenu)
 self.memory.initialized.addCallback(self._postMemoryInit)
 def _postMemoryInit(self, ignore):
 """Method called after memory initialization is done"""
 info(_("Memory initialised"))
 self._import_plugins()
 def _import_plugins(self):
 """Import all plugins found in plugins directory"""
 import sat.plugins
 plugins_path = os.path.dirname(sat.plugins.__file__)
 plug_lst = [os.path.splitext(plugin)[0] for plugin in map(os.path.basename,glob(os.path.join(plugins_path,"plugin*.py")))]
 __plugins_to_import = {} #plugins we still have to import
 for plug in plug_lst:
 plugin_path = 'sat.plugins.'+plug
 __import__(plugin_path)
 self.plugins[import_name].is_handler = True
 else:
 self.plugins[import_name].is_handler = False
 #TODO: test xmppclient presence and register handler parent
 def connect(self, profile_key = '@DEFAULT@'):
 """Connect to jabber server"""
 self.asyncConnect(profile_key)
 def asyncConnect(self, profile_key = '@DEFAULT@'):
 """Connect to jabber server with asynchronous reply
 @param profile_key: %(doc_profile)s
 """
 profile = self.memory.getProfileName(profile_key)
 if not profile:
 error (_('Trying to connect a non-exsitant profile'))
 raise ProfileUnknownError(profile_key)
 if (self.isConnected(profile)):
 info(_("already connected !"))
 return defer.succeed("None")
 def afterMemoryInit(ignore):
 error(_("Can't parse port value, using default value"))
 port = 5222
 current = self.profiles[profile] = xmpp.SatXMPPClient(self, profile,
 jid.JID(self.memory.getParamA("JabberID", "Connection", profile_key = profile), profile),
 self.memory.getParamA("Password", "Connection", profile_key = profile),
 self.memory.getParamA("Server", "Connection", profile_key = profile),
 port)
 current.messageProt = xmpp.SatMessageProtocol(self)
 current.messageProt.setHandlerParent(current)
 current.roster = xmpp.SatRosterProtocol(self)
 current.roster.setHandlerParent(current)
 current.presence = xmpp.SatPresenceProtocol(self)
 current.presence.setHandlerParent(current)
 current.versionHandler = xmpp.SatVersionHandler(self.get_const('client_name'),
 self.get_const('client_version'))
 current.versionHandler.setHandlerParent(current)
 debug (_("setting plugins parents"))
 for plugin in self.plugins.iteritems():
 if plugin[1].is_handler:
 plugin[1].getHandler(profile).setHandlerParent(current)
 connected_cb = getattr(plugin[1], "profileConnected", None)
 if connected_cb:
 def startService(self):
 info("Salut à toi ô mon frère !")
 #TODO: manage autoconnect
 #self.connect()
 def stopService(self):
 self.memory.save()
 info("Salut aussi à Rantanplan")
 def run(self):
 debug(_("running app"))
 reactor.run()
 def stop(self):
 debug(_("stopping app"))
 reactor.stop()
 ## Misc methods ##
 def getJidNStream(self, profile_key):
 """Convenient method to get jid and stream from profile key
 @return: tuple (jid, xmlstream) from profile, can be None"""
 profile = self.memory.getProfileName(profile_key)
 if not profile or not self.profiles[profile].isConnected():
 next_id = id or sat_next_id()  #the id is used to send server's answer
 serverRegistrer = xmlstream.XmlStreamFactory(xmpp.RegisteringAuthenticator(self, server, login, password, email, next_id, profile))
 connector = reactor.connectTCP(server, port, serverRegistrer)
 serverRegistrer.clientConnectionLost = lambda conn, reason: connector.disconnect()
 return next_id
 def registerNewAccountCB(self, id, data, profile):
 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)
 self.actionResult(id, "ERROR", {'message':_("No user, password or server given, can't register new account.")}, profile)
 return
 confirm_id = sat_next_id()
 self.__private_data[confirm_id]=(id,profile)
 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
 """
 profile = self.memory.getProfileName(profile_key)
 assert(profile)
 to_jid = jid.JID(target)
 iq = compat.IQ(self.profiles[profile].xmlstream, 'set')
 iq["to"] = target
 iq["from"] = self.profiles[profile].jid.full()
 query = iq.addElement(('jabber:iq:register', 'query'))
 if action=='SUBMIT':
 error (_("Unknown action type"))
 return ""
 ## jabber methods ##
 def getWaitingConf(self, profile_key=None):
 assert(profile_key)
 client = self.getClient(profile_key)
 if not client:
 raise ProfileNotInCacheError
 ret = []
 for conf_id in client._waiting_conf:
 conf_type, data = client._waiting_conf[conf_id][:2]
 ret.append((conf_id, conf_type, data))
 return ret
 def sendMessage(self, to, msg, subject=None, mess_type='auto', profile_key='@DEFAULT@'):
 #FIXME: check validity of recipient
 profile = self.memory.getProfileName(profile_key)
 assert(profile)
 client = self.profiles[profile]
 current_jid = client.jid
 mess_data = { #we put data in a dict, so trigger methods can change them
 "to": jid.JID(to),
 "message": msg,
 "subject": subject,
 "type": mess_type
 }
 if mess_data["type"] == "auto":
 # we try to guess the type
 if mess_data["subject"]:
 mess_data["type"] = 'normal'
 elif not mess_data["to"].resource: #if to JID has a resource, the type is not 'groupchat'
 #we may have a groupchat message, we check if the we know this jid
 try:
 entity_type = self.memory.getEntityData(mess_data["to"], ['type'], profile)["type"]
 #FIXME: should entity_type manage ressources ?
 except (UnknownEntityError, KeyError):
 entity_type = "contact"
 if entity_type == "chatroom":
 mess_data["type"] = 'groupchat'
 else:
 mess_data["type"] = 'chat'
 else:
 mess_data["type"] == 'chat'
 mess_data["type"] == "chat" if mess_data["subject"] else "normal"
 if not self.trigger.point("sendMessage", mess_data, profile):
 return
 debug(_("Sending jabber message of type [%(type)s] to %(to)s...") % {"type": mess_data["type"], "to": to})
 message = domish.Element((None,'message'))
 message["to"] = mess_data["to"].full()
 message["from"] = current_jid.full()
 message["type"] = mess_data["type"]
 if statuses.has_key(''):
 statuses['default'] = statuses['']
 del statuses['']
 self.bridge.presenceUpdate(self.profiles[profile].jid.full(),  show,
 int(priority), statuses, profile)
 def subscription(self, subs_type, raw_jid, profile_key):
 """Called to manage subscription
 @param subs_type: subsciption type (cf RFC 3921)
 @param raw_jid: unicode entity's jid
 @param profile_key: profile"""
 debug (_("Identity found: [%(category)s/%(type)s] %(identity)s") % {'category':cat, 'type':type, 'identity':disco.identities[(cat,type)]})
 def serverDiscoItems(self, disco_result, disco_client, profile, initialized):
 """xep-0030 Discovery Protocol.
 @param disco_result: result of the disco item querry
 @param disco_client: SatDiscoProtocol instance
 @param profile: profile of the user
 @param initialized: deferred which must be chained when everything is done"""
 def _check_entity_cb(result, entity, profile):
 for category, type in result.identities:
 debug (_('Identity added: (%(category)s,%(type)s) ==> %(entity)s [%(profile)s]') % {
 'category':category, 'type':type, 'entity':entity, 'profile':profile})
 self.memory.addServerIdentity(category, type, entity, profile)
 def _errback(result, entity, profile):
 warning(_("Can't get information on identity [%(entity)s] for profile [%(profile)s]") % {'entity':entity, 'profile': profile})
 defer_list = []
 for item in disco_result._items:
 if item.entity.full().count('.') == 1: #XXX: workaround for a bug on jabberfr, tmp
 warning(_('Using jabberfr workaround, be sure your domain has at least two levels (e.g. "example.tld", not "example" alone)'))
 continue
 args = [item.entity, profile]
 defer_list.append(disco_client.requestInfo(item.entity).addCallbacks(_check_entity_cb, _errback, args, None, args))
 defer.DeferredList(defer_list).chainDeferred(initialized)
 ## Generic HMI ##
 def actionResult(self, action_id, action_type, data, profile):
 """Send the result of an action
 @param action_id: same action_id used with action
 @param action_type: result action_type ("PARAM", "SUCCESS", "ERROR", "XMLUI")
 @param data: dictionary

Mercurial > libervia-backend

comparison src/core/sat_main.py @ 587:952322b1d490