I suggested a $File::Find::prune approach in the chatterbox, but now I wonder whether readdir() together with -f wouldn't be better (untested):

  opendir DIR, "/";
  my @files = readdir DIR;
  closedir DIR;
 
  @files = grep { -d "/$_" } @files;

  my $dirname;
  foreach $dirname @DIR {
    if (-f "/$dirname/foo.bar") {
      print "$dirname has foo.bar\n"
    };
  };
[download]

bydepth just means to process the contents of a directory before processing the directory itself. So for your example find . -depth -print (equivalent to setting bydepth) would print the following:

/user/user1/foo.bar
/user/user1
/user/user2
/user/user4
/user/user500/foo.bar
/user/user500
/user
[download]

/user
/user/user1
/user/user1/foo.bar
/user/user2
/user/user4
/user/user500
/user/user500/foo.bar
[download]

What you might be thinking of is a breadth-first search that looks at all nodes the same depth down before moving on. You can't do this with File::Find or find since it would need to keep a lot of state kicking around to remember where to go next. It also would not do what you need since it would still traverse all files.

What (I think) you want to tell it is to stop looking if it is more than 2 directories in. The following wanted function looks at the current directory name and tells the find to stop looking deeper if there is a / in it.

sub wanted {
    my $depth = $File::Find::dir =~ tr{/}{/};
    $File::Find::prune = 1
        if $depth == 1;
    print("$depth $File::Find::name\n");
}
[download]

BTW you said that it would check up to 2 gig of files, remember that it does not actually need to look at the contents of the files, just their directory information. So it is still expensive, but unless you have lots of small files, it should be much smaller than 2 gig.

-ben

my @files = grep { -f and /pattern/ } glob("/home/*/*/*");
[download]

@UserDirectorys = ();
opendir (DIR, "/user/");
  
  @UserDirectorys = grep {not /^(\.\.?)$/} // probably not the best wa
+y to do this
  readdir(DIR);
 
closedir (DIR);

foreach $USER ( @UserDirectorys ) {
@UserFiles = ();
opendir (DIR, "/user/$USER");
  
  @UserFiles =  readdir(DIR);
 
closedir (DIR);

# Search @UserFiles for files needed....
}
[download]

Update: File::Find even with the prune option seems to take way more time than this piece of code. I say "seems", b/c I canned the file::find version once it ran over the time of this code's benchmark.

Thanks (++) for all the help!

# Finds all of the thingtolookfor.txt across all servers and prints ou
+t a list 
# of those people that do not have them to log.txt

use strict;
use Benchmark;
my $t0 = new Benchmark;
my ($server,$usershare);
my $out='//mymachine/myshare/log.txt';
my @servers=('XXY','ZZZ','ETC');

open OUT,">$out";

foreach $server (@servers){
    my $dir1="//$server/c\$/chompy";
    # Check if chompy share is on $C or D$
    if (!(-e "$dir1")){#if directory doesn't exist try d$
        $dir1="//$server/d\$/chompy";
        if (!(-e "$dir1")){
            die "Directory not does not exist on $server\n...Exiting S
+cript.\n";
        }
    }

    # Read the user shares 
    opendir(DIR, $dir1) or die "can't opendir $dir1: $!";
    #weed out dots and get only dirs
    my @dirs = grep { !/^\./ && -d "$dir1/$_" } readdir(DIR); 
    closedir DIR;

    foreach $usershare(@dirs){
        my $userdir="$dir1/$usershare";
        if (!-e "$userdir/thingtolookfor.txt"){
            print OUT "$userdir:\tno\n";
            print "$userdir:\tno\n";
        }
    }
}
close OUT;

#benchmarking info
my $t1 = new Benchmark;
my $td = timediff($t1, $t0);

print OUT "The code took:",timestr($td),"\n";
[download]

-OzzyOsbourne