mirror of
https://github.com/davidalves04/Trabalho-Pratico-SD.git
synced 2025-12-08 20:43:32 +00:00
Compare commits
1 Commits
10-create-
...
dash_test
| Author | SHA1 | Date | |
|---|---|---|---|
| 128e2e2366 |
61
.github/workflows/maven.yml
vendored
61
.github/workflows/maven.yml
vendored
@@ -1,61 +0,0 @@
|
||||
name: Java CI with Maven
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [ "main" ]
|
||||
tags:
|
||||
- 'v*.*.*'
|
||||
pull_request:
|
||||
branches: [ "main" ]
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Set up JDK 17
|
||||
uses: actions/setup-java@v4
|
||||
with:
|
||||
java-version: '17'
|
||||
distribution: 'temurin'
|
||||
cache: maven
|
||||
|
||||
- name: Build with Maven
|
||||
run: mvn -B package
|
||||
working-directory: main
|
||||
|
||||
- name: Upload built JAR
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: package
|
||||
path: main/target/*.jar
|
||||
|
||||
- name: Generate dependency graph
|
||||
run: mvn -B -f main/pom.xml com.github.ferstl:depgraph-maven-plugin:4.0.1:graph
|
||||
|
||||
- name: Upload dependency graph artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: dependency-graph
|
||||
path: main/target/**
|
||||
|
||||
publish-release:
|
||||
runs-on: ubuntu-latest
|
||||
needs: [build]
|
||||
if: startsWith(github.ref, 'refs/tags/')
|
||||
permissions:
|
||||
contents: write
|
||||
|
||||
steps:
|
||||
- name: Download built JAR
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: package
|
||||
path: main/target/
|
||||
|
||||
- name: Create GitHub Release
|
||||
uses: softprops/action-gh-release@v2
|
||||
with:
|
||||
files: main/target/*.jar
|
||||
2
.gitignore
vendored
2
.gitignore
vendored
@@ -47,4 +47,4 @@ build/
|
||||
|
||||
# Other
|
||||
*.swp
|
||||
*.pdf
|
||||
*.pdf
|
||||
620
README.md
620
README.md
@@ -1,620 +0,0 @@
|
||||
# Sistema de Simulação de Tráfego Distribuído
|
||||
|
||||
Sistema distribuído de simulação de tráfego.
|
||||
---
|
||||
|
||||
## Índice
|
||||
|
||||
- [Visão Geral](#visão-geral)
|
||||
- [Arquitetura](#arquitetura)
|
||||
- [Protocolo de Comunicação](#protocolo-de-comunicação)
|
||||
- [Estrutura do Projeto](#estrutura-do-projeto)
|
||||
- [Instalação e Execução](#instalação-e-execução)
|
||||
- [Documentação](#documentação)
|
||||
- [Desenvolvimento](#desenvolvimento)
|
||||
|
||||
---
|
||||
|
||||
## Visão Geral
|
||||
|
||||
Este projeto implementa uma simulação distribuída de tráfego veicular numa rede de cruzamentos. O sistema utiliza:
|
||||
|
||||
- **Processos independentes** para cada cruzamento
|
||||
- **Threads** para controlar os semáforos dentro de cada cruzamento
|
||||
- **Comunicação via sockets** para transferência de veículos entre cruzamentos
|
||||
- **Simulação de eventos discretos** (DES) para gerir o tempo de simulação
|
||||
|
||||
### Características Principais
|
||||
|
||||
- Simulação determinística e reproduzível
|
||||
- Comunicação assíncrona entre processos
|
||||
- Protocolo de mensagens baseado em JSON
|
||||
- Dashboard em tempo real (planeado)
|
||||
- Estatísticas detalhadas de desempenho
|
||||
|
||||
---
|
||||
|
||||
## Arquitetura
|
||||
|
||||
### Visão Geral do Sistema
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────────┐
|
||||
│ SISTEMA DISTRIBUÍDO │
|
||||
├─────────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ ┌──────────────┐ ┌──────────────┐ │
|
||||
│ │ Coordenador │ ────────────────────────>│ Dashboard │ │
|
||||
│ │ / Gerador │ │ │
|
||||
│ └──────┬───────┘ └──────▲───────┘ │
|
||||
│ │ │ │
|
||||
│ │ Gera veículos Stats │ │
|
||||
│ │ │ │
|
||||
│ ▼ │ │
|
||||
│ ┌─────────────────────────────────────────────────┴──────┐ │
|
||||
│ │ Rede de Cruzamentos (Processos) │ │
|
||||
│ │ │ │
|
||||
│ │ ┌────┐ ┌────┐ ┌────┐ │ │
|
||||
│ │ │Cr1 │◄───────►│Cr2 │◄───────►│Cr3 │ │ │
|
||||
│ │ └─┬──┘ └─┬──┘ └─┬──┘ │ │
|
||||
│ │ │ │ │ │ │
|
||||
│ │ │ ┌────▼────┐ │ │ │
|
||||
│ │ └────────►│ Cr4 │◄────────┘ │ │
|
||||
│ │ └────┬────┘ │ │
|
||||
│ │ │ │ │
|
||||
│ │ ┌────▼────┐ │ │
|
||||
│ │ │ Cr5 │ │ │
|
||||
│ │ └────┬────┘ │ │
|
||||
│ └───────────────────┼─────────────────────────────────────┤ │
|
||||
│ │ │ │
|
||||
│ ▼ │ │
|
||||
│ ┌──────────────┐ │ │
|
||||
│ │ Nó de Saída │ │ │
|
||||
│ │ (S) │ │ │
|
||||
│ └──────────────┘ │ │
|
||||
│ │ │
|
||||
└────────────────────────────────────────────────────────────┘ │
|
||||
```
|
||||
|
||||
### Componentes
|
||||
|
||||
1. **Coordenador/Gerador**: Gera veículos e injeta no sistema
|
||||
2. **Cruzamentos (Cr1-Cr5)**: Processos independentes que gerem tráfego local
|
||||
3. **Nó de Saída (S)**: Recolhe estatísticas de veículos que saem do sistema
|
||||
4. **Dashboard Server**: Agrega e exibe dados em tempo real
|
||||
|
||||
---
|
||||
|
||||
## Protocolo de Comunicação
|
||||
|
||||
### Formato de Serialização: JSON (Gson)
|
||||
|
||||
O sistema utiliza JSON como formato de serialização por ser mais rápido, seguro e legível que a serialização em Java.
|
||||
|
||||
### Estrutura de Mensagens
|
||||
|
||||
Todas as mensagens seguem o formato base:
|
||||
|
||||
```json
|
||||
{
|
||||
"messageId": "uuid",
|
||||
"type": "MESSAGE_TYPE",
|
||||
"senderId": "sender_id",
|
||||
"destinationId": "destination_id",
|
||||
"timestamp": 1729595234567,
|
||||
"payload": { ... }
|
||||
}
|
||||
```
|
||||
|
||||
### Tipos de Mensagens
|
||||
|
||||
#### 1. VEHICLE_TRANSFER
|
||||
|
||||
Transfere um veículo entre cruzamentos.
|
||||
|
||||
**Estrutura:**
|
||||
```json
|
||||
{
|
||||
"messageId": "a3c5e7f9-1234-5678-90ab-cdef12345678",
|
||||
"type": "VEHICLE_TRANSFER",
|
||||
"senderId": "Cr1",
|
||||
"destinationId": "Cr2",
|
||||
"timestamp": 1729595234567,
|
||||
"payload": {
|
||||
"id": "V123",
|
||||
"type": "LIGHT",
|
||||
"entryTime": 15.7,
|
||||
"route": ["Cr1", "Cr2", "Cr5", "S"],
|
||||
"currentRouteIndex": 1,
|
||||
"totalWaitingTime": 3.2,
|
||||
"totalCrossingTime": 1.8
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Fluxo:**
|
||||
1. Veículo completa travessia no Cr1
|
||||
2. Cr1 serializa mensagem VEHICLE_TRANSFER
|
||||
3. Envia para Cr2 via socket
|
||||
4. Cr2 desserializa e adiciona veículo à fila
|
||||
|
||||
#### 2. STATS_UPDATE
|
||||
|
||||
Envia estatísticas de um cruzamento para o Dashboard.
|
||||
|
||||
**Estrutura:**
|
||||
```json
|
||||
{
|
||||
"messageId": "b4d6e8f0-2345-6789-01bc-def123456789",
|
||||
"type": "STATS_UPDATE",
|
||||
"senderId": "Cr3",
|
||||
"destinationId": "Dashboard",
|
||||
"timestamp": 1729595234789,
|
||||
"payload": {
|
||||
"intersectionId": "Cr3",
|
||||
"queueLengths": {
|
||||
"North": 5,
|
||||
"South": 3,
|
||||
"East": 7,
|
||||
"West": 2
|
||||
},
|
||||
"vehiclesProcessed": 142,
|
||||
"averageWaitTime": 4.5,
|
||||
"currentTime": 123.45
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Frequência:** A cada 10 segundos (configurável)
|
||||
|
||||
#### 3. VEHICLE_EXIT
|
||||
|
||||
Notifica quando um veículo sai do sistema.
|
||||
|
||||
**Estrutura:**
|
||||
```json
|
||||
{
|
||||
"messageId": "c5e7f9a1-3456-7890-12bc-def123456789",
|
||||
"type": "VEHICLE_EXIT",
|
||||
"senderId": "Cr5",
|
||||
"destinationId": "ExitNode",
|
||||
"timestamp": 1729595234890,
|
||||
"payload": {
|
||||
"id": "V123",
|
||||
"type": "LIGHT",
|
||||
"entryTime": 15.7,
|
||||
"exitTime": 45.2,
|
||||
"totalSystemTime": 29.5,
|
||||
"totalWaitingTime": 8.3,
|
||||
"totalCrossingTime": 4.8,
|
||||
"routeTaken": ["Cr1", "Cr2", "Cr5", "S"]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### 4. HEARTBEAT
|
||||
|
||||
Mantém a ligação ativa e monitoriza a saúde dos processos.
|
||||
|
||||
**Estrutura:**
|
||||
```json
|
||||
{
|
||||
"messageId": "d6e8f0a2-4567-8901-23cd-ef1234567890",
|
||||
"type": "HEARTBEAT",
|
||||
"senderId": "Cr1",
|
||||
"destinationId": "Coordinator",
|
||||
"timestamp": 1729595235000,
|
||||
"payload": {
|
||||
"status": "RUNNING",
|
||||
"uptime": 120.5,
|
||||
"vehiclesInQueue": 12
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Frequência:** A cada 5 segundos
|
||||
|
||||
#### 5. LIGHT_CHANGE
|
||||
|
||||
Notifica mudança de estado de semáforo (para logging/debugging).
|
||||
|
||||
**Estrutura:**
|
||||
```json
|
||||
{
|
||||
"messageId": "e7f9a1b3-5678-9012-34de-f12345678901",
|
||||
"type": "LIGHT_CHANGE",
|
||||
"senderId": "Cr1-North",
|
||||
"destinationId": "Dashboard",
|
||||
"timestamp": 1729595235100,
|
||||
"payload": {
|
||||
"lightId": "Cr1-North",
|
||||
"previousState": "RED",
|
||||
"newState": "GREEN",
|
||||
"queueSize": 5
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Tipos de Veículos
|
||||
|
||||
```json
|
||||
{
|
||||
"BIKE": {
|
||||
"probability": 0.20,
|
||||
"crossingTime": 1.5
|
||||
},
|
||||
"LIGHT": {
|
||||
"probability": 0.60,
|
||||
"crossingTime": 2.0
|
||||
},
|
||||
"HEAVY": {
|
||||
"probability": 0.20,
|
||||
"crossingTime": 4.0
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Estados dos Semáforos
|
||||
|
||||
```
|
||||
RED → Veículos aguardam na fila
|
||||
GREEN → Veículos podem atravessar
|
||||
```
|
||||
|
||||
### Exemplo de Comunicação Completa
|
||||
|
||||
```
|
||||
Tempo Processo Ação Mensagem
|
||||
------ --------- ------------------------------------- ------------------
|
||||
15.7s Gerador Gera veículo V123 -
|
||||
15.7s Gerador → Injeta V123 em Cr1 VEHICLE_TRANSFER
|
||||
18.2s Cr1 V123 inicia travessia -
|
||||
20.2s Cr1 V123 completa travessia -
|
||||
20.2s Cr1 → Cr2 Transfere V123 para Cr2 VEHICLE_TRANSFER
|
||||
23.5s Cr2 V123 inicia travessia -
|
||||
25.5s Cr2 V123 completa travessia -
|
||||
25.5s Cr2 → Cr5 Transfere V123 para Cr5 VEHICLE_TRANSFER
|
||||
28.0s Cr5 V123 inicia travessia -
|
||||
30.0s Cr5 V123 completa travessia -
|
||||
30.0s Cr5 → Exit V123 sai do sistema VEHICLE_EXIT
|
||||
30.0s Exit → Dash Estatísticas de V123 STATS_UPDATE
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Estrutura do Projeto
|
||||
|
||||
```
|
||||
Trabalho-Pratico-SD/
|
||||
├── README.md # Este ficheiro
|
||||
├── TODO.md # Plano de desenvolvimento
|
||||
├── main/
|
||||
│ ├── pom.xml # Configuração do Maven
|
||||
│ ├── docs/
|
||||
│ │ ├── README.md # Índice da documentação
|
||||
│ │ ├── SERIALIZATION_SPECIFICATION.md
|
||||
│ │ ├── SERIALIZATION_DECISION.md
|
||||
│ │ ├── SERIALIZATION_SUMMARY.md
|
||||
│ │ └── SERIALIZATION_ARCHITECTURE.md
|
||||
│ ├── src/
|
||||
│ │ ├── main/java/sd/
|
||||
│ │ │ ├── Entry.java # Ponto de entrada
|
||||
│ │ │ ├── config/
|
||||
│ │ │ │ └── SimulationConfig.java
|
||||
│ │ │ ├── engine/
|
||||
│ │ │ │ └── SimulationEngine.java
|
||||
│ │ │ ├── model/
|
||||
│ │ │ │ ├── Event.java
|
||||
│ │ │ │ ├── EventType.java
|
||||
│ │ │ │ ├── Intersection.java
|
||||
│ │ │ │ ├── Message.java # Estrutura de mensagens
|
||||
│ │ │ │ ├── MessageType.java # Tipos de mensagens
|
||||
│ │ │ │ ├── TrafficLight.java
|
||||
│ │ │ │ ├── Vehicle.java
|
||||
│ │ │ │ └── VehicleType.java
|
||||
│ │ │ ├── serialization/ # Sistema de serialização
|
||||
│ │ │ │ ├── MessageSerializer.java
|
||||
│ │ │ │ ├── SerializationException.java
|
||||
│ │ │ │ ├── JsonMessageSerializer.java
|
||||
│ │ │ │ ├── SerializerFactory.java
|
||||
│ │ │ │ ├── SerializationExample.java
|
||||
│ │ │ │ └── README.md
|
||||
│ │ │ └── util/
|
||||
│ │ │ ├── RandomGenerator.java
|
||||
│ │ │ ├── StatisticsCollector.java
|
||||
│ │ │ └── VehicleGenerator.java
|
||||
│ │ └── test/java/
|
||||
│ │ ├── SimulationTest.java
|
||||
│ │ └── sd/serialization/
|
||||
│ │ └── SerializationTest.java
|
||||
│ └── target/ # Ficheiros compilados
|
||||
└── .vscode/ # Configuração do VS Code
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Instalação e Execução
|
||||
|
||||
### Pré-requisitos
|
||||
|
||||
- **Java 17** ou superior
|
||||
- **Maven 3.8+**
|
||||
- **Git**
|
||||
|
||||
### Instalação
|
||||
|
||||
```bash
|
||||
# Clonar o repositório
|
||||
git clone https://github.com/davidalves04/Trabalho-Pratico-SD.git
|
||||
cd Trabalho-Pratico-SD/main
|
||||
|
||||
# Compilar o projeto
|
||||
mvn clean compile
|
||||
|
||||
# Executar os testes
|
||||
mvn test
|
||||
```
|
||||
|
||||
### Execução
|
||||
|
||||
#### Simulação Básica (Single Process)
|
||||
|
||||
```bash
|
||||
mvn exec:java -Dexec.mainClass="sd.Entry"
|
||||
```
|
||||
|
||||
#### Exemplo de Serialização
|
||||
|
||||
```bash
|
||||
mvn exec:java -Dexec.mainClass="sd.serialization.SerializationExample"
|
||||
```
|
||||
|
||||
#### Configuração
|
||||
|
||||
Editar `src/main/resources/simulation.properties`:
|
||||
|
||||
```properties
|
||||
# Duração da simulação (segundos)
|
||||
simulation.duration=60.0
|
||||
|
||||
# Modelo de chegada: FIXED ou POISSON
|
||||
arrival.model=POISSON
|
||||
|
||||
# Taxa de chegada (veículos/segundo)
|
||||
arrival.rate=0.5
|
||||
|
||||
# Intervalo de atualização de estatísticas (segundos)
|
||||
stats.update.interval=10.0
|
||||
|
||||
# Distribuição de tipos de veículos
|
||||
vehicle.type.bike.probability=0.20
|
||||
vehicle.type.light.probability=0.60
|
||||
vehicle.type.heavy.probability=0.20
|
||||
|
||||
# Tempos de travessia por tipo (segundos)
|
||||
vehicle.type.bike.crossing.time=1.5
|
||||
vehicle.type.light.crossing.time=2.0
|
||||
vehicle.type.heavy.crossing.time=4.0
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Documentação
|
||||
|
||||
### Documentação de Serialização
|
||||
|
||||
A documentação completa sobre o protocolo de serialização está disponível em:
|
||||
|
||||
- **[Índice Completo](./main/docs/README.md)** - Navegação da documentação
|
||||
- **[Especificação](./main/docs/SERIALIZATION_SPECIFICATION.md)** - Design detalhado
|
||||
- **[Guia de Decisão](./main/docs/SERIALIZATION_DECISION.md)** - Porquê JSON?
|
||||
- **[Resumo](./main/docs/SERIALIZATION_SUMMARY.md)** - Estado de implementação
|
||||
- **[Arquitetura](./main/docs/SERIALIZATION_ARCHITECTURE.md)** - Diagramas visuais
|
||||
|
||||
### Guias de Utilização
|
||||
|
||||
- **[Serialization README](./main/src/main/java/sd/serialization/README.md)** - Como utilizar os serializers
|
||||
|
||||
### Exemplos de Código
|
||||
|
||||
```java
|
||||
// Criar serializer
|
||||
MessageSerializer serializer = SerializerFactory.createDefault();
|
||||
|
||||
// Serializar mensagem
|
||||
Vehicle vehicle = new Vehicle("V123", VehicleType.LIGHT, 10.5, route);
|
||||
Message message = new Message(
|
||||
MessageType.VEHICLE_TRANSFER,
|
||||
"Cr1",
|
||||
"Cr2",
|
||||
vehicle
|
||||
);
|
||||
byte[] data = serializer.serialize(message);
|
||||
|
||||
// Enviar via socket
|
||||
outputStream.write(data);
|
||||
|
||||
// Receber e desserializar
|
||||
byte[] received = inputStream.readAllBytes();
|
||||
Message msg = serializer.deserialize(received, Message.class);
|
||||
Vehicle v = msg.getPayloadAs(Vehicle.class);
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Desenvolvimento
|
||||
|
||||
### Estado do Projeto
|
||||
|
||||
| Componente | Estado | Notas |
|
||||
|------------|--------|-------|
|
||||
| Modelo de Dados | Completo | Vehicle, Message, Event, etc. |
|
||||
| Simulação DES | Completo | Single-process funcional |
|
||||
| Serialização | Completo | JSON e Java implementados |
|
||||
| Testes | 14/14 | Suite de serialização |
|
||||
| Processos Distribuídos | Planeado | Próxima etapa |
|
||||
| Comunicação Sockets | Planeado | Em design |
|
||||
| Dashboard | Planeado | UI web |
|
||||
|
||||
### Roteiro de Desenvolvimento
|
||||
|
||||
#### Fase 1: Fundações (Concluído)
|
||||
- Modelação de classes
|
||||
- Simulação DES single-process
|
||||
- Design de protocolo de serialização
|
||||
- Implementação JSON/Java serialization
|
||||
- Testes unitários
|
||||
|
||||
#### Fase 2: Distribuição (Em Curso)
|
||||
- Implementar comunicação via sockets
|
||||
- Separar cruzamentos em processos
|
||||
- Implementar threads de semáforos
|
||||
- Testar comunicação entre processos
|
||||
|
||||
#### Fase 3: Dashboard e Monitorização
|
||||
- Dashboard server
|
||||
- UI web em tempo real
|
||||
- Visualização de estatísticas
|
||||
- Logs estruturados
|
||||
|
||||
#### Fase 4: Optimização e Análise
|
||||
- Testes de carga
|
||||
- Análise de diferentes políticas
|
||||
- Recolha de métricas
|
||||
- Relatório final
|
||||
|
||||
### Executar Testes
|
||||
|
||||
```bash
|
||||
# Todos os testes
|
||||
mvn test
|
||||
|
||||
# Apenas testes de serialização
|
||||
mvn test -Dtest=SerializationTest
|
||||
|
||||
# Com relatório de cobertura
|
||||
mvn test jacoco:report
|
||||
```
|
||||
|
||||
### Contribuir
|
||||
|
||||
1. Fork o projeto
|
||||
2. Criar uma branch para a funcionalidade (`git checkout -b feature/MinhaFuncionalidade`)
|
||||
3. Commit das alterações (`git commit -m 'Adiciona MinhaFuncionalidade'`)
|
||||
4. Push para a branch (`git push origin feature/MinhaFuncionalidade`)
|
||||
5. Abrir um Pull Request
|
||||
|
||||
---
|
||||
|
||||
## Métricas de Desempenho
|
||||
|
||||
### Serialização
|
||||
|
||||
| Formato | Tamanho | Latência | Throughput |
|
||||
|---------|---------|----------|------------|
|
||||
| JSON | 300 bytes | 40.79 μs | ~24k msgs/s |
|
||||
| Java | 657 bytes | 33.34 μs | ~30k msgs/s |
|
||||
|
||||
**Conclusão**: JSON é 54% menor com overhead desprezível (7 μs)
|
||||
|
||||
### Simulação
|
||||
|
||||
- **Veículos gerados/s**: ~0.5-1.0 (configurável)
|
||||
- **Throughput**: ~0.2 veículos/s (saída)
|
||||
- **Tempo de execução**: 140ms para 60s de simulação
|
||||
- **Overhead**: < 0.25% do tempo simulado
|
||||
|
||||
---
|
||||
|
||||
## Protocolo de Mensagens - Resumo
|
||||
|
||||
### Formato Base
|
||||
|
||||
```
|
||||
+------------------+
|
||||
| Message Header |
|
||||
|------------------|
|
||||
| messageId | UUID único
|
||||
| type | Enum MessageType
|
||||
| senderId | ID do processo remetente
|
||||
| destinationId | ID do processo destino (null = broadcast)
|
||||
| timestamp | Tempo de criação (ms)
|
||||
+------------------+
|
||||
| Payload |
|
||||
|------------------|
|
||||
| Object | Dados específicos do tipo de mensagem
|
||||
+------------------+
|
||||
```
|
||||
|
||||
### Serialização
|
||||
|
||||
- **Formato**: JSON (UTF-8)
|
||||
- **Biblioteca**: Gson 2.10.1
|
||||
- **Codificação**: UTF-8
|
||||
- **Compressão**: Opcional (gzip)
|
||||
|
||||
### Transporte
|
||||
|
||||
- **Protocolo**: TCP/IP
|
||||
- **Porta base**: 5000+ (configurável)
|
||||
- **Timeout**: 30s
|
||||
- **Keep-alive**: Heartbeat a cada 5s
|
||||
|
||||
---
|
||||
|
||||
## Segurança
|
||||
|
||||
### Considerações
|
||||
|
||||
1. **Validação de Mensagens**
|
||||
- Verificar tipos esperados
|
||||
- Validar intervalos de valores
|
||||
- Rejeitar mensagens malformadas
|
||||
|
||||
2. **Autenticação** (Planeado)
|
||||
- Autenticação baseada em token
|
||||
- Whitelist de processos
|
||||
|
||||
3. **Encriptação** (Opcional)
|
||||
- TLS/SSL para produção
|
||||
- Não necessário para ambiente de desenvolvimento local
|
||||
|
||||
---
|
||||
|
||||
## Licença
|
||||
|
||||
Este projeto é desenvolvido para fins académicos no âmbito da disciplina de Sistemas Distribuídos (SD) do Instituto Politécnico do Porto.
|
||||
|
||||
---
|
||||
|
||||
## Equipa
|
||||
|
||||
**Instituição**: Instituto Politécnico do Porto
|
||||
**Curso**: Sistemas Distribuídos
|
||||
**Ano Letivo**: 2025-2026 (1º Semestre)
|
||||
|
||||
---
|
||||
|
||||
## Suporte
|
||||
|
||||
Para questões ou problemas:
|
||||
|
||||
1. Consultar a [documentação](./main/docs/README.md)
|
||||
2. Ver [exemplos de código](./main/src/main/java/sd/serialization/SerializationExample.java)
|
||||
3. Executar testes: `mvn test`
|
||||
4. Abrir issue no GitHub
|
||||
|
||||
---
|
||||
|
||||
## Ligações Úteis
|
||||
|
||||
- [Documentação do Projeto](./main/docs/README.md)
|
||||
- [Plano de Desenvolvimento](./TODO.md)
|
||||
- [Especificação de Serialização](./main/docs/SERIALIZATION_SPECIFICATION.md)
|
||||
- [Guia de Serialização](./main/src/main/java/sd/serialization/README.md)
|
||||
|
||||
---
|
||||
|
||||
**Última actualização**: 23 de outubro de 2025
|
||||
**Versão**: 1.0.0
|
||||
**Estado**: Em Desenvolvimento Activo
|
||||
134
STEP2_SUMMARY.md
134
STEP2_SUMMARY.md
@@ -1,134 +0,0 @@
|
||||
# 🏁 Single-Process Prototype — Implementation Summary
|
||||
|
||||
**Status:** ✅ Complete
|
||||
**Date:** October 22, 2025
|
||||
**Branch:** `8-single-process-prototype`
|
||||
|
||||
---
|
||||
|
||||
## Overview
|
||||
|
||||
The single-process prototype implements a **discrete event simulation (DES)** of a 3×3 urban grid with five intersections, realistic vehicle behavior, and fully synchronized traffic lights. Everything runs under one process, laying the groundwork for the distributed architecture in Phase 3.
|
||||
|
||||
---
|
||||
|
||||
## Core Architecture
|
||||
|
||||
### **SimulationEngine**
|
||||
|
||||
Drives the DES loop with a priority queue of timestamped events — vehicles, lights, crossings, and periodic stats updates. Handles five intersections (Cr1–Cr5) and six event types.
|
||||
|
||||
**Main loop:**
|
||||
|
||||
```
|
||||
while (events && time < duration):
|
||||
event = nextEvent()
|
||||
time = event.timestamp
|
||||
handle(event)
|
||||
```
|
||||
|
||||
### **VehicleGenerator**
|
||||
|
||||
Spawns vehicles via:
|
||||
|
||||
* **Poisson arrivals** (λ = 0.5 veh/s) or fixed intervals
|
||||
* **Probabilistic routes** from E1–E3
|
||||
* **Type distribution**: 20% BIKE, 60% LIGHT, 20% HEAVY
|
||||
|
||||
### **StatisticsCollector**
|
||||
|
||||
Tracks system-wide and per-type metrics: throughput, avg. wait, queue sizes, light cycles — updated every 10 s and at simulation end.
|
||||
|
||||
---
|
||||
|
||||
## Model Highlights
|
||||
|
||||
* **Vehicle** – type, route, timings, lifecycle.
|
||||
* **Intersection** – routing tables, traffic lights, queues.
|
||||
* **TrafficLight** – red/green cycles with FIFO queues.
|
||||
* **Event** – timestamped, comparable; 6 types for all DES actions.
|
||||
|
||||
---
|
||||
|
||||
## Configuration (`simulation.properties`)
|
||||
|
||||
```properties
|
||||
simulation.duration=60.0
|
||||
simulation.arrival.model=POISSON
|
||||
simulation.arrival.rate=0.5
|
||||
|
||||
vehicle.bike.crossingTime=1.5
|
||||
vehicle.light.crossingTime=2.0
|
||||
vehicle.heavy.crossingTime=4.0
|
||||
|
||||
statistics.update.interval=10.0
|
||||
```
|
||||
|
||||
**Speed logic:**
|
||||
`t_bike = 0.5×t_car`, `t_heavy = 2×t_car`.
|
||||
|
||||
---
|
||||
|
||||
## Topology
|
||||
|
||||
```
|
||||
E1→Cr1→Cr4→Cr5→S
|
||||
E2→Cr2→Cr5→S
|
||||
E3→Cr3→S
|
||||
Bi-dir: Cr1↔Cr2, Cr2↔Cr3
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Results
|
||||
|
||||
**Unit Tests:** 7/7 ✅
|
||||
**60-Second Simulation:**
|
||||
|
||||
* Generated: 22 vehicles
|
||||
* Completed: 5 (22.7%)
|
||||
* Avg system time: 15.47 s
|
||||
* Throughput: 0.08 veh/s
|
||||
* All lights & intersections operational
|
||||
|
||||
**Performance:**
|
||||
~0.03 s real-time run (≈2000× speed-up), < 50 MB RAM.
|
||||
|
||||
---
|
||||
|
||||
## Code Structure
|
||||
|
||||
```
|
||||
sd/
|
||||
├── engine/SimulationEngine.java
|
||||
├── model/{Vehicle,Intersection,TrafficLight,Event}.java
|
||||
├── util/{VehicleGenerator,StatisticsCollector}.java
|
||||
└── config/SimulationConfig.java
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Key Flow
|
||||
|
||||
1. Initialize intersections, lights, first events.
|
||||
2. Process events chronologically.
|
||||
3. Vehicles follow routes → queue → cross → exit.
|
||||
4. Lights toggle, queues drain, stats update.
|
||||
5. Print summary and performance metrics.
|
||||
|
||||
---
|
||||
|
||||
## Next Steps — Phase 3
|
||||
|
||||
* Split intersections into independent **processes**.
|
||||
* Add **socket-based communication**.
|
||||
* Run **traffic lights as threads**.
|
||||
* Enable **distributed synchronization** and fault handling.
|
||||
|
||||
---
|
||||
|
||||
## TL;DR
|
||||
|
||||
Solid single-process DES ✅
|
||||
Everything’s working — traffic lights, routing, vehicles, stats.
|
||||
Ready to go distributed next.
|
||||
27
TODO.md
27
TODO.md
@@ -1,26 +1,3 @@
|
||||
## ✅ SINGLE-PROCESS PROTOTYPE - COMPLETED
|
||||
|
||||
### Phase 2 Status: DONE ✅
|
||||
|
||||
All components for the single-process prototype have been successfully implemented and tested:
|
||||
|
||||
- ✅ **SimulationEngine** - Priority queue-based discrete event simulation
|
||||
- ✅ **VehicleGenerator** - Poisson and Fixed arrival models
|
||||
- ✅ **StatisticsCollector** - Comprehensive metrics tracking
|
||||
- ✅ **Entry point** - Main simulation runner
|
||||
- ✅ **60s test simulation** - Successfully validated event processing and routing
|
||||
|
||||
### Test Results:
|
||||
- All 7 unit tests passing
|
||||
- 60-second simulation completed successfully
|
||||
- Generated 22 vehicles with 5 completing their routes
|
||||
- Traffic light state changes working correctly
|
||||
- Vehicle routing through intersections validated
|
||||
|
||||
---
|
||||
|
||||
## NEXT: Distributed Architecture Implementation
|
||||
|
||||
### Compreender os Conceitos Fundamentais
|
||||
|
||||
Primeiro, as tecnologias e paradigmas chave necessários para este projeto devem ser totalmente compreendidos.
|
||||
@@ -39,7 +16,7 @@ Primeiro, as tecnologias e paradigmas chave necessários para este projeto devem
|
||||
|
||||
- Uma **lista de eventos** central, frequentemente uma fila de prioridades, será necessária para armazenar eventos futuros, ordenados pelo seu timestamp. O ciclo principal da simulação retira o próximo evento da lista, processa-o e adiciona quaisquer novos eventos que resultem dele.
|
||||
|
||||
- **Processo de Poisson:** Para o modelo 'mais realista' de chegadas de veículos, é especificado um processo de Poisson. A principal conclusão é que o tempo _entre_ chegadas consecutivas de veículos segue uma **distribuição exponencial**. Em Java, este intervalo pode ser gerado usando `Math.log(1 - Math.random()) / -lambda`, onde `lambda` (λi) é a taxa de chegada especificada.
|
||||
- **Processo de Poisson:** Para o modelo "mais realista" de chegadas de veículos, é especificado um processo de Poisson. A principal conclusão é que o tempo _entre_ chegadas consecutivas de veículos segue uma **distribuição exponencial**. Em Java, este intervalo pode ser gerado usando `Math.log(1 - Math.random()) / -lambda`, onde `lambda` (λi) é a taxa de chegada especificada.
|
||||
|
||||
|
||||
---
|
||||
@@ -195,4 +172,4 @@ Assim que o sistema completo estiver a funcionar, as experiências exigidas pela
|
||||
|
||||
- **Debugging:** Debugging de sistemas distribuídos podem ser difíceis. Uma framework de logging (como Log4j 2 ou SLF4J) pode ser usada para registar eventos//alterações de estado nos diferentes processos.
|
||||
|
||||
- **Configuração:** Valores como endereços IP, números de porta ou parâmetros da simulação não devem ser "hardcoded". Um ficheiro de configuração (ex: um ficheiro `.properties` ou `.json`) torna a aplicação mais fácil de executar e testar.
|
||||
- **Configuração:** Valores como endereços IP, números de porta ou parâmetros da simulação não devem ser "hardcoded". Um ficheiro de configuração (ex: um ficheiro `.properties` ou `.json`) torna a aplicação mais fácil de executar e testar.
|
||||
41
main/pom.xml
41
main/pom.xml
@@ -22,47 +22,6 @@
|
||||
<version>5.10.0</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
|
||||
<!-- Gson for JSON serialization -->
|
||||
<dependency>
|
||||
<groupId>com.google.code.gson</groupId>
|
||||
<artifactId>gson</artifactId>
|
||||
<version>2.10.1</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
<plugins>
|
||||
<!-- Maven Exec Plugin for running examples -->
|
||||
<plugin>
|
||||
<groupId>org.codehaus.mojo</groupId>
|
||||
<artifactId>exec-maven-plugin</artifactId>
|
||||
<version>3.1.0</version>
|
||||
<configuration>
|
||||
<mainClass>sd.Entry</mainClass>
|
||||
</configuration>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-shade-plugin</artifactId>
|
||||
<version>3.5.2</version>
|
||||
<executions>
|
||||
<execution>
|
||||
<phase>package</phase>
|
||||
<goals>
|
||||
<goal>shade</goal>
|
||||
</goals>
|
||||
<configuration>
|
||||
<transformers>
|
||||
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
|
||||
<mainClass>sd.Entry</mainClass>
|
||||
</transformer>
|
||||
</transformers>
|
||||
</configuration>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
|
||||
</project>
|
||||
@@ -1,501 +0,0 @@
|
||||
package sd;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.ServerSocket;
|
||||
import java.net.Socket;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import sd.config.SimulationConfig;
|
||||
import sd.model.Intersection;
|
||||
import sd.model.MessageType;
|
||||
import sd.model.TrafficLight;
|
||||
import sd.model.TrafficLightState;
|
||||
import sd.model.Vehicle;
|
||||
import sd.protocol.MessageProtocol;
|
||||
import sd.protocol.SocketConnection;
|
||||
|
||||
/**
|
||||
* Main class for an Intersection Process in the distributed traffic simulation.
|
||||
* * Each IntersectionProcess runs as an independent Java application (JVM instance)
|
||||
* representing one of the five intersections (Cr1-Cr5) in the network.
|
||||
*/
|
||||
public class IntersectionProcess {
|
||||
|
||||
private final String intersectionId;
|
||||
|
||||
private final SimulationConfig config;
|
||||
|
||||
private final Intersection intersection;
|
||||
|
||||
private ServerSocket serverSocket;
|
||||
|
||||
private final Map<String, SocketConnection> outgoingConnections;
|
||||
|
||||
private final ExecutorService connectionHandlerPool;
|
||||
|
||||
private final ExecutorService trafficLightPool;
|
||||
|
||||
private volatile boolean running; //Quando uma thread escreve um valor volatile, todas as outras
|
||||
//threads veem a mudança imediatamente.
|
||||
|
||||
/**
|
||||
* Constructs a new IntersectionProcess.
|
||||
*
|
||||
* @param intersectionId The ID of this intersection (e.g., "Cr1").
|
||||
* @param configFilePath Path to the simulation.properties file.
|
||||
* @throws IOException If configuration cannot be loaded.
|
||||
*/
|
||||
public IntersectionProcess(String intersectionId, String configFilePath) throws IOException {
|
||||
this.intersectionId = intersectionId;
|
||||
this.config = new SimulationConfig(configFilePath);
|
||||
this.intersection = new Intersection(intersectionId);
|
||||
this.outgoingConnections = new HashMap<>();
|
||||
this.connectionHandlerPool = Executors.newCachedThreadPool();
|
||||
this.trafficLightPool = Executors.newFixedThreadPool(4); // Max 4 directions
|
||||
this.running = false;
|
||||
|
||||
System.out.println("=".repeat(60));
|
||||
System.out.println("INTERSECTION PROCESS: " + intersectionId);
|
||||
System.out.println("=".repeat(60));
|
||||
}
|
||||
|
||||
public void initialize() {
|
||||
System.out.println("\n[" + intersectionId + "] Initializing intersection...");
|
||||
|
||||
createTrafficLights();
|
||||
|
||||
configureRouting();
|
||||
|
||||
startTrafficLights();
|
||||
|
||||
System.out.println("[" + intersectionId + "] Initialization complete.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates traffic lights for this intersection based on its physical connections.
|
||||
* Each intersection has different number and directions of traffic lights
|
||||
* according to the network topology.
|
||||
*/
|
||||
private void createTrafficLights() {
|
||||
System.out.println("\n[" + intersectionId + "] Creating traffic lights...");
|
||||
|
||||
String[] directions = new String[0];
|
||||
switch (intersectionId) {
|
||||
case "Cr1":
|
||||
directions = new String[]{"East", "South"};
|
||||
break;
|
||||
case "Cr2":
|
||||
directions = new String[]{"West", "East", "South"};
|
||||
break;
|
||||
case "Cr3":
|
||||
directions = new String[]{"West", "South"};
|
||||
break;
|
||||
case "Cr4":
|
||||
directions = new String[]{"East"};
|
||||
break;
|
||||
case "Cr5":
|
||||
directions = new String[]{"East"};
|
||||
break;
|
||||
}
|
||||
|
||||
for (String direction : directions) {
|
||||
double greenTime = config.getTrafficLightGreenTime(intersectionId, direction);
|
||||
double redTime = config.getTrafficLightRedTime(intersectionId, direction);
|
||||
|
||||
TrafficLight light = new TrafficLight(
|
||||
intersectionId + "-" + direction,
|
||||
direction,
|
||||
greenTime,
|
||||
redTime
|
||||
);
|
||||
|
||||
intersection.addTrafficLight(light);
|
||||
System.out.println(" Created traffic light: " + direction +
|
||||
" (Green: " + greenTime + "s, Red: " + redTime + "s)");
|
||||
}
|
||||
}
|
||||
|
||||
private void configureRouting() {
|
||||
System.out.println("\n[" + intersectionId + "] Configuring routing...");
|
||||
|
||||
switch (intersectionId) {
|
||||
case "Cr1":
|
||||
intersection.configureRoute("Cr2", "East");
|
||||
intersection.configureRoute("Cr4", "South");
|
||||
break;
|
||||
|
||||
case "Cr2":
|
||||
intersection.configureRoute("Cr1", "West");
|
||||
intersection.configureRoute("Cr3", "East");
|
||||
intersection.configureRoute("Cr5", "South");
|
||||
break;
|
||||
|
||||
case "Cr3":
|
||||
intersection.configureRoute("Cr2", "West");
|
||||
intersection.configureRoute("S", "South");
|
||||
break;
|
||||
|
||||
case "Cr4":
|
||||
intersection.configureRoute("Cr5", "East");
|
||||
break;
|
||||
|
||||
case "Cr5":
|
||||
intersection.configureRoute("S", "East");
|
||||
break;
|
||||
|
||||
default:
|
||||
System.err.println(" Error: unknown intersection ID: " + intersectionId);
|
||||
}
|
||||
|
||||
System.out.println(" Routing configured.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts all traffic light threads.
|
||||
*/
|
||||
private void startTrafficLights() {
|
||||
System.out.println("\n[" + intersectionId + "] Starting traffic light threads...");
|
||||
|
||||
for (TrafficLight light : intersection.getTrafficLights()) {
|
||||
trafficLightPool.submit(() -> runTrafficLightCycle(light));
|
||||
System.out.println(" Started thread for: " + light.getDirection());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The main loop for a traffic light thread.
|
||||
* Continuously cycles between GREEN and RED states.
|
||||
*
|
||||
* @param light The traffic light to control.
|
||||
*/
|
||||
private void runTrafficLightCycle(TrafficLight light) {
|
||||
System.out.println("[" + light.getId() + "] Traffic light thread started.");
|
||||
|
||||
while (running) {
|
||||
try {
|
||||
// Green state
|
||||
light.changeState(TrafficLightState.GREEN);
|
||||
System.out.println("[" + light.getId() + "] State: GREEN");
|
||||
|
||||
// Process vehicles while green
|
||||
processGreenLight(light);
|
||||
|
||||
// Wait for green duration
|
||||
Thread.sleep((long) (light.getGreenTime() * 1000));
|
||||
|
||||
// RED state
|
||||
light.changeState(TrafficLightState.RED);
|
||||
System.out.println("[" + light.getId() + "] State: RED");
|
||||
|
||||
// Wait for red duration
|
||||
Thread.sleep((long) (light.getRedTime() * 1000));
|
||||
|
||||
} catch (InterruptedException e) {
|
||||
System.out.println("[" + light.getId() + "] Traffic light thread interrupted.");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
System.out.println("[" + light.getId() + "] Traffic light thread stopped.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes vehicles when a traffic light is GREEN.
|
||||
* Dequeues vehicles and sends them to their next destination.
|
||||
*
|
||||
* @param light The traffic light that is currently green.
|
||||
*/
|
||||
private void processGreenLight(TrafficLight light) {
|
||||
while (light.getState() == TrafficLightState.GREEN && light.getQueueSize() > 0) {
|
||||
Vehicle vehicle = light.removeVehicle();
|
||||
|
||||
if (vehicle != null) {
|
||||
// Get crossing time based on vehicle type
|
||||
double crossingTime = getCrossingTimeForVehicle(vehicle);
|
||||
|
||||
// Simulate crossing time
|
||||
try {
|
||||
Thread.sleep((long) (crossingTime * 1000));
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
break;
|
||||
}
|
||||
|
||||
// Update vehicle statistics
|
||||
vehicle.addCrossingTime(crossingTime);
|
||||
|
||||
// Update intersection statistics
|
||||
intersection.incrementVehiclesSent();
|
||||
|
||||
// Send vehicle to next destination
|
||||
sendVehicleToNextDestination(vehicle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the crossing time for a vehicle based on its type.
|
||||
*
|
||||
* @param vehicle The vehicle.
|
||||
* @return The crossing time in seconds.
|
||||
*/
|
||||
private double getCrossingTimeForVehicle(Vehicle vehicle) {
|
||||
switch (vehicle.getType()) {
|
||||
case BIKE:
|
||||
return config.getBikeVehicleCrossingTime();
|
||||
case LIGHT:
|
||||
return config.getLightVehicleCrossingTime();
|
||||
case HEAVY:
|
||||
return config.getHeavyVehicleCrossingTime();
|
||||
default:
|
||||
return config.getLightVehicleCrossingTime();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a vehicle to its next destination via socket connection.
|
||||
*
|
||||
* @param vehicle The vehicle that has crossed this intersection.
|
||||
*/
|
||||
private void sendVehicleToNextDestination(Vehicle vehicle) {
|
||||
String nextDestination = vehicle.getCurrentDestination();
|
||||
|
||||
try {
|
||||
// Get or create connection to next destination
|
||||
SocketConnection connection = getOrCreateConnection(nextDestination);
|
||||
|
||||
// Create and send message
|
||||
MessageProtocol message = new VehicleTransferMessage(
|
||||
intersectionId,
|
||||
nextDestination,
|
||||
vehicle
|
||||
);
|
||||
|
||||
connection.sendMessage(message);
|
||||
|
||||
System.out.println("[" + intersectionId + "] Sent vehicle " + vehicle.getId() +
|
||||
" to " + nextDestination);
|
||||
|
||||
// Note: vehicle route is advanced when it arrives at the next intersection
|
||||
|
||||
} catch (IOException | InterruptedException e) {
|
||||
System.err.println("[" + intersectionId + "] Failed to send vehicle " +
|
||||
vehicle.getId() + " to " + nextDestination + ": " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets an existing connection to a destination or creates a new one.
|
||||
*
|
||||
* @param destinationId The ID of the destination node.
|
||||
* @return The SocketConnection to that destination.
|
||||
* @throws IOException If connection cannot be established.
|
||||
* @throws InterruptedException If connection attempt is interrupted.
|
||||
*/
|
||||
private synchronized SocketConnection getOrCreateConnection(String destinationId)
|
||||
throws IOException, InterruptedException {
|
||||
|
||||
if (!outgoingConnections.containsKey(destinationId)) {
|
||||
String host = getHostForDestination(destinationId);
|
||||
int port = getPortForDestination(destinationId);
|
||||
|
||||
System.out.println("[" + intersectionId + "] Creating connection to " +
|
||||
destinationId + " at " + host + ":" + port);
|
||||
|
||||
SocketConnection connection = new SocketConnection(host, port);
|
||||
outgoingConnections.put(destinationId, connection);
|
||||
}
|
||||
|
||||
return outgoingConnections.get(destinationId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the host address for a destination node from configuration.
|
||||
*
|
||||
* @param destinationId The destination node ID.
|
||||
* @return The host address.
|
||||
*/
|
||||
private String getHostForDestination(String destinationId) {
|
||||
if (destinationId.equals("S")) {
|
||||
return config.getExitHost();
|
||||
} else {
|
||||
return config.getIntersectionHost(destinationId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the port number for a destination node from configuration.
|
||||
*
|
||||
* @param destinationId The destination node ID.
|
||||
* @return The port number.
|
||||
*/
|
||||
private int getPortForDestination(String destinationId) {
|
||||
if (destinationId.equals("S")) {
|
||||
return config.getExitPort();
|
||||
} else {
|
||||
return config.getIntersectionPort(destinationId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the server socket and begins accepting incoming connections.
|
||||
* This is the main listening loop of the process.
|
||||
*
|
||||
* @throws IOException If the server socket cannot be created.
|
||||
*/
|
||||
public void start() throws IOException {
|
||||
int port = config.getIntersectionPort(intersectionId);
|
||||
serverSocket = new ServerSocket(port);
|
||||
running = true;
|
||||
|
||||
System.out.println("\n[" + intersectionId + "] Server started on port " + port);
|
||||
System.out.println("[" + intersectionId + "] Waiting for incoming connections...\n");
|
||||
|
||||
// Main accept loop
|
||||
while (running) {
|
||||
try {
|
||||
Socket clientSocket = serverSocket.accept();
|
||||
|
||||
// Handle each connection in a separate thread
|
||||
connectionHandlerPool.submit(() -> handleIncomingConnection(clientSocket));
|
||||
|
||||
} catch (IOException e) {
|
||||
if (running) {
|
||||
System.err.println("[" + intersectionId + "] Error accepting connection: " +
|
||||
e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles an incoming connection from another process.
|
||||
* Continuously listens for vehicle transfer messages.
|
||||
*
|
||||
* @param clientSocket The accepted socket connection.
|
||||
*/
|
||||
private void handleIncomingConnection(Socket clientSocket) {
|
||||
try (SocketConnection connection = new SocketConnection(clientSocket)) {
|
||||
|
||||
System.out.println("[" + intersectionId + "] New connection accepted from " +
|
||||
clientSocket.getInetAddress().getHostAddress());
|
||||
|
||||
// Continuously receive messages while connection is active
|
||||
while (running && connection.isConnected()) {
|
||||
try {
|
||||
MessageProtocol message = connection.receiveMessage();
|
||||
|
||||
if (message.getType() == MessageType.VEHICLE_TRANSFER) {
|
||||
Vehicle vehicle = (Vehicle) message.getPayload();
|
||||
|
||||
System.out.println("[" + intersectionId + "] Received vehicle: " +
|
||||
vehicle.getId() + " from " + message.getSourceNode());
|
||||
|
||||
// Add vehicle to appropriate queue
|
||||
intersection.receiveVehicle(vehicle);
|
||||
}
|
||||
|
||||
} catch (ClassNotFoundException e) {
|
||||
System.err.println("[" + intersectionId + "] Unknown message type received: " +
|
||||
e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
} catch (IOException e) {
|
||||
if (running) {
|
||||
System.err.println("[" + intersectionId + "] Connection error: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stops the intersection process gracefully.
|
||||
* Shuts down all threads and closes all connections.
|
||||
*/
|
||||
public void shutdown() {
|
||||
System.out.println("\n[" + intersectionId + "] Shutting down...");
|
||||
running = false;
|
||||
|
||||
// Close server socket
|
||||
try {
|
||||
if (serverSocket != null && !serverSocket.isClosed()) {
|
||||
serverSocket.close();
|
||||
}
|
||||
} catch (IOException e) {
|
||||
System.err.println("[" + intersectionId + "] Error closing server socket: " +
|
||||
e.getMessage());
|
||||
}
|
||||
|
||||
// Shutdown thread pools
|
||||
trafficLightPool.shutdown();
|
||||
connectionHandlerPool.shutdown();
|
||||
|
||||
try {
|
||||
if (!trafficLightPool.awaitTermination(5, TimeUnit.SECONDS)) {
|
||||
trafficLightPool.shutdownNow();
|
||||
}
|
||||
if (!connectionHandlerPool.awaitTermination(5, TimeUnit.SECONDS)) {
|
||||
connectionHandlerPool.shutdownNow();
|
||||
}
|
||||
} catch (InterruptedException e) {
|
||||
trafficLightPool.shutdownNow();
|
||||
connectionHandlerPool.shutdownNow();
|
||||
}
|
||||
|
||||
// Close all outgoing connections
|
||||
for (Map.Entry<String, SocketConnection> entry : outgoingConnections.entrySet()) {
|
||||
try {
|
||||
entry.getValue().close();
|
||||
} catch (IOException e) {
|
||||
System.err.println("[" + intersectionId + "] Error closing connection to " +
|
||||
entry.getKey() + ": " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
System.out.println("[" + intersectionId + "] Shutdown complete.");
|
||||
System.out.println("=".repeat(60));
|
||||
}
|
||||
|
||||
// --- Inner class for Vehicle Transfer Messages ---
|
||||
|
||||
/**
|
||||
* Implementation of MessageProtocol for vehicle transfers between processes.
|
||||
*/
|
||||
private static class VehicleTransferMessage implements MessageProtocol {
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
private final String sourceNode;
|
||||
private final String destinationNode;
|
||||
private final Vehicle payload;
|
||||
|
||||
public VehicleTransferMessage(String sourceNode, String destinationNode, Vehicle vehicle) {
|
||||
this.sourceNode = sourceNode;
|
||||
this.destinationNode = destinationNode;
|
||||
this.payload = vehicle;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MessageType getType() {
|
||||
return MessageType.VEHICLE_TRANSFER;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object getPayload() {
|
||||
return payload;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSourceNode() {
|
||||
return sourceNode;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDestinationNode() {
|
||||
return destinationNode;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -31,7 +31,7 @@ public class SimulationConfig {
|
||||
* (por exemplo quando executado a partir do classpath/jar),
|
||||
* faz fallback para carregar a partir do classpath usando o ClassLoader.
|
||||
*/
|
||||
IOException lastException = null; //FIXME: melhorar esta parte para reportar erros de forma mais clara
|
||||
IOException lastException = null;
|
||||
|
||||
try {
|
||||
try (InputStream input = new FileInputStream(filePath)) {
|
||||
|
||||
@@ -264,19 +264,32 @@ public class SimulationEngine {
|
||||
*/
|
||||
private void processEvent(Event event) {
|
||||
switch (event.getType()) {
|
||||
case VEHICLE_GENERATION -> handleVehicleGeneration();
|
||||
case VEHICLE_GENERATION:
|
||||
handleVehicleGeneration();
|
||||
break;
|
||||
|
||||
case VEHICLE_ARRIVAL -> handleVehicleArrival(event);
|
||||
case VEHICLE_ARRIVAL:
|
||||
handleVehicleArrival(event);
|
||||
break;
|
||||
|
||||
case TRAFFIC_LIGHT_CHANGE -> handleTrafficLightChange(event);
|
||||
case TRAFFIC_LIGHT_CHANGE:
|
||||
handleTrafficLightChange(event);
|
||||
break;
|
||||
|
||||
case CROSSING_START -> handleCrossingStart(event);
|
||||
case CROSSING_START:
|
||||
handleCrossingStart(event);
|
||||
break;
|
||||
|
||||
case CROSSING_END -> handleCrossingEnd(event);
|
||||
case CROSSING_END:
|
||||
handleCrossingEnd(event);
|
||||
break;
|
||||
|
||||
case STATISTICS_UPDATE -> handleStatisticsUpdate();
|
||||
case STATISTICS_UPDATE:
|
||||
handleStatisticsUpdate();
|
||||
break;
|
||||
|
||||
default -> System.err.println("Unknown event type: " + event.getType());
|
||||
default:
|
||||
System.err.println("Unknown event type: " + event.getType());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -373,7 +386,7 @@ public class SimulationEngine {
|
||||
* @param vehicle The vehicle to process.
|
||||
* @param intersection The intersection where the vehicle is.
|
||||
*/
|
||||
private void tryProcessVehicle(Vehicle vehicle, Intersection intersection) { //FIXME
|
||||
private void tryProcessVehicle(Vehicle vehicle, Intersection intersection) {
|
||||
// Find the direction (and light) this vehicle is queued at
|
||||
// This logic is a bit flawed: it just finds the *first* non-empty queue
|
||||
// A better approach would be to get the light from the vehicle's route
|
||||
@@ -578,12 +591,16 @@ public class SimulationEngine {
|
||||
* @return The crossing time in seconds.
|
||||
*/
|
||||
private double getCrossingTime(VehicleType type) {
|
||||
return switch (type) {
|
||||
case BIKE -> config.getBikeVehicleCrossingTime();
|
||||
case LIGHT -> config.getLightVehicleCrossingTime();
|
||||
case HEAVY -> config.getHeavyVehicleCrossingTime();
|
||||
default -> 2.0;
|
||||
}; // Default fallback
|
||||
switch (type) {
|
||||
case BIKE:
|
||||
return config.getBikeVehicleCrossingTime();
|
||||
case LIGHT:
|
||||
return config.getLightVehicleCrossingTime();
|
||||
case HEAVY:
|
||||
return config.getHeavyVehicleCrossingTime();
|
||||
default:
|
||||
return 2.0; // Default fallback
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -104,28 +104,16 @@ public class Intersection {
|
||||
* Accepts an incoming vehicle and places it in the correct queue.
|
||||
* * This method:
|
||||
* 1. Increments the {@link #totalVehiclesReceived} counter.
|
||||
* 2. Advances the vehicle's route (since it just arrived here)
|
||||
* 3. Gets the vehicle's *next* destination (from {@link Vehicle#getCurrentDestination()}).
|
||||
* 4. Uses the {@link #routing} map to find the correct *direction* for that destination.
|
||||
* 5. Adds the vehicle to the queue of the {@link TrafficLight} for that direction.
|
||||
* 2. Gets the vehicle's *next* destination (from {@link Vehicle#getCurrentDestination()}).
|
||||
* 3. Uses the {@link #routing} map to find the correct *direction* for that destination.
|
||||
* 4. Adds the vehicle to the queue of the {@link TrafficLight} for that direction.
|
||||
*
|
||||
* @param vehicle The {@link Vehicle} arriving at the intersection.
|
||||
*/
|
||||
public void receiveVehicle(Vehicle vehicle) {
|
||||
totalVehiclesReceived++;
|
||||
|
||||
// Advance route since vehicle just arrived at this intersection
|
||||
vehicle.advanceRoute();
|
||||
|
||||
String nextDestination = vehicle.getCurrentDestination();
|
||||
|
||||
// Check if vehicle reached final destination
|
||||
if (nextDestination == null) {
|
||||
System.out.printf("[%s] Vehicle %s reached final destination%n",
|
||||
this.id, vehicle.getId());
|
||||
return;
|
||||
}
|
||||
|
||||
String direction = routing.get(nextDestination);
|
||||
|
||||
if (direction != null && trafficLights.containsKey(direction)) {
|
||||
|
||||
@@ -1,142 +0,0 @@
|
||||
package sd.model;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Represents a message exchanged between processes in the distributed simulation.
|
||||
* Each message has a unique ID, a type, a sender, a destination, and a payload.
|
||||
* This class implements {@link Serializable} to allow transmission over the network.
|
||||
*/
|
||||
public class Message implements Serializable {
|
||||
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
/**
|
||||
* Unique identifier for this message.
|
||||
*/
|
||||
private final String messageId;
|
||||
|
||||
/**
|
||||
* The type of this message (e.g., VEHICLE_TRANSFER, STATS_UPDATE).
|
||||
*/
|
||||
private final MessageType type;
|
||||
|
||||
/**
|
||||
* Identifier of the process that sent this message.
|
||||
*/
|
||||
private final String senderId;
|
||||
|
||||
/**
|
||||
* Identifier of the destination process. Can be null for broadcast messages.
|
||||
*/
|
||||
private final String destinationId;
|
||||
|
||||
/**
|
||||
* The actual data being transmitted. Type depends on the message type.
|
||||
*/
|
||||
private final Object payload;
|
||||
|
||||
/**
|
||||
* Timestamp when this message was created (simulation time or real time).
|
||||
*/
|
||||
private final long timestamp;
|
||||
|
||||
/**
|
||||
* Creates a new message with all parameters.
|
||||
*
|
||||
* @param type The message type
|
||||
* @param senderId The ID of the sending process
|
||||
* @param destinationId The ID of the destination process (null for broadcast)
|
||||
* @param payload The message payload
|
||||
* @param timestamp The timestamp of message creation
|
||||
*/
|
||||
public Message(MessageType type, String senderId, String destinationId,
|
||||
Object payload, long timestamp) {
|
||||
this.messageId = UUID.randomUUID().toString();
|
||||
this.type = type;
|
||||
this.senderId = senderId;
|
||||
this.destinationId = destinationId;
|
||||
this.payload = payload;
|
||||
this.timestamp = timestamp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new message with current system time as timestamp.
|
||||
*
|
||||
* @param type The message type
|
||||
* @param senderId The ID of the sending process
|
||||
* @param destinationId The ID of the destination process
|
||||
* @param payload The message payload
|
||||
*/
|
||||
public Message(MessageType type, String senderId, String destinationId, Object payload) {
|
||||
this(type, senderId, destinationId, payload, System.currentTimeMillis());
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a broadcast message (no specific destination).
|
||||
*
|
||||
* @param type The message type
|
||||
* @param senderId The ID of the sending process
|
||||
* @param payload The message payload
|
||||
*/
|
||||
public Message(MessageType type, String senderId, Object payload) {
|
||||
this(type, senderId, null, payload, System.currentTimeMillis());
|
||||
}
|
||||
|
||||
//Getters
|
||||
|
||||
public String getMessageId() {
|
||||
return messageId;
|
||||
}
|
||||
|
||||
public MessageType getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
public String getSenderId() {
|
||||
return senderId;
|
||||
}
|
||||
|
||||
public String getDestinationId() {
|
||||
return destinationId;
|
||||
}
|
||||
|
||||
public Object getPayload() {
|
||||
return payload;
|
||||
}
|
||||
|
||||
public long getTimestamp() {
|
||||
return timestamp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if this is a broadcast message (no specific destination).
|
||||
*
|
||||
* @return true if destinationId is null, false otherwise
|
||||
*/
|
||||
public boolean isBroadcast() {
|
||||
return destinationId == null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the payload cast to a specific type.
|
||||
* Use with caution and ensure type safety.
|
||||
*
|
||||
* @param <T> The expected payload type
|
||||
* @return The payload cast to type T
|
||||
* @throws ClassCastException if the payload is not of type T
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T> T getPayloadAs(Class<T> clazz) {
|
||||
return (T) payload;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("Message[id=%s, type=%s, from=%s, to=%s, timestamp=%d]",
|
||||
messageId, type, senderId,
|
||||
destinationId != null ? destinationId : "BROADCAST",
|
||||
timestamp);
|
||||
}
|
||||
}
|
||||
@@ -1,81 +0,0 @@
|
||||
package sd.model;
|
||||
|
||||
/**
|
||||
* Enumeration representing all possible message types for distributed communication.
|
||||
* These types are used for inter-process communication between different components
|
||||
* of the distributed traffic simulation system.
|
||||
*/
|
||||
public enum MessageType {
|
||||
|
||||
/**
|
||||
* Message to transfer a vehicle between intersections or processes.
|
||||
* Payload: Vehicle object with current state
|
||||
*/
|
||||
VEHICLE_TRANSFER,
|
||||
|
||||
/**
|
||||
* Message to update statistics across the distributed system.
|
||||
* Payload: Statistics data (waiting times, queue sizes, etc.)
|
||||
*/
|
||||
STATS_UPDATE,
|
||||
|
||||
/**
|
||||
* Message to synchronize traffic light states between processes.
|
||||
* Payload: TrafficLight state and timing information
|
||||
*/
|
||||
TRAFFIC_LIGHT_SYNC,
|
||||
|
||||
/**
|
||||
* Heartbeat message to check if a process is alive.
|
||||
* Payload: Process ID and timestamp
|
||||
*/
|
||||
HEARTBEAT,
|
||||
|
||||
/**
|
||||
* Request to join the distributed simulation.
|
||||
* Payload: Process information and capabilities
|
||||
*/
|
||||
JOIN_REQUEST,
|
||||
|
||||
/**
|
||||
* Response to a join request.
|
||||
* Payload: Acceptance status and configuration
|
||||
*/
|
||||
JOIN_RESPONSE,
|
||||
|
||||
/**
|
||||
* Message to notify about a new vehicle generation.
|
||||
* Payload: Vehicle generation parameters
|
||||
*/
|
||||
VEHICLE_SPAWN,
|
||||
|
||||
/**
|
||||
* Message to request the current state of an intersection.
|
||||
* Payload: Intersection ID
|
||||
*/
|
||||
STATE_REQUEST,
|
||||
|
||||
/**
|
||||
* Response containing the current state of an intersection.
|
||||
* Payload: Complete intersection state
|
||||
*/
|
||||
STATE_RESPONSE,
|
||||
|
||||
/**
|
||||
* Message to signal shutdown of a process.
|
||||
* Payload: Process ID and reason
|
||||
*/
|
||||
SHUTDOWN,
|
||||
|
||||
/**
|
||||
* Acknowledgment message for reliable communication.
|
||||
* Payload: Message ID being acknowledged
|
||||
*/
|
||||
ACK,
|
||||
|
||||
/**
|
||||
* Error message to report problems in the distributed system.
|
||||
* Payload: Error description and context
|
||||
*/
|
||||
ERROR
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
package sd.protocol;
|
||||
|
||||
import java.io.Serializable;
|
||||
import sd.model.MessageType; // Assuming MessageType is in sd.model or sd.protocol
|
||||
|
||||
/**
|
||||
* Interface defining the contract for all messages exchanged in the simulator.
|
||||
* Ensures that any message can be identified and routed.
|
||||
* * This interface extends Serializable to allow objects that implement it
|
||||
* to be sent over Sockets (ObjectOutputStream).
|
||||
*
|
||||
*/
|
||||
public interface MessageProtocol extends Serializable {
|
||||
|
||||
/**
|
||||
* Returns the type of the message, indicating its purpose.
|
||||
* @return The MessageType (e.g., VEHICLE_TRANSFER, STATS_UPDATE).
|
||||
*/
|
||||
MessageType getType();
|
||||
|
||||
/**
|
||||
* Returns the data object (payload) that this message carries.
|
||||
* The type of object will depend on the MessageType.
|
||||
* * - If getType() == VEHICLE_TRANSFER, the payload will be a {@link sd.model.Vehicle} object.
|
||||
* - If getType() == STATS_UPDATE, the payload will be a statistics object.
|
||||
* * @return The data object (payload), which must also be Serializable.
|
||||
*/
|
||||
Object getPayload();
|
||||
|
||||
/**
|
||||
* Returns the ID of the node (Process) that sent this message.
|
||||
* @return String (e.g., "Cr1", "Cr5", "S").
|
||||
*/
|
||||
String getSourceNode();
|
||||
|
||||
/**
|
||||
* Returns the ID of the destination node (Process) for this message.
|
||||
* @return String (e.g., "Cr2", "DashboardServer").
|
||||
*/
|
||||
String getDestinationNode();
|
||||
}
|
||||
@@ -1,199 +0,0 @@
|
||||
package sd.protocol;
|
||||
|
||||
import java.io.Closeable;
|
||||
import java.io.DataInputStream;
|
||||
import java.io.DataOutputStream;
|
||||
import java.io.IOException;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.net.ConnectException;
|
||||
import java.net.Socket;
|
||||
import java.net.SocketTimeoutException;
|
||||
import java.net.UnknownHostException;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import sd.serialization.MessageSerializer;
|
||||
import sd.serialization.SerializationException;
|
||||
import sd.serialization.SerializerFactory;
|
||||
|
||||
|
||||
/**
|
||||
* Wrapper class that simplifies communication via Sockets.
|
||||
* Includes connection retry logic for robustness.
|
||||
*/
|
||||
public class SocketConnection implements Closeable {
|
||||
|
||||
private final Socket socket;
|
||||
private final OutputStream outputStream;
|
||||
private final InputStream inputStream;
|
||||
private final MessageSerializer serializer;
|
||||
|
||||
// --- Configuration for Retry Logic ---
|
||||
/** Maximum number of connection attempts. */
|
||||
private static final int MAX_RETRIES = 5;
|
||||
/** Delay between retry attempts in milliseconds. */
|
||||
private static final long RETRY_DELAY_MS = 1000;
|
||||
|
||||
/**
|
||||
* Constructor for the "Client" (who initiates the connection).
|
||||
* Tries to connect to a process that is already listening (Server).
|
||||
* Includes retry logic in case of initial connection failure.
|
||||
*
|
||||
* @param host The host address (e.g., "localhost" from your simulation.properties)
|
||||
* @param port The port (e.g., 8001 from your simulation.properties)
|
||||
* @throws IOException If connection fails after all retries.
|
||||
* @throws UnknownHostException If the host is not found (this error usually doesn't need retry).
|
||||
* @throws InterruptedException If the thread is interrupted while waiting between retries.
|
||||
*/
|
||||
public SocketConnection(String host, int port) throws IOException, UnknownHostException, InterruptedException {
|
||||
Socket tempSocket = null;
|
||||
IOException lastException = null;
|
||||
|
||||
System.out.printf("[SocketConnection] Attempting to connect to %s:%d...%n", host, port);
|
||||
|
||||
// --- Retry Loop ---
|
||||
for (int attempt = 1; attempt <= MAX_RETRIES; attempt++) {
|
||||
try {
|
||||
// Try to establish the connection
|
||||
tempSocket = new Socket(host, port);
|
||||
|
||||
// If successful, break out of the retry loop
|
||||
System.out.printf("[SocketConnection] Connected successfully on attempt %d.%n", attempt);
|
||||
lastException = null; // Clear last error on success
|
||||
break;
|
||||
|
||||
} catch (ConnectException | SocketTimeoutException e) {
|
||||
// These are common errors indicating the server might not be ready.
|
||||
lastException = e;
|
||||
System.out.printf("[SocketConnection] Attempt %d/%d failed: %s. Retrying in %d ms...%n",
|
||||
attempt, MAX_RETRIES, e.getMessage(), RETRY_DELAY_MS);
|
||||
|
||||
if (attempt < MAX_RETRIES) {
|
||||
// Wait before the next attempt
|
||||
TimeUnit.MILLISECONDS.sleep(RETRY_DELAY_MS);
|
||||
}
|
||||
} catch (IOException e) {
|
||||
// Other IOExceptions might be more permanent, but we retry anyway.
|
||||
lastException = e;
|
||||
System.out.printf("[SocketConnection] Attempt %d/%d failed with IOException: %s. Retrying in %d ms...%n",
|
||||
attempt, MAX_RETRIES, e.getMessage(), RETRY_DELAY_MS);
|
||||
if (attempt < MAX_RETRIES) {
|
||||
TimeUnit.MILLISECONDS.sleep(RETRY_DELAY_MS);
|
||||
}
|
||||
}
|
||||
} // --- End of Retry Loop ---
|
||||
|
||||
// If after all retries tempSocket is still null, it means connection failed permanently.
|
||||
if (tempSocket == null) {
|
||||
System.err.printf("[SocketConnection] Failed to connect to %s:%d after %d attempts.%n", host, port, MAX_RETRIES);
|
||||
if (lastException != null) {
|
||||
throw lastException; // Throw the last exception encountered
|
||||
} else {
|
||||
// Should not happen if loop ran, but as a fallback
|
||||
throw new IOException("Failed to connect after " + MAX_RETRIES + " attempts, reason unknown.");
|
||||
}
|
||||
}
|
||||
|
||||
// If connection was successful, assign to final variable and create streams
|
||||
this.socket = tempSocket;
|
||||
|
||||
this.outputStream = socket.getOutputStream();
|
||||
this.inputStream = socket.getInputStream();
|
||||
this.serializer = SerializerFactory.createDefault();
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Constructor for the "Server" (who accepts the connection).
|
||||
* Receives a Socket that has already been accepted by a ServerSocket.
|
||||
* No retry logic needed here as the connection is already established.
|
||||
*
|
||||
* @param acceptedSocket The Socket returned by serverSocket.accept().
|
||||
* @throws IOException If stream creation fails.
|
||||
*/
|
||||
public SocketConnection(Socket acceptedSocket) throws IOException {
|
||||
this.socket = acceptedSocket;
|
||||
this.outputStream = socket.getOutputStream();
|
||||
this.inputStream = socket.getInputStream();
|
||||
this.serializer = SerializerFactory.createDefault();
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends (serializes) a MessageProtocol object over the socket.
|
||||
*
|
||||
* @param message The "envelope" (which contains the Vehicle) to be sent.
|
||||
* @throws IOException If writing to the stream fails or socket is not connected.
|
||||
*/
|
||||
public void sendMessage(MessageProtocol message) throws IOException {
|
||||
if (socket == null || !socket.isConnected()) {
|
||||
throw new IOException("Socket is not connected");
|
||||
}
|
||||
|
||||
try {
|
||||
// Serializa para bytes JSON
|
||||
byte[] data = serializer.serialize(message);
|
||||
|
||||
// Write 4-byte length prefix
|
||||
DataOutputStream dataOut = new DataOutputStream(outputStream);
|
||||
dataOut.writeInt(data.length);
|
||||
dataOut.write(data);
|
||||
dataOut.flush();
|
||||
|
||||
} catch (SerializationException e) {
|
||||
throw new IOException("Failed to serialize message", e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to read (deserialize) a MessageProtocol object from the socket.
|
||||
*
|
||||
* @return The "envelope" (MessageProtocol) that was received.
|
||||
* @throws IOException If the connection is lost, the stream is corrupted, or socket is not connected.
|
||||
* @throws ClassNotFoundException If the received object is unknown.
|
||||
*/
|
||||
public MessageProtocol receiveMessage() throws IOException, ClassNotFoundException {
|
||||
if (socket == null || !socket.isConnected()) {
|
||||
throw new IOException("Socket is not connected");
|
||||
}
|
||||
|
||||
try {
|
||||
// Lê um prefixo de 4 bytes - indicador de tamanho
|
||||
DataInputStream dataIn = new DataInputStream(inputStream);
|
||||
int length = dataIn.readInt();
|
||||
|
||||
if (length <= 0 || length > 10_000_000) { // Sanity check (10MB max)
|
||||
throw new IOException("Invalid message length: " + length);
|
||||
}
|
||||
|
||||
// Ler dados da mensagem
|
||||
byte[] data = new byte[length];
|
||||
dataIn.readFully(data);
|
||||
|
||||
// Deserialize do JSON
|
||||
return serializer.deserialize(data, MessageProtocol.class);
|
||||
|
||||
} catch (SerializationException e) {
|
||||
throw new IOException("Failed to deserialize message", e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Closes the socket and all streams (Input and Output).
|
||||
*/
|
||||
@Override
|
||||
public void close() throws IOException {
|
||||
if (inputStream != null) inputStream.close();
|
||||
if (outputStream != null) outputStream.close();
|
||||
if (socket != null) socket.close();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return true if the socket is still connected and not closed.
|
||||
*/
|
||||
public boolean isConnected() {
|
||||
return socket != null && socket.isConnected() && !socket.isClosed();
|
||||
}
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
package sd.serialization;
|
||||
|
||||
import com.google.gson.Gson;
|
||||
import com.google.gson.GsonBuilder;
|
||||
import com.google.gson.JsonSyntaxException;
|
||||
|
||||
import java.nio.charset.StandardCharsets;
|
||||
|
||||
/**
|
||||
* JSON-based implementation of {@link MessageSerializer} using Google's Gson library.
|
||||
*
|
||||
* This serializer converts objects to JSON format for transmission, providing:
|
||||
* - Human-readable message format (easy debugging)
|
||||
* - Cross-platform compatibility
|
||||
* - Smaller message sizes compared to Java native serialization
|
||||
* - Better security (no code execution during deserialization)
|
||||
*
|
||||
* The serializer is configured with pretty printing disabled by default for
|
||||
* production use, but can be enabled for debugging purposes.
|
||||
*
|
||||
* Thread-safety: This class is thread-safe as Gson instances are thread-safe.
|
||||
*
|
||||
* @see MessageSerializer
|
||||
*/
|
||||
public class JsonMessageSerializer implements MessageSerializer {
|
||||
|
||||
private final Gson gson;
|
||||
private final boolean prettyPrint;
|
||||
|
||||
/**
|
||||
* Creates a new JSON serializer with default configuration (no pretty printing).
|
||||
*/
|
||||
public JsonMessageSerializer() {
|
||||
this(false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new JSON serializer with optional pretty printing.
|
||||
*
|
||||
* @param prettyPrint If true, JSON output will be formatted with indentation
|
||||
*/
|
||||
public JsonMessageSerializer(boolean prettyPrint) {
|
||||
this.prettyPrint = prettyPrint;
|
||||
GsonBuilder builder = new GsonBuilder();
|
||||
|
||||
if (prettyPrint) {
|
||||
builder.setPrettyPrinting();
|
||||
}
|
||||
|
||||
// Register custom type adapters here if needed
|
||||
// builder.registerTypeAdapter(Vehicle.class, new VehicleAdapter());
|
||||
|
||||
this.gson = builder.create();
|
||||
}
|
||||
|
||||
@Override
|
||||
public byte[] serialize(Object object) throws SerializationException {
|
||||
if (object == null) {
|
||||
throw new IllegalArgumentException("Cannot serialize null object");
|
||||
}
|
||||
|
||||
try {
|
||||
String json = gson.toJson(object);
|
||||
return json.getBytes(StandardCharsets.UTF_8);
|
||||
} catch (Exception e) {
|
||||
throw new SerializationException(
|
||||
"Failed to serialize object of type " + object.getClass().getName(), e);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public <T> T deserialize(byte[] data, Class<T> clazz) throws SerializationException {
|
||||
if (data == null) {
|
||||
throw new IllegalArgumentException("Cannot deserialize null data");
|
||||
}
|
||||
if (clazz == null) {
|
||||
throw new IllegalArgumentException("Class type cannot be null");
|
||||
}
|
||||
|
||||
try {
|
||||
String json = new String(data, StandardCharsets.UTF_8);
|
||||
return gson.fromJson(json, clazz);
|
||||
} catch (JsonSyntaxException e) {
|
||||
throw new SerializationException(
|
||||
"Failed to parse JSON for type " + clazz.getName(), e);
|
||||
} catch (Exception e) {
|
||||
throw new SerializationException(
|
||||
"Failed to deserialize object of type " + clazz.getName(), e);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "JSON (Gson)";
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the underlying Gson instance for advanced usage.
|
||||
*
|
||||
* @return The Gson instance
|
||||
*/
|
||||
public Gson getGson() {
|
||||
return gson;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if pretty printing is enabled.
|
||||
*
|
||||
* @return true if pretty printing is enabled
|
||||
*/
|
||||
public boolean isPrettyPrint() {
|
||||
return prettyPrint;
|
||||
}
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
package sd.serialization;
|
||||
|
||||
/**
|
||||
* Interface for serializing and deserializing objects for network transmission.
|
||||
*
|
||||
* This interface provides a common abstraction for different serialization strategies
|
||||
* allowing the system to switch between implementations without changing the communication layer.
|
||||
*
|
||||
* Implementations must ensure:
|
||||
* - Thread-safety if used in concurrent contexts
|
||||
* - Proper exception handling with meaningful error messages
|
||||
* - Preservation of object state during round-trip serialization
|
||||
*
|
||||
* @see JsonMessageSerializer
|
||||
*/
|
||||
public interface MessageSerializer {
|
||||
|
||||
/**
|
||||
* Serializes an object into a byte array for transmission.
|
||||
*
|
||||
* @param object The object to serialize (must not be null)
|
||||
* @return A byte array containing the serialized representation
|
||||
* @throws SerializationException If serialization fails
|
||||
* @throws IllegalArgumentException If object is null
|
||||
*/
|
||||
byte[] serialize(Object object) throws SerializationException;
|
||||
|
||||
/**
|
||||
* Deserializes a byte array back into an object of the specified type.
|
||||
*
|
||||
* @param <T> The expected type of the deserialized object
|
||||
* @param data The byte array containing serialized data (must not be null)
|
||||
* @param clazz The class of the expected object type (must not be null)
|
||||
* @return The deserialized object
|
||||
* @throws SerializationException If deserialization fails
|
||||
* @throws IllegalArgumentException If data or clazz is null
|
||||
*/
|
||||
<T> T deserialize(byte[] data, Class<T> clazz) throws SerializationException;
|
||||
|
||||
/**
|
||||
* Gets the name of this serialization strategy (e.g., "JSON", "Java Native").
|
||||
* Useful for logging and debugging.
|
||||
*
|
||||
* @return The serializer name
|
||||
*/
|
||||
String getName();
|
||||
|
||||
}
|
||||
@@ -1,134 +0,0 @@
|
||||
package sd.serialization;
|
||||
|
||||
import sd.model.Message;
|
||||
import sd.model.MessageType;
|
||||
import sd.model.Vehicle;
|
||||
import sd.model.VehicleType;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Demonstration of JSON serialization usage in the traffic simulation system.
|
||||
*
|
||||
* This class shows practical examples of how to use JSON (Gson) serialization
|
||||
* for network communication between simulation processes.
|
||||
*/
|
||||
public class SerializationExample {
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println("=== JSON Serialization Example ===\n");
|
||||
|
||||
// Create a sample vehicle
|
||||
List<String> route = Arrays.asList("Cr1", "Cr2", "Cr5", "S");
|
||||
Vehicle vehicle = new Vehicle("V001", VehicleType.LIGHT, 10.5, route);
|
||||
vehicle.addWaitingTime(2.3);
|
||||
vehicle.addCrossingTime(1.2);
|
||||
|
||||
// Create a message containing the vehicle
|
||||
Message message = new Message(
|
||||
MessageType.VEHICLE_TRANSFER,
|
||||
"Cr1",
|
||||
"Cr2",
|
||||
vehicle
|
||||
);
|
||||
|
||||
// ===== JSON Serialization =====
|
||||
demonstrateJsonSerialization(message);
|
||||
|
||||
// ===== Factory Usage =====
|
||||
demonstrateFactoryUsage(message);
|
||||
|
||||
// ===== Performance Test =====
|
||||
performanceTest(message);
|
||||
}
|
||||
|
||||
private static void demonstrateJsonSerialization(Message message) {
|
||||
System.out.println("--- JSON Serialization ---");
|
||||
|
||||
try {
|
||||
// Create JSON serializer with pretty printing for readability
|
||||
MessageSerializer serializer = new JsonMessageSerializer(true);
|
||||
|
||||
// Serialize to bytes
|
||||
byte[] data = serializer.serialize(message);
|
||||
|
||||
// Display the JSON
|
||||
String json = new String(data);
|
||||
System.out.println("Serialized JSON (" + data.length + " bytes):");
|
||||
System.out.println(json);
|
||||
|
||||
// Deserialize back
|
||||
Message deserialized = serializer.deserialize(data, Message.class);
|
||||
System.out.println("\nDeserialized: " + deserialized);
|
||||
System.out.println("✓ JSON serialization successful\n");
|
||||
|
||||
} catch (SerializationException e) {
|
||||
System.err.println("❌ JSON serialization failed: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
private static void demonstrateFactoryUsage(Message message) {
|
||||
System.out.println("--- Using SerializerFactory ---");
|
||||
|
||||
try {
|
||||
// Get default serializer (JSON)
|
||||
MessageSerializer serializer = SerializerFactory.createDefault();
|
||||
System.out.println("Default serializer: " + serializer.getName());
|
||||
|
||||
// Use it
|
||||
byte[] data = serializer.serialize(message);
|
||||
Message deserialized = serializer.deserialize(data, Message.class);
|
||||
|
||||
System.out.println("Message type: " + deserialized.getType());
|
||||
System.out.println("From: " + deserialized.getSenderId() +
|
||||
" → To: " + deserialized.getDestinationId());
|
||||
System.out.println("✓ Factory usage successful\n");
|
||||
|
||||
} catch (SerializationException e) {
|
||||
System.err.println("❌ Factory usage failed: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
private static void performanceTest(Message message) {
|
||||
System.out.println("--- Performance Test ---");
|
||||
|
||||
int iterations = 1000;
|
||||
|
||||
try {
|
||||
MessageSerializer compactSerializer = new JsonMessageSerializer(false);
|
||||
MessageSerializer prettySerializer = new JsonMessageSerializer(true);
|
||||
|
||||
// Warm up
|
||||
for (int i = 0; i < 100; i++) {
|
||||
compactSerializer.serialize(message);
|
||||
}
|
||||
|
||||
// Test compact JSON
|
||||
long compactStart = System.nanoTime();
|
||||
byte[] compactData = null;
|
||||
for (int i = 0; i < iterations; i++) {
|
||||
compactData = compactSerializer.serialize(message);
|
||||
}
|
||||
long compactTime = System.nanoTime() - compactStart;
|
||||
|
||||
// Test pretty JSON
|
||||
byte[] prettyData = prettySerializer.serialize(message);
|
||||
|
||||
// Results
|
||||
System.out.println("Iterations: " + iterations);
|
||||
System.out.println("\nJSON Compact:");
|
||||
System.out.println(" Size: " + compactData.length + " bytes");
|
||||
System.out.println(" Time: " + (compactTime / 1_000_000.0) + " ms total");
|
||||
System.out.println(" Avg: " + (compactTime / iterations / 1_000.0) + " μs/operation");
|
||||
|
||||
System.out.println("\nJSON Pretty-Print:");
|
||||
System.out.println(" Size: " + prettyData.length + " bytes");
|
||||
System.out.println(" Size increase: " +
|
||||
String.format("%.1f%%", ((double)prettyData.length / compactData.length - 1) * 100));
|
||||
|
||||
} catch (SerializationException e) {
|
||||
System.err.println("❌ Performance test failed: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
package sd.serialization;
|
||||
|
||||
/**
|
||||
* Exception thrown when serialization or deserialization operations fail.
|
||||
*
|
||||
* This exception wraps underlying errors (I/O exceptions, parsing errors, etc.)
|
||||
* and provides context about what went wrong during the serialization process.
|
||||
*/
|
||||
public class SerializationException extends Exception {
|
||||
|
||||
private static final long serialVersionUID = 1L; // Long(64bits) instead of int(32bits)
|
||||
|
||||
/**
|
||||
* Constructs a new serialization exception with the specified detail message.
|
||||
*
|
||||
* @param message The detail message
|
||||
*/
|
||||
public SerializationException(String message) {
|
||||
super(message);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new serialization exception with the specified detail message
|
||||
* and cause.
|
||||
*
|
||||
* @param message The detail message
|
||||
* @param cause The cause of this exception
|
||||
*/
|
||||
public SerializationException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new serialization exception with the specified cause.
|
||||
*
|
||||
* @param cause The cause of this exception
|
||||
*/
|
||||
public SerializationException(Throwable cause) {
|
||||
super(cause);
|
||||
}
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
package sd.serialization;
|
||||
|
||||
/**
|
||||
* Factory for creating {@link MessageSerializer} instances.
|
||||
*
|
||||
* This factory provides a centralized way to create and configure JSON serializers
|
||||
* using Gson, making it easy to configure serialization throughout the application.
|
||||
*
|
||||
* The factory can be configured via system properties for easy deployment configuration.
|
||||
*
|
||||
* Example usage:
|
||||
* <pre>
|
||||
* MessageSerializer serializer = SerializerFactory.createDefault();
|
||||
* byte[] data = serializer.serialize(myObject);
|
||||
* </pre>
|
||||
*/
|
||||
public class SerializerFactory {
|
||||
|
||||
/**
|
||||
* System property key for enabling pretty-print in JSON serialization.
|
||||
* Set to "true" for debugging, "false" for production.
|
||||
*/
|
||||
public static final String JSON_PRETTY_PRINT_PROPERTY = "sd.serialization.json.prettyPrint";
|
||||
|
||||
// Default configuration
|
||||
private static final boolean DEFAULT_JSON_PRETTY_PRINT = false;
|
||||
|
||||
/**
|
||||
* Private constructor to prevent instantiation.
|
||||
*/
|
||||
private SerializerFactory() {
|
||||
throw new UnsupportedOperationException("Factory class cannot be instantiated");
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a JSON serializer based on system configuration.
|
||||
*
|
||||
* Pretty-print is determined by checking the system property
|
||||
* {@value #JSON_PRETTY_PRINT_PROPERTY}. If not set, defaults to false.
|
||||
*
|
||||
* @return A configured JsonMessageSerializer instance
|
||||
*/
|
||||
public static MessageSerializer createDefault() {
|
||||
boolean prettyPrint = Boolean.getBoolean(JSON_PRETTY_PRINT_PROPERTY);
|
||||
return new JsonMessageSerializer(prettyPrint);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a JSON serializer with default configuration (no pretty printing).
|
||||
*
|
||||
* @return A JsonMessageSerializer instance
|
||||
*/
|
||||
public static MessageSerializer createSerializer() {
|
||||
return createSerializer(DEFAULT_JSON_PRETTY_PRINT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a JSON serializer with specified pretty-print setting.
|
||||
*
|
||||
* @param prettyPrint Whether to enable pretty printing
|
||||
* @return A JsonMessageSerializer instance
|
||||
*/
|
||||
public static MessageSerializer createSerializer(boolean prettyPrint) {
|
||||
return new JsonMessageSerializer(prettyPrint);
|
||||
}
|
||||
}
|
||||
@@ -1,473 +0,0 @@
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.net.Socket;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.Arrays;
|
||||
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.Timeout;
|
||||
import org.junit.jupiter.api.io.TempDir;
|
||||
|
||||
import sd.IntersectionProcess;
|
||||
import sd.model.MessageType;
|
||||
import sd.model.Vehicle;
|
||||
import sd.model.VehicleType;
|
||||
|
||||
/**
|
||||
* Tests for IntersectionProcess - covers initialization, traffic lights,
|
||||
* vehicle transfer and network stuff
|
||||
*/
|
||||
public class IntersectionProcessTest {
|
||||
|
||||
@TempDir
|
||||
Path tempDir;
|
||||
|
||||
private Path configFile;
|
||||
private IntersectionProcess intersectionProcess;
|
||||
|
||||
// setup test config before each test
|
||||
@BeforeEach
|
||||
public void setUp() throws IOException {
|
||||
// create temp config file
|
||||
configFile = tempDir.resolve("test-simulation.properties");
|
||||
|
||||
String configContent = """
|
||||
# Test Simulation Configuration
|
||||
|
||||
# Intersection Network Configuration
|
||||
intersection.Cr1.host=localhost
|
||||
intersection.Cr1.port=18001
|
||||
intersection.Cr2.host=localhost
|
||||
intersection.Cr2.port=18002
|
||||
intersection.Cr3.host=localhost
|
||||
intersection.Cr3.port=18003
|
||||
intersection.Cr4.host=localhost
|
||||
intersection.Cr4.port=18004
|
||||
intersection.Cr5.host=localhost
|
||||
intersection.Cr5.port=18005
|
||||
|
||||
# Exit Configuration
|
||||
exit.host=localhost
|
||||
exit.port=18099
|
||||
|
||||
# Dashboard Configuration
|
||||
dashboard.host=localhost
|
||||
dashboard.port=18100
|
||||
|
||||
# Traffic Light Timing (seconds)
|
||||
trafficLight.Cr1.East.greenTime=5.0
|
||||
trafficLight.Cr1.East.redTime=5.0
|
||||
trafficLight.Cr1.South.greenTime=5.0
|
||||
trafficLight.Cr1.South.redTime=5.0
|
||||
trafficLight.Cr1.West.greenTime=5.0
|
||||
trafficLight.Cr1.West.redTime=5.0
|
||||
|
||||
trafficLight.Cr2.West.greenTime=4.0
|
||||
trafficLight.Cr2.West.redTime=6.0
|
||||
trafficLight.Cr2.East.greenTime=4.0
|
||||
trafficLight.Cr2.East.redTime=6.0
|
||||
trafficLight.Cr2.South.greenTime=4.0
|
||||
trafficLight.Cr2.South.redTime=6.0
|
||||
|
||||
trafficLight.Cr3.West.greenTime=3.0
|
||||
trafficLight.Cr3.West.redTime=7.0
|
||||
trafficLight.Cr3.East.greenTime=3.0
|
||||
trafficLight.Cr3.East.redTime=7.0
|
||||
|
||||
trafficLight.Cr4.East.greenTime=6.0
|
||||
trafficLight.Cr4.East.redTime=4.0
|
||||
|
||||
trafficLight.Cr5.East.greenTime=5.0
|
||||
trafficLight.Cr5.East.redTime=5.0
|
||||
|
||||
# Vehicle Crossing Times (seconds)
|
||||
vehicle.bike.crossingTime=2.0
|
||||
vehicle.light.crossingTime=3.0
|
||||
vehicle.heavy.crossingTime=5.0
|
||||
""";
|
||||
|
||||
Files.writeString(configFile, configContent);
|
||||
}
|
||||
|
||||
// cleanup after tests
|
||||
@AfterEach
|
||||
public void tearDown() {
|
||||
if (intersectionProcess != null) {
|
||||
intersectionProcess.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== Initialization Tests ====================
|
||||
|
||||
@Test
|
||||
public void testConstructor_Success() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
|
||||
assertNotNull(intersectionProcess);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructor_InvalidConfig() {
|
||||
Exception exception = assertThrows(IOException.class, () -> {
|
||||
new IntersectionProcess("Cr1", "non-existent-config.properties");
|
||||
});
|
||||
assertNotNull(exception);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInitialize_Cr1() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
|
||||
assertDoesNotThrow(() -> intersectionProcess.initialize());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInitialize_Cr2() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr2", configFile.toString());
|
||||
assertDoesNotThrow(() -> intersectionProcess.initialize());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInitialize_Cr3() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr3", configFile.toString());
|
||||
assertDoesNotThrow(() -> intersectionProcess.initialize());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInitialize_Cr4() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr4", configFile.toString());
|
||||
assertDoesNotThrow(() -> intersectionProcess.initialize());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInitialize_Cr5() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr5", configFile.toString());
|
||||
assertDoesNotThrow(() -> intersectionProcess.initialize());
|
||||
}
|
||||
|
||||
// traffic light creation tests
|
||||
|
||||
@Test
|
||||
public void testTrafficLightCreation_Cr1_HasCorrectDirections() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
// cant access private fields but initialization succeds
|
||||
assertNotNull(intersectionProcess);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTrafficLightCreation_Cr3_HasCorrectDirections() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr3", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
// Cr3 has west and south only
|
||||
assertNotNull(intersectionProcess);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTrafficLightCreation_Cr4_HasSingleDirection() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr4", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
// Cr4 only has east direction
|
||||
assertNotNull(intersectionProcess);
|
||||
}
|
||||
|
||||
// server startup tests
|
||||
|
||||
@Test
|
||||
@Timeout(5)
|
||||
public void testServerStart_BindsToCorrectPort() throws IOException, InterruptedException {
|
||||
intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
// start server in seperate thread
|
||||
Thread serverThread = new Thread(() -> {
|
||||
try {
|
||||
intersectionProcess.start();
|
||||
} catch (IOException e) {
|
||||
// expected on shutdown
|
||||
}
|
||||
});
|
||||
serverThread.start();
|
||||
|
||||
Thread.sleep(500); // wait for server to start
|
||||
|
||||
// try connecting to check if its running
|
||||
try (Socket clientSocket = new Socket("localhost", 18001)) {
|
||||
assertTrue(clientSocket.isConnected());
|
||||
}
|
||||
|
||||
intersectionProcess.shutdown();
|
||||
serverThread.join(2000);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Timeout(5)
|
||||
public void testServerStart_MultipleIntersections() throws IOException, InterruptedException {
|
||||
// test 2 intersections on diferent ports
|
||||
IntersectionProcess cr1 = new IntersectionProcess("Cr1", configFile.toString());
|
||||
IntersectionProcess cr2 = new IntersectionProcess("Cr2", configFile.toString());
|
||||
|
||||
cr1.initialize();
|
||||
cr2.initialize();
|
||||
|
||||
Thread thread1 = new Thread(() -> {
|
||||
try { cr1.start(); } catch (IOException e) { }
|
||||
});
|
||||
|
||||
Thread thread2 = new Thread(() -> {
|
||||
try { cr2.start(); } catch (IOException e) { }
|
||||
});
|
||||
|
||||
thread1.start();
|
||||
thread2.start();
|
||||
|
||||
Thread.sleep(500);
|
||||
|
||||
// check both are running
|
||||
try (Socket socket1 = new Socket("localhost", 18001);
|
||||
Socket socket2 = new Socket("localhost", 18002)) {
|
||||
assertTrue(socket1.isConnected());
|
||||
assertTrue(socket2.isConnected());
|
||||
}
|
||||
|
||||
cr1.shutdown();
|
||||
cr2.shutdown();
|
||||
thread1.join(2000);
|
||||
thread2.join(2000);
|
||||
}
|
||||
|
||||
// vehicle transfer tests
|
||||
|
||||
@Test
|
||||
@Timeout(10)
|
||||
public void testVehicleTransfer_ReceiveVehicle() throws IOException, InterruptedException {
|
||||
// setup reciever intersection
|
||||
intersectionProcess = new IntersectionProcess("Cr2", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
Thread serverThread = new Thread(() -> {
|
||||
try {
|
||||
intersectionProcess.start();
|
||||
} catch (IOException e) { }
|
||||
});
|
||||
serverThread.start();
|
||||
|
||||
Thread.sleep(500);
|
||||
|
||||
// create test vehicle
|
||||
java.util.List<String> route = Arrays.asList("Cr2", "Cr3", "S");
|
||||
Vehicle vehicle = new Vehicle("V001", VehicleType.LIGHT, 0.0, route);
|
||||
|
||||
// send vehicle from Cr1 to Cr2
|
||||
try (Socket socket = new Socket("localhost", 18002)) {
|
||||
ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
|
||||
|
||||
TestVehicleMessage message = new TestVehicleMessage("Cr1", "Cr2", vehicle);
|
||||
out.writeObject(message);
|
||||
out.flush();
|
||||
|
||||
Thread.sleep(1000); // wait for procesing
|
||||
}
|
||||
|
||||
intersectionProcess.shutdown();
|
||||
serverThread.join(2000);
|
||||
}
|
||||
|
||||
// routing config tests
|
||||
|
||||
@Test
|
||||
public void testRoutingConfiguration_Cr1() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
// indirect test - if init works routing should be ok
|
||||
assertNotNull(intersectionProcess);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRoutingConfiguration_Cr5() throws IOException {
|
||||
intersectionProcess = new IntersectionProcess("Cr5", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
// Cr5 routes to exit
|
||||
assertNotNull(intersectionProcess);
|
||||
}
|
||||
|
||||
// shutdown tests
|
||||
|
||||
@Test
|
||||
@Timeout(5)
|
||||
public void testShutdown_GracefulTermination() throws IOException, InterruptedException {
|
||||
intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
Thread serverThread = new Thread(() -> {
|
||||
try {
|
||||
intersectionProcess.start();
|
||||
} catch (IOException e) { }
|
||||
});
|
||||
serverThread.start();
|
||||
|
||||
Thread.sleep(500);
|
||||
|
||||
// shutdown should be fast
|
||||
assertDoesNotThrow(() -> intersectionProcess.shutdown());
|
||||
|
||||
serverThread.join(2000);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Timeout(5)
|
||||
public void testShutdown_ClosesServerSocket() throws IOException, InterruptedException {
|
||||
intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
Thread serverThread = new Thread(() -> {
|
||||
try {
|
||||
intersectionProcess.start();
|
||||
} catch (IOException e) { }
|
||||
});
|
||||
serverThread.start();
|
||||
|
||||
Thread.sleep(500);
|
||||
|
||||
// verify server running
|
||||
try (Socket socket = new Socket("localhost", 18001)) {
|
||||
assertTrue(socket.isConnected());
|
||||
}
|
||||
|
||||
intersectionProcess.shutdown();
|
||||
serverThread.join(2000);
|
||||
|
||||
// after shutdown conection should fail
|
||||
Thread.sleep(500);
|
||||
Exception exception = assertThrows(IOException.class, () -> {
|
||||
Socket socket = new Socket("localhost", 18001);
|
||||
socket.close();
|
||||
});
|
||||
assertNotNull(exception);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Timeout(5)
|
||||
public void testShutdown_StopsTrafficLightThreads() throws IOException, InterruptedException {
|
||||
intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
|
||||
intersectionProcess.initialize();
|
||||
|
||||
Thread serverThread = new Thread(() -> {
|
||||
try {
|
||||
intersectionProcess.start();
|
||||
} catch (IOException e) { }
|
||||
});
|
||||
serverThread.start();
|
||||
|
||||
Thread.sleep(500);
|
||||
|
||||
int threadCountBefore = Thread.activeCount();
|
||||
|
||||
intersectionProcess.shutdown();
|
||||
serverThread.join(2000);
|
||||
|
||||
Thread.sleep(500); // wait for threads to die
|
||||
|
||||
// thread count should decrese (traffic light threads stop)
|
||||
int threadCountAfter = Thread.activeCount();
|
||||
assertTrue(threadCountAfter <= threadCountBefore);
|
||||
}
|
||||
|
||||
// integration tests
|
||||
|
||||
@Test
|
||||
@Timeout(15)
|
||||
public void testIntegration_TwoIntersectionsVehicleTransfer() throws IOException, InterruptedException {
|
||||
// setup 2 intersections
|
||||
IntersectionProcess cr1 = new IntersectionProcess("Cr1", configFile.toString());
|
||||
IntersectionProcess cr2 = new IntersectionProcess("Cr2", configFile.toString());
|
||||
|
||||
cr1.initialize();
|
||||
cr2.initialize();
|
||||
|
||||
// start both
|
||||
Thread thread1 = new Thread(() -> {
|
||||
try { cr1.start(); } catch (IOException e) { }
|
||||
});
|
||||
|
||||
Thread thread2 = new Thread(() -> {
|
||||
try { cr2.start(); } catch (IOException e) { }
|
||||
});
|
||||
|
||||
thread1.start();
|
||||
thread2.start();
|
||||
|
||||
Thread.sleep(1000); // wait for servers
|
||||
|
||||
// send vehicle to Cr1 that goes to Cr2
|
||||
java.util.List<String> route = Arrays.asList("Cr1", "Cr2", "S");
|
||||
Vehicle vehicle = new Vehicle("V001", VehicleType.LIGHT, 0.0, route);
|
||||
|
||||
try (Socket socket = new Socket("localhost", 18001)) {
|
||||
ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
|
||||
|
||||
TestVehicleMessage message = new TestVehicleMessage("Entry", "Cr1", vehicle);
|
||||
out.writeObject(message);
|
||||
out.flush();
|
||||
|
||||
Thread.sleep(2000); // time for processing
|
||||
}
|
||||
|
||||
cr1.shutdown();
|
||||
cr2.shutdown();
|
||||
thread1.join(2000);
|
||||
thread2.join(2000);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMain_MissingArguments() {
|
||||
// main needs intersection ID as argument
|
||||
// cant test System.exit easily in modern java
|
||||
assertTrue(true, "Main method expects intersection ID as first argument");
|
||||
}
|
||||
|
||||
// helper class for testing vehicle messages
|
||||
private static class TestVehicleMessage implements sd.protocol.MessageProtocol {
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
private final String sourceNode;
|
||||
private final String destinationNode;
|
||||
private final Vehicle payload;
|
||||
|
||||
public TestVehicleMessage(String sourceNode, String destinationNode, Vehicle vehicle) {
|
||||
this.sourceNode = sourceNode;
|
||||
this.destinationNode = destinationNode;
|
||||
this.payload = vehicle;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MessageType getType() {
|
||||
return MessageType.VEHICLE_TRANSFER;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object getPayload() {
|
||||
return payload;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSourceNode() {
|
||||
return sourceNode;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDestinationNode() {
|
||||
return destinationNode;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -43,7 +43,7 @@ class SimulationTest {
|
||||
assertEquals("TEST1", vehicle.getId());
|
||||
assertNotNull(vehicle.getType());
|
||||
assertNotNull(vehicle.getRoute());
|
||||
assertTrue(!vehicle.getRoute().isEmpty());
|
||||
assertTrue(vehicle.getRoute().size() > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -1,140 +0,0 @@
|
||||
package sd.serialization;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import sd.model.Message;
|
||||
import sd.model.Vehicle;
|
||||
import sd.model.VehicleType;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Test suite for JSON serialization.
|
||||
*
|
||||
* Tests JSON serialization to ensure:
|
||||
* - Correct serialization and deserialization
|
||||
* - Data integrity during round-trip conversion
|
||||
* - Proper error handling
|
||||
*/
|
||||
class SerializationTest {
|
||||
|
||||
private MessageSerializer jsonSerializer = new JsonMessageSerializer();
|
||||
|
||||
private Vehicle testVehicle = new Vehicle("V001", VehicleType.LIGHT, 10.5,
|
||||
Arrays.asList("Cr1", "Cr2", "Cr5", "S"));
|
||||
private Message testMessage = new Message(
|
||||
sd.model.MessageType.VEHICLE_TRANSFER,
|
||||
"Cr1",
|
||||
"Cr2",
|
||||
testVehicle
|
||||
);
|
||||
|
||||
|
||||
// ===== JSON Serialization Tests =====
|
||||
|
||||
@Test
|
||||
@DisplayName("JSON: Should serialize and deserialize Vehicle correctly")
|
||||
void testJsonVehicleRoundTrip() throws SerializationException {
|
||||
// Serialize
|
||||
byte[] data = jsonSerializer.serialize(testVehicle);
|
||||
assertNotNull(data);
|
||||
assertTrue(data.length > 0);
|
||||
|
||||
// Print JSON for inspection
|
||||
System.out.println("JSON Vehicle:");
|
||||
System.out.println(new String(data));
|
||||
|
||||
// Deserialize
|
||||
Vehicle deserialized = jsonSerializer.deserialize(data, Vehicle.class);
|
||||
|
||||
// Verify
|
||||
assertNotNull(deserialized);
|
||||
assertEquals(testVehicle.getId(), deserialized.getId());
|
||||
assertEquals(testVehicle.getType(), deserialized.getType());
|
||||
assertEquals(testVehicle.getEntryTime(), deserialized.getEntryTime());
|
||||
assertEquals(testVehicle.getRoute(), deserialized.getRoute());
|
||||
assertEquals(testVehicle.getTotalWaitingTime(), deserialized.getTotalWaitingTime());
|
||||
assertEquals(testVehicle.getTotalCrossingTime(), deserialized.getTotalCrossingTime());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("JSON: Should serialize and deserialize Message correctly")
|
||||
void testJsonMessageRoundTrip() throws SerializationException {
|
||||
// Serialize
|
||||
byte[] data = jsonSerializer.serialize(testMessage);
|
||||
assertNotNull(data);
|
||||
|
||||
// Print JSON for inspection
|
||||
System.out.println("\nJSON Message:");
|
||||
System.out.println(new String(data));
|
||||
|
||||
// Deserialize
|
||||
Message deserialized = jsonSerializer.deserialize(data, Message.class);
|
||||
|
||||
// Verify
|
||||
assertNotNull(deserialized);
|
||||
assertEquals(testMessage.getType(), deserialized.getType());
|
||||
assertEquals(testMessage.getSenderId(), deserialized.getSenderId());
|
||||
assertEquals(testMessage.getDestinationId(), deserialized.getDestinationId());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("JSON: Should throw exception on null object")
|
||||
void testJsonSerializeNull() {
|
||||
assertThrows(IllegalArgumentException.class, () -> {
|
||||
jsonSerializer.serialize(null);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("JSON: Should throw exception on null data")
|
||||
void testJsonDeserializeNull() {
|
||||
assertThrows(IllegalArgumentException.class, () -> {
|
||||
jsonSerializer.deserialize(null, Vehicle.class);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("JSON: Should throw exception on invalid JSON")
|
||||
void testJsonDeserializeInvalid() {
|
||||
byte[] invalidData = "{ invalid json }".getBytes();
|
||||
assertThrows(SerializationException.class, () -> {
|
||||
jsonSerializer.deserialize(invalidData, Vehicle.class);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("JSON: Should preserve data integrity for complex objects")
|
||||
void testDataIntegrity() throws SerializationException {
|
||||
// Create a more complex vehicle
|
||||
Vehicle vehicle = new Vehicle("V999", VehicleType.HEAVY, 100.5,
|
||||
Arrays.asList("Cr1", "Cr2", "Cr3", "Cr4", "Cr5", "S"));
|
||||
vehicle.addWaitingTime(10.5);
|
||||
vehicle.addWaitingTime(5.3);
|
||||
vehicle.addCrossingTime(2.1);
|
||||
vehicle.advanceRoute();
|
||||
vehicle.advanceRoute();
|
||||
|
||||
// Serialize and deserialize
|
||||
byte[] jsonData = jsonSerializer.serialize(vehicle);
|
||||
Vehicle deserialized = jsonSerializer.deserialize(jsonData, Vehicle.class);
|
||||
|
||||
// Verify all fields match
|
||||
assertEquals(vehicle.getId(), deserialized.getId());
|
||||
assertEquals(vehicle.getType(), deserialized.getType());
|
||||
assertEquals(vehicle.getTotalWaitingTime(), deserialized.getTotalWaitingTime());
|
||||
assertEquals(vehicle.getCurrentRouteIndex(), deserialized.getCurrentRouteIndex());
|
||||
}
|
||||
|
||||
// ===== Factory Tests =====
|
||||
|
||||
@Test
|
||||
@DisplayName("Factory: Should create JSON serializer by default")
|
||||
void testFactoryDefault() {
|
||||
MessageSerializer serializer = SerializerFactory.createDefault();
|
||||
assertNotNull(serializer);
|
||||
assertEquals("JSON (Gson)", serializer.getName());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user