Or perhaps there's a different reason.

Before we launch into round n+1, please tell us why the various solutions that have been proposed do not work for you. It would seem straightforward for a novice Perl programmer to extend them to deal with the requirements you've laid out. Which have you tried? How did they fail?

That said, I'm still concerned that may be taking a bad approach to this problem, for reasons I laid out in a previous response. I've dealt with systems that assigned support "tickets" to agents. Strict round-robin doesn't work at all well.

you've been going in circles here asking the same question (albeit slightly refined) over and over, airblaine. this is tiresome. please post some code and stop wasting our time by inventing yet another solution for you.

that said, i'll give you some advice-- first break your problem down into smaller problems, and solve each seperately. then put them together to form the whole. suggestions for smaller problems include:

move a file
select a directory
store state information

~Particle *accelerates*

#!/usr/bin/perl

use strict;
use warnings qw /all/;

# Program picks up files in one directory, and moves them round robin
# to a set of other directories.
# It's required to keep track of directory a file was moved to last.
    
use Fcntl qw /:DEFAULT :flock :seek/;

my $pickup   = "/tmp/main";
my @targets  = map {"/tmp/target/$_"} qw /dir1 dir2 dir3 dir4 dir5 dir
+6/;
my $state    = "/tmp/state";


# Open the state file for read/write, creating it as necessary.
sysopen my $state_h => $state, O_RDWR | O_CREAT, 0666
     or die "Failed to sysopen $state: $!\n";

# Lock the file exclusively. This has the additional effect no other
# invokation will try to move the same files we do.
flock $state_h => LOCK_EX or die "Failed to flock $state: $!\n";
    
# Read the state. If the file didn't exist, this will return undef.
my $last_dir = <$state_h>;
 
# If defined, chomp, and rotate the target directories until we found
# the directory the last file was written to. If not defined, roll one
# directory in the opposite direction.   
if (defined $last_dir) {
    chomp $last_dir;
    push @targets => shift @targets while $last_dir ne $targets [0];
}
else {
    unshift @targets => pop @targets;
}

# Open the pickup directory and read its content.
opendir my $pickup_h => $pickup or die "Failed to opendir $pickup: $!\
+n";
my @files = grep {$_ ne "." && $_ ne ".."} readdir $pickup_h;
closedir $pickup_h;

# For all the files to be moved, roll the target directories so we get
# the next one, and then move the file to the destination. We're assum
+ing
# we work on the same file system and we can use 'rename'.
foreach my $file (@files) {
    push @targets => shift @targets;
    rename "$pickup/$file" => "$targets[0]/$file"
        or  die "Failed to rename $pickup/$file\n";  
}

# Record the last directory we wrote into, and close the file;
# closing the file will release the lock.
seek  $state_h => SEEK_SET, 0 or die "Failed to seek $state: $!\n";
print $state_h $targets [0], "\n";
close $state_h or die "Failed to close $state: $!\n";

exit;
[download]

If your program is the only one writing to these dirs, you can sort them by mtime, as you can for files that appear in /main:

my @dirs = ('/dir1/', '/dir2/', '/dir3/', '/dir4/', '/dir5/', '/dir6/'
+,);

my @newfiles = sort {-M $b <=> -M $a} grep {-f } glob("/main/*");
my @seq = (sort {-M $b <=> -M $a} @dirs) x int( 1 + @newfiles/@dirs);

for (@newfiles) {
    my $status = system '/bin/cp', '-f', $_, shift @seq;
    die 'Copy failed for ', $_, ': Child Error ', $?, $! if $status;
    unlink $_ unless $status;
}
[download]

After Compline,
Zaxo

use File::Copy;
@dirs=qw(FullPathToDir1 FullPathToDir2  etc);
while(1){
    $dir="FullPathToMain";
    opendir(MAIN,$dir) or die "Can't open $dir:$!";
    while(defined($file = readdir MAIN)){
        next if $file =~/^\.\.?$/;
        $path=$dir.$file;
        $newdir=@dirs[$i];
        move($path,"$newdir$file") or die "move failed:$!";
        $i++;
        undef $i if ($i>$#dirs);
    }
}
[download]