Discussion :

[siaoly]

Bonjour j'ai fait un script utilisant lwp etc... qui télécharge donc des infos a partir du net , j'aimerais entre autre savoir la taille des ficheirs que je télécharge et pour cela j'utilise HTTP::Size seulement il ralentit mon script etant donné qu'il fait un GET() alors que j'en est déjà fait un juste avant pour télécharger le fihcier ce qui est contre productif .

Voici comment je traite mes url de façon très classique avec LWP

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
my $requete    =     HTTP::Request->new( 'GET', $lien );
                    my $res        =     $ua->request($requete);
 
                    if ( $res->is_success )
                    {
                        my $code_doc = $res->content;
 
                        my %hash = (
 
                            result => [ "$lien", "$code_doc" ]
 
                        );
 
                        print "$hash{'result'}->[0]\n";
                        print "$hash{'result'}->[1]\n";
 
 
                    }

et maintenant avec HTTP::Size vous allez vite comprendre la problème

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
my $requete    =     HTTP::Request->new( 'GET', $lien );
                    my $res        =     $ua->request($requete);
 
                    if ( $res->is_success )
                    {
                       my $code_doc = $res->content;
                       my $size       =    HTTP::Size::get_size( $lien );
                       if( defined $size )
                       {
                        my %hash = (
 
                            result => [ "$lien", "$code_doc", "$size" ]
 
                        );
 
                        print "$page{'result'}->[0]\n";
                        print "$page{'result'}->[1]\n";
                        print "$page{'result'}->[2]\n";
 
                    }
                   }

Comme vous pouvez le voir sa fait 2 get d'ou perte de temps

J'ai regardé un peu le code du module et je n'est pas trouvé comment le "cabler" pour qu'il evalue la taille de $lien sans refaire un get etant donné que j'en est fait un juste avant.

Avez vous une idée ?


Heu voici le code du module

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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
132
133
134
135
# $Id: Size.pm,v 1.5 2004/09/08 01:36:02 comdog Exp $
package HTTP::Size;
 
use subs qw( get_size _request );
use vars qw(
	$ERROR $HTTP_STATUS $VERSION
	$INVALID_URL $COULD_NOT_FETCH $BAD_CONTENT_TYPE
	);
 
use LWP::UserAgent;
use URI;
use HTTP::Request;
 
$VERSION = 0.91;
 
my $User_agent = LWP::UserAgent->new();
 
$INVALID_URL        = -1;
$COULD_NOT_FETCH    = -2;
$BAD_CONTENT_LENGTH = -3;
 
 
sub get_size
	{
	my $url    = shift;
	my $method = shift || 0;
	_init();
 
	unless( ref $url eq 'URI' )
		{
		$url = URI->new( $url );
		}
 
	unless( $url->scheme )
		{
		$ERROR = $INVALID_URL;
		return;
		};
 
	my $response = '';
	my $size     = 0;
 
	unless( $method )
		{
		my $request = HTTP::Request->new( HEAD => $url->as_string );
 
		$response    = _request( $request );
		$HTTP_STATUS = $response->code;
		$size        = $response->content_length;
		}
 
	unless( not $method and $response->is_success and $size )
		{
		$request     = HTTP::Request->new( GET => $url->as_string );
		$response    = _request( $request );
		$HTTP_STATUS = $response->code;
		$CONTENT     = $response->content;
 
		unless( $response->is_success )
			{
			$ERROR = $COULD_NOT_FETCH;
			return;
			}
		elsif( not $response->content_length )
			{
			$size = length $CONTENT;
			}
		elsif( $response->content_length )
			{
			$size = $response->content_length;
			}
 
		}
 
	$CONTENT_TYPE = lc $response->content_type;
 
	return $size;
	}
 
 
 
 
 
 
sub get_sizes
	{
	my $url  = shift;
	my $base = shift;
 
	my %hash;
 
	my $size = get_size( $url, 'GET' );
 
	@{$hash{$url}}{ qw(size ERROR HTTP_STATUS) }
		= ($size, $ERROR, $HTTP_STATUS);
 
	unless( $size and $CONTENT_TYPE eq 'text/html' )
		{
		return wantarray ? ( $size, \%hash ) : $size;
		}
 
	require HTML::SimpleLinkExtor;
 
	my $total = $size;
 
	my $extor = HTML::SimpleLinkExtor->new( $url );
 
	$extor->parse( $CONTENT );
 
	foreach my $img ( $extor->img )
		{
		my $size = get_size( $img ) || 0;
 
		@{$hash{$img}}{ qw(size ERROR HTTP_STATUS) }
			= ( $size, $ERROR, $HTTP_STATUS );
 
		$total += $size;
		}
 
	return wantarray ? ( $total, \%hash ) : $total;
	}
 
sub _init
	{
	$ERROR = $CONTENT_TYPE = $CONTENT = $HTTP_STATUS = '';
	}
 
sub _request
	{
	my $response = $User_agent->request( shift );
 
	$HTTP_STATUS = $response->code;
 
	return $response;
	}

[Jedai]

Premièrement, HTTP::Size ne fait pas systématiquement un GET (heureusement !), il essaie d'abord un HEAD. Deuxièmement, il suffit d'utiliser length() sur $code_doc pour connaître la taille de ton contenu...

--
Jedaï

[siaoly]

Heu je me suis mal expliqué quand je dit la taille je parle de la taille en octect. La solution de lenght aurais été pas mal si je ne pompais que des fichier au format texte , mais ce n'est ps le cas

[Jedai]

La solution de lenght aurais été pas mal si je ne pompais que des fichier au format texte , mais ce n'est ps le cas

Je ne vois pas le problème ? En utilisant le pragma "bytes" tu peux être sûr de ne pas travailler en Unicode, et dans ce cas length renvoie la longueur en octet de son paramètre.

--
Jedaï

[siaoly]

Heu ok , j'ai bien chercher je ne trouve aucune doc sur cette utiisation de lenght(), peut tu s'il te plait me filer le lien

Encore merci