I think you should at least try using MD5s before concluding that they're too slow. Digest::MD5 is pretty fast, in my experience.

-sam

Thanks, I'll give MD5 a try, assuming it's available. Also, by my understanding, File::Compare stops comparing once a difference is found; as I understand it calculating an MD5 sum requires reading in the entire file. It will be interesting to see how the two bench out.

Thanks,

T

_________________________________________________________________________________

I like computer programming because it's like Legos for the mind.

He's doing "one-way synchronization of directory trees In Windows". If that means he's doing archiving, he only needs to compute the MD5 of the archived file once. That means that MD5 requires that one file be read fully, whereas File::Compare requires two files to be read in part or in full.

OK, so I benched File::Comparing vs. using MD5 digests, vs. using modification times.

After four runs, I got an average time of about 42 seconds using full comparison, about 48 seconds for MD5 (calculating for just the source, as the destination presumablyalready has one), and about 11 seconds for just modification times using stat().

I think I am just going to go with modification time.

Thanks,

T.

_________________________________________________________________________________

I like computer programming because it's like Legos for the mind.

runrig++! This is exactly what I am doing (replacement for Briefcase!)

I'm going to give benchamarking MD5 vs File::Compare a try, and then look into your solution!

_________________________________________________________________________________

I like computer programming because it's like Legos for the mind.

Argh, Win32::API not present on the desktops. I'll be posting benchmarks on the other ways of doing it in a bit.

_________________________________________________________________________________

I like computer programming because it's like Legos for the mind.

Win32::API doesn't come with the standard install of ActiveState Perl, but it is easily installed with the ppm utility.

Using just modification time and size may mostly work OK if your clocks are in sync. If you want to try this, you should at least make sure everybody's running NTP. There's still a potential for conflicts if there's more than one person updating data, though.

What he said.

To do anything other than use rsync would be really stupid. Spend your valuable time on something more productive than reinventing this nasty wheel.

I agree - rsynch is the way to go - the next feature you will want is bandwidth limiting, then after that you will want maybe ssh tunnelling with key authentication for security, and then after that you will want permission synchronisation, and then... well, you get my drift.

Regards,

Jeff

jdtoronto

In fact, on Unix, I have the impression that just checking ctime is enough, as any change to the file changes that timestamp, and it cannot be changed manually. Unfortunately, that's not the case on Windows.

> In fact, on Unix, I have the impression that just checking ctime is enough, as any change to the file changes that timestamp, and it cannot be changed manually.

I believe this is incorrect, but I'm not sure how it is done.

I've looked at some freely available C source code to change ctime of files, and wht it does is change the clock time, change a file's ctime to the "current time", and change the clock back. (I'll link to it if I can find it back.)

If this hack is the only way to achieve it, I think you can state it can't be done.

Here's what I've come up with:

use strict;
use File::Copy;
use File::Find;
use File::Compare;
use Time::HiRes qw(time);

my $source   = "G:\\contingency\\";
my $maindest = "D:\\";

( -r $source ) || die "Error:  $source not readable\n";
( -e $maindest )
  || die
"Error:  $maindest (memory stick) does not exist--is your memory stick
+ attached?\n";

print "Beginning scan of source directory for updated files...\n\n";

# for the convenience of &wanted calls, including -eval statements:
use vars qw/*name *dir *prune/;
*name  = *File::Find::name;
*dir   = *File::Find::dir;
*prune = *File::Find::prune;

my $newdirs        = 0;
my $newfiles       = 0;
my $changedfiles   = 0;
my $unchangedfiles = 0;
my $orphans        = 0;
my $startcompcopy  = time;
my $status1        = find( \&wantedtime, $source );
my $endcompcopy    = time;
printf "Synchronization took %f seconds.\n\n", $endcompcopy - $startco
+mpcopy;

my $totalfiles = $newdirs + $newfiles + $changedfiles + $unchangedfile
+s;
print "Summary report:  \n";
print "$totalfiles entries scanned.\n";
print "$newdirs new directories found and created.\n";
print "$newfiles new files found and copied.\n";
print "$changedfiles updated files copied.\n";
print "$unchangedfiles unchanged files ignored.\n\n";

#..and then take care of orphans
print "searching for orphans:\n";
my $dest1 = $source;
$dest1 =~ s/G:/D:/;
my @filesizes;

#use finddepth here cos we're deleting
my $status1 = finddepth( \&wantedorphans, $dest1 );

print "$orphans orphans deleted from memory stick.\n\n";

print "This program will now pause for 10 seconds, then exit.\n";

sleep 10;

sub wantedtime {
    my $dest = $name;
    $dest =~ s/G:/D:/;
    if ( not -e $dest ) {
        if ( -d $name ) {
            print "Making new directory $dest\n";
            mkdir $dest;
            ++$newdirs;
        }
        else {
            print "Copying previously nonexistent file $dest\n";
            my $cstatus = copy( $name, $dest );

            #copy returns 1 on success
            ++$newfiles;
            ($cstatus)
              || warn
              "WARNING:  Copy of $name failed with status $cstatus: $!
+\n";
        }
    }
    else {

        #Not doing this for directories as empty dirs are taken care o
+f above
        #and copying an entire directory won't work with copy()
        if ( -d $name ) {
            print "scanning $name...\n";
        }
        else {
            my $smtime = ( stat($name) )[9];
            my $dmtime = ( stat($dest) )[9];
            if ( ( $smtime > $dmtime ) ) {
                print
                  "Updated file found!\n Copying $name\n to memory sti
+ck \n";
                my $cstatus = copy( $name, $dest );

                #copy returns 1 on success
                ($cstatus)
                  || warn
                  "WARNING:  Copy of $name failed with status $cstatus
+: $!\n";
                ++$changedfiles;
            }
            else {
                ++$unchangedfiles;
            }
        }
    }
}

sub wantedorphans {
    my $status = 1;
    $source = $name;
    $source =~ s/D:/G:/;
    if ( not -e $source ) {
        ++$orphans;
        print "$name is an orphan; deleting...\n";
        if ( -d $name ) {
            $status = rmdir $name;
        }
        else {
            $status = unlink $name;
        }

#rmidr returns true on success; unlink returns number of files deleted
+ (should be 1)
        ($status)
          || warn "WARNING:  Status of removal of $name is $status : $
+!\n";
    }
}
[download]

_________________________________________________________________________________

I like computer programming because it's like Legos for the mind.

Well, at least my boss knows what's up, and he has the handy-dandy script he can run. I think it was still worth it, even for one user. It was also a learning experience for Perl and to continue to try to figure out this other person with whom I have to work closely.

_________________________________________________________________________________

I like computer programming because it's like Legos for the mind.