Socket : services

un serveur HTTP simplissime

Source de MonSimpleServeurHttp.java
 

    
import java.io.*;
import java.net.*;
import java.util.zip.*;
public class MonSimpleServeurHttp {
  public static void main(String args[]) {
    try {
      int port = 80;
      if (args.length == 1)
        port = Integer.parseInt(args[0]);
      ServerSocket sockServ = new ServerSocket(port);
      System.out.println("start Simple Http Server :\n " 
      + "ecoute sur port " + port);     
      for(;;) {
        Socket sockClient = sockServ.accept();
        System.out.println("connection de :"  + sockClient);     
        BufferedReader sockIn = new BufferedReader(
                    new InputStreamReader(sockClient.getInputStream()));
        PrintWriter sockOut = new PrintWriter(sockClient.getOutputStream());   
        try {
          String reqLine  = sockIn.readLine();
          while ((reqLine != null)&& (reqLine.length() == 0)) 
            reqLine = sockIn.readLine();
          reqLine.trim();
          if (reqLine.indexOf("GET") != 0)
            throw new DataFormatException("requete autre que GET"); 
          String fileName = reqLine.substring(3,reqLine.length()).trim()
                                                + " ";
          int endOfFileName = fileName.indexOf(" ");
          fileName = fileName.substring(0, endOfFileName);
          File file = new File(fileName);
          if (! (file.exists()&&file.isFile()&&file.canRead()) )
            throw new FileNotFoundException("fichier inexistant"
                                          + " ou inaccessible");
          sockOut.print("HTTP/1.0 200 OK\n");          
          sockOut.print("Content-Type: text/plain\n"); 
          FileReader fileIn = new FileReader(file);
          long len= file.length();
          sockOut.print("Content-length : "+len);    
          sockOut.print("\n");    
          char[] buffer = new char[1024];
          int nombreLu;
          while ((nombreLu = fileIn.read(buffer,0,1024)) != -1)
            sockOut.write(buffer,0,nombreLu);
          fileIn.close();
        }
        catch (DataFormatException e) {
          sockOut.print("HTTP/1.0 400 "+e.getMessage()+"\n");             
        }
        catch (FileNotFoundException e) {
          sockOut.print("HTTP/1.0 404 "+e.getMessage()+"\n");          
        }
        finally {
          sockOut.print("\n");        
          sockOut.close();    
          sockIn.close();     
          sockClient.close();  
        } 
      }
    }      
    catch (Exception e) {
      System.err.println(e);
      System.err.println("Usage: java MonSimpleServeurHttp [<port>]");
    }
  }
}

Un fichier essai

EXECUTION

sur console 1 : $ cat essai fichier essai de 2 lignes $ java MonSimpleServeurHttp 8000 start Simple Http Server : ecoute sur port 8000 sur console 2 : $ telnet -e $ localhost 8000 Telnet escape character is '$'. Trying 127.0.0.1... Connected to localhost. Escape character is '$'. GET essai HTTP/1.0 200 OK Content-Type: text/plain Content-length : 26 fichier essai de 2 lignes Connection closed by foreign host. sur console 1 : connection de :Socket[addr=/127.0.0.1,port=1048,localport=8000]

Les lignes de la classe :

• Le service HTTP est içi simplifié à l'extrême :
  • le service est lancé en spécifiant un port d'écoute
  • le client ne peut effectuée qu'une requête "GET [chemin/]fichier"
  • le serveur renvoie une réponse d'erreur si la requête est erronée ou le fichier demandée inaccessible
  • le serveur ne sert qu'un client à la fois
  • il n'y a aucune sécurité coté serveur de restriction d'accès aux fichiers : la requete peut concerner /etc/passwd
  • une fois le contenu du fichier fourni, le serveur ferme la connection comme dans la version 1.0 du protocol HTTP
• L'architecture de la classe :
  • création du serveur
  • boucle :
    • attendre une connection/requête d'un client
    • A la connection d'un client, le serveur crée un socket "privée" sockClient
    • mettre un adapteur sockIn de lecture de caractère et un adapteur sockOut d'écriture de caractère
    • lit la requete du client sur sockIn
      • vérifie sa syntaxe
      • si mauvaise, ecrire "HTTP 400 ERREUR" sur sockOut
      • récupérer le nom du fichier et vérifier s'il existe et est lisible
      • sinon "HTTP 400 ERREUR" sur sockOut
      • écrire "HTTP 200 OK" sur sockOut
      • ouvrir le fichier en lecture
        • boucle de lecture des caractères du fichier
          • écrire les caractères sur sockOut
    • fermer sockOut, sockIn et sockClient

serveur HTTP multi-connection

Source de ServerPlusieursConnections.java
 

    
import java.io.*;
import java.net.*;
public class ServerPlusieursConnections {
  private int maxConnection = 0;
  private int nbreConnection = 0;
  private ServerSocket serveurSock = null;
  private int modeLent = 0;
  public static void main(String args[]) {
    try {
      if ((args.length < 2) || (args.length > 3))
        throw  new IllegalArgumentException("Usage: java "
          +"ServerPlusieursConnections port maxconnection [mode_lent]");
      int port = Integer.parseInt(args[0]);
      int maxConnection = Integer.parseInt(args[1]);
      int modeLent = 0;
      if (args.length == 3)
        modeLent = Integer.parseInt(args[2]); // 500 !
      ServerPlusieursConnections server = 
        new ServerPlusieursConnections(port, maxConnection, modeLent);
      server.go();
    }  
    catch (Exception e) {
      System.err.println(e);
    }
  }
  public ServerPlusieursConnections(int port, int maxConnection, 
         int modeLent) throws IOException {    
    serveurSock = new ServerSocket(port);
    this.maxConnection = maxConnection;
    this.nbreConnection = 0;
    this.modeLent = modeLent;
  }
  public void go() throws IOException {
    for(;;) {
        Socket sockClient = serveurSock.accept();
        addConnection(sockClient);     
    }
  }
  protected synchronized void addConnection(Socket sockClient) {
    if (nbreConnection >= maxConnection) {
      try {
        PrintWriter out = new PrintWriter(sockClient.getOutputStream());
        out.print("connection refusee\n");
        out.close();    
        sockClient.close();  
      }  
      catch (Exception e) {
        System.err.println(e);
      }
    }
    else {
      nbreConnection++;
      Connection connect = new Connection(sockClient);
      System.out.println("connection de : " + sockClient);
      connect.start();
    }
  }
  protected synchronized void finConnection() {
    nbreConnection--;
  }
  private class Connection extends Thread {
    private Socket sockClient = null;
    public Connection(Socket sockClient) {
      super("ServerConnection : " 
           + sockClient.getInetAddress().getHostAddress() 
           + " : " + sockClient.getPort());
      this.sockClient = sockClient;
    }
    public void run() {
      try {
        boolean Ok = true;
        BufferedReader sockIn = new BufferedReader(
                new InputStreamReader(sockClient.getInputStream()));
        PrintWriter sockOut = new PrintWriter(sockClient.getOutputStream());
        String requete = sockIn.readLine();
          File file = null;
        if (requete == null)
          Ok = false;
        else {
          requete.trim();
          if (requete.indexOf("GET") != 0)
            Ok = false;
          else {
            String nomFichier = requete.substring(3,
                                  requete.length()).trim()+" ";
            int finNomFichier = nomFichier.indexOf(" ");
            nomFichier = nomFichier.substring(0, finNomFichier);        
            file = new File(nomFichier);
            if (! (file.exists()&&file.isFile()&&file.canRead()) )
              Ok = false;
          }
        }
        if (Ok) {
          sockOut.print("HTTP/1.0 200 Ok\n");          
          sockOut.print("Content-Type: text/plain\n"); 
          FileReader flotFichier = new FileReader(file);
          long longueur= file.length();
          sockOut.print("Content-length : "+longueur);    
          sockOut.print("\n");    
          char car=0;
          for ( int i = 0; i < longueur; i++) {
            car= (char)flotFichier.read();
            sockOut.print(car);
            if (modeLent != 0) {
              sockOut.flush();
              sleep((int)(Math.random()*modeLent));
            }
          }
          flotFichier.close();
        }
        else {
          sockOut.print("HTTP/1.0 400 Not Found\n");          
        }
        sockOut.print("\n");
        sockOut.close();    
        sockIn.close();  
        System.out.println("          fin de : " + sockClient);   
        sockClient.close();  
      }    
      catch (Exception e) {
        System.err.println(e);
      }
      finally {
        finConnection();
      }
    } 
  }
}

EXECUTION

sur console 1 : $ java ServerPlusieursConnections 8000 2 500 sur console 2 : $ telnet -e $ localhost 8000 Telnet escape character is '$'. Trying 127.0.0.1... Connected to localhost. Escape character is '$'. GET essai HTTP/1.0 200 OK Content-Type: text/plain Content-length : 26 fichier essai de 2 lignes Connection closed by foreign host. sur console 3 : $ telnet ..... sur console 4 : $ telnet -e $ localhost 8000 Telnet escape character is '$'. Trying 127.0.0.1... Connected to localhost. Escape character is '$'. connection refusee Connection closed by foreign host. sur console 1 : connection de : Socket[addr=/127.0.0.1,port=1065,localport=8000] connection de : Socket[addr=/127.0.0.1,port=1066,localport=8000] fin de : Socket[addr=/127.0.0.1,port=1065,localport=8000] fin de : Socket[addr=/127.0.0.1,port=1066,localport=8000]

Les lignes de la classe :

• c'est encore un service HTTP "pas cher" :
  • mais le serveur sert plusieurs clients à la fois dans une limite fixée par paramêtre
  • pour mettre clairement en évidence que plusieurs clients sont servis en même temps, il suffit d'ajouter un paramêtre entier de ralentissement de la réponse caractère par caractère (500 est une bonne valeur)
  • si on tente de lancer un n+1-ième client alors que n sont servis par un serveur à n connections, ce dernier voit sa tentative de connection refusée.
  • chaque connection est servie/assurée par un thread.
• L'architecture de la classe :
  • le serveur se met en boucle pour attendre et servir une connection/requête d'un client
  • A la connection d'un client, le serveur vérifie si cette demande ne dépasse pas le nombre de connections simultanées maximun définie.
  • Si c'est possible, il crée un socket "privée" et lance un thread qui assurera le service particulier à ce client.
  • Ainsi le thread "main" se fait qu'assurer la boucle d'attente du ServerSocket et lancer les threads de communication. Il est donc très disponible pour écouter sur le port.
  • Le nombre maximal de connections simultanées définit donc le nombre maximal de threads de traitement des communications.
  • Comme ce sont les threads qui ordonnent la décrémentation du nombre de connection, et le thread "main" qui l'incrémente, la gestion de ce nombre est en exclusion mutuelle.
• Multi-thread :
  • Le server multi-client utilise la norme Http 1.0 : dès que le GET est servi, la connection est fermée.
  • Le serveur utilise au mieux les threads : quand une demande de connexion arrive, un thread est créé pour servir immédiatement la demande "GET" du client puis "close" (version 1.0) donc termine le thread.

serveur multi-connections "connectées"

Source de ServerProphete.java
 

    
import java.io.*;
import java.net.*;
import java.util.*;
public class ServerProphete {
  private ArrayList<String> listProphetie = null;
  private ServerSocket serveurSock = null;
  static int port = 6666;
  public static void main(String args[]) {
    try {
      ServerProphete server =  new ServerProphete();
      server.go();
    }  
    catch (Exception e) {
      System.err.println("erreur server : "+e.getMessage());
    }
  }
  public ServerProphete() throws IOException {    
    serveurSock = new ServerSocket(port);
    listProphetie = new ArrayList();
    SaisieProphetie saisie = new SaisieProphetie();
    saisie.start();
  }
  public void go() throws IOException {
    for(;;) {
      Socket sockClient = serveurSock.accept();
      System.out.println("connection de : "+sockClient);
      Connection connect = new Connection(sockClient);
      connect.start();   
    }
  }
  private class Connection extends Thread {
    private Socket sockClient = null;
    public Connection(Socket sockClient) {
      this.sockClient = sockClient;
    }
    public void run() {
      DataInputStream sockDataIn = null;
      OutputStream sockOut = null;
      byte[] buffer = new byte[1024];
      String prophetie = null;
      try {
        sockDataIn = new DataInputStream(socket.getInputStream());
        sockOut = socket.getOutputStream();
        while (true) { 
          int i = sockDataIn.readInt();
          synchronized(listProphetie) {
            try {
              prophetie = listProphetie.get(i);
            } catch (IndexOutOfBoundsException e) {
              prophetie ="";
            }      
          }
          prophetie = prophetie+"\n";
          buffer = prophetie.getBytes();
          sockOut.write(buffer, 0, prophetie.length());
          sockOut.flush();    
        }
      } catch (IOException e) {
        System.out.println("erreur du socket : "+sockClient+"\n"+e.getMessage());
      } finally {
        System.out.println("fin du socket : "+sockClient);
        try {
          sockDataIn.close();
          sockOut.close();
          sockClient.close();
        } catch (IOException e) {
          System.out.println("erreur grave du socket : "+sockClient+"\n"+e.getMessage());
        } 
      }
    }     
  }
  private class SaisieProphetie extends Thread {
    public void run() {
      BufferedReader console = null;
      String message = null;
      try {
        console = new BufferedReader(new InputStreamReader(System.in));
        while (true)  {
          message = console.readLine();
          synchronized(listProphetie) {
            listProphetie.add(message);
          }
        }  
      } catch (IOException e) {
        System.out.println("erreur fatale "+e.getMessage());
      }
    }  
  }
}

Source de ClientDisciple.java

import java.io.*; import java.net.*; import java.util.*; public class ClientDisciple { private String hote; static int port = 6666; private boolean continuer = true; public static void main(String[] args) throws IOException { try { if (args.length != 1) throw new IllegalArgumentException("Usage: java " +"ClientDisciple hote "); String hote = args[0]; ClientDisciple client = new ClientDisciple(hote); client.go(); } catch (Exception e) { System.out.println("arret du client \n erreur : "+e.getMessage()); } } public ClientDisciple(String hote) { this.hote = hote; } public void go() throws Exception { Socket socket = null; DataOutputStream sockDataOut = null; BufferedReader sockIn = null; Scanner scan = new Scanner(System.in); boolean continuer = true; String prophetie = null; try { socket = new Socket(hote, port); sockDataOut = new DataOutputStream(socket.getOutputStream()); sockIn = new BufferedReader(new InputStreamReader (socket.getInputStream())); } catch (UnknownHostException e) { throw new Exception("hote non atteignable : "+hote+"\n"+e.getMessage()); } catch (IOException e) { throw new Exception("connection impossible avec : "+hote+"\n"+e.getMessage()); } System.out.println("tapez q pour terminer, sinon un numero de prophetie"); while (continuer) if (scan.hasNextInt()) { try { sockDataOut.writeInt(scan.nextInt()-1); prophetie = sockIn.readLine(); if (prophetie != null) System.out.println("prophetie : "+prophetie); else { System.out.println("fermeture de la connection au serveur"); continuer = false; } } catch (IOException e) { System.out.println("impossible d'envoyer ou lire au serveur\n"+e.getMessage()); continuer = false; } } else if (scan.next().toLowerCase().equals("q")) continuer = false; sockDataOut.close(); socket.close(); } }

EXECUTION

sur console 1 : $ java ServerProphete Dieu est grand Le Chat aussi sur console 2 : $ java ClientDisciple localhost tapez q pour terminer, sinon un numero de prophetie 2 prophetie : Le Chat aussi 1 prophetie : Dieu est grand q $

Les lignes de la classe :

• la liste des prophétie peut changer via la console : c'est donc une ressource en exclusion mutuelle
• le server prophete est multi-client en utilisant des threads :
  • le problème est que chaque thread attend en boucle les demandes de prophéties du disciple : si le disciple demande peu, le thread ne fait rien.
• le numéro de prophétie est transmit en tant que donnée de type entier : DataOutputStream et DataInputStream

Select sur les Sockets:

• la technique du "select" sur les sockets est une technique de programmation événementielle :
  • pour un port donné, à  un événement socket (tentative de connection, arrivée de données à  lire sur une connection déja établie, possibilité d'écrire des données sur une connection déja établie), on associe une fonction "handler" qui sera déclanchée.
  • package java.nio.channels :
    • tout flot (en particulier, les sockets) est considéré comme un Channel
    • un Channel est enregistré auprès d'un Selector, un multiplexeur :
    • l'enregistrement register spécifie pour quelle(s) opération(s) : OP_ACCEPT OP_CONNECT OP_READ OP_WRITE ainsi qu'un objet attaché
    • L'objet attaché sert à maintenir le contexte entre 2 "événements"
    • un boucle de lecture des "événements" sur le multiplexeur permet d'obtenir l'événement ainsi que son attachment()
• + la technique du pool de threads
  • lors d'un événement, un thread du pool prend en charge le traitement à effectuer en fonction de l'événement arrivé et en utilisant l'objet attaché.
  • Cela nécessite de découper le service en petites taches qui seront exécutées en fonction des événements et d'assurer un persistance des données contectuelles entre 2 appels.

exercices

• La Radio et ses auditeurs :
  • un serveur envoie les messages tapé au Clavier par le speaker à tous les auditeurs.
  • Les auditeurs ne font qu'écouter.
  • Source de ServerRadio.java

    import java.io.*; import java.net.*; import java.util.*; public class ServerRadio { private ArrayList<Auditeur> listAuditeur = null; private ServerSocket serveurSock = null; static int port = 8888; private class Auditeur { private Socket sockClient; private OutputStream sockOut; public Auditeur(Socket sock) throws IOException { sockClient = sock; sockOut = sockClient.getOutputStream(); } public Socket getSocket() { return sockClient; } public OutputStream getSockOut() { return sockOut; } } public static void main(String args[]) { try { ServerRadio server = new ServerRadio(); server.go(); } catch (Exception e) { System.err.println("erreur server : "+e.getMessage()); } } public ServerRadio() throws IOException { serveurSock = new ServerSocket(port); listAuditeur = new ArrayList(); SaisieSpeaker speaker = new SaisieSpeaker(); speaker.start(); } public void go() throws IOException { for(;;) { Socket sockClient = serveurSock.accept(); System.out.println("connection de : "+sockClient); synchronized(listAuditeur) { listAuditeur.add(new Auditeur(sockClient)); } } } private class SaisieSpeaker extends Thread { public void run() { BufferedReader console = null; String message = null; ArrayList<Auditeur> copieList = null; byte[] buffer = new byte[1024]; OutputStream sockOut = null; console = new BufferedReader(new InputStreamReader(System.in)); while (true) { try { message = console.readLine()+"\n"; } catch (IOException e) { } synchronized(listAuditeur) { copieList = (ArrayList<Auditeur>)listAuditeur.clone(); } buffer = message.getBytes(); for (Auditeur auditeur : copieList) { try { sockOut = auditeur.getSockOut(); System.out.println("write message/socket : "+message+"/"+auditeur.getSocket()); sockOut.write(buffer, 0, message.length()); sockOut.flush(); } catch (IOException e2) { System.out.println("probleme socket : "+auditeur.getSocket()+"\n"+e2.getMessage()); } } } } } }

  • Içi le source de ClientAuditeur.java
  • EXECUTION
    

    $ java ServerRadio connection de : Socket[addr=/127.0.0.1,port=33860,localport=8888] connection de : Socket[addr=/127.0.0.1,port=37387,localport=8888] coucou write message/socket : coucou /Socket[addr=/127.0.0.1,port=33860,localport=8888] write message/socket : coucou /Socket[addr=/127.0.0.1,port=37387,localport=8888] encore write message/socket : encore /Socket[addr=/127.0.0.1,port=33860,localport=8888] probleme socket : Socket[addr=/127.0.0.1,port=33860,localport=8888] Broken pipe write message/socket : encore /Socket[addr=/127.0.0.1,port=37387,localport=8888] et toujours write message/socket : et toujours /Socket[addr=/127.0.0.1,port=33860,localport=8888] probleme socket : Socket[addr=/127.0.0.1,port=33860,localport=8888] Broken pipe write message/socket : et toujours /Socket[addr=/127.0.0.1,port=37387,localport=8888]

  • 2 auditeurs se sont connectés puis l'un a arrêté : mais le serveur radio lui diffuse encore les messages !!
    Comment corriger ce problème ?
  • Correction
      
• Réaliser un serveur multi-echo :
  • plusieurs clients sont/peuvent etre connectés en même temps.
  • Quand un client envoie une ligne de caractères, le serveur la renvoie en écho à tous les clients.
  • Au lieu d'écrire un client spécifique, vous pouvez utiliser telnet