xargs -n5 tool.pl < hosts.txt
[download]

G'day sunil9009,

You can do that like this:

#!/usr/bin/env perl

use strict;
use warnings;
use autodie qw{:all};

my $hosts = 2;
my $tool = 'echo';

my @cmd = ($tool);

while (<DATA>) {
    chomp;
    push @cmd, $_; 

    if ($. % $hosts == 0) { 
        system @cmd;
        @cmd = ($tool);
    }
}

system @cmd if @cmd > 1;

__DATA__
host1
host2
host3
host4
host5
[download]

Output:

host1 host2
host3 host4
host5
[download]

Pass the host file name to the Perl script on the command line as an argument. Change the script so that within it you open the host file (by name) and read n 'host' names at a time and process them. You might even make n an argument to the script along with the file name.

undef $/;
my @args = split /\n/, <DATA>;
for(my $idx=4;$idx<@args+4;$idx+=5){
    print join(" ", @args[$idx-4..$idx]), "\n";
}

__DATA__
host1
host2
host3
host4
host5
host6
host7
host8
host9
host10
host11
host12
[download]

Is there any advantage of not calling your tool simply 12 times with a single hostname each time?

Another way would be to grab five lines at a time from your input. The &groupsOf subroutine runs the code block given as the first argument on however many items at a time, second argument, of the third and subsequent arguments which in the code below are the lines of the input file. Given this tool:-

$ cat spw1081756tool.pl
#!/usr/bin/perl
#
use strict;
use warnings;

use 5.014;

say qq{$0 \@ARGV ->@ARGV<-};
$
[download]

Running this code:-

use strict;
use warnings;

use 5.014;

sub groupsOf (&$@);

open my $hostsFH, q{<}, \ <<EOD or die $!;
host1
host2
host3
host4
host5
host6
host7
host8
host9
host10
host11
host12
EOD

groupsOf {
    system q{spw1081756tool.pl}, map { chomp; $_ } @_;
    } 5, <$hostsFH>;

close $hostsFH or die $!;

sub groupsOf (&$@)
{
    my $rcToRun  = shift;
    my $groupsOf = shift;

    my $rcDoIt;
    $rcDoIt = sub
       {
           return $rcToRun->(
              map shift,
                 1 .. do {
                     my $elems = scalar( @_ );
                     $groupsOf < $elems ? $groupsOf : $elems
                     } ),
           @_ ? &$rcDoIt : ();
       };
    return &$rcDoIt;
}
[download]

Gives this output:-

./spw1081756tool.pl @ARGV ->host1 host2 host3 host4 host5<-
./spw1081756tool.pl @ARGV ->host6 host7 host8 host9 host10<-
./spw1081756tool.pl @ARGV ->host11 host12<-
[download]

I hope this is helpful.

Re^2: reading several lines in a gulp (iterator)

Employing list utils:

use List::MoreUtils 'part';

chomp(@$_), system("echo", @$_) for (part {$i++/5} <>);
[download]

awesome!! Thanks a ton hbm@ for so simple and easy solution. I underestimated the power of splice.

Can I have some simple solution. Something like this ? Its not working though. Dont know why

#!/usr/bin/perl -w

use strict;
use warnings;

open(my $fh, '<', '/tmp/list') or die "Unable to open file, $!";

my @entire_file=<$fh>;
for my $i (0..$#entire_file) {
my @group;
push @group,$entire_file[$i]  until ( $i % 5 == 0 );
`tool.pl @group`;
}
[download]

#!/usr/bin/perl
use strict;
use warnings;
open my $fh, '<', 'list.txt' or die $!;
chomp(my @hosts = <$fh>);
close $fh;

while (my @five = splice @hosts, 0, 5) {
   print qq{command @five\n};
}

# prints:
command host1 host2 host3 host4 host5
command host6 host7 host8 host9 host10
command host11 host12
[download]

'until' starts an infinite loop when $i == 1