WS_RaceCondition_PoC

Race Conditions nei WebSockets

Nel campo dell'informatica, garantire l'affidabilità e l'integrità dei dati è cruciale, specialmente con milioni di utenti e terabyte di dati in gioco. Tuttavia, man mano che i sistemi software diventano più complessi, possono emergere problemi come le race condition, che impattano significativamente sul funzionamento del sistema e portano a risultati imprevedibili.

Cosa sono le race condition?

Le race condition sono errori che si verificano nei programmi multitasking quando due o più thread o processi tentano di modificare dati o risorse condivise simultaneamente senza sincronizzazione. Ciò può causare risultati inaspettati e imprevedibili poiché l'ordine di esecuzione delle operazioni dipende da quali thread o processi terminano per primi. Rilevare le race condition è una sfida complessa nei sistemi software a causa della loro natura imprevedibile.

Fonti e ulteriori letture:

• "Race Condition" su Wikipedia
• "Smashing the State Machine: the True Potential of Web Race Conditions" di James Kettle

Sebbene esistano numerose risorse disponibili su internet riguardo alle race condition classiche, questo articolo esplora se le race condition possono verificarsi nei WebSockets.

WebSockets

I WebSockets sono una tecnologia all'avanguardia che migliora significativamente l'interazione nelle applicazioni web fornendo una connessione bidirezionale aperta tra il browser web dell'utente e un server web. Questa connessione continua consente lo scambio di dati senza la necessità di avviare costantemente nuove richieste HTTP, rendendoli ideali per creare applicazioni interattive.

Vantaggi dei WebSockets:

1. Bassa latenza: i WebSockets minimizzano i ritardi nello scambio di dati, rendendoli una scelta eccellente per applicazioni in cui il tempo reale è importante, come giochi online o applicazioni di chat.
2. Efficienza delle risorse: i WebSockets supportano una connessione persistente, riducendo il sovraccarico associato all'instaurazione e alla chiusura delle connessioni rispetto a numerose richieste HTTP consecutive.
3. Scambio di dati bidirezionale: sia il client che il server possono inviare dati l'uno all'altro senza attendere una richiesta, rendendo i WebSockets uno strumento eccellente per creare applicazioni web interattive.
4. Compatibilità: i WebSockets possono essere utilizzati in vari linguaggi di programmazione e tecnologie, rendendoli uno strumento universale per creare applicazioni web interattive.

Per dimostrare il concetto, questo articolo include un codice Java che rappresenta un server WebSocket che interagisce con un database PostgreSQL. Il server utilizza la libreria Java-WebSocket per gestire le connessioni WebSocket e svolge le seguenti attività:

1. Dopo l'avvio del programma, il codice Java si connette al database e verifica se la tabella "example" esiste. Se non esiste, crea la tabella e inserisce dati casuali:

   • RandomName0
   • RandomName1
   • ...
   • RandomName9

2. Il codice più interessante si trova nella funzione "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);
    }
}

C'è una variabile globale "a" inizializzata a 0. Quando un client si connette al server e invia un messaggio, viene verificato se "id == 0", indicando se questa funzione è già stata eseguita. In caso negativo, viene eseguito un semplice comando SQL per selezionare il conteggio delle righe dalla tabella "example". Poi, "a" viene incrementato di 1 e il suo valore viene stampato. E in teoria, la funzione non dovrebbe essere eseguita 2 volte.

Per quanto riguarda il client, sono stati creati due tipi di client: "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());
        }
    }
}

e "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 {

    public static void main(String[] args) {
        String serverUri = "ws://127.0.0.1:8080"; // WebSocket server URI
        int numParallelRequests = 285; // Number of parallel WebSocket requests