Exécuter code dans un autre fichier

Version imprimable

28/06/2012, 16h13
Mwoua_n7

Exécuter code dans un autre fichier
Bonjour a tous.

J'ai un petit programme dans lequel je définis un certain nombre de variables.

Ensuite, en fonction de ces variables, j'aimerai appeler un autre script perl (dans un sous dossier), mais qui puisse acceder et modifier toutes les variables defini dans le script parent.

J'ai essayé en faisant un do "chemin/du/script.pm", j'ai pas d'erreur, mais ca modifie rien.

Je suis encore assez débutant en perl, mais je pense pas que ce soit compliqué.

Merci

edit : par exemple dans le fichier parent j'ai ca
Code:

1 2 3 4 5 6 7 my $var1; my $var2; my $content; [les deux variables sont modifiées] do "chemin/du/script/".$var1; print $content;
et dans le script enfant
Code:

1 2 $content.='test';
28/06/2012, 16h40
Philou67430

La portée de la variable $content est limitée au module parent (my).
Pour pouvoir utiliser cette variable dans un module fils, il faut :
- élargir la portée de cette variable (en utilisant our ou à la limite, local)
- utiliser sa référence complète dans le module fils : $::content

J'ai essayé les deux méthodes, ca marche pas.

Voila les code que j'utilise (en simplifié), c'est du mod_perl avec du PerlHandler

Le premier code recupere la requete, et la transmet au 2e code, qui fait la requete et selon le résultat de la requete appelle un autre morceau de code

(le do est ligne 75 du 2nd bloc de code)

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
 
package aw::main;
use strict;
use warnings;
use Apache2::Const qw(:common);
use Apache2::RequestRec;
use Apache2::RequestIO;
use aw::process;
 
my $destdomain="example.com";
my $desthost="www1.example.com";
my $wwwdesthost="www.example.com";
 
sub handler {
   my ($r) = @_;
   $r->handler("perl-script");
   $r->set_handlers(PerlHandler => \&proxy_handler);
   return OK;
}
 
sub proxy_handler {
	my($r) = @_;
	$r->status(200);
	$r->content_type("text/plain");
	my $ourhost="domaine.fr.cr";
	my $wwwourhost="www.dmoaine.fr.cr";
	my $result=aw::process::process($r);
 
 
	if($result) {
		$r->print($$result);
	}
	$_=undef; # clear private data
   return OK;
}
 
1;

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
 
package aw::process;
use strict;
use warnings;
use LWP::UserAgent; #pour les connexion
use APR::Table;
 
sub process {	
	my $destdomain="example.com";
           my $desthost="www1.example.com";
           my $wwwdesthost="www.example.com";
	my $dir="/usr/lib/perl5/awproxy/";
	my $ourhost="domaine.fr.cr";
	my $wwwourhost="www.dmoaine.fr.cr";
	my $r = shift;
 
 
	# autodetect $ourhost value from input headers
	my $headers_in = $r->headers_in;
	my $host=$headers_in->get("Host");
	my $dest;
	if($host=~/^www\.a/) { # matches $wwwourhost
		$dest=$wwwdesthost;
	} else {
		$dest=$desthost;
	}
 
	#Pour creer la requete
	my $ua = LWP::UserAgent->new();
	$ua->agent('Mwoua');
	my $method = uc($r->method);
	my $request = HTTP::Request->new($method,"http://".$dest.$r->uri);	
 
 
	while(my($key,$val) = each %$headers_in) {
      next if($key eq "Host"); # do not override host header
      next if($key eq "Accept-Encoding");
      $request->header($key,$val);
	}
 
	#on ajoute les donnees POST
	if($request->header("Content-Length")) {
		my $postdata;
		$r->read($postdata,$request->header("Content-Length"));
		$request->content($postdata);		
	}
 
 
	my $response = $ua->request($request);
	if(!$response)
	{
		$r->status(500);
		$r->print("sorry: something went wrong\n");
		return;
	}
	$r->content_type($response->header('Content-type'));
	my $headers_out=[];
	$response->scan(sub {
        if(lc $_[0] ne "connection") {
				$r->headers_out->add(@_);
				push(@$headers_out, \@_);
        }
	});
 
	my $out;
	my $content;
 
	#on regarde ou on est, et on applique les modifs
	my $include=$r->unparsed_uri;
	$include =~ s/\.php$//i ;
	$include =~ s/\/$// ;
	$include=$dir.$dest.$include.'.pm';
	if(-e $include)
	{
		my $ret=do $include;
	}
	else
	{
		$content.='pouet'.$include;
	}
	$content.=$response->content;
	return \$content;
}
1;

Et le module que j'appelle, pour mes tests, tres simple :

Code:

1
2
3
4
5
6
7
 
use strict;
use warnings;
 
$::content.='haha';
 
1;

28/06/2012, 23h30
Lolo78
Je ne comprends pas bien ce que tu veux faire, mais j'ai l'impression que tu prends les choses un peu à l'envers.

Si tu as un programme perl (.pl) et un module perl (.pm) et que tu veux récupérer dans le programme des constantes définies dans le module, alors c'est dans le module, et non dans le programme, que tu dois déclarer ta variable.

Un truc vite fait dans ce genre.

Dans le module my_module.pm:
Code:

1 2 3 4 5 6 7 8 9 ... our @ISA = qw(Exporter); our @EXPORT = qw(PI); our @EXPORT_OK = qw($dix); sub PI {return 3.14159;} our $dix = 10; ... 1;
Ici, "our @EXPORT" déclare que le module exporte automatiquement la fonction PI et "our @EXPORT_OK" déclare que le module autorise l'exportation de $dix (mais l'importation devra être explicite).

Et dans ton programme, tu écris une directive du type

Code:

use my_module;

Ce qui aura pour effet d'importer automatiquement PI.

Si tu veux aussi importer $dix, alors il faut importer explicitement:

Code:

use my_module qw ($dix);

Le fait d'utiliser ces directives "use ..." va t'autoriser à utiliser dans le programme principale les constantes, variables ou fonctions déclarées et définies dans le module.

Bon, j'ai juste donné une version super "lite" (et approximative) du mécanisme, mais j'espère que ça te permet de comprendre à peu près comment ça marche. (Et je n'ai rien testé.)
29/06/2012, 11h46
Philou67430

J'avais bien précisé qu'il fallait changer le type de déclaration de la variable $content. Or, ligne 66, on voit encore my $content => à changer en local $content par exemple.

Ensuite, j'avais supposé que le module appelant était le seul et unique module (main), et qu'il n'était pas nommé. Or, ce module est nommé à l'aide de l'instruction package :

Code:

package aw::process;

Dans le module fils, il faut donc utiliser le nom du module d'origine ainsi :

Code:

$aw::process:content .= 'haha';

L'autre solution, proposée par Lolo est bien entendue plus universelle et maintenable. On peut même l'améliorer en transformant ce module fils en module OO (ne nécessitant alors plus le module Exporter).
29/06/2012, 16h37
Mwoua_n7

@philou, j'ai remis le code de base, avant ton intervention, mais j'avais essayé en changeant la déclaration

et je crois que javais aussi essayé en mettant $aw::process:content .= 'haha'; mais ca cest pas sur.

@lolo : merci

Je réessaye lundi et je vous tiens au courant

Et j'ai que des modules, je perlhandler fais appel a un module, et dedans je fais appel a un autre module
02/07/2012, 14h20
Mwoua_n7

Bon, a priori javais mal essayé avec
$aw::process::content parceque maintenant ca marche.

Merci bien