Discussion :

[ptitepomme]

Bonsoir à tous,

Voilà plusieurs jours que je m'arrache littérallement les cheveux sur une petite application que je développe et qui me facilite la vie de tous les jours.

Il s'agit d'une application qui surveille la disponibilité réseau d'une ou plusieurs machines par PING.

J'utilise une classe Runnable pour que mes requêtes s'envoient en parallèle sans inter-blocage. Tout fonctionne bien sauf une chose ... les temps de réponse !

Je vous mets la partie du code, ça devrait vous aider à comprendre et peut être même trouver la solution

Pour le calcul du temps, j'ai d'abord essayé avec une Date, mais je pensais que c'était trop consommateur, donc je suis passé à l'objet System.

Le temps retourné est la différence entre le temps après le "isReachable" et le temps juste avant. Normalement ça ne devrait prendre que quelques millisecondes (comme le font mes requêtes directement avec un PING windows) et là ma différence est de plus ou moins 1000ms.

Merci d'avance pour ceux qui se creuseront la tête.

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
 
while(vivant){
    try {
            responseTimeTemp = System.nanoTime();
            reachable = address.isReachable(5000);
            responseTimeTemp = Math.round((System.nanoTime() - responseTimeTemp)/Math.pow(10, 6));
            System.out.println("--- " + responseTimeTemp);
            responseTime = (int)responseTimeTemp;
            this.nbPingSend++;
            if(reachable){
                this.nbPingReceive++;
                this.lastResponse = new Date();
                System.out.println("update FAIT : " + responseTime + "!");
            } else {
                System.err.println(name + " : injoignable ! ");
                this.lastCut = new Date();
            }
 
        } catch (UnknownHostException e) {
            //System.err.println("Unable to lookup " + name);
        } catch (IOException e) {
            //System.err.println("Unable to reach " + name);
            this.lastCut = new Date();
        } catch(Exception e){
            //System.err.println("Unable to reach " + name);
        }
}

[Influenza]

Bonsoir,

Est-ce que tu as déjà essayé avec un System.currentTimeMillis() à la place de nano ? Comme ça tu n'affiche que le résultat de la soustraction ? Autant y a juste un problème avec le calcul...

Edit : Ben non, après test ça fait pareil...

Mathieu

[Invité]

Salut,

Normalement ça ne devrait prendre que quelques millisecondes (comme le font mes requêtes directement avec un PING windows) et là ma différence est de plus ou moins 1000ms.

sans doute parce que dans ton cas, isReachable() utilise un ECHO sur le port TCP 7 de ta cible, et non pas un paquet ICMP.

As-tu pris une trace pour voir ce qui est envoyé ?

Steph

[kox2ee]

Bonjour,
comme IP_Steph, j'ai vu que isReachable essayait d'envoyer une requête ICMP echo vers la destination, s'il en avait la possibilité, et que dans le cas contraire, il établissait une connexion TCP sur le port 7 (ECHO)...
J'ai essayé sur plusieurs machines (win et linux), les temps sont aussi longs...

La question qu'on peut se poser est donc :
si isReachable fait l'équivalent d'un Ping, quelle est la taille des données qu'il envoie, et combien de demande d'écho fait-il ? Et fait-il autre chose ?
Sachant que le seul paramètre que nous ayons est le timeout, qui determine juste la durée maximale de la tentative de contact.

Il faudrait regarder avec un sniffer ce qui passe exactement avec isReachable

Je met une version de ping perso, qui consiste à exécuter un ping en ligne de commande, en ne faisant qu'une seule demande d'echo :

Sous win :

ping -n 1 127.0.0.1

Sous linux :

ping -c 1 127.0.0.1

à partir de :

Process proc = new ProcessBuilder("ping", host, -c ou -n , "1").start();

Les temps de réponse sont déjà plus acceptables, preuve que isReachable en fait beaucoup...

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
 
public class Ping {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		Ping ping = new Ping();
		ping.ping(args[0]);
	}
 
	private boolean isReachable;
	private long responseTime;
	private Logger log;
 
	public Ping() {
		log = Logger.getLogger("Ping");
 
	}
 
	private static boolean isWindows() {
		String OS = System.getProperty("os.name").toLowerCase();
		return (OS.indexOf("win") >= 0);
	}
 
	private String getCountParam() {
		String result = "-c";
		if (isWindows())
			result = "-n";
		return result;
	}
 
	public void ping(String host) {
		isReachable = false;
		try {
			long start = System.currentTimeMillis();
 
			Process proc = new ProcessBuilder("ping", host, getCountParam(), "1").start();
 
			int exitValue = proc.waitFor();
			responseTime = System.currentTimeMillis() - start;
			isReachable = (exitValue == 0);
			if (isReachable)
				log.log(Level.INFO, "Ping ok vers " + host + ", temps de réponse : " + responseTime + " ms");
			else
				log.log(Level.WARNING, "Impossible de joindre l'hôte destination : " + host);
		} catch (IOException e1) {
			log.log(Level.SEVERE, "Erreur I/O", e1);
		} catch (InterruptedException e) {
			log.log(Level.SEVERE, "Interruption de la commande", e);
		}
	}
}

[adiGuba]

Salut,


Le problème du ping via le paquet ICMP c'est que c'est bloqué par l'OS.
Sauf erreur sous Windows il n'y a pas d'API pour faire cela, et sous Unix/Linux c'est réservé aux utilisateurs root (le programme "ping" possédant ces droits).

Du coup isReachable() utilise un paquet ECHO comme solution de secours, ce qui est plutôt "couteux" en temps...



Comme l'indique kox2ee, la meilleur solution consiste donc à utiliser la commande native.

Toutefois il serait préférable de fermer les flux du process, sous peine de risquer un dead-lock :

Code :

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

1
2
3
4
5
Process proc = new ProcessBuilder("ping", host, getCountParam(), "1").start();
proc.getInputStream().close();
proc.getOutputStream().close();
proc.getErrorStream().close();
int exitValue = proc.waitFor();

a++

[ptitepomme]

Merci à tous pour vos réponses qui me sont bien utiles.

Effectivement après prise de trace, il s'avère que isReachable n'est pas du tout un PING.

Pour la solution des commandes PING via les Process je l'avais trouvé sur d'autre forum, mais la façon de récupérer les temps de réponse ne me plait pas beaucoup car il faut parser la chaine de caractère à la recherche de la chaine qui nous intéresse. C'est pour ça que je m'étais intéressé à isReachable.

Donc on est tous tombé d'accord ... isReachable => fausse bonne idée !

kox2ee :
Dans ton application récupère tu des informations dans le contenu de la chaine retourné ? Et si oui, fais tu une recherche dans cette chaine ou as-tu trouvé une solution plus ... propre ?!

[kox2ee]

kox2ee :
Dans ton application récupère tu des informations dans le contenu de la chaine retourné ? Et si oui, fais tu une recherche dans cette chaine ou as-tu trouvé une solution plus ... propre ?!

Non, j'ai fait un System.currentTimeMillis() avant et après...
je pense ne pas être trop trop loin du temps de réponse normal.

Je t'ai mis tout mon code dans l'exemple.

Tu as vu quoi en tracant le isReachable ?

[ptitepomme]

Non, j'ai fait un System.currentTimeMillis() avant et après...
je pense ne pas être trop trop loin du temps de réponse normal.

Je t'ai mis tout mon code dans l'exemple.

Tu as vu quoi en tracant le isReachable ?

Oui on a pas l'air trop loin de la réalité effectivement. Je vais essayer en parsant le retour pour avoir la valeur exacte, c'est important pour moi d'avoir le temps exact.
Mais merci pour ton bout de code, il m'a bien aidé.

Pour les traces, je les mettrai ce soir, sur le PC du boulot, il y a trop de trafic pour y voir clair. Mais si je me souviens bien, c'est de l'UDP qui passe.

[ptitepomme]

Voilà j'ai trouvé un bon compromis qui me donne les temps de réponses exactes.
Je vous partage la source ça en aidera surement certain.

Merci à tous pour vos remarques et vos avis

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
 
public void updateDataResponse(){
		String OS = System.getProperty("os.name");
		String command = null;
		if(OS.startsWith("Windows")){
			command = "ping -n 1 " + this.ip;
		} else if(OS.startsWith("Linux")) {
			command = "ping -c 1 " + this.ip;
		}
 
		try {
			Process p = Runtime.getRuntime().exec(command);
			new PingReader(p.getInputStream(), this).start();
			p.waitFor();
		} catch (IOException e1) {
			//
		} catch (InterruptedException e) {
			//
		}
}

PingReader :

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
 
public void run(){
		while(true){
			try {
				String retourPing = buf.readLine();
				if(retourPing != null){
					if(retourPing.startsWith("R")){
						int begin = retourPing.indexOf("temps=");
						int end = retourPing.indexOf(" ms");
						int time = Integer.parseInt(retourPing.substring(begin+6, end));
						sysId.setResponseTime(time);
					}
				} else {
					return;
				}				
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}