Hi,

if you are able to move the already copied files into an archiv directory, I would do the following:

Rename the found file to a filename which will be never hit by incoming files (some tilde before and after, or somthing like that). This would serve as flag that the file is in progress.

Copy this file into the target directory. This may last some time.

After successful copy move the source file into the archive directory rolling back the initial filename change.

Rename the target file in the target directory back to the initial filename.

When you log every step you should be able to find out weired circumstances when this process terminates abnormally. And you can be sure that the file in the target directory will only be fetched when completely written. With the code above you can't guarantee that.

When you want you can also delete the source file in the source archiv.

Best regards
McA

### original code by Jenda as found at http://www.perlmonks.org/?node_
+id=105128
#perl -w
# watch_dirs.pl
use strict;
#use G;
use File::Copy;
use Win32::IPC qw(wait_any);
use Win32::ChangeNotify;
use Win32::AbsPath qw(Relative2Absolute);
use Win32::FileOp qw(:DIALOGS);

use vars qw($VERSION $path @paths $i @notify @data $file $pathnum);

$VERSION = "1.0";

if (@ARGV) {
    @paths = @ARGV;
    Relative2Absolute @paths;
    foreach (@paths) {
        die "Ussage: watch_dirs.pl [directory ...]\n\t\tversion $VERSI
+ON by Jenda.Krynicky.cz (c) 2001\n"
         unless -d $_;
    }
} else {
    while (1) {
        $path = BrowseForFolder "Watch directory for changes\nClick [C
+ancel] to finish directory selection" , CSIDL_DRIVES, BIF_RETURNONLYF
+SDIRS
         or last;
        push @paths, $path;
    }
    die "OK. No directory selected. I'm quiting.\n"
     unless @paths;
}

print "Watching directories:\n";
for ($i=0;$i<=$#paths;$i++) {
    $path = $paths[$i];
    print "\t$path\n";
    mkdir $path.'\\_b_a_c_k_u_p', 0777;
    opendir DIR, $path;
    while ($file = readdir DIR) {
        next if -d $path.'\\'.$file;
        $data[$i]->{$file} = (stat($path.'\\'.$file))[9];
    }
    closedir DIR;
    push @notify, Win32::ChangeNotify->new($path,0,"LAST_WRITE SIZE FI
+LE_NAME");
};
print "\n";


while (1) {
    $pathnum = wait_any(@notify) or die "Can't monitor the directory: 
+$!\n";
    $pathnum--; # arrays always start from zero not one

    my $pathdata = $data[$pathnum];
    my $path = $paths[$pathnum];

    opendir DIR, $path;
    while ($file = readdir DIR) {
        next if -d "$path\\$file";
        my $time = (stat("$path\\$file"))[9];
        if ($pathdata->{$file} != $time) {
            print "$path\\$file has changed!\n";
            my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)
             = localtime(time);$mon++;$year += 1900;
            my $timestr = sprintf '%04d%02d%02d-%02d%02d%02d',$year,$m
+on,$mday,$hour,$min,$sec;
            copy "$path\\$file" => "$path\\_b_a_c_k_u_p\\$file.$timest
+r";
            $pathdata->{$file} = $time;
        }
    }
    closedir DIR;

    $notify[$pathnum]->reset;
}

=pod PerlApp

perlapp watch_dirs.pl -f -c -x "-info=fileversion=1.0;productversion=1
+.0;internalname=watch_dirs.pl 1.0;originalfilename=watch_dirs.exe;com
+panyname=Jenda Krynicky;productname=watch_dirs;legaltrademarks=Jenda.
+Krynicky.cz;filedescription=Watch dirs for changes and make backup;le
+galcopyright=Jenda.Krynicky.cz"

=cut
[download]

Append another extension to the files in directory 1 when you copy them. Your next .. $filterstring will filter them out in subsequent runs.

This is actually a good idea and works. The only concern is that "directory 1" is an starting point for another larger workflow. So extensions and naming convention must remain original.

use strict;
use warnings;
use diagnostics;

use File::Copy::Recursive qw(dircopy rcopy);
use File::Path qw(make_path);

my $dirname  = "$ENV{USERPROFILE}\\Dropped Box\\";
my $dirname2 = "C:\\Dropped Stuff\\";

my $sleep        = 5;    # how long to sleep for

while (1) {
    opendir( DIR, $dirname ) || die "Error in opening dir $dirname\n";
    foreach my $filename ( readdir(DIR) ) {
        if ( not -e $dirname2 . $filename ) {
            print "copying $dirname$filename to $dirname2$filename\n";
            dircopy( $dirname . $filename, $dirname2 . $filename );
            rcopy( $dirname . $filename, $dirname2 . $filename );
        }
        else {
            print "files already exists so im skipping\n";
        }
    }
    closedir(DIR);
    sleep $sleep;
    1;
}
[download]

i wonder how someone could set this up for directory recursion that would include all folders and subfolders?

This is a local RAID drive on a Mpeg capture system. We do archive the files on network storage but that is manual process done by staff at their convenience. I am trying to monitor the capture folder for new captures and then just copy the file to a QC workflow watch folder.I have a software called "Second Copy" doing this now but it sort of does the same thing my Perl script does. Except it copies the entire list of mpg files every time there is a file/s change. So I am just trying to get a simple script that will copy only newly captured files to a network folder.