G56 - Ruggine

Ruggine è una piattaforma di chat real-time con gestione avanzata di gruppi, ruoli e inviti, sviluppata come progetto universitario al Politecnico di Torino dal Gruppo 56.
Il backend è scritto in Rust e il frontend in React tramite Tauri per la distribuzione desktop.

Indice

• Funzionalità
• Architettura
• Stuttura delle cartelle
• Pacchetti principali
• Installazione
• Database
• WebSocket (Axum)
• Logging utilizzo CPU
• Portabilità Linux
• Prestazioni e dimensione eseguibile

Funzionalità

• Autenticazione utenti (login/registrazione)
• Creazione e gestione gruppi (nome, descrizione, owner, admin, membri)
• Chat di gruppo e chat dirette
• Gestione ruoli (owner, admin, membro) con promozione/demozione
• Sistema di inviti per aggiungere utenti ai gruppi
• Messaggistica real-time tramite WebSocket
• Persistenza dati con SQLite

Architettura

• Backend:
  Rust, Axum, SeaORM, WebSocket, SQLite
• Frontend:
  React, Tauri, Vite

Struttura delle cartelle

G56/
├── client/
│   ├── src/
│   ├── src-tauri/
│   └── ...
├── server/
│   ├── src/
│   └── ...
└── README.md

Pacchetti principali

Server (Rust)

• axum – Framework web asincrono per API REST e WebSocket
• sea-orm – ORM asincrono per la gestione del database SQLite
• tokio – Runtime asincrono
• async-trait – Utility per async
• serde / serde_json – Serializzazione/deserializzazione dati (JSON)
• tower-http – Middleware HTTP (CORS, ecc.)
• uuid – Generazione token per le sessioni
• argon2 - Hashing delle password nel database
• sha2 – Hashing dei token
• sysinfo – Monitoraggio risorse di sistema

Client (Rust + Tauri)

• tauri - Toolkit per applicazioni desktop, usato in client/src-tauri per integrare il frontend React con il backend Rust.
• reqwest – Client HTTP asincrono/sincrono, usato per chiamate API esterne dal lato Rust

Client (React + Tauri)

• @tauri-apps/api – API per comunicazione tra frontend e backend Tauri (JS)
• react – Libreria per interfacce utente
• react-router-dom – Routing client-side
• vite – Dev server e bundler

Installazione

Prerequisiti

• Rust
• Node.js
• Tauri CLI

Setup

1. Clona il repository

   git clone <repo-url>
   cd G56

2. Avvia il backend

   cd server
   cargo run

3. Avvia il frontend

   cd client
   npm install
   npm run tauri dev

Database

• SQLite (file: ./data/database.db)
• Tabelle principali: User, Group, GroupMember, Session, Invite, Message

WebSocket (Axum)

Per realizzare l’invio dei messaggi in real-time si usa Axum con il protocollo WebSocket (RFC 6455), che fornisce canali full‑duplex su una singola connessione TCP.

Struttura dei file

G56/

• client/src/ws/socket.js
• server/
  • main.rs
  • src/ws/
    • handler.rs
    • state.rs

Funzionamento

Nel client l’utente apre il WebSocket al login chiamando la route /ws da socket.js a cui passa il token di sessione nella query. per autenticarsi.

Nel server state.rs contiene la struct WSState che contiene due mappe: chats che memorizza per una chat i canali broadcast broadcast::Sender per cui inviare i messaggi nel formato WSMessage a tutti gli utenti che hanno fatto subscribe() e users che memorizza quali sono gli utenti connessi ad ogni chat.

Il Router nel main passa WSState a handle_socket() in handler.rs che riceve il token e autentica l’utente. Una volta stabilita la connessione viene gestita tramite handle_socket_connection() che lancia due task asincroni dividendo il socket in sender e receiver.

Il sender registra il comandi messagge invia un messaggio in broadcast a chi si è sottoscritto al canale della chat, e i comandi join e leave con i quali effettua dinamicamente il cambio di chat, quando l’utente lo richiede, uscendo dal canale precedente ed entrando in quello desiderato.

Il receiver si occupa di ricevere il messaggio inviato in broadcast e se il client vuole cambiare chat cancella la vecchia sottoscrizione e si iscrive dinamicamente cambiando il receiver.

Logging utilizzo CPU

Il backend avvia automaticamente un logger dell'utilizzo CPU del processo server in server/src/main.rs tramite la funzione start_cpu_logger().

• Il file di output è server/data/cpu.log
• Il log viene inizializzato a ogni avvio del server
• Ogni 120 secondi viene aggiunta una riga con:
  • timestamp UTC (to_rfc3339)
  • percentuale CPU corrente del processo (cpu_usage)
  • tempo CPU accumulato (accumulated_cpu_time)
  • uptime del processo in secondi (run_time)

Formato riga esempio:

2026-02-17T10:12:00Z | cpu_usage=3.5 | cpu_time=128 | uptime=720s

Portabilità Linux

Il progetto è portabile su Linux sia lato backend che lato desktop client:

• Backend (server/): scritto in Rust + Axum/SeaORM, quindi compilabile ed eseguibile su Linux con cargo run.
• Client desktop (client/src-tauri/): basato su Tauri v2 con configurazione bundle targets: "all" in tauri.conf.json, utile per generare pacchetti per i target supportati dalla piattaforma.

Per build desktop su Linux:

cd client
npm install
npm run tauri build

Nota: la creazione dei pacchetti Linux dipende anche dalle dipendenze di sistema richieste da Tauri/WebKitGTK presenti sulla macchina di build.

Prestazioni e dimensione eseguibile

Il progetto è stato sviluppato con attenzione a performance e footprint:

• Runtime efficiente: backend in Rust asincrono (Tokio + Axum) per ridurre overhead e gestire concorrenza in modo scalabile.
• Monitoraggio risorse: il logger CPU (server/data/cpu.log) aiuta a osservare il comportamento del processo server nel tempo.
• Desktop leggero: il client usa Tauri (WebView nativa del sistema) invece di includere un runtime browser completo, con impatto positivo sulle dimensioni finali.

Per contenere la dimensione dell'eseguibile e ottenere performance migliori, usare build in modalità release:

# Backend
cd server
cargo build --release

# Client desktop
cd ../client
npm run tauri build

La dimensione effettiva dei binari/pacchetti dipende da OS, target e dipendenze di sistema; gli artefatti finali sono disponibili nelle cartelle target/release e client/src-tauri/target/release/bundle.

Dimensioni reali ottenute su Windows (build release):

• App desktop client (.exe in build client): 11.57 MB
• Server (build release): 8.64 MB

Dimensioni reali ottenute su Linux (build release):

• App desktop client (eseguibile build client): 15.62 MB
• Server (build release): 9.73 MB