Article publié dans Linux Magazine 55, novembre 2003. Repris dans Linux Dossiers 2, avril/mai/juin 2004.

Des fonctions de haut niveau

On peut dire très grossièrement qu'il en existe trois formes différentes (les deux dernières permettent de récupérer la sortie) :

    system "commande";
    $sortie = `commande`;
    open SORTIE, "commande |";

Voyons donc en détail ces outils que Perl met à notre disposition.

`system()`

Un premier moyen de lancer un processus fils est la fonction system() :

    system "date";

Ici, le processus fils est la commande Unix date(1). Tout ce que le prompt shell peut interpréter peut être utilisé dans cette chaîne (on précisera plus loin quel shell réalise cette interprétation).

Le processus fils hérite des entrées et sorties standards ainsi que de la sortie d'erreur de Perl. Aussi, la sortie de cette commande date(1) aboutira là où le STDOUT de Perl était dirigé (par défaut, l'écran). Il n'est donc pas possible de récupérer facilement cette sortie dans le script Perl d'où la commande a été lancée. Il est bien entendu possible de la rediriger vers un fichier. Mais si dans la suite du script on souhaite accéder à cette sortie, cela signifie qu'il faut ouvrir ce fichier, le lire puis le refermer. Si une écriture sur disque n'est pas indispensable, on préférera d'autres solutions qui seront abordées dans la suite.

La commande peut être aussi complexe que nécessaire, dans la mesure où /bin/sh peut l'exécuter :

    system "for i in *; do echo __ \$i __; cat \$i; done";

Ici, on affiche le contenu d'un répertoire, fichier par fichier. Les variables $i sont protégées par une barre oblique inversée (\) parce que Perl les aurait remplacées par leur valeur courante dans le script Perl alors qu'on souhaite que le shell voit ses propres variables $i à la place. Une solution est d'utiliser les apostrophes (' ou simple quotes) à la place des guillemets (" ou double quotes), puisqu'elles ne réalisent pas l'interpolation des variables Perl :

    system 'for i in *; do echo __ $i __; cat $i; done';

Cette commande serait plus lisible si elle s'étendait sur plusieurs lignes. Ce qui se fait très simplement avec une citation orientée ligne (here-document ou document « ici-même ») :

    system <<'FIN';
    for i in *
    do
        echo __ $i __
        cat $i
    done
    FIN

Cette citation orientée ligne est initiée par l'opérateur << suivi d'un identifiant qui déterminera la fin de la citation (FIN dans notre cas). Toutes les lignes qui se trouvent entre les deux occurrences de l'identifiant FIN sont transformées en une chaîne, qui constitue l'argument de system(). La manière dont la transformation est effectuée dépend des éventuels caractères de ponctuation qui entourent l'identifiant. En l'absence de tels caractères, c'est le comportement des guillemets qui est utilisé par défaut. Aussi des apostrophes ont-elles été ajoutées pour empêcher l'interpolation des $i qui doivent être passés au shell. Une attention particulière doit être portée à cette syntaxe : la seconde occurrence de l'identifiant doit apparaître seule sur la ligne de terminaison (sans ponctuation et sans espaces).

Par ailleurs, pendant que le processus fils s'exécute, Perl est arrêté. Ainsi, si une commande nécessite 40 secondes pour s'exécuter, votre script est arrêté pendant 40 secondes. Il est possible de faire se dérouler un processus en tâche de fond par l'intermédiaire du shell :

    system "commande_qui_prend_du_temps avec ses arguments &";

Attention cependant : dans ce cas plus moyen d'interagir avec la commande, ni même de connaître son numéro de processus pour la tuer ou vérifier qu'elle est encore en vie.

On n'abordera que plus tard les cas où cette interprétation par le shell peut s'avérer problématique. Mais signalons dès maintenant qu'il existe une autre version de system() qui évite tout passage par le shell. Cette version utilise non plus un unique argument mais plusieurs. Nous y reviendrons le moment venu.

`exec()`

La fonction exec() se comporte comme system() pour tous les aspects déjà évoqués. La seule différence est qu'au lieu de créer un processus fils pour exécuter la commande en argument, le processus perl devient cette commande. Par exemple :

    exec "date";

À partir du moment où la commande date(1) a commencé à s'exécuter, on quitte perl pour ne plus y revenir. L'interpréteur perl est remplacé par la commande date(1). La seule raison de placer du code Perl après un exec() est d'expliquer que la commande date(1) n'a pu être trouvée dans le PATH :

    exec "date";
    die "date non trouvée dans $ENV{PATH}";

Placer autre chose qu'un die(), un warn() ou un exit() après un exec() provoque d'ailleurs un avertissement si on emploie l'option -w (ou use warnings depuis Perl 5.6) :

    $ perl -we 'exec "date"; print "date non trouvée";'
    Statement unlikely to be reached at -e line 1.
            (Maybe you meant system() when you said exec()?)

Disons d'une manière imagée qu'avec system() on embarque pour un voyage aller-retour, alors qu'avec exec(), on prend un aller simple. Si on se trouve encore sur le quai après un exec(), c'est que le départ n'a pas été possible.

Randal L. Schwartz emploie pour sa part une autre métaphore pour exprimer cette différence entre system() et exec() : il compare system() à un appel de fonction et exec() à un goto.

Remarquez d'ailleurs que l'utilisation d'exec() empêchera l'appel des blocs END de votre code et des méthodes DESTROY de vos objets.

Pourquoi employer exec() plutôt que system() ? Il peut s'avérer intéressant d'employer exec() dans les cas où Perl est utilisé pour préparer l'environnement d'une commande dont l'exécution prendra du temps :

    $ENV{DATABASE} = "ma_base_de_donnee";
    $ENV{PATH} = "/usr/bin:/bin:/opt/base_de_donnee";
    chdir "/usr/lib/mes.informations"
        or die "Changement de répertoire impossible : $!";
    exec "commande_qui_prend_du_temps";
    die "commande_qui_prend_du_temps non trouvée dans $ENV{PATH}";

Remplacer exec() par system() aurait eu pour effet de laisser tourner un programme Perl inutile qui attendrait juste que commande_qui_prend_du_temps s'achève.

Pour prendre un exemple plus concret d'utilité de exec(), construisons une version Perl de la commande dvipdf. Cette commande transforme un document au format DVI (un des formats de sortie de LaTeX) en un fichier PDF. Elle se présente à l'origine sous la forme d'un petit script shell dont le but est de lancer une suite de commandes munies des bonnes options. Il s'agit essentiellement, quand on souhaite générer un fichier destination.pdf à partir d'un fichier source.dvi, de ne pas avoir à se souvenir d'un enchaînement du type dvips -q -f source.dvi | gs -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sOutputFile=destination.pdf -c save pop -. Une telle inclusion dans un script permet, en plus, de construire à partir du préfixe au .dvi le nom du fichier destination.pdf quand ce dernier n'est pas spécifié :

    #!/usr/bin/perl -w
    # Version Perl de dvipdf.
    use strict;

    # séparation des arguments
    my $options = join ( ' ', grep { /^-\S+/ } @ARGV );    # options
    my @fichiers = grep { !/^-\S+/ } @ARGV;                # source et autres

    if ( $#fichiers < 0 or $#fichiers > 1 ) {
        use File::Basename;
        print "Usage: ", basename($0),
          " [options...] source.dvi [destination.pdf]\n";
    }

    my $source = $fichiers[0];
    my $destination;
    if ( $#fichiers == 0 ) {
        $fichiers[0] =~ s/.dvi$//;
        $destination = "$fichiers[0].pdf";
    }
    else {
        $destination = $fichiers[1];
    }

    my $commandes =
      "dvips -q -f $source |"
      . " gs -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite"
      . " -sOutputFile=$destination $options -c save pop -";

    # fin des préparatifs, exécution des commandes
    exec $commandes;

On entrevoit ici qu'un exec() peut nécessiter un gros travail de préparation. Signalons qu'outre le gain en temps d'exécution par rapport à la version shell, cette version Perl offre plus de souplesse : elle n'oblige pas à placer les fichiers source et destination après les options (ordre à respecter avec la version shell).

Les apostrophes inversées

Le terme d'apostrophe inversée désigne le caractère ` appelé backquote ou backtick en anglais (quote désignant l'apostrophe).

Quand on invoque une commande pour disposer de sa sortie sous la forme d'une chaîne de caractères, la manière la plus simple de procéder est d'employer les apostrophes inversées :

    $maintenant = `date`;

La sortie standard de date(1) est stockée sous la forme d'une chaîne d'une trentaine de caractères suivie d'un saut de ligne. Tout ce qui est envoyé vers la sortie standard est capturé sous la forme d'une chaîne de caractères, renvoyée par les apostrophes inversées, et, dans notre cas, stocké dans $maintenant. Si la sortie comporte plusieurs lignes, toutes les lignes se retrouvent les unes à la suite des autres dans la chaîne. Cette chaîne peut être divisée en lignes par un split() sur les sauts de ligne, mais la manière la plus simple est d'utiliser les apostrophes inversées en contexte de liste :

    @logins = `who`;

Ici, @logins contiendra une entrée pour chacune des lignes de la sortie de la commande who. On peut analyser cette sortie au moyen d'une boucle comme celle qui suit :

    for( `who` ) {
        ($utilisateur, $tty, $date) =
            /^(\S+)\s+(\S+)\s+(.*)/;
        $logins{$utilisateur}{$tty} = $date;
    }

Chaque itération de la boucle décrit un terminal différent avec la date depuis laquelle le dernier utilisateur s'y trouve. Ces informations sont placées dans un hash à deux niveaux indexé par le nom de l'utilisateur puis celui du terminal. Ceci fait, on peut afficher le tout trié par utilisateur :

    for $utilisateur ( sort keys %logins ) {
        for $tty ( sort keys %{ $logins{$utilisateur} } ) {
            print "$utilisateur se trouve sur $tty depuis ",
              "$logins{$utilisateur}{$tty}\n";
        }
    }

La première boucle peut profiter des variables par défaut pour obtenir une écriture plus concise :

    for( `who` ) {
        /^(\S+)\s+(\S+)\s+(.*)/;
        $logins{$1}{$2} = $3
    }

Les variables globales $1, $2 et $3 correspondent aux trois chaînes capturées par les parenthèses de l'expression régulière (l'utilisateur, le terminal et la date).

Les apostrophes inversées se comportent comme des guillemets en ce qui concerne l'interpolation de leur contenu. Ainsi, les caractères d'échappement comme \n et \t peuvent être utilisés et les variables Perl sont interpolées. Une première conséquence de cette interpolation est que, comme pour system(), on peut être amené à protéger certains caractères spéciaux :

    $fichiers = `for i in *; do echo __ \$i __; cat \$i; done`;

Il est également possible d'utiliser l'opérateur qx/CHAINE/, équivalent aux apostrophes inversées, mais qui donne accès aux apostrophes (simples) :

    $fichiers = qx'for i in *; do echo __ $i __; cat $i; done';

L'autre conséquence de l'interpolation sera développée dans le chapitre sur le passage par le shell.

Si on souhaite récupérer la sortie d'erreur plutôt que la sortie standard, on peut utiliser les opérateurs de redirection du shell (l'ordre est ici très important) :

    $sortie_erreur = `commande 2>&1 1>/dev/null`;

2>&1 provoque d'abord la redirection de la sortie d'erreur (désignée par le chiffre 2) vers l'endroit où la sortie standard (désignée par 1) aboutit par défaut (c'est ce que les apostrophes inversées récupéreront). Pour que les apostrophes inversées ne récupèrent pas également la sortie standard, cette dernière est réorientée vers /dev/null (1>/dev/null). Si l'ordre avait été inversé (1>/dev/null 2>&1), les sorties auraient toutes deux abouti dans /dev/null, et les apostrophes inversées n'auraient rien renvoyé.

`open()`

En Perl, la fonction open() ne sert pas seulement à accéder à des fichiers. Si le deuxième argument d'un open() s'achève par une barre verticale (le symbole tube), Perl le traite comme une commande à lancer plutôt que comme un nom de fichier :

    open DATE, "date|";

Au moment où cette ligne est exécutée, une commande date(1) est lancée dont la sortie standard aboutit dans le manipulateur de fichier DATE pour y être lue. On parle de tube ou de conduit car la sortie de la commande se déverse dans une sorte de fichier temporaire présent uniquement en mémoire. Ce fichier temporaire est justement appelé un tube (pipe en anglais). Le manipulateur DATE permet de lire ce fichier comme s'il s'agissait d'un fichier normal (sur disque). On peut donc y lire la sortie en utilisant les opérations habituelles sur les manipulateurs de fichiers :

    $maintenant = <DATE>;

De la même manière que pour les fichiers, le manipulateur est créé par le open() et disparaîtra après un close(). Contrairement au manipulateur d'un fichier classique, il n'est par contre pas possible d'y accéder par l'intermédiaire des fonctions tell() et seek().

Le processus tourne en parallèle de Perl, et se coordonne avec lui de la même manière que pour un tube standard. Donc si la commande date(1) envoie sa sortie avant que Perl ne soit prêt, il attendra, et si Perl lit avant que date(1) ne soit prêt à écrire, le processus Perl sera arrêté jusqu'à ce que la sortie soit disponible, sans consommation de CPU.

Par rapport aux apostrophes inversées, cette méthode présente l'avantage de pouvoir traiter la sortie au fur et à mesure de son écriture. En effet, si la sortie est volumineuse, la récupérer d'un seul coup va occuper de la mémoire, que ce soit par l'intermédiaire des apostrophes inversées :

    @sortie = `genere_sortie_volumineuse`;

ou bien par l'intermédiaire d'une lecture en contexte de liste :

    open SORTIE, "genere_sortie_volumineuse |";
    @sortie = <SORTIE>;
    close SORTIE;

Dans les deux cas, le tableau @sortie peut occuper beaucoup de place en mémoire.

Une solution est d'utiliser le manipulateur de fichier fourni par open() en contexte scalaire :

    open SORTIE, "genere_sortie_volumineuse |";
    while( my $ligne = <SORTIE> ) {
        # la ligne courante est stockée dans $ligne
        ...
    }
    close SORTIE;

Rappelons que dans ce cas d'une affectation simple, Perl traduit automatiquement cette boucle while en :

    while( defined( my $ligne = <SORTIE> ) ) {
        ...
    }

ce qui évite d'être à la merci de bugs subtils (comme l'avait précisé BooK dans son article sur les variables de LinuxMag 52).

Avec cette construction, la sortie est traitée ligne par ligne, au fur et à mesure de son écriture par genere_sortie_volumineuse. On stocke ainsi une seule ligne à la fois plutôt que l'ensemble des lignes, ce qui réduit d'autant l'espace mémoire occupé.

La fonction open() renvoie undef dans le cas où la duplication de processus (le fork) n'a pu être réalisée. On peut donc le tester au moyen d'un ou :

    open SORTIE, "commande |"
        or die "impossible de dupliquer le processus : $!";

Lancer des processus à partir de Perl

Chapeau de l'article

Plusieurs manières de faire

Les processus

Lancer des processus ?

Des fonctions de haut niveau

`system()`

`exec()`

Les apostrophes inversées

`open()`

Le passage par le shell

Pour `system()` et `exec()`

Pour les apostrophes inversées

Pour `open()`

Et les fonctions de plus bas niveau ?

La gestion des états de sortie

La variable `$?`

Avec `system()`

Avec les apostrophes inversées

Avec `open()`

Ne pas tomber dans l'excès

Résumé

Conclusion

Références

Auteur

Lancer des processus à partir de Perl

Chapeau de l'article

Plusieurs manières de faire

Les processus

Lancer des processus ?

Des fonctions de haut niveau

system()

exec()

Les apostrophes inversées

open()

Le passage par le shell

Pour system() et exec()

Pour les apostrophes inversées

Pour open()

Et les fonctions de plus bas niveau ?

La gestion des états de sortie

La variable $?

Avec system()

Avec les apostrophes inversées

Avec open()

Ne pas tomber dans l'excès

Résumé

Conclusion

Références

Auteur

`system()`

`exec()`

`open()`

Pour `system()` et `exec()`

Pour `open()`

La variable `$?`

Avec `system()`

Avec `open()`