Since you already mention rsync: it should be able to do everything you mention. See its --archive (implies --recursive --links --perms --times --group --owner --devices --specials), --hard-links, and --sparse options for mirroring a filesystem as closely as possible (perhaps --no-owner --no-group if the UID/GIDs are different and you don't want to keep them), its --files-from option to give it a list of files to sync (this implies --relative and disables --recursive, so I usually add the latter back on), plus its --filter, --exclude-from and --include-from to control which files are included and excluded. If you have files spread out sparsely across the whole fileystem that you want to sync, it's possible, but setting up the right combination of the aforementioned options takes a bit of reading in the manpage to get right. The --dry-run --itemize-changes --verbose options are useful for testing.

Several years ago I did a bunch of research on rsync to arrive at the above combination of options and wrote a Perl frontend for it. Unfortunately it's not really something to publish, but maybe I'll get around to cleaning it up for publishing someday.

Of course I don't want to discourage writing a Perl solution though :-) Note you don't need to create a bash script: The equivalent to mkdir -p is File::Path's make_path, scp can be done by Net::OpenSSH, and links via symlink.

This kind of black box module?

use v5.12;
use strict;
use warnings;

package MyClass {
    use Moo;

    has _map => (
        is      => 'lazy',
        builder => sub {
            # however you get your list put that here
            return {
                'file1'         => { type => 'file' },
                'somedir/file2' => { type => 'file' },
                'dir1'          => { type => 'dir' },
                'somedir/dir2'  => { type => 'dir' },
                'link1'         => { type => 'link', target => 'somedi
+r/file1' },
                'link2'         => { type => 'link', target => 'otherd
+ir/file3' },
            };
        },
    );

    sub files {
        my $self = shift;
        return [ grep { $self->_map->{$_}{type} eq 'file' } keys %{ $s
+elf->_map } ];
    }

    sub directories {
        my $self = shift;
        return [ grep { $self->_map->{$_}{type} eq 'dir' } keys %{ $se
+lf->_map } ];
    }

    sub links {
        my $self = shift;
        my @links = grep { $self->_map->{$_}{type} eq 'link' } keys %{
+ $self->_map };
        return [ map { { $_ => $self->_map->{$_}{target} } } @links ];
    }
};

my $obj = MyClass->new;
say for @{ $obj->directories };
[download]

dir1
somedir/dir2
[download]

Hope this helps!

Glad to see someone write a bunch of the code that needed writing, but that I didn't have time to write. As a piece of feedback, you should probably use File::Spec to do some path manipulation, particularly since you need to create parent directories before their children.

---

#11929 First ask yourself `How would I do this without a computer?' Then have the computer do it the same way.

Or Path::Tiny which will let you create the directories (otherwise you'll probably File::Path for make_path which works akin to mkdir -p to call yourself).

The cake is a lie.
The cake is a lie.
The cake is a lie.

Hi!
Thank you for suggestion. My question focus on how to build the builder part. I have bunch of paths. How do I know for example if there is a link in the path? Even if I will iterate over each path and check it, how do I know the link? realpath won't work for links such as: a/b -> c/d -> e/f

I have bunch of paths. How do I know for example if there is a link in the path?

You won't know from just looking at the string. You'll have to check the filesystem, and for each pathname break it down into its components, using e.g. -l on each one. You can break down a filename using e.g. splitdir from File::Spec, or IMO a little easier, Path::Class. Maybe something like:

use warnings;
use strict;
use Path::Class qw/file dir/;

my $file = file('/tmp/foolink/bar/quz');

my $prev;
while (1) {
    die "doesn't exist: $file" unless -e $file;
    print $file, " is a ", -l $file ? 'link to '.readlink($file)
        : -f $file ? 'file' : -d _ ? 'dir' : 'special', "\n";
    $prev = $file;
    $file = $file->parent;
    last if $prev eq $file;
}

__END__

/tmp/foolink/bar/quz is a file
/tmp/foolink/bar is a dir
/tmp/foolink is a link to foo
/tmp is a dir
/ is a dir
[download]

Update: Added a check to the above code to make sure the file exists in the first place.