Perte de flux / Stream

**ouranos21** · 21/03/2008, 16h55

Bonjour,

Voici le bloc de code que j'utilise pour parcourir une HashMap et afficher ses éléments.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
if(command2==null && options.contains("e"))
                     {
                        sortie.println("Exceptions triggered the last minute: ");
                        //Lire la HashMap ligne par ligne et obtenir la valeur pour la clé de chaque HashMap
                        Set cles = ans.exceptions.keySet();
                        Iterator it = cles.iterator();
                        //on parcours cet array
                        //System.out.println("Size of Exceptions: "+ans.exceptions.size());
                        sortie.println("Size of Exceptions: "+ans.exceptions.size()+"keyset: "+cles.size());
                        while (it.hasNext())
                        {
                            System.out.println(it);
                            Object cle = it.next(); 
                            Object valeur = ans.exceptions.get(cle);
 
                            System.out.println("DB: "+cle);
                            sortie.println("DB: "+cle);
                            System.out.println(" Exception: "+valeur);
                            sortie.println(" Exception: "+valeur);
                        }
                        sortie.println("Hop !");
                        System.out.println("Hop !");
                        sortie.println("\n");
                     }

L'objet "exceptions" contient en clé, le nom d'une base de donnée, et en valeur l'exception levée pour cette DB, lors de la connexion à la base.

Donc là mon but est d'afficher tout ce qu'il y a dans "exceptions"

Voici ce qui est affiché par les System.out.println (côté serveur):

DB: DB1
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB2
Exception: java.sql.SQLException: ORA-01034: ORACLE not available
ORA-27101: shared memory realm does not exist
SVR4 Error: 2: No such file or directory

DB: DB3
Exception: java.sql.SQLException: Io exception: Connection refused
DB: DB4
Exception: java.sql.SQLException: Io exception: Connection refused
DB: DB5
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB6
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB7
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB8
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB9
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB10
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB11
Exception: java.sql.SQLException: ORA-01034: ORACLE not available
ORA-27101: shared memory realm does not exist
SVR4 Error: 2: No such file or directory

...

Et voici ce qui est displayé côté client avec les sortie.println:

Exceptions triggered the last minute:
DB: DB1
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB2
Exception: java.sql.SQLException: ORA-01034: ORACLE not available
ORA-27101: shared memory realm does not exist
SVR4 Error: 2: No such file or directory
Connexion closed...

En gros, le serveur envoie sur le flux les deux premières erreurs/exceptions, puis, plus rien, perte du flux...

Voici côté client comment je lis le flux:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
else if(options!=null && options.contains("e"))
                    {
                        String message = args[0];
                        sortie.println(message);
                        do 
                        {
                            reponseDuServeur = entreeDepuisServeur.readLine();
                            if(reponseDuServeur.isEmpty()==false)
                            {    
                                System.out.println(reponseDuServeur);
                            }
                        }
                        while(reponseDuServeur.isEmpty()==false);
 
                    }

(je pense que le code n'est pas difficile à décrypter...)

Vous avez une idée du pourquoi qu'j'ai pas un affichage complet côté client ?

J'ai essayé en faisant un affichage sur le flux de sortie (côté serveur) de le String "plop", juste à la fin de ma boucle while, et juste au début... et rien ne s'affiche lorsque le flux est perdu ('fin, perdu, je suppose quoi...)

Oukélé mon erreur ?

D'avance merci.
Bien à vous.

**gifffftane** · 22/03/2008, 15h26

Peut être fermes-tu trop tôt ton flux coté serveur, sans attendre que le client ait tout lu.

Comment envoies-tu les données coté serveur ?

**ouranos21** · 25/03/2008, 11h17

Bonjour, merci de répondre ^^

Le code côté serveur est le premier bloc de code que j'ai collé en haut de mon premier post...

Comme tu vois, je ne sors de la boucle qu'une fois que j'ai parcouru tout l'itérateur.

Bon maintenant je ne sais pas si ça peut t'aider, mais je peux te montrer le minuscule code qui me permet de récupérer le contenu de ma hashmap "Exceptions" dans mon objet:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
public String getExceptions(String db_name)
{
        return (String)exceptions.get(db_name);
}

Je vais essayer de te montrer la structure de ma classe principale côté serveur, celle par laquelle transitent les données, celle que le client consulte et qui redirige les données vers le client, celle qui fait "interface" quoi...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
public static void main(String[] args) 
  {
    //je t'épargne les déclarations de variables et autres tests inutiles pour l'explication  
    try 
    {
      ServerSocket service = new ServerSocket(9000); //On crée le Socket
      .
      .
      .
      if(flag==false)
          {
              if(args.length>0 && options2.contains("l"))
              {
                  log = true;
              }
              threadCo = new ThreadConnexion(verbose,log); //on instancie l'objet qui fait les traitements
              threadCo.start();
 
              //Une fois les threads démarrés, ServeurThread attend les requêtes clients, au besoin on questionnera l'objet
              //et formatera la réponse (pour une meilleure lisibilité) qu'il enverra sur le flux de sortie pour l'afficher
              //côté client.
              while (true) //boucle infinie
              {
                    Socket connexion = service.accept();
                    //une fois la requête reçue on crée les flux
                    BufferedReader entree = new BufferedReader(new InputStreamReader(connexion.getInputStream()));
                    PrintWriter sortie=new PrintWriter(connexion.getOutputStream(), true);
                    //on stock la requête (la commande envoyée côté client)
                    str=entree.readLine();
                    if(command2==null && options.contains("e"))
                     {
                        sortie.println("Exceptions triggered the last minute: ");
                        //Lire la HashMap ligne par ligne et obtenir la valeur pour la clé de chaque HashMap
                        Set cles = ans.exceptions.keySet();
                        Iterator it = cles.iterator();
                        //on parcours cet array
                        //System.out.println("Size of Exceptions: "+ans.exceptions.size());
                        sortie.println("Size of Exceptions: "+ans.exceptions.size()+"keyset: "+cles.size());
                        while (it.hasNext())
                        {
                            System.out.println(it);
                            Object cle = it.next(); 
                            //cle.toString();
                            Object valeur = ans.getExceptions(cle.toString());
                            //Object valeur = ans.exceptions.get(cle); //getStatus(cle);
                            //on rempli l'array avec les valeur pour les clé...
 
                            System.out.println("DB: "+cle);
                            sortie.println("DB: "+cle);
                            System.out.println(" Exception: "+valeur);
                            sortie.println(" Exception: "+valeur.toString());
                        }
                        sortie.println("Hop !");
                        System.out.println("Hop !");
                        //Le flux est pourri dés la 3èe itération, dés qu'on commence à avoir des "login timeout"
                        sortie.println("\n");
                     }
                     if(command2!=null && options.contains("s") && flag3==true)
                     {
                       ...
                     }
                     if(options.contains("u"))
                    {
                       ...
                    }
                    else if(options.contains("s") && command2==null) 
                    {
                    }
//Puis tout une série de "else if"...
}
    catch (IOException e) 
    { 
    	System.err.println("INIT:"+e);
        System.out.println("");
    }
 
  }

Voilà. Je ne sais pas si tu as assez d'éléments pour pouvoir m'aider à avancer...

Merci d'essayer en tout cas.
Bien à toi.

**gifffftane** · 25/03/2008, 12h21

Ce qui me gène là dedans, c'est que je ne vois nulle part la fermeture du flux de sortie, ou de la socket. Est-ce que tu ne l'as pas recopié ? Qui ferme la socket, et / ou la sortie, et sur quel événement le fait-il ?

**ouranos21** · 25/03/2008, 12h30

Effectivement je ne ferme jamais le flux de sortie.

Je termine juste son envoie par le '\n'.

Et je ne ferme jamais non plus la socket. Mais bon, comme ce programme est en fait un programme de monitoring de bases de données, il est censé tourner 24/7, donc je m'étais dit que ce n'était pas la peine de fermer ni la socket, ni le flux, juste parfois faire un flush du flux.

En fait, c'est sûrement mal codé de ma part, mais ça fonctionne pour toutes les autres options (arguments en ligne de commande) de mon programme. Juste que là avec les exceptions, je consulte une hashmap (une de plus, et avec les autres j'ai pas de problème) et le flux refuse d'envoyer les lignes vers le client

Si ça peut t'aider je peux t'envoyer mes sources, mais ce serait en privé... et je rédigerais la solution en public, dans ce thread.

EDIT: Bon j'ai testé avec fermeture de flux, et ça n'arrange pas les choses...

**gifffftane** · 25/03/2008, 13h08

Je suis peut être parti dans la mauvaise direction. Mais si tu ne fermes pas la sortie, d'où vient le Connexion closed... que l'on voit sur les traces coté client ?

S'il se confirme que tu ne fermes jamais la sortie ou la socket, le problème ne vient pas de là, même si ce n'est pas très propre.

**ouranos21** · 25/03/2008, 13h57

Pas ça non plus ^^

Le "connexion closed" vient d'un System.out.println que je fais dans un bloc Finally enfin de client.

**ouranos21** · 26/03/2008, 10h38

En fait le truc que je comprend vraiment pas, c'est que côté serveur, je boucle l'envoie de donnée tant qu'il y a des éléments:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
if(command2==null && options.contains("e"))
                     {
                        //Lire la HashMap ligne par ligne et obtenir la valeur pour la clé de chaque HashMap
                        Set cles = ans.exceptions.keySet();
                        Iterator it = cles.iterator();
                        //on parcours cet array
                        //System.out.println("Size of Exceptions: "+ans.exceptions.size());
                        while (it.hasNext())
                        {
                            System.out.println(it);
                            Object cle = it.next(); 
                            //cle.toString();
                            Object valeur = ans.getExceptions(cle.toString());
                            //Object valeur = ans.exceptions.get(cle); //getStatus(cle);
                            //on rempli l'array avec les valeur pour les clé...
 
                            System.out.println("DB: "+cle);
                            sortie.println("DB: "+cle);
                            System.out.println(" Exception: "+valeur);
                            sortie.println(" Exception: "+valeur.toString());
                        }
                        sortie.println("Hop !");
                        System.out.println("Hop !");
                        //Le flux est pourri dés la 3èe itération, dés qu'on commence à avoir des "login timeout"
                        sortie.println("\n");
                     }

Et quand il n'y a plus d'éléments, j'envoie '\n', côté serveur avec les System.out.println, je sais qu'il y a encore des éléments, et je les affiche, par contre, soit ils ne sont pas envoyés (il envoie 2 "exceptions" sur le flux de sortie, mais pas plus), soit les éléments (Strings) ne sont pas bien réceptionnés côté client. Mais bon, là-dedans:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
else if(options!=null && options.contains("e"))
                    {
                        //String reponseVerbose = null;
                        System.out.println("Exceptions triggered the last minute: ");
                        String message = args[0];
                        sortie.println(message);
                        do 
                        {
                            reponseDuServeur = entreeDepuisServeur.readLine();
                            if(reponseDuServeur.isEmpty()==false)
                            {    
                                System.out.println(reponseDuServeur);
                            }
                        }
                        while(reponseDuServeur.isEmpty()==false);
 
                    }

... la méthode readline est bloquante non ? Donc impossible de sortir de cette boucle tant qu'il y a des éléments à envoyer, vrai ?
Or là je sors de cette boucle do-while et je passe dans le bloc Finally à la fin de ma classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
finally
        {
            if(flag==false)
            {    
                try
                {
                    connexion.close();
                    System.out.println("Connexion closed...");
                }
                catch(IOException e) 
                { 
                    System.out.println("Erreur : "+e);
                    System.out.println("Connexion closed...");
                }
            }
        }

Et ce bloc se trouve après tout un tas de else-if, donc le programme client se déroule normalement, mais oublie d'attendre/lire/recevoir les données envoyées sur sont flux d'entrée :/

J'pige po...

**ouranos21** · 26/03/2008, 11h31

Trouvé !

Alors en fait y'avait un '\n' qui était envoyé à mon insu dans le message d'une exception.

Là:

DB: DB1
Exception: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
DB: DB2
Exception: java.sql.SQLException: ORA-01034: ORACLE not available
ORA-27101: shared memory realm does not exist
SVR4 Error: 2: No such file or directory
IIIIIIIIIIIIIIIIIIIIICIIIIIIIIIIIIIIIIIIIIIIIII
DB: DB3
Exception: java.sql.SQLException: Io exception: Connection refused
DB: DB4
Exception: java.sql.SQLException: Io exception: Connection refused
DB: DB5

Et il faisait se terminer l'envoie de données sur le flux.

J'ai donc, quand je capture l'exception pour l'ajouter à ma HashMap, fais un trim(). Et donc là j'avais une certaine uniformisation de stockage des Strings dans ma HashMap si je peux dire ainsi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
catch(Exception e)
        {
	    timeforlogin2=System.currentTimeMillis();
 
            String c = e.toString().trim();
            //int logtimeout = DriverManager.getLoginTimeout();
            long timeforlogin3=timeforlogin2-timeforlogin;
            System.out.println(timeforlogin3);
            if(timeforlogin3>=300000)
            {
                c="LOGIN TIMEOUT "+ timeforlogin3;
            }    
            ans.setException(db_name,c);
            System.out.println("=============================================");
            System.out.println(">>>>>>>>>>>>>>>>>>>> Database: "+suburl);
            ans.setCantConnect(db_name);
            System.out.println("");
            System.out.println("Error: Unreachable Database: " + e);
            System.out.println("=============================================");
            System.out.println("");
	}

Voilà comment je stock le message de mon exception dans mon objet HashMap (setException(String,String))... C'est vraiment dégueu pour l'instant mais c'est juste pour le test.

Du coup, côté Client, plus de problème.

Perte de flux / Stream

Collection et Stream Java

Discussions similaires

Partager

Partager