Appel sous script

Version imprimable

Voir 40 message(s) de cette discussion en une page

20/03/2006, 19h29
Jedai

Tu sembles oublier de déclarer correctement tes variables : il faut mettre un 'my' devant si ce sont des variables locales, ou un 'our' devant si elles sont globales. Tu devrais nous montrer ton vrai code si tu veux qu'on t'aide à le débugguer.

--
Jedaï

Oki je sais mais si je met le code bon courage car ca commence a entre long !!!

Ma sous fonction

Code:

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
 
#!/usr/bin/perl
use strict;             #module detectant les erreurs potetielles
use Carp;
package sous_fonc;                      #package nom_du_sous_script
require Exporter;
our @ISA = qw(Exporter);
our  @EXPORT=qw(Switch_Cisco);
 
my $Lecture_Fichier_Mib;           #Contient le champ correspondant à la communauté snmp
my $Bonne_Ligne_Fichier_Mib;       #Contient le nom d'un switch    a la fois
my $Numero_Switch_Type;
my @a;
my $Resultat_Snmp;
my$Type_Switch_Cisco;
# my $Type_Switch;
sub Switch_Cisco
{
        $Resultat_Snmp= [i][u]([b]$Type_Switch[/b]);# [/u][/i]Resultat de la requete SNMP
        if (($Numero_Switch_Type)=(($Resultat_Snmp)=~/\D(\d+)$/))  # /\.(\d{3})/))
                                #On va selectionner le chiffre correspondant au materiel du switch
                                {
                                        #print $Numero_Switch_Type;
                                }
        open(Fichier_mib_cisco,"<CISCO-PRODUCTS-MIB.my") || die ("Fichier CISCO-PRODUCTS-MIB.my introuvable :\n $! ");
        while ($Lecture_Fichier_Mib = <Fichier_mib_cisco>) # On parcours ligne par ligne le fichier CISCO-PRODUCTS-MIB.my
       {
                $Bonne_Ligne_Fichier_Mib = $Lecture_Fichier_Mib if ( $Lecture_Fichier_Mib =~ m/^(.*{ ciscoProducts $Numero_Switch_Type }.*)$/) ;
       }
 
        ($Bonne_Ligne_Fichier_Mib,@a) = split /\s/,$Bonne_Ligne_Fichier_Mib;
        $Type_Switch_Cisco = $Bonne_Ligne_Fichier_Mib if ($Bonne_Ligne_Fichier_Mib =~/^\s?(\S)\s?/);
 
close Fichier_mib_cisco;
return $Type_Switch_Cisco;
}
1;# Ce n'est pas un L minuscule mais un "UN"

Mon fichier principal:

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
#!/usr/bin/perl
                                          #Utilisation du module POSIX pour recuperer l'heure
                                          #car ce module gère les variables d'environnement
use POSIX qw(strftime);                   #strftime est un sous programme du module POSIX qui retourne des listes
use strict;
use lib '.';                              #Mettre un '.' si le module et pro_prin sont [u][i][b]ds le meme rep sinon './rep'
require sous_fonc;[/b[/i][/u]]
 
#Variables globales utilisées par le programme
my $Date;
my $Heure;
my $Ligne_Fichier;
my $Groupe;             #Contient le nom des groupes à chaque passage dans la boucle groupe
my $Com_Snmp;           #Contient le champ correspondant à la communauté snmp
my $Nom_Switch;         #Contient le nom d'un switch    a la fois
my $Addr_Ip;            #Contient l'adresse IP correspondant au nom du switch sélectionné
[b]our $Type_Switch[/b];       #Contient le type du switch pour l adresse IP contneu dans $Addrs_Ip
my $cpt=0;
my $Cmd_Snmp_Type;      #
my $Cmd_Snmp_Type_Oid;  #Commande SNMP complete avec l oid pour recuperer le type
my $Loc_Switch;         #Contient le type du switch pour l adresse IP contneu dans $Addrs_Ip
my $Cmd_Snmp_Loc;       #
my $Cmd_Snmp_Loc_Oid;   #Commande SNMP complete avec l oid pour recuperer la localisation du switch
my $Num_Type;           #On recupere le numero precis du numero du switch
#my $Lecture_Fichier_Mib;
#my $Bonne_Ligne_Fichier_Mib;
my $Type_Switch_Cisco;
#my @a;
        $Date = strftime "%a %e %b %Y",localtime; #On place la date $date  %a=jour %e=semaine %b=mois %Y annee
        $Heure = strftime "%H:%M:%S", localtime;  #On place l heure dans la variable $heure
 
print ("#################################################################\n");
print ("########### Début du script :",$Date," ",$Heure,"############\n"); # affichage de la date et heure
print ("#################################################################\n");
print ("\n");
print ("## Verifiez la présence du fichier Utilisé par Nagios ###########\n");
print ("## Verifiez la présence du fichier CISCO-PRODUCTS-MIB.my#########\n");
 
# Vérification et ouverture du fichier base_Lan.txt pour la lecture
open(Fichier_Lan,"< base_light_perso.txt") || die ("Vérifiez la présence du fichier base_Lan.txt ou son chemin à la ligne :\n $! ");
open(Fichier_Resultat,">resultat_info_switch") || die ("Vérifiez la présence du fichier resultat.txt ou son chemin à la ligne :\n $! ");
while ($Ligne_Fichier = <Fichier_Lan> )
 
{
 next if (($Ligne_Fichier) =~ m/^$/);
 #Cette ligne permet d'omettre toute les lignes vides !!! On ne considere donc que les lignes utiles
   {
        if (($Ligne_Fichier)=~s/\n//g)
        #on fait de notre ficher une simple ligne
        {
 
                if ( ($Ligne_Fichier) =~/\[/)
                ############################################################################################
                # Cette condition va permetre de selectionner les lignes  ou l'on a les groupe et communaute
                ############################################################################################
                {
                        if ( ($Groupe)=(($Ligne_Fichier) =~/\[(\S+)\]\t+\S/ ))
                        # expression reguliere qui permet de trouver le groupe qui est entre crochets
                        {
                        #       print "\n Nom du groupe: [$Groupe]";
                                # affiche le nom du groupe
                        }
 
                        if ( ($Com_Snmp)= (($Ligne_Fichier) =~/\]\t+(.*)/ ))
                        # expression reguliere qui permet de trouver la communauté snmp du groupe
                        {
                        #       print ("\t\t\t Nom de la communauté SNMP: [$Com_Snmp] \n"); #
                        }
                }
                else
                ############################################################################################
                #Ici on traite toutes les lignes ou l'on ni groupe ni communaute
                ############################################################################################
 
                {
                        if ( ($Nom_Switch)= (($Ligne_Fichier) =~/(\S+)\t+\d+\.\d+\.\d+\.\d+/))
                        # expression reguliere qui permet de trouver le nom du switch
                        {
                        #       print ("\tNom du switch: [$Nom_Switch]"); #
                        }
 
                        if ( ($Addr_Ip)= (($Ligne_Fichier) =~/\S+\t+(\d+\.\d+\.\d+\.\d+)/))
                        # expression reguliere qui permet de trouver l'@IP de chaque witch
                        {
                        #       print ("\t\t\t Adresse IP: [$Addr_Ip]\n");
                        #       print("\n");
 
 
                                ####################
                                sub Fonc_Type_Switch
                                #On passe en paramatre l'ip et la communaute snmp du switch a la fonction et l'on
                                #recupere le type de switch contenu dans l'OID
                                {
                                        $Cmd_Snmp_Type = "snmpget -v1 -c $Com_Snmp -Ovq";
                                        $Cmd_Snmp_Type_Oid  = `$Cmd_Snmp_Type $Addr_Ip .1.3.6.1.2.1.1.2.0`;
                                        chomp($Cmd_Snmp_Type_Oid);
                                        #Enlève le dernier caractère de la chaîne
                                        return $Cmd_Snmp_Type_Oid;
                                        #Permet de retourner une variable precise, évite d'avoir la variable par defaut
                                }
                                $Type_Switch = &Fonc_Type_Switch;
                                ##################
 
 
                                ##################
                                sub Fonc_Loc_Switch
                                #On passe en paramatre l'ip et la communaute Snmp du switch et l'on
                                #recupere la localisation du materiel contenu dans l'OID
                                {
                                        $Cmd_Snmp_Loc = "snmpget -v1 -c $Com_Snmp -Ovq";
                                        $Cmd_Snmp_Loc_Oid  = `$Cmd_Snmp_Loc $Addr_Ip .1.3.6.1.2.1.1.6.0  `;
                                        chomp($Cmd_Snmp_Loc_Oid);
                                        return $Cmd_Snmp_Loc_Oid;
                                }
                                $Loc_Switch = &Fonc_Loc_Switch;
                                #################
 
                        [b]$Type_Switch_Cisco=&Switch_Cisco($Type_Switch);[/b]
 
 
                        print("\n$Nom_Switch;$Addr_Ip;$Groupe;$Com_Snmp;$Loc_Switch;$Type_Switch_Cisco;\n");
                        print Fichier_Resultat ("$Nom_Switch;$Addr_Ip;$Groupe;$Com_Snmp;$Loc_Switch;$Type_Switch_Cisco;\n");
                 }
         }
   }
}
close Fichier_Lan;
close Fichier_Resultat;
 
}

Ben voila je sais que c est long mais c est ca mon code j ai mis en gras la variable que je ve recupere et les lignes importantes !!!

Merci d avance Jules et bon courage

Bon je l ai allégé et simplifié pour mieux comprendre !!

voici donc ma sous fonction :

Code:

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
 
#!/usr/bin/perl
use strict;             #module detectant les erreurs potetielles
use Carp;
package sous_fonction_numero;                      #package nom_du_sous_script
require Exporter;
our @ISA = qw(Exporter);
our  @EXPORT=qw(Switch_Cisco);
 
my $Lecture_Fichier_Mib;           #Contient le champ correspondant à la communauté snmp
my $Bonne_Ligne_Fichier_Mib;       #Contient le nom d'un switch    a la fois
my $Numero_Switch_Type;
my @a;
my $Resultat_Snmp;
my$Type_Switch_Cisco;
# $main::$Type_Switch;
sub Switch_Cisco
{
        $Resultat_Snmp= ($Type_Switch);# Resultat de la requete SNMP
        if (($Numero_Switch_Type)=(($Resultat_Snmp)=~/\D(\d+)$/))  # /\.(\d{3})/))
                                #On va selectionner le chiffre correspondant au materiel du switch
                                {
                                }
        open(Fichier_mib_cisco,"<CISCO-PRODUCTS-MIB.my") || die ("Fichier CISCO-PRODUCTS-MIB.my introuvable :\n $! ");
        while ($Lecture_Fichier_Mib = <Fichier_mib_cisco>) # On parcours ligne par ligne le fichier CISCO-PRODUCTS-MIB.my
       {
                $Bonne_Ligne_Fichier_Mib = $Lecture_Fichier_Mib if ( $Lecture_Fichier_Mib =~ m/^(.*{ ciscoProducts $Numero_Switch_Type }.*)$/) ;
       }
 
        ($Bonne_Ligne_Fichier_Mib,@a) = split /\s/,$Bonne_Ligne_Fichier_Mib;
        $Type_Switch_Cisco = $Bonne_Ligne_Fichier_Mib if ($Bonne_Ligne_Fichier_Mib =~/^\s?(\S)\s?/);
 
close Fichier_mib_cisco;
return $Type_Switch_Cisco;
}
1;# Ce n'est pas un L minuscule mais un "UN"

Voici mon prog principal :

Code:

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
59
60
61
62
 
#!/usr/bin/perl
use strict;
use lib '.';                              #Mettre un '.' si le module et pro_prin sont ds le meme rep sinon './rep'
require sous_fonction_numero;
 
#Variables globales utilisées par le programme
my $Ligne_Fichier;
my $Groupe;             #Contient le nom des groupes à chaque passage dans la boucle groupe
my $Com_Snmp;           #Contient le champ correspondant à la communauté snmp
my $Nom_Switch;         #Contient le nom d'un switch    a la fois
my $Addr_Ip;            #Contient l'adresse IP correspondant au nom du switch sélectionné
our $Type_Switch;       #Contient le type du switch pour l adresse IP contneu dans $Addrs_Ip
my $Num_Type;           #On recupere le numero precis du numero du switch
my $Type_Switch_Cisco;
# Vérification et ouverture du fichier base_Lan.txt pour la lecture
open(Fichier_Lan,"< base_light_perso.txt") || die ("Vérifiez la présence du fichier base_Lan.txt ou son chemin à la ligne :\n $! ");
open(Fichier_Resultat,">resultat_info_switch") || die ("Vérifiez la présence du fichier resultat.txt ou son chemin à la ligne :\n $! ");
while ($Ligne_Fichier = <Fichier_Lan> )
{
        next if (($Ligne_Fichier) =~ m/^$/);
        #Cette ligne permet d'omettre toute les lignes vides !!! On ne considere donc que les lignes utiles
        {
                if (($Ligne_Fichier)=~s/\n//g)
                #on fait de notre ficher une simple ligne
                {
                        if ( ($Ligne_Fichier) =~/\[/)
                        # Cette condition va permetre de selectionner les lignes  ou l'on a les groupe et communaute
                        {
                                if ( ($Groupe)=(($Ligne_Fichier) =~/\[(\S+)\]\t+\S/ ))
                                # expression reguliere qui permet de trouver le groupe qui est entre crochets
                                {
                                #       print "\n Nom du groupe: [$Groupe]";
                                # affiche le nom du groupe
                                }
                                if ( ($Com_Snmp)= (($Ligne_Fichier) =~/\]\t+(.*)/ ))
                                # expression reguliere qui permet de trouver la communauté snmp du groupe
                                {
                                #       print ("\t\t\t Nom de la communauté SNMP: [$Com_Snmp] \n"); #
                                }
                        }
                        else
                        #Ici on traite toutes les lignes ou l'on ni groupe ni communaute
 {
                                if ( ($Nom_Switch)= (($Ligne_Fichier) =~/(\S+)\t+\d+\.\d+\.\d+\.\d+/))
                                # expression reguliere qui permet de trouver le nom du switch
                                {
                                #       print ("\tNom du switch: [$Nom_Switch]"); #
                                }
                                if ( ($Addr_Ip)= (($Ligne_Fichier) =~/\S+\t+(\d+\.\d+\.\d+\.\d+)/))
                                # expression reguliere qui permet de trouver l'@IP de chaque witch
                                {
                                        $Type_Switch ="system.sysObjectID.0 = OID: enterprises.9.1.449";
                                        $Type_Switch_Cisco=&Switch_Cisco($Type_Switch);
                                print("\n$Nom_Switch;$Addr_Ip;$Groupe;$Com_Snmp;$Type_Switch_Cisco;\n");
                                }
                        }
                }
        }
        close Fichier_Lan;
        close Fichier_Resultat;
}

Merci d avance de m expliquer pourquoi il me dit lorsque je compile :
erreur:

Global symbol "$Type_Switch" requires explicit package name at sous_fonction_numero.pm line 18.
Compilation failed in require at ./principal.pl line 4.

Je pense que le sous prog ne trouve pas la variablie dispo dans le prog principal !!!
Merci d avance Jules

21/03/2006, 10h22
djibril

lit la Faq en entier t'apprendra pleins de trucs. C'est rapide à lire.
Global symbol "$Type_Switch" requires explicit package name cette erreur signifie que tu n'as pas declaré $Type_Switch avec un my. confere ligne où il y a

Code:

# my $Type_Switch;

:wink:
Tu l'as mis en commentaire

Oui je sais mais pourquoi je dois declare cette variable "$Type_Switch"
dans le prog principal et dans la sous fonction si je les definis avec my dans chacun est que le sous programme va savoir que cette variable est herité du prog principal !

Voila j ai essaye ca :
prog principal:

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
#!/usr/bin/perl
                                          #Utilisation du module POSIX pour recuperer l'heure
                                          #car ce module gère les variables d'environnement
use strict;
use lib '.';                              #Mettre un '.' si le module et pro_prin sont ds le meme rep sinon './rep'
#require sous_fonction_numero;
 
#Variables globales utilisées par le programme
my $Ligne_Fichier;
my $Groupe;             #Contient le nom des groupes à chaque passage dans la boucle groupe
my $Com_Snmp;           #Contient le champ correspondant à la communauté snmp
my $Nom_Switch;         #Contient le nom d'un switch    a la fois
my $Addr_Ip;            #Contient l'adresse IP correspondant au nom du switch sélectionné
my $Type_Switch;        #Contient le type du switch pour l adresse IP contneu dans $Addrs_Ip
my $Num_Type;           #On recupere le numero precis du numero du switch
my $Type_Switch_Cisco;
 
# Vérification et ouverture du fichier base_Lan.txt pour la lecture
open(Fichier_Lan,"< base_light_perso.txt") || die ("Vérifiez la présence du fichier base_Lan.txt ou son chemin à la ligne :\n $! ");
open(Fichier_Resultat,">resultat_info_switch") || die ("Vérifiez la présence du fichier resultat.txt ou son chemin à la ligne :\n $! ");
while ($Ligne_Fichier = <Fichier_Lan> )
{
 next if (($Ligne_Fichier) =~ m/^$/);
 #Cette ligne permet d'omettre toute les lignes vides !!! On ne considere donc que les lignes utiles
   {
        if (($Ligne_Fichier)=~s/\n//g)
        #on fait de notre ficher une simple ligne
        {
 
                if ( ($Ligne_Fichier) =~/\[/)
                ############################################################################################
                # Cette condition va permetre de selectionner les lignes  ou l'on a les groupe et communaute
                ############################################################################################
                {
                        if ( ($Groupe)=(($Ligne_Fichier) =~/\[(\S+)\]\t+\S/ ))
                        # expression reguliere qui permet de trouver le groupe qui est entre crochets
                        {
                        #       print "\n Nom du groupe: [$Groupe]";
                                # affiche le nom du groupe
                        }
 
                        if ( ($Com_Snmp)= (($Ligne_Fichier) =~/\]\t+(.*)/ ))
 # expression reguliere qui permet de trouver la communauté snmp du groupe
                        {
                        #       print ("\t\t\t Nom de la communauté SNMP: [$Com_Snmp] \n"); #
                        }
                }
                else
                ############################################################################################
                #Ici on traite toutes les lignes ou l'on ni groupe ni communaute
                ############################################################################################
 
                {
                        if ( ($Nom_Switch)= (($Ligne_Fichier) =~/(\S+)\t+\d+\.\d+\.\d+\.\d+/))
                        # expression reguliere qui permet de trouver le nom du switch
                        {
                        #       print ("\tNom du switch: [$Nom_Switch]"); #
                        }
 
                        if ( ($Addr_Ip)= (($Ligne_Fichier) =~/\S+\t+(\d+\.\d+\.\d+\.\d+)/))
                        # expression reguliere qui permet de trouver l'@IP de chaque witch
                        {
                        #       print ("\t\t\t Adresse IP: [$Addr_Ip]\n");
                        #       print("\n");
                        }
 
                                  $Num_Type ="system.sysObjectID.0 = OID: enterprises.9.1.449";
 
                                require sous_fonction_numero;
                                $Type_Switch_Cisco=&Switch_Cisco($Type_Switch);
                                print("\n$Nom_Switch;$Addr_Ip;$Groupe;$Com_Snmp;$Num_Type;\n");
                 }
         }
   }
}
close Fichier_Lan;
close Fichier_Resultat;

Voici mon sous programme:

Code:

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
 
#!/usr/bin/perl
use strict;             #module detectant les erreurs potetielles
use Carp;
package sous_fonction_numero;                      #package nom_du_sous_script
require Exporter;
our @ISA = qw(Exporter);
our  @EXPORT=qw(Switch_Cisco);
 
my $Lecture_Fichier_Mib;           #Contient le champ correspondant à la communauté snmp
my $Bonne_Ligne_Fichier_Mib;       #Contient le nom d'un switch    a la fois
my $Numero_Switch_Type;
my @a;
my $Resultat_Snmp;
my $Type_Switch_Cisco;
my $Type_Switch;
sub Switch_Cisco
{
        $Resultat_Snmp= ($Type_Switch);# Resultat de la requete SNMP
        if (($Numero_Switch_Type)=(($Resultat_Snmp)=~/\D(\d+)$/))  # /\.(\d{3})/))
                                #On va selectionner le chiffre correspondant au materiel du switch
                                {
                                }
        open(Fichier_mib_cisco,"<CISCO-PRODUCTS-MIB.my") || die ("Fichier CISCO-PRODUCTS-MIB.my introuvable :\n $! ");
        while ($Lecture_Fichier_Mib = <Fichier_mib_cisco>) # On parcours ligne par ligne le fichier CISCO-PRODUCTS-MIB.my
       {
                $Bonne_Ligne_Fichier_Mib = $Lecture_Fichier_Mib if ( $Lecture_Fichier_Mib =~ m/^(.*{ ciscoProducts $Numero_Switch_Type }.*)$/) ;
       }
 
        ($Bonne_Ligne_Fichier_Mib,@a) = split /\s/,$Bonne_Ligne_Fichier_Mib;
        $Type_Switch_Cisco = $Bonne_Ligne_Fichier_Mib if ($Bonne_Ligne_Fichier_Mib =~/^\s?(\S)\s?/);
 
close Fichier_mib_cisco;
return $Type_Switch_Cisco;
}
1;# Ce n'est pas un L minuscule mais un "UN"

Et voici mon erreur :

Undefined subroutine &main::Switch_Cisco called at ./essai_principal.pl line 70, <Fichier_Lan> line 3.

Je ùe doute que l erreur pet etre bizzare mais bon c est celen qui m empeched avancer !
Merci Jules

21/03/2006, 11h38
calimero642

Bon voila ou j en suis je peux compiler le prog qui fait appel au sous programme.
Mais le probleme c est que lorsque je verifie si je receptionne bien la variable du prog principal utilisee dans le sous prog ca ne marche pas !!!
Je ne comprend moi meme pas comment le sous programme peut differencier la variable qui vient d un autre programme si la variable est declaree plus haut !!!
21/03/2006, 17h24
calimero642

Bon j ai perseveré e ca fonctionne !!!!
merci beaucoup.Je passe sous un nouveau thread pour une nouvelle question !!
a toute Jules

Voir 40 message(s) de cette discussion en une page