Newsgroup: it.hobby.elettronica.digitale
Titolo: Gestione client/server

Ciao,
 
scrivo qui perché in passato su un argomento simile avevo ricevuto 
consigli utili.
 
Supponendo di avere una rete LAN (cablata) di una ventina di pc (tra 
computer e schede embedded, comunque con debian o windows sui pc) devo 
gestire tramite applicazioni Qt4 la comunicazione tra loro.
 
Vi è un pc che fa da server, tutti gli altri client si collegano 
all'accensione e mantengono attiva la connessione finché sono accesi.
 
I dati da scambiare sono di due tipi:
 
- piccoli pacchetti inviati in maniera asincrona dai client al server di 
tanto in tanto (e viceversa)
 
- file per un totale di qualche MB da inviare sporadicamente dal server 
a tutti i client
 
Per quanto riguarda i pacchetti di dati, mi serve la garanzia di 
consegna (nel senso che non posso perdere la trasmissione) ma non ho 
criticità particolari circa il tempo. Anche se venisse recapitato 500 ms 
dopo non è un problema.
 
Se ho ben capito mi conviene utilizzare il protocollo TCP/IP.
Sul pc server scrivo appunto un server che rimane in ascolto e ad ogni 
client connesso esegue un thread separato.
 
Per l'invio dei file, potrei gestire tutto a manina: leggere x byte alla 
volta e inviarli con send (ip e tcp dovrebbero garantirmi l'ordine di 
consegna e integrità dei dati). C'è qualcosa di più furbo che mi 
permetta semplicemente di selezionare il file ed eventualmente sapere a 
che punto è la trasmissione?
 
Grazie!
Marco
 

 a tutti i client
 
Anche se non l'ho usato in prima persona (mi tocca ripetermi) zeromq fa 
proprio quello che ti serve: consegna affidabile, connessioni 1-1 e a 
sottoscrizione, quando il server centrale pubblica il client riceve.
 
Ci sono due binding per le Qt, il migliore sembra [1], cerca "qt" in [2] 
e comunque la documentazione perché ha diversi pattern per la 
comunicazione.
 
 
 
[1] 
https://github.com/jonnydee/nzmqt
 
[2] 
http://www.zeromq.org/docs:labs
 

 [1] 
https://github.com/jonnydee/nzmqt
 
 
 
Grazie, scaricato.
Sto cercando di compilarlo ora.
 
Farò sapere come mi sono trovato! Anche se non ci vorrà qualche giorno...
 
Ciao
Marco
 

 Farò sapere come mi sono trovato! Anche se non ci vorrà qualche giorno...
 
C'è la presentazione [1] "ZeroMQ is the Answer" e relativo video [2] con 
un aspiratissimo accento britannico.
 
 
[1] 
http://www.slideshare.net/IanBarber/zeromq-is-the-answer
 
[2] 
http://vimeo.com/20605470
 

 un aspiratissimo accento britannico.
 
Ben venga! L'inglese è una lingua, l'americano un dialetto:)
 
Grazie comunque del link, molto interessante questo zeromq. Noto che la 
libreria c'è già nei repository di Debian.

 libreria c'è già nei repository di Debian.
 
 
Infatti, sgrunt.
Con debian tempo 2 minuti avevo installato zeromq dai repository, 
scaricato i bindings per qt4, compilato e installato e verificato in 
qtcreator.
 
Sotto windows è tutto il pomeriggio che sto cercando ancora di far 
funzionare la cosa. A parte l'installer del dev-kit di mingw che per 3 
volte mi ha costretto a effettuare il reset del pc con il tasto 
(completamente bloccato, mah). A parte che nel 2012 ancora non vengono 
supportati i percorsi con gli spazi, mah...
 
Insomma ora ho compilato zeromq, e sto litigando con nzmqt....
 
Ciao!
Marco

 libreria c'è già nei repository di Debian.
 
Credo sia ubiquo, basta ci siano le socket BSD. Da quanto dice nel video 
dovrebbe funzionare con IPC anche su Windows.

 consegna e integrità dei dati).
 
Facendo comunque le cose a manina puoi anche salire di livello. Ad 
esempio lavorare con un httpserver da un lato e un httpclient 
dall'altro. I dati sono caricati (e ricevuti) sulla request http 
dimenticando cosa gira a livello piu' basso e relativi problemi di 
connessioni.
 
Con la codifica/decodifica Json puoi anche trasmettere paro paro interi 
dizionari arbitrariamente annidati.
 
I i dati binari andrebbero b64encodati (aumentano del 33%).
 
 
 
Per Python 3 avevo fatto qualche prova, una cosa di base potrebbe essere 
questa:
 
#---------------------------------------------------------------------
 
from http.client import HTTPConnection
 
conn = HTTPConnection( "localhost", 8080 )
conn.request( "POST", "/", body=open("myFile.txt", "rb") )
resp = conn.getresponse()
conn.close()
 
#---------------------------------------------------------------------
 
from http.server import HTTPServer, BaseHTTPRequestHandler
 
class Handler(BaseHTTPRequestHandler):
 
     def do_POST(self):
         lenData = int( self.headers.get("content-length") )
         data = self.rfile.read(lenData)
         print( "YOU HAVE ME SENT:\n" + data.decode("utf-8") )
         self.send_response(200)
         self.connection.shutdown(1)
 
HTTPServer( ("localhost", 8080), Handler ).serve_forever()
 

 I i dati binari andrebbero b64encodati (aumentano del 33%).
 
[cut]
 
Grazie anche a te.
Quando dicevo qualcosa di più furbo intendevo quello che hai intuito. 
Ora sto facendo qualche prova con zeromq, se trovassi difficoltà ripiego 
su queste altre strade.
 
Ciao!
Marco

 Farò sapere come mi sono trovato! Anche se non ci vorrà qualche giorno...
 
 
Ho fatto un paio di prove al volo e direi che la soluzione migliore è 
utilizzare nzmqt per i messaggi asincroni tra server e client (ROUTER e 
DEALER), e un server HTTP o FTP per trasferire i file.
 
Ciao!
Marco

 DEALER), e un server HTTP o FTP per trasferire i file.
 
Però hai l'ingombro di dover impostare anche questo server, dato che 
stai già usando 0MQ non puoi semplicemente passare il file come un 
messaggio e scriverlo?
 
O in alternativa come ti hanno già suggerito puoi usare semplicemente un 
metodo HTTP per i messaggi asincroni e scartare 0MQ.
 
Quello che sto suggerendo è di ridurre ad uno solo dei sistemi, così 
devi manutenerne uno solo e, si spera, c'è meno roba che può 
malfunzionare.

 malfunzionare.
 
 
Questo è giusto, ma un server ftp sarà comunque presente per poter 
scaricare file o log da remoto. Quindi in ogni caso dovrò predisporlo.
 
Anche perché se non ho capito male 0MQ non prevede la possibilità di 
sapere a che punto è la trasmissione del messaggio.
Non è molto comodo per l'utente dover aspettare tutto il tempo 
necessario al trasferimento senza sapere se l'upload sta andando a buon 
fine.
 
Ciao!
Marco