Linux: Zipping Directories into Zipped Files Recursively

Here's a perl script to do it. The idea is from using find2perl, which can construct how perl would do Unix/Linux find command. Using it as a base, a simple script can be very powerful. Note the use of $prune. This is equivalent to find's -prune option. It is used to stop traversing below the current directory.

1. #!/usr/bin/perl -w
2. #
3. # sqzfps.pl -- compress FPS batch files
4. #
5. # CJKim, 27-Jul-2016, Created
6. #
7. 
   
8. use strict;
9. use File::Find ();
10. use vars qw/*name *dir *prune/;
11. *name   = *File::Find::name;
12. *dir    = *File::Find::dir;
13. *prune  = *File::Find::prune;
14. 
    
15. my $topdir = 'some-top-directory';
16. my $aging  = 90; # 365;
17. my $cputhr = 50;
18. my $cpuchk = 50;
19. my $dircnt = 0;
20. $| = 1;
21. 
    
22. sub cpu_ok
23. {
24.     $dircnt++;
25.     if ($dircnt > $cpuchk) {
26.         $dircnt = 0;
27.         while (1) {
28.             open CPU, 'vmstat 1 2 | awk \'{if (++c == 4) print $15;}\' |';
29.             my $idle = <CPU>;
30.             close CPU;
31.             $idle += 0;
32.             last if $idle > $cputhr;
33.             print "Sleeping for 30 seconds since CPU is at $idle% idle...\n";
34.             sleep 30;
35.         }
36.     }
37.     return 1;
38. }
39. 
    
40. sub wanted
41. {
42.     # $_ is the file name only
43.     # $name is the full path
44.     # $dir is just the directory name
45.     # $prune may be set to 1 to stop traversing below the current dir
46. 
    
47.     my ($dev,$ino,$mode,$nlink,$uid,$gid);
48. 
    
49.     (($dev,$ino,$mode,$nlink,$uid,$gid) = lstat($_))
50.     && (-d _)  # directory only
51.     && (int(-M _) > $aging)  # so many days old
52.     && ($_ =~ /^\d{16}FF$/)  # fits the name pattern
53.     && ($prune = 1)  # stop traversing after this one
54.     && cpu_ok()  # check if we have enough cpu available
55.     && system "(echo 'Processing $_'; cd $name && zip -m $dir/$_.zip *.* && cd / && rmdir $name)"
56.     ;
57. }
58. 
    
59. 
    
60. # traverse the filesystem
61. File::Find::find({wanted => \&wanted}, $topdir);
62. 
    

Running the Same Command Periodically and Watch the Output

Have you ever find yourself typing the same command over and over again just to see what's been changing? On a standard Linux, there is a little-known utility called "watch". It can run a command repeatedly every so many seconds and shows you the output. But it goes one step further by showing the differences between the last run and current by highlighting the differences. Yes, it's a clunky command line tool but does a beautiful job of saving a lot of typing and figuring out what changed. See the man pages for watch(1) for the detail and the option flags.

I often used it with SQL*Plus to see the changes in database. For example, you can have a SQL statement in a file called, say, count.sql. You can invoke it using SQL*Plus but you will see the output only one time. To see the output periodically, you can invoke it with watch(1), e.g.

watch -d sqlplus scott/tiger@xe @count

Don't forget to have "EXIT" as the last command in count.sql so that sqlplus would exit after executing the SQL statements.

Cloning a Directory Tree in Linux/Unix

Here's an old command that clones an entire directory tree in Unix or Linux. So far, the command appears to work on all variants of Unix (HP-UX, Solaris, AIX, RedHat, Ubuntu, CentOS, and Fedora):

    $ cd to_the_directory_to_be_cloned  
    $ find . -depth -print | cpio -pdv destination_directory  

While the above command clones all files, since find(1) offers many options, you can clone selected files. For example, if you wish to clone only java programs, specify the option "-name '*.java'" to do so.