redrays-io/ws_racecondition_pocPoC simples para demonstrar Race Conditions em Websockets
No campo da tecnologia da informação, garantir a confiabilidade e a integridade dos dados é crucial, especialmente com milhões de usuários e terabytes de dados envolvidos. No entanto, à medida que os sistemas de software se tornam mais complexos, problemas como condições de corrida podem surgir, impactando significativamente a operação do sistema e levando a resultados imprevisíveis.
Condições de corrida são erros que ocorrem em programas multitarefa quando duas ou mais threads ou processos tentam modificar dados ou recursos compartilhados simultaneamente sem sincronização. Isso pode resultar em resultados inesperados e imprevisíveis, uma vez que a ordem de execução das operações depende de quais threads ou processos terminam primeiro. Detectar condições de corrida é um problema desafiador em sistemas de software devido à sua natureza imprevisível.
Embora existam inúmeros recursos disponíveis sobre condições de corrida clássicas na internet, este artigo explora se condições de corrida podem ocorrer em WebSockets.
WebSockets são uma tecnologia de ponta que melhora significativamente a interação em aplicações web, proporcionando uma conexão bidirecional aberta entre o navegador web do usuário e um servidor web. Essa conexão contínua permite a troca de dados sem a necessidade de iniciar constantemente novas requisições HTTP, tornando-os ideais para criar aplicações interativas.
Para demonstrar o conceito, este artigo inclui um código Java que representa um servidor WebSocket que interage com um banco de dados PostgreSQL. O servidor usa a biblioteca Java-WebSocket para lidar com conexões WebSocket e executa as seguintes tarefas:
Após iniciar o programa, o código Java se conecta ao banco de dados e verifica se a tabela "example" existe. Se não existir, ele cria a tabela e insere dados aleatórios:
O código mais interessante está na função "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);
}
}
Há uma variável global "a" inicializada com 0. Quando um cliente se conecta ao servidor e envia uma mensagem, ele verifica se "id == 0", indicando se essa função já foi executada. Se não, um comando SQL simples é executado para selecionar a contagem de linhas da tabela "example". Em seguida, "a" é incrementado em 1, e seu valor é impresso. E, em teoria, a função não deveria ser executada 2 vezes.
Em relação ao cliente, dois tipos de clientes foram criados: "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
try {
WebSocketClient webSocketClient = new WebSocketClient(new URI(serverUri)) {