Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(iot): stabilize MQTT WebSocket concurrent sessions (#3816)

Vũ Thế Huy98e1cca8a57d
diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridge.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridge.java
index 115259c45f..39af9d3d10 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridge.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridge.java
@@ -12,6 +12,8 @@ import jakarta.enterprise.event.Observes;
import jakarta.inject.Inject;
import org.jboss.logging.Logger;
+import java.util.concurrent.atomic.AtomicBoolean;
+
/**
* Serves MQTT over WebSocket at {@code /mqtt} on the HTTP and HTTPS ports, the path and port AWS
* IoT uses for browser clients, the Device SDK's WebSocket transport and secure tunnelling. Frames
@@ -90,8 +92,7 @@ public class IotMqttWebSocketBridge {
socket.close();
return;
}
- wire(ws, socket);
- ws.resume();
+ new BridgeSession(ws, socket).start();
})
.onFailure(error -> {
LOG.warnv("MQTT WebSocket bridge could not reach the broker on {0}:{1}: {2}",
@@ -100,39 +101,86 @@ public class IotMqttWebSocketBridge {
});
}
- private static void wire(ServerWebSocket ws, NetSocket socket) {
- ws.frameHandler(frame -> {
- if (ws.isClosed()) {
- return;
- }
- if (frame.isText()) {
- ws.close(CLOSE_UNSUPPORTED_DATA, "MQTT over WebSocket is binary");
- return;
- }
- if (!frame.isBinary() && !frame.isContinuation()) {
- return;
+ static final class BridgeSession {
+
+ private final ServerWebSocket webSocket;
+ private final NetSocket socket;
+ private final AtomicBoolean closed = new AtomicBoolean();
+
+ BridgeSession(ServerWebSocket webSocket, NetSocket socket) {
+ this.webSocket = webSocket;
+ this.socket = socket;
+ }
+
+ void start() {
+ webSocket.frameHandler(frame -> {
+ if (closed.get() || webSocket.isClosed()) {
+ return;
+ }
+ if (frame.isText()) {
+ close(CLOSE_UNSUPPORTED_DATA, "MQTT over WebSocket is binary");
+ return;
+ }
+ if (!frame.isBinary() && !frame.isContinuation()) {
+ return;
+ }
+ socket.write(frame.binaryData());
+ if (socket.writeQueueFull()) {
+ webSocket.pause();
+ socket.drainHandler(ignored -> {
+ if (!closed.get()) {
+ webSocket.resume();
+ }
+ });
+ }
+ });
+ webSocket.closeHandler(ignored -> closeSocket());
+ webSocket.exceptionHandler(error -> close(CLOSE_INTERNAL_ERROR, "MQTT WebSocket failed"));
+
+ socket.handler(bytes -> {
+ if (closed.get() || webSocket.isClosed()) {
+ return;
+ }
+ webSocket.writeBinaryMessage(bytes);
+ if (webSocket.writeQueueFull()) {
+ socket.pause();
+ webSocket.drainHandler(ignored -> {
+ if (!closed.get()) {
+ socket.resume();
+ }
+ });
+ }
+ });
+ socket.closeHandler(ignored -> closeWebSocket());
+ socket.exceptionHandler(error -> close(CLOSE_INTERNAL_ERROR, "MQTT broker connection failed"));
+
+ if (webSocket.isClosed()) {
+ closeSocket();
+ } else {
+ webSocket.resume();
}
- socket.write(frame.binaryData());
- if (socket.writeQueueFull()) {
- ws.pause();
- socket.drainHandler(ignored -> ws.resume());
+ }
+
+ private void close(short code, String reason) {
+ if (closed.compareAndSet(false, true)) {
+ socket.close();
+ if (!webSocket.isClosed()) {
+ webSocket.close(code, reason);
+ }
}
- });
- ws.closeHandler(ignored -> socket.close());
- ws.exceptionHandler(error -> socket.close());
+ }
- socket.handler(bytes -> {
- if (ws.isClosed()) {
- return;
+ private void closeSocket() {
+ if (closed.compareAndSet(false, true)) {
+ socket.close();
}
- ws.writeBinaryMessage(bytes);
- if (ws.writeQueueFull()) {
- socket.pause();
- ws.drainHandler(ignored -> socket.resume());
+ }
+
+ private void closeWebSocket() {
+ if (closed.compareAndSet(false, true) && !webSocket.isClosed()) {
+ webSocket.close();
}
- });
- socket.closeHandler(ignored -> ws.close());
- socket.exceptionHandler(error -> ws.close(CLOSE_INTERNAL_ERROR, "MQTT broker connection failed"));
+ }
}
/** The broker binds {@code 0.0.0.0} by default, which is not a connect target; loopback is. */
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridgeTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridgeTest.java
new file mode 100644
index 0000000000..52d78c4009
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketBridgeTest.java
@@ -0,0 +1,107 @@
+package io.github.hectorvent.floci.services.iot;
+
+import io.vertx.core.Handler;
+import io.vertx.core.http.ServerWebSocket;
+import io.vertx.core.net.NetSocket;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import static org.mockito.ArgumentMatchers.anyShort;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class IotMqttWebSocketBridgeTest {
+
+ @Test
+ void brokerCloseAndExceptionCloseWebSocketOnlyOnce() {
+ ServerWebSocket webSocket = mock(ServerWebSocket.class);
+ NetSocket socket = mock(NetSocket.class);
+ when(webSocket.isClosed()).thenReturn(false);
+
+ IotMqttWebSocketBridge.BridgeSession session =
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket);
+ session.start();
+
+ ArgumentCaptor<Handler<Void>> closeCaptor = ArgumentCaptor.forClass(Handler.class);
+ verify(socket).closeHandler(closeCaptor.capture());
+ ArgumentCaptor<Handler<Throwable>> exceptionCaptor = ArgumentCaptor.forClass(Handler.class);
+ verify(socket).exceptionHandler(exceptionCaptor.capture());
+
+ closeCaptor.getValue().handle(null);
+ exceptionCaptor.getValue().handle(new IllegalStateException("already closed"));
+
+ verify(webSocket).close();
+ verify(webSocket, never()).close(anyShort(), anyString());
+ }
+
+ @Test
+ void brokerExceptionAndCloseCloseWebSocketOnlyOnce() {
+ ServerWebSocket webSocket = mock(ServerWebSocket.class);
+ NetSocket socket = mock(NetSocket.class);
+ when(webSocket.isClosed()).thenReturn(false);
+
+ IotMqttWebSocketBridge.BridgeSession session =
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket);
+ session.start();
+
+ ArgumentCaptor<Handler<Void>> closeCaptor = ArgumentCaptor.forClass(Handler.class);
+ verify(socket).closeHandler(closeCaptor.capture());
+ ArgumentCaptor<Handler<Throwable>> exceptionCaptor = ArgumentCaptor.forClass(Handler.class);
+ verify(socket).exceptionHandler(exceptionCaptor.capture());
+
+ exceptionCaptor.getValue().handle(new IllegalStateException("already closed"));
+ closeCaptor.getValue().handle(null);
+
+ verify(webSocket).close(anyShort(), anyString());
+ verify(webSocket, never()).close();
+ }
+
+ @Test
+ void webSocketExceptionAndCloseCloseBrokerSocketOnlyOnce() {
+ ServerWebSocket webSocket = mock(ServerWebSocket.class);
+ NetSocket socket = mock(NetSocket.class);
+ when(webSocket.isClosed()).thenReturn(false);
+
+ IotMqttWebSocketBridge.BridgeSession session =
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket);
+ session.start();
+
+ ArgumentCaptor<Handler<Throwable>> exceptionCaptor = ArgumentCaptor.forClass(Handler.class);
+ verify(webSocket).exceptionHandler(exceptionCaptor.capture());
+ ArgumentCaptor<Handler<Void>> closeCaptor = ArgumentCaptor.forClass(Handler.class);
+ verify(webSocket).closeHandler(closeCaptor.capture());
+
+ exceptionCaptor.getValue().handle(new IllegalStateException("ws error"));
+ closeCaptor.getValue().handle(null);
+
+ verify(socket).close();
+ verify(webSocket).close((short) 1011, "MQTT WebSocket failed");
+ verify(webSocket, never()).close();
+ }
+
+ @Test
+ void webSocketCloseAndExceptionCloseBrokerSocketOnlyOnce() {
+ ServerWebSocket webSocket = mock(ServerWebSocket.class);
+ NetSocket socket = mock(NetSocket.class);
+ when(webSocket.isClosed()).thenReturn(false);
+
+ IotMqttWebSocketBridge.BridgeSession session =
+ new IotMqttWebSocketBridge.BridgeSession(webSocket, socket);
+ session.start();
+
+ ArgumentCaptor<Handler<Void>> closeCaptor = ArgumentCaptor.forClass(Handler.class);
+ verify(webSocket).closeHandler(closeCaptor.capture());
+ ArgumentCaptor<Handler<Throwable>> exceptionCaptor = ArgumentCaptor.forClass(Handler.class);
+ verify(webSocket).exceptionHandler(exceptionCaptor.capture());
+
+ closeCaptor.getValue().handle(null);
+ exceptionCaptor.getValue().handle(new IllegalStateException("ws error"));
+
+ verify(socket).close();
+ verify(webSocket, never()).close();
+ verify(webSocket, never()).close(anyShort(), anyString());
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketIntegrationTest.java
index 94fd2303c0..2720d69a79 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotMqttWebSocketIntegrationTest.java
@@ -38,6 +38,7 @@ import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
@@ -270,20 +271,19 @@ public class IotMqttWebSocketIntegrationTest {
String topic = "ws/fanout/" + System.nanoTime();
byte[] payload = "to everyone".getBytes(StandardCharsets.UTF_8);
int clients = 16;
- List<WsClient> subscribers = new ArrayList<>();
+ List<WsClient> subscribers = new CopyOnWriteArrayList<>();
+ List<Thread> threads = new ArrayList<>();
try {
CountDownLatch connected = new CountDownLatch(clients);
- List<Thread> threads = new ArrayList<>();
- List<Throwable> failures = new java.util.concurrent.CopyOnWriteArrayList<>();
+ List<Throwable> failures = new CopyOnWriteArrayList<>();
for (int i = 0; i < clients; i++) {
String clientId = "ws-fanout-" + i + "-" + System.nanoTime();
Thread thread = new Thread(() -> {
+ WsClient subscriber = null;
try {
- WsClient subscriber = WsClient.connect(ws("/mqtt"), clientId, null, null);
+ subscriber = WsClient.connect(ws("/mqtt"), clientId, null, null);
+ subscribers.add(subscriber);
subscriber.subscribe(topic);
- synchronized (subscribers) {
- subscribers.add(subscriber);
- }
} catch (Exception e) {
failures.add(e);
} finally {
@@ -304,8 +304,23 @@ public class IotMqttWebSocketIntegrationTest {
assertArrayEquals(payload, subscriber.takePayload());
}
} finally {
+ for (Thread thread : threads) {
+ thread.interrupt();
+ }
+ for (Thread thread : threads) {
+ try {
+ thread.join(1000);
+ } catch (InterruptedException ignored) {
+ // Safe to ignore during teardown; restore interrupt status for the calling thread.
+ Thread.currentThread().interrupt();
+ }
+ }
for (WsClient subscriber : subscribers) {
- subscriber.close();
+ try {
+ subscriber.close();
+ } catch (Exception ignored) {
+ // Safe to ignore teardown close errors on partially-connected or already closed clients.
+ }
}
}
}
@@ -418,6 +433,7 @@ public class IotMqttWebSocketIntegrationTest {
MqttConnectOptions options = new MqttConnectOptions();
options.setCleanSession(true);
options.setConnectionTimeout(10);
+ options.setMqttVersion(MqttConnectOptions.MQTT_VERSION_3_1_1);
if (url.startsWith("wss://")) {
options.setSocketFactory(trustOnlyFlociCa().getSocketFactory());
}