gnu-grep braucht ewig unter Perl (system) (gelöst) (Allgemeines zu Perl)

[thread]15590[/thread]

gnu-grep braucht ewig unter Perl (system) [gelöst]

Leser: 17

Articles: hide open all | hide show old branches

+8 replies

Gast equinox

2010-11-01 12:37

Hi,

Folgendes Szenario:
Ich möchte mit "gnu" grep http-access logs vorfiltern um später in perl die Ergebnisse daraus nach RFI-Patterns zu durchsuchen. Eigentlich funktioniert alles, nur habe ich festgestellt, dass mein greü-Befehl den ich innerhalb von Perl per system() absetze sehr lange braucht (1,5 Minuten). Führe ich den gleichen Befehl in einer Shell aus geht das ganze sehr schnell (2-3 Sekunden).

Der Befehl: find /kunden/homepages/20/d264326328/htdocs//logs/ -maxdepth 1 -type f -name access.log* | xargs -r -n1 -P10 /bin/zgrep -E " \"(POST |GET .*=(htt|ft|ph)p(:|%3[aA])(/|%2[fF])).* HTTP/[0-9]\.[0-9]\" [23][0-9]{2}"

An der Datenmenge kann es nicht liegen (ca. 600kb), das habe ich bereits getestet. Auch an der Art wie ich den Befehl absetze kann es nicht liegen (mit system() probiert, aber auch mit open FH <$cmd>; usw ..). Interessant ist auch, dass in der Shell mehrere grep-Prozesse gestartet werden, unter Perl nicht. Hat jemand eine Ahnung woran das liegt?

Danke und Grüße
equinox
Last edited: 2010-11-01 12:46:02 +0100 (CET)

+7 replies

topeg

2010-11-01 13:16

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Dafür brauchst du gar keine externen Programme:

Code (perl): (dl )

#!/usr/bin/perl
use strict;
use warnings;

my @lines_found;

for my $file (glob('/kunden/homepages/20/d264326328/htdocs/logs/access.log*'))
{
  next unless(-f $file);

  if(open(my $fh, '<', $file))
  {
    while(my $line=<$fh>)
    {
      push(@lines_found,$line) if($line=~m!"(?:POST |GET .*=(?:htt|ft|ph)p(?::|%3a)(?:/|%2f)).* HTTP/[0-9]\.[0-9]" [23][0-9]{2}!i)
    }
    close($fh);
  }
  else
  { warn "ERROR open $file ($!)\n"; }
}

print $_ for(@lines_found);

Wenn du doch mal tiefer verschachtelte suchen machen willst. Es gibt das Modul CPAN:

File::Find

Was die lange Ausführung betrifft wie hast du den Aufruf gemacht? Unter Umständen hat Perl den String interpretiert, bevor er ausgeführt wurde und verändert. Das würde dann bewirken dass etwas ganz anderes gemacht wurde als du erwartest.

EDIT:
Ich habe übersehen, dass du auch komprimierte Dateien lesen willst. Darum hier das angepasste Beispiel:

Code (perl): (dl )

#!/usr/bin/perl
use strict;
use warnings;
use IO::Uncompress::Gunzip;
use File::Type;

my $ft = File::Type->new();
my @lines_found;

for my $file (glob('/home/httpd/thttpd.log*'))
{
  next unless(-f $file);

  my $fh=undef;

  if($ft->mime_type($file)=~/gzip/)
  {
    unless($fh=IO::Uncompress::Gunzip->new($file))
    { warn "ERROR open compressed $file ($IO::Uncompress::Gunzip::GunzipError)"; }
  }
  else
  {
    unless(open($fh, '<', $file))
    { warn "ERROR open $file ($!)\n"; }
  }

  if($fh)
  {
    while(my $line=<$fh>)
    {
      push(@lines_found,$line) if($line=~m!"(?:POST |GET .*=(?:htt|ft|ph)p(?::|%3a)(?:/|%2f)).* HTTP/[0-9]\.[0-9]" [23][0-9]{2}!i)
    }
    close($fh);
  }
}

print $_ for(@lines_found);

Last edited: 2010-11-01 17:34:40 +0100 (CET)

+6 replies

Gast equinox

2010-11-02 09:22

hi.

Danke erstmal für Deine Lösung :)
Sowas in der Art hatte ich auch schonmal, kann mich aber entsinnen, dass dieser Weg mehr Zeit in Anspruch nahm als mit zcat/find | grep. Ich werds aber trotzdem nochmal versuchen.

Der Aufruf sieht übrigens so aus:

Code (perl): (dl )

use strict; use warnings;
use Carp;

sub run {
    my ($self) = shift;
    my $args = $self->{args};

    my $post_method     = "POST";
    my $get_method      = "GET .*=(htt|ft|ph)p(:|%3[aA])(/|%2[fF])";
    my $method_string   = '\"('.$post_method.' |'.$get_method.')';

    if ( (defined $args->{method}) && ($#{$args->{method}} + 1 == 1) ) {
        if (grep lc($_) eq "post", @{$args->{method}}) {
            $method_string = '\"'.$post_method;
        } elsif (grep lc($_) eq "get", @{$args->{method}}) {
            $method_string = '\"('.$get_method.')';
        }
    }

    my $command =  "find ".$args->{docroot}."/logs/ -maxdepth 1 -type f -name access.log\* | xargs -r -n1 -P10 /bin/zgrep -E \" ".$method_string.".* HTTP/[0-9]\\\.[0-9]\\\" [23][0-9]{2}\"";

    open FH, "-|", $command;
    local $/;
    my $output=<FH>;
    close FH;

    return $output;
}

1;

Grüße
equinox
Last edited: 2010-11-02 09:30:07 +0100 (CET)

+5 replies

topeg

2010-11-02 23:30

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Das hier

Code (perl): (dl )

(defined $args->{method}) && ($#{$args->{method}} + 1 == 1)

ist nur erfüllt wenn das array genau einen Eintrag hat ist das so gewünscht? Dann macht da grep gar keinen Sinn da man einfach den ersten Eintrag überprüfen muss.

Ich glaube du kommst mit dem Quoten durch einander. So sollte es funktionieren:

Code (perl): (dl )

sub run {
    my ($self) = shift;
    my $args = $self->{args};

    my $post_method     = 'POST';
    my $get_method      = 'GET .*=(htt|ft|ph)p(:|%3[aA])(/|%2[fF])';
    my $method_string   = qq!"($post_method |$get_method)!;

    if ( defined($args->{method}) && @{$args->{method}}==1 )
    {
      if (lc($args->{method}->[0]) eq 'post')
      { $method_string = qq!"$post_method!; }
      elsif (lc($args->{method}->[0]) eq 'get')
      { $method_string = qq!"($get_method)!; }
    }

    my $command =  qq!find $args->{docroot}/logs/ -maxdepth 1 -type f -name access.log\* | xargs -r -n1 -P10 /bin/zgrep -E '$method_string.* HTTP/[0-9]\.[0-9]" [23][0-9]{2}'!;

    open FH, "-|", $command;
    local $/;
    my $output=<FH>;
    close FH;

    return $output;
}

Dein Code kann durchaus schneller sein, da in deiner Pipeline geforkt wird. Das macht aber nur auf einem Mehrprozessorsystem wirklich Sinn. Das hab ich mal nachgebildet:

Code (perl): (dl )

#!/usr/bin/perl
use strict;
use warnings;
use IO::Uncompress::Gunzip;
use File::Type;

my $ft = File::Type->new();
my @lines_found;

my @files=glob('/kunden/homepages/20/d264326328/htdocs/logs/access.log*');
my %pipes;

while(@files || keys(%pipes))
{
  if(keys(%pipes) >= 10 || @files==0)
  {
    for my $child (keys(%pipes))
    {
      my $fh=$pipes{$child};
      if(eof($fh))
      {
        delete($pipes{$child});
        next;
      }

      eval{
        local $SIG{ALRM}=sub{die()};
        alarm(1);
        while(<$fh>)
        { push(@lines_found,$_); }
        alarm(0);
      };
    }
    next;
  }

  next unless(@files);
  my $file=shift(@files);
  next unless(-f $file);

  my $pid=open(my $child, '-|');
  die("Fork failed!") unless(defined($pid));

  if($pid)
  {
    $pipes{$pid}=$child;
    next;
  }

  child($file);
}

print $_ for(@lines_found);

sub child
{
  my $file=shift;
  my $fh=undef;

  my $ftype=$ft->mime_type($file);
  if($ftype=~/gzip/)
  {
    unless($fh=IO::Uncompress::Gunzip->new($file))
   { warn "ERROR open Copressed $file ($IO::Uncompress::Gunzip::GunzipError)"; }
  }
  elsif($ftype=~/octet-stream|text/)
  {
    unless(open($fh, '<', $file))
    { warn "ERROR open $file ($!)\n"; }
  }
  else
  { warn("ERROR open $file Filetype unknown ($ftype)\n"); }

  if($fh)
  {
    while(my $line=<$fh>)
    {
      print $line if($line=~m!"(?:POST |GET .*=(?:htt|ft|ph)p(?::|%3a)(?:/|%2f)).* HTTP/[0-9]\.[0-9]" [23][0-9]{2}!i)
    }
    close($fh);
  }
  exit;
}

Last edited: 2010-11-02 23:36:25 +0100 (CET)

+4 replies
Gast equinox

2010-11-03 07:57
Guten morgen,

also ich hab mal Deinen letzten Vorschlag ausprobiert. Leider ist die Performance da noch schlechter (Analysezeit über 2 Minuten) als mit einem einzelnen grep via systemcall (ca. 1,5 Minuten).

Mir ging es ja auch vorrangig darum herauszufinden, warum der grep-Systemcall so lange braucht während der in einer Shellumgebung zur Ausführung gerademal 3 Sekunden benötigt. Vielleicht hab ich das in meinem Eröffnungsthread aber auch nicht genau genug angedeutet?

Ich hab dann noch folgendes ausprobiert (mit überflüssigem ersten if-Block):
Code (perl): (dl )

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

sub init { my ($self) = shift; $self->setWanted($self->{args}->{docroot}."/logs/access.log*"); } sub run { my ($self) = shift; my $args = $self->{args}; # default method strings my $post_method = "POST"; my $get_method = "GET .*=(htt|ft|ph)p(:|%3[aA])(/|%2[fF])"; my $method_string = '\"('.$post_method.' |'.$get_method.')'; # redefine method string if it is given from the client if ( (defined $args->{method}) && ($#{$args->{method}} + 1 == 1) ) { if (grep lc($_) eq "post", @{$args->{method}}) { $method_string = '\"'.$post_method; } elsif (grep lc($_) eq "get", @{$args->{method}}) { $method_string = '\"('.$get_method.')'; } } # we fork several processes here to have the results faster. somehow grep takes a looooooooooooooong time to have a look over the logfiles. FIXME? foreach (keys %{$self->{files}}) { my $pid = fork(); # parent if ($pid) { $result->{$pid} = (); # child } elsif ($pid == 0) { my $cmd = '/bin/zgrep -E " '.$method_string.'.* HTTP/[0-9]\.[0-9]\" [23][0-9]{2}" '.$_." 2>/dev/null"; print `$cmd`; exit(0); } else { main::error("Could not fork: $!"); exit(1); } } foreach (keys %$result) { waitpid($_, 0); } return; }
Damit dauert das ganze jetzt nur noch 28 Sekunden, ist aber im Vergleich zur Shell immernoch 9-10mal langsamer. Irgendwo werden intern (perl) scheinbar irgendwelche limits gesetzt, wenn ein Systemcall gemacht wird.
Allerdings sind die ulimits in der Shell die gleichen wie unter Perl.

Somit hab ich jetzt immernoch das gleiche Problem wie vorher und komm einfach nicht weiter :(

Grüße

PS: Der erste if-Block ist natürlich völliger Käse, das ist mir jetzt dann auch mal so richtig aufgefallen ;)
Last edited: 2010-11-03 09:23:35 +0100 (CET)
- +2 replies
- Gast equinox
  
  2010-11-03 13:09
  
  Moin,
  
  Ich habs *endlich* nach 2 Tagen rausgefunden.
  
  Grund für das lahme grep war (und da wärst Du nun leider nie draufgekommen, weil ich das Testszenario nicht gut genug beschrieben hab - shame on me), dass beim connect via SSH auf dem remote host LC_ALL und LANG auf en_US gesetzt wurden. Blöderweise affektiert das 'grep', welches dann utf8 lesen will.
  Bei den Tests die (lokal auf dem remote host) schnell durchliefen waren LC_ALL und LANG allerdings auf C gesetzt.
  
  => Problem gelöst, 2 Tage Zeit verplempert und wieder was gelernt.
  Trotzdem danke fürs helfen ;)
  
  Grüße
  equinox
  Last edited: 2010-11-03 13:20:34 +0100 (CET)
  - GwenDragon
    
    2010-11-06 14:47
    
    User since
    2005-01-17
    14546 Artikel
    Admin1
    
    Gibt es denn noch Linux-Systeme, die nicht systemweit im Encoding auf UTF8 eingestellt sind?
    die Drachin, Gwendolyn
    
    Unterschiedliche Perl-Versionen auf Windows (fast wie perlbrew) • Meine Perl-Artikel
- topeg
  
  2010-11-03 13:33
  User since
  2006-07-10
  2611 Artikel
  BenutzerIn
  schreibe die Stelle:
  
  Code (perl): (dl )
  
  1 2 3 4 5
  
  elsif ($pid == 0) { my $cmd = '/bin/zgrep -E " '.$method_string.'.* HTTP/[0-9]\.[0-9]\" [23][0-9]{2}" '.$_." 2>/dev/null"; print `$cmd`; exit(0); }
  
  mal so:
  
  Code (perl): (dl )
  
  1 2 3 4
  
  elsif ($pid == 0) { exec('/bin/zgrep -E " '.$method_string.'.* HTTP/[0-9]\.[0-9]\" [23][0-9]{2}" '.$_." 2>/dev/null"); die(Fehler); }
  
  Und das warten auf die Kinder würde ich andres machen:
  
  Code (perl): (dl )
  
  1 2 3 4 5
  
  local $SIG{CHLD}=sub{ my $pid=wait(); delete($result->{$pid}) }; sleep 1 while(keys(%$result));
  
  Aber wie ich schon gesagte, du Quotest manches etwas durcheinander. An einigen Stellen braucht du die Anführungszeichen nicht zu entwerten und an anderer Stelle benutzt du doppelte Anführungszeichen obwohl Einfache besser währen. Wenn du das so machst musst du manche Quotes verdoppeln, damit sie auch in der Shell ankommen.
  Darum versuch ich das Quoten, wann immer möglich durch die passende Wahl der Anführungszeichen zu verhindern.

View all threads created 2010-11-01 12:37.