CODEWITHSUNDEEP
perl
rpg
rpg

Reputation: 1652

Is it ok to use Attribute::Handlers for implementing retry logic

Is it ok to use Attribute::Handlers for implementing retry logic

I have almost 50+ subroutine like verifyXXXX. I need to implement the retry logic for all these subs. I want to write this retry logic where the sub is actually implemented. If the return value of sub is false/undef then it will retry again.

subs will be called in regular way, so that the caller will not know about the retry logic, something like.

verify_am_i_doing_good()
    or die('sorry you are not doing as expected.');

verify_am_i_fine()
    or die ('sorry you are not find.');

: :

the actual implementation of these functions is something like this in the package.

use Attribute::Handlers;

use constant RETRY_LIMIT => 4;
use constant RETRY_DELAY => 2;

sub verify_am_i_doing_good : __retry
{
    return 1 if ($x == $y);
    return;
}

sub __retry : ATTR(CODE) {
    my ($pkg, $sym, $code) = @_;

    my $name = *{ $sym }{NAME};
    no warnings 'redefine';

    *{ $sym } = sub
    {
        my $self = $_[0];
        my $result;

        logMsg (INFO, "Executing subroutine $name with retry limit " . RETRY_LIMIT);
        for (my $retryCount = 1; $retryCount <= RETRY_LIMIT; $retryCount++)
        {
            logMsg (INFO, "Executing subroutine $name with retry count $retryCount");
            my $result = $code->( @_ );
            if ($result)
            {
                logMsg (INFO, "Expected result observed in retry count $retryCount");
                return wantarray ? @$result : $result;
            }
            else
            {
                logMsg (INFO, "Expected result is NOT observed in retry count $retryCount");
                logMsg (INFO, "Retrying again by updating uixml");

                sleep RETRY_DELAY;
                $self->updateState();
            }
        }
        logMsg (WARN, "Failed to verify expected result for subroutine $name with retry limit " . RETRY_LIMIT);
        return;
    };
}

The reason to use Attribute::Handlers, inplace of Attribute::Attempts is that in the case of failure, I need to call another subroutine updateState() before retrying (re-executing) the subroutine.

I got this idea of writing the retry logic from following post http://www.perl.com/pub/2007/04/12/lightning-four.html

My main concern is that since I am using this __retry attribute for almost 50+ subs. Is it a good practice to do in this way or is there anything simple I can do?

You help will be highly appreciated.

Upvotes: 2

Views: 174

Answers (1)

Axeman
Axeman

Reputation: 29854

You don't need attributes to do a sub wrapper. There was Memoize long before there was Memoize::Attrs (or Attribute::Memoize for that matter). You can just take a look at how Memoize handles it.

Quite recently, I was writing some Perl for functions called in another interface. All the arguments passed to the Perl function from this interface would be passed in a funky-but-universal format used by my division. Rather than deal with this everywhere, I wrote a logic wrapper like so 

sub external (@) {
    my ( $subname, $code ) = @_;
    ...
    my $wrapped 
        = sub { 
            my $count = 5;
            while ( --$count and not my @results = &$code ) { 
                adjust_stuff();
            }
            return @results;
        };
    {   no strict 'refs'; # my special "no-block"
        *$subname = $wrapped;
    }
    return;
}

And used it like this (some people don't like this use of the "fat comma")

external something_I_want_to_do => sub {
    my @regular_old_perl_args = @_;
    ...
};

The prototype (@) helps a sub act as an operator and need not always be called with parenthesis.

But by all means if you like method attributes and it works and you can get it not to bite you, use them. But you don't have to. You should probably read up on the caveats though.

Upvotes: 2

Related Questions