my @allDACDirs = (@configapp1, @configbbb);
for my $i (0 .. $#allDACDirs) {
   ...
[download]

Or maybe I'm not good at following depth in multi-dimensional arrays.

On a side note, you could save a little typing on your array constructors using qw:

my @configbbb = qw(
    m:configbbb
    f:b1.0
    f:bb1.0.config
);
[download]

Update: Here is a crack at a more complex data structure and how you would navigate it:

use strict;
use warnings;
use Data::Dumper;

my @allDACDirs = (
    {
        dir   => 'conf',
        root  => 'configapp1',
        files => [
            {subdir => 'conf', name => '4K_logging.properties'},
            {subdir => 'conf', name => 'logging.properties'   },
            {name => 'dactest1'},
        ]
    },
    {
        root  => 'configbbb',
        files => [
            {name => 'b1.0'},
            {name => 'bb1.0.config'},
        ]
    }
);
#print Dumper(\@allDACDirs);    # for debug

for my $href (@allDACDirs) {
    my %h = %$href;
    my $curr_dir = "$location/$h{root}";
    # mkdir curr_dir...
    if (exists $h{dir}) {
        # mkdir curr_dir/$h{dir}...
    }
    for my $ref (@{ $h{files} }) {
        if (exists ${$ref}{subdir}) {
            # mkdir subdir...
            # create file...
        }
        else {
            # create file...
        }
    }
}
[download]

Any way that helps you understand is a good one. After all, this is Perl.<grin/>

However, I do have a few suggestions. I find that small utility functions often reduce the difficulty of reading code. For example, you repeat a snippet of code in three places to create a directory. I would probably define:

sub mkdir_if_needed
{
    my ($dir) = @_;
    return if -d $dir;
    mkdir($dir,0755) or
       warn "Could not mkdir: $!\n";
    return;
}
[download]

and then call it in multiple places. That reduces unnecessary noise in the code.

The outer loop can also be done as a Perl foreach loop (instead of the C-style you are using). The beginning of the loop would look like:

foreach my $dacdir ( @allDACDirs )
{
    my $curr_dir;
    my $entry;
    # Read the array and populate
    foreach $entry (@{$dacdir})

    ...
[download]

This removes the need for $array_no and $i.

A minor step into a more complex data structure would be to replace the strings above with anonymous arrays, so you don't spend time reparsing. I would have made the following replacements in the first array:

• "m:configapp1" would be [ 'm', 'configappl' ]
• "d:conf" would be [ 'd', 'conf' ]
• "f:dactest1" would be [ 'f', 'dactest1' ]
• "f:conf,4K_logging.properties" would be [ 'f', 'conf', '4K_logging.properties' ]

This is mostly because I tend to think in these kinds of structures. I might then suggest different characters for the two styles of f entries. One would not have the extra file entry and the other would.

This might tempt me toward a more table-driven approach for processing the entries... But, I'll stop here before the abstraction level gets too deep (and we have to break out the hip-waders<grin/>).

I forgot to remind that Data::Dumper is your friend when dealing with more complex data structures.

G. Wade

#!/opt/local/bin/perl
use strict;
use warnings;
use File::Path;
use File::Copy;
my $source      = '/tmp';
my $destination = '.';
my @cfgA        = qw( configapp1/conf/dactest1
                      configapp1/conf/4k_logging.properties
                      configapp1/conf/logging.properties
                    );
my @cfgB        = qw( configbbb/b1.0
                      configbbb/b1.0.config
                    );
foreach (@cfgA, @cfgB) {
   my ($path, $file) = m|(.*)/(.*)|;
   &File::Path::mkpath($path,0,0755)  unless -d $path;
   if (-f "$source/$file") {
      copy("$source/$file", "$destination/$path/");
   } elsif (open(IN,">$destination/$path/$file")) {
      close(IN);
   } else {
      warn("Couldn't copy or create $destination/$path/$file!");
   }
}
[download]

Very nice, but all in all I have 16 arrays now, might make the foreach loop long and hard to read.

I do like the data entries in the arrays though, I hadn't really used File module like that, but having each one as a single directory path would make it easier to read.

As for the foreach getting too long, the following layout might be useful:

foreach ( @cfgA,
          @cfgB,
         #@cfgC,   # not this time!
          @cfgD,
          @cfgE,
         #@cfgF,   # not!
          @cfgG,
         # etc
        ) {
}
[download]

But it might be easier to maintain the paths and files on your filesystem than in your script. I.e., create all the paths and files in your $local_dir; and just copy the desired paths; or perhaps tar up each configuration and untar the desired ones.