Add simple connection management capabilities to the broker. An external codebase will now be able to monitor and close the opened connections.

broker/src/main/java/io/moquette/server/ConnectionDescriptorStore.java

@@ -1,21 +1,31 @@
 package io.moquette.server;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import io.moquette.connections.IConnectionsManager;
+import io.moquette.connections.MqttSession;
+import io.moquette.connections.MqttSubscription;
 import io.moquette.parser.proto.messages.AbstractMessage;
+import io.moquette.spi.ClientSession;
+import io.moquette.spi.ISessionsStore;
+import io.moquette.spi.impl.subscriptions.Subscription;
 
-public class ConnectionDescriptorStore {
+public class ConnectionDescriptorStore implements IConnectionsManager {
 
 	private static final Logger LOG = LoggerFactory.getLogger(ConnectionDescriptorStore.class);
 
 	private final ConcurrentMap<String, ConnectionDescriptor> connectionDescriptors;
+	private final ISessionsStore sessionsStore;
 
-	public ConnectionDescriptorStore() {
+	public ConnectionDescriptorStore(ISessionsStore sessionsStore) {
 		this.connectionDescriptors = new ConcurrentHashMap<String, ConnectionDescriptor>();
+		this.sessionsStore = sessionsStore;
 	}
 
 	public boolean sendMessage(AbstractMessage message, String clientId) {
@@ -78,8 +88,74 @@ public class ConnectionDescriptorStore {
 		return connectionDescriptors.get(clientID);
 	}
 	
-	public boolean isConnected(String clientID) {
-		return connectionDescriptors.containsKey(clientID);
-	}
+    @Override
+    public boolean isConnected(String clientID) {
+        return connectionDescriptors.containsKey(clientID);
+    }
+
+    @Override
+    public int getActiveConnectionsNo() {
+        return connectionDescriptors.size();
+    }
+
+    @Override
+    public Collection<String> getConnectedClientIds() {
+        return connectionDescriptors.keySet();
+    }
+
+    @Override
+    public boolean closeConnection(String clientID, boolean closeImmediately) {
+        ConnectionDescriptor descriptor = connectionDescriptors.get(clientID);
+        if (descriptor == null) {
+            LOG.error(
+                    "The connection descriptor doesn't exist. The MQTT connection cannot be closed. MqttClientId = {}, closeImmediately = {}.",
+                    clientID, closeImmediately);
+            return false;
+        }
+        if (closeImmediately) {
+            descriptor.abort();
+            return true;
+        } else {
+            return descriptor.close();
+        }
+    }
+
+    @Override
+    public MqttSession getSessionStatus(String clientID) {
+        LOG.info("Retrieving status of session. MqttClientId = {}.", clientID);
+        ClientSession session = sessionsStore.sessionForClient(clientID);
+        if (session == null) {
+            LOG.error("The given MQTT client ID doesn't have an associated session. MqttClientId = {}.", clientID);
+            return null;
+        }
+        return buildMqttSession(session);
+    }
+
+    @Override
+    public Collection<MqttSession> getSessions() {
+        LOG.info("Retrieving status of all sessions.");
+        Collection<MqttSession> result = new ArrayList<MqttSession>();
+        for (ClientSession session : sessionsStore.getAllSessions()) {
+            result.add(buildMqttSession(session));
+        }
+        return result;
+    }
+
+    private MqttSession buildMqttSession(ClientSession session) {
+        MqttSession result = new MqttSession();
+        Collection<MqttSubscription> mqttSubscriptions = new ArrayList<>();
+        for (Subscription subscription : session.getSubscriptions()) {
+            mqttSubscriptions.add(new MqttSubscription(subscription.getRequestedQos().toString(),
+                    subscription.getClientId(), subscription.getTopicFilter(), subscription.isActive()));
+        }
+        result.setActiveSubscriptions(mqttSubscriptions);
+        result.setCleanSession(session.isCleanSession());
+        result.setConnectionEstablished(this.isConnected(session.clientID));
+        result.setPendingPublishMessagesNo(session.getPendingPublishMessagesNo());
+        result.setSecondPhaseAckPendingMessages(session.getSecondPhaseAckPendingMessages());
+        result.setInflightMessages(session.getInflightMessagesNo());
+        LOG.info("The status of the session has been retrieved successfully. MqttClientId = {}.", session.clientID);
+        return result;
+    }
 
 }

broker/src/main/java/io/moquette/server/Server.java

@@ -23,6 +23,7 @@ import com.hazelcast.core.HazelcastInstance;
 import com.hazelcast.core.HazelcastInstanceNotActiveException;
 import com.hazelcast.core.ITopic;
 import io.moquette.BrokerConstants;
+import io.moquette.connections.IConnectionsManager;
 import io.moquette.interception.HazelcastInterceptHandler;
 import io.moquette.interception.HazelcastMsg;
 import io.moquette.interception.InterceptHandler;
@@ -295,4 +296,13 @@ public class Server {
         m_processor.removeInterceptHandler(interceptHandler);
     }
 
+    /**
+     * Returns the connections manager of this broker.
+     * 
+     * @return
+     */
+    public IConnectionsManager getConnectionsManager() {
+        return m_processorBootstrapper.getConnectionDescriptors();
+    }
+
 }