Mercurial > libervia-backend
changeset 1970:200cd707a46d
plugin XEP-0045, quick_frontend + primitivus (chat): cleaning of XEP-0045 (first pass):
- bridge methods/signals now all start with "muc" to follow new convention
- internal method use client instead of profile to follow new convention
- removed excetpions from plugin XEP-0045 in favor of core.exceptions, NotReady added
- cleaned/simplified several part of the code. checkClient removed as it is not needed anymore
- self.clients map removed, muc data are now stored directly in client
- getRoomEntityNick and getRoomNicksOfUsers are removed as they don't look sane.
/!\ This break all room game plugins for the moment
- use of uuid4 instead of uuid1 for getUniqueName, as host ID and current time are used for uuid1
| author | Goffi <goffi@goffi.org> |
|---|---|
| date | Mon, 27 Jun 2016 21:45:11 +0200 |
| parents | 5fbe09b9b568 |
| children | 9421e721d5e2 |
| files | frontends/src/primitivus/chat.py frontends/src/primitivus/primitivus frontends/src/quick_frontend/quick_app.py src/core/exceptions.py src/memory/memory.py src/plugins/plugin_exp_parrot.py src/plugins/plugin_misc_room_game.py src/plugins/plugin_misc_tarot.py src/plugins/plugin_misc_text_commands.py src/plugins/plugin_sec_otr.py src/plugins/plugin_xep_0045.py src/plugins/plugin_xep_0054.py src/plugins/plugin_xep_0085.py src/plugins/plugin_xep_0249.py |
| diffstat | 14 files changed, 294 insertions(+), 307 deletions(-) [+] |
line wrap: on
line diff
--- a/frontends/src/primitivus/chat.py Fri Jun 24 22:41:28 2016 +0200 +++ b/frontends/src/primitivus/chat.py Mon Jun 27 21:45:11 2016 +0200 @@ -30,6 +30,7 @@ from sat_frontends.primitivus.keys import action_key_map as a_key from sat_frontends.primitivus.widget import PrimitivusWidget import time +import locale from sat_frontends.tools import jid from functools import total_ordering import bisect @@ -117,8 +118,8 @@ # timestamp if self.parent.show_timestamp: # if the message was sent before today, we print the full date - time_format = "%c" if self.timestamp < self.parent.day_change else "%H:%M" - markup.append(('date', "[{}]".format(time.strftime(time_format, self.timestamp).decode('utf-8')))) + time_format = u"%c" if self.timestamp < self.parent.day_change else u"%H:%M" + markup.append(('date', u"[{}]".format(time.strftime(time_format, self.timestamp).decode(locale.getlocale()[1])))) # nickname if self.parent.show_short_nick:
--- a/frontends/src/primitivus/primitivus Fri Jun 24 22:41:28 2016 +0200 +++ b/frontends/src/primitivus/primitivus Mon Jun 27 21:45:11 2016 +0200 @@ -855,7 +855,7 @@ def onJoinRoomRequest(self, menu): """User wants to join a MUC room""" - pop_up_widget = sat_widgets.InputDialog(_("Entering a MUC room"), _("Please enter MUC's JID"), default_txt=self.bridge.getDefaultMUC(), ok_cb=self.onJoinRoom) + pop_up_widget = sat_widgets.InputDialog(_("Entering a MUC room"), _("Please enter MUC's JID"), default_txt=self.bridge.mucGetDefaultService(), ok_cb=self.onJoinRoom) pop_up_widget.setCallback('cancel', lambda dummy: self.removePopUp(pop_up_widget)) self.showPopUp(pop_up_widget)
--- a/frontends/src/quick_frontend/quick_app.py Fri Jun 24 22:41:28 2016 +0200 +++ b/frontends/src/quick_frontend/quick_app.py Mon Jun 27 21:45:11 2016 +0200 @@ -116,12 +116,12 @@ for sub in waiting_sub: self.host.subscribeHandler(waiting_sub[sub], sub, self.profile) - self.bridge.getRoomsJoined(self.profile, callback=self._plug_profile_gotRoomsJoined) + self.bridge.mucGetRoomsJoined(self.profile, callback=self._plug_profile_gotRoomsJoined) def _plug_profile_gotRoomsJoined(self, rooms_args): #Now we open the MUC window where we already are: for room_args in rooms_args: - self.host.roomJoinedHandler(*room_args, profile=self.profile) + self.host.mucRoomJoinedHandler(*room_args, profile=self.profile) #Presence must be requested after rooms are filled self.host.bridge.getPresenceStatuses(self.profile, callback=self._plug_profile_gotPresences) @@ -254,10 +254,10 @@ self.registerSignal("progressFinished") self.registerSignal("progressError") self.registerSignal("actionResultExt", self.actionResultHandler) - self.registerSignal("roomJoined", iface="plugin") - self.registerSignal("roomLeft", iface="plugin") - self.registerSignal("roomUserChangedNick", iface="plugin") - self.registerSignal("roomNewSubject", iface="plugin") + self.registerSignal("mucRoomJoined", iface="plugin") + self.registerSignal("mucRoomLeft", iface="plugin") + self.registerSignal("mucRoomUserChangedNick", iface="plugin") + self.registerSignal("mucRoomNewSubject", iface="plugin") self.registerSignal("chatStateReceived", iface="plugin") self.registerSignal("psEvent", iface="plugin") @@ -548,7 +548,7 @@ self.callListeners('presence', entity, show, priority, statuses, profile=profile) - def roomJoinedHandler(self, room_jid_s, occupants, user_nick, subject, profile): + def mucRoomJoinedHandler(self, room_jid_s, occupants, user_nick, subject, profile): """Called when a MUC room is joined""" log.debug(u"Room [{room_jid}] joined by {profile}, users presents:{users}".format(room_jid=room_jid_s, profile=profile, users=occupants.keys())) room_jid = jid.JID(room_jid_s) @@ -557,7 +557,7 @@ self.contact_lists[profile].setSpecial(room_jid, C.CONTACT_SPECIAL_GROUP) # chat_widget.update() - def roomLeftHandler(self, room_jid_s, profile): + def mucRoomLeftHandler(self, room_jid_s, profile): """Called when a MUC room is left""" log.debug(u"Room [%(room_jid)s] left by %(profile)s" % {'room_jid': room_jid_s, 'profile': profile}) room_jid = jid.JID(room_jid_s) @@ -566,14 +566,14 @@ self.widgets.deleteWidget(chat_widget) self.contact_lists[profile].removeContact(room_jid) - def roomUserChangedNickHandler(self, room_jid_s, old_nick, new_nick, profile): + def mucRoomUserChangedNickHandler(self, room_jid_s, old_nick, new_nick, profile): """Called when an user joined a MUC room""" room_jid = jid.JID(room_jid_s) chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, room_jid, type_=C.CHAT_GROUP, profile=profile) chat_widget.changeUserNick(old_nick, new_nick) log.debug(u"user [%(old_nick)s] is now known as [%(new_nick)s] in room [%(room_jid)s]" % {'old_nick': old_nick, 'new_nick': new_nick, 'room_jid': room_jid}) - def roomNewSubjectHandler(self, room_jid_s, subject, profile): + def mucRoomNewSubjectHandler(self, room_jid_s, subject, profile): """Called when subject of MUC room change""" room_jid = jid.JID(room_jid_s) chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, room_jid, type_=C.CHAT_GROUP, profile=profile)
--- a/src/core/exceptions.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/core/exceptions.py Mon Jun 27 21:45:11 2016 +0200 @@ -114,3 +114,8 @@ class ParsingError(Exception): pass + + +# Something which need to be done is not available yet +class NotReady(Exception): + pass
--- a/src/memory/memory.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/memory/memory.py Mon Jun 27 21:45:11 2016 +0200 @@ -635,25 +635,25 @@ return available def _getMainResource(self, jid_s, profile_key): + client = self.host.getClient(profile_key) jid_ = jid.JID(jid_s) - return self.getMainResource(jid_, profile_key) or "" + return self.getMainResource(client, jid_) or "" - def getMainResource(self, entity_jid, profile_key): + def getMainResource(self, client, entity_jid): """Return the main resource used by an entity @param entity_jid: bare entity jid - @param profile_key: %(doc_profile_key)s @return (unicode): main resource or None """ if entity_jid.resource: raise ValueError("getMainResource must be used with a bare jid (got {})".format(entity_jid)) try: - if self.host.plugins["XEP-0045"].isRoom(entity_jid, profile_key): + if self.host.plugins["XEP-0045"].isJoinedRoom(client, entity_jid): return None # MUC rooms have no main resource except KeyError: # plugin not found pass try: - resources = self.getAllResources(entity_jid, profile_key) + resources = self.getAllResources(entity_jid, client.profile) except exceptions.UnknownEntityError: log.warning(u"Entity is not in cache, we can't find any resource") return None @@ -662,7 +662,7 @@ full_jid = copy.copy(entity_jid) full_jid.resource = resource try: - presence_data = self.getEntityDatum(full_jid, "presence", profile_key) + presence_data = self.getEntityDatum(full_jid, "presence", client.profile) except KeyError: log.debug(u"No presence information for {}".format(full_jid)) continue
--- a/src/plugins/plugin_exp_parrot.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_exp_parrot.py Mon Jun 27 21:45:11 2016 +0200 @@ -93,7 +93,7 @@ entity_type = "contact" if entity_type == 'chatroom': src_txt = from_jid.resource - if src_txt == self.host.plugins["XEP-0045"].getRoomNick(from_jid.userhostJID(), profile): + if src_txt == self.host.plugins["XEP-0045"].getRoomNick(client, from_jid.userhostJID()): #we won't repeat our own messages return True else:
--- a/src/plugins/plugin_misc_room_game.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_misc_room_game.py Mon Jun 27 21:45:11 2016 +0200 @@ -48,6 +48,8 @@ } +# FIXME: this plugin is broken, need to be fixed + class RoomGame(object): """This class is used to help launching a MUC game. @@ -123,7 +125,7 @@ host.trigger.add("MUC user joined", self.userJoinedTrigger) host.trigger.add("MUC user left", self.userLeftTrigger) - def _createOrInvite(self, room, other_players, profile): + def _createOrInvite(self, room_jid, other_players, profile): """ This is called only when someone explicitly wants to play. @@ -131,22 +133,24 @@ also its creation could be postponed until all the expected players join the room (in that case it will be created from userJoinedTrigger). @param room (wokkel.muc.Room): the room - @param other_players (list[jid.JID]): list of the other players JID (bare) + @param other_players (list[jid.JID]): list of the other players JID (bare) """ + # FIXME: broken ! + raise NotImplementedError("To be fixed") + client = self.host.getClient(profile) user_jid = self.host.getJidNStream(profile)[0] - room_jid = room.occupantJID.userhostJID() - nick = self.host.plugins["XEP-0045"].getRoomNick(room_jid, profile) + nick = self.host.plugins["XEP-0045"].getRoomNick(client, room_jid) nicks = [nick] if self._gameExists(room_jid): if not self._checkJoinAuth(room_jid, user_jid, nick): return - nicks.extend(self._invitePlayers(room, other_players, nick, profile)) + nicks.extend(self._invitePlayers(room_jid, other_players, nick, profile)) self._updatePlayers(room_jid, nicks, True, profile) else: self._initGame(room_jid, nick) - (auth, waiting, missing) = self._checkWaitAuth(room, other_players) + (auth, waiting, missing) = self._checkWaitAuth(room_jid, other_players) nicks.extend(waiting) - nicks.extend(self._invitePlayers(room, missing, nick, profile)) + nicks.extend(self._invitePlayers(room_jid, missing, nick, profile)) if auth: self.createGame(room_jid, nicks, profile) else: @@ -300,15 +304,15 @@ """ return [] - def _invitePlayers(self, room, other_players, nick, profile): + def _invitePlayers(self, room_jid, other_players, nick, profile): """Invite players to a room, associated game may exist or not. - @param room (wokkel.muc.Room): the room @param other_players (list[jid.JID]): list of the players to invite @param nick (unicode): nick of the user who send the invitation @return: list[unicode] of room nicks for invited players who are already in the room """ - room_jid = room.occupantJID.userhostJID() + raise NotImplementedError("Need to be fixed !") + # FIXME: this is broken and unsecure ! if not self._checkInviteAuth(room_jid, nick): return [] # TODO: remove invitation waiting for too long, using the time data @@ -316,7 +320,7 @@ nicks = [] for player_jid in [player.userhostJID() for player in other_players]: # TODO: find a way to make it secure - other_nick = self.host.plugins["XEP-0045"].getRoomNickOfUser(room, player_jid, secure=self.testing) + other_nick = self.host.plugins["XEP-0045"].getRoomEntityNick(room_jid, player_jid, secure=self.testing) if other_nick is None: self.host.plugins["XEP-0249"].invite(player_jid, room_jid, {"game": self.name}, profile) else: @@ -397,8 +401,9 @@ @param profile_key (unicode): %(doc_profile_key)s @return: jid.JID (unique name for a new room to be created) """ + client = self.host.getClient(profile_key) # FIXME: jid.JID must be used instead of strings - room = self.host.plugins["XEP-0045"].getUniqueName(muc_service, profile_key=profile_key) + room = self.host.plugins["XEP-0045"].getUniqueName(client, muc_service) return jid.JID("sat_%s_%s" % (self.name.lower(), room.userhost())) def _prepareRoom(self, other_players=None, room_jid_s='', profile_key=C.PROF_KEY_NONE): @@ -413,6 +418,8 @@ @param room_jid (jid.JID): JID of the room, or None to generate a unique name @param profile_key (unicode): %(doc_profile_key)s """ + # FIXME: need to be refactored + client = self.host.getClient(profile_key) log.debug(_(u'Preparing room for %s game') % self.name) profile = self.host.memory.getProfileName(profile_key) if not profile: @@ -421,21 +428,17 @@ if other_players is None: other_players = [] - def roomJoined(room): - """@param room: instance of wokkel.muc.Room""" - self._createOrInvite(room, other_players, profile) - # Create/join the given room, or a unique generated one if no room is specified. if room_jid is None: room_jid = self.getUniqueName(profile_key=profile_key) else: - if room_jid in self.host.plugins["XEP-0045"].clients[profile].joined_rooms: - roomJoined(self.host.plugins["XEP-0045"].clients[profile].joined_rooms[room_jid]) - return defer.succeed(None) + self.host.plugins["XEP-0045"].checkRoomJoined(client, room_jid) + self._createOrInvite(client, room_jid, other_players) + return defer.succeed(None) user_jid = self.host.getJidNStream(profile)[0] d = self.host.plugins["XEP-0045"].join(room_jid, user_jid.user, {}, profile) - return d.addCallback(roomJoined) + return d.addCallback(lambda dummy: self._createOrInvite(client, room_jid, other_players)) def userJoinedTrigger(self, room, user, profile): """This trigger is used to check if the new user can take part of a game, create the game if we were waiting for him or just update the players list.
--- a/src/plugins/plugin_misc_tarot.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_misc_tarot.py Mon Jun 27 21:45:11 2016 +0200 @@ -477,9 +477,10 @@ """ @param mess_elt: instance of twisted.words.xish.domish.Element """ + client = self.host.getClient(profile) from_jid = jid.JID(mess_elt['from']) room_jid = jid.JID(from_jid.userhost()) - nick = self.host.plugins["XEP-0045"].getRoomNick(room_jid, profile) + nick = self.host.plugins["XEP-0045"].getRoomNick(client, room_jid) game_elt = mess_elt.firstChildElement() game_data = self.games[room_jid] @@ -522,7 +523,7 @@ # TODO: use proper XEP-0004 way for answering form player = elt['player'] players_data[player]['contrat'] = unicode(elt) - contrats = [players_data[player]['contrat'] for player in game_data['players']] + contrats = [players_data[p]['contrat'] for p in game_data['players']] if contrats.count(None): # not everybody has choosed his contrat, it's next one turn player = self.__next_player(game_data)
--- a/src/plugins/plugin_misc_text_commands.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_misc_text_commands.py Mon Jun 27 21:45:11 2016 +0200 @@ -305,7 +305,7 @@ if mess_data['type'] == "groupchat": room = mess_data["to"].userhostJID() try: - if self.host.plugins["XEP-0045"].isNickInRoom(room, entity, client.profile): + if self.host.plugins["XEP-0045"].isNickInRoom(client, room, entity): entity = u"%s/%s" % (room, entity) except KeyError: log.warning("plugin XEP-0045 is not present") @@ -322,7 +322,7 @@ return False if not target_jid.resource: - target_jid.resource = self.host.memory.getMainResource(target_jid, client.profile) + target_jid.resource = self.host.memory.getMainResource(client, target_jid) whois_msg = [_(u"whois for %(jid)s") % {'jid': target_jid}]
--- a/src/plugins/plugin_sec_otr.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_sec_otr.py Mon Jun 27 21:45:11 2016 +0200 @@ -276,10 +276,11 @@ @param menu_data: %(menu_data)s @param profile: %(doc_profile)s """ + client = self.host.getClient(profile) try: to_jid = jid.JID(menu_data['jid']) if not to_jid.resource: - to_jid.resource = self.host.memory.getMainResource(to_jid, profile) # FIXME: temporary and unsecure, must be changed when frontends are refactored + to_jid.resource = self.host.memory.getMainResource(client, to_jid) # FIXME: temporary and unsecure, must be changed when frontends are refactored except KeyError: log.error(_("jid key is not present !")) return defer.fail(exceptions.DataError) @@ -294,10 +295,11 @@ @param menu_data: %(menu_data)s @param profile: %(doc_profile)s """ + client = self.host.getClient(profile) try: to_jid = jid.JID(menu_data['jid']) if not to_jid.resource: - to_jid.resource = self.host.memory.getMainResource(to_jid, profile) # FIXME: temporary and unsecure, must be changed when frontends are refactored + to_jid.resource = self.host.memory.getMainResource(client, to_jid) # FIXME: temporary and unsecure, must be changed when frontends are refactored except KeyError: log.error(_("jid key is not present !")) return defer.fail(exceptions.DataError) @@ -311,10 +313,11 @@ @param menu_data: %(menu_data)s @param profile: %(doc_profile)s """ + client = self.host.getClient(profile) try: to_jid = jid.JID(menu_data['jid']) if not to_jid.resource: - to_jid.resource = self.host.memory.getMainResource(to_jid, profile) # FIXME: temporary and unsecure, must be changed when frontends are refactored + to_jid.resource = self.host.memory.getMainResource(client, to_jid) # FIXME: temporary and unsecure, must be changed when frontends are refactored except KeyError: log.error(_("jid key is not present !")) return defer.fail(exceptions.DataError) @@ -381,10 +384,11 @@ @param menu_data: %(menu_data)s @param profile: %(doc_profile)s """ + client = self.host.getClient(profile) try: to_jid = jid.JID(menu_data['jid']) if not to_jid.resource: - to_jid.resource = self.host.memory.getMainResource(to_jid, profile) # FIXME: temporary and unsecure, must be changed when frontends are refactored + to_jid.resource = self.host.memory.getMainResource(client, to_jid) # FIXME: temporary and unsecure, must be changed when frontends are refactored except KeyError: log.error(_("jid key is not present !")) return defer.fail(exceptions.DataError) @@ -467,7 +471,7 @@ return True to_jid = copy.copy(mess_data['to']) if mess_data['type'] != 'groupchat' and not to_jid.resource: - to_jid.resource = self.host.memory.getMainResource(to_jid, profile) # FIXME: it's dirty, but frontends don't manage resources correctly now, refactoring is planed + to_jid.resource = self.host.memory.getMainResource(client, to_jid) # FIXME: it's dirty, but frontends don't manage resources correctly now, refactoring is planed otrctx = self.context_managers[profile].getContextForUser(to_jid) if mess_data['type'] != 'groupchat' and otrctx.state != potr.context.STATE_PLAINTEXT: if otrctx.state == potr.context.STATE_ENCRYPTED: @@ -496,11 +500,12 @@ return True def _presenceReceivedTrigger(self, entity, show, priority, statuses, profile): + client = self.host.getClient(profile) if show != C.PRESENCE_UNAVAILABLE: return True if not entity.resource: try: - entity.resource = self.host.memory.getMainResource(entity, profile) # FIXME: temporary and unsecure, must be changed when frontends are refactored + entity.resource = self.host.memory.getMainResource(client, entity) # FIXME: temporary and unsecure, must be changed when frontends are refactored except exceptions.UnknownEntityError: return True # entity was not connected if entity in self.context_managers[profile].contexts:
--- a/src/plugins/plugin_xep_0045.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_xep_0045.py Mon Jun 27 21:45:11 2016 +0200 @@ -63,44 +63,32 @@ default_conf = {"default_muc": u'sat@chat.jabberfr.org'} -class UnknownRoom(Exception): - pass - - -class AlreadyJoinedRoom(Exception): - pass - -class NotReadyYet(Exception): - pass - - class XEP_0045(object): - # TODO: this plugin is messy, need a big cleanup/refactoring def __init__(self, host): log.info(_("Plugin XEP_0045 initialization")) self.host = host - self.clients = {} # FIXME: should be moved to profile's client self._sessions = memory.Sessions() host.bridge.addMethod("mucJoin", ".plugin", in_sign='ssa{ss}s', out_sign='s', method=self._join, async=True) - host.bridge.addMethod("mucNick", ".plugin", in_sign='sss', out_sign='', method=self.mucNick) - host.bridge.addMethod("mucLeave", ".plugin", in_sign='ss', out_sign='', method=self.mucLeave, async=True) - host.bridge.addMethod("getRoomsJoined", ".plugin", in_sign='s', out_sign='a(sa{sa{ss}}ss)', method=self.getRoomsJoined) - host.bridge.addMethod("getRoomsSubjects", ".plugin", in_sign='s', out_sign='a(ss)', method=self.getRoomsSubjects) - host.bridge.addMethod("getUniqueRoomName", ".plugin", in_sign='ss', out_sign='s', method=self._getUniqueName) - host.bridge.addMethod("configureRoom", ".plugin", in_sign='ss', out_sign='s', method=self._configureRoom, async=True) - host.bridge.addMethod("getDefaultMUC", ".plugin", in_sign='', out_sign='s', method=self.getDefaultMUC) - host.bridge.addSignal("roomJoined", ".plugin", signature='sa{sa{ss}}sss') # args: room_jid, occupants, user_nick, subject, profile - host.bridge.addSignal("roomLeft", ".plugin", signature='ss') # args: room_jid, profile - host.bridge.addSignal("roomUserChangedNick", ".plugin", signature='ssss') # args: room_jid, old_nick, new_nick, profile - host.bridge.addSignal("roomNewSubject", ".plugin", signature='sss') # args: room_jid, subject, profile + host.bridge.addMethod("mucNick", ".plugin", in_sign='sss', out_sign='', method=self._nick) + host.bridge.addMethod("mucLeave", ".plugin", in_sign='ss', out_sign='', method=self._leave, async=True) + host.bridge.addMethod("mucGetRoomsJoined", ".plugin", in_sign='s', out_sign='a(sa{sa{ss}}ss)', method=self._getRoomsJoined) + host.bridge.addMethod("mucGetUniqueRoomName", ".plugin", in_sign='ss', out_sign='s', method=self._getUniqueName) + host.bridge.addMethod("mucConfigureRoom", ".plugin", in_sign='ss', out_sign='s', method=self._configureRoom, async=True) + host.bridge.addMethod("mucGetDefaultService", ".plugin", in_sign='', out_sign='s', method=self.getDefaultMUC) + host.bridge.addSignal("mucRoomJoined", ".plugin", signature='sa{sa{ss}}sss') # args: room_jid, occupants, user_nick, subject, profile + host.bridge.addSignal("mucRoomLeft", ".plugin", signature='ss') # args: room_jid, profile + host.bridge.addSignal("mucRoomUserChangedNick", ".plugin", signature='ssss') # args: room_jid, old_nick, new_nick, profile + host.bridge.addSignal("mucRoomNewSubject", ".plugin", signature='sss') # args: room_jid, subject, profile self.__submit_conf_id = host.registerCallback(self._submitConfiguration, with_data=True) host.importMenu((D_("MUC"), D_("configure")), self._configureRoomMenu, security_limit=0, help_string=D_("Configure Multi-User Chat room"), type_=C.MENU_ROOM) try: - self.host.plugins[C.TEXT_CMDS].registerTextCommands(self) - self.host.plugins[C.TEXT_CMDS].addWhoIsCb(self._whois, 100) + txt_cmds = self.host.plugins[C.TEXT_CMDS] except KeyError: - log.info(_("Text commands not available")) + log.info(_(u"Text commands not available")) + else: + txt_cmds.registerTextCommands(self) + txt_cmds.addWhoIsCb(self._whois, 100) host.trigger.add("presence_available", self.presenceTrigger) host.trigger.add("MessageReceived", self.MessageReceivedTrigger, priority=1000000) @@ -117,8 +105,8 @@ return False from_jid = jid.JID(message_elt['from']) room_jid = from_jid.userhostJID() - if room_jid in self.clients[client.profile].joined_rooms: - room = self.clients[client.profile].joined_rooms[room_jid] + if room_jid in client._muc_client.joined_rooms: + room = client._muc_client.joined_rooms[room_jid] if not room._room_ok: log.warning(u"Received non delayed message in a room before its initialisation: {}".format(message_elt.toXml())) room._cache.append(message_elt) @@ -128,137 +116,129 @@ return False return True - def checkClient(self, profile): - """Check if the profile is connected and has used the MUC feature. - - If profile was using MUC feature but is now disconnected, remove it from the client list. - @param profile: profile to check - @return: True if the profile is connected and has used the MUC feature, else False""" - if not profile or profile not in self.clients or not self.host.isConnected(profile): - log.error(_(u'Unknown or disconnected profile (%s)') % profile) - if profile in self.clients: - del self.clients[profile] - return False - return True - - def getProfileAssertInRoom(self, room_jid, profile_key): - """Retrieve the profile name, assert that it's connected and participating in the given room. + def checkRoomJoined(self, client, room_jid): + """Check that given room has been joined in current session @param room_jid (JID): room JID - @param profile_key (str): %(doc_profile_key) - @return: the profile name + """ + if room_jid not in client._muc_client.joined_rooms: + raise exceptions.NotFound(_(u"This room has not been joined")) + + def isJoinedRoom(self, client, room_jid): + """Tell if a jid is a known and joined room + + @room_jid(jid.JID): jid of the room """ - profile = self.host.memory.getProfileName(profile_key) - if not self.checkClient(profile): - raise exceptions.ProfileUnknownError("Unknown or disconnected profile") - if room_jid not in self.clients[profile].joined_rooms: - raise UnknownRoom("This room has not been joined") - return profile + try: + self.checkRoomJoined(client, room_jid) + except exceptions.NotFound: + return False + else: + return True - def _joinCb(self, room, profile): + def _joinCb(self, room, client): """Called when the user is in the requested room""" if room.locked: # FIXME: the current behaviour is to create an instant room # and send the signal only when the room is unlocked # a proper configuration management should be done - print "room locked !" - d = self.clients[profile].configure(room.roomJID, {}) + log.debug(_(u"room locked !")) + d = client._muc_client.configure(room.roomJID, {}) d.addErrback(lambda dummy: log.error(_(u'Error while configuring the room'))) return room - def _joinEb(self, failure, room_jid, nick, password, profile): + def _joinEb(self, failure, client, room_jid, nick, password): """Called when something is going wrong when joining the room""" - if hasattr(failure.value, "condition") and failure.value.condition == 'conflict': - # we have a nickname conflict, we try again with "_" suffixed to current nickname - nick += '_' - return self.clients[profile].join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, callbackKeywords={'profile': profile}, errbackArgs=[room_jid, nick, password, profile]) - mess = D_("Error while joining the room %s" % room_jid.userhost()) try: - mess += " with condition '%s'" % failure.value.condition + condition = failure.value.condition except AttributeError: - pass + msg_suffix = '' + else: + if condition == 'conflict': + # we have a nickname conflict, we try again with "_" suffixed to current nickname + nick += '_' + return client.join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, callbackKeywords={client: client}, errbackArgs=[client, room_jid, nick, password]) + msg_suffix = ' with condition "{}"'.format(failure.value.condition) + + mess = D_(u"Error while joining the room {room}{suffix}".format( + room = room_jid.userhost(), suffix = msg_suffix)) log.error(mess) - self.host.bridge.newAlert(mess, D_("Group chat error"), "ERROR", profile) - raise failure + xmlui = xml_tools.note(mess, D_(u"Group chat error"), level=C.XMLUI_DATA_LVL_ERROR) + self.host.actionNew({'xmlui': xmlui.toXml()}, profile=client.profile) @staticmethod def _getOccupants(room): """Get occupants of a room in a form suitable for bridge""" return {u.nick: {k:unicode(getattr(u,k) or '') for k in OCCUPANT_KEYS} for u in room.roster.values()} - def isRoom(self, entity_bare, profile_key): - """Tell if a bare entity is a MUC room. + def _getRoomsJoined(self, profile_key=C.PROF_KEY_NONE): + client = self.host.getClient(profile_key) + return self.getRoomsJoined(client) - @param entity_bare (jid.JID): bare entity - @param profile_key (unicode): %(doc_profile_key)s - @return bool - """ - profile = self.host.memory.getProfileName(profile_key) - return entity_bare in self.clients[profile].joined_rooms - - def getRoomsJoined(self, profile_key=C.PROF_KEY_NONE): - """Return room where user is""" - profile = self.host.memory.getProfileName(profile_key) + def getRoomsJoined(self, client): + """Return rooms where user is""" result = [] - if not self.checkClient(profile): - return result - for room in self.clients[profile].joined_rooms.values(): + for room in client._muc_client.joined_rooms.values(): if room._room_ok: result.append((room.roomJID.userhost(), self._getOccupants(room), room.nick, room.subject)) return result - def getRoomNick(self, room_jid, profile_key=C.PROF_KEY_NONE): + def getRoomNick(self, client, room_jid): """return nick used in room by user @param room_jid (jid.JID): JID of the room @profile_key: profile - @return: nick or empty string in case of error""" - profile = self.host.memory.getProfileName(profile_key) - if not self.checkClient(profile) or room_jid not in self.clients[profile].joined_rooms: - return '' - return self.clients[profile].joined_rooms[room_jid].nick - - def getRoomNickOfUser(self, room, user_jid, secure=True): - """Returns the nick of the given user in the room. - - @param room (wokkel.muc.Room): the room - @param user (jid.JID): bare JID of the user - @param secure (bool): set to True for a secure check - @return: unicode or None if the user didn't join the room. + @return: nick or empty string in case of error """ - for user in room.roster.values(): - if user.entity is not None: - if user.entity.userhostJID() == user_jid.userhostJID(): - return user.nick - elif not secure: - # FIXME: this is NOT ENOUGH to check an identity!! - # See in which conditions user.entity could be None. - if user.nick == user_jid.user: - return user.nick - return None + try: + self.checkRoomJoined(client, room_jid) + except exceptions.NotFound: + return '' # FIXME: should not return empty string but raise the error + return client._muc_client.joined_rooms[room_jid].nick - def getRoomNicksOfUsers(self, room, users=[], secure=True): - """Returns the nicks of the given users in the room. + # FIXME: broken, to be removed ! + # def getRoomEntityNick(self, client, room_jid, entity_jid, =True): + # """Returns the nick of the given user in the room. - @param room (wokkel.muc.Room): the room - @param users (list[jid.JID]): list of users - @param secure (True): set to True for a secure check - @return: a couple (x, y) with: - - x (list[unicode]): nicks of the users who are in the room - - y (list[jid.JID]): JID of the missing users. - """ - nicks = [] - missing = [] - for user in users: - nick = self.getRoomNickOfUser(room, user, secure) - if nick is None: - missing.append(user) - else: - nicks.append(nick) - return nicks, missing + # @param room (wokkel.muc.Room): the room + # @param user (jid.JID): bare JID of the user + # @param secure (bool): set to True for a secure check + # @return: unicode or None if the user didn't join the room. + # """ + # for user in room.roster.values(): + # if user.entity is not None: + # if user.entity.userhostJID() == user_jid.userhostJID(): + # return user.nick + # elif not secure: + # # FIXME: this is NOT ENOUGH to check an identity!! + # # See in which conditions user.entity could be None. + # if user.nick == user_jid.user: + # return user.nick + # return None + + # def getRoomNicksOfUsers(self, room, users=[], secure=True): + # """Returns the nicks of the given users in the room. + + # @param room (wokkel.muc.Room): the room + # @param users (list[jid.JID]): list of users + # @param secure (True): set to True for a secure check + # @return: a couple (x, y) with: + # - x (list[unicode]): nicks of the users who are in the room + # - y (list[jid.JID]): JID of the missing users. + # """ + # nicks = [] + # missing = [] + # for user in users: + # nick = self.getRoomNickOfUser(room, user, secure) + # if nick is None: + # missing.append(user) + # else: + # nicks.append(nick) + # return nicks, missing def _configureRoom(self, room_jid_s, profile_key=C.PROF_KEY_NONE): - d = self.configureRoom(jid.JID(room_jid_s), profile_key) + client = self.host.getClient(profile_key) + d = self.configureRoom(client, jid.JID(room_jid_s)) d.addCallback(lambda xmlui: xmlui.toXml()) return d @@ -268,6 +248,7 @@ @param menu_data: %(menu_data)s @param profile: %(doc_profile)s """ + client = self.host.getClient(profile) try: room_jid = jid.JID(menu_data['room_jid']) except KeyError: @@ -276,31 +257,31 @@ def xmluiReceived(xmlui): return {"xmlui": xmlui.toXml()} - return self.configureRoom(room_jid, profile).addCallback(xmluiReceived) + return self.configureRoom(client, room_jid).addCallback(xmluiReceived) - def configureRoom(self, room_jid, profile_key=C.PROF_KEY_NONE): + def configureRoom(self, client, room_jid): """return the room configuration form @param room: jid of the room to configure - @param profile_key: %(doc_profile_key)s @return: configuration form as XMLUI """ - profile = self.getProfileAssertInRoom(room_jid, profile_key) + self.checkRoomJoined(client, room_jid) def config2XMLUI(result): if not result: return "" - session_id, session_data = self._sessions.newSession(profile=profile) + session_id, session_data = self._sessions.newSession(profile=client.profile) session_data["room_jid"] = room_jid xmlui = xml_tools.dataForm2XMLUI(result, submit_id=self.__submit_conf_id) xmlui.session_id = session_id return xmlui - d = self.clients[profile].getConfiguration(room_jid) + d = client._muc_client.getConfiguration(room_jid) d.addCallback(config2XMLUI) return d def _submitConfiguration(self, raw_data, profile): + client = self.host.getClient(profile) try: session_data = self._sessions.profileGet(raw_data["session_id"], profile) except KeyError: @@ -310,25 +291,17 @@ return defer.succeed({'xmlui': _dialog.toXml()}) data = xml_tools.XMLUIResult2DataFormResult(raw_data) - d = self.clients[profile].configure(session_data['room_jid'], data) + d = client._muc_client.configure(session_data['room_jid'], data) _dialog = xml_tools.XMLUI('popup', title=D_('Room configuration succeed')) _dialog.addText(D_("The new settings have been saved.")) d.addCallback(lambda ignore: {'xmlui': _dialog.toXml()}) del self._sessions[raw_data["session_id"]] return d - def isNickInRoom(self, room_jid, nick, profile): + def isNickInRoom(self, client, room_jid, nick): """Tell if a nick is currently present in a room""" - profile = self.getProfileAssertInRoom(room_jid, profile) - return self.clients[profile].joined_rooms[room_jid].inRoster(muc.User(nick)) - - def getRoomsSubjects(self, profile_key=C.PROF_KEY_NONE): - """Return received subjects of rooms""" - # FIXME: to be removed - profile = self.host.memory.getProfileName(profile_key) - if not self.checkClient(profile): - return [] - return self.clients[profile].rec_subjects.values() + self.checkRoomJoined(client, room_jid) + return client._muc_client.joined_rooms[room_jid].inRoster(muc.User(nick)) @defer.inlineCallbacks def getMUCService(self, jid_=None, profile=C.PROF_KEY_NONE): @@ -349,28 +322,28 @@ defer.returnValue(muc_service) def _getUniqueName(self, muc_service="", profile_key=C.PROF_KEY_NONE): - return self.getUniqueName(muc_service or None, profile_key).full() + client = self.host.getClient(profile_key) + return self.getUniqueName(client, muc_service or None).full() - def getUniqueName(self, muc_service=None, profile_key=C.PROF_KEY_NONE): + def getUniqueName(self, client, muc_service=None): """Return unique name for a room, avoiding collision @param muc_service (jid.JID) : leave empty string to use the default service @return: jid.JID (unique room bare JID) """ # TODO: we should use #RFC-0045 10.1.4 when available here - client = self.host.getClient(profile_key) - room_name = uuid.uuid1() + room_name = unicode(uuid.uuid4()) if muc_service is None: try: muc_service = client.muc_service except AttributeError: - raise NotReadyYet("Main server MUC service has not been checked yet") + raise exceptions.NotReady(u"Main server MUC service has not been checked yet") if muc_service is None: log.warning(_("No MUC service found on main server")) raise exceptions.FeatureNotFound muc_service = muc_service.userhost() - return jid.JID("%s@%s" % (room_name, muc_service)) + return jid.JID(u"{}@{}".format(room_name, muc_service)) def getDefaultMUC(self): """Return the default MUC. @@ -380,19 +353,19 @@ return self.host.memory.getConfig(CONFIG_SECTION, 'default_muc', default_conf['default_muc']) def join(self, client, room_jid, nick, options): - def _errDeferred(exc_obj=Exception, txt='Error while joining room'): + def _errDeferred(exc_obj=Exception, txt=u'Error while joining room'): d = defer.Deferred() d.errback(exc_obj(txt)) return d - if room_jid in self.clients[client.profile].joined_rooms: - log.warning(_(u'%(profile)s is already in room %(room_jid)s') % {'profile': client.profile, 'room_jid': room_jid.userhost()}) - return _errDeferred(AlreadyJoinedRoom, D_(u"The room has already been joined")) - log.info(_(u"[%(profile)s] is joining room %(room)s with nick %(nick)s") % {'profile': client.profile, 'room': room_jid.userhost(), 'nick': nick}) + if room_jid in client._muc_client.joined_rooms: + log.warning(_(u'{profile} is already in room {room_jid}').format(profile=client.profile, room_jid = room_jid.userhost())) + return defer.fail(exceptions.ConflictError(_(u"The room has already been joined"))) + log.info(_(u"[{profile}] is joining room {room} with nick {nick}").format(profile=client.profile, room=room_jid.userhost(), nick=nick)) password = options["password"] if "password" in options else None - return self.clients[client.profile].join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, callbackKeywords={'profile': client.profile}, errbackArgs=[room_jid, nick, password, client.profile]) + return client._muc_client.join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, callbackKeywords={'client': client}, errbackArgs=[client, room_jid, nick, password]) def _join(self, room_jid_s, nick, options=None, profile_key=C.PROF_KEY_NONE): """join method used by bridge @@ -416,74 +389,72 @@ d = self.join(client, room_jid, nick, options) return d.addCallback(lambda room: room.roomJID.userhost()) - def nick(self, room_jid, nick, profile_key): - profile = self.getProfileAssertInRoom(room_jid, profile_key) - return self.clients[profile].nick(room_jid, nick) + def _nick(self, room_jid_s, nick, profile_key=C.PROF_KEY_NONE): + client = self.host.getClient(profile_key) + return self.nick(client, jid.JID(room_jid_s), nick) - def leave(self, room_jid, profile_key): - profile = self.getProfileAssertInRoom(room_jid, profile_key) - return self.clients[profile].leave(room_jid) + def nick(self, client, room_jid, nick): + """Change nickname in a room""" + self.checkRoomJoined(client, room_jid) + return client._muc_client.nick(room_jid, nick) - def subject(self, room_jid, subject, profile_key): - profile = self.getProfileAssertInRoom(room_jid, profile_key) - return self.clients[profile].subject(room_jid, subject) + def _leave(self, room_jid, profile_key): + client = self.host.getClient(profile_key) + return self.leave(client, jid.JID(room_jid)) - def mucNick(self, room_jid_s, nick, profile_key=C.PROF_KEY_NONE): - """Change nickname in a room""" - return self.nick(jid.JID(room_jid_s), nick, profile_key) + def leave(self, client, room_jid): + self.checkRoomJoined(client, room_jid) + return client._muc_client.leave(room_jid) - def mucLeave(self, room_jid_s, profile_key=C.PROF_KEY_NONE): - """Leave a room""" - return self.leave(jid.JID(room_jid_s), profile_key) + def subject(self, client, room_jid, subject): + self.checkRoomJoined(client, room_jid) + return client._muc_client.subject(room_jid, subject) def getHandler(self, profile): - self.clients[profile] = SatMUCClient(self) - return self.clients[profile] + # create a MUC client and associate it with profile' session + client = self.host.getClient(profile) + muc_client = client._muc_client = SatMUCClient(self) + return muc_client - def profileDisconnected(self, profile): - try: - del self.clients[profile] - except KeyError: - pass - - def kick(self, nick, room_jid, options={}, profile_key=C.PROF_KEY_NONE): + def kick(self, client, nick, room_jid, options=None): """ Kick a participant from the room @param nick (str): nick of the user to kick @param room_jid_s (JID): jid of the room @param options (dict): attribute with extra info (reason, password) as in #XEP-0045 - @param profile_key (str): %(doc_profile_key)s """ - profile = self.getProfileAssertInRoom(room_jid, profile_key) - return self.clients[profile].kick(room_jid, nick, reason=options.get('reason', None)) + if options is None: + options = {} + self.checkRoomJoined(client, room_jid) + return client._muc_client.kick(room_jid, nick, reason=options.get('reason', None)) - def ban(self, entity_jid, room_jid, options={}, profile_key=C.PROF_KEY_NONE): - """ - Ban an entity from the room + def ban(self, client, entity_jid, room_jid, options=None): + """Ban an entity from the room + @param entity_jid (JID): bare jid of the entity to be banned - @param room_jid_s (JID): jid of the room + @param room_jid (JID): jid of the room @param options: attribute with extra info (reason, password) as in #XEP-0045 - @param profile_key (str): %(doc_profile_key)s """ - assert(not entity_jid.resource) - assert(not room_jid.resource) - profile = self.getProfileAssertInRoom(room_jid, profile_key) - return self.clients[profile].ban(room_jid, entity_jid, reason=options.get('reason', None)) + self.checkRoomJoined(client, room_jid) + if options is None: + options = {} + assert not entity_jid.resource + assert not room_jid.resource + return client._muc_client.ban(room_jid, entity_jid, reason=options.get('reason', None)) - def affiliate(self, entity_jid, room_jid, options=None, profile_key=C.PROF_KEY_NONE): - """ - Change the affiliation of an entity + def affiliate(self, client, entity_jid, room_jid, options): + """Change the affiliation of an entity + @param entity_jid (JID): bare jid of the entity @param room_jid_s (JID): jid of the room @param options: attribute with extra info (reason, nick) as in #XEP-0045 - @param profile_key (str): %(doc_profile_key)s """ - assert(not entity_jid.resource) - assert(not room_jid.resource) - assert('affiliation' in options) - profile = self.getProfileAssertInRoom(room_jid, profile_key) + self.checkRoomJoined(client, room_jid) + assert not entity_jid.resource + assert not room_jid.resource + assert 'affiliation' in options # TODO: handles reason and nick - return self.clients[profile].modifyAffiliationList(room_jid, [entity_jid], options['affiliation']) + return client._muc_client.modifyAffiliationList(room_jid, [entity_jid], options['affiliation']) # Text commands # @@ -508,7 +479,7 @@ """ if mess_data["unparsed"].strip(): room_jid = self.host.plugins[C.TEXT_CMDS].getRoomJID(mess_data["unparsed"].strip(), mess_data["to"].host) - nick = (self.getRoomNick(room_jid, client.profile) or + nick = (self.getRoomNick(client, room_jid) or self.host.getClient(client.profile).jid.user) self.join(client, room_jid, nick, {}) @@ -546,7 +517,7 @@ options = mess_data["unparsed"].strip().split() try: nick = options[0] - assert(self.isNickInRoom(mess_data["to"], nick, client.profile)) + assert self.isNickInRoom(client, mess_data["to"], nick) except (IndexError, AssertionError): feedback = _(u"You must provide a member's nick to kick.") self.host.plugins[C.TEXT_CMDS].feedBack(client, feedback, mess_data) @@ -639,7 +610,7 @@ if subject: room = mess_data["to"] - self.subject(room, subject, client.profile) + self.subject(client, room, subject) return False @@ -655,12 +626,12 @@ """ Add MUC user information to whois """ if mess_data['type'] != "groupchat": return - if target_jid.userhostJID() not in self.clients[client.profile].joined_rooms: + if target_jid.userhostJID() not in client._muc_client.joined_rooms: log.warning(_("This room has not been joined")) return if not target_jid.resource: return - user = self.clients[client.profile].joined_rooms[target_jid.userhostJID()].getUser(target_jid.resource) + user = client._muc_client.joined_rooms[target_jid.userhostJID()].getUser(target_jid.resource) whois_msg.append(_("Nickname: %s") % user.nick) if user.entity: whois_msg.append(_("Entity: %s") % user.entity) @@ -675,7 +646,7 @@ def presenceTrigger(self, presence_elt, client): # XXX: shouldn't it be done by the server ?!! - muc_client = self.clients[client.profile] + muc_client = client._muc_client for room_jid, room in muc_client.joined_rooms.iteritems(): elt = copy.deepcopy(presence_elt) elt['to'] = room_jid.userhost() + '/' + room.nick @@ -683,7 +654,7 @@ return True -class SatMUCClient (muc.MUCClient): +class SatMUCClient(muc.MUCClient): implements(iwokkel.IDisco) def __init__(self, plugin_parent): @@ -823,7 +794,7 @@ log.info(_(u"Room ({room}) left ({profile})").format( room = room_jid_s, profile = self.parent.profile)) self.host.memory.delEntityCache(room.roomJID, profile_key=self.parent.profile) - self.host.bridge.roomLeft(room.roomJID.userhost(), self.parent.profile) + self.host.bridge.mucRoomLeft(room.roomJID.userhost(), self.parent.profile) else: log.debug(_(u"user {nick} left room {room_id}").format(nick=user.nick, room_id=room.occupantJID.userhost())) extra = {'info_type': ROOM_USER_LEFT, @@ -847,7 +818,7 @@ self.host.messageSendToBridge(mess_data, self.parent) def userChangedNick(self, room, user, new_nick): - self.host.bridge.roomUserChangedNick(room.roomJID.userhost(), user.nick, new_nick, self.parent.profile) + self.host.bridge.mucRoomUserChangedNick(room.roomJID.userhost(), user.nick, new_nick, self.parent.profile) def userUpdatedStatus(self, room, user, show, status): self.host.bridge.presenceUpdate(room.roomJID.userhost() + '/' + user.nick, show or '', 0, {C.PRESENCE_STATUSES_DEFAULT: status or ''}, self.parent.profile) @@ -923,7 +894,7 @@ return muc.MUCClientProtocol.subject(self, room, subject) def _historyCb(self, dummy, room): - self.host.bridge.roomJoined( + self.host.bridge.mucRoomJoined( room.roomJID.userhost(), XEP_0045._getOccupants(room), room.nick, @@ -954,7 +925,7 @@ else: # the subject has been changed log.debug(_(u"New subject for room ({room_id}): {subject}").format(room_id = room.roomJID.full(), subject = subject)) - self.host.bridge.roomNewSubject(room.roomJID.userhost(), subject, self.parent.profile) + self.host.bridge.mucRoomNewSubject(room.roomJID.userhost(), subject, self.parent.profile) ## disco ##
--- a/src/plugins/plugin_xep_0054.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_xep_0054.py Mon Jun 27 21:45:11 2016 +0200 @@ -109,16 +109,18 @@ return True - def isInRoom(self, entity_jid, profile): + def isInRoom(self, client, entity_jid): """Tell if an full jid is a member of a room @param entity_jid(jid.JID): full jid of the entity @return (bool): True if the bare jid of the entity is a room jid """ try: - return self.host.plugins['XEP-0045'].isRoom(entity_jid.userhostJID(), profile_key=profile) - except KeyError: + self.host.plugins['XEP-0045'].checkRoomJoined(client, entity_jid.userhostJID()) + except exceptions.NotFound: return False + else: + return True def _fillCachedValues(self, profile): #FIXME: this is really suboptimal, need to be reworked @@ -143,41 +145,39 @@ log.debug(u"Deleting profile cache for avatars") del self.cache[profile] - def updateCache(self, jid_, name, value, profile): + def updateCache(self, client, jid_, name, value): """update cache value save value in memory in case of change @param jid_(jid.JID): jid of the owner of the vcard @param name(str): name of the item which changed @param value(unicode): new value of the item - @param profile(unicode): profile which received the update """ if jid_.resource: - if not self.isInRoom(jid_, profile): + if not self.isInRoom(client, jid_): # VCard are retrieved with bare jid # but MUC room is a special case jid_ = jid.userhostJID() - self.host.memory.updateEntityData(jid_, name, value, profile_key=profile) + self.host.memory.updateEntityData(jid_, name, value, profile_key=client.profile) if name in CACHED_DATA: jid_s = jid_.userhost() - self.cache[profile].setdefault(jid_s, {})[name] = value - self.cache[profile].force(jid_s) + self.cache[client.profile].setdefault(jid_s, {})[name] = value + self.cache[client.profile].force(jid_s) - def getCache(self, entity_jid, name, profile): + def getCache(self, client, entity_jid, name): """return cached value for jid @param entity_jid: target contact @param name: name of the value ('nick' or 'avatar') - @param profile: %(doc_profile)s @return: wanted value or None""" if entity_jid.resource: - if not self.isInRoom(entity_jid, profile): + if not self.isInRoom(client, entity_jid): # VCard are retrieved with bare jid # but MUC room is a special case entity_jid = jid.userhostJID() try: - data = self.host.memory.getEntityData(entity_jid, [name], profile) + data = self.host.memory.getEntityData(entity_jid, [name], client.profile) except exceptions.UnknownEntityError: return None return data.get(name) @@ -217,7 +217,7 @@ return image_hash @defer.inlineCallbacks - def vCard2Dict(self, vcard, target, profile): + def vCard2Dict(self, client, vcard, target): """Convert a VCard to a dict, and save binaries""" log.debug(_("parsing vcard")) dictionary = {} @@ -227,7 +227,7 @@ dictionary['fullname'] = unicode(elem) elif elem.name == 'NICKNAME': dictionary['nick'] = unicode(elem) - self.updateCache(target, 'nick', dictionary['nick'], profile) + self.updateCache(client, target, 'nick', dictionary['nick']) elif elem.name == 'URL': dictionary['website'] = unicode(elem) elif elem.name == 'EMAIL': @@ -239,7 +239,7 @@ if not dictionary["avatar"]: # can happen in case of e.g. empty photo elem del dictionary['avatar'] else: - self.updateCache(target, 'avatar', dictionary['avatar'], profile) + self.updateCache(client, target, 'avatar', dictionary['avatar']) else: log.info(_('FIXME: [%s] VCard tag is not managed yet') % elem.name) @@ -248,56 +248,52 @@ # and we reset them for datum in CACHED_DATA.difference(dictionary.keys()): log.debug(u"reseting vcard datum [{datum}] for {entity}".format(datum=datum, entity=target.full())) - self.updateCache(target, datum, '', profile) + self.updateCache(client, target, datum, '') defer.returnValue(dictionary) - def _VCardCb(self, answer, profile): + def _VCardCb(self, answer, client): """Called after the first get IQ""" log.debug(_("VCard found")) if answer.firstChildElement().name == "vCard": - _jid, steam = self.host.getJidNStream(profile) try: from_jid = jid.JID(answer["from"]) except KeyError: - from_jid = _jid.userhostJID() - d = self.vCard2Dict(answer.firstChildElement(), from_jid, profile) - d.addCallback(lambda data: self.host.bridge.actionResult("RESULT", answer['id'], data, profile)) + from_jid = client.jid.userhostJID() + d = self.vCard2Dict(client, answer.firstChildElement(), from_jid) + d.addCallback(lambda data: self.host.bridge.actionResult("RESULT", answer['id'], data, client.profile)) else: log.error(_("FIXME: vCard not found as first child element")) - self.host.bridge.actionResult("SUPPRESS", answer['id'], {}, profile) # FIXME: maybe an error message would be better + self.host.bridge.actionResult("SUPPRESS", answer['id'], {}, client.profile) # FIXME: maybe an error message would be better - def _VCardEb(self, failure, profile): + def _VCardEb(self, failure, client): """Called when something is wrong with registration""" try: - self.host.bridge.actionResult("SUPPRESS", failure.value.stanza['id'], {}, profile) # FIXME: maybe an error message would be better + self.host.bridge.actionResult("SUPPRESS", failure.value.stanza['id'], {}, client.profile) # FIXME: maybe an error message would be better log.warning(_(u"Can't find VCard of %s") % failure.value.stanza['from']) - self.updateCache(jid.JID(failure.value.stanza['from']), "avatar", '', profile) + self.updateCache(client, jid.JID(failure.value.stanza['from']), "avatar", '') except (AttributeError, KeyError): # 'ConnectionLost' object has no attribute 'stanza' + sometimes 'from' key doesn't exist log.warning(_(u"Can't find VCard: %s") % failure.getErrorMessage()) def _getCard(self, target_s, profile_key=C.PROF_KEY_NONE): - return self.getCard(jid.JID(target_s), profile_key) + client = self.host.getClient(profile_key) + return self.getCard(client, jid.JID(target_s)) - def getCard(self, target, profile_key=C.PROF_KEY_NONE): + def getCard(self, client, target): """Ask server for VCard @param target(jid.JID): jid from which we want the VCard @result: id to retrieve the profile """ - current_jid, xmlstream = self.host.getJidNStream(profile_key) - if not xmlstream: - raise exceptions.ProfileUnknownError('Asking vcard for a non-existant or not connected profile ({})'.format(profile_key)) - profile = self.host.memory.getProfileName(profile_key) to_jid = target.userhostJID() log.debug(_(u"Asking for %s's VCard") % to_jid.userhost()) - reg_request = IQ(xmlstream, 'get') - reg_request["from"] = current_jid.full() + reg_request = client.IQ('get') + reg_request["from"] = client.jid.full() reg_request["to"] = to_jid.userhost() reg_request.addElement('vCard', NS_VCARD) - reg_request.send(to_jid.userhost()).addCallbacks(self._VCardCb, self._VCardEb, callbackArgs=[profile], errbackArgs=[profile]) + reg_request.send(to_jid.userhost()).addCallbacks(self._VCardCb, self._VCardEb, callbackArgs=[client], errbackArgs=[client]) return reg_request["id"] def getAvatarFile(self, avatar_hash): @@ -354,7 +350,7 @@ def elementBuilt(result): """Called once the image is at the right size/format, and the vcard set element is build""" set_avatar_elt, img_hash = result - self.updateCache(client.jid.userhostJID(), 'avatar', img_hash, client.profile) + self.updateCache(client, client.jid.userhostJID(), 'avatar', img_hash) return set_avatar_elt.send().addCallback(lambda ignore: client.presence.available()) # FIXME: should send the current presence, not always "available" ! d.addCallback(elementBuilt) @@ -385,7 +381,7 @@ @param presend(domish.Element): <presence/> stanza """ from_jid = jid.JID(presence['from']) - if from_jid.resource and not self.plugin_parent.isInRoom(from_jid, self.parent.profile): + if from_jid.resource and not self.plugin_parent.isInRoom(self.parent, from_jid): from_jid = from_jid.userhostJID() #FIXME: wokkel's data_form should be used here try: @@ -401,12 +397,12 @@ hash_ = str(photo_elt) if not hash_: return - old_avatar = self.plugin_parent.getCache(from_jid, 'avatar', self.parent.profile) + old_avatar = self.plugin_parent.getCache(self.parent, from_jid, 'avatar') filename = self.plugin_parent._getFilename(hash_) if not old_avatar or old_avatar != hash_: if os.path.exists(filename): log.debug(u"New avatar found for [{}], it's already in cache, we use it".format(from_jid.full())) - self.plugin_parent.updateCache(from_jid, 'avatar', hash_, self.parent.profile) + self.plugin_parent.updateCache(self.parent, from_jid, 'avatar', hash_) else: log.debug(u'New avatar found for [{}], requesting vcard'.format(from_jid.full())) self.plugin_parent.getCard(from_jid, self.parent.profile)
--- a/src/plugins/plugin_xep_0085.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_xep_0085.py Mon Jun 27 21:45:11 2016 +0200 @@ -309,18 +309,16 @@ @param profile_key (str): %(doc_profile_key)s """ # TODO: try to optimize this method which is called often - profile = self.host.memory.getProfileName(profile_key) - if profile is None: - raise exceptions.ProfileUnknownError + client = self.host.getClient(profile_key) to_jid = JID(to_jid_s) - if self._isMUC(to_jid, profile): + if self._isMUC(to_jid, client.profile): to_jid = to_jid.userhostJID() elif not to_jid.resource: - to_jid.resource = self.host.memory.getMainResource(to_jid, profile) - if not self._checkActivation(to_jid, forceEntityData=False, profile=profile): + to_jid.resource = self.host.memory.getMainResource(client, to_jid) + if not self._checkActivation(to_jid, forceEntityData=False, profile=client.profile): return try: - self.map[profile][to_jid]._onEvent("composing") + self.map[client.profile][to_jid]._onEvent("composing") except (KeyError, AttributeError): # no message has been sent/received since the notifications # have been enabled, it's better to wait for a first one
--- a/src/plugins/plugin_xep_0249.py Fri Jun 24 22:41:28 2016 +0200 +++ b/src/plugins/plugin_xep_0249.py Mon Jun 27 21:45:11 2016 +0200 @@ -19,6 +19,7 @@ from sat.core.i18n import _ from sat.core.constants import Const as C +from sat.core import exceptions from sat.core.log import getLogger log = getLogger(__name__) from twisted.words.xish import domish @@ -136,6 +137,7 @@ @param message: message element @profile: %(doc_profile)s """ + client = self.host.getClient(profile) try: room_jid_s = message.firstChildElement()['jid'] log.info(_(u'Invitation received for room %(room)s [%(profile)s]') % {'room': room_jid_s, 'profile': profile}) @@ -144,9 +146,14 @@ return from_jid_s = message["from"] room_jid = jid.JID(room_jid_s) - if room_jid in self.host.plugins["XEP-0045"].clients[profile].joined_rooms: - log.info(_("Invitation silently discarded because user is already in the room.")) + try: + self.host.plugins["XEP-0045"].checkRoomJoined(client, room_jid) + except exceptions.NotFound: + pass + else: + log.info(_(u"Invitation silently discarded because user is already in the room.")) return + autojoin = self.host.memory.getParamA(AUTOJOIN_NAME, AUTOJOIN_KEY, profile_key=profile) def accept_cb(conf_id, accepted, data, profile):