Java ServerChannel类代码示例

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
void processDisconnect(ServerChannel session, String clientID, boolean cleanSession) throws InterruptedException {

        String username = authSubjects.get(clientID).getUsername();
        removeAuthorizationSubject(clientID);

        if (cleanSession) {
            //cleanup topic subscriptions
            processRemoveAllSubscriptions(clientID);
        }
//        m_notifier.disconnect(evt.getSession());
        m_clientIDs.remove(clientID);
        session.close(true);

        //de-activate the subscriptions for this ClientID
        subscriptions.deactivate(clientID);

        try {
            AndesMQTTBridge.getBridgeInstance().onClientDisconnection(clientID, null,
                    username, AndesMQTTBridge.SubscriptionEvent.DISCONNECT);
            log.info("Disconnected client " + clientID + " with clean session " + cleanSession);
        } catch (MQTTException e) {
            log.error("Error occurred when attempting to disconnect subscriber", e);
        }
    }
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
/**
 * Remove the clientID from topic subscription, if not previously subscribed,
 * doesn't reply any error
 */
void processUnsubscribe(ServerChannel session, String clientID, List<String> topics, int messageID) {
    if (log.isDebugEnabled()) {
        log.debug("processUnsubscribe invoked, removing subscription on topics " + topics + ", for clientID " + clientID);
    }

    for (String topic : topics) {
        subscriptions.removeSubscription(topic, clientID);
        //also will unsubscribe from the kernel
        try {
            AndesMQTTBridge.getBridgeInstance().onClientDisconnection(clientID, topic,
                    authSubjects.get(clientID).getUsername(),
                    AndesMQTTBridge.SubscriptionEvent.UNSUBSCRIBE);
        } catch (Exception e) {
            final String message = "Error occurred when disconnecting the subscriber ";
            log.error(message + e.getMessage());
        }
        // bridge.onClientDisconnection(clientID);
    }
    //ack the client
    UnsubAckMessage ackMessage = new UnsubAckMessage();
    ackMessage.setMessageID(messageID);

    log.info("replying with UnsubAck to MSG ID " + messageID);
    session.write(ackMessage);
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
void processDisconnect(ServerChannel session, String clientID, boolean cleanSession) throws InterruptedException {
        if (cleanSession) {
            //cleanup topic subscriptions
            processRemoveAllSubscriptions(clientID);
        }
//        m_notifier.disconnect(evt.getSession());
        m_clientIDs.remove(clientID);
        session.close(true);

        //de-activate the subscriptions for this ClientID
        subscriptions.deactivate(clientID);
        //cleanup the will store
        m_willStore.remove(clientID);

        Log.info("Disconnected client <{}> with clean session {}", clientID, cleanSession);
    }
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
void processSubscribe(ServerChannel session, SubscribeMessage msg, String clientID, boolean cleanSession) {
    LOG.info(String.format("processSubscribe invoked from client %s with msgID %d", clientID, msg.getMessageID()));

    for (SubscribeMessage.Couple req : msg.subscriptions()) {
        AbstractMessage.QOSType qos = AbstractMessage.QOSType.values()[req.getQos()];
        Subscription newSubscription = new Subscription(clientID, req.getTopic(), qos, cleanSession);
        subscribeSingleTopic(newSubscription, req.getTopic());
    }

    //ack the client
    SubAckMessage ackMessage = new SubAckMessage();
    ackMessage.setMessageID(msg.getMessageID());

    //TODO by now it handles only QoS 0 messages
    for (int i = 0; i < msg.subscriptions().size(); i++) {
        ackMessage.addType(AbstractMessage.QOSType.MOST_ONE);
    }
    LOG.info("replying with SubAck to MSG ID " + msg.getMessageID());
    session.write(ackMessage);
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
/**
 * Added as an upgrade for 3.1.1 specification, This is adopted by WSO2 from Moquette
 *
 * @param session the server session which holds channel information
 */
private void failedCredentials(ServerChannel session) {
    ConnAckMessage okResp = new ConnAckMessage();
    okResp.setReturnCode(ConnAckMessage.BAD_USERNAME_OR_PASSWORD);
    session.write(okResp);
    session.close(false);
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
void proccessConnectionLost(String clientID) {

        boolean forciblyClosed = false;

        if (forciblyClosedChannels.containsKey(clientID)) {
            ServerChannel oldSession = forciblyClosedChannels.remove(clientID);
            ServerChannel newSession = m_clientIDs.get(clientID).getSession();

            // If the new channel and the old channel are not equal, this is a connection lost received from a
            // forcibly closed a connection. Hence remove the record and avoid processing connection lost for the old
            // session since it's session data has already been cleared
            if (null != newSession && !oldSession.getUUID().equals(newSession.getUUID())) {
                forciblyClosed = true;
            }
        }

        //If already removed a disconnect message was already processed for this clientID
        if (!forciblyClosed && m_clientIDs.remove(clientID) != null) {
            //de-activate the subscriptions for this ClientID
            subscriptions.deactivate(clientID);
            log.info("Lost connection with client " + clientID);
            //Andes change
            //Need to handle disconnection
            try {

            // We need to disconnect subscription only if client id exists in authSubjects.
            // If it's not existing in authSubjects Subscription has already removed or
            // subscription has never created due to invalid credentials.
            if(authSubjects.containsKey(clientID)) {
                String username = authSubjects.get(clientID).getUsername();
                AndesMQTTBridge.getBridgeInstance().onClientDisconnection(clientID, null, username,
                        AndesMQTTBridge.SubscriptionEvent.DISCONNECT);
            }
            } catch (MQTTException e) {
                final String message = "Error occurred when attempting to disconnect subscriber ";
                log.error(message + e.getMessage(), e);
            }
            removeAuthorizationSubject(clientID);
        }
    }
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
public PublishEvent(PublishMessage pubMsg, String clientID, ServerChannel session) {
    m_topic = pubMsg.getTopicName();
    m_qos = pubMsg.getQos();
    m_message = pubMsg.getPayload();
    m_retain = pubMsg.isRetainFlag();
    m_clientID = clientID;
    m_session = session;
    if (pubMsg.getQos() != QOSType.MOST_ONE) {
        m_msgID = pubMsg.getMessageID();
    }
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
/**
 * Remove the clientID from topic subscription, if not previously subscribed,
 * doesn't reply any error
 */
void processUnsubscribe(ServerChannel session, String clientID, List<String> topics, int messageID) {
    Log.trace("processUnsubscribe invoked, removing subscription on topics {}, for clientID <{}>", topics, clientID);

    for (String topic : topics) {
        subscriptions.removeSubscription(topic, clientID);
    }
    //ack the client
    UnsubAckMessage ackMessage = new UnsubAckMessage();
    ackMessage.setMessageID(messageID);

    Log.trace("replying with UnsubAck to MSG ID {}", messageID);
    session.write(ackMessage);
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
void processDisconnect(ServerChannel session, String clientID, boolean cleanSession) throws InterruptedException {
        if (cleanSession) {
            //cleanup topic subscriptions
            processRemoveAllSubscriptions(clientID);
        }
//        m_notifier.disconnect(evt.getSession());
        m_clientIDs.remove(clientID);
        session.close(true);

        //de-activate the subscriptions for this ClientID
//        String clientID = (String) evt.getSession().getAttribute(Constants.ATTR_CLIENTID);
        subscriptions.deactivate(clientID);
    }
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
/**
 * Remove the clientID from topic subscription, if not previously subscribed,
 * doesn't reply any error
 */
void processUnsubscribe(ServerChannel session, String clientID, List<String> topics, int messageID) {
    LOG.debug("processSubscribe invoked");

    for (String topic : topics) {
        subscriptions.removeSubscription(topic, clientID);
    }
    //ack the client
    UnsubAckMessage ackMessage = new UnsubAckMessage();
    ackMessage.setMessageID(messageID);

    LOG.info(String.format("replying with UnsubAck to MSG ID %s", messageID));
    session.write(ackMessage);
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
public PublishEvent(String topic, QOSType qos, byte[] message, boolean retain,
        String clientID, ServerChannel session) {
    m_topic = topic;
    m_qos = qos;
    m_message = message;
    m_retain = retain;
    m_clientID = clientID;
    m_session = session;
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
public ServerChannel getSession() {
    return m_session;
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
public OutputMessagingEvent(ServerChannel channel, AbstractMessage message) {
    m_channel = channel;
    m_message = message;
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
public ServerChannel getChannel() {
    return m_channel;
}
 

import org.dna.mqtt.moquette.server.ServerChannel; //导入依赖的package包/类
public DisconnectEvent(ServerChannel session) {
    m_session = session;
}