Discussion :

[Luciefer]

Bonjour,

Voilà mon soucis.
Je travaille sur une application TK.
Cette application lance des commandes avec telnet sur des machines distantes et affiche le résultat dans mon appli TK.

JE souhaiterai que l'affichage se fasse en temps réel :

Exemple :

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
 
fonction1(){
   #Envoi une commande
   #Réceptionne le résultat
 
   #Envoi une autre commande
   #Réceptionne le résultat
}
 
#Fonction qui lancem on appli
application(){
   #Création de l'appli (MainWindow....)
   #Appel à la fonction qui lance des commande
   fonction1();
   #Et là, je souhaiterai voir afficher dans ma fenetre TK le résultat de la 1e commande, et puis de la deuxième.... Que tout ne s'affiche pas d'un bloc, quand la fonction1 se termine quoi.
}
MainLoop;

Vous avez une idée?
Je galère dessus depuis pas mal de temps, je ne sais pas du tout quoi faire.
J'ai tenté les thread mais pas top, les fork mais je ne sais pas les utiliser correctement.

Lucie

[Arioch]

Ca a peut être changé maintenant, mais je sais qu'au boulot, on a galéré énormément pour tâcher de faire en sorte qu'une grosse appli écrite en Tk puisse afficher en temps réel les choses qu'on lui demandait.

Ca n'a jamais réussi. C'est particulièrement frustrant lorsque tu vois le bouton "démarrer" rester enfoncé pendant 36 heures sans que rien ne s'affiche à l'écran, le temps que l'appli termine ce qu'elle a à faire

On avait essayé à l'époque de forker, sans aucun changement.

[djibril]

Il est possible de faire une progressbar en TK, jete un coup d'oeil dessus au cas ou ça peut t'aider.

[Arioch]

Il est possible de faire une progressbar en TK, jete un coup d'oeil dessus au cas ou ça peut t'aider.

Une barre de progression, oui, mais comment parvenir à afficher le contenu d'une widget de type Text par exemple au fur et à mesure que le programme écrit des choses dedans ?

Au boulot, nous avons plein d'applis écrites en Perl/Tk. Toutes ont une zone d'affichage chargée d'afficher le résultat du déroulement du programme. Ben à chaque fois, c'est lorsque le programme a fini son taf qu'on a le résultat à l'affichage.

[Jedai]

Au boulot, nous avons plein d'applis écrites en Perl/Tk. Toutes ont une zone d'affichage chargée d'afficher le résultat du déroulement du programme. Ben à chaque fois, c'est lorsque le programme a fini son taf qu'on a le résultat à l'affichage.

Essaie avec un pipe (IO::Pipe par exemple), normalement ça devrait marcher (si tu utilises bien DoOneEvent() dans ta boucle de lecture).

--
Jedaï

[Luciefer]

Re bonjour,

Merci pour les conseils.
J'ai songé à utiliser le pipe mais ej ne sais pas du tout comment l'utiliser dans le cas concret.
Je l'appelle à chaque fois que je lance une commande dans ma fonction????
Je ne sais pas là comment l'utiliser intelligemment.

Sinon ça fait plaisir de voir que je ne suis pas la seule à avoir le même problème :o) Mais le fait que tu n'ais pas trouvé de solution m'inquiète un peu. C'est en effet très frustrant de voir le bouton Valider rester enfoncer très longtemps en bloquant totalement l'appli.

Merci,
Lucie

[Jedai]

Je parlai à Arioch, toi tu veux exécuter du code Perl plutôt qu'un autre processus, non ? Essaie ça :

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
#!/usr/bin/perl
use strict; use warnings;
 
use threads;
use threads::shared;
 
use Tk;
 
my $mw = Tk::MainWindow->new();
 
my $lab = $mw->Label(-text => 'Hello');
$lab->pack;
 
my $finished : shared = 0;
my $result : shared;
 
my $thr = threads->new( sub { 
			  sleep 8; 
			  lock($finished); 
			  $finished = 1; 
			  lock($result);
			  $result = 'Bye';
			} 
);
$thr->detach();
 
my $id;
$id = $mw->repeat(1000, 
		sub { 
		  lock($finished); 
		  if( $finished ){ 
		    $lab->configure(-text => $result);
		    $id->cancel();
		  }
		}
);
 
MainLoop();
 
__END__

Evidemment mets quelque chose de plus intéressant à la place du sleep()...

--
Jedaï

[Luciefer]

Heu non, c exactement le même problème.

Je voudrais pouvoir afficher en temps réel le résultat de ma commande.
Donc je pense qu'il faut utiliser les pipes (comme tu l'as conseillé) mais je ne sais pas comment faire.

Merci,
Lucie

[Jedai]

Non, ce n'est pas exactement le même problème... Ton application reste réactive pendant que ta fonction s'exécute (contrairement à ton code), ce qui signifie qu'en compliquant un peu le schéma du $finished/$result, en utilisant une Thread::Queue par exemple, tu peux avoir un affichage au fur et à mesure de l'exécution de ta fonction1 et même en gardant l'application réactive aux autres évènements tout du long.

--
Jedaï

[Jedai]

Deuxième exemple pour te montrer la différence :

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
#!/usr/bin/perl
use strict; use warnings;
 
use threads;
use threads::shared;
 
use Tk;
 
my $mw = Tk::MainWindow->new();
 
my $lab = $mw->Label(-text => 'Hello');
$lab->pack;
 
my $finished : shared = 0;
my $result : shared;
 
my $thr = threads->new( sub { 
			  sleep 8; 
			  {
			    lock($finished); 
			    $finished = 1; 
			    lock($result);
			    $result = 'Bye';
			  }
			  sleep 4; 
			  {
			    lock($finished); 
			    $finished = 1; 
			    lock($result);
			    $result = 'Bye222';
			  }
			} 
);
$thr->detach();
 
my ($id1, $id2, $i);
 
$id1 = $mw->repeat(500, 
		sub { 
		  my $s = ++$i % 2 ? 'Hello' : '__Hello__';
		  $lab->configure(-text => $s);
		}
);
 
$id2 = $mw->repeat(1000, 
		sub { 
		  lock($finished); 
		  if( $finished ){
		    $id1->cancel();
		    $lab->configure(-text => $result);
		    $finished = 0;
		  }
		}
);
 
MainLoop();
 
__END__

--
Jedaï

[Luciefer]

Re,

Non justement, mon appli n'est plus du tout réactive. Elle est entièrement bloquée le temps que ma fonction s'exécute.
Je reprend la main sur mon appli uniquement quand ma fonction a fini de s'exécuter.
Même dans ce cas, je peux utiliser les méthodes que vous m'avez montré?

Je vais essayer de comprendre pour les threads mais c pas simple :o)
Merci,
Lucie

[Jedai]

Re,

Non justement, mon appli n'est plus du tout réactive. Elle est entièrement bloquée le temps que ma fonction s'exécute.
Je reprend la main sur mon appli uniquement quand ma fonction a fini de s'exécuter.
Même dans ce cas, je peux utiliser les méthodes que vous m'avez montré?

Je vais essayer de comprendre pour les threads mais c pas simple :o)
Merci,
Lucie

Tu es sûr d'avoir bien compris ce que j'ai dis ? Avec MON code, l'application reste réactive pendant que la fonction s'exécute dans un autre thread, avec TON code, l'application ne reste pas réactive, c'est bien ça ?

--
Jedaï

[Luciefer]

D'accord, je vais donc tester.
Par contre, je pense que Arioch devra donc utiliser cette même méthode plutôt que les pipes, non?

Merci et bon we,
Lucie

[Jedai]

D'accord, je vais donc tester.
Par contre, je pense que Arioch devra donc utiliser cette même méthode plutôt que les pipes, non?

Merci et bon we,
Lucie

Son problème est différent et plus simple a priori. Je t'avais initialement conseillé de parsemer ta fonction de DoOneEvent(), tu l'as bien essayé, non ? J'avais cru comprendre que ton principal problème avec cette simple solution était le temps nécessaire pour l'établissement de la connexion telnet, c'est bien ça ?

--
Jedaï

[Jedai]

Pour Arioch, il est possible qu'il soit nécessaire d'utiliser Tk::fileevent plutôt qu'une boucle de lecture si les applications ont tendance à écrire de façon ponctuelle et à s'arrêter d'écrire sur de longues périodes.
Luciefer, je vais essayer de te montrer à quoi pourrai ressembler ton code dans ma solution :

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
#!/usr/bin/perl
use strict; use warnings;
 
use threads;
use threads::shared;
 
use Tk;
 
my $mw = Tk::MainWindow->new();
 
my $lab = $mw->Label(-text => 'Hello');
$lab->pack;
 
my $finished : shared = 0;
my $result : shared;
 
my $thr = threads->new( sub { 
			  # debut fonction1
			  #envoi une commande
                          # premier résultat à afficher
			  {
			    lock($finished); 
			    $finished = 1; 
			    lock($result);
			    $result = 'résultat à afficher';
			  }
 
			  # envoie une commande
                          # second résultat
			  {
			    lock($finished); 
			    $finished = 1; 
			    lock($result);
			    $result = 'second résultat';
			  }
 
                          # et ainsi de suite
			} 
);
$thr->detach();
 
$mw->repeat(1000, 
		sub { 
		  lock($finished); 
		  if( $finished ){
		    $lab->configure(-text => $result);
		    $finished = 0;
		  }
		}
);
 
MainLoop();
 
__END__

Evidemment ta GUI doit être plus complexe, mais cela n'a pas d'influence sur le principe.

--
Jedaï

[Jedai]

Luciefer, as-tu essayé mon avant dernier script et fonctionne-t-il bien sur ta machine ? (a priori il marche sous Windows et Linux, il est donc probable qu'il marche partout où tu voudrais l'utiliser, mais vérifions)
As-tu essayé mon dernier script ? Quel a été le résultat ? Si les commandes s'exécutent vite, il est probable que tu "perdes" des messages vu que la mise à jour ne se fait qu'une fois par seconde, mais ce script n'est là que pour que tu vois le principe, dans ton application finale tu feras ça proprement avec une Thread::Queue et tu ne perdras alors aucun message, ne t'inquiète pas.

--
Jedaï

[Luciefer]

Bonjour,

J'ai testé ce script en l'adaptant à ma solution.
Voici le script :

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
 
#!/usr/bin/perl
use strict; use warnings;
 
use threads;
use threads::shared;
 
use Tk;
 
my $mw = Tk::MainWindow->new();
 
my $lab = $mw->Label(-text => 'Hello');
$lab->pack;
 
my $finished : shared = 0;
my $result : shared;
 
my $thr = threads->new( sub { 
			  fonction1(); #j'exécute ma fonction 1 ici
			  {
			    lock($finished); 
			    $finished = 1; 
			    lock($result);
			    $result = 'résultat à afficher';
			  }
 
			  fonction2(); #j'exécute ma fonction 2 ici
			  {
			    lock($finished); 
			    $finished = 1; 
			    lock($result);
			    $result = 'second résultat';
			  }
 
                          # et ainsi de suite
			} 
);
$thr->detach();
 
$mw->repeat(1000, 
		sub { 
		  lock($finished); 
		  if( $finished ){
		    $lab->configure(-text => $result);
		    $finished = 0;
		  }
		}
);
 
MainLoop();
 
__END__

Et j'ai toujours le même problème. La fonction 2 ne s'exécute uniquement que quand la fonction 1 est terminée complétement.
Est-ce que c parce que ma fonction 1 a un temps relativement court d'exécution ou parce que c'est l'algo qui veut ça?

Merci bcp en tout cas,
Lucie

[/CODE]

[Luciefer]

De plus, je ne peux pas voir si l'affichage se fait en temps réel parce que ma fenêtre se ferme sitôt l'exécution de la 2e fonction terminée.
Mon code exact est le suivant :

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
 
#!/usr/bin/perl
use strict; use warnings;
 
use threads;
use threads::shared;
 
use Tk;
 
my $mw = Tk::MainWindow->new();
 
my $lab = $mw->Label(-text => 'Hello');
$lab->pack;
my $texte_terminal_fonction1=$mw->Scrolled('Text',-scrollbars=>'se',-width=>50,-heigth=>10);
$texte_terminal_fonction1->pack(-side=>'top');
my $texte_terminal_fonction2=$mw->Scrolled('Text',-scrollbars=>'se',-width=>50,-heigth=>10);
$texte_terminal_fonction2->pack(-side=>'top');
 
my $finished : shared = 0;
my $result : shared;
 
my $thr = threads->new( sub { 
			  fonction1($texte_terminal_fonction1);  #j'exécute ma fonction 1 ici 
#Cette fonction affiche dans le terminal 1
			  {
			    lock($finished); 
			    $finished = 1; 
			    lock($result);
			    $result = 'résultat à afficher';
			  }
 
			  fonction2($texte_terminal_fonction2); #j'exécute ma fonction 2 ici
#Cette fonction affiche dans le terminal 2
			  {
			    lock($finished); 
			    $finished = 1; 
			    lock($result);
			    $result = 'second résultat';
			  }
 
                          # et ainsi de suite
			} 
);
$thr->detach();
 
$mw->repeat(1000, 
		sub { 
		  lock($finished); 
		  if( $finished ){
		    $lab->configure(-text => $result);
		    $finished = 0;
		  }
		}
);
 
MainLoop();
 
__END__

L'affichage ne se fait pas en temps réel, en effet, le résultat de la fonction 1 s'affichage dans le text terminal 1 uniquement à la fin de son exécution.

Et à la fin de l'exécution de la fonction 2, la fenêtre se ferme automatiquement et le texte ne s'affiche pas en temps réel.

Lucie

[Jedai]

Merci bcp en tout cas,

Peut-être qu'un minimum de connaissance en informatique parallèle t'aiderait... Parce que là tu as foutu tes deux fonctions dans le même thread à la suite l'une de l'autre, donc évidemment elle s'exécutent séquentiellement !
Par ailleurs tu attends la fin de ta fonction1() avant de communiquer le résultat total au thread principal, donc il n'a rien d'étonnant à ce que le résultat ne s'affiche qu'à la fin de la fonction... Mon exemple spécifiait bien que tu devais modifier ta fonction 1 pour que les résultats soient régulièrement transmis au thread principal.

Va voir la définition de thread quelque part... et revient me dire que tu as compris ton erreur avant que j'abandonne.

--
Jedaï

[Luciefer]

Oui, c bon, j'ai explos' ma fonction 1 et je l'ai intercalé.
Ca fonctionne.

Merci,
Lucie