🚨 Emergency Management System

Sistema distribuito per la gestione e il monitoraggio di emergenze, con backend in C multi-thread, comunicazione tramite code POSIX e frontend React/WebSocket.

---

Indice

• Descrizione
• Funzionalità
• Architettura
• Requisiti
• Avvio Rapido con Docker (Consigliato)
• Installazione e Avvio Manuale (Alternativa)
• Utilizzo
• Configurazione
• Dettagli tecnici
• Logging
• Testing
• Autori

---

Descrizione

Emergency Management System è una piattaforma per la simulazione e gestione di emergenze in tempo reale. Il backend, scritto in C, gestisce parsing di configurazioni, code di emergenze, assegnazione automatica dei soccorritori e logging avanzato. Il frontend React consente il monitoraggio live della mappa e dei mezzi tramite WebSocket.

---

Funzionalità

• Parsing automatico di file di configurazione (env.conf, emergency_types.conf, rescuers.conf)
• Gestione thread-safe di emergenze tramite coda circolare
• Scheduler per assegnazione automatica dei soccorritori alle emergenze
• Digital twin per ogni soccorritore (thread dedicato)
• Logging avanzato su file e via TCP (per la dashboard)
• Bridge Node.js per conversione TCP -> WebSocket con caching degli stati
• Dashboard React per visualizzazione interattiva in tempo reale
• Client C per invio emergenze da riga di comando o file batch
• Architettura a microservizi completamente containerizzata con Docker

---

Architettura

+-------------------+         +-------------------+         +----------------------+
|     Client C      | <-----> |     Backend C     | <-----> |   Node.js TCP/WS     |
| (Invio emergenze) | POSIX MQ| (Gestione logica) |   TCP   |  (Bridge WebSocket)  |
+-------------------+         +-------------------+         +----------------------+
                                                                      |
                                                                      | WebSocket
                                                                      v
                                                        +----------------------+
                                                        |    Frontend React    |
                                                        |   (Dashboard live)   |
                                                        +----------------------+

• Backend C: parsing, gestione emergenze, scheduler, logging, digital twin.
• Client C: invio emergenze via Message Queue.
• Node.js: buffer di stato e bridge bidirezionale TCP <-> WebSocket.
• Frontend React: interfaccia utente live (Vite + React).

---

Requisiti

• Docker e Docker Compose (Fortemente raccomandati per evitare conflitti di librerie o IPC)
• Per esecuzione manuale (Senza Docker): Linux/WSL, GCC, libreria -lrt (POSIX MQ), Node.js >= 18.

---

Avvio Rapido con Docker (Consigliato)

L'intera infrastruttura è gestita tramite Docker Compose, che si occupa di compilare il codice C, allineare le librerie e condividere correttamente lo spazio IPC (code POSIX) tra i microservizi.

1. Clona il repository

git clone [https://github.com/DaPrato4/ProgettoLaboratorio2.git](https://github.com/DaPrato4/ProgettoLaboratorio2.git)
cd ProgettoLaboratorio2

2. Avvia i container

Esegui questo comando nella root del progetto. Docker compilerà il backend C e avvierà tutti i servizi:

docker compose up --build

(Per fermare il sistema, premi Ctrl+C e usa il comando docker compose down per pulire le risorse).

3. Apri la Dashboard

Visita nel tuo browser: 👉 http://localhost:5173

---

Installazione e Avvio Manuale (Alternativa)

Se preferisci avviare il sistema senza Docker, su un ambiente Linux nativo o WSL:

1. Compila il backend C:

   make

2. Avvia il bridge Node.js:

   cd frontend/node-server
   npm install
   node server.js

3. Avvia la dashboard React (in un altro terminale):

   cd frontend/dashboard-react
   npm install
   npm run dev

4. Avvia il backend C (in un altro terminale):

   make run

---

Utilizzo

Puoi creare nuove emergenze in due modi:

Metodo 1: Dalla Dashboard (Interfaccia Grafica)

Compila il form azzurro in alto a sinistra nella web app fornendo Nome, coordinate (X, Y) e delay. L'emergenza verrà inviata al backend e la mappa si aggiornerà in tempo reale.

Metodo 2: Da Riga di Comando (Client C)

Puoi usare l'eseguibile compilato per simulare invii di sistema. Se stai usando Docker, devi lanciare il comando all'interno del container del bridge Node, in modo che acceda correttamente alla coda condivisa:

• Singola emergenza:

  docker exec -it progettolaboratorio2-node-bridge-1 /app/build/client Terremoto 120 45 0

  (La sintassi è: <nome_eseguibile> <tipo> <x> <y> <delay>)

• Da file batch:

  docker exec -it progettolaboratorio2-node-bridge-1 /app/build/client -f /app/emergencies.txt

(Se non usi Docker, esegui semplicemente ./build/client ... dal tuo terminale host).

---

Configurazione

I file di configurazione si trovano nella cartella conf/ e possono essere modificati a caldo. Se usi Docker, i file sono montati come volumi, quindi le modifiche avranno effetto al riavvio del backend.

• env.conf: Parametri di ambiente (es. nome coda POSIX, dimensioni griglia).
• emergency_types.conf: Tipologie di emergenza e mezzi richiesti (es. [Terremoto] [2] Pompieri:4,10;...).
• rescuers.conf: Quantità e velocità dei soccorritori.

---

Dettagli tecnici

• src/: sorgenti C (gestione code, digital twin, scheduler, logger TCP).
• include/: header C.
• frontend/dashboard-react/: applicazione React per la visualizzazione.
• frontend/node-server/: server bridge Node.js.
• docker-compose.yml: orchestrazione microservizi, mount dei volumi /build e /conf, e condivisione esplicita dello spazio IPC (/dev/mqueue) per le comunicazioni POSIX intra-container.

---

Logging

Tutti gli eventi del backend vengono registrati simultaneamente:

1. Su file locale (system.log nella root).
2. Trasmessi in streaming JSON tramite Socket TCP sulla porta 9000 al server Node.js, che li converte in eventi WebSocket per la dashboard.

---

Testing

Per testare la robustezza del sistema sotto carico:

• Usa la modalità batch del client (-f) passando un file testuale con centinaia di emergenze.
• Monitora il log del terminale (o docker compose logs -f) per verificare l'assenza di memory leak o deadlocks nella gestione delle code concorrenti.

---

Autori

• Da Prato Gabriele email | github