Applicazioni TCP/IP. Maurizio Cozzetto. Brescia 20 agosto 2014

Transcript

1 Applicazioni TCP/IP Maurizio Cozzetto Brescia 20 agosto 2014 Un po' di teoria Ricordiamo che un'applicazione distribuita e un'applicazione composta da piu programmi (almeno 2) posti in esecuzione su macchine diverse all'interno di una rete di calcolatori e che utilizzano un protocollo di comunicazione comune. I pc connessi a Internet comunicano tra loro usando diversi protocolli tra cui il piu famoso e forse il TCP/IP (Transmission Control Protocol/Internet Protocol) ben supportato da Java. Un altro protocollo e l'udp (User Datagram Protocol). Il protocollo TCP/IP viene definito protocollo connection-oriented, orientato alla connessione, cioe garantisce che i pacchetti inviati arrivino a destinazione (se vi e un qualche errore il destinatario chiede la ritrasmissione del pacchetto), mentre l'udp non garantisce l'arrivo di tutti i pacchetti e viene definito connection-less. E' preferito in genere in tutti quei casi in cui perdite contenute di informazione durante la trasmissione sono trascurabili (come nelle trasmissioni audio-video) e quello che conta invece e la velocita di trasmissione. Java utilizza per la comunicazione in rete il paradigma di programmazione basato sul concetto di socket, progettato presso l'universita di Berkley (California). Socket Il socket puo essere definito come un punto terminale o di aggancio di una linea di comunicazione da cui un programma puo inviare i dati in rete e puo ricevere i dati dalla rete. Il socket (la traduzione letterale e presa di corrente) e un'astrazione software che e in qualche modo l'equivalente della presa elettrica per gli apparecchi elettrici. In pratica un socket e una coppia di valori, il primo identifica un computer e il secondo un processo sul computer: scendendo piu in dettaglio un socket e formato da un indirizzo IP (4 byte o 8 byte a seconda della versione dello standard IP, IPv4 o IPv6) che identifica un computer sulla rete e da un numero di porta TCP (2 byte) che identifica un processo o un'applicazione in esecuzione. Il socket rappresenta solo uno dei due capi di una comunicazione; due computer per comunicare usano ciascuno un socket e tra i due socket si crea una connessione (full-duplex) per il trasferimento dei dati in due direzioni. La realizzazione di applicazioni client/server in Java come vedremo tra poco si basa sulle classi contenute nel package java.net e in particolare sulle classi InetAddress, ServerSocket e Socket (per maggiori dettagli sui metodi posseduti dalle classi, consulta il libro di testo). Ricordiamo brevemente che un programma e detto client (front-end) se richiede un servizio a un programma detto server (back-end) che fornisce il servizio richiesto e poi si rimette in ascolto in attesa di ulteriori richieste da parte di altri client. É un modello asimmetrico (in contrapposizione col modello UDP che invece e simmetrico) chiamato anche request-replay perche si basa sul susseguirsi di richieste e risposte. Puo accadere frequentemente che su un server vi siano in esecuzione servizi diversi per cui, per distinguerli, si usa un numero identificativo del servizio, la porta appunto. Pag. 1/20

2 Per esempio su una macchina server, potrebbero girare il server web Apache (o il server web Tomcat, un server web Java che quindi richiede una JVM già installata, o entrambi) e il database server MySQL. Un web server fornisce solitamente pagine web statiche o dinamiche (se il server dispone di un opportuno interprete di un certo linguaggio come PHP o Java), un database server dati organizzati in un database relazionale. Le porte impiegate sono quasi sempre la porta 80 per il server web Apache, la porta 8080 per il web server Tomcat e la porta 3306 per il database server MySQL. Se si vogliono usare porte differenti, occorre configurare i server editando opportunamente determinati file di configurazione. Le porte dalla 0 alla 1023 sono riservate ai principali servizi di rete conosciuti e sono dette anche Well Known Ports, le porte dalla 1024 alla sono le Registered Ports, mentre le porte dalla alla sono le Dynamic and/or Private Ports. Per un elenco parziale delle Well Known Ports, consulta Inoltre un server singlethread (o server unicast o singlecast) e un server che comunica con un solo client alla volta (se esistono altri client, ogni cliente deve attendere il proprio turno), mentre se il server e multithread (o server multicast) al server possono connettersi contemporaneamente piu client (per ogni client, il server attiva un thread distinto) e poi si rimette in ascolto di nuove connessioni. Fig. 1. Un server multithread gestisce la comunicazione con 2 client mediante due oggetti di tipo Socket. L'oggetto di tipo ServerSocket è detto socket di benvenuto (Welcome socket) e provvede a creare i socket di comunicazione coi client per ogni richiesta. Altra considerazione importante e che, una volta stabilita la connessione, la comunicazione tra client e server e basata sulla comunicazione tra flussi di dati (stream), cioe inviare dati equivale a scrivere file mentre ricevere dati equivale a leggere file. In questo articolo, per ragioni di brevità, prenderemo in esame solo il protocollo TCP/IP. Pag. 2/20

3 Server unicast Cominciamo col vedere le istruzioni fondamentali per la creazione di un server unicast, che accetta richieste da parte di un client, fornisce la risposta (trasforma una stringa inviata dal client in maiuscolo) e quindi si rimettere in ascolto di una nuova richiesta. Il server, se riceve piu richieste, le mette in una coda di attesa, per cui fornisce il servizio ad un client alla volta. /* * TCPServer.java package it.mauriziocozzetto.tcpclientserver.simple; import java.io.bufferedreader; import java.io.bufferedwriter; import java.io.ioexception; import java.io.inputstreamreader; import java.net.serversocket; import java.net.socket; /** maurizio public class TCPServer { public static void main(string[] args) throws IOException { // Crea un serversocket sulla porta 6789 ServerSocket serversocket = new ServerSocket(6789); while (true) { System.out.println("Server in ascolto sulla porta " + serversocket.getlocalport() + "..."); // Attesa di una richiesta di connessione da parte di un client Socket clientsocket = serversocket.accept(); // Stream di input bufferizzato proveniente dal client BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); // Stream di output verso il client BufferedWriter out = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream())); // Legge i dati provenienti dal client String clientsentence = in.readline(); System.out.println("Stringa ricevuta: " + clientsentence); // Il server provvede a rendere maiuscola la stringa ricevuta dal client String capitalizedsentence = clientsentence.touppercase(); // Il server invia la stringa verso il client out.write(capitalizedsentence); // Invio di una nuova linea out.newline(); Pag. 3/20

4 // Forza l'invio dei dati verso il client out.flush(); // Chiusura degli stream e del socket in.close(); out.close(); clientsocket.close(); // Fine while // Fine main // Fine classe TCPServer Non avremmo in teoria bisogno di scrivere un client per testare questo server: si puo usare telnet. Ogni volta che premiamo <invio>, cio che abbiamo inserito viene spedito al server e che quello che viene inviato dal server viene scritto sullo schermo. Presenteremo in ogni caso successivamente un client Java per questioni di completezza. Fig. 2. Il telnet in azione. Il server in questo caso gira localmente. Il comando telnet richiede due parametri: il nome o l'indirizzo IP del server e la porta su cui esso risponde. Ecco invece il codice del client Java. /* * TCPClient.java package it.mauriziocozzetto.tcpclientserver.simple; import java.io.bufferedreader; import java.io.bufferedwriter; import java.io.ioexception; import java.io.inputstreamreader; import java.net.socket; import java.util.scanner; Pag. 4/20

5 /** maurizio public class TCPClient { public static void main(string[] args) throws IOException { // Creazione di un socket sulla porta 6789 sulla macchina "localhost" Socket clientsocket = new Socket("localhost", 6789); // Stream proveniente dal server BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); // Stream diretto verso il server BufferedWriter out = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream())); // Lettura dei dati da tastiera Scanner input = new Scanner(System.in); System.out.print("Inserisci una frase: "); String sentence = input.nextline(); // Invio dei dati dati al server out.write(sentence); // Nuova riga out.newline(); // Forza l'invio dei dati verso il server out.flush(); // Lettura della stringa dal server (il server la trasforma in maiuscolo) String modifiedsentence = in.readline(); // Stampa sulla console System.out.println("Dal server: " + modifiedsentence); // Chiusura degli stream e del socket in.close(); out.close(); clientsocket.close(); // Fine metodo main // Fine classe TCPClient Per provare il programma, dobbiamo prima lanciare il server e successivamente uno o piu client, altrimenti avremo degli errori in fase di esecuzione (in particolare si ottiene l'eccezione Connection refused). Ecco il risultato dell'esecuzione. Partiamo dal server. Server in ascolto sulla porta Stringa ricevuta: ciao come ti va? Server in ascolto sulla porta Pag. 5/20

6 Per un client Java, abbiamo: Inserisci una frase: ciao come ti va? Dal server: CIAO COME TI VA? BUILD SUCCESSFUL (total time: 1 minute 38 seconds) Possiamo notare che il client termina regolarmente la sua esecuzione, mentre il server rimane indefinitivamente in attesa. Per arrestare il server, dobbiamo interromperlo dall'ide o dobbiamo uccidere il relativo processo. Loop di richiesta Se vogliamo consentire ad un singolo client di ripetere la richiesta inviando piu stringhe al server, dobbiamo modificare non solo il codice del client ma anche il codice del server, inserendo due loop distinti. Nel loop del client, la condizione di arresto e l'inserimento della stringa 0 (oppure fine o FINE o qualsiasi altra stringa), mentre nel loop del server la condizione di uscita e in.readline() == null. Infatti, se il client chiude la connessione quando l'utente inserisce la stringa 0, in.readline() e null (in e l'oggetto di tipo BufferedReader associato al socket). Per brevità, riportiamo solo i frammenti di codice relativi ai loop. Per il client: // Preparazione dell'oggetto associato alla tastiera Scanner input = new Scanner(System.in); while(true) { // Lettura della stringa System.out.print("Inserisci una frase (0 per terminare): "); String sentence = input.nextline(); if (sentence.equals("0")) { break; // Invio dei dati dati al server out.write(sentence); out.newline(); out.flush(); // Lettura della stringa dal server (il server la trasforma in maiuscolo) String modifiedsentence = in.readline(); // Stampa sulla console System.out.println("Dal server: " + modifiedsentence); Per il server: while (true) { // Legge i dati provenienti dal client String clientsentence = in.readline(); if (clientsentence == null) { System.out.println("Il client ha chiuso la connessione"); break; Pag. 6/20

7 System.out.println("Stringa ricevuta: " + clientsentence); // Il server provvede a rendere maiuscola la stringa ricevuta dal client String capitalizedsentence = clientsentence.touppercase(); // Il server invia la stringa verso il client out.write(capitalizedsentence); out.newline(); out.flush(); // Fine while Ecco l'output prodotto dal programma (parte client): Inserisci una frase (0 per terminare): Questa è la frase 1 Dal server: QUESTA È LA FRASE 1 Inserisci una frase (0 per terminare): Questa è la frase 2 Dal server: QUESTA È LA FRASE 2 Inserisci una frase (0 per terminare): Questa è la frase 3 Dal server: QUESTA È LA FRASE 3 Inserisci una frase (0 per terminare): 0 BUILD SUCCESSFUL (total time: 29 seconds) Output prodotto dal server: Server in ascolto sulla porta Stringa ricevuta: Questa è la frase 1 Stringa ricevuta: Questa è la frase 2 Stringa ricevuta: Questa è la frase 3 Il client ha chiuso la connessione Server in ascolto sulla porta Classi wrapper Possiamo riscrivere l'applicativo precedente considerando due thread distinti, uno per il client e uno per il server e aggiungendo inoltre alcune informazioni (indirizzo IP, porta ecc) sulle connessioni stabilite. Partiamo dal codice del server. /* * TCPUnicastServerThread.java package it.mauriziocozzetto.tcpclientserver.unicast; import java.io.bufferedreader; import java.io.bufferedwriter; import java.io.ioexception; import java.io.inputstreamreader; import java.net.serversocket; import java.net.socket; /** maurizio public class TCPUnicastServerThread extends Thread { private ServerSocket serversocket; Pag. 7/20

8 public TCPUnicastServerThread(int portnumber) throws IOException { serversocket = new ServerSocket(portNumber); System.out.println("Informazioni sul server"); public void run() { while (true) { try { System.out.println("Server in ascolto..."); // Attesa di una richiesta di connessione Socket clientsocket = serversocket.accept(); System.out.println("Informazioni sul client"); System.out.println(clientSocket.toString()); // Stream di input e di output da e verso il client BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); BufferedWriter out = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream())); //Ricezione della stringa dal client String clientsentence = in.readline(); System.out.println("Stringa ricevuta: " + clientsentence); // Trasformazione in maiuscolo della stringa e invio al client String capitalizedsentence = clientsentence.touppercase(); out.write(capitalizedsentence); out.newline(); out.flush(); // Chiusura degli stream e del socket in.close(); out.close(); clientsocket.close(); catch (IOException e) { e.printstacktrace(); // Fine try-catch // Fine while // Fine metodo run public static void main(string argv[]) throws Exception { TCPUnicastServerThread serverthread = new TCPUnicastServerThread(6789); serverthread.start(); // Fine classe TCPUnicastServerThread Segue codice del client. /* * TCPClientThread.java Pag. 8/20

9 package it.mauriziocozzetto.tcpclientserver.unicast; import java.io.bufferedreader; import java.io.bufferedwriter; import java.io.ioexception; import java.io.inputstreamreader; import java.net.socket; import java.util.scanner; /** maurizio public class TCPClientThread extends Thread { private Socket clientsocket; public TCPClientThread(String hostname, int portnumber) throws IOException { clientsocket = new Socket(hostname, portnumber); System.out.println("Informazioni sul client"); System.out.println(clientSocket); // Fine costruttore public void run() { try { // Stream da e verso il server BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); BufferedWriter out = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream())); // Lettura della stringa da tastiera System.out.print("Inserisci una frase: "); Scanner input = new Scanner(System.in); String sentence = input.nextline(); // Invio della stringa al server out.write(sentence); out.newline(); out.flush(); // Ricezione della stringa convertita in maiuscolo e stampa String modifiedsentence = in.readline(); System.out.println("Dal server: " + modifiedsentence); // Chiusura degli stream e del socket in.close(); out.close(); clientsocket.close(); catch (IOException e) { e.printstacktrace(); // Fine try-catch public static void main(string argv[]) throws Exception { TCPClientThread clientthread = new TCPClientThread("localhost", 6789); Pag. 9/20

10 clientthread.start(); // Fine metodo main // Fine classe TCPClientThread Segue un esempio di esecuzione con un solo client. Informazioni sul client Socket[addr=localhost/ ,port=6789,localport=52269] Inserisci una frase: Ciao, come ti va? Dal server: CIAO, COME TI VA? BUILD SUCCESSFUL (total time: 9 seconds) Questo e l'output prodotto dal server. Informazioni sul server ServerSocket[addr= / ,localport=6789] Server in ascolto... Informazioni sul client Socket[addr=/ ,port=52269,localport=6789] Stringa ricevuta: Ciao, come ti va? Server in ascolto... Come si puo notare, la porta del client e un numero scelto dal sistema operativo. Server multicast I casi precedenti sono semplici esempi di servizi di tipo iterativo. Nei casi piu realistici, occorre implementare invece un server concorrente che crea uno specifico thread di comunicazione con il client, rendendo possibile l'accettazione di ulteriori richieste di connessione nello stesso tempo in cui sono gestiti uno o piu client. Riportiamo solo il codice del server e del thread creato dal server (il thread crea gli stream di comunicazione e si preoccupa di convertire la stringa ricevuta dal client in maiuscolo), mentre il codice del client rimane lo stesso dell'esempio precedente. /* * TCPMulticastServerThread.java package it.mauriziocozzetto.tcpclientserver.multicast; import java.io.ioexception; import java.net.serversocket; import java.net.socket; /** maurizio public class TCPMulticastServerThread extends Thread { private ServerSocket serversocket; public TCPMulticastServerThread(int portnumber) throws IOException { serversocket = new ServerSocket(portNumber); System.out.println("Informazioni sul server"); public void run() { Pag. 10/20

11 while (true) { try { System.out.println("Server in ascolto..."); // Attesa di una richiesta di connessione Socket clientsocket = serversocket.accept(); System.out.println("Informazioni sul client"); System.out.println(clientSocket.toString()); // Creazione e lancio del thread StringCapitalizerThread thread = new StringCapitalizerThread(clientSocket); thread.start(); catch (IOException e) { e.printstacktrace(); // Fine while // Fine metodo run public static void main(string argv[]) throws Exception { TCPMulticastServerThread serverthread = new TCPMulticastServerThread(6789); serverthread.start(); // fine classe TCPMulticastServerThread Segue codice del thread. /* * StringCapitalizerThread.java package it.mauriziocozzetto.tcpclientserver.multicast; import java.io.bufferedreader; import java.io.bufferedwriter; import java.io.ioexception; import java.io.inputstreamreader; import java.net.socket; /** maurizio public class StringCapitalizerThread extends Thread { private Socket socket; public StringCapitalizerThread(Socket socket) throws IOException { this.socket = public void run() { try { // Stream di input e di output da e verso il client BufferedReader in = new BufferedReader(new InputStreamReader(this.socket.getInputStream())); BufferedWriter out = new BufferedWriter(new OutputStreamWriter(this.socket.getOutputStream())); Pag. 11/20

12 //Ricezione della stringa dal client String clientsentence = in.readline(); System.out.println("Stringa ricevuta: " + clientsentence); // Trasformazione in maiuscolo della stringa e invio al client String capitalizedsentence = clientsentence.touppercase(); out.write(capitalizedsentence); out.newline(); out.flush(); // Chiusura degli stream e del socket in.close(); out.close(); this.socket.close(); catch (IOException e) { e.printstacktrace(); // Fine metodo run // Fine classe StringCapitalizerThread Ecco l'output prodotto dal programma. Nel nostro caso, ci sono due client il cui arrivo e sequenziale, ma si puo ipotizzare tranquillamente che essi arrivino contemporaneamente. Output del server. Informazioni sul server ServerSocket[addr= / ,localport=6789] Server in ascolto... Informazioni sul client Socket[addr=/ ,port=53162,localport=6789] Server in ascolto... Stringa ricevuta: Hello, how are you? Informazioni sul client Socket[addr=/ ,port=53169,localport=6789] Server in ascolto... Stringa ricevuta: Ciao, come stai? Output dei client. Informazioni sul client Socket[addr=localhost/ ,port=6789,localport=53162] Inserisci una frase: Hello, how are you? Dal server: HELLO, HOW ARE YOU? BUILD SUCCESSFUL (total time: 10 seconds) Informazioni sul client Socket[addr=localhost/ ,port=6789,localport=53169] Inserisci una frase: Ciao, come stai? Dal server: CIAO, COME STAI? BUILD SUCCESSFUL (total time: 21 seconds) Implementazione di un protocollo testuale Di solito il thread di comunicazione col client implementa un protocollo applicativo di tipo testuale in base al quale il client invia una richiesta in forma di stringa di caratteri, il server la interpreta e successivamente risponde al client inviando la stringa di caratteri che soddisfa alle regole imposte dal Pag. 12/20

13 protocollo. Nel nostro caso, il protocollo testuale e basato sui seguenti comandi terminati dai caratteri CR (codice ASCII 13 o 0xD in esadecimale) e LF (codice ASCII 10 o 0xA): M,stringa m,stringa V,stringa S,stringa,inizio,fine Esempi di comandi del protocollo sono le stringhe M,ciao come stai? che richiede che la stringa posta dopo la M sia trasformata in maiuscolo (risultato: CIAO COME STAI?), oppure m,hello WORLD! che richiede che la stringa che segue la m minuscola sia trasformata in minuscolo (risultato: hello world!), oppure V,ciao come state? che richiede il conteggio delle vocali contenute nella stringa (risultato: 7 come oggetto stringa; se serve il valore numerico, ricorriamo al metodo statico parseint() della classe Integer). A tale proposito, presentiamo la classe CommandParser che valuta i comandi e la classe CommandParserTest che acquisisce le stringhe da analizzare da un file di testo, le interpreta correttamente e crea un file risultato. Per semplificare ulteriormente la gestione dell'input e dell'output di un file testuale, usiamo la libreria stdlib.jar sviluppata presso l'università di Princeton ( contiene i sorgenti, la libreria in formato jar e reperibile all'indirizzo In particolare, alle classi in forma compilata In e Out cui e demandata la gestione dell'input e dell'output in generale, la gestione dei file di testo e la comunicazione mediante socket. /** * CommandParser.java package it.mauriziocozzetto.parser; /** maurizio public class CommandParser { private String command; // la stringa di partenza private String sep; // il carattere di separazione public CommandParser(String command, String sep) { this.command = command; this.sep = sep; // Valuta la stringa e produce i risultati public String evaluate() { String[] s = this.command.split(this.sep); switch(s[0]) { case "M": if (s.length == 2) return s[1].touppercase(); else throw new RuntimeException("Comando M: il numero degli argomenti è sbagliato"); case "m": if (s.length == 2) Pag. 13/20

14 return (s[1].tolowercase()); else throw new RuntimeException("Comando m: il numero degli argomenti è sbagliato"); case "V": if (s.length == 2) { int c = 0; for (int i = 0; i < s[1].length(); i++) if (s[1].charat(i)=='a' s[1].charat(i)=='e' s[1].charat(i)=='i' s[1].charat(i)=='o' s[1].charat(i)=='u' s[1].charat(i)=='a' s[1].charat(i)=='e' s[1].charat(i)=='i' s[1].charat(i)=='o' s[1].charat(i)=='u') c++; return String.valueOf(c); else throw new RuntimeException("Comando V: il numero degli argomenti è sbagliato"); case "S": if (s.length == 4) { return s[1].substring(integer.parseint(s[2]), Integer.parseInt(s[3])); else throw new RuntimeException("Comando S: il numero degli argomenti è sbagliato"); default: throw new RuntimeException(s[0] + ": comando non previsto"); // Fine switch // Fine metodo evaluate // Proviamo i comandi del protocollo public static void main(string[] args) { CommandParser p = null; try { p = new CommandParser("M,ciao come ti va", ","); System.out.println(p.evaluate()); p = new CommandParser("S,ciao come ti va,2,8", ","); System.out.println(p.evaluate()); p = new CommandParser("m,hello everybody claps your hands!", ","); System.out.println(p.evaluate()); p = new CommandParser("m,ciao COME TI VA", ","); System.out.println(p.evaluate()); p = new CommandParser("V,ciao come ti va", ","); System.out.println(p.evaluate()); p = new CommandParser("X,ciao come ti va", ","); System.out.println(p.evaluate()); catch (RuntimeException e) { System.out.println(e.getMessage()); // Fine metodo main // Fine classe CommandParser Pag. 14/20

15 Output del programma: CIAO COME TI VA ao com hello everybody claps your hands! ciao come ti va 7 X: comando non previsto BUILD SUCCESSFUL (total time: 0 seconds) /* * CommandParserTest.java package it.mauriziocozzetto.parser; import java.io.file; import edu.princeton.cs.introcs.in; import edu.princeton.cs.introcs.out; /** maurizio public class CommandParserTest { public static void main(string[] args) { In f1 = null; try { // Controlliamo se il file esiste f1 = new In(new File("commands.txt")); catch (Exception e) { System.out.println(e); return; // Creiamo il file di output Out f2 = new Out("results.txt"); boolean error = false; // Finchè ci sono dati while (!f1.isempty()) { // Leggo una riga String s = f1.readline(); // Preparo l'oggetto parser che la analizza CommandParser parser = new CommandParser(s, ","); try{ // Valuto la riga e scrivo il risultato nel file di output f2.println(parser.evaluate()); // Mando anche a video i risultati come controllo System.out.println(parser.evaluate()); catch(exception e) { // Scrivo il messaggio di errore nel file di output e proseguo l'elaborazione f2.println(e.getmessage()); error = true; Pag. 15/20

16 // Se c'è un errore, non interrompiamo l'esecuzione, ma saltiamo la riga if (error) { error = false; // Fine ciclo while f1.close(); f2.close(); System.out.println("Fine"); // Fine metodo main // Fine classe CommandParserTest Il file commands.txt contiene le seguenti informazioni: M,ciao come stai? X,questa riga contiene un comando non valido M,questa riga va trasformata in maiuscolo m,questa RIGA va TRASFORMATA IN MINUSCOLO m,questa riga contiene troppi argomenti,1,2 V,Questa riga contiene 12 vocali V,Questa invece 9 vocali S,Troviamo una sottostringa a partire dal carattere 3 fino al carattere 20 escluso,3,20 S,Nuova sottostringa a partire dal carattere 10 fino al carattere 30 escluso,10,30 Il file results.txt contiene i seguenti dati: CIAO COME STAI? X: comando non previsto QUESTA RIGA VA TRASFORMATA IN MAIUSCOLO questa riga va trasformata in minuscolo Comando m: il numero degli argomenti è sbagliato 12 9 viamo una sottost ostringa a partire d Esempio conclusivo In questo lavoro finale, poniamo alcuni comandi previsti dal nostro protocollo in un file di testo. Ogni riga del file viene letta e inviata al server, il quale, essendo provvisto di un oggetto di tipo CommandParser provvede ad interpretare correttamente il comando, ad elaborarlo e a spedire immediatamente al client il risultato dell'elaborazione ottenuta. Il client riceve tale elaborazione e la memorizza in un file di output distinto (vedi fig. 3). Per semplicità di lettura, ci limitiamo ad usare un server unicast. /* * TCPServer.java package it.mauriziocozzetto.tcpclientserver.parser; import edu.princeton.cs.introcs.in; import edu.princeton.cs.introcs.out; import java.io.ioexception; import java.net.serversocket; import java.net.socket; Pag. 16/20

17 /** * maurizio public class TCPServer { public static void main(string[] args) throws IOException { // Crea un serversocket sulla porta 6789 ServerSocket serversocket = new ServerSocket(6789); while (true) { System.out.println("Server in ascolto sulla porta " + serversocket.getlocalport() + "..."); // Attesa di una richiesta di connessione da parte di un client Socket clientsocket = serversocket.accept(); // Stream di input proveniente dal client In in = new In(clientSocket); // Stream di output verso il client Out out = new Out(clientSocket); while (true) { // Legge i dati provenienti dal client String command = in.readline(); if (command == null) { System.out.println("Il client ha chiuso la connessione"); break; System.out.println("Stringa ricevuta: " + command); // Il server provvede a interpretare i comandi mediante l'oggetto parser CommandParser parser = new CommandParser(command,","); boolean error = false; try { // Il server valuta il comando e invia la stringa risultato al client String result = parser.evaluate(); out.println(result); catch(exception e) { // Se ci sono errori, viene inviato il tipo di errore out.println(e.getmessage()); error = true; // Si continua l'elaborazione con la riga successiva if (error) { error = false; // Fine while interno Pag. 17/20

18 // Chiusura del socket in.close(); out.close(); clientsocket.close(); // Fine while esterno // Fine metodo main // Fine classe TCPServer /* * TCPClient.java package it.mauriziocozzetto.tcpclientserver.parser; import edu.princeton.cs.introcs.in; import edu.princeton.cs.introcs.out; import java.io.ioexception; import java.net.socket; /** maurizio public class TCPClient { public static void main(string[] args) throws IOException { // Creazione di un socket sulla porta 6789 sulla macchina "localhost" Socket clientsocket = new Socket("localhost", 6789); // Stream proveniente dal server In in = new In(clientSocket); // Stream diretto verso il server Out out = new Out(clientSocket); // Preparazione dei due file (supponiamo che il file di input esista già sul disco) In f1 = new In("commands.txt"); Out f2 = new Out("results.txt"); // Finchè ci sono dati while(!f1.isempty()) { // Lettura di una riga dal file String command = f1.readline(); // Invio dei dati dati al server out.println(command); // Lettura del risultata proveniente dal server String result = in.readline(); // Stampa sulla console e scrittura sul disco System.out.println("Dal server: " + result); f2.println(result); // Fine ciclo while // Chiusura degli stream e del socket Pag. 18/20

19 in.close(); out.close(); f1.close(); f2.close(); clientsocket.close(); System.out.println("Fine"); // Fine metodo main // Fine classe TCPClient Output del client (il file di input e lo stesso dell'esempio precedente): Dal server: CIAO COME STAI? Dal server: X: comando non previsto Dal server: QUESTA RIGA VA TRASFORMATA IN MAIUSCOLO Dal server: questa riga va trasformata in minuscolo Dal server: Comando m: il numero degli argomenti è sbagliato Dal server: 12 Dal server: 9 Dal server: viamo una sottost Dal server: ostringa a partire d Fine BUILD SUCCESSFUL (total time: 0 seconds) Output del server: Server in ascolto sulla porta Stringa ricevuta: M,ciao come stai? Stringa ricevuta: X,questa riga contiene un comando non valido Stringa ricevuta: M,questa riga va trasformata in maiuscolo Stringa ricevuta: m,questa RIGA va TRASFORMATA IN MINUSCOLO Stringa ricevuta: m,questa riga contiene troppi argomenti,1,2 Stringa ricevuta: V,Questa riga contiene 12 vocali Stringa ricevuta: V,Questa invece 9 vocali Stringa ricevuta: S,Troviamo una sottostringa a partire dal carattere 3 fino al carattere 20 escluso,3,20 Stringa ricevuta: S,Nuova sottostringa a partire dal carattere 10 fino al carattere 30 escluso,10,30 Il client ha chiuso la connessione Server in ascolto sulla porta Bibliografia Meini-Formichi, Tecnologie e progettazione di sistemi informatici e di telecomunicazioni, Zanichelli, volume 3 Scorzoni, Informatica, Programmazione in Java, Loescher Camagni-Nikolassy, Tecnologie e progettazione di sistemi informatici e di telecomunicazioni, Hoepli, volume 3 Lorenzo Bettini, Programmazione distribuita in Java (pdf), Dipartimento Sistemi e Informatica, Università di Firenze, Ottobre 2005 Lorenzi-Facchetti-Rizzi, Il linguaggio Java (Nuova Edizione), Atlas Kurose-Ross, Computer Networking, A Top-Down Approach, 5 th edition, Pearson Pag. 19/20

20 Fig. 3 Interazione tra le varie componenti del sistema. Pag. 20/20