Problem Using unlink

I have a short and sweet perl script that I'm running directly on our TS server (Solaris 9 & TS 6.1) to delete some unwanted files off the docroot. Basically, I just build an array with a find command, then loop thru and unlink...problem is, the files aren't being deleted. Here's the code chunk and the error output:

my @files = `find /teamsite/iwmnt/default/main/Development/WORKAREA/dsoderberg -type f -name "WS_FTP.LOG"`;

foreach $file (@files){

### Delete the WS_FTP.LOG file.
unlink $file or warn "Can't delete $file: $!\n";
print OUT "Deleted - " . $file . "\n";

} # end of foreach

Here's my error on the unlink:

Can't delete /teamsite/iwmnt/default/main/Development/WORKAREA/dsoderberg/deploy/docroot/wireless/WS_FTP.LOG
: No such file or directory

My confusion stems from the fact that the find is building the array and when it comes time to delete the file, all of the sudden, the file it found in the find command can't be found??? Has anyone run into anything like this?

Find more posts tagged with

Comments

Migrateduser

Remove the new line at the end of the variable $file and then use unlink command.

chomp $file;

dlsoderberg

I knew it would be something small that I missed...thanks a lot!!!

Adam Stoller

I have a short and sweet perl script that I'm running directly on our TS server (Solaris 9 & TS 6.1) to delete some unwanted files off the docroot. [...]:

my @files = `find /teamsite/iwmnt/default/main/Development/WORKAREA/dsoderberg -type f -name "WS_FTP.LOG"`;

foreach $file (@files){

### Delete the WS_FTP.LOG file.
unlink $file or warn "Can't delete $file: $!\n";
print OUT "Deleted - " . $file . "\n";

} # end of foreach

You've already been told to chomp() the value so that your script now works - but I have to wonder why you're doing it this way.

If you're going to use Perl - use Perl - and use built-in I/O operators like opendir/readdir/closedir to traverse the contents of the workarea to find the files you want to unlink.

If you're going to use 'find' - use find - and have it use

-delete

-exec /bin/rm {} \;

If you really want to store the information in an array and use unlink() - then why not just provide the array to unlink instead of doing a foreach loop on it?

What you have now works - and that's fine. I'm just suggesting you think a bit more about what you're doing and figure out if it's really the best way to do it. Depending on the system specs and the number of times you're going to need to run this script - it may not really matter - but it's still worth a bit of thought IMO.

I just wrote a quick benchmarking script to test this on the local file system of my machine (thus ignoring any potential extra latency in dealing with the IFS) - for 100 iterations:

           baseline:  2 wallclock secs ( 0.04 usr  0.34 sys +  0.47 cusr  1.81 csys =  2.66 CPU) @ 263.16/s (n=100)
        hybrid_list:  4 wallclock secs ( 0.05 usr  0.53 sys +  0.56 cusr  2.22 csys =  3.36 CPU) @ 172.41/s (n=100)
        hybrid_loop:  3 wallclock secs ( 0.05 usr  0.52 sys +  0.55 cusr  2.19 csys =  3.31 CPU) @ 175.44/s (n=100)
    purefind_delete:  4 wallclock secs ( 0.05 usr  0.45 sys +  0.55 cusr  2.28 csys =  3.33 CPU) @ 200.00/s (n=100)
      purefind_exec:  6 wallclock secs ( 0.05 usr  0.47 sys +  1.04 cusr  4.49 csys =  6.05 CPU) @ 192.31/s (n=100)
      pureperl_list:  3 wallclock secs ( 0.09 usr  0.55 sys +  0.48 cusr  1.86 csys =  2.98 CPU) @ 156.25/s (n=100)
      pureperl_loop:  4 wallclock secs ( 0.10 usr  0.54 sys +  0.47 cusr  1.86 csys =  2.97 CPU) @ 156.25/s (n=100)
pureperl_when_found:  3 wallclock secs ( 0.09 usr  0.56 sys +  0.48 cusr  1.87 csys =  3.00 CPU) @ 153.85/s (n=100)

(baseline is the amount of time it takes to create a directory tree with N files at each level - which is done as part of each of the other operations)
A find with an -exec takes longer than a find with a -delete.
Using pure-perl with a single call to unlink to process a list, or calling unlink on the file when its found takes about as long a doing a find into a list and then looping on that list - which seems strange, you would think the hybrid_list would be slightly more efficient than the hybrid_loop - but you can see that the difference for lists vs. loops is pretty negligable at 100 iterations anyway.

           baseline: 28 wallclock secs ( 0.40 usr  3.46 sys +  4.73 cusr 17.97 csys = 26.56 CPU) @ 259.07/s (n=1000)
        hybrid_list: 34 wallclock secs ( 0.56 usr  5.38 sys +  5.51 cusr 21.95 csys = 33.40 CPU) @ 168.35/s (n=1000)
        hybrid_loop: 34 wallclock secs ( 0.58 usr  5.59 sys +  5.54 cusr 22.08 csys = 33.79 CPU) @ 162.07/s (n=1000)
    purefind_delete: 35 wallclock secs ( 0.51 usr  4.77 sys +  5.53 cusr 22.77 csys = 33.58 CPU) @ 189.39/s (n=1000)
      purefind_exec: 65 wallclock secs ( 0.53 usr  4.99 sys + 10.34 cusr 44.21 csys = 60.07 CPU) @ 181.16/s (n=1000)
      pureperl_list: 31 wallclock secs ( 0.98 usr  5.73 sys +  4.77 cusr 18.59 csys = 30.07 CPU) @ 149.03/s (n=1000)
      pureperl_loop: 31 wallclock secs ( 1.00 usr  5.80 sys +  4.79 cusr 18.72 csys = 30.31 CPU) @ 147.06/s (n=1000)
pureperl_when_found: 31 wallclock secs ( 0.97 usr  5.79 sys +  4.77 cusr 18.59 csys = 30.12 CPU) @ 147.93/s (n=1000)

At 1000 iterations we can clearly see that find with the -exec flag is a big loser
Pureperl starts to look a bit better than using find by itself or in combination with Perl.

           baseline: 275 wallclock secs ( 4.05 usr 34.77 sys +  47.14 cusr 178.46 csys = 264.42 CPU) @ 257.60/s (n=10000)
        hybrid_list: 342 wallclock secs ( 5.62 usr 52.89 sys +  55.01 cusr 218.67 csys = 332.19 CPU) @ 170.91/s (n=10000)
        hybrid_loop: 346 wallclock secs ( 5.83 usr 53.84 sys +  55.01 cusr 219.32 csys = 334.00 CPU) @ 167.59/s (n=10000)
    purefind_delete: 348 wallclock secs ( 5.09 usr 46.32 sys +  55.39 cusr 228.73 csys = 335.53 CPU) @ 194.51/s (n=10000)
      purefind_exec: 658 wallclock secs ( 5.36 usr 47.90 sys + 104.14 cusr 450.48 csys = 607.88 CPU) @ 187.76/s (n=10000)
      pureperl_list: 312 wallclock secs ( 9.84 usr 56.58 sys +  47.70 cusr 186.12 csys = 300.24 CPU) @ 150.56/s (n=10000)
      pureperl_loop: 311 wallclock secs (10.03 usr 58.21 sys +  47.86 cusr 186.46 csys = 302.56 CPU) @ 146.54/s (n=10000)
pureperl_when_found: 312 wallclock secs ( 9.72 usr 57.76 sys +  47.66 cusr 186.16 csys = 301.30 CPU) @ 148.19/s (n=10000)

At 10,000 iterations the tradeoffs of using 'find' vs. built-in I/O functions on my server are a bit more distinct with the perl built-in's ultimately taking less time than the callout to 'find' (which makes sense, since invoking 'find' also involves invoking at least one, if not two, other process(es) for which you need to consider the overhead.

So - for something that's called once in a blue moon - it really doesn't matter too much, but if the code is going to be called many times in succession - you're better off using the Perl built-in's, and IMO, I'd suggest coding for it always unless the code is intended to be thrown away after being used once to collect some sort of data.

REP_WEEK.rptdesign