Pipe en entrée et en sortie. Blocage.

**AiYori** · 14/01/2015, 20h49

Bonjour,

Je fais suite au fil Pipe en entrée et en sortie.

Il s'avère que le script utilisé fonctionne bien pour les entrées courtes, mais il y a un blocage dès que l'entrée devient volumineuse. Le code suivant permet de mettre en relief le problème.

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
 
use strict;
use warnings;
 
use File::Slurp;
use IPC::Open2;
 
#* Paramètres. *
my $nomsource = "source.php";
 
sub filtrecommande {
    my ($commande, $entree) = @_;
 
    #* Ouverture des descripteurs de fichiers. *
    my ($df_sortie, $df_entree);
    my $pid = open2($df_sortie, $df_entree, $commande);
 
    #* Envoie des données en entrée du filtre. *
    print $df_entree $entree;
    close $df_entree;
print STDERR "Balise 1.\n";
    waitpid($pid, 0);
print STDERR "Balise 2.\n";
 
    #* Récupération des données en sortie de filtre. *
    my $sortie;
    while ( my $ligne = <$df_sortie> ) {
        $sortie .= $ligne;
    }
    close $df_sortie;
 
    #* Terminaison. *
    return $sortie;
 
}
 
my $source = read_file($nomsource, binmode => ':utf8');
my $produit = filtrecommande('php', $source);
print STDERR "Produit : <<$produit>>\n";

Le script s'arrête, lorsque 'source.php' est volumineux, entre la balise 1 et la balise 2. Manifestement le fils (qui lance le programme 'php' je pense) ne termine pas. Mon analyse est que le tampon de sortie du programme 'php' est plein.

Est-ce que quelqu'un aurait des idées, et pourrait me conseiller sur un mode de résolution ?

**Lolo78** · 14/01/2015, 23h15

Hum, vraiment pas sûr que je puisse t'aider, si ce n'est en te redisant ce que je t'avais dit sur ton autre thread, à savoir que tu as choisi une architecture bien compliquée.

Mais bon, je vais quand même essayer. Peux-tu donner les informations suivantes:
- Tu parles d'un blocage dès que l'entrée devient volumineuse; je suppose que tu parles du fichier en pseudo-SGML (modifié ou non par ton code Perl). A partir de quelle taille (approximativement) ça bloque?
- Si tu mets le contenu que tu passes au programme PHP dans un fichier et fait traiter ce fichier pas ce programme, est-ce que ça marche?
- Ton code PHP, est-ce qu'il ne fait que lire séquentiellement le contenu qui lui est passé et renvoyer le contenu transformé? Est-ce qu'il charge tout le contenu en entrée en mémoire?
- Ton code PHP fonctionne sur un serveur? Lequel? Le code est-il multi-threadé? N'y a-t-il pas un risque d'interblocage dans ce cas?

Sinon, une ou deux pistes un peu différentes: le module PHP du CPAN et le module interpréteur PHP du CPAN. Ces deux modules paraissent les plus prometteurs, puisqu'ils semblent être en mesure d'exécuter du PHP deluis l'interpréteur Perl, mais il y a quelques autres modules relatifs à PHP sur le CPAN, fais une recherche "CPAN PHP" sur Google ou autre, tu trouveras peut-être une solution te convenant.

**Philou67430** · 15/01/2015, 09h13

Je crois l'avoir déjà dit, mais l'usage du pipe en entrée et en sortie avec IPC::Open2 nécessite que les deux processus en communication (c'est nécessaire mais pas forcément suffisant) fassent leurs écritures en direct, sans bufferisation. Ça signifie pour perl d'avoir au moins l'instruction $|++ en tête de programme. Néanmoins, je vois que tu fermes le filehandle une fois écris ce que tu as à envoyer au processus fils, donc cela devrait "flusher" la sortie... mais dans ce type d'architecture, je mettrais ceinture et bretelle, c'est trop sensible.
Pour PHP, aucune idée, mais on pourrait supposer que les informations que tu envoies sont insuffisantes pour que le processus se termine. As-tu essayé de copier ce que tu émets dans $df_entree dans un fichier de log que tu pourras essayer d'envoyer à ton processus PHP en dehors de perl (en ligne de commande par exemple) ? (voir point 2 de lolo)

**AiYori** · 25/01/2015, 15h26

Le script suivant fonctionne.

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
 
use strict;
use warnings;
 
use File::Slurp;
use IPC::Open2;
 
#* Paramètres. *
my $nomsource = "source1.php";
 
sub filtrecommande {
    my ($commande, $entree) = @_;
 
    #* Ouverture des descripteurs de fichiers. *
    my ($df_sortie, $df_entree);
    my $pid = open2($df_sortie, $df_entree, $commande);
 
    #* Envoie des données en entrée du filtre. *
    print $df_entree $entree;
    close $df_entree;
 
    #* Récupération des données en sortie de filtre. *
    my $sortie;
    while ( my $ligne = <$df_sortie> ) {
        $sortie .= $ligne;
    }
    close $df_sortie;
 
    #* Attente processus fils. *
    waitpid($pid, 0);
 
    #* Terminaison. *
    return $sortie;
 
}
 
my $source = read_file($nomsource, binmode => ':utf8');
my $produit = filtrecommande('php', $source);
print STDERR "Produit : <<$produit>>\n";

**AiYori** · 25/01/2015, 15h41

En réponse à une des questions de Lolo78 dans son message du 14 janvier :
- un ficher en entrée ('source1.php') d'une taille de 15 604 octets passe ;
- un fichier en entrée ('source2.php') d'une taille de 85 194 octets ne passe pas.

**AiYori** · 25/01/2015, 15h43

En réponse à une des questions de Lolo78 dans son message du 14 janvier, la commande suivante fonctionne.

Code :

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

1
2
 
cat source1.php | php

**AiYori** · 25/01/2015, 15h54

Autre éléments de réponse au message de Lilo78 en date du 14 janvier.

- Ton code PHP, est-ce qu'il ne fait que lire séquentiellement le contenu qui lui est passé et renvoyer le contenu transformé? Est-ce qu'il charge tout le contenu en entrée en mémoire?

Le code PHP que je mets en entrée ne lit en fait rien. Il manipule quelques variables simples.
La question qu'on pourrait en revanche se poser, c'est la manière dont se comporte l'intépréteur PHP. Et là, pour l'heure, je n'en sais rien. Je suppose néanmoins qu'il doit charger tout le fichier texte, effectuer une précompilation en mémoire, et exécuter le bytecode obtenu (et resté en mémoire).

- Ton code PHP fonctionne sur un serveur? Lequel? Le code est-il multi-threadé? N'y a-t-il pas un risque d'interblocage dans ce cas?

Je ne fonctionne pas du tout sur une architecture client - serveur. Je me contente d'utiliser l'interpréteur PHP en local, comme un préprocesseur de texte, comme on a l'habitude de le faire avec M4.

Sinon, une ou deux pistes un peu différentes: le module PHP du CPAN et le module interpréteur PHP du CPAN. Ces deux modules paraissent les plus prometteurs, puisqu'ils semblent être en mesure d'exécuter du PHP deluis l'interpréteur Perl, mais il y a quelques autres modules relatifs à PHP sur le CPAN, fais une recherche "CPAN PHP" sur Google ou autre, tu trouveras peut-être une solution te convenant.

Cette idée me plaît bien. Je vais creuser.

**AiYori** · 25/01/2015, 16h06

Envoyé par Philou67430

Je crois l'avoir déjà dit, mais l'usage du pipe en entrée et en sortie avec IPC::Open2 nécessite que les deux processus en communication (c'est nécessaire mais pas forcément suffisant) fassent leurs écritures en direct, sans bufferisation. Ça signifie pour perl d'avoir au moins l'instruction $|++ en tête de programme. Néanmoins, je vois que tu fermes le filehandle une fois écris ce que tu as à envoyer au processus fils, donc cela devrait "flusher" la sortie... mais dans ce type d'architecture, je mettrais ceinture et bretelle, c'est trop sensible.

Ca ne marche pas. Le code suivant bloque toujours.

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
 
use strict;
use warnings;
 
use File::Slurp;
use IPC::Open2;
 
#* Paramètres. *
my $nomsource = "source1.php";
$|++;
 
sub filtrecommande {
    my ($commande, $entree) = @_;
 
    #* Ouverture des descripteurs de fichiers. *
    my ($df_sortie, $df_entree);
    my $pid = open2($df_sortie, $df_entree, $commande);
 
    #* Envoie des données en entrée du filtre. *
    print $df_entree $entree;
    close $df_entree;
print STDERR "Balise 1.\n";
    waitpid($pid, 0);
print STDERR "Balise 2.\n";
 
    #* Récupération des données en sortie de filtre. *
    my $sortie;
    while ( my $ligne = <$df_sortie> ) {
        $sortie .= $ligne;
    }
    close $df_sortie;
 
    #* Terminaison. *
    return $sortie;
 
}
 
my $source = read_file($nomsource, binmode => ':utf8');
my $produit = filtrecommande('php', $source);
print STDERR "Produit : <<$produit>>\n";

**AiYori** · 25/01/2015, 16h15

Merci à tous pour votre aide. Vous pouvez voir dans mon message 25/01/2015#0 que le problème peu sembler être résolu en attentant le fils une fois que la lecture a été effectuée.
J'ai tout de même l'impression que mon code n'est pas très robuste. Je n'en comprends pas trop le fonctionnement interne : il est nécessaire que je lise un peu de code avant que le fils (le processus qui exécute l'interpréteur PHP) ne puisse se terminer. Est-ce que je ne cours pas le risque de ne lire qu'une partie du code produit par le processus fils ?

Pipe en entrée et en sortie. Blocage.

Programmation et administration système Perl

Discussions similaires

Partager

Partager