A do-while loop should do the job without the goto:

my $output;
my $tries = 0;
do {
  $output = `expect -f show_running_config.exp $router->[$IP]`;
  if($?){     # subshell returns error
    $tries++; # count a try
    sleep 5;  # pause
  }
} while( $? and $tries < 4 ); # loop again if error and more tries
           # was the last try unsuccessful?
if($?){    # last try was an error, ran out of tries
  print "Unable to connect after $tries tries\n";
  exit;
}
# go on to handle the response in $output
[download]

Thanks, I didn't think of that. Works great.

Not only can you use a while loop but you can also use goto in a better way. Perl has two distinct forms of goto. The first (as you are doing here) is a classic goto. Just a jump, all state preserved, messy. Don't do it.

The second is a tail call form. If you goto &sub it leaves the current stack frame and re-enters with the existing values of @_ re-aliased. This means you have clean scope. This is very useful for retries. So in this case we could:

for my $router (@routers) {
    get_config($router, 0);
}

....

sub get_config {
    my ($router, $retries) = @_;
    my $output = `expect -f show_running_config.exp $router->[$IP]`;
    die "Failed to get config for $router->[$NAME] at $router->[
+$IP]: $output\n" if $retries > 3 and $?;
    unless ($?) {
        sleep 5;
        $_[2] = $_[2] + 1;
        goto &get_config;
    return write_config($output, "$router->[$NAME].cfg");
}
[download]

Here goto gives you an effective restart condition, but with a clean state (i.e. all locally scoped variables, such as $output get cleared on each retry. It is very nice in the sense it gives you a clean restart on the function without the extra stack overhead (though since you are only retrying 5 times, recursion may be another option).

Hmmm. I guess this probably works well, but this form of goto is somewhat magical, I am not sure it should be advised to someone probably not understanding the details and, more broadly, for such a simple task, where a while loop or a simple recursive call would do as well.
Je suis Charlie.

I think it seems magical because it isn't really a goto. I see why Perl 6 is changing it to &sub.nextwith(). It would be nicer IMO if it had been given its own keyword like tailcall().

# refactor each $router to have a 'success' key of 0;
# running this way allows you to iterate through the 
# entire list of routers, dealing with failures only
# after the entire stack has been processed.  
# assuming a sufficient number of targets, this should
# sidestep your problem as I understand it.  
for (my $i = 0; $i++; $i < 3) {
  my $failures = 0; 
  foreach my $router (@routers) {
    if ($router->{'success'} != 1) {
      my $output = `expect -f show_running_config.exp $router->[$IP]`;
      if (write_config($output, "$router->[$NAME].cfg") == 0) {
        $router->{'success'} = 1;
        $router->{'msg'} = "Output was $output";
      } else {
        $failures++;
        $router->{'msg'} = "Failed to get config for $router->[$NAME] 
+at $router->[$IP]: $output\n";
        if ($i == 2) {
          print $router->{'msg'};
        }
      }
    }
  }
  if ($failures < 1) { last; }
  sleep 5;
  $i++;
}
[download]