Una semplice architettura client-server TCP/IP in Python

Una serie di workshop applicativi sull'uso di Python?

Con questo workshop viene presentato un semplice modulo, sviluppato all'IFAC, per realizzare applicazioni client-server in Python con protocollo proprietario e ne vengono illustrate alcune applicazioni esemplificative.

Sarebbe interessante se questo fosse il primo di una serie di semplici workshop applicativi in cui vengono illustrate applicazioni in Python sviluppate internamente, che possono essere di utilità generale, o per un riutilizzo diretto oppure come spunto di riflessione per approfondire alcuni aspetti del linguaggio. Tra gli argomenti che vengono in mente in proposito: accesso ai database, gestione avanzata di immagini e colori, gestione della strumentazione e rapporti con l'hardware.

Impostazione

Dopo un brevissimo riepilogo di alcuni concetti generali, per il resto questa introduzione si dipanerà attraverso la presentazione e la discussione di alcuni esempi.
I sorgenti verranno copiati da questa pagina Web in un editor di testo (o in Idle), eventualmente modificati e lanciati in esecuzione.

Aspetti generali

Architettura client-server

Secondo la solita Wikipedia:
Un sistema client-server (letteralmente cliente-servente) è un'architettura di rete nella quale un computer client istanzia l'interfaccia utente di un'applicazione connettendosi ad una server application o ad un sistema di database.
Più semplicemente, i sistemi client/server sono un'evoluzione dei sistemi basati sulla condivisione semplice delle risorse.
La presenza di un server permette ad un certo numero di client di condividere delle risorse, lasciando che sia il server a gestire gli accessi alle risorse per evitare conflitti di utilizzazione tipici dei primi sistemi informatici.
[Fine citazione]

In altre parole, in una applicazione client-server, l'obiettivo che si vuole raggiungere viene perseguito suddividendo le elaborazioni da svolgere tra due programmi distinti, detti per l'appunto client e server, che si ripartiscono i compiti in modo ottimale e colloquiano tra di loro mediante una connessione di rete. Noi ci occuperemo unicamente di connessioni di rete realizzate mediante il protocollo TCP/IP. Una volta che i due programmi sono collegati, il loro ruolo sulla rete è del tutto paritetico, ma ciò non ostante dal punto di vista dell'applicazione complessiva i ruoli del client e del server sono chiaramente distinti. In linea di massima, il server si occupa di gestire delle risorse mentre il client si occupa di offrire un'interfaccia all'utente.
Esempi tipici di applicazioni client-server con protocollo TCP/IP sono la distribuzione della posta elettronica (protocolli SMTP, POP3, IMAP), il trasferimento file (protocollo FTP), la consultazione delle pagine Web (protocollo HTTP).
Noi ci occuperemo dello sviluppo di applicazioni client-server con protocollo proprietario.

Vantaggi dell'architettura client-server

Il carico computazionale viene ripartito tra due piattaforme in genere distinte. Ognuna di esse può essere ottimizzata per i compiti a cui è destinata: gestione di basi di dati, gestione di documenti, calcolo numerico, gestione di strumentazione, interfaccia utente.
L'architettura si presta in modo naturale alla condivisione delle risorse: le risorse gestite dal server sono accessibili in teoria da qualunque nodo di Internet; se il server è realizzato in modo concorrente, l'accesso può avvenire da più nodi simultaneamente.
Client e server possono:
- essere sviluppati su piattaforme (cioè sistemi operativi) diversi; tutti i moderni sistemi operativi supportano infatti il protocollo TCP/IP;
- essere sviluppati con linguaggi di programmazione diversi; tutti i moderni linguaggi di programmazione supportano infatti il protocollo TCP/IP;
- essere sviluppati da programmatori diversi, creando così una modalità naturale di ripartizione del lavoro in un team.

Svantaggi dell'architettura client-server

Maggior complessità del sistema.
Dipendenza da una connessione di rete efficace.
Procedura di sviluppo un po' più complicata.

Concetti di base di una applicazione client-server


Architettura client-server TCP/IP
La connessione TCP/IP stabilisce un collegamento punto-punto tra due applicazioni. Gli estremi di questo collegamento sono contrassegnati da un indirizzo IP, che identifica la workstation e da un numero di porta, che rende possibile la coesistenza, sulla stessa workstation, di più connessioni, facenti capo ad applicazioni indipendenti. Le applicazioni che utilizzano il protocollo TCP/IP in un contesto client-server non solo devono conoscere ciascuna l'indirizzo IP e il numero di porta dell'altra, ma devono anche condividere il protocollo dell'applicazione, che pertanto deve essere stato preventivamente definito. Una volta stabilita la connessione e il protocollo cui scambiare dati su di essa, il sottostante protocollo TCP/IP si incarica di far arrivare questi dati, suddivisi in pacchetti, da un estremo all'altro del collegamento. In particolare, il protocollo TCP si occupa di assemblare e disassemblare i pacchetti e di gestire l'handshaking che garantisce l'affidabilità della connnessione, mentre il protocollo IP si occupa del trasporto dei singoli pacchetti e della scelta del miglior instradamento degli stessi lungo la rete. Questo meccanismo è alla base della robustezza del protocollo TCP/IP nel suo insieme, che a sua volta rappresenta una delle motivazioni dello sviluppo del protocollo stesso in ambito militare (ARPAnet). Le varie applicazioni standard esistenti (navigazione Web, trasferimento file, posta elettronica e molte altre) utilizzano protocolli di applicazione standardizzati (http, ftp, pop3, imap, smtp etc.). Ogni applicazione client-server specifica deve invece definire ed applicare il proprio protocollo di applicazione proprietario. Questo può prevedere lo scambio di dati in blocchi di dimensioni fisse (è la soluzione più semplice), oppure in forma di stringhe di testo terminate da CR+LF (è forse la soluzione più comune, che presenta il vantaggio di rendere facile il debug da parte di operatori umani) oppure ancora in blocchi delimitati in altro modo, con approcci ibdridi o diversi.

Architettura client-server TCP/IP

La connessione TCP/IP stabilisce un collegamento punto-punto tra due applicazioni. Gli estremi di questo collegamento sono contrassegnati da un indirizzo IP, che identifica la workstation e da un numero di porta, che rende possibile la coesistenza, sulla stessa workstation, di più connessioni, facenti capo ad applicazioni indipendenti.
Le applicazioni che utilizzano il protocollo TCP/IP in un contesto client-server non solo devono conoscere ciascuna l'indirizzo IP e il numero di porta dell'altra, ma devono anche condividere il protocollo dell'applicazione, che pertanto deve essere stato preventivamente definito.
Una volta stabilita la connessione e il protocollo cui scambiare dati su di essa, il sottostante protocollo TCP/IP si incarica di far arrivare questi dati, suddivisi in pacchetti, da un estremo all'altro del collegamento. In particolare, il protocollo TCP si occupa di assemblare e disassemblare i pacchetti e di gestire l'handshaking che garantisce l'affidabilità della connnessione, mentre il protocollo IP si occupa del trasporto dei singoli pacchetti e della scelta del miglior instradamento degli stessi lungo la rete. Questo meccanismo è alla base della robustezza del protocollo TCP/IP nel suo insieme, che a sua volta rappresenta una delle motivazioni dello sviluppo del protocollo stesso in ambito militare (ARPAnet).
Le varie applicazioni standard esistenti (navigazione Web, trasferimento file, posta elettronica e molte altre) utilizzano protocolli di applicazione standardizzati (http, ftp, pop3, imap, smtp etc.). Ogni applicazione client-server specifica deve invece definire ed applicare il proprio protocollo di applicazione proprietario. Questo può prevedere lo scambio di dati in blocchi di dimensioni fisse (è la soluzione più semplice), oppure in forma di stringhe di testo terminate da CR+LF (è forse la soluzione più comune, che presenta il vantaggio di rendere facile il debug da parte di operatori umani) oppure ancora in blocchi delimitati in altro modo, con approcci ibdridi o diversi.

Il ruolo del server in una applicazione client-server

Una volta avviato (manualmente o - spesso - automaticamente all'avvio della workstation su cui gira), il programma server resta attivo indefinitamente.
Si collega ad una porta TCP/IP della propria workstation. Il numero della porta può essere imposto dal programmatore o definito da un file di configurazione o infine impostato direttamente dall'operatore. Il programma server resta in attesa, su tale porta, di richieste di collegamento da parte di uno o più client.
Gestisce molto spesso una risorsa condivisa: un database, un archivio di documenti o di file in genere, una risorsa di calcolo, uno strumento.
I server di tipo iterativo possono gestire un client per volta (le richieste vengono messe in coda). I server di tipo concorrente possono gestire più richieste contemporaneamente, mediante il meccanismo del fork in ambiente Linux, del threading in ambiente Windows.
Al termine delle elaborazioni richieste dal client, quest'ultimo in genere (ma non è un obbligo) prende l'iniziativa di chiudere la sessione; il collegamento viene chiuso prima dal lato server e poi, di riflesso, dal lato client.

Il ruolo del client in una applicazione client-server

Viene avviato dall'utente al momento del bisogno e arrestato (chiuso) al termine dell'utilizzo.
Chiede (o sa) a quale workstation remota (indirizzo IP) e a quale numero di porta su di essa collegarsi.
Gestisce l'interazione con l'utente, in base alla quale si stabilisce come utilizzare la risorsa gestita dal server.
Prende in genere l'iniziativa di chiudere la sessione, a seguito di una decisione dell'utente e del relativo comando.

Ciò detto, iniziamo!

Viene presentato un modulo Python (anzi due, uno per l'ambiente testuale e uno per PyQt) che permette di realizzare applicazioni client-server in modo piuttosto elementare. Ci soffermeremo più sull'applicazione dei moduli che sulla loro implementazione.
I moduli hanno le loro radici in una libreria C che, assieme ad Alessandro Agostini, sviluppammo verso la fine del 1995 per gestire in modo semplice il colloquio client-server nel nascente sistema di acquisizione delle firme elettroniche dell'allora IROE, superando una certa farraginosità insita nel supporto nativo offerto dal linguaggio. La libreria fu sviluppata per le piattaforme Linux (gcc) e DOS (TurboC con supporto TCP/IP Ftp Software e Wattcp).
Successivamente, ho portato la libreria (in genere con qualche limitazione) in altre piattaforme, via via che se n'è presentata l'esigenza o l'opportunità: C/C++ sotto Win32 (client e server); VB6 sotto Win32 (solo client e senza supporto ai trasferimenti binari), PHP (idem) ed infine Python (client e server, per ora senza supporto ai trasferimento binari).

Risorse:

Il modulo per l'ambiente testuale: tcpstream.py.
Il modulo per l'ambiente PyQt: qtcpstream.py.
Il modulo nativo Python per il networking a basso livello: WEB - WEB.
I moduli nativi Python per le applicazioni TCP/IP (Internet) standard: WEB.

Funzioni di servizio

Un client HTTP minimale

Notare:

I metodi base tcpstream.open, tcpstream.printf, tcpstream.putc, tcpstream.gets
L'host WWW virtuale.

Un client general purpose orientato alla riga

###################################
#    Client ASCII-TCP generico    #
#     Versione line-oriented      #
# ATTENZIONE NON FUNZIONA IN IDLE #
###################################

import msvcrt
import sys
from tcpstream import *

DEFHST="pop3.infinito.it"
DEFPRT=110

#
# Main.
#
if len(sys.argv)<3:
  #
  # Imposta il server e la porta di default
  #
  host=DEFHST
  port=DEFPRT
else:
  #
  # Imposta il server e la porta indicati su linea di comando
  #
  host=sys.argv[1]
  port=int(sys.argv[2])
doclient(host,port)

Notare:

A causa del modulo msvcrt:
1. il programma gira solo in MS-Windows;
2. il programma NON funziona sotto Idle.

Un server iterativo

#
# Single task (iterative) server.
#
from tcpstream import *

TCPPORT=5555

def scrivilog(s):
  print(s)

########################################
#         PROGRAMMA PRINCIPALE         #
########################################
# Visualizza una stringa di "greetings".
#
print("In ascolto sulla porta {0:d}.".format(TCPPORT))
#
# Crea un socket TCP con funzioni server e gli passa:
# - il numero di porta su cui mettersi in ascolto;
# - la funzione da eseguire in caso di ricevimento
#   e accettazione di una richiesta di connessione.
#
netServer=tcpServer(TCPPORT,masterserver)
#
# Il comando "run" mette in ascolto il server; il flag
# di argomento permette di scegliere tra funzionamento
# iterativo (passare False) e concorrente (passare True);
# nel caso si attivi un server single task (iterativo),
# l'esecuzione prosegue tutta internamente all'oggetto
# di classe tcpServer; se ne esce solo quando il client
# ne richiede uno shutdown.
#
netServer.run(False)
netServer.close()
print("Server arrestato.")

Notare:

Il client vengono tenuti in coda.

Un server concorrente

#
# Multitasking (concurrent) server.
#
from tcpstream import *

TCPPORT=5555

def scrivilog(s):
  print(s)

########################################
#         PROGRAMMA PRINCIPALE         #
########################################
# Visualizza una stringa di "greetings".
#
print("In ascolto sulla porta {0:d}.".format(TCPPORT))
#
# Crea un socket TCP con funzioni server e gli passa:
# - il numero di porta su cui mettersi in ascolto;
# - la funzione da eseguire in caso di ricevimento
#   e accettazione di una richiesta di connessione.
#
netServer=tcpServer(TCPPORT,masterserver)
#
# Il comando "run" mette in ascolto il server; il flag
# di argomento permette di scegliere tra funzionamento
# iterativo (passare False) e concorrente (passare True).
#
netServer.run(True)
#
# Attende la condizione di uscita.
#
while netServer.canContinue:
  #
  # Si potrebbero inserire istruzioni NON BLOCCANTI
  # per poter arrestare il server anche da tastiera
  # oltre che da remoto!
  #
  pass
netServer.close()
print("Server arrestato.")

Notare:

Il meccanismo dei thread (a causa del quale probabilmente questo programma gira solo in ambiente Windows).
Il meccanismo di intercettazione dell'eccezione sul socket server per evitare il messaggio di errore in caso di arresto del server.
Il meccanismo legato al flag daemon.

Il modulo tcpstream.py

Funzioni di utilizzo diretto
- dirsolve(name)
  Converte un hostname in formato alfanumerico in un indirizzo IP in formato numerico puntato, che riporta come stringa.
- bcksolve(ip)
  Converte un indirizzo IP in formato numerico puntato in un hostname completo, in formato alfanumerico, che riporta come stringa.
- getLocalAddress()
  Riporta l'indirizzo IP della macchina locale, in formato numerico-puntato.
- getLocalName()
  Riporta l'hostname della macchina locale (senza dominio).
- getLocalDomain()
  Riporta il nome del dominio della macchina locale.
Metodi della classe principale tcpStream(socket.socket)
Nel seguito si è posto net=tcpStream()
- net.open(None,port)
  Apre uno stream TCP in modo SERVER, inizializzando un socket sulla porta TCP port della macchina locale e ponendolo in ascolto.
- net.acceptConnection()
  Attende ed accetta la connessione sul socket e ne riporta il nuovo stream TCP; è un'istruzione bloccante.
- net.open(serverName,port)
  Apre uno stream TCP in modo CLIENT, inizializzando un socket verso la porta TCP port del server serverName.
- net.getRemoteAddress()
  Riporta l'indirizzo IP del corrispondente remoto, in formato numerico-puntato.
- net.getRemoteName()
  Riporta l'hostname completo del corrispondente remoto, in formato alfanumerico.
- net.recvready()
  Riporta True se e solo se ci sono dati pronti da leggere sulla connessione di rete.
- net.eof()
  Riporta True se e solo se il corrispondente ha chiuso la connessione dalla sua parte.
- net.getc()
  Per leggere un singolo carattere dalla connessione di rete.
- net.putc()
  Per inviare un singolo carattere sulla connessione di rete.
- net.gets()
  Per leggere dalla connessione di rete una stringa terminata con LINEFEED; i caratteri RETURN e/o LINEFEED finali NON vengono riportati.
- net.printf()
  Per inviare una stringa sulla connessione di rete.

Un client general purpose orientato al carattere

###################################
#    Client ASCII-TCP generico    #
#   Versione character-oriented   #
# ATTENZIONE NON FUNZIONA IN IDLE #
###################################

import msvcrt
import sys
from tcpstream import *

DEFHST="pop3.infinito.it"
DEFPRT=110

def doclient(serv,port):
  net=tcpStream()
  net.open(serv,port)
  print("***** Connesso a "+net.getRemoteAddress())
  print("***** Connesso a "+net.getRemoteName())
  #
  # Master Loop.
  #
  while True:
    #
    # Ricezione.
    #
    while net.recvready():
      bufChr=net.getc()                 # getc() restituisce string
      if bufChr!="":
        msvcrt.putch(bufChr.encode())   # da string a bytes (putch() vuole bytes)
    #
    # Controllo chiusura connessione da parte del server.
    #
    if net.eof():
      net.close()
      return
    #
    # Trasmissione.
    #
    if msvcrt.kbhit():
      bufChr=msvcrt.getch()             # getch() restituisce bytes
      if ord(bufChr)==13:
        msvcrt.putch(bufChr)            # putch() vuole bytes
        net.putc(bufChr.decode())       # da bytes a string (putc vuole string)
        bufChr=b'\x0A'                  # questo definisce una costante bytes
        msvcrt.putch(bufChr)            # putch() vuole bytes
        net.putc(bufChr.decode())       # da bytes a string (putc vuole string)
      elif ord(bufChr)==10:
        pass
      else:
        msvcrt.putch(bufChr)            # putch() vuole bytes
        net.putc(bufChr.decode())       # da bytes a string (putc vuole string)

Notare:

Il funzionamento meno fluido rispetto alla versione orientata alla riga.
La necessità di curare nel proprio programma l'editing in input.

Un server a doppia porta

#
# Multitasking (concurrent) twin server.
# Due distinti server in ascolto su porte diverse.
#
import threading
from tcpstream import *

TCPPORT1=5555
TCPPORT2=6666

def masterserver(net,chi):
#
# Legge e processa dal socket "net" i comandi via via ricevuti.
#
  print("Server {0:s} - Ricevuta richiesta di servizio da {1:s}.".format(chi,net.getRemoteName()))
  #
  # Master loop.
  #
  net.printf("+OK General Purpose Server {0:s}\r\n".format(chi))
  while True:
    #
    # Accettazione dei comandi.
    #
    # I comandi hanno il seguente formato:
    # NOME arg1,arg2,...,argn
    #
    line=net.gets().split(' ')
    cmd=line[0].upper()
    if len(line)>1:
      args=line[1].split(',')
    #
    # Gestione dei comandi.
    #
    if cmd=="HELP":
      net.printf("This general purpose demo server {0:s} recognizes\r\n".format(chi))
      net.printf("only this HELP, the QUIT and the SHUT commands\r\n")
      net.printf("+OK General Purpose Server {0:s}\r\n".format(chi))
    elif cmd=="QUIT":
      net.printf("+OK {0:s} is closing the connection\r\n".format(chi))
      net.close()
      return True  # significa lasciare il server acceso
    elif cmd=="SHUT":
      net.printf("+OK {0:s} is closing the connection and shutting down the server\r\n".format(chi))
      net.close()
      return False # significa spengere il server
    else:
      net.printf("-ERR Command error {0:s}\r\n".format(chi))
# End of masterserver

def ms1(net):
  #
  # Master server collegato alla porta TCPPORT1.
  # Gli assegno il nome "Jeeves".
  #
  return masterserver(net,"JEEVES")

def ms2(net):
  #
  # Master server collegato alla porta TCPPORT2.
  # Gli assegno il nome "Battista".
  #
  return masterserver(net,"BATTISTA")

class ChildThread(threading.Thread):
  def __init__(self,netclient,servfun):
    threading.Thread.__init__(self)
    #
    # Memorizza il socket (oggetto di classe
    # "tcpStream") su cui si deve lavorare.
    #
    self.netClient=netclient
    #
    # Memorizzo il riferimento alla funzione
    # che deve gestire il servizio richiesto.
    #
    self.servFun=servfun
    #
    # Si setta "daemon=False" in modo che questo thread
    # rimanga in vita quando terminera' il main, fino
    # alla chiusura del collegamento in corso di servizio.
    # Vedi:
    # http://stackoverflow.com/questions/5127401/setdaemon-function-in-thread
    # "In contrast, when t.daemon is set to True, the thread
    # is terminated when the main thread ends."
    #
    self.daemon=False
  def run(self):
    global canContinue
    goon=self.servFun(self.netClient)
    self.netClient.close()
    #
    # E' opportuno separare l'assegnazione di "goon" da
    # quella di "canContinue" per essere certo che anche
    # le due istruzioni dopo il ritorno da "self.servFun"
    # vengano sicuramente eseguite!
    #
    canContinue=goon

class MasterLoopThread(threading.Thread):
  def __init__(self,netserver,servfun):
    threading.Thread.__init__(self)
    #
    # Memorizza il socket (oggetto di classe
    # "tcpStream") su cui si deve lavorare.
    #
    self.netServer=netserver
    #
    # Memorizzo il riferimento alla funzione
    # che deve gestire il servizio richiesto.
    #
    self.servFun=servfun
    #
    # Si setta "daemon=True" in modo che questo thread
    # e tutti quelli da esso generati (che ereditano
    # questo valore) vengano in ogni caso terminati
    # quando terminera' il main.
    # Vedi:
    # http://stackoverflow.com/questions/5127401/setdaemon-function-in-thread
    # "In contrast, when t.daemon is set to True, the thread
    # is terminated when the main thread ends."
    #
    self.daemon=True
  def run(self):
    #
    # Master Loop.
    #
    while True:
      #
      # Attende ed onora una connessione da un processo client.
      # ATTENZIONE: la funzione "acceptConnection" e` bloccante,
      # se ne esce solo o per connessione accettata o per errore.
      # L'eccezione viene intercettata per evitare il messaggio
      # di errore in caso di arresto del server.
      #
      try:
        netClient=self.netServer.acceptConnection()
      except:
        return
      #
      # Crea un nuovo thread per gestire la connessione.
      #
      ChildThread(netClient,self.servFun).start()

######################################
#        PROGRAMMA PRINCIPALE        #
######################################
# Visualizza una stringa di "greetings".
#
print("In ascolto sulle porte {0:d} e {1:d}.".format(TCPPORT1,TCPPORT2))
#
# Apre un socket TCP e lo collega alla prima
# porta ("TCPPORT1") con cui si vuole lavorare.
#
netServer1=tcpStream()
netServer1.open(None,TCPPORT1)
#
# Apre un altro socket TCP e lo collega alla seconda
# porta ("TCPPORT2") con cui si vuole lavorare.
#
netServer2=tcpStream()
netServer2.open(None,TCPPORT2)
#
# Crea due nuovi thread per gestire le richieste di servizio TCP.
# Il creatore e` il thread 0 (che rimane in attesa della condizione
# di arresto del programma), i creati sono i thread 1 e 2 (che
# gestiranno le richieste di connessione e servizio); i thread
# successivi, associati alla gestione delle richieste di servizio,
# avranno numeri da 3 in poi.
#
MasterLoopThread(netServer1,ms1).start()
MasterLoopThread(netServer2,ms2).start()
#
# Attende la condizione di uscita.
#
canContinue=True
while canContinue:
  pass
  # Si potrebbero inserire istruzioni NON BLOCCANTI
  # per poter arrestare il server anche da tastiera
  # oltre che da remoto!
netServer1.close()
netServer2.close()
print("Server arrestati.")

Notare:

Non è necessario associare esplicitamente una variabile ai thread che vengono istanziati.

Un server iterativo per controllo strumentazione

#
# Single task (iterative) server.
# Simulazione di controllo strumentazione.
#
import random
import sys
from tcpstream import *

TCPPORT=5555

def scrivilog(s):
  print(s)

def masterserver(net):
#
# Legge e processa dal socket "net" i comandi via via ricevuti.
#
  scrivilog("Ricevuta richiesta di servizio da {0:s}.".format(net.getRemoteName()))
  net.printf("+OK General Purpose Server\r\n")
  #
  # Master loop.
  #
  mul=100
  udm="V/m"
  while True:
    #
    # Accettazione dei comandi.
    #
    # I comandi hanno il seguente formato:
    # NOME arg1,arg2,...,argn
    #
    line=net.gets().split(' ')
    cmd=line[0].upper()
    if len(line)>1:
      args=line[1].split(',')
    #
    # Gestione dei comandi.
    #
    if cmd=="HELP":
      net.printf("Recognized commands:\r\n")
      net.printf("HELP\r\n")
      net.printf("MEASURE\r\n")
      net.printf("MODE E,high\r\n")
      net.printf("MODE E,low\r\n")
      net.printf("MODE B,high\r\n")
      net.printf("MODE B,low\r\n")
      net.printf("QUIT\r\n")
      net.printf("SHUT\r\n")
      net.printf("+OK General Purpose Server\r\n")
    elif cmd=="MEASURE":
      #
      # Qui si dovrebbe interagire con l'hardware!
      #
      val=random.random()*mul
      net.printf("+OK {0:.2f} {1:s}\r\n".format(val,udm))
    elif cmd=="MODE" and len(args)>1:
      #
      # Qui si dovrebbe interagire con l'hardware!
      #
      if args[0].upper()=='E':
        if args[1]=="high":
          mul=10
          udm="kV/m"
          net.printf("+OK E [kV/m] Mode set\r\n")
        elif args[1]=="low":
          mul=100
          udm="V/m"
          net.printf("+OK E [V/m] Mode set\r\n")
        else:
          net.printf("-ERR Command error\r\n")
      elif args[0].upper()=='B':
        if args[1]=="high":
          mul=10
          udm="mT"
          net.printf("+OK B [mT] Mode set\r\n")
        elif args[1]=="low":
          mul=100
          udm="uT"
          net.printf("+OK B [uT] Mode set\r\n")
        else:
          net.printf("-ERR Command error\r\n")
      else:
        net.printf("-ERR Command error\r\n")
    elif cmd=="QUIT":
      scrivilog("Richiesta di servizio da {0:s} completata.".format(net.getRemoteName()))
      net.printf("+OK Connection closed\r\n")
      net.close()
      return True  # significa lasciare il server acceso
    elif cmd=="SHUT":
      scrivilog("Richiesta di servizio da {0:s} completata.".format(net.getRemoteName()))
      net.printf("+OK Connection closed - server shutdown\r\n")
      net.close()
      return False # significa spengere il server
    else:
      net.printf("-ERR Command error\r\n")
# End of masterserver

Notare:

Non è necessario associare esplicitamente una variabile all'oggetto tcpStream restituito da acceptConnection.
I comandi operativi per gestire uno strumento di misura e simulare l'interazione con l'hardware.
La funzione scrivilog.
La portabilità di masterserver.
L'utilizzo di un server iterativo (cioè single-task) elimina i problemi di accesso concorrenziale all'hardware.

Un client general purpose PyQt orientato alla riga

#
# Client ASCII-TCP generico in modalita' PyQt.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qtcpstream import *

DEFSERVER="niremf.ifac.cnr.it"
DEFPORT=5210

#################################
# Classe della dialog principale.
#
class dBoxMain(QDialog):
  def __init__(self,args):
  #
  # Costruttore della dialog principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle("PyQt generic client")
    #
    # Costruzione dei widget.
    #
    self.btnConnect=QPushButton("Connessione",self)
    self.btnConnect.setEnabled(True)
    self.btnExit=QPushButton("Uscita",self)
    self.btnExit.setEnabled(True)
    #
    self.linInput=QLineEdit(self)
    self.linInput.setFont(QFont("Courier New",10))
    self.linInput.setEnabled(False)
    #
    self.txtOutput=QTextEdit(self)
    self.txtOutput.setFont(QFont("Courier New",10))
    self.txtOutput.setReadOnly(True)
    #
    # Definizione del layout.
    #
    hlt=QHBoxLayout()
    hlt.addWidget(self.btnConnect)
    hlt.addWidget(self.btnExit)
    hlt.addStretch()
    vlt=QVBoxLayout()
    vlt.addWidget(self.txtOutput)
    vlt.addWidget(self.linInput)
    vlt.addLayout(hlt)
    self.setLayout(vlt)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(self.btnConnect,SIGNAL("clicked(bool)"),self.doconnect)
    self.connect(self.btnExit,SIGNAL("clicked(bool)"),self.reject)
    self.connect(self.linInput,SIGNAL("editingFinished()"),self.trasmit)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.resize(600,400)
    self.show()
  #
  # Procedure operative della dialog box principale.
  #
  def doconnect(self):
    #
    # Costruisce la dialog box di richiesta
    # dei parametri di connessione.
    #
    dbd=QDialog(self)
    dbd.setWindowTitle("Parametri di connessione")
    lblServer=QLabel("&Server",dbd)
    linServer=QLineEdit(DEFSERVER,dbd)
    lblPort=QLabel("&Port",dbd)
    sbxPort=QSpinBox(dbd)
    sbxPort.setRange(1,9999)
    sbxPort.setSingleStep(1)
    sbxPort.setValue(DEFPORT)
    btnOk=QPushButton("Conferma",self)
    lblServer.setBuddy(linServer)
    lblPort.setBuddy(sbxPort)
    grd=QGridLayout()
    grd.addWidget(lblServer,0,0)
    grd.addWidget(linServer,0,1)
    grd.addWidget(lblPort,1,0)
    grd.addWidget(sbxPort,1,1)
    grd.addWidget(btnOk,2,0,1,2)
    dbd.setLayout(grd)
    dbd.connect(btnOk,SIGNAL("clicked(bool)"),dbd.accept)
    #
    # Esegue la dialog box di richiesta
    # dei parametri e se questa viene
    # chiusa con una conferma, procede
    # al collegamento.
    #
    if dbd.exec_():
      self.txtOutput.clear()
      self.net=tcpStream()
      self.net.open(linServer.text(),sbxPort.value())
      self.btnConnect.setEnabled(False)
      self.btnExit.setEnabled(False)
      self.linInput.setEnabled(True)
      #
      # Loop di attesa e ricezione dalla rete.
      #
      while True:
        #
        # Rimettiamo sempre il focus sul campo di input.
        #
        self.linInput.setFocus()
        #
        # Controllo chiusura connessione da parte del server.
        #
        if self.net.eof():
          self.net.close()
          self.btnConnect.setEnabled(True)
          self.btnExit.setEnabled(True)
          self.linInput.setEnabled(False)
          return
        #
        # Elaborazione degli eventi di sistema.
        #
        QApplication.processEvents()
        #
        # Gestione dati in arrivo.
        #
        while self.net.recvready():
          bufStr=self.net.gets()
          if bufStr!="":
            self.txtOutput.append("<span style='color: #0000a0;'>"+bufStr+"</span>")
  def trasmit(self):
    bufStr=self.linInput.text()
    if bufStr!="":
      self.txtOutput.append("<p style='color: #a00000;'>"+bufStr+"</p>")
      self.net.printf(bufStr+"\r\n")
    self.linInput.clear()
  def reject(self):
    if not self.btnExit.isEnabled():
      QMessageBox.information(self,"Attenzion",
        "Chiudi la connessione prima di chiudere l'applicazione!",
        QMessageBox.Ok,QMessageBox.NoButton)
      return
    else:
      QDialog.reject(self)
    
##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

Il widget QLineEdit ed il suo segnale editingFinished.
Il metodo setFocus.
L'inserimento nel loop dell'istruzione QApplication.processEvents().
La possibilità di utilizzare gli stili CSS-like per decorare il contenuto di QLineEdit, QTextEdit, QLabel.
Provare prima il funzionamento con l'account di posta di infinito, poi con il server locale di gestione strumentazione (lanciarlo!).

Un client PyQt per controllo remoto strumentazione

#
# PyQt client per controllo remoto strumentazione.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qtcpstream import *

SERVER="localhost"
TCPPORT=5555

#################################
# Classe della dialog principale.
#
class dBoxMain(QDialog):
  def __init__(self,args):
  #
  # Costruttore della dialog principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle("Controllo remoto strumentazione")
    self.mode="E,low"
    #
    # Costruzione dei widget.
    #
    gbx1=QGroupBox(self)
    gbx1.setEnabled(True)
    gbx1.setTitle("Cosa misurare")
    self.rdbE=QRadioButton("Campo E",gbx1)
    self.rdbE.setChecked(True)
    self.rdbB=QRadioButton("Campo B",gbx1)
    #
    self.gbx2=QGroupBox(self)
    self.gbx2.setEnabled(True)
    self.gbx2.setTitle("Campo elettrico")
    self.rdbE1=QRadioButton("V/m",self.gbx2)
    self.rdbE1.setChecked(True)
    self.rdbE2=QRadioButton("kV/m",self.gbx2)
    #
    self.gbx3=QGroupBox(self)
    self.gbx3.setEnabled(False)
    self.gbx3.setTitle("Induzione magnetica")
    self.rdbB1=QRadioButton("\u03bcT",self.gbx3)
    self.rdbB1.setChecked(True)
    self.rdbB2=QRadioButton("mT",self.gbx3)
    #
    btnMeasure=QPushButton("Misura",self)
    self.lblResult=QLabel(self)
    self.lblResult.setAlignment(Qt.AlignCenter)
    self.lblResult.setFont(QFont("Courier New",12))
    self.lblResult.setFrameStyle(QFrame.WinPanel | QFrame.Sunken)
    lblWarning=QLabel("NB: questo client lavora sulla porta {0:d}".format(TCPPORT),self)
    lblWarning.setAlignment(Qt.AlignCenter)
    #
    # Definizione del layout.
    #
    vlt1=QVBoxLayout()
    vlt1.addWidget(self.rdbE)
    vlt1.addWidget(self.rdbB)
    gbx1.setLayout(vlt1)
    #
    vlt2=QVBoxLayout()
    vlt2.addWidget(self.rdbE1)
    vlt2.addWidget(self.rdbE2)
    self.gbx2.setLayout(vlt2)
    #
    vlt3=QVBoxLayout()
    vlt3.addWidget(self.rdbB1)
    vlt3.addWidget(self.rdbB2)
    self.gbx3.setLayout(vlt3)
    #
    hltA=QHBoxLayout()
    hltA.addWidget(gbx1)
    hltA.addWidget(self.gbx2)
    hltA.addWidget(self.gbx3)
    #
    hltB=QHBoxLayout()
    hltB.addWidget(btnMeasure)
    hltB.addWidget(self.lblResult)
    #
    vlt=QVBoxLayout()
    vlt.addLayout(hltA)
    vlt.addLayout(hltB)
    vlt.addWidget(lblWarning)
    self.setLayout(vlt)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(self.rdbE,SIGNAL("toggled(bool)"),self.setup)
    self.connect(self.rdbE1,SIGNAL("toggled(bool)"),self.setup)
    self.connect(self.rdbE2,SIGNAL("toggled(bool)"),self.setup)
    self.connect(self.rdbB,SIGNAL("toggled(bool)"),self.setup)
    self.connect(self.rdbB1,SIGNAL("toggled(bool)"),self.setup)
    self.connect(self.rdbB2,SIGNAL("toggled(bool)"),self.setup)
    self.connect(btnMeasure,SIGNAL("clicked(bool)"),self.measure)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def setup(self):
    if self.rdbE.isChecked():
      self.gbx2.setEnabled(True)
      self.gbx3.setEnabled(False)
      if self.rdbE1.isChecked():
        self.mode="E,low"
      elif self.rdbE2.isChecked():
        self.mode="E,high"
    elif self.rdbB.isChecked():
      self.gbx2.setEnabled(False)
      self.gbx3.setEnabled(True)
      if self.rdbB1.isChecked():
        self.mode="B,low"
      elif self.rdbB2.isChecked():
        self.mode="B,high"
  def measure(self):
    net=tcpStream()
    net.open(SERVER,TCPPORT)
    #
    # Attende l'OK iniziale del server.
    #
    while net.gets()[0:3]!="+OK":
      pass
    #
    # Invia il comando per impostare il modo
    # di misura e attende l'OK di conferma.
    #
    net.printf("MODE "+self.mode+"\r\n")
    while net.gets()[0:3]!="+OK":
      pass
    #
    # Invia il comando di misura e attende
    # l'OK di conferma (contenente anche
    # il valore misurato).
    #
    net.printf("MEASURE\r\n")
    s=""
    while s[0:3]!="+OK":
      s=net.gets()
    #
    # Estrae e mostra il valore misurato.
    #
    (val,udm)=s[4:].split(' ')
    if udm=="uT":
      udm="\u03bcT"
    self.lblResult.setText("{0:5.2f} {1:3s}".format(eval(val),udm))
    #
    # Invia il comando di chiusura, attende
    # la chiusura lato server quindi chiude
    # a sua volta la connessione.
    #
    net.printf("QUIT\r\n")
    while net.gets()[0:3]!="+OK":
      pass
    while not net.eof():
      pass
    net.close()

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

Il metodo setFrameStyle: vedere qui.
La modalità open-exec-close minimizza i problemi di accesso concorrenziale all'hardware.

Un server PyQt concorrente per controllo strumentazione (senza gestione conflitti)

#
# PyQt concurrent server.
# Simulazione di controllo strumentazione.
# Senza gestione conflitti.
#
import random
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qtcpstream import *

TCPPORT=5555

mul=100
udm="V/m"

def scrivilog(s):
  global dbm
  dbm.textLog.append(s)

def masterserver(net):
#
# Legge e processa dal socket "net" i comandi via via ricevuti.
#
  global mul,udm
  scrivilog("Ricevuta richiesta di servizio da {0:s}.".format(net.getRemoteName()))
  net.printf("+OK General Purpose Server\r\n")
  #
  # Master loop.
  #
  while True:
    #
    # Accettazione dei comandi.
    #
    # I comandi hanno il seguente formato:
    # NOME arg1,arg2,...,argn
    #
    line=net.gets().split(' ')
    cmd=line[0].upper()
    if len(line)>1:
      args=line[1].split(',')
    #
    # Gestione dei comandi.
    #
    if cmd=="HELP":
      net.printf("Recognized commands:\r\n")
      net.printf("HELP\r\n")
      net.printf("MEASURE\r\n")
      net.printf("MODE E,high\r\n")
      net.printf("MODE E,low\r\n")
      net.printf("MODE B,high\r\n")
      net.printf("MODE B,low\r\n")
      net.printf("QUIT\r\n")
      net.printf("SHUT\r\n")
      net.printf("+OK General Purpose Server\r\n")
    elif cmd=="MEASURE":
      #
      # Qui si dovrebbe interagire con l'hardware!
      #
      val=random.random()*mul
      net.printf("+OK {0:.2f} {1:s}\r\n".format(val,udm))
    elif cmd=="MODE" and len(args)>1:
      #
      # Qui si dovrebbe interagire con l'hardware!
      #
      if args[0].upper()=='E':
        if args[1]=="high":
          mul=10
          udm="kV/m"
          net.printf("+OK E [kV/m] Mode set\r\n")
        elif args[1]=="low":
          mul=100
          udm="V/m"
          net.printf("+OK E [V/m] Mode set\r\n")
        else:
          net.printf("-ERR Command error\r\n")
      elif args[0].upper()=='B':
        if args[1]=="high":
          mul=10
          udm="mT"
          net.printf("+OK B [mT] Mode set\r\n")
        elif args[1]=="low":
          mul=100
          udm="uT"
          net.printf("+OK B [uT] Mode set\r\n")
        else:
          net.printf("-ERR Command error\r\n")
      else:
        net.printf("-ERR Command error\r\n")
    elif cmd=="QUIT":
      scrivilog("Richiesta di servizio da {0:s} completata.".format(net.getRemoteName()))
      net.printf("+OK Connection closed\r\n")
      net.close()
      return True  # significa lasciare il server acceso
    elif cmd=="SHUT":
      scrivilog("Richiesta di servizio da {0:s} completata.".format(net.getRemoteName()))
      net.printf("+OK Connection closed - server shutdown\r\n")
      net.close()
      return False # significa spengere il server
    else:
      net.printf("-ERR Command error\r\n")
# End of masterserver

#################################
# Classe della dialog principale.
#
class dBoxMain(QDialog):
  def __init__(self,args):
  #
  # Costruttore della dialog principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle("Server per controllo strumentazione")
    self.isrunning=False
    #
    # Costruzione dei widget.
    #
    lblPort=QLabel("&Port",self)
    self.cbxPort=QComboBox(self)
    self.cbxPort.addItems(["{0:d}".format(x) for x in range(4001,6001)])
    self.cbxPort.setCurrentIndex(TCPPORT-4001)
    #
    self.btnRnSt=QPushButton("Run",self)
    btnExit=QPushButton("Exit",self)
    #
    self.lblRunning=QLabel(self)
    self.lblRunning.setAlignment(Qt.AlignCenter)
    self.lblRunning.setStyleSheet("background-color: transparent;")
    self.lblRunning.setText("")
    #
    self.textLog=QTextEdit(self)
    self.textLog.setReadOnly(True)
    self.textLog.setFont(QFont("Courier New",9))
    #
    # NB: quello che segue non e' un widget, ma lo metto
    # qui perche' deve stare comunque prima dell'associazione
    # eventi-metodi.
    #
    self.netServer=tcpServer(masterserver,self)
    #
    # Amicizia Label-Controlli.
    #
    lblPort.setBuddy(self.cbxPort)
    #
    # Definizione del layout.
    #
    grd=QGridLayout()
    grd.addWidget(lblPort,0,0)
    grd.addWidget(self.cbxPort,0,1)
    grd.addWidget(self.btnRnSt,0,2)
    grd.addWidget(self.lblRunning,0,3)
    grd.setColumnStretch(4,10)
    grd.addWidget(btnExit,0,5)
    grd.addWidget(self.textLog,1,0,1,6)
    self.setLayout(grd)
    self.resize(400,300)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(self.btnRnSt,SIGNAL("clicked(bool)"),self.runstop)
    self.connect(btnExit,SIGNAL("clicked(bool)"),self.reject)
    self.connect(self.netServer,SIGNAL("closerequest()"),self.runstop)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.textLog.setPlainText("Scegli la porta e premi RUN\n")
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def runstop(self):
    if not self.isrunning:
      self.port=int(self.cbxPort.currentText())
      self.textLog.append("In ascolto sulla porta {0:d}.".format(self.port))
      self.btnRnSt.setText("Stop")
      self.lblRunning.setStyleSheet("color: #ff0000; background-color: #ffff00; font-weight: 600;")
      self.lblRunning.setText("RUNNING")
      self.isrunning=True
      self.netServer.listen(QHostAddress.Any,self.port)
    else:
      self.textLog.append("Server arrestato.\n")
      self.btnRnSt.setText("Run")
      self.lblRunning.setStyleSheet("background-color: transparent;")
      self.lblRunning.setText("")
      self.isrunning=False
      self.netServer.close()
  def reject(self):
    if self.isrunning:
      self.netServer.close()
    QDialog.reject(self)

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

L'utilizzo di oggetti PyQt (QTcpServer e QThread).
Il metodo setStyleSheet.
Il metodo emit.
Il problema del controllo dell'accesso alle risorse hardware (provare per esempio a portare fuori mul e udm e indicarle come globali in masterserver.

Un server PyQt concorrente per controllo strumentazione (con gestione conflitti)

#
# PyQt concurrent server.
# Simulazione di controllo strumentazione.
# Con gestione conflitti.
#
import random
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qtcpstream import *

TCPPORT=5555

mul=100
udm="V/m"
#
# "0" significa hardware libero; altrimenti contiene il fileno()
# del socket che gestisce la connessione dal lato server.
#
busy=0

def scrivilog(s):
  global dbm
  dbm.textLog.append(s)

def masterserver(net):
#
# Legge e processa dal socket "net" i comandi via via ricevuti.
#
  global mul,udm,busy
  scrivilog("Ricevuta richiesta di servizio da {0:s}.".format(net.getRemoteName()))
  net.printf("+OK General Purpose Server\r\n")
  #
  # Se l'hardware e' libero ne prende possesso!
  #
  if busy==0:
    busy=net.fileno()
  #
  # Master loop.
  #
  while True:
    #
    # Accettazione dei comandi.
    #
    # I comandi hanno il seguente formato:
    # NOME arg1,arg2,...,argn
    #
    line=net.gets().split(' ')
    cmd=line[0].upper()
    if len(line)>1:
      args=line[1].split(',')
    #
    # Gestione dei comandi.
    #
    if cmd=="HELP":
      net.printf("Recognized commands:\r\n")
      net.printf("HELP\r\n")
      net.printf("MEASURE\r\n")
      if busy==net.fileno():
        #
        # Questo processo ha in gestione l'hardware!
        #
        net.printf("MODE E,high\r\n")
        net.printf("MODE E,low\r\n")
        net.printf("MODE B,high\r\n")
        net.printf("MODE B,low\r\n")
      net.printf("QUIT\r\n")
      net.printf("SHUT\r\n")
      net.printf("+OK General Purpose Server\r\n")
    elif cmd=="MEASURE":
      #
      # Qui si dovrebbe interagire con l'hardware!
      #
      val=random.random()*mul
      net.printf("+OK {0:.2f} {1:s}\r\n".format(val,udm))
    elif cmd=="MODE" and len(args)>1:
      if busy==net.fileno():
        #
        # Questo processo ha in gestione l'hardware!
        #
        # Qui si dovrebbe interagire con l'hardware!
        #
        if args[0].upper()=='E':
          if args[1]=="high":
            mul=10
            udm="kV/m"
            net.printf("+OK E [kV/m] Mode set\r\n")
          elif args[1]=="low":
            mul=100
            udm="V/m"
            net.printf("+OK E [V/m] Mode set\r\n")
          else:
            net.printf("-ERR Command error\r\n")
        elif args[0].upper()=='B':
          if args[1]=="high":
            mul=10
            udm="mT"
            net.printf("+OK B [mT] Mode set\r\n")
          elif args[1]=="low":
            mul=100
            udm="uT"
            net.printf("+OK B [uT] Mode set\r\n")
          else:
            net.printf("-ERR Command error\r\n")
        else:
          net.printf("-ERR Command error\r\n")
      else:
        net.printf("-ERR hardware busy\r\n")
    elif cmd=="QUIT":
      scrivilog("Richiesta di servizio da {0:s} completata.".format(net.getRemoteName()))
      net.printf("+OK Connection closed\r\n")
      net.close()
      if busy:
        busy=False
      return True  # significa lasciare il server acceso
    elif cmd=="SHUT":
      scrivilog("Richiesta di servizio da {0:s} completata.".format(net.getRemoteName()))
      net.printf("+OK Connection closed - server shutdown\r\n")
      net.close()
      return False # significa spengere il server
    else:
      net.printf("-ERR Command error\r\n")
# End of masterserver

#################################
# Classe della dialog principale.
#
class dBoxMain(QDialog):
  def __init__(self,args):
  #
  # Costruttore della dialog principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle("Server per controllo strumentazione")
    self.isrunning=False
    #
    # Costruzione dei widget.
    #
    lblPort=QLabel("&Port",self)
    self.cbxPort=QComboBox(self)
    self.cbxPort.addItems(["{0:d}".format(x) for x in range(4001,6001)])
    self.cbxPort.setCurrentIndex(TCPPORT-4001)
    #
    self.btnRnSt=QPushButton("Run",self)
    btnExit=QPushButton("Exit",self)
    #
    self.lblRunning=QLabel(self)
    self.lblRunning.setAlignment(Qt.AlignCenter)
    self.lblRunning.setStyleSheet("background-color: transparent;")
    self.lblRunning.setText("")
    #
    self.textLog=QTextEdit(self)
    self.textLog.setReadOnly(True)
    self.textLog.setFont(QFont("Courier New",9))
    #
    # NB: quello che segue non e' un widget, ma lo metto
    # qui perche' deve stare comunque prima dell'associazione
    # eventi-metodi.
    #
    self.netServer=tcpServer(masterserver,self)
    #
    # Amicizia Label-Controlli.
    #
    lblPort.setBuddy(self.cbxPort)
    #
    # Definizione del layout.
    #
    grd=QGridLayout()
    grd.addWidget(lblPort,0,0)
    grd.addWidget(self.cbxPort,0,1)
    grd.addWidget(self.btnRnSt,0,2)
    grd.addWidget(self.lblRunning,0,3)
    grd.setColumnStretch(4,10)
    grd.addWidget(btnExit,0,5)
    grd.addWidget(self.textLog,1,0,1,6)
    self.setLayout(grd)
    self.resize(400,300)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(self.btnRnSt,SIGNAL("clicked(bool)"),self.runstop)
    self.connect(btnExit,SIGNAL("clicked(bool)"),self.reject)
    self.connect(self.netServer,SIGNAL("closerequest()"),self.runstop)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.textLog.setPlainText("Scegli la porta e premi RUN\n")
    self.show()

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

L'utilizzo del metodo fileno dell'oggetto tcpStream (ereditato da socket.socket) per etichettare il gestore corrente dell'hardware.

Ritorna alla pagina indice

Daniele Andreuccetti, IFAC-CNR, febbraio 2013