eval {
  CODE WHAT TO DO || die;
};
print $@;
[download]

Just a question to your SIG{__DIE__}: Is this the same like an END{} Block ?

UPDATE: added a ; behind the eval block ;-)

-----------------------------------
--the good, the bad and the physi--
-----------------------------------
[download]

Just a question to your SIG{__DIE__}: Is this the same like an END{} Block ?

END happens after the die..

#!/usr/bin/perl -w

$SIG{__DIE__} = sub { print "Dead\n"; };

die "Blah";

END {
    print "This is the end, my friend.\n";
}
[download]

Outputs:

Dead
blah at ./foo.pl line 5.
This is the end, my friend.
[download]

But, you need to define the SIG before you use it. The END will happen regardless. For example:

#!/usr/bin/perl -w

die "Blah";

$SIG{__DIE__} = sub { print "Dead\n"; };

END {
    print "This is the end, my friend.\n";
}
[download]

Will output:

Blah at ./foo.pl line 3.
This is the end, my friend.
[download]

Cheers,
KM

This is what I do and what I usually find. Note, however, that $@ is the only help you get about what failed. eval retuns undef if it died. That means you have to parse $@ to find out why it died (useful if it was a system event that killed it), or you can set a package or global variable to tell you why it died. I tend to do the latter whenever possible.

traveler

Try to put yout Net::FTP part into an eval block:

eval {
  CODE WHAT TO DO || die;
};
print $@;
[download]

Thanks, that's exactly what I needed! The Net::FTP code was actually dieing (I didn't call die) so I needed to trap the die and verify that it died because it was timing out. Putting the call to "Net::FTP->get()" in an eval block let me trap that. I didn't know I could do that with eval. Now I just need to look at $@ to see if the Net::FTP Timeout is there. Thanks again!

As for your question about SIG(__DIE__), KM's response basically sums it up. The END block gets executed last and no matter what caused the script to end. However, when the script dies, I want to know so I can do some extra clean up (log the errors, close files, etc) that doesn't need to happen when the script executes normally.

Update:

Added a ; after eval block. :-)

ChOas

I had something similar once. My answer wasn't awfully pretty, but it worked. I wrapped each step into its own function, and had each sub return a unique error code upon failure instead of dying. One sub would return 12, another would return 8, etc. The main code in the program would then be able to handle each error condition as it happened, knowing exactly what blew up.

Just try to keep the sub calls out of loops if you don't want to eat too many cycles.

sub get_files {
    # ftp files from remote server

    while (1) {
                $ftp = Net::FTP->new("$From_Host", Debug => 0);
                $ftp->login("$From_User","$From_Pass") || do { &print_
+ftp_error; redo; };
                $ftp->cwd("$From_Dir");
                (@dir_files = $ftp->dir) || do { &print_ftp_error; red
+o; };
                $ftp->quit;
                last;
    }

sub print_ftp_error {
    # Error handling proc

    $save = $ftp->error;
    $ftp->quit;

    print STDERR "ftp error: $save\n";
    print_to_log("ftp error: $save\n");

    if (++$ftp_errors{"$save"} >= $Max_ftp_Errors) {
                print STDERR "\n\nExceeded maximum number of ftp error
+s. Exiting!!!\n";
                print_to_log("\n\nExceeded maximum number of ftp error
+s. Exiting!!!\n");
                system("$Notify_Proc \"ftpfiles.pl Exceeded maximum nu
+mber of ftp errors. Please check $Log_File.\" 2>&1 > /dev/null");
                rename "$Log_File", "$Log_File.$year.$mon.$mday\_$hour
+.$min";
                exit 1;
    } else {
                #
                # Give the ftp server a 60 second grace period to get
                # it's act together.
                #
                sleep 60;
        }
}
[download]

birdbrane

That's very similar to what I needed to do. Thanks for posting the snippet! I think I'll incorporate this idea into my script. I've got a "download_file" sub similar to your get_files so it should be a fairly easy fix. That seems much easier than trapping "die", etc. Although, I must admit that in working on this and reading the replies here I've learned *a lot* about perl that I didn't know two days ago! ;-)

--RT