IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Modules Perl Discussion :

Détourner l"utlisation normale d'un module


Sujet :

Modules Perl

  1. #1
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2005
    Messages
    73
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2005
    Messages : 73
    Par défaut Détourner l"utlisation normale d'un module
    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;
    	}

  2. #2
    Expert confirmé
    Avatar de Jedai
    Homme Profil pro
    Enseignant
    Inscrit en
    Avril 2003
    Messages
    6 245
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Avril 2003
    Messages : 6 245
    Par défaut
    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ï

  3. #3
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2005
    Messages
    73
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2005
    Messages : 73
    Par défaut
    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

  4. #4
    Expert confirmé
    Avatar de Jedai
    Homme Profil pro
    Enseignant
    Inscrit en
    Avril 2003
    Messages
    6 245
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Avril 2003
    Messages : 6 245
    Par défaut
    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ï

  5. #5
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2005
    Messages
    73
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2005
    Messages : 73
    Par défaut
    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

Discussions similaires

  1. Réponses: 1
    Dernier message: 22/02/2013, 16h11
  2. Problème "LoadModule ssl_module modules/mod_ssl.so"
    Par ldcarpathes dans le forum Apache
    Réponses: 9
    Dernier message: 24/01/2008, 11h07
  3. est ce normal que le module NET::FTP soit TRES lent ?
    Par ramislebob dans le forum Modules
    Réponses: 4
    Dernier message: 14/03/2006, 09h13
  4. Quotes dans TFilenameEdit (RXLib)
    Par AnnSo dans le forum Composants VCL
    Réponses: 3
    Dernier message: 23/01/2003, 20h26
  5. Détourner des IRQ sous Windows
    Par Blustuff dans le forum Assembleur
    Réponses: 15
    Dernier message: 06/12/2002, 10h16

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo