redrays-io/ws_racecondition_pocEinfacher PoC zur Demonstration von Race Conditions bei Websockets
Im Bereich der Informationstechnologie ist die Gewährleistung von Datenzuverlässigkeit und -integrität von entscheidender Bedeutung, insbesondere wenn Millionen von Nutzern und Terabytes an Daten im Spiel sind. Da Softwaresysteme jedoch immer komplexer werden, können Probleme wie Race Conditions auftreten, die den Systembetrieb erheblich beeinträchtigen und zu unvorhersehbaren Ergebnissen führen können.
Race Conditions sind Fehler, die in Multitasking-Programmen auftreten, wenn zwei oder mehr Threads oder Prozesse versuchen, gemeinsam genutzte Daten oder Ressourcen gleichzeitig ohne Synchronisation zu verändern. Dies kann zu unerwarteten und unvorhersehbaren Ergebnissen führen, da die Ausführungsreihenfolge der Operationen davon abhängt, welche Threads oder Prozesse zuerst fertig werden. Die Erkennung von Race Conditions ist aufgrund ihrer unvorhersehbaren Natur eine anspruchsvolle Aufgabe in Softwaresystemen.
Während im Internet zahlreiche Ressourcen über klassische Race Conditions verfügbar sind, untersucht dieser Artikel, ob Race Conditions in WebSockets auftreten können.
WebSockets sind eine hochmoderne Technologie, die die Interaktion in Webanwendungen erheblich verbessert, indem sie eine offene bidirektionale Verbindung zwischen dem Webbrowser eines Nutzers und einem Webserver bereitstellt. Diese nahtlose Verbindung ermöglicht den Datenaustausch, ohne dass ständig neue HTTP-Anfragen initiiert werden müssen, was sie ideal für die Erstellung interaktiver Anwendungen macht.
Um das Konzept zu demonstrieren, enthält dieser Artikel einen Java-Code, der einen WebSocket-Server darstellt, der mit einer PostgreSQL-Datenbank interagiert. Der Server verwendet die Java-WebSocket-Bibliothek, um WebSocket-Verbindungen zu verwalten, und führt die folgenden Aufgaben aus:
Nach dem Start des Programms verbindet sich der Java-Code mit der Datenbank und prüft, ob die Tabelle „example" existiert. Falls nicht, erstellt er die Tabelle und fügt Zufallsdaten ein:
Der interessanteste Code befindet sich in der Funktion „onMessage".
public static int a = 0;
@Override
public void onMessage(WebSocket conn, String message) {
if (a == 0) {
try {
// some activity with db
int rowCount = getCountFromExampleTable();
} catch (SQLException e) {
System.out.println("Error executing query: " + e.getMessage());
}
conn.send("Echo: " + message);
a = a + 1;
System.out.println(a);
}
}
Es gibt eine globale Variable „a", die mit 0 initialisiert wird. Wenn ein Client sich mit dem Server verbindet und eine Nachricht sendet, wird geprüft, ob „id == 0", was anzeigt, ob diese Funktion bereits ausgeführt wurde. Falls nicht, wird ein einfacher SQL-Befehl ausgeführt, um die Anzahl der Zeilen aus der Tabelle „example" auszuwählen. Dann wird „a" um 1 erhöht und sein Wert ausgegeben. Und theoretisch sollte die Funktion nicht zweimal ausgeführt werden.
Bezüglich des Clients wurden zwei Arten von Clients erstellt: „WebSocketParallel_Success"
package io.redrays.ws.concept.client;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class WebSocketParallel_Success {
public static void main(String[] args) {
// Define the WebSocket server URI
String serverUri = "ws://127.0.0.1:8080";
// Number of WebSocket clients to create
int numClients = 100;
// Create an ExecutorService to manage multiple WebSocket client threads
ExecutorService executor = Executors.newFixedThreadPool(numClients);
// Create a list to store WebSocket client instances
List<WebSocketClient> clients = new ArrayList<>();
// Loop to create and configure multiple WebSocket clients
for (int i = 0; i < numClients; i++) {
int clientId = i + 1;
try {
// Create a WebSocket client for each connection
WebSocketClient webSocketClient = new WebSocketClient(new URI(serverUri)) {
@Override
public void onOpen(ServerHandshake handshakedata) {
// Handle WebSocket connection opened event
System.out.println("Client " + clientId + " connected to the WebSocket server");
this.send("Hello, WebSocket server! From client " + clientId);
}
@Override
public void onMessage(String message) {
// Handle incoming WebSocket messages
System.out.println("Client " + clientId + " received message: " + message);
}
@Override
public void onClose(int code, String reason, boolean remote) {
// Handle WebSocket connection closed event
System.out.println("Client " + clientId + " connection closed: " + reason);
}
@Override
public void onError(Exception ex) {
// Handle WebSocket error
System.out.println("Client " + clientId + " error occurred: " + ex.getMessage());
}
};
// Add the WebSocket client to the list
clients.add(webSocketClient);
// Connect the WebSocket client in a separate thread
executor.submit(webSocketClient::connect);
} catch (URISyntaxException e) {
System.out.println("Invalid WebSocket server URI: " + e.getMessage());
}
}
// Shutdown the executor after all tasks are submitted
executor.shutdown();
// Wait for all WebSocket client threads to complete
try {
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
} catch (InterruptedException e) {
System.out.println("Interrupted while waiting for tasks to complete: " + e.getMessage());
}
}
}
und „WebSocketParallel_Failed".
package io.redrays.ws.concept.client;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class WebSocketParallel_Failed {