conversationmanager.java

openfire 服务器源码下载

    /**
     * Notification message indicating that a user left a groupchat conversation. If
     * no groupchat conversation was taking place in the specified room then ignore this
     * event.
     *
     * @param room the room where the user left.
     * @param user the user that left the room.
     * @param date date when the user left the group coversation.
     */
    void leftGroupConversation(JID room, JID user, Date date) {
        Conversation conversation = getRoomConversation(room);
        if (conversation != null) {
            conversation.participantLeft(user, date.getTime());
        }
    }

    void roomConversationEnded(JID room, Date date) {
        Conversation conversation = getRoomConversation(room);
        if (conversation != null) {
            removeConversation(room.toString(), conversation, date);
        }
    }

    private void removeConversation(String key, Conversation conversation, Date date) {
        conversations.remove(key);
        // Notify conversation that it has ended
        conversation.conversationEnded(date);
        // Notify listeners of the conversation ending.
        for (ConversationListener listener : conversationListeners) {
            listener.conversationEnded(conversation);
        }
    }

    /**
     * Returns the group conversation taking place in the specified room or <tt>null</tt> if none.
     *
     * @param room JID of the room.
     * @return the group conversation taking place in the specified room or null if none.
     */
    private Conversation getRoomConversation(JID room) {
        String conversationKey = room.toString();
        return conversations.get(conversationKey);
    }

    private boolean isExternal(XMPPServer server, JID jid) {
        return !server.isLocal(jid) || gateways.contains(jid.getDomain());
    }

    /**
     * Returns true if the specified message should be processed by the conversation manager.
     * Only messages between two users, group chats, or gateways are processed.
     *
     * @param message the message to analyze.
     * @return true if the specified message should be processed by the conversation manager.
     */
    boolean isConversation(Message message) {
        if (Message.Type.normal == message.getType() || Message.Type.chat == message.getType()) {
            // TODO: how should conversations with components on other servers be handled?
            return isConversationJID(message.getFrom()) && isConversationJID(message.getTo());
        }
        return false;
    }

    /**
     * Returns true if the specified JID should be recorded in a conversation.
     *
     * @param jid the JID.
     * @return true if the JID should be recorded in a conversation.
     */
    private boolean isConversationJID(JID jid) {
        // Ignore conversations when there is no jid
        if (jid == null) {
            return false;
        }
        XMPPServer server = XMPPServer.getInstance();
        if (jid.getNode() == null) {
            return false;
        }

        // Always accept local JIDs or JIDs related to gateways
        // (this filters our components, MUC, pubsub, etc. except gateways).
        if (server.isLocal(jid) || gateways.contains(jid.getDomain())) {
            return true;
        }

        // If not a local JID, always record it.
        if (!jid.getDomain().endsWith(serverInfo.getXMPPDomain())) {
            return true;
        }

        // Otherwise return false.
        return false;
    }

    /**
     * Returns a unique key for a coversation between two JID's. The order of two JID parameters
     * is irrelevant; the same key will be returned.
     *
     * @param jid1 the first JID.
     * @param jid2 the second JID.
     * @return a unique key.
     */
    String getConversationKey(JID jid1, JID jid2) {
        StringBuilder builder = new StringBuilder();
        if (jid1.compareTo(jid2) < 0) {
            builder.append(jid1.toBareJID()).append("_").append(jid2.toBareJID());
        }
        else {
            builder.append(jid2.toBareJID()).append("_").append(jid1.toBareJID());
        }
        return builder.toString();
    }

    String getRoomConversationKey(JID roomJID) {
        return roomJID.toString();
    }

    public void componentInfoReceived(Component component, IQ iq) {
        //Check if the component is a gateway
        boolean gatewayFound = false;
        Element childElement = iq.getChildElement();
        for (Iterator it = childElement.elementIterator("identity"); it.hasNext();) {
            Element identity = (Element)it.next();
            if ("gateway".equals(identity.attributeValue("category"))) {
                gatewayFound = true;
            }
        }
        // If component is a gateway then keep track of the component
        if (gatewayFound) {
            gateways.add(iq.getFrom().getDomain());
        }
    }

    public void componentRegistered(Component component, JID componentJID) {
        //Do nothing
    }

    public void componentUnregistered(Component component, JID componentJID) {
        // Remove stored information about this component
        gateways.remove(componentJID.getDomain());
    }

    void queueParticipantLeft(Conversation conversation, JID user, ConversationParticipation participation) {
        RoomParticipant updatedParticipant = new RoomParticipant();
        updatedParticipant.conversationID = conversation.getConversationID();
        updatedParticipant.user = user;
        updatedParticipant.joined = participation.getJoined();
        updatedParticipant.left = participation.getLeft();
        participantQueue.add(updatedParticipant);
    }

    /**
     * A task that persists conversation meta-data and messages to the database.
     */
    private class ArchivingTask implements Runnable {

        public void run() {
            synchronized (this) {
                if (archivingRunning) {
                    return;
                }
                archivingRunning = true;
            }
            if (!messageQueue.isEmpty() || !conversationQueue.isEmpty() || !participantQueue.isEmpty()) {
                Connection con = null;
                PreparedStatement pstmt = null;
                try {
                    con = DbConnectionManager.getConnection();

                    pstmt = con.prepareStatement(INSERT_MESSAGE);
                    ArchivedMessage message;
                    int count = 0;
                    while ((message = messageQueue.poll()) != null) {
                        pstmt.setLong(1, message.getConversationID());
                        pstmt.setString(2, message.getFromJID().toString());
                        pstmt.setString(3, message.getToJID().toString());
                        pstmt.setLong(4, message.getSentDate().getTime());
                        DbConnectionManager.setLargeTextField(pstmt, 5, message.getBody());
                        if (DbConnectionManager.isBatchUpdatesSupported()) {
                            pstmt.addBatch();
                        }
                        else {
                            pstmt.execute();
                        }
                        // Only batch up to 500 items at a time.
                        if (count % 500 == 0 && DbConnectionManager.isBatchUpdatesSupported()) {
                            pstmt.executeBatch();
                        }
                        count++;
                    }
                    if (DbConnectionManager.isBatchUpdatesSupported()) {
                        pstmt.executeBatch();
                    }

                    pstmt = con.prepareStatement(UPDATE_CONVERSATION);
                    Conversation conversation;
                    count = 0;
                    while ((conversation = conversationQueue.poll()) != null) {
                        pstmt.setLong(1, conversation.getLastActivity().getTime());
                        pstmt.setInt(2, conversation.getMessageCount());
                        pstmt.setLong(3, conversation.getConversationID());
                        if (DbConnectionManager.isBatchUpdatesSupported()) {
                            pstmt.addBatch();
                        }
                        else {
                            pstmt.execute();
                        }
                        // Only batch up to 500 items at a time.
                        if (count % 500 == 0 && DbConnectionManager.isBatchUpdatesSupported()) {
                            pstmt.executeBatch();
                        }
                        count++;
                    }
                    if (DbConnectionManager.isBatchUpdatesSupported()) {
                        pstmt.executeBatch();
                    }

                    pstmt = con.prepareStatement(UPDATE_PARTICIPANT);
                    RoomParticipant particpiant;
                    count = 0;
                    while ((particpiant = participantQueue.poll()) != null) {
                        pstmt.setLong(1, particpiant.left.getTime());
                        pstmt.setLong(2, particpiant.conversationID);
                        pstmt.setString(3, particpiant.user.toBareJID());
                        pstmt.setString(4, particpiant.user.getResource() == null ? " " : particpiant.user.getResource());
                        pstmt.setLong(5, particpiant.joined.getTime());
                        if (DbConnectionManager.isBatchUpdatesSupported()) {
                            pstmt.addBatch();
                        }
                        else {
                            pstmt.execute();
                        }
                        // Only batch up to 500 items at a time.
                        if (count % 500 == 0 && DbConnectionManager.isBatchUpdatesSupported()) {
                            pstmt.executeBatch();
                        }
                        count++;
                    }
                    if (DbConnectionManager.isBatchUpdatesSupported()) {
                        pstmt.executeBatch();
                    }
                }
                catch (Exception e) {
                    Log.error(e);
                }
                finally {
                    DbConnectionManager.closeConnection(pstmt, con);
                }
            }
            // Set archiving running back to false.
            archivingRunning = false;
        }
    }

    /**
     * A PropertyEventListener that tracks updates to Jive properties that are related
     * to conversation tracking and archiving.
     */
    private class ConversationPropertyListener implements PropertyEventListener {

        public void propertySet(String property, Map params) {
            if (property.equals("conversation.metadataArchiving")) {
                String value = (String)params.get("value");
                metadataArchivingEnabled = Boolean.valueOf(value);
            }
            else if (property.equals("conversation.messageArchiving")) {
                String value = (String)params.get("value");
                messageArchivingEnabled = Boolean.valueOf(value);
                // Force metadata archiving enabled on if message archiving on.
                if (messageArchivingEnabled) {
                    metadataArchivingEnabled = true;
                }
            }
            else if (property.equals("conversation.roomArchiving")) {
                String value = (String)params.get("value");
                roomArchivingEnabled = Boolean.valueOf(value);
                // Force metadata archiving enabled on if message archiving on.
                if (roomArchivingEnabled) {
                    metadataArchivingEnabled = true;
                }
            }
            else if (property.equals("conversation.roomsArchived")) {
                String value = (String)params.get("value");
                roomsArchived = StringUtils.stringToCollection(value);
            }
            else if (property.equals("conversation.idleTime")) {
                String value = (String)params.get("value");
                try {
                    idleTime = Integer.parseInt(value) * JiveConstants.MINUTE;
                }
                catch (Exception e) {
                    Log.error(e);
                    idleTime = DEFAULT_IDLE_TIME * JiveConstants.MINUTE;
                }
            }
            else if (property.equals("conversation.maxTime")) {
                String value = (String)params.get("value");
                try {
                    maxTime = Integer.parseInt(value) * JiveConstants.MINUTE;
                }
                catch (Exception e) {
                    Log.error(e);
                    maxTime = DEFAULT_MAX_TIME * JiveConstants.MINUTE;
                }
            }
        }

        public void propertyDeleted(String property, Map params) {
            if (property.equals("conversation.metadataArchiving")) {
                metadataArchivingEnabled = true;
            }
            else if (property.equals("conversation.messageArchiving")) {
                messageArchivingEnabled = false;
            }
            else if (property.equals("conversation.roomArchiving")) {
                roomArchivingEnabled = false;
            }
            else if (property.equals("conversation.roomsArchived")) {
                roomsArchived = Collections.emptyList();
            }
            else if (property.equals("conversation.idleTime")) {
                idleTime = DEFAULT_IDLE_TIME * JiveConstants.MINUTE;
            }
            else if (property.equals("conversation.maxTime")) {
                maxTime = DEFAULT_MAX_TIME * JiveConstants.MINUTE;
            }
        }

        public void xmlPropertySet(String property, Map params) {
            // Ignore.
        }

        public void xmlPropertyDeleted(String property, Map params) {
            // Ignore.
        }
    }

    private static class RoomParticipant {
        private long conversationID = -1;
        private JID user;
        private Date joined;
        private Date left;
    }
}