Depends on your FTP server, and possibly the client. I've had experience where a large file gets uploaded as .filename.ext, and once the transfer is finished, the file becomes (rather quickly) renamed as filename.txt.

I don't recall if this convention is inherent in FTP, or was just a happy coincidence that the server and client combination I was using happened to honor. I'd test a few large file transfers in your local FTP server/client combination of choice.

Update: Thanks for jogging my memory, wjw. ProFTPD was the server I was using, and has a nice directive for accomplishing the rename, documentation for which resides here.

s**lil*;  $*=join'',sort split q**;  s;.*;grr; &&s+(.(.)).+$2$1+; $; =
qq-$_-;s,.*,ahc,;$,.=chop for split q,,,reverse;print for($,,$;,$*,$/)
[download]

There is a good nodejs module (remote-file-watcher) for this exact use available on npmjs.com

I used something like this to move files from a customer upload location on our site DMZ to a secure location on our internal network. I a believe that this will allow you to do what you want. My memory may be a bit rusty... but I seem to recall having a perl program which parsed the log files and noted completed transfers, moved the files, and kept track of which files had been moved. We fired off the process every 10 minutes via cron, but a daemon would have worked just as well. The daemon ran inside the firewall and used scp to reach out to the DMZ ftp server and grab the log. It then processed the log and grabbed any new files, again via scp, keeping track locally of files which had been already recieved/moved.

Probably not exactly what you had in mind, but it worked for us at the time.

I've not had to use the features for renaming files that wjw mentions. Though if you can't see the xferlog file that would be a very good way to do it. And, yes, we use ProFTPD also for its extreme flexibility.

We had also had the problem of cutomers uploading more than once. The files they uploaded were very large (50-60 meg) so they would start a transfer, go away for a while and come back noting that the file was not there and disregarding the fact that their client showed a successful transfer, then start the whole thing over again.

We addressed that problem by actually placing a text file in the upload directory which had a name like (file_name)xfer_complete.txt. The contents of the file were always the same; something like "your file has been recieved and moved to a secure place on our network" if I recall correctly.

Most customers caught on right away, the others we would 'coach' if we noticed they needed it. We removed these files after a few hours, and our scp script was coded to ignore them.

Saved us a lot of those Sighs! :-)Just an idea to save some bandwidth for you and your customers. :-)

...the majority is always wrong, and always the last to know about it...

I think this is a great idea, thanks. I'm going to go with tailing the xferlog, too. (Why didn't I think of that before? :) ).

I've really wanted to do this, like creating a <your_filename>.received_correctly_and_processed.txt file. Automatically removing the file after a while makes it sound even better.

The problem we often saw was that we were _so_ fast at picking and moving the file, that the user wouldn't ever see it, even when directly following the PUT with a DIR. It is one thing to see the transition from 'there' to "not there", but it kinda freaked them out that they never saw it at all. Like it had gone into the bit bucket. And our applications are named _somewhat_ differently...

If you are on a Linux or similar system where the modules are supported and you have FAM configured you could try something like:

#!/usr/bin/perl
 
use strict;
use warnings;
use File::Basename;
use SGI::FAM;
use Linux::Fuser;
use File::Spec;
 
my $fam  = SGI::FAM->new();
 
$fam->monitor('/home/jonathan/famtest');
 
my %filecache;
my $newdir = '/home/jonathan/famtemp';
 
my $fuser = Linux::Fuser->new();
while (1)
{
   my $event = $fam->next_event();
    
   my $basename = basename $event->filename();
 
   my $fullpath = File::Spec->catfile($fam->which($event),$basename);
   if ( $event->type() eq 'create' )
   {
      $filecache{$basename}++;
   }
   elsif ( $event->type() eq 'change' )
   {
     if ( exists  $filecache{$basename} and ! $fuser->fuser($fullpath)
+)
     {
        rename $fullpath,File::Spec->catfile($newdir,$basename)
                                  or warn "Couldn't move $fullpath - $
+!\n";
        delete $filecache{$basename};
     }
   }
   else
   {
            print "Pathname: ", $event->filename,
             " Event: ", $event->type, "\n";
   }
}
[download]

/J\