libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0045.py @ 2581:395a3d1c2888

plugin XEP-0045: fixed joining workflow: - room keep joining workflow state, and display warning when something is received at unexpected moment - state is change immediatly when subject is received (which must be the last thing before live messages), avoiding timing issue if history storage in database is taking too much time - user joined/left data are not saved anymore in history as it takes a lot of space for little interest. A future option may allow to re-enable it if needed.

author	Goffi <goffi@goffi.org>
date	Fri, 11 May 2018 17:11:47 +0200
parents	26edcf3a30eb
children	8378806a70fe

comparison

equal deleted inserted replaced

-:5e54afd17321
+:395a3d1c2888
 AFFILIATIONS = ('owner', 'admin', 'member', 'none', 'outcast')
 ROOM_USER_JOINED = 'ROOM_USER_JOINED'
 ROOM_USER_LEFT = 'ROOM_USER_LEFT'
 OCCUPANT_KEYS = ('nick', 'entity', 'affiliation', 'role')
 ENTITY_TYPE_MUC = "MUC"
+ROOM_STATE_OCCUPANTS = "occupants"
+ROOM_STATE_SELF_PRESENCE = "self-presence"
+ROOM_STATE_LIVE = "live"
+ROOM_STATES = (ROOM_STATE_OCCUPANTS, ROOM_STATE_SELF_PRESENCE, ROOM_STATE_LIVE)
 CONFIG_SECTION = u'plugin muc'
 default_conf = {"default_muc": u'sat@chat.jabberfr.org'}
 else:
 self.text_cmds.registerTextCommands(self)
 self.text_cmds.addWhoIsCb(self._whois, 100)
 host.trigger.add("presence_available", self.presenceTrigger)
-host.trigger.add("MessageReceived", self.MessageReceivedTrigger, priority=1000000)
+host.trigger.add("MessageReceived", self.messageReceivedTrigger, priority=1000000)
 def profileConnected(self, client):
 def assign_service(service):
 client.muc_service = service
 return self.getMUCService(client).addCallback(assign_service)
-def MessageReceivedTrigger(self, client, message_elt, post_treat):
+def messageReceivedTrigger(self, client, message_elt, post_treat):
 if message_elt.getAttribute("type") == C.MESS_TYPE_GROUPCHAT:
 if message_elt.subject or message_elt.delay:
 return False
 from_jid = jid.JID(message_elt['from'])
 room_jid = from_jid.userhostJID()
 if room_jid in client._muc_client.joined_rooms:
 room = client._muc_client.joined_rooms[room_jid]
-if not room._room_ok:
+if room.state != ROOM_STATE_LIVE:
-log.warning(u"Received non delayed message in a room before its initialisation: {}".format(message_elt.toXml()))
+log.warning(_(u"Received non delayed message in a room before its initialisation: state={state}, msg={msg}").format(
+state=room.state,
+msg=message_elt.toXml()))
 room._cache.append(message_elt)
 return False
 else:
 log.warning(u"Received groupchat message for a room which has not been joined, ignoring it: {}".format(message_elt.toXml()))
 return False
 def getRoomsJoined(self, client):
 """Return rooms where user is"""
 result = []
 for room in client._muc_client.joined_rooms.values():
-if room._room_ok:
+if room.state == ROOM_STATE_LIVE:
 result.append((room.roomJID.userhost(), self._getOccupants(room), room.nick, room.subject))
 return result
 def _getRoomNick(self, room_jid_s, profile_key=C.PROF_KEY_NONE):
 client = self.host.getClient(profile_key)
 @return: nick or empty string in case of error
 @raise exceptions.Notfound: use has not joined the room
 """
 self.checkRoomJoined(client, room_jid)
 return client._muc_client.joined_rooms[room_jid].nick
-# 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 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):
 client = self.host.getClient(profile_key)
 d = self.configureRoom(client, jid.JID(room_jid_s))
 d.addCallback(lambda xmlui: xmlui.toXml())
 def join(self, client, room_jid, nick=None, options=None):
 if not nick:
 nick = client.jid.user
 if options is None:
 options = {}
-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 client._muc_client.joined_rooms:
 room = client._muc_client.joined_rooms[room_jid]
-log.warning(_(u'{profile} is already in room {room_jid}').format(profile=client.profile, room_jid = room_jid.userhost()))
+log.info(_(u'{profile} is already in room {room_jid}').format(profile=client.profile, room_jid = room_jid.userhost()))
 return defer.fail(AlreadyJoined(room))
 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
+password = options.get("password")
 return client._muc_client.join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, (client, room_jid, nick), errbackArgs=(client, room_jid, nick, password))
 def _nick(self, room_jid_s, nick, profile_key=C.PROF_KEY_NONE):
 client = self.host.getClient(profile_key)
 def __init__(self, plugin_parent):
 self.plugin_parent = plugin_parent
 self.host = plugin_parent.host
 muc.MUCClient.__init__(self)
-self.rec_subjects = {}
 self._changing_nicks = set()  # used to keep trace of who is changing nick,
 # and to discard userJoinedRoom signal in this case
 print "init SatMUCClient OK"
 @property
 def joined_rooms(self):
 return self._rooms
+def changeRoomState(self, room, new_state):
+"""Check that room is in expected state, and change it
+@param new_state: one of ROOM_STATE_*
+"""
+new_state_idx = ROOM_STATES.index(new_state)
+if new_state_idx == -1:
+raise exceptions.InternalError("unknown room state")
+if new_state_idx < 1:
+raise exceptions.InternalError("unexpected new room state ({room}): {state}".format(
+room=room.userhost(),
+state=new_state))
+expected_state = ROOM_STATES[new_state_idx-1]
+if room.state != expected_state:
+log.warning(_(u"room {room} is not in expected state: room is in state {current_state} while we were expecting {expected_state}").format(
+room=room.userhost(),
+current_state=room.state,
+expected_state=expected_state))
+room.state = new_state
 def _addRoom(self, room):
 super(SatMUCClient, self)._addRoom(room)
 room._roster_ok = False  # True when occupants list has been fully received
-room._room_ok = None  # False when roster, history and subject are available
+room.state = ROOM_STATE_OCCUPANTS
-# True when new messages are saved to database
 room._history_d = defer.Deferred()  # used to send bridge signal once backlog are written in history
 room._history_d.callback(None)
 # FIXME: check if history_d is not redundant with fully_joined
 room.fully_joined = defer.Deferred()  # called when everything is OK
+# cache data until room is ready
+# list of elements which will be re-injected in stream
 room._cache = []
-def _gotLastDbHistory(self, mess_data_list, room_jid, nick, password):
+@defer.inlineCallbacks
+def join(self, room_jid, nick, password=None):
+mess_data_list = yield self.host.memory.historyGet(self.parent.jid.userhostJID(),
+room_jid,
+1,
+True,
+profile=self.parent.profile)
 if mess_data_list:
 timestamp = mess_data_list[0][1]
 # we use seconds since last message to get backlog without duplicates
 # and we remove 1 second to avoid getting the last message again
 seconds = int(time.time() - timestamp) - 1
 else:
 seconds = None
-d = super(SatMUCClient, self).join(room_jid, nick, muc.HistoryOptions(seconds=seconds), password)
+room = yield super(SatMUCClient, self).join(room_jid, nick, muc.HistoryOptions(seconds=seconds), password)
-return d
+defer.returnValue(room)
-def join(self, room_jid, nick, password=None):
-d = self.host.memory.historyGet(self.parent.jid.userhostJID(), room_jid, 1, True, profile=self.parent.profile)
-d.addCallback(self._gotLastDbHistory, room_jid, nick, password)
-return d
 ## presence/roster ##
 def availableReceived(self, presence):
 """
 if room is None:
 return
 if user is None:
 nick = presence.sender.resource
+if not nick:
+log.warning(_(u"missing nick in presence: {xml}").format(
+xml = presence.toElement().toXml()))
+return
 user = muc.User(nick, presence.entity)
 # Update user data
 user.role = presence.role
 user.affiliation = presence.affiliation
 self.userLeftRoom(room, user)
 def userJoinedRoom(self, room, user):
 if user.nick == room.nick:
 # we have received our own nick, this mean that the full room roster was received
-room._roster_ok = True
+self.changeRoomState(room, ROOM_STATE_SELF_PRESENCE)
 log.debug(u"room {room} joined with nick {nick}".format(room=room.occupantJID.userhost(), nick=user.nick))
-# We set type so we don't have use a deferred with disco to check entity type
+# We set type so we don't have to use a deferred with disco to check entity type
 self.host.memory.updateEntityData(room.roomJID, C.ENTITY_TYPE, ENTITY_TYPE_MUC, profile_key=self.parent.profile)
-elif not room._room_ok:
+elif room.state not in (ROOM_STATE_OCCUPANTS, ROOM_STATE_LIVE):
-log.warning(u"Received user presence data in a room before its initialisation (and after our own presence),"
+log.warning(u"Received user presence data in a room before its initialisation (current state: {state}),"
-"this is not standard! Ignoring it: {} ({})".format(
+"this is not standard! Ignoring it: {room} ({nick})".format(
-room.roomJID.userhost(),
+state=room.state,
-user.nick))
+room=room.roomJID.userhost(),
+nick=user.nick))
 return
-elif room._roster_ok:
+else:
+if not room.fully_joined.called:
+return
 try:
 self._changing_nicks.remove(user.nick)
 except KeyError:
 # this is a new user
 log.debug(_(u"user {nick} has joined room {room_id}").format(nick=user.nick, room_id=room.occupantJID.userhost()))
 "subject": {},
 "type": C.MESS_TYPE_INFO,
 "extra": extra,
 "timestamp": time.time(),
 }
-self.parent.messageAddToHistory(mess_data)
+# FIXME: we disable presence in history as it's taking a lot of space
+#        while not indispensable. In the future an option may allow
+#        to re-enable it
+# self.parent.messageAddToHistory(mess_data)
 self.parent.messageSendToBridge(mess_data)
 def userLeftRoom(self, room, user):
 if not self.host.trigger.point("MUC user left", room, user, self.parent.profile):
 room_jid_s = room.roomJID.userhost()
 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.mucRoomLeft(room.roomJID.userhost(), self.parent.profile)
-elif not room._room_ok:
+elif room.state != ROOM_STATE_LIVE:
-log.warning(u"Received user presence data in a room before its initialisation (and after our own presence),"
+log.warning(u"Received user presence data in a room before its initialisation (current state: {state}),"
-"this is not standard! Ignoring it: {} ({})".format(
+"this is not standard! Ignoring it: {room} ({nick})".format(
-room.roomJID.userhost(),
+state=room.state,
-user.nick))
+room=room.roomJID.userhost(),
+nick=user.nick))
 return
 else:
+if not room.fully_joined.called:
+return
 log.debug(_(u"user {nick} left room {room_id}").format(nick=user.nick, room_id=room.occupantJID.userhost()))
 extra = {'info_type': ROOM_USER_LEFT,
 'user_affiliation': user.affiliation,
 'user_role': user.role,
 'user_nick': user.nick
 "subject": {},
 "type": C.MESS_TYPE_INFO,
 "extra": extra,
 "timestamp": time.time(),
 }
-self.parent.messageAddToHistory(mess_data)
+# FIXME: disable history, see userJoinRoom comment
+# self.parent.messageAddToHistory(mess_data)
 self.parent.messageSendToBridge(mess_data)
 def userChangedNick(self, room, user, new_nick):
 self.host.bridge.mucRoomUserChangedNick(room.roomJID.userhost(), user.nick, new_nick, self.parent.profile)
 @param room(muc.Room): room instance
 @param user(muc.User, None): the user that sent the message
 None if the message come from the room
 @param message(muc.GroupChat): the parsed message
 """
+if room.state != ROOM_STATE_SELF_PRESENCE:
+log.warning(_(u"received history in unexpected state in room {room} (state: {state})").format(
+room = room.userhost(),
+state = room.state))
 room._history_d.addCallback(self._addToHistory, user, message)
 room._history_d.addErrback(self._addToHistoryEb)
 ## subject ##
 def subject(self, room, subject):
 return muc.MUCClientProtocol.subject(self, room, subject)
 def _historyCb(self, dummy, room):
+"""Called when history have been written to database and subject is received
+this method will finish joining by:
+- sending message to bridge
+- calling fully_joined deferred
+- sending stanza put in cache
+- cleaning variables not needed anymore
+"""
 args = self.plugin_parent._getRoomJoinedArgs(room, self.parent.profile)
 self.host.bridge.mucRoomJoined(*args)
+room.fully_joined.callback(room)
 del room._history_d
 cache = room._cache
 del room._cache
-room._room_ok = True
 for elem in cache:
 self.parent.xmlstream.dispatch(elem)
 def _historyEb(self, failure_, room):
 log.error(u"Error while managing history: {}".format(failure_))
 def receivedSubject(self, room, user, subject):
 # when subject is received, we know that we have whole roster and history
 # cf. http://xmpp.org/extensions/xep-0045.html#enter-subject
 room.subject = subject  # FIXME: subject doesn't handle xml:lang
-self.rec_subjects[room.roomJID.userhost()] = (room.roomJID.userhost(), subject)
+if room.state != ROOM_STATE_LIVE:
-if room._room_ok is None:
+self.changeRoomState(room, ROOM_STATE_LIVE)
-# this is the first subject we receive
-# that mean that we have received everything we need
-room._room_ok = False
 room._history_d.addCallbacks(self._historyCb, self._historyEb, [room], errbackArgs=[room])
-room.fully_joined.callback(room)
 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.mucRoomNewSubject(room.roomJID.userhost(), subject, self.parent.profile)

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0045.py @ 2581:395a3d1c2888