即时通信系统Openfire分析之五：会话管理

　　什么是会话？

　　A拨了B的电话
　　电话接通
　　A问道：Are you OK？ 
　　B回复：I have a bug！
　　A挂了电话

　　上面所喻整个过程就是所谓的会话。

　　会话(Session)是一个客户与服务器之间的不中断的请求响应序列。注意其中“不中断”一词。

　　Openfire的通信，是以服务器为中转站的消息转发机制，客户端与服务器要实现通信，必须保持连接，即持有会话。Session的管理，集中在SessionManager模块中。

　　SessionManager

　　SessionManager提供了一系列与Session生命周期相关的管理功能，例如：

// 创建
public LocalClientSession createClientSession(Connection conn, StreamID id, Locale language) ;
// 添加
public void addSession(LocalClientSession session) ;
// 获取
public ClientSession getSession(JID from) ;
// 移除
public boolean removeSession(LocalClientSession session) ;

......

　　Session的整个生命周期，大致的讲可以分为：预创建、认证、移除

• 　　预创建：在连接打开后，服务端收到客户端的第一个消息请求（即初始化流）时完成，此时的Session还不能用于通信
• 　　认证：在资源绑定时完成，此时的Session被添加到会话管理队列以及路由表中，象征着已具备通信功能
• 　　移除：当连接空闲或者关闭时，Session被移除

　　特别注意的一点：

　　预创建、认证这两个过程，是在客户端登录的时候完成，从后面分析中看到的回应报文，以及第一章《Openfire与XMPP协议》中提到登录报文协议，可以清楚的看到这一点。而移除则是在客户端掉线的时候完成。

　　下面，就重点来看看，Openfire是具体是如何实现对Session的管理。

　　Session 预创建

　　回顾一下上一章的内容：ConnectionHandler类作为MINA的处理器，ConnectionHandler中的messageReceived()方法是消息的接收入口，接收到的消息交由StanzaHandler类处理。

　　StanzaHandler.process()方法在处理消息时，首先调用本类中createSession()方法，完成了对Session的预创建。

abstract boolean createSession(String namespace, String serverName, XmlPullParser xpp, Connection connection)
throws XmlPullParserException;

　　上面的createSession()是一个抽象方法，由其子类完成。本文我们以C2S通信为研究对象，故其实现子类为：ClientStanzaHandler类

　　ClientStanzaHandler.createSession()方法代码如下：

@Override
boolean createSession(String namespace, String serverName, XmlPullParser xpp, Connection connection)
        throws XmlPullParserException {
    if ("jabber:client".equals(namespace)) {
        // The connected client is a regular client so create a ClientSession
        session = LocalClientSession.createSession(serverName, xpp, connection);
        return true;
    }
    return false;
}

这里创建了一个LocalClientSession类型的Session对象。

LocalClientSession.createSession()方法如下，只保留与创建流程相关的代码：

public static LocalClientSession createSession(String serverName, XmlPullParser xpp, Connection connection)
        throws XmlPullParserException {
  
    ......

    // Create a ClientSession for this user.
    LocalClientSession session = SessionManager.getInstance().createClientSession(connection, language);
    
        // Build the start packet response
    StringBuilder sb = new StringBuilder(200);
    sb.append("<?xml version='1.0' encoding='");
    sb.append(CHARSET);
    sb.append("'?>");
    if (isFlashClient) {
        sb.append("<flash:stream xmlns:flash="http://www.jabber.com/streams/flash" ");
    }
    else {
        sb.append("<stream:stream ");
    }
    sb.append("xmlns:stream="http://etherx.jabber.org/streams" xmlns="jabber:client" from="");
    sb.append(serverName);
    sb.append("" id="");
    sb.append(session.getStreamID().toString());
    sb.append("" xml:lang="");
    sb.append(language.toLanguageTag());
    // Don't include version info if the version is 0.0.
    if (majorVersion != 0) {
        sb.append("" version="");
        sb.append(majorVersion).append('.').append(minorVersion);
    }
    sb.append("">");
    connection.deliverRawText(sb.toString());

    // If this is a "Jabber" connection, the session is now initialized and we can
    // return to allow normal packet parsing.
    if (majorVersion == 0) {
        return session;
    }
    // Otherwise, this is at least XMPP 1.0 so we need to announce stream features.

    sb = new StringBuilder(490);
    sb.append("<stream:features>");
    if (connection.getTlsPolicy() != Connection.TLSPolicy.disabled) {
        sb.append("<starttls xmlns="urn:ietf:params:xml:ns:xmpp-tls">");
        if (connection.getTlsPolicy() == Connection.TLSPolicy.required) {
            sb.append("<required/>");
        }
        sb.append("</starttls>");
    }
    // Include available SASL Mechanisms
    sb.append(SASLAuthentication.getSASLMechanisms(session));
    // Include Stream features
    String specificFeatures = session.getAvailableStreamFeatures();
    if (specificFeatures != null) {
        sb.append(specificFeatures);
    }
    sb.append("</stream:features>");

    connection.deliverRawText(sb.toString());
    
    return session;
}

　　创建了一个LocalClientSession对象之后，服务端调用了两次deliverRawText()给客户端发送报文。从协议报文的内容来看，其实就是登录过程中，服务端收到客户端第一个初始化流之后的两个应答：第一个是流回复，第二个是通知客户端进行STL协商。

　　而LocalClientSession是由SessionManager生成。

　　SessionManager.createClientSession()代码如下：

public LocalClientSession createClientSession(Connection conn, Locale language) {
    return createClientSession(conn, nextStreamID(), language);
}

public LocalClientSession createClientSession(Connection conn, StreamID id, Locale language) {
    if (serverName == null) {
        throw new IllegalStateException("Server not initialized");
    }
    LocalClientSession session = new LocalClientSession(serverName, conn, id, language);
    conn.init(session);
    // Register to receive close notification on this session so we can
    // remove  and also send an unavailable presence if it wasn't
    // sent before
    conn.registerCloseListener(clientSessionListener, session);

    // Add to pre-authenticated sessions.
    localSessionManager.getPreAuthenticatedSessions().put(session.getAddress().getResource(), session);
    // Increment the counter of user sessions
    connectionsCounter.incrementAndGet();
    return session;
}　

　　由上面两个方法总结起来，Session的预创建流程为：

　　（1）生成一个新streamID，并创建一个LocalClientSession对象的session

　　（2）调用conn.registerCloseListener()，注册了Session的关闭监听。作用是当Connection关掉时，Session也相应清除掉

　　（3）将生成的session添加到preAuthenticatedSessions队列中，表示预创建完成。但此时的Session并没有加入到路由表，还不能用来通信

　　Session 认证

　　在第一章，《Openfire与XMPP协议》一文中已经介绍，资源绑定其实是用户登录过程的其中一步。亦即，在这里完成了Session的认证。

　　资源绑定是一个IQ消息，结合上一章《消息路由》中的分析，对于IQ消息，PacketRouterImpl模块使用IQRouter来完成路由。

　　IQRouter.route()方法如下，其中只保留资源绑定部分代码：

public void route(IQ packet) {
    ......
    try {
        ......
        else if (session == null || session.getStatus() == Session.STATUS_AUTHENTICATED || (
                childElement != null && isLocalServer(to) && (
                    "jabber:iq:auth".equals(childElement.getNamespaceURI()) ||
                    "jabber:iq:register".equals(childElement.getNamespaceURI()) ||
                    "urn:ietf:params:xml:ns:xmpp-bind".equals(childElement.getNamespaceURI())))) {
            handle(packet);
        } 
        ......
    }
    catch (PacketRejectedException e) {
        ......
    }
}

　　其中，handle()方法创建了处理该IQ的IQHandler，并调用IQandler中的process()进行包处理。

　　IQRouter.handle()：

private void handle(IQ packet) {
    JID recipientJID = packet.getTo();
    ......
    if (isLocalServer(recipientJID)) {
        if (namespace == null) {
            ......
        }
        else {
            IQHandler handler = getHandler(namespace);
            if (handler == null) {
               ......
            }
            else {
                handler.process(packet);
            }
        }
    }
    ......
}

　　传入的参数"namespace"，是IQ的唯一标识码，将决定了这个IQ由谁来处理。

　　资源绑定的namespace为：urn:ietf:params:xml:ns:xmpp-bind，也就是说，这个IQ，最终将交给IQBindHandler来处理。

　　可以看到，IQBindHandler的构造方法：

public IQBindHandler() {
    super("Resource Binding handler");
    info = new IQHandlerInfo("bind", "urn:ietf:params:xml:ns:xmpp-bind");
}

　　包处理方法IQHandler.process()：

@Override
public void process(Packet packet) throws PacketException {
    IQ iq = (IQ) packet;
    try {
        IQ reply = handleIQ(iq);
        if (reply != null) {
            deliverer.deliver(reply);
        }
    }
   ......
}

　　IQBindHandler.handleIQ()中，setAuthToken()方法实现对Session认证。

@Override
public IQ handleIQ(IQ packet) throws UnauthorizedException {
    LocalClientSession session = (LocalClientSession) sessionManager.getSession(packet.getFrom());
    IQ reply = IQ.createResultIQ(packet);
    Element child = reply.setChildElement("bind", "urn:ietf:params:xml:ns:xmpp-bind");
    ......
    if (authToken.isAnonymous()) {
        // User used ANONYMOUS SASL so initialize the session as an anonymous login
        session.setAnonymousAuth();
    }
    else {
        ......
        session.setAuthToken(authToken, resource);
    }
    child.addElement("jid").setText(session.getAddress().toString());
    // Send the response directly since a route does not exist at this point.
    session.process(reply);
    // After the client has been informed, inform all listeners as well.
    SessionEventDispatcher.dispatchEvent(session, SessionEventDispatcher.EventType.resource_bound);
    return null;
}

　　Session的认证后，其实就是将Session加入SessionManager中，如下：

LocalClientSession.setAuthToken():

public void setAuthToken(AuthToken auth, String resource) {
    ......
    sessionManager.addSession(this);
}

　　在第四章分析消息路由时，发送消息前，首先用ToJID从路由表中获取Session，接着再进行消息路由。也就是说，一条消息能否被接收到，取决于接收者的Session是否存在于路由表中。
　　而SessionManager.addSession()刚好就是将Session加入路由表，如下：

　　SessionManager.addSession()：

public void addSession(LocalClientSession session) {

    routingTable.addClientRoute(session.getAddress(), session);
    ....
}

　　此时，就代表了这个Session拥有了全部的功能，可以用来进行通信了。

　　Session 移除

　　移除工作就相对简单一些了，当监听到Connection关闭时，应清除掉相应的Session。

　　在SessionManager的私有类ClientSessionListener实现了ConnectionCloseListener，能及时地监听到Connection关闭并进行Session的清除工作。监听是在Session预创建时注册，上文已经介绍。

　　Session的关闭监听，ClientSessionListener类如下：

private class ClientSessionListener implements ConnectionCloseListener {
    /**
     * Handle a session that just closed.
     *
     * @param handback The session that just closed
     */
    @Override
    public void onConnectionClose(Object handback) {
        try {
            LocalClientSession session = (LocalClientSession) handback;
            try {
                if ((session.getPresence().isAvailable() || !session.wasAvailable()) &&
                        routingTable.hasClientRoute(session.getAddress())) {
                    // Send an unavailable presence to the user's subscribers
                    // Note: This gives us a chance to send an unavailable presence to the
                    // entities that the user sent directed presences
                    Presence presence = new Presence();
                    presence.setType(Presence.Type.unavailable);
                    presence.setFrom(session.getAddress());
                    router.route(presence);
                }

                session.getStreamManager().onClose(router, serverAddress);
            }
            finally {
                // Remove the session
                removeSession(session);
            }
        }
        catch (Exception e) {
            // Can't do anything about this problem...
            Log.error(LocaleUtils.getLocalizedString("admin.error.close"), e);
        }
    }
}

　　先关闭Sessoin，然后移除出队列，清除完毕！

---

Over！