Looks to me like someone may have made a couple of (bad?) simplifying assumptions:

1. That there will always be exactly 3 salespeople available to service requests
2. That all customer service messages are equivalent in terms of complexity
3. That each salesperson services equivalent requests at the same rate

The approach you're taking hard-codes these assumptions.

Wouldn't it be better to provide a queue that the salespeople could take the next request from? That would let the salespeople load balance amongst themselves, and would still provide management metrics (e.g., the rate at which different salespeople absorb requests).

• read salesman's directory number from disk
• route STDIN to a file
• increment the directory number and write to disk

akira:~$ cat .forward
|myproc.pl

akira:~$ cat myproc.pl
#! /usr/bin/perl -w
$fh = die "read that node more carefully!" # your to-do. load it from 
+a file.
open FH, ">>$fh" || die $!;
while (<STDIN>){
    print FH $_;
}
close FH;
# now alter whatever's in $fh, and save it to disk.
[download]

use strict;
use File::Find;

# plug your own value here
$rotate_dir = '/share/files/rotate';
$move_timeout = 5*60; # 5 minutes.

my %files;

while (1) {
  # find files that have to be rotated
  my @rotate;
  find(\&wanted, $rotate_dir);
  rotate();
}

sub wanted {
  if (exists $files{$File::File::name}) {
    # alright, we saw it before.. so, has it's
    # time come to move?
    push @rotate, $File::File::name 
      if ($files{$File::File::name} < time - $move_timeout);
  }
  $files{$File::File::name} = time;  
}

sub rotate {
  # "I know, I don't have to use global vars, I KNOW!" ;)
  for (@rotate) {
    my $new_path;
    if (m|/main/|) { # initial spot
      $new_path = $_;
      # drop it to the first sale rep's directory
      $new_path =~ s|/main/|/dir_1/|;
    } else {
      # retrieve sales person's id
      my ($sales_id) = ($_ =~ m|(\d+)/$|);
      my $new_id = $sales_id + 1;
      $new_dir =~ s|$sales_id/|$new_id/|;

      # drop to main directory if next sale's rep
      # id isn't valid (exists)
      $new_dir = 'dir/main'
    unless (-d $new_dir); 
    }

    # move to that new directory...
  }
[download]

$"=q;grep;;$,=q"grep";for(`find . -name ".saves*~"`){s;$/;;;/(.*-(\d+)
+-.*)$/;
$_=["ps -e -o pid | "," $2 | "," -v "," "];`@$_`?{print"+ $1"}:{print"
+- $1"}&&`rm $1`;
print$\;}
[download]

So, paraphrasing your problem specification, I get this:

1. Rotate files from dir_1 to dir_2 every 5 minutes.
2. Rotate files from dir_2 to dir_3 every 5 minutes.
3. Rotate files from dir_3 to dir/main every 5 minutes.
4. and so on.


i don't think this is the problem statement. i think it's more like:

1. file arrives in main directory.
2. move file to one of three directories, alternate between dir_1, dir_2, dir_3

i could be wrong, of course.

~Particle *accelerates*

Close...It's tough for me to explain and even tougher for me to figure it out! It's more like this...

1. Rotate files from dir/main to dir_1 next 5 minutes. 
2. Rotate files from dir/main to dir_2 next 5 minutes. 
3. Rotate files from dir/main to dir_3 next 5 minutes.  
4. start at 1. again (loop)
[download]

use File::Copy;

## set up directories
my $in_dir = '/dir/main';
my @xfer_dirs = qw! /dir/dir_1 /dir/dir_2 /dir/dir_3 !;

## list of files in $in_dir 
my @infiles;

## pick a random dir to start
## so salesperson 1 doesn't get more mail when the job restarts
my $xfer_dir_index = int rand @xfer_dirs;

{
  ## create a directory handle
  local *DH;
  ## open the directory
  opendir( DH, $in_dir ) or die "ERROR: $0 - can't open dir $in_dir - 
+$!";
  ## get a list of files
  @infiles = grep { /^\./ && -f "$in_dir/$_" } readdir(DIR);
  ## close the directory
  closedir DH;
}

for @infiles
{
  ## move the file
  move( 
    $in_dir . '/' . $_, 
    $xfer_dirs[$xfer_dirs_index] . '/' . $_ 
  );
  ## cycle the directory index
  $xfer_dir_index++
  $xfer_dir_index %= @xfer_dirs;
}

## sleep
sleep(300);
[download]

~Particle *accelerates*

while(1){
  `mv /dir/main/* /dir_1`
  sleep(300);

  `mv /dir/main/* /dir_2`
  sleep(300);

  `mv /dir/main/* /dir_3`
  sleep(300);
}
[download]

@dirs = ("/dir_1","/dir_2","/dir_3");
while() {
  sleep{300);
  mv /dir/main/ $dir[$i++%3];
}
[download]