From perl at escwq.fr Sat Feb 8 21:56:29 2020 From: perl at escwq.fr (Nicolas) Date: Sat, 8 Feb 2020 21:56:29 +0100 Subject: [Perl] =?utf-8?q?Retour_=C3=A0_Perl_-_parser_une_sortie_de_comman?= =?utf-8?q?de_multiligne?= Message-ID: Bonsoir, Après de (trop) nombreuses années à ne pas faire d'admin, je remets (laborieusement) les mains dans le cambouis... et donc dans perl ;o) Je n'ai jamais eu un niveau "gourou" en perl (même il y a 15ans) mais j'arrive encore à écrire du code qui me donne le résultat attendu.... alors ça me convient ;o) Mais du coup je vais peut-être avoir une question "bête" concernant le traitement de la sortie d'une commande. La commande fournit une sortie sur STDOUT que je stocke dans un tableau via : my @array=split(/\n/,`ma_super_commande_UNIX`) or die "error while processing command \"ma_super_commande_UNIX\""; Ensuite je fais une boucle pour parcourir le tableau et appliquer la bonne regexp afin de récupérer les parties "ah-hoc" de chaque ligne et les stocker dans un hash avec les bonnes clés. La boucle est de la forme : foreach my $scalar (@array) {   if ( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ )   {     $hash{$stanza}{'VGid'}=$1;   } } En répétant les "if" dans la boucle (un "if" par ligne à traiter avec la regexp associée) je peux matcher chaque ligne "qui va bien" par exécution de la commande et ainsi récupérer les 2 valeurs par ligne qui m'intéressent. A la place du "if" j'ai essayé une notation de la forme :     ($hash{$stanza}{'VGid'}, )=( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ); Mais ceci a pour seul résultat de bien matcher la bonne ligne dans la boucle, mais au "tour suivant" de la boucle (ligne suivante stockée dans @array) alors la valeur est "mise à zéro", ceci sans doute car du coup la regexp ne match pas ce qui est assez logique puisque ce n'est plus la bonne ligne. J'ai donc certainement loupé un truc quelque part..... Je peux bien entendu garder ma ribambelle de "if" à l'intérieur de la boucle mais..... je pense qu'il y a plus simple / plus perl et que je ne suis pas loin..... :( J'ai mis, un exemple de sortie de commande en fin de mail, je récupère les 1 ou 2 valeurs par ligne pour stocker la 30aine de valeurs dans un hash. Bonne soirée, Nicolas VOLUME GROUP:       rootvg                   VG IDENTIFIER: 00f702be00004c0000000159122168ad VG STATE:           active                   PP SIZE:        128 megabyte(s) VG PERMISSION:      read/write               TOTAL PPs:      799 (102272 megabytes) MAX LVs:            256                      FREE PPs:       21 (2688 megabytes) LVs:                28                       USED PPs:       778 (99584 megabytes) OPEN LVs:           22                       QUORUM:         2 (Enabled) TOTAL PVs:          1                        VG DESCRIPTORS: 2 STALE PVs:          0                        STALE PPs:      0 ACTIVE PVs:         1                        AUTO ON:        yes MAX PPs per VG:     32512 MAX PPs per PV:     1016                     MAX PVs:        32 LTG size (Dynamic): 512 kilobyte(s)          AUTO SYNC:      no HOT SPARE:          no                       BB POLICY: relocatable PV RESTRICTION:     none                     INFINITE RETRY: no DISK BLOCK SIZE:    512                      CRITICAL VG:    no FS SYNC OPTION:     no From biz at joueb.com Sun Feb 9 00:52:03 2020 From: biz at joueb.com (=?UTF-8?Q?St=c3=a9phane_Gigandet?=) Date: Sun, 9 Feb 2020 00:52:03 +0100 Subject: [Perl] =?utf-8?q?Retour_=C3=A0_Perl_-_parser_une_sortie_de_comman?= =?utf-8?q?de_multiligne?= In-Reply-To: References: Message-ID: Hello Nicolas, Comme la sortie est toujours de la forme "clé : valeur" (avec 2 paires clés / valeurs sur chaque ligne), le plus simple c'est peut être de parser toutes les clés en un coup, sans découper chaque ligne dans un tableau, avec un truc de ce genre là : #!/usr/bin/perl -w use strict; my $result = `cat result`; my %values = (); while ($result =~ /\s*([^:]+):\s+(.*?)(  |\n)/g) {         $values{$1} = $2; } foreach my $key (sort keys %values) {         print "$key : $values{$key}\n"; } Ca donne ça : ACTIVE PVs : 1 AUTO ON : yes AUTO SYNC : no BB POLICY : relocatable CRITICAL VG : no DISK BLOCK SIZE : 512 FREE PPs : 21 (2688 megabytes) FS SYNC OPTION : no HOT SPARE : no INFINITE RETRY : no LTG size (Dynamic) : 512 kilobyte(s) LVs : 28 MAX LVs : 256 MAX PPs per PV : 1016 MAX PPs per VG : 32512 MAX PVs : 32 OPEN LVs : 22 PP SIZE : 128 megabyte(s) PV RESTRICTION : none QUORUM : 2 (Enabled) STALE PPs : 0 STALE PVs : 0 TOTAL PPs : 799 (102272 megabytes) TOTAL PVs : 1 USED PPs : 778 (99584 megabytes) VG DESCRIPTORS : 2 VG IDENTIFIER : 00f702be00004c0000000159122168ad VG PERMISSION : read/write VG STATE : active VOLUME GROUP : rootvg Bon dimanche, Stéphane Le 08/02/2020 à 21:56, Nicolas a écrit : > Bonsoir, > > Après de (trop) nombreuses années à ne pas faire d'admin, je remets > (laborieusement) les mains dans le cambouis... et donc dans perl ;o) > > Je n'ai jamais eu un niveau "gourou" en perl (même il y a 15ans) mais > j'arrive encore à écrire du code qui me donne le résultat attendu.... > alors ça me convient ;o) > Mais du coup je vais peut-être avoir une question "bête" concernant le > traitement de la sortie d'une commande. > > La commande fournit une sortie sur STDOUT que je stocke dans un > tableau via : > my @array=split(/\n/,`ma_super_commande_UNIX`) or die "error while > processing command \"ma_super_commande_UNIX\""; > > Ensuite je fais une boucle pour parcourir le tableau et appliquer la > bonne regexp afin de récupérer les parties "ah-hoc" de chaque ligne et > les stocker dans un hash avec les bonnes clés. > > La boucle est de la forme : > foreach my $scalar (@array) > { >   if ( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ) >   { >     $hash{$stanza}{'VGid'}=$1; >   } > } > > En répétant les "if" dans la boucle (un "if" par ligne à traiter avec > la regexp associée) je peux matcher chaque ligne "qui va bien" par > exécution de la commande et ainsi récupérer les 2 valeurs par ligne > qui m'intéressent. > > A la place du "if" j'ai essayé une notation de la forme : >     ($hash{$stanza}{'VGid'}, )=( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ); > > Mais ceci a pour seul résultat de bien matcher la bonne ligne dans la > boucle, mais au "tour suivant" de la boucle (ligne suivante stockée > dans @array) alors la valeur est "mise à zéro", ceci sans doute car du > coup la regexp ne match pas ce qui est assez logique puisque ce n'est > plus la bonne ligne. > J'ai donc certainement loupé un truc quelque part..... > Je peux bien entendu garder ma ribambelle de "if" à l'intérieur de la > boucle mais..... je pense qu'il y a plus simple / plus perl et que je > ne suis pas loin..... :( > > J'ai mis, un exemple de sortie de commande en fin de mail, je récupère > les 1 ou 2 valeurs par ligne pour stocker la 30aine de valeurs dans un > hash. > > Bonne soirée, > Nicolas > > VOLUME GROUP:       rootvg                   VG IDENTIFIER: > 00f702be00004c0000000159122168ad > VG STATE:           active                   PP SIZE:        128 > megabyte(s) > VG PERMISSION:      read/write               TOTAL PPs:      799 > (102272 megabytes) > MAX LVs:            256                      FREE PPs:       21 (2688 > megabytes) > LVs:                28                       USED PPs:       778 > (99584 megabytes) > OPEN LVs:           22                       QUORUM:         2 (Enabled) > TOTAL PVs:          1                        VG DESCRIPTORS: 2 > STALE PVs:          0                        STALE PPs:      0 > ACTIVE PVs:         1                        AUTO ON:        yes > MAX PPs per VG:     32512 > MAX PPs per PV:     1016                     MAX PVs:        32 > LTG size (Dynamic): 512 kilobyte(s)          AUTO SYNC:      no > HOT SPARE:          no                       BB POLICY: relocatable > PV RESTRICTION:     none                     INFINITE RETRY: no > DISK BLOCK SIZE:    512                      CRITICAL VG:    no > FS SYNC OPTION:     no > > > _______________________________________________ > Perl mailing list > Perl at mongueurs.net > http://listes.mongueurs.net/mailman/listinfo/perl > Attention, les archives sont publiques From perl at escwq.fr Sun Feb 9 02:41:30 2020 From: perl at escwq.fr (Nicolas) Date: Sun, 9 Feb 2020 02:41:30 +0100 Subject: [Perl] =?utf-8?q?Retour_=C3=A0_Perl_-_parser_une_sortie_de_comman?= =?utf-8?q?de_multiligne?= In-Reply-To: References: Message-ID: Bonsoir Stéphane, Merci pour ta proposition ! C'est effectivement sans doute la bonne approche au global, modulo que certaines lignes n'ont parfois qu'une seule "clée/valeur" suivant la config rencontrée (donc non prévisible). Il semble que ta regexp "gère ça" mais je n'ai pas encore compris comment :/ Par contre j'aimerai quelques explications (ou une confirmation) sur ta regexp stp (j'aime bien comprendre ^_^ ). /\s*([^:]+):\s+(.*?)(  |\n)/g /          0) Début de la regexp \s*        1) Match 0 ou + "espace" (          2) On commence la sélection => ce sera $1 [^:]+      3) On prend ):         4) On termine la sélection juste avant le premier ":"                 A ce stade on a "enlevé tous les espaces de début de ligne (1) et ensuite commencé la sélection (2) juste avant de prendre et on termine la sélection juste avant le premier ":" rencontré (4), car ":" c'est le séparateur de fin de clée. \s+        5) Match 0 ou + "espace" (          6) On commence la sélection => ce sera $2 .*?        7) On prend n'importe quel caractère en mode "non gourmand" )          8) On termine la sélection                 A partir d'ici j'ai plus de mal à comprendre car je pense que ça doit débuter la sélection de $3, alors qu'on ne l'utilise pas après. (          9) On commence la sélection => ce sera $3   |\n     10) On prend "2x espace" ou "fin de ligne" )         11) On termine la sélection /g        12) Fin de la regex avec utilisation du flag "g" qui va matcher répétitivement. Je pense avoir correctement analysé le contenu mais pas le "but" de la regexp "dans son ensemble", en particulier les parties (9) et suivantes. Je pense que le (10) sert à identifier une "fin de paire cle/valeur" avec les 2 espaces consécutifs ou la fin de ligne. Le flag "g" va permettre de matcher "plusieurs fois" par ligne et donc les 2 couples "clé/valeur" par ligne, mais du coup comment perl "fait-il le job" en utilisant uniquement $1 et $2 dans le while et que devient $3 ? En effet, pour une ligne avec 1x "clé/valeur", on va bien avoir :     $1 = clé     $2 = valeur Mais pour une ligne avec 2x "clé/valeur", je m'attendrai à avoir :     $1 = clé     $2 = valeur     $3 = clé     $4 = valeur Et là je me rend bien compte que j'ai loupé une subtilité :'( A noter qu'il faut que je vérifie qu'il y ai toujours au moins "2 espaces" entre la fin de la "1ere Valeur" et le début de la "2eme clee". Par contre je dois pouvoir utiliser un lettre "majuscule" (les CLEE sont presque exclusivement en majuscule) comme point de repère du début de la 2eme clée.... faut que je récupère d'avantage de "données brut" pour infirmer/confirmer. @+ Nicolas Le 09/02/2020 à 00:52, Stéphane Gigandet a écrit : > Hello Nicolas, > > Comme la sortie est toujours de la forme "clé : valeur" (avec 2 paires > clés / valeurs sur chaque ligne), le plus simple c'est peut être de > parser toutes les clés en un coup, sans découper chaque ligne dans un > tableau, avec un truc de ce genre là : > > #!/usr/bin/perl -w > > use strict; > > my $result = `cat result`; > > my %values = (); > > while ($result =~ /\s*([^:]+):\s+(.*?)(  |\n)/g) { >         $values{$1} = $2; > } > > foreach my $key (sort keys %values) { >         print "$key : $values{$key}\n"; > } > > Ca donne ça : > > ACTIVE PVs : 1 > AUTO ON : yes > AUTO SYNC : no > BB POLICY : relocatable > CRITICAL VG : no > DISK BLOCK SIZE : 512 > FREE PPs : 21 (2688 megabytes) > FS SYNC OPTION : no > HOT SPARE : no > INFINITE RETRY : no > LTG size (Dynamic) : 512 kilobyte(s) > LVs : 28 > MAX LVs : 256 > MAX PPs per PV : 1016 > MAX PPs per VG : 32512 > MAX PVs : 32 > OPEN LVs : 22 > PP SIZE : 128 megabyte(s) > PV RESTRICTION : none > QUORUM : 2 (Enabled) > STALE PPs : 0 > STALE PVs : 0 > TOTAL PPs : 799 (102272 megabytes) > TOTAL PVs : 1 > USED PPs : 778 (99584 megabytes) > VG DESCRIPTORS : 2 > VG IDENTIFIER : 00f702be00004c0000000159122168ad > VG PERMISSION : read/write > VG STATE : active > VOLUME GROUP : rootvg > > Bon dimanche, > > Stéphane > > Le 08/02/2020 à 21:56, Nicolas a écrit : >> Bonsoir, >> >> Après de (trop) nombreuses années à ne pas faire d'admin, je remets >> (laborieusement) les mains dans le cambouis... et donc dans perl ;o) >> >> Je n'ai jamais eu un niveau "gourou" en perl (même il y a 15ans) mais >> j'arrive encore à écrire du code qui me donne le résultat attendu.... >> alors ça me convient ;o) >> Mais du coup je vais peut-être avoir une question "bête" concernant >> le traitement de la sortie d'une commande. >> >> La commande fournit une sortie sur STDOUT que je stocke dans un >> tableau via : >> my @array=split(/\n/,`ma_super_commande_UNIX`) or die "error while >> processing command \"ma_super_commande_UNIX\""; >> >> Ensuite je fais une boucle pour parcourir le tableau et appliquer la >> bonne regexp afin de récupérer les parties "ah-hoc" de chaque ligne >> et les stocker dans un hash avec les bonnes clés. >> >> La boucle est de la forme : >> foreach my $scalar (@array) >> { >>   if ( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ) >>   { >>     $hash{$stanza}{'VGid'}=$1; >>   } >> } >> >> En répétant les "if" dans la boucle (un "if" par ligne à traiter avec >> la regexp associée) je peux matcher chaque ligne "qui va bien" par >> exécution de la commande et ainsi récupérer les 2 valeurs par ligne >> qui m'intéressent. >> >> A la place du "if" j'ai essayé une notation de la forme : >>     ($hash{$stanza}{'VGid'}, )=( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ); >> >> Mais ceci a pour seul résultat de bien matcher la bonne ligne dans la >> boucle, mais au "tour suivant" de la boucle (ligne suivante stockée >> dans @array) alors la valeur est "mise à zéro", ceci sans doute car >> du coup la regexp ne match pas ce qui est assez logique puisque ce >> n'est plus la bonne ligne. >> J'ai donc certainement loupé un truc quelque part..... >> Je peux bien entendu garder ma ribambelle de "if" à l'intérieur de la >> boucle mais..... je pense qu'il y a plus simple / plus perl et que je >> ne suis pas loin..... :( >> >> J'ai mis, un exemple de sortie de commande en fin de mail, je >> récupère les 1 ou 2 valeurs par ligne pour stocker la 30aine de >> valeurs dans un hash. >> >> Bonne soirée, >> Nicolas >> >> VOLUME GROUP:       rootvg                   VG IDENTIFIER: >> 00f702be00004c0000000159122168ad >> VG STATE:           active                   PP SIZE:        128 >> megabyte(s) >> VG PERMISSION:      read/write               TOTAL PPs:      799 >> (102272 megabytes) >> MAX LVs:            256                      FREE PPs:       21 (2688 >> megabytes) >> LVs:                28                       USED PPs:       778 >> (99584 megabytes) >> OPEN LVs:           22                       QUORUM:         2 (Enabled) >> TOTAL PVs:          1                        VG DESCRIPTORS: 2 >> STALE PVs:          0                        STALE PPs:      0 >> ACTIVE PVs:         1                        AUTO ON:        yes >> MAX PPs per VG:     32512 >> MAX PPs per PV:     1016                     MAX PVs:        32 >> LTG size (Dynamic): 512 kilobyte(s)          AUTO SYNC:      no >> HOT SPARE:          no                       BB POLICY: relocatable >> PV RESTRICTION:     none                     INFINITE RETRY: no >> DISK BLOCK SIZE:    512                      CRITICAL VG:    no >> FS SYNC OPTION:     no >> >> >> _______________________________________________ >> Perl mailing list >> Perl at mongueurs.net >> http://listes.mongueurs.net/mailman/listinfo/perl >> Attention, les archives sont publiques > > > _______________________________________________ > Perl mailing list > Perl at mongueurs.net > http://listes.mongueurs.net/mailman/listinfo/perl > Attention, les archives sont publiques -------------- section suivante -------------- Une pièce jointe HTML a été nettoyée... URL: From biz at joueb.com Sun Feb 9 12:46:17 2020 From: biz at joueb.com (=?UTF-8?Q?St=c3=a9phane_Gigandet?=) Date: Sun, 9 Feb 2020 12:46:17 +0100 Subject: [Perl] =?utf-8?q?Retour_=C3=A0_Perl_-_parser_une_sortie_de_comman?= =?utf-8?q?de_multiligne?= In-Reply-To: References: Message-ID: <9412fd06-bc7d-ebfc-d09e-c5fbc842e0f8@joueb.com> Bonjour Nicolas, Tu as tout analysé correctement. L'idée c'est de considérer ta sortie non pas comme une suite de lignes, mais comme une seule longue chaîne de caractères qui contient aussi des retours chariots \n. Dans cette chaîne, la fin d'une valeur est suivie soit par plusieurs espaces (quand c'est la 1ère paire clé/valeur et qu'il y en a une 2ème plus à droite), soit par un retour chariot (quand c'est la dernière paire clé/valeur de la ligne). C'est le but du (  |\n) : on arrête la valeur quand on a 2 espaces ou le retour chariot. J'ai mis des parenthèses autour de ( |\n), c'est pour que le | s'applique sur les 2 espaces ou le retour chariot. Ca va effectivement mettre ces 2 espaces ou le retour chariot dans $3, qu'on n'utilise pas. Ce n'est pas gênant. Le /g permet de matcher plusieurs fois par chaîne, pas par ligne, on ne considère plus chaque ligne individuellement. C'est une solution parmi plein d'autres possibles, c'est juste celle qui me paraissait la plus rapide à coder à minuit hier soir. :) Bonne journée, Stéphane Le 09/02/2020 à 02:41, Nicolas a écrit : > Bonsoir Stéphane, > > Merci pour ta proposition ! > C'est effectivement sans doute la bonne approche au global, modulo que > certaines lignes n'ont parfois qu'une seule "clée/valeur" suivant la > config rencontrée (donc non prévisible). > Il semble que ta regexp "gère ça" mais je n'ai pas encore compris > comment :/ > > Par contre j'aimerai quelques explications (ou une confirmation) sur > ta regexp stp (j'aime bien comprendre ^_^ ). > /\s*([^:]+):\s+(.*?)(  |\n)/g > /          0) Début de la regexp > \s*        1) Match 0 ou + "espace" > (          2) On commence la sélection => ce sera $1 > [^:]+      3) On prend > ):         4) On termine la sélection juste avant le premier ":" >                 A ce stade on a "enlevé tous les espaces de début de > ligne (1) et ensuite commencé la sélection (2) juste avant de prendre > et on termine la sélection juste avant le > premier ":" rencontré (4), car ":" c'est le séparateur de fin de clée. > \s+        5) Match 0 ou + "espace" > (          6) On commence la sélection => ce sera $2 > .*?        7) On prend n'importe quel caractère en mode "non gourmand" > )          8) On termine la sélection >                 A partir d'ici j'ai plus de mal à comprendre car je > pense que ça doit débuter la sélection de $3, alors qu'on ne l'utilise > pas après. > (          9) On commence la sélection => ce sera $3 >   |\n     10) On prend "2x espace" ou "fin de ligne" > )         11) On termine la sélection > /g        12) Fin de la regex avec utilisation du flag "g" qui va > matcher répétitivement. > > Je pense avoir correctement analysé le contenu mais pas le "but" de la > regexp "dans son ensemble", en particulier les parties (9) et suivantes. > Je pense que le (10) sert à identifier une "fin de paire cle/valeur" > avec les 2 espaces consécutifs ou la fin de ligne. > Le flag "g" va permettre de matcher "plusieurs fois" par ligne et donc > les 2 couples "clé/valeur" par ligne, mais du coup comment perl > "fait-il le job" en utilisant uniquement $1 et $2 dans le while et que > devient $3 ? > > En effet, pour une ligne avec 1x "clé/valeur", on va bien avoir : >     $1 = clé >     $2 = valeur > Mais pour une ligne avec 2x "clé/valeur", je m'attendrai à avoir : >     $1 = clé >     $2 = valeur >     $3 = clé >     $4 = valeur > > Et là je me rend bien compte que j'ai loupé une subtilité :'( > > A noter qu'il faut que je vérifie qu'il y ai toujours au moins "2 > espaces" entre la fin de la "1ere Valeur" et le début de la "2eme clee". > Par contre je dois pouvoir utiliser un lettre "majuscule" (les CLEE > sont presque exclusivement en majuscule) comme point de repère du > début de la 2eme clée.... faut que je récupère d'avantage de "données > brut" pour infirmer/confirmer. > > @+ > Nicolas > > > Le 09/02/2020 à 00:52, Stéphane Gigandet a écrit : >> Hello Nicolas, >> >> Comme la sortie est toujours de la forme "clé : valeur" (avec 2 >> paires clés / valeurs sur chaque ligne), le plus simple c'est peut >> être de parser toutes les clés en un coup, sans découper chaque ligne >> dans un tableau, avec un truc de ce genre là : >> >> #!/usr/bin/perl -w >> >> use strict; >> >> my $result = `cat result`; >> >> my %values = (); >> >> while ($result =~ /\s*([^:]+):\s+(.*?)(  |\n)/g) { >>         $values{$1} = $2; >> } >> >> foreach my $key (sort keys %values) { >>         print "$key : $values{$key}\n"; >> } >> >> Ca donne ça : >> >> ACTIVE PVs : 1 >> AUTO ON : yes >> AUTO SYNC : no >> BB POLICY : relocatable >> CRITICAL VG : no >> DISK BLOCK SIZE : 512 >> FREE PPs : 21 (2688 megabytes) >> FS SYNC OPTION : no >> HOT SPARE : no >> INFINITE RETRY : no >> LTG size (Dynamic) : 512 kilobyte(s) >> LVs : 28 >> MAX LVs : 256 >> MAX PPs per PV : 1016 >> MAX PPs per VG : 32512 >> MAX PVs : 32 >> OPEN LVs : 22 >> PP SIZE : 128 megabyte(s) >> PV RESTRICTION : none >> QUORUM : 2 (Enabled) >> STALE PPs : 0 >> STALE PVs : 0 >> TOTAL PPs : 799 (102272 megabytes) >> TOTAL PVs : 1 >> USED PPs : 778 (99584 megabytes) >> VG DESCRIPTORS : 2 >> VG IDENTIFIER : 00f702be00004c0000000159122168ad >> VG PERMISSION : read/write >> VG STATE : active >> VOLUME GROUP : rootvg >> >> Bon dimanche, >> >> Stéphane >> >> Le 08/02/2020 à 21:56, Nicolas a écrit : >>> Bonsoir, >>> >>> Après de (trop) nombreuses années à ne pas faire d'admin, je remets >>> (laborieusement) les mains dans le cambouis... et donc dans perl ;o) >>> >>> Je n'ai jamais eu un niveau "gourou" en perl (même il y a 15ans) >>> mais j'arrive encore à écrire du code qui me donne le résultat >>> attendu.... alors ça me convient ;o) >>> Mais du coup je vais peut-être avoir une question "bête" concernant >>> le traitement de la sortie d'une commande. >>> >>> La commande fournit une sortie sur STDOUT que je stocke dans un >>> tableau via : >>> my @array=split(/\n/,`ma_super_commande_UNIX`) or die "error while >>> processing command \"ma_super_commande_UNIX\""; >>> >>> Ensuite je fais une boucle pour parcourir le tableau et appliquer la >>> bonne regexp afin de récupérer les parties "ah-hoc" de chaque ligne >>> et les stocker dans un hash avec les bonnes clés. >>> >>> La boucle est de la forme : >>> foreach my $scalar (@array) >>> { >>>   if ( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ) >>>   { >>>     $hash{$stanza}{'VGid'}=$1; >>>   } >>> } >>> >>> En répétant les "if" dans la boucle (un "if" par ligne à traiter >>> avec la regexp associée) je peux matcher chaque ligne "qui va bien" >>> par exécution de la commande et ainsi récupérer les 2 valeurs par >>> ligne qui m'intéressent. >>> >>> A la place du "if" j'ai essayé une notation de la forme : >>>     ($hash{$stanza}{'VGid'}, )=( $scalar =~ m/VG >>> IDENTIFIER:\s+(\S+)/ ); >>> >>> Mais ceci a pour seul résultat de bien matcher la bonne ligne dans >>> la boucle, mais au "tour suivant" de la boucle (ligne suivante >>> stockée dans @array) alors la valeur est "mise à zéro", ceci sans >>> doute car du coup la regexp ne match pas ce qui est assez logique >>> puisque ce n'est plus la bonne ligne. >>> J'ai donc certainement loupé un truc quelque part..... >>> Je peux bien entendu garder ma ribambelle de "if" à l'intérieur de >>> la boucle mais..... je pense qu'il y a plus simple / plus perl et >>> que je ne suis pas loin..... :( >>> >>> J'ai mis, un exemple de sortie de commande en fin de mail, je >>> récupère les 1 ou 2 valeurs par ligne pour stocker la 30aine de >>> valeurs dans un hash. >>> >>> Bonne soirée, >>> Nicolas >>> >>> VOLUME GROUP:       rootvg                   VG IDENTIFIER: >>> 00f702be00004c0000000159122168ad >>> VG STATE:           active                   PP SIZE: 128 megabyte(s) >>> VG PERMISSION:      read/write               TOTAL PPs: 799 (102272 >>> megabytes) >>> MAX LVs:            256                      FREE PPs: 21 (2688 >>> megabytes) >>> LVs:                28                       USED PPs: 778 (99584 >>> megabytes) >>> OPEN LVs:           22                       QUORUM:         2 >>> (Enabled) >>> TOTAL PVs:          1                        VG DESCRIPTORS: 2 >>> STALE PVs:          0                        STALE PPs:      0 >>> ACTIVE PVs:         1                        AUTO ON: yes >>> MAX PPs per VG:     32512 >>> MAX PPs per PV:     1016                     MAX PVs: 32 >>> LTG size (Dynamic): 512 kilobyte(s)          AUTO SYNC: no >>> HOT SPARE:          no                       BB POLICY: relocatable >>> PV RESTRICTION:     none                     INFINITE RETRY: no >>> DISK BLOCK SIZE:    512                      CRITICAL VG: no >>> FS SYNC OPTION:     no >>> >>> >>> _______________________________________________ >>> Perl mailing list >>> Perl at mongueurs.net >>> http://listes.mongueurs.net/mailman/listinfo/perl >>> Attention, les archives sont publiques >> >> >> _______________________________________________ >> Perl mailing list >> Perl at mongueurs.net >> http://listes.mongueurs.net/mailman/listinfo/perl >> Attention, les archives sont publiques > > > _______________________________________________ > Perl mailing list > Perl at mongueurs.net > http://listes.mongueurs.net/mailman/listinfo/perl > Attention, les archives sont publiques -------------- section suivante -------------- Une pièce jointe HTML a été nettoyée... URL: From perl at escwq.fr Wed Feb 12 08:38:33 2020 From: perl at escwq.fr (Nicolas) Date: Wed, 12 Feb 2020 08:38:33 +0100 Subject: [Perl] =?utf-8?q?Retour_=C3=A0_Perl_-_parser_une_sortie_de_comman?= =?utf-8?q?de_multiligne?= In-Reply-To: <9412fd06-bc7d-ebfc-d09e-c5fbc842e0f8@joueb.com> References: <9412fd06-bc7d-ebfc-d09e-c5fbc842e0f8@joueb.com> Message-ID: <11bd9c9c-1467-cd55-e2f2-4e00e215adc5@escwq.fr> Bonjour Stéphane, Oui il y a toujours plus d'une façon de faire en Perl ;) Donc en fait la "clé" qui me manquait était l'analyse de la sortie "multiligne" de la commande en "une seule chaine" (et non comme "plusieurs lignes successives"). La regexp est donc construite pour matcher "autant de fois que possible" les "clé/valeur" tout au long de la chaine et non "une ou 2 fois par ligne", c'est ce qui me "manquait". Merci pour ce petit coup de pouce un samedi à minuit ;) Bonne journée, Nicolas Le 09/02/2020 à 12:46, Stéphane Gigandet a écrit : > Bonjour Nicolas, > > Tu as tout analysé correctement. L'idée c'est de considérer ta sortie > non pas comme une suite de lignes, mais comme une seule longue chaîne > de caractères qui contient aussi des retours chariots \n. > > Dans cette chaîne, la fin d'une valeur est suivie soit par plusieurs > espaces (quand c'est la 1ère paire clé/valeur et qu'il y en a une 2ème > plus à droite), soit par un retour chariot (quand c'est la dernière > paire clé/valeur de la ligne). > > C'est le but du (  |\n) : on arrête la valeur quand on a 2 espaces ou > le retour chariot. > > J'ai mis des parenthèses autour de ( |\n), c'est pour que le | > s'applique sur les 2 espaces ou le retour chariot. Ca va effectivement > mettre ces 2 espaces ou le retour chariot dans $3, qu'on n'utilise > pas. Ce n'est pas gênant. > > Le /g permet de matcher plusieurs fois par chaîne, pas par ligne, on > ne considère plus chaque ligne individuellement. > > C'est une solution parmi plein d'autres possibles, c'est juste celle > qui me paraissait la plus rapide à coder à minuit hier soir. :) > > Bonne journée, > > Stéphane > > Le 09/02/2020 à 02:41, Nicolas a écrit : >> Bonsoir Stéphane, >> >> Merci pour ta proposition ! >> C'est effectivement sans doute la bonne approche au global, modulo >> que certaines lignes n'ont parfois qu'une seule "clée/valeur" suivant >> la config rencontrée (donc non prévisible). >> Il semble que ta regexp "gère ça" mais je n'ai pas encore compris >> comment :/ >> >> Par contre j'aimerai quelques explications (ou une confirmation) sur >> ta regexp stp (j'aime bien comprendre ^_^ ). >> /\s*([^:]+):\s+(.*?)(  |\n)/g >> /          0) Début de la regexp >> \s*        1) Match 0 ou + "espace" >> (          2) On commence la sélection => ce sera $1 >> [^:]+      3) On prend >> ):         4) On termine la sélection juste avant le premier ":" >>                 A ce stade on a "enlevé tous les espaces de début de >> ligne (1) et ensuite commencé la sélection (2) juste avant de prendre >> et on termine la sélection juste avant le >> premier ":" rencontré (4), car ":" c'est le séparateur de fin de clée. >> \s+        5) Match 0 ou + "espace" >> (          6) On commence la sélection => ce sera $2 >> .*?        7) On prend n'importe quel caractère en mode "non gourmand" >> )          8) On termine la sélection >>                 A partir d'ici j'ai plus de mal à comprendre car je >> pense que ça doit débuter la sélection de $3, alors qu'on ne >> l'utilise pas après. >> (          9) On commence la sélection => ce sera $3 >>   |\n     10) On prend "2x espace" ou "fin de ligne" >> )         11) On termine la sélection >> /g        12) Fin de la regex avec utilisation du flag "g" qui va >> matcher répétitivement. >> >> Je pense avoir correctement analysé le contenu mais pas le "but" de >> la regexp "dans son ensemble", en particulier les parties (9) et >> suivantes. >> Je pense que le (10) sert à identifier une "fin de paire cle/valeur" >> avec les 2 espaces consécutifs ou la fin de ligne. >> Le flag "g" va permettre de matcher "plusieurs fois" par ligne et >> donc les 2 couples "clé/valeur" par ligne, mais du coup comment perl >> "fait-il le job" en utilisant uniquement $1 et $2 dans le while et >> que devient $3 ? >> >> En effet, pour une ligne avec 1x "clé/valeur", on va bien avoir : >>     $1 = clé >>     $2 = valeur >> Mais pour une ligne avec 2x "clé/valeur", je m'attendrai à avoir : >>     $1 = clé >>     $2 = valeur >>     $3 = clé >>     $4 = valeur >> >> Et là je me rend bien compte que j'ai loupé une subtilité :'( >> >> A noter qu'il faut que je vérifie qu'il y ai toujours au moins "2 >> espaces" entre la fin de la "1ere Valeur" et le début de la "2eme clee". >> Par contre je dois pouvoir utiliser un lettre "majuscule" (les CLEE >> sont presque exclusivement en majuscule) comme point de repère du >> début de la 2eme clée.... faut que je récupère d'avantage de "données >> brut" pour infirmer/confirmer. >> >> @+ >> Nicolas >> >> >> Le 09/02/2020 à 00:52, Stéphane Gigandet a écrit : >>> Hello Nicolas, >>> >>> Comme la sortie est toujours de la forme "clé : valeur" (avec 2 >>> paires clés / valeurs sur chaque ligne), le plus simple c'est peut >>> être de parser toutes les clés en un coup, sans découper chaque >>> ligne dans un tableau, avec un truc de ce genre là : >>> >>> #!/usr/bin/perl -w >>> >>> use strict; >>> >>> my $result = `cat result`; >>> >>> my %values = (); >>> >>> while ($result =~ /\s*([^:]+):\s+(.*?)(  |\n)/g) { >>>         $values{$1} = $2; >>> } >>> >>> foreach my $key (sort keys %values) { >>>         print "$key : $values{$key}\n"; >>> } >>> >>> Ca donne ça : >>> >>> ACTIVE PVs : 1 >>> AUTO ON : yes >>> AUTO SYNC : no >>> BB POLICY : relocatable >>> CRITICAL VG : no >>> DISK BLOCK SIZE : 512 >>> FREE PPs : 21 (2688 megabytes) >>> FS SYNC OPTION : no >>> HOT SPARE : no >>> INFINITE RETRY : no >>> LTG size (Dynamic) : 512 kilobyte(s) >>> LVs : 28 >>> MAX LVs : 256 >>> MAX PPs per PV : 1016 >>> MAX PPs per VG : 32512 >>> MAX PVs : 32 >>> OPEN LVs : 22 >>> PP SIZE : 128 megabyte(s) >>> PV RESTRICTION : none >>> QUORUM : 2 (Enabled) >>> STALE PPs : 0 >>> STALE PVs : 0 >>> TOTAL PPs : 799 (102272 megabytes) >>> TOTAL PVs : 1 >>> USED PPs : 778 (99584 megabytes) >>> VG DESCRIPTORS : 2 >>> VG IDENTIFIER : 00f702be00004c0000000159122168ad >>> VG PERMISSION : read/write >>> VG STATE : active >>> VOLUME GROUP : rootvg >>> >>> Bon dimanche, >>> >>> Stéphane >>> >>> Le 08/02/2020 à 21:56, Nicolas a écrit : >>>> Bonsoir, >>>> >>>> Après de (trop) nombreuses années à ne pas faire d'admin, je remets >>>> (laborieusement) les mains dans le cambouis... et donc dans perl ;o) >>>> >>>> Je n'ai jamais eu un niveau "gourou" en perl (même il y a 15ans) >>>> mais j'arrive encore à écrire du code qui me donne le résultat >>>> attendu.... alors ça me convient ;o) >>>> Mais du coup je vais peut-être avoir une question "bête" concernant >>>> le traitement de la sortie d'une commande. >>>> >>>> La commande fournit une sortie sur STDOUT que je stocke dans un >>>> tableau via : >>>> my @array=split(/\n/,`ma_super_commande_UNIX`) or die "error while >>>> processing command \"ma_super_commande_UNIX\""; >>>> >>>> Ensuite je fais une boucle pour parcourir le tableau et appliquer >>>> la bonne regexp afin de récupérer les parties "ah-hoc" de chaque >>>> ligne et les stocker dans un hash avec les bonnes clés. >>>> >>>> La boucle est de la forme : >>>> foreach my $scalar (@array) >>>> { >>>>   if ( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ) >>>>   { >>>>     $hash{$stanza}{'VGid'}=$1; >>>>   } >>>> } >>>> >>>> En répétant les "if" dans la boucle (un "if" par ligne à traiter >>>> avec la regexp associée) je peux matcher chaque ligne "qui va bien" >>>> par exécution de la commande et ainsi récupérer les 2 valeurs par >>>> ligne qui m'intéressent. >>>> >>>> A la place du "if" j'ai essayé une notation de la forme : >>>>     ($hash{$stanza}{'VGid'}, )=( $scalar =~ m/VG >>>> IDENTIFIER:\s+(\S+)/ ); >>>> >>>> Mais ceci a pour seul résultat de bien matcher la bonne ligne dans >>>> la boucle, mais au "tour suivant" de la boucle (ligne suivante >>>> stockée dans @array) alors la valeur est "mise à zéro", ceci sans >>>> doute car du coup la regexp ne match pas ce qui est assez logique >>>> puisque ce n'est plus la bonne ligne. >>>> J'ai donc certainement loupé un truc quelque part..... >>>> Je peux bien entendu garder ma ribambelle de "if" à l'intérieur de >>>> la boucle mais..... je pense qu'il y a plus simple / plus perl et >>>> que je ne suis pas loin..... :( >>>> >>>> J'ai mis, un exemple de sortie de commande en fin de mail, je >>>> récupère les 1 ou 2 valeurs par ligne pour stocker la 30aine de >>>> valeurs dans un hash. >>>> >>>> Bonne soirée, >>>> Nicolas >>>> >>>> VOLUME GROUP:       rootvg                   VG IDENTIFIER: >>>> 00f702be00004c0000000159122168ad >>>> VG STATE:           active                   PP SIZE: 128 megabyte(s) >>>> VG PERMISSION:      read/write               TOTAL PPs: 799 (102272 >>>> megabytes) >>>> MAX LVs:            256                      FREE PPs: 21 (2688 >>>> megabytes) >>>> LVs:                28                       USED PPs: 778 (99584 >>>> megabytes) >>>> OPEN LVs:           22                       QUORUM: 2 (Enabled) >>>> TOTAL PVs:          1                        VG DESCRIPTORS: 2 >>>> STALE PVs:          0                        STALE PPs: 0 >>>> ACTIVE PVs:         1                        AUTO ON: yes >>>> MAX PPs per VG:     32512 >>>> MAX PPs per PV:     1016                     MAX PVs: 32 >>>> LTG size (Dynamic): 512 kilobyte(s)          AUTO SYNC: no >>>> HOT SPARE:          no                       BB POLICY: relocatable >>>> PV RESTRICTION:     none                     INFINITE RETRY: no >>>> DISK BLOCK SIZE:    512                      CRITICAL VG: no >>>> FS SYNC OPTION:     no >>>> >>>> >>>> _______________________________________________ >>>> Perl mailing list >>>> Perl at mongueurs.net >>>> http://listes.mongueurs.net/mailman/listinfo/perl >>>> Attention, les archives sont publiques >>> >>> >>> _______________________________________________ >>> Perl mailing list >>> Perl at mongueurs.net >>> http://listes.mongueurs.net/mailman/listinfo/perl >>> Attention, les archives sont publiques >> >> >> _______________________________________________ >> Perl mailing list >> Perl at mongueurs.net >> http://listes.mongueurs.net/mailman/listinfo/perl >> Attention, les archives sont publiques > > > > _______________________________________________ > Perl mailing list > Perl at mongueurs.net > http://listes.mongueurs.net/mailman/listinfo/perl > Attention, les archives sont publiques -------------- section suivante -------------- Une pièce jointe HTML a été nettoyée... URL: From dkrotkine at gmail.com Fri Feb 14 15:38:47 2020 From: dkrotkine at gmail.com (Damien Krotkine) Date: Fri, 14 Feb 2020 15:38:47 +0100 Subject: [Perl] =?utf-8?q?Retour_=C3=A0_Perl_-_parser_une_sortie_de_comman?= =?utf-8?q?de_multiligne?= In-Reply-To: <11bd9c9c-1467-cd55-e2f2-4e00e215adc5@escwq.fr> References: <9412fd06-bc7d-ebfc-d09e-c5fbc842e0f8@joueb.com> <11bd9c9c-1467-cd55-e2f2-4e00e215adc5@escwq.fr> Message-ID: <7fca8861-0273-43b4-be00-186915ee3979@www.fastmail.com> Hello, une autre approche permet de le faire en une ligne: my $result = `cat result`; my %values = grep length, split(/: +| +|\n/, $result); A lire de droite à gauche: on applique split(/: +| +|\n/) sur result. Cela va couper la longue chaine sur - "deux-points suivis d'autant d'espace qu'on veut": pour séparer la clef à gauche du deux-points de la valeur qui est à droite - "deux ou plus espaces": pour séparer entre deux "clefs-valeur" sur une même ligne - "\n": pour séparer par ligne. On applique un grep pour virer les lignes vides si jamais il y en a. Au final on a une liste de clef valeur qu'il suffit de stocker dans un hash. Le résultat: 'VG DESCRIPTORS' => '2', 'FS SYNC OPTION' => 'no', 'MAX LVs' => '256', 'FREE PPs' => '21 (2688 megabytes)', 'MAX PPs per VG' => '32512', 'LTG size (Dynamic)' => '512 kilobyte(s)', 'BB POLICY' => 'relocatable', 'PV RESTRICTION' => 'none', 'OPEN LVs' => '22', 'VG PERMISSION' => 'read/write', 'TOTAL PVs' => '1', 'AUTO ON' => 'yes', 'LVs' => '28', 'VG IDENTIFIER' => '00f702be00004c0000000159122168ad', 'ACTIVE PVs' => '1', 'DISK BLOCK SIZE' => '512', 'STALE PPs' => '0', 'QUORUM' => '2 (Enabled)', 'USED PPs' => '778 (99584 megabytes)', 'MAX PVs' => '32', 'VOLUME GROUP' => 'rootvg', 'PP SIZE' => '128 megabyte(s)', 'MAX PPs per PV' => '1016', 'VG STATE' => 'active', 'TOTAL PPs' => '799 (102272 megabytes)', 'CRITICAL VG' => 'no', 'AUTO SYNC' => 'no', 'HOT SPARE' => 'no', 'INFINITE RETRY' => 'no', 'STALE PVs' => '0' On Wed, Feb 12, 2020, at 08:38, Nicolas wrote: > Bonjour Stéphane, > > Oui il y a toujours plus d'une façon de faire en Perl ;) > > Donc en fait la "clé" qui me manquait était l'analyse de la sortie "multiligne" de la commande en "une seule chaine" (et non comme "plusieurs lignes successives"). > La regexp est donc construite pour matcher "autant de fois que possible" les "clé/valeur" tout au long de la chaine et non "une ou 2 fois par ligne", c'est ce qui me "manquait". > > Merci pour ce petit coup de pouce un samedi à minuit ;) > > Bonne journée, > Nicolas > > > Le 09/02/2020 à 12:46, Stéphane Gigandet a écrit : >> Bonjour Nicolas, >> >> Tu as tout analysé correctement. L'idée c'est de considérer ta sortie non pas comme une suite de lignes, mais comme une seule longue chaîne de caractères qui contient aussi des retours chariots \n. >> >> Dans cette chaîne, la fin d'une valeur est suivie soit par plusieurs espaces (quand c'est la 1ère paire clé/valeur et qu'il y en a une 2ème plus à droite), soit par un retour chariot (quand c'est la dernière paire clé/valeur de la ligne). >> >> C'est le but du ( |\n) : on arrête la valeur quand on a 2 espaces ou le retour chariot. >> >> J'ai mis des parenthèses autour de ( |\n), c'est pour que le | s'applique sur les 2 espaces ou le retour chariot. Ca va effectivement mettre ces 2 espaces ou le retour chariot dans $3, qu'on n'utilise pas. Ce n'est pas gênant. >> >> Le /g permet de matcher plusieurs fois par chaîne, pas par ligne, on ne considère plus chaque ligne individuellement. >> >> C'est une solution parmi plein d'autres possibles, c'est juste celle qui me paraissait la plus rapide à coder à minuit hier soir. :) >> >> Bonne journée, >> >> Stéphane >> >> Le 09/02/2020 à 02:41, Nicolas a écrit : >>> Bonsoir Stéphane, >>> >>> Merci pour ta proposition ! >>> C'est effectivement sans doute la bonne approche au global, modulo que certaines lignes n'ont parfois qu'une seule "clée/valeur" suivant la config rencontrée (donc non prévisible). >>> Il semble que ta regexp "gère ça" mais je n'ai pas encore compris comment :/ >>> >>> Par contre j'aimerai quelques explications (ou une confirmation) sur ta regexp stp (j'aime bien comprendre ^_^ ). >>> /\s*([^:]+):\s+(.*?)( |\n)/g >>> / 0) Début de la regexp >>> \s* 1) Match 0 ou + "espace" >>> ( 2) On commence la sélection => ce sera $1 >>> [^:]+ 3) On prend >>> ): 4) On termine la sélection juste avant le premier ":" >>> A ce stade on a "enlevé tous les espaces de début de ligne (1) et ensuite commencé la sélection (2) juste avant de prendre et on termine la sélection juste avant le premier ":" rencontré (4), car ":" c'est le séparateur de fin de clée. >>> \s+ 5) Match 0 ou + "espace" >>> ( 6) On commence la sélection => ce sera $2 >>> .*? 7) On prend n'importe quel caractère en mode "non gourmand" >>> ) 8) On termine la sélection >>> A partir d'ici j'ai plus de mal à comprendre car je pense que ça doit débuter la sélection de $3, alors qu'on ne l'utilise pas après. >>> ( 9) On commence la sélection => ce sera $3 >>> |\n 10) On prend "2x espace" ou "fin de ligne" >>> ) 11) On termine la sélection >>> /g 12) Fin de la regex avec utilisation du flag "g" qui va matcher répétitivement. >>> Je pense avoir correctement analysé le contenu mais pas le "but" de la regexp "dans son ensemble", en particulier les parties (9) et suivantes. >>> Je pense que le (10) sert à identifier une "fin de paire cle/valeur" avec les 2 espaces consécutifs ou la fin de ligne. >>> Le flag "g" va permettre de matcher "plusieurs fois" par ligne et donc les 2 couples "clé/valeur" par ligne, mais du coup comment perl "fait-il le job" en utilisant uniquement $1 et $2 dans le while et que devient $3 ? >>> >>> En effet, pour une ligne avec 1x "clé/valeur", on va bien avoir : >>> $1 = clé >>> $2 = valeur >>> Mais pour une ligne avec 2x "clé/valeur", je m'attendrai à avoir : >>> $1 = clé >>> $2 = valeur >>> $3 = clé >>> $4 = valeur >>> >>> Et là je me rend bien compte que j'ai loupé une subtilité :'( >>> >>> A noter qu'il faut que je vérifie qu'il y ai toujours au moins "2 espaces" entre la fin de la "1ere Valeur" et le début de la "2eme clee". >>> Par contre je dois pouvoir utiliser un lettre "majuscule" (les CLEE sont presque exclusivement en majuscule) comme point de repère du début de la 2eme clée.... faut que je récupère d'avantage de "données brut" pour infirmer/confirmer. >>> >>> @+ >>> Nicolas >>> >>> >>> >>> Le 09/02/2020 à 00:52, Stéphane Gigandet a écrit : >>>> Hello Nicolas, >>>> >>>> Comme la sortie est toujours de la forme "clé : valeur" (avec 2 paires clés / valeurs sur chaque ligne), le plus simple c'est peut être de parser toutes les clés en un coup, sans découper chaque ligne dans un tableau, avec un truc de ce genre là : >>>> >>>> #!/usr/bin/perl -w >>>> >>>> use strict; >>>> >>>> my $result = `cat result`; >>>> >>>> my %values = (); >>>> >>>> while ($result =~ /\s*([^:]+):\s+(.*?)( |\n)/g) { >>>> $values{$1} = $2; >>>> } >>>> >>>> foreach my $key (sort keys %values) { >>>> print "$key : $values{$key}\n"; >>>> } >>>> >>>> Ca donne ça : >>>> >>>> ACTIVE PVs : 1 >>>> AUTO ON : yes >>>> AUTO SYNC : no >>>> BB POLICY : relocatable >>>> CRITICAL VG : no >>>> DISK BLOCK SIZE : 512 >>>> FREE PPs : 21 (2688 megabytes) >>>> FS SYNC OPTION : no >>>> HOT SPARE : no >>>> INFINITE RETRY : no >>>> LTG size (Dynamic) : 512 kilobyte(s) >>>> LVs : 28 >>>> MAX LVs : 256 >>>> MAX PPs per PV : 1016 >>>> MAX PPs per VG : 32512 >>>> MAX PVs : 32 >>>> OPEN LVs : 22 >>>> PP SIZE : 128 megabyte(s) >>>> PV RESTRICTION : none >>>> QUORUM : 2 (Enabled) >>>> STALE PPs : 0 >>>> STALE PVs : 0 >>>> TOTAL PPs : 799 (102272 megabytes) >>>> TOTAL PVs : 1 >>>> USED PPs : 778 (99584 megabytes) >>>> VG DESCRIPTORS : 2 >>>> VG IDENTIFIER : 00f702be00004c0000000159122168ad >>>> VG PERMISSION : read/write >>>> VG STATE : active >>>> VOLUME GROUP : rootvg >>>> >>>> Bon dimanche, >>>> >>>> Stéphane >>>> >>>> Le 08/02/2020 à 21:56, Nicolas a écrit : >>>> >>>>> Bonsoir, >>>>> >>>>> Après de (trop) nombreuses années à ne pas faire d'admin, je remets (laborieusement) les mains dans le cambouis... et donc dans perl ;o) >>>>> >>>>> Je n'ai jamais eu un niveau "gourou" en perl (même il y a 15ans) mais j'arrive encore à écrire du code qui me donne le résultat attendu.... alors ça me convient ;o) >>>>> Mais du coup je vais peut-être avoir une question "bête" concernant le traitement de la sortie d'une commande. >>>>> >>>>> La commande fournit une sortie sur STDOUT que je stocke dans un tableau via : >>>>> my @array=split(/\n/,`ma_super_commande_UNIX`) or die "error while processing command \"ma_super_commande_UNIX\""; >>>>> >>>>> Ensuite je fais une boucle pour parcourir le tableau et appliquer la bonne regexp afin de récupérer les parties "ah-hoc" de chaque ligne et les stocker dans un hash avec les bonnes clés. >>>>> >>>>> La boucle est de la forme : >>>>> foreach my $scalar (@array) >>>>> { >>>>> if ( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ) >>>>> { >>>>> $hash{$stanza}{'VGid'}=$1; >>>>> } >>>>> } >>>>> >>>>> En répétant les "if" dans la boucle (un "if" par ligne à traiter avec la regexp associée) je peux matcher chaque ligne "qui va bien" par exécution de la commande et ainsi récupérer les 2 valeurs par ligne qui m'intéressent. >>>>> >>>>> A la place du "if" j'ai essayé une notation de la forme : >>>>> ($hash{$stanza}{'VGid'}, )=( $scalar =~ m/VG IDENTIFIER:\s+(\S+)/ ); >>>>> >>>>> Mais ceci a pour seul résultat de bien matcher la bonne ligne dans la boucle, mais au "tour suivant" de la boucle (ligne suivante stockée dans @array) alors la valeur est "mise à zéro", ceci sans doute car du coup la regexp ne match pas ce qui est assez logique puisque ce n'est plus la bonne ligne. >>>>> J'ai donc certainement loupé un truc quelque part..... >>>>> Je peux bien entendu garder ma ribambelle de "if" à l'intérieur de la boucle mais..... je pense qu'il y a plus simple / plus perl et que je ne suis pas loin..... :( >>>>> >>>>> J'ai mis, un exemple de sortie de commande en fin de mail, je récupère les 1 ou 2 valeurs par ligne pour stocker la 30aine de valeurs dans un hash. >>>>> >>>>> Bonne soirée, >>>>> Nicolas >>>>> >>>>> VOLUME GROUP: rootvg VG IDENTIFIER: 00f702be00004c0000000159122168ad >>>>> VG STATE: active PP SIZE: 128 megabyte(s) >>>>> VG PERMISSION: read/write TOTAL PPs: 799 (102272 megabytes) >>>>> MAX LVs: 256 FREE PPs: 21 (2688 megabytes) >>>>> LVs: 28 USED PPs: 778 (99584 megabytes) >>>>> OPEN LVs: 22 QUORUM: 2 (Enabled) >>>>> TOTAL PVs: 1 VG DESCRIPTORS: 2 >>>>> STALE PVs: 0 STALE PPs: 0 >>>>> ACTIVE PVs: 1 AUTO ON: yes >>>>> MAX PPs per VG: 32512 >>>>> MAX PPs per PV: 1016 MAX PVs: 32 >>>>> LTG size (Dynamic): 512 kilobyte(s) AUTO SYNC: no >>>>> HOT SPARE: no BB POLICY: relocatable >>>>> PV RESTRICTION: none INFINITE RETRY: no >>>>> DISK BLOCK SIZE: 512 CRITICAL VG: no >>>>> FS SYNC OPTION: no >>>>> >>>>> >>>>> _______________________________________________ >>>>> Perl mailing list >>>>> Perl at mongueurs.net >>>>> http://listes.mongueurs.net/mailman/listinfo/perl >>>>> Attention, les archives sont publiques >>>> >>>> >>>> _______________________________________________ >>>> Perl mailing list >>>> Perl at mongueurs.net >>>> http://listes.mongueurs.net/mailman/listinfo/perl >>>> Attention, les archives sont publiques >>> >>> >>> _______________________________________________ Perl mailing list >>> Perl at mongueurs.net >>> http://listes.mongueurs.net/mailman/listinfo/perl Attention, les archives sont publiques >> >> >> _______________________________________________ Perl mailing list >> Perl at mongueurs.net >> http://listes.mongueurs.net/mailman/listinfo/perl Attention, les archives sont publiques > > _______________________________________________ > Perl mailing list > Perl at mongueurs.net > http://listes.mongueurs.net/mailman/listinfo/perl > Attention, les archives sont publiques -------------- section suivante -------------- Une pièce jointe HTML a été nettoyée... URL: From pdupre at gmx.com Wed Feb 26 10:14:59 2020 From: pdupre at gmx.com (Patrick Dupre) Date: Wed, 26 Feb 2020 10:14:59 +0100 Subject: [Perl] Interaction avec Tk Message-ID: Bonjour, J'utilise perl:Tk pour mon interface graphique. Dans une routine je fais une mise a jour de l'interface: $val_cutoff -> configure (-foreground => 'red') ; $val_cutoff -> insert (0, $cutoff) ; Puis, je lance un calcul. Cette routine a ete lancee par l'interface. La mise a jour ne se fait qu'a la fin du calul. Serait-ce possible de faire une mise a jour immediate? Merci. =========================================================================== Patrick DUPRÉ | | email: pdupre at gmx.com Laboratoire interdisciplinaire Carnot de Bourgogne 9 Avenue Alain Savary, BP 47870, 21078 DIJON Cedex FRANCE Tel: +33 (0)380395988 =========================================================================== From xlat at cpan.org Wed Feb 26 10:28:58 2020 From: xlat at cpan.org (Nicolas GEORGES) Date: Wed, 26 Feb 2020 10:28:58 +0100 Subject: [Perl] Interaction avec Tk In-Reply-To: References: Message-ID: Bonjour, Ca ressemble à un soucis avec l'eventloop, as-tu ajouté : $val_cutoff -> update(); pour forcer la prise en compte de tout les messages ? print pack'b*',join'',map{$_.($_+0?'010':'100')}unpack('b*',pack'w*',7376,16,193516616,0,1508,0,11289860)=~/...../g Le mer. 26 févr. 2020 à 10:15, Patrick Dupre a écrit : > Bonjour, > > J'utilise perl:Tk pour mon interface graphique. > Dans une routine je fais une mise a jour de l'interface: > $val_cutoff -> configure (-foreground => 'red') ; > $val_cutoff -> insert (0, $cutoff) ; > Puis, je lance un calcul. > Cette routine a ete lancee par l'interface. > > La mise a jour ne se fait qu'a la fin du calul. > Serait-ce possible de faire une mise a jour immediate? > > Merci. > > =========================================================================== > Patrick DUPRÉ | | email: pdupre at gmx.com > Laboratoire interdisciplinaire Carnot de Bourgogne > 9 Avenue Alain Savary, BP 47870, 21078 DIJON Cedex FRANCE > Tel: +33 (0)380395988 > =========================================================================== > > _______________________________________________ > Perl mailing list > Perl at mongueurs.net > http://listes.mongueurs.net/mailman/listinfo/perl > Attention, les archives sont publiques > -------------- section suivante -------------- Une pièce jointe HTML a été nettoyée... URL: From pdupre at gmx.com Wed Feb 26 10:54:20 2020 From: pdupre at gmx.com (Patrick Dupre) Date: Wed, 26 Feb 2020 10:54:20 +0100 Subject: [Perl] Interaction avec Tk In-Reply-To: References: Message-ID: Une pièce jointe HTML a été nettoyée... URL: From pdupre at gmx.com Wed Feb 26 11:48:21 2020 From: pdupre at gmx.com (Patrick Dupre) Date: Wed, 26 Feb 2020 11:48:21 +0100 Subject: [Perl] plplot exit Message-ID: Bonjour, J'utilise PLplot pour mes graphiques. Je peux utiliser le curseur de la souris pour quitter le mode graphique. Mais je voudrais aussi pourvoir utiliser le X (exit, en-haut a droite) de la fenetre X dans laquelle se trouve mes graphiques. Comment puisse gerer cette requete? =========================================================================== Patrick DUPRÉ | | email: pdupre at gmx.com Laboratoire interdisciplinaire Carnot de Bourgogne 9 Avenue Alain Savary, BP 47870, 21078 DIJON Cedex FRANCE Tel: +33 (0)380395988 ===========================================================================