@farmLs = `ls -ltr /usr/local/farm/*/*/input/`;
[download]

It's always somewhat disconcerting when I see someone writing shell scripts inside their perl code ... I'm not sure where I first heard it, but the old saying that "you can write ForTran in any language" is just as true about any other seriously limited language (e.g., batch files or shell scripts)...

Especially when perl has the ability to do this already.

require File::Spec;
@farms = glob(
  File::Spec->catfile(
    qw(usr local farms * * input), "*$corp*"
  )
);
[download]

#!/usr/bin/perl
#
# This is a program that is intended to allow FEP operators
# a tool that will facilitate in monitoring incoming transmissions
# and preprocessor logs.
#
#------------------- Define Subroutines ------------------#

# lsForCorp Subroutine designed to take an argument and do a directory
# listing looking for that argument on the farm and then returning the
+ 
# results.

use strict;

sub lsForCorp {
  my $corp = $_[0];
  require File::Spec;
  my $path = File::Spec->catfile(
                                 File::Spec->rootdir(),
                                 qw(usr local farms * * input), "*$cor
+p*"
                                );
  my @farms = glob($path);
  foreach my $farm (@farms) {
      print $farm, "\n";
  } # end of foreach statement
} #end of lsForCorp subroutine


#------------------- End Subroutines ---------------------#

print "What corp are you looking for? " ;
chomp(my $whatWeWant = <STDIN>);
lsForCorp($whatWeWant);
[download]

Awesome, that is a good start... now if I get rid of the input and just have

qw(usr local farms * *), "*$corp*"
[download]

Will it do a recursive search through log, input, save, failed, etc? or will I have to make a seperate subroutine for each of those paths?

Also, would you be willing to do a small breakdown of what each line is actually doing (only the one's you changed, I should hope I know what the ones I wrote were doing) so I'm not just taking prefabbed code... I'd like to relearn this (I never really got far with perl in the first place, so I guess learn would be a better word than relearn)

Also, with glob, is there some way that I can get the date, time, and bytecount of the files being returned?

Here's some comments in-line:

# supersearch this one - short version: it detects most common coding 
+errors.
# always use it.
use strict;

sub lsForCorp {
  my $corp = $_[0];
# File::Spec allows you to create a directory structure in
# a platform-independant manner.  Not a big deal to you since
# this probably only runs on unix anyway, but all my code
# has to run on both unix and Windows, so it's just a
# habit.
  require File::Spec;
  my $path = File::Spec->catfile(
# this reconstructs the path - if you print $path, you'll
# see exactly the path you were using - again, no big deal
# if portability is unimportant (and "/usr/local" is not
# really portable either ;->)
                                 File::Spec->rootdir(),
                                 qw(usr local farms * * input), "*$cor
+p*"
                                );
# let glob do all the work rather than ls.  Besides, ls
# calls the same thing as glob under the covers, more or
# less.  (Technically, it's the shell.)
  my @farms = glob($path);
  foreach my $farm (@farms) {
# no if statement since the glob already only gets files that match
# *$corp*, which is the glob way of saying /\Q$corp/.
      print $farm, "\n";
  } # end of foreach statement
} #end of lsForCorp subroutine


#------------------- End Subroutines ---------------------#

print "What corp are you looking for? " ;
# chomp it to remove the trailing newline.
chomp(my $whatWeWant = <STDIN>);
# & doesn't do what you think it does - avoid it unless you
# actually mean to do what it does.
lsForCorp($whatWeWant);
[download]

If you want to search more than just "input", you want to search all directories at that level, you just change "input" to "*", and it'll handle that: /usr/local/farms/*/*/*/*$corp*. As long as everything is at the same depth in the directory tree, this works fine. If you're looking for files at different depths, you'll need to use File::Find or something similar.

As for getting the date/time/bytecount, you'll need to use the -X functions and/or stat or File::stat. e.g.:

use File::stat;
# ...
  my $s = stat($farm);
  printf "%s: Age [%s], size [%d]\n", $farm, $s->mtime(), $s->size();
[download]

I think you should chomp your input from STDIN, the lineend is probably not part of the file name. Davido's suggestion of File::Find is certainly what you want, but I like glob when a piece of a file name is known, here are a couple of fragments to help.

use File::Find;
sub ask {
    my $response;
    print @_;
    chomp($response = <STDIN>);
    $response;
}

my $searchbase = '/usr/local/farm/company/subcompany/';
our @files;
our $whatWeWant = ask 'What corp are you looking for? ';
find sub {
    -d and push @files, glob "$File::Find::name/*$whatWeWant*";
}, $searchbase;
{
    local ($\,$,) = ($/, $/);
    print @files;
}
[download]

Since you are planning a recursive directory search, I would use File::Find, and put your number search in the wanted() sub.

I dunno, for some reason I've always had a hard time getting my head around the API for File::Find. For me, and YMMV, File::Find::Rule is a little more intuitive.

-- vek --

And if you like the find(1) command, also look at File::Finder, which is more find(1)-like than File::Find::Rule.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Can you give my a syntax example? And how about CPU time, will this take longer than doing an ls and string matching? We've got a lot of folders to go through, and I'm looking for a relatively quick way to do it...

"ls /usr/local/farms/*/*/input/*$corp*" is not recursive. File::Find isn't incredibly slow if there aren't any subdirectories under /usr/local/farms that aren't matched by /usr/local/farms/*/*/input, but glob is likely to be faster than File::Find.