Spectra
Un client desktop nativo per il pannello Spectra su Windows e Linux, scritto in C#/.NET. Un vero binario con accesso al sistema, non un Chromium impacchettato. La stessa vista del web, ma con prestazioni native e integrazione con il desktop.
Un client di amministrazione nativo per l'hosting di server di gioco Spectra su Windows e Linux, costruito in C#/.NET su Avalonia. La stessa vista del pannello web, ma come binario reale collegato direttamente al cuore della piattaforma e alla sua enorme API frozcore/frozmod - con accesso al sistema, velocità nativa e logica condivisa con il resto di Spectra, non riscritta una seconda volta.
Introduzione
Spectra è un marchio di hosting di server di gioco per il quale abbiamo costruito l'intero backend del pannello. Questo caso di studio riguarda un pezzo, ma cruciale, di quel puzzle: il client desktop nativo per gli amministratori. Non è un'app separata che vive accanto al pannello - è un'altra scocca sopra lo stesso cuore, che dialoga con lo stesso backend della versione web. Per capire perché sia stata una sfida, bisogna prima vedere quanto grande sia il sistema sottostante.
Il client desktop non disegna belle schermate sopra il vuoto. Poggia su una piattaforma completa: provisioning dei server, gestione della potenza, file, database, telemetria, fatturazione e permessi. Il nostro compito era dare all'amministratore una finestra nativa su tutto questo - senza un browser impacchettato e senza duplicare una logica che già viveva nel pannello web.
Un pannello in cui si sta tutto il giorno
Un amministratore di server di gioco non controlla il pannello una volta a settimana. Lo tiene aperto per otto ore, accanto alla console, al client di gioco e alla messaggistica. In questa modalità un'altra scheda del browser non è una comodità, è una quinta ruota del carro: si perde nella folla delle schede, non ha un'icona propria nella barra delle applicazioni, ignora le scorciatoie di sistema e non vede i file locali.
Volevamo dare la stessa vista del web, ma come app che si comporta come il resto dei programmi sul desktop. Una condizione ferrea: niente Chromium impacchettato. Un client che aggiunge 200 MB di memoria all'avvio solo per mostrare esattamente la stessa cosa manca il proprio scopo prima ancora di aver finito di avviarsi. Se l'amministratore deve passare qui la maggior parte della giornata, l'app deve essere leggera, immediata e "di casa" sul suo sistema, non l'ennesima finestra del browser che finge di essere un programma.
In cifre
| Metrica | Valore |
|---|---|
| Sistemi da un'unica base di codice | Windows e Linux |
| Impronta di memoria tipica | ~40 MB |
| Cuore condiviso con il pannello web | uno |
| Viste collegate all'API | decine |
Cos'è davvero Spectra sotto
Il più grande fraintendimento in un progetto come questo è pensare che "sia solo un pannello". In realtà il pannello è un sottile strato sopra un backend che fa il lavoro pesante: avvia e ferma i server di gioco, alloca le risorse, tiene i database, trasmette i log e la console in diretta e fa rispettare limiti e fatturazione. Quel backend è la corposa API frozcore/frozmod - decine di endpoint, eventi in tempo reale e un modello di permessi che decide chi vede cosa e cosa può fare.
Il client desktop deve dialogare con esattamente la stessa API del pannello web. Non c'è una "versione desktop semplificata": se l'amministratore cambia il limite di memoria di un server o riavvia un'istanza, lo fa attraverso lo stesso contratto che usa il web. Perciò, prima ancora che esistesse una sola schermata, bisognava capire e domare la scala di quell'API - e questa era la vera parte della sfida, non l'aspetto della finestra.
La console e il flusso di log funzionano in diretta. Non è un aggiornamento ogni pochi secondi, ma un flusso continuo di eventi dal backend - il client desktop vi si iscrive esattamente come il web, cosicché l'amministratore vede l'output di un server nell'istante stesso in cui si produce.
Un cuore, due scocche
La logica di dominio - autorizzazione, modello del server, comandi di alimentazione, flusso di log, mappatura dei permessi su quell'API - vive in un'unica libreria .NET. Il pannello web e il client desktop sono due scocche sopra quell'unico cuore, cosicché una correzione in una regola di permessi o nel modo di gestire un endpoint atterra in entrambi i posti contemporaneamente. Un'intera classe di bug "funziona sul web, rotto sul desktop" semplicemente scompare.
Avalonia disegna lo strato di vista. Non è un webview - i controlli si renderizzano direttamente tramite Skia, per lo stesso percorso su Windows e Linux, cosicché l'app appare identica su entrambi. Lungo la strada ottiene un accesso reale al file system, agli appunti e alle notifiche che una pagina impacchettata non ha mai avuto.
Stack
| Livello | Scelta | Perché così |
|---|---|---|
| Linguaggio e runtime | C# / .NET | un solo linguaggio per logica e UI, buoni strumenti |
| Livello di vista | Avalonia (Skia) | rendering nativo, identico su Windows e Linux |
| Cuore di dominio | libreria .NET condivisa | la stessa logica e lo stesso client API del pannello web |
| Livello di rete | client frozcore/frozmod tipizzato | un contratto, web e desktop parlano la stessa lingua |
| Distribuzione | self-contained publish | un binario, nessuna installazione di runtime dal cliente |
Integrazione con un'API gigantesca
Questa è stata la parte più pesante. Il backend di Spectra espone decine di operazioni: ciclo di vita del server, console, file, database, pianificazioni di attività, backup, utenti e permessi, telemetria delle risorse. Per evitare che il client desktop si trasformi in un groviglio di chiamate, abbiamo avvolto l'intera API in un unico client tipizzato nel cuore - con un unico posto per autorizzazione, ritentativi e gestione degli errori.
ogni endpoint frozcore/frozmod dietro un'unica interfaccia, con autorizzazione e ritentativi in un solo posto, cosicché né il web né il desktop ripetano quella logica.
console, log e telemetria come sottoscrizioni di eventi, non polling in un ciclo; lo stesso meccanismo del pannello web.
ciò che un amministratore può vedere e fare deriva dalle stesse regole del web, calcolate nel cuore e non "a occhio" nell'UI.
le risposte dell'API atterrano direttamente nei controlli nativi di Avalonia, senza un DOM di mezzo.
Avvolgere l'intera API in un unico client nel cuore ha ripagato due volte: una modifica del contratto sul lato backend è un'unica correzione nella libreria, che web e desktop ricevono nello stesso commit. Nessuna deriva di versione, nessun "sul mio computer funziona".
Prestazioni e natività
Poiché la condizione al contorno era "niente Chromium impacchettato", le prestazioni non erano un'aggiunta ma l'obiettivo. Avalonia disegna l'interfaccia direttamente, senza motore di browser all'interno, cosicché un binario con il pannello completo pesa una frazione di ciò che peserebbe la stessa vista in Electron, e si avvia in una frazione di secondo.
Impronta di memoria all'avvio (indicativa, MB)
A questo si aggiunge tutto ciò che un browser non ha mai dato: accesso reale al file system (punti ai file del server direttamente dal disco, senza caricarli prima in un browser), scorciatoie di sistema, notifiche native e un'icona nella barra delle applicazioni. Per chi sta nel pannello tutto il giorno, questa non è cosmesi ma un risparmio di tempo quotidiano.
Come abbiamo collegato tutto
Con un cuore che contiene il client API e una scocca su Avalonia, il tutto si assemblava in modo ripetibile. La cosa fondamentale era che un'unica sorgente producesse due binari autonomi, davvero testati su entrambi i sistemi, e non solo compilati per entrambi.
autorizzazione, modello del server, comandi e client API sono stati staccati dalla vista web e spostati in una libreria separata che non sa nulla di chi la disegna.
lo stesso layout di schermate del web, ma in controlli nativi, collegata al cuore tramite semplici chiamate, non tramite HTTP verso se stessa.
publish su win-x64 e linux-x64 dalla stessa sorgente, ciascuno come binario autonomo.
la stessa cosa eseguita davvero su Windows e su Linux, collegata al backend reale, e non solo compilata per entrambi.
Qual è il risultato finale della collaborazione
L'amministratore ottiene un programma che si avvia in una frazione di secondo, si tiene nella barra delle applicazioni come qualsiasi altra app e mostra esattamente i dati del pannello web - perché sotto è lo stesso codice e la stessa API. Le scorciatoie di sistema funzionano, i file sul disco si possono scegliere senza caricarli prima in un browser, la console e i log scorrono in diretta e la finestra non si perde in un groviglio di schede. Invece di una "pagina in una finestra", l'amministratore ottiene uno strumento che si sente parte del suo sistema.
Dal lato di Spectra il guadagno è altrettanto concreto e duraturo. Una sola logica e un solo client API invece di due tenuti a mano in accordo significano che sviluppare la piattaforma non si moltiplica per il numero di scocche. Una nuova regola di permessi, un nuovo endpoint nel backend o una modifica al modello del server atterra su web e desktop nello stesso commit. Un'intera classe di bug di sincronizzazione scompare, e il client desktop smette di essere un progetto separato da mantenere.
La cosa più importante, tuttavia, è che il desktop non è una "versione light". Dialoga con la stessa API frozcore/frozmod completa del pannello web, cosicché l'amministratore non deve mai tornare al browser per una funzione che mancava all'app - perché non ne mancava nessuna. Questa è la differenza tra una pagina impacchettata e un vero client di piattaforma nativo: quest'ultimo cresce con il backend invece di trascinarsi dietro di esso.
Altri progetti
Altri lavori della stessa categoria - scopri come affrontiamo sfide simili.
Hai un progetto simile?
Contattaci - il preventivo è gratuito e arriva entro un'ora.



