• Willkommen im Linux Club - dem deutschsprachigen Supportforum für GNU/Linux. Registriere dich kostenlos, um alle Inhalte zu sehen und Fragen zu stellen.

[SOLVED]Ausgabe aller Variablen im Perl Debugger

Hallo Forum!

Ich habe folgendes Problem.
Wir haben von einer Firma Perl Scripte bekommen, die Nagios Abfragen initialisieren.
Diese Scripte sind unglaublich lange und so verschachtelt, dass man sich damit vermutlich wochenlang auseinandersetzen muesste, um herauszufinden, was eben gerade geschieht.
Das Problem an dem Script ist, dass es nur "Found error:" zurueckliefert; wir aber wuerden es gerne so umschreiben, dass die komplette Zeile vom Log-File ausgegeben wird.

Die checkcommands.cfg sieht so aus:

Code:
command_name orclog_probe_bhs_warn
command_line    /ITdesign/plugins/itd_check_value.pl -h $HOSTADDRESS$ -s $SERVICEDESC$ -Cmd 'tail -10 /usr/orc/log/$ARG1$.log |grep -c $ARG2$' -q "" -t ssh -w gt0 -c OFF -OkText 'Nothing found in log.' -WarningText 'Found $ARG2$ in the last 10 lines!'
}

Jetzt habe ich versucht das Perlscript durchzugehen im Debugger, jedoch half mir das nicht weiter, nun wollte ich mir vll. alle Zustaende der Variablen ausgeben lassen, aber es scheint sowas nicht zu geben!
Weiss jemand vll. eine anderen Moeglichkeit, um die Zustaende und Werte der einzelnen Variablen sich ausgeben zu lassen?

Um einen kurzen Abschnitt herzuzeigen aus dem Script:

Code:
use strict;
use Data::Dumper;

# include WATCH IT libraries
use lib '/ITdesign/lib';
use Variables;
use CommandLine;
use MacroHandler;
use FileOperations  qw ( ReadCsvFile );
use PluginFunctions qw ( ExitPlugin mcompare );
use CommonFunctions qw ( normalize );
use Communication   qw ( ExecuteCommand GetMrtgData SnmpGetV1 );
use CommonFunctions qw ( GetCurrentTimeStamp GetTimeDifference );

my $grefaLines = [];# lines from PIPE or CMD
my $gFoundLines;    # found lines in $grefaLines
my $grefhMacros;    # Macros e.g. $RUNTIME, $EXITCODE
my $grefhOutput;    # what we write to CSV or STDOUT or into mcompare
my $gIFS=',';
my $gOFS=',';

# no data from anywhere - print help and exit
$grefhOpt->{help} and exit system ("$refhPath->{RelBin}/doc.pl $0");

defined $grefhOpt->{MacroPfx}   or  $grefhOpt->{MacroPfx} = '@';
defined $grefhOpt->{NL}         or  $grefhOpt->{NL} = '<br>';
defined $grefhOpt->{k}          or  $grefhOpt->{k} = 'KWCounter';

my $gDebug          =   "$grefhOpt->{Debug}";

# set field seperator if indicated by the commandline
defined $grefhOpt->{IFS} and $gIFS = $grefhOpt->{IFS};
defined $grefhOpt->{OFS} and $gOFS = $grefhOpt->{OFS};

# undef if options are empty
$grefhOpt->{Comp}   eq "" and undef $grefhOpt->{Comp};
$grefhOpt->{q}      eq "" and undef $grefhOpt->{q};

# generate structure for csv file and exit
my $refhStruct = {
    KeyWord             =>  "$grefhOpt->{k}",   # required parameter
    Host                =>  "$grefhOpt->{h}",   # required parameter
    Service             =>  "$grefhOpt->{s}",   # required parameter
    Query               =>  "$grefhOpt->{q}",   # required parameter
    UnknownExit         =>  "$grefhOpt->{UnknownExit}",  # optional
    UnknownText         =>  "$grefhOpt->{UnknownText}",  # optional
    Passive             =>  "$grefhOpt->{Passive}",      # optional
    Debug               =>  "$gDebug"                    # optional
};
.
.
.
#-------------------------------------------------------------------------
# set default text values
#-------------------------------------------------------------------------
sub SetExitText {

    # set default text
    if (defined $grefhOpt->{Text}) {
        $grefhMacros->{Text} = "$grefhOpt->{Text}";
    } else {
        if ("X$grefhMacros->{QUERY}" eq "X") { # no -q ... nubers
            $grefhMacros->{Text} = "Value: $grefaLines->[0]";
        } else {
            $grefhMacros->{Text} = "\"$grefhOpt->{q}\" matches in ".
                HandleNFMacro ()." line(s)";
        }
    }

    if ($grefhOutput->{ExitCode} == $STATE_OK and
        defined $grefhOpt->{OkText}) {
        $grefhMacros->{Text} = "$grefhOpt->{OkText}";
    } elsif ($grefhOutput->{ExitCode} == $STATE_WARNING and
        defined $grefhOpt->{WarningText}) {
        $grefhMacros->{Text} = "$grefhOpt->{WarningText}";
    } elsif ($grefhOutput->{ExitCode} == $STATE_CRITICAL and
        defined $grefhOpt->{CriticalText}) {
        $grefhMacros->{Text} = "$grefhOpt->{CriticalText}";
    } elsif ($grefhOutput->{ExitCode} == $STATE_UNKNOWN and
        defined $grefhOpt->{UnknownText}) {
        $grefhMacros->{Text} = "$grefhOpt->{UnknownText}";
    }

    return $grefhMacros->{Text};
}

Mich wuerde gerne interessieren, ob der Debugger in die Subroutine SetExitText kommt, was bisher in den einzelnen Durchlaeufen nicht so zu scheinen mag!

Ich habe schon folgende Sachen versucht im Debugger:

X, x, s, n, V, v -> Leider alles ohne Ergebnis der einzelnen Variablen zum Zeitpunkt des Aufrufes!

Danke fuer jede Hilfe!
 
Ich glaube, in
Code:
perldoc perldebtut
steht dazu was unter "Looking at data and -w and v".

Gruß

P.S.:
Wir haben von einer Firma Perl Scripte bekommen, die Nagios Abfragen initialisieren. Diese Scripte sind unglaublich lange und so verschachtelt, dass man sich damit vermutlich wochenlang auseinandersetzen muesste, um herauszufinden, was eben gerade geschieht.
Tja, das wäre genau der Hauptvorteil von Python gegenüber Perl, daß der Code besser zu durchschauen wäre ...
 

framp

Moderator
Teammitglied
Ein jeder Programmierer baut debug Statements in seinen Code ein. In den Snippets von Dir ist auch zu sehen dass dort debug-Möglichkeiten enabled werden können. Sie mal das genauer an wie Du das enablen kannst.
 
Hallo!

Danke Euch vielmals!
Ich werde es mir gleich ansehen.
Tja, haette man den Leuten frueher sagen muessen, dass sie es besser in Python schreiben sollten :).
Perl mag ich zwar persoenlich sehr, aber "write once, run once" trifft hier leider zu.
Meinen eigenen Code schaffe ich manchmal nicht mehr zu lesen nach nur ein paar Wochen!
 
... dann findest Du bestimmt auch das hier noch ganz lustig:

http://www.python.org/doc/humor/#python-vs-perl-according-to-yoda

:lol:

Gruß
 
Cool :)
Obwohl ich sicherlich keine 6 Monate benoetige, um meinen Perl Code nicht mehr zu verstehen, das geht sicherlich auch in 6 Tagen :)
und zu meiner Schande habe ich mir nun Perl 6 (Objektorientiert) bestellt.
War der Meinung, dass muss ich mir mal unbedingt reinziehen, haette ich doch lieber mit Python angefangen!
Aber man sollte die Eigenheiten einer Sprache schon in und -auswendig kennen denke ich mir, um dann zur naechsten Sprache ueberzugehen!
 
Prima. Wenn Du Perl kennst, und Dich Python näher interessiert, können Dir vielleicht meine Seiten beim Einstieg helfen:
Auf meiner Perl-Seite habe ich ein paar grundlegende Sachen gezeigt:

http://www.angelfire.com/linux/tux25/perl/perl.html

und ziemlich genau dieselben Sachen in Python:

http://www.angelfire.com/linux/tux25/python/python.html

Das kann man dann recht einfach vergleichen (bitte JavaScript ausschalten, da kostenloser, werbefinanzierter Webspace). Die Python-Seite hab' ich übrigens zuerst geschrieben; in etwa dasselbe für Perl zu erklären, war deutlich schwieriger ($_ usw.).

Eigentlich mag ich Perl auch sehr, aber ich komme jedesmal um Pythons Vorteile nicht herum.

Viele Grüße
 
Danke Dir vielmals für die Links!
Python Bücher habe ich eh schon seit 2 Jahren ca. :)
Aber leider nie dazu gekommen einen Blick reinzuwerfen oder mehr als einen Blick.
Aber ich muss mir eh eine neue Sprache suchen, und da bittet sich im Moment eh nur Python an.
Programmiersprachen suche ich auch dann für später, im Moment kann ich nur C ein wenig, Java, ABAP und Cobol.
Wobei mir COBOL und ABAP taugen :)
Ob da C++ noch was bringt?
 
Ob da C++ noch was bringt?
Kommt natürlich drauf an, wofür. Mir ist C/C++ im allgemeinen zu stressig, mit Skriptsprachen bin ich als kleiner Einzelprogrammierer produktiver.
Aber Perl6 sieht auch ganz interessant aus. Du schriebst, Du habest es bestellt ? Wird es nicht OpenSource ?
Objetkorientierte Programmierung gibt es natürlich auch in Perl5:
Code:
perldoc perlboot
perldoc perltoot
Nur ist das halt etwas unschön und unübersichtlich. Z.B. in Python:
Code:
#!/usr/bin/env python

class Lamp:

    def __init__(self):
        self.status = "off"

    def switchOn(self):
        print "Click. Light."
        self.status = "on"

    def switchOff(self):
        print "Click. Darkness."
        self.status = "off"

    def printStatus(self):
        print "The lamp is " + self.status + " now."

mylamp = Lamp()

mylamp.printStatus()

mylamp.switchOn()

mylamp.printStatus()

mylamp.switchOff()

mylamp.printStatus()
und in Perl:
Code:
#!/usr/bin/perl -w
use strict;

package Lamp;

    sub new
    {
       my $Lamp = shift;
       my $self = {};
       $self -> {s} = 0;
       print "A lamp appears.\n";
       return bless $self, $Lamp;
    }

    sub on
    {
        my $self = $_[0];
        $self -> {s} = 1;
        print "Lamp is on.\n";
    }

    sub off
    {
        my $self = $_[0];
        $self -> {s} = 0;
        print "Lamp is off.\n";
    }

package main;

my $myLamp = Lamp -> new();

$myLamp -> on();
print $myLamp -> {s} . "\n";

$myLamp -> off();
print $myLamp -> {s} . "\n";
Aber wohl die meisten Perl-Module wie "Tk" setzen auch jetzt OOP ein.

"say" statt "print" finde ich in Perl6 allerdings etwas peinlich. "say" bezieht sich bei mir seit Amiga-Tagen auf "Text-to-speech". Da ist Pythons "print" wesentlich eleganter, und es kommt ebenfalls ohne "\n" aus.

Viele Grüße
 
Ja, ich hab mir ein Perl 6 Buch bestellt.
Ich tue mir leichter, wenn ich es "in der Hand" halten kann, anstatt alles am Bildschirm lesen zu müssen.

Also das say sieht wirklich grausig aus in Perl 6.
Aber ich dachte mir, objektorientiertes Perl ist sicher auch nicht schlecht zu kennen.
Zudem verlangen es viele Arbeitgeber nun.
Python sieht von seiner Syntax her wirklich schöner aus, dass muss ich zugeben.

Naja, sobald ich Zeit finde, werde ich auch Python dazulernen!

Java an sich gefällt mir auch, aber man muss, um ein kleines Problem lösen zu können, viel Schreibaufwand an den Tag legen, das gefällt mir wiederum nicht (auch wenn die Sprache per se für grössere Projekte gedacht ist!).
Ich programmiere lieber nach Lust und Laune in den verschiedenen Sprachen herum!

Viele Grüsse!
 
Oben