b46e0419a7ab978072f5b9a72143301b65a96c4a
larrym
  Mon Sep 12 11:45:00 2011 -0700
use cgi versioned copies of files instead of softlinks for production files (see redmine 5104)
diff --git src/hg/utils/cpAndLinkToResourceFiles.pl src/hg/utils/cpAndLinkToResourceFiles.pl
index 1fb70a2..7bb3dd0 100755
--- src/hg/utils/cpAndLinkToResourceFiles.pl
+++ src/hg/utils/cpAndLinkToResourceFiles.pl
@@ -1,168 +1,198 @@
 #!/usr/bin/env perl
 
-# Copy files to resource directory; make versioned soft-links as appropriate (and delete obsolete ones too).
+# Copy files to resource directory; make versioned soft-links and/or files as appropriate (and delete obsolete ones too).
 
 use strict;
 
 use Cwd;
 use Getopt::Long;
 
 sub usage
 {
     my ($msg) = @_;
     print STDERR <<END;
 $msg
 
 Usage:
 
 cpAndLinkToResourceFiles.pl [OPTION] -destDir=dir -versionFile=file files
 
 Copy any modified static files to a directory in the apache DocumentRoot and create appropriately versioned softlinks.
 
 Options:
 
      -destDir=dir          Directory where we copy files
      -exclude=fileList     Comma-delimited list of files to exclude (useful if the files argument was created using "ls *.js")
      -force                Force update of all files
      -forceVersionNumbers  Force use of CGI versioned softlinks; useful for debugging in dev trees
      -minify               Minify javascript files (currently experimental)
      -versionFile=file     Get CGI version from this header file
 END
 }
 
 my ($exclude, $destDir, $debug, $versionFile, $cgiVersion, $useMtimes);
 my %exclude;
 my %seen;
 my $forceVersionNumbers;   # You can use this option to test CGI-versioned links on dev server
 my ($force, $minify);
-my $minifyJar = "/cluster/home/larrym/tmp/yuicompressor-2.4.6/build/yuicompressor-2.4.6.jar";   # not sure where to install the jar (in utils dir?)
+
+# minify code is experimental (hence this hardwired path; I'm not sure where to install the jar (in utils dir?)).
+my $minifyJar = "/cluster/home/larrym/tmp/yuicompressor-2.4.6/build/yuicompressor-2.4.6.jar";
 
 GetOptions("exclude=s" => \$exclude, "destDir=s" => \$destDir, "debug" => \$debug, "force" => \$force, "minify" => \$minify,
            "versionFile=s" => \$versionFile,  "forceVersionNumbers" =>  \$forceVersionNumbers);
 
 if($exclude) {
     %exclude = map { $_ => 1} split(/\s*,\s*/, $exclude);
 }
 
 usage("Missing/invalid destDir '$destDir'") if(!$destDir || !(-d $destDir));
 
 my $host = $ENV{HOST};
 if(!defined($host)) {
     $host = `/bin/hostname`;
     chomp($host);
 }
 
-# Use version based links in production sites, mtime based links in dev sites (see redmine #3170)
+# Use version based copies in production sites, mtime based links in dev sites (see redmine #3170 and 5104).
 if($forceVersionNumbers) {
     $useMtimes = 0;
 } else {
     $useMtimes = $host eq 'hgwdev' || $host eq 'genome-test' || $host eq 'genome-preview';
 }
 
 if(!$useMtimes) {
     if(defined($versionFile)) {
         open(FILE, $versionFile) || die "Couldn't open '$versionFile'; err: $!";
         while(<FILE>) {
             if(/CGI_VERSION \"([^\"]+)\"/) {
                 $cgiVersion = $1;
             }
         }
         close(FILE);
         if(!defined($cgiVersion)) {
             die "Couldn't find CGI_VERSION in '$versionFile'";
         }
     } else {
         die "Missing required versionFile parameter";
     }
 }
 
 $destDir =~ s/\/$//;
 
 my @destFiles;
 opendir(DIR, $destDir);
 for my $file (readdir(DIR)) {
     if($file !~ /^\./) {
         push(@destFiles, $file);
     }
 }
 closedir(DIR);
 
 # To avoid screwing up mirrors who run "rsync --links", we chdir into the resource directory and make non-absolute softlinks there.
 my $cwd = getcwd();
 chdir($destDir) || die "Couldn't chdir into '$destDir'; err: $!";
 
 for my $file (@ARGV)
 {
     if(!$seen{$file} && !$exclude{$file}) {
         $seen{$file} = 1;
-        my @stat = stat("$cwd/$file") or die "Couldn't stat '$file'; err: $!";
+        my $srcFile = "$cwd/$file";
+        my @stat = stat($srcFile) or die "Couldn't stat '$srcFile'; err: $!";
         my $mtime = $stat[9];
         my ($prefix, $suffix);
         if($file =~ /(.+)\.([a-z]+)$/) {
             $prefix = $1;
             $suffix = $2;
+        } else {
+            die "Couldn't parse prefix and suffix out of file '$file'";
         }
-        # update destination file as appropriate
+
+        if($useMtimes) {
+            # On dev machine, we copy file to apache dir and then create a mtime versioned softlink to this file.
+
         my $update = 0;
+            my $exists = 0;
         my $destFile = $file;
         if(-e $destFile) {
             my @destStat = stat("$destFile") or die "Couldn't stat '$destFile'; err: $!";
             $update = ($destStat[9] < $mtime);
+                $exists = 1;
         } else {
             $update = 1;
         }
         $update = $update || $force;
         if($update) {
-            my $done;
-            if (-e $destFile) {
+                if ($exists) {
                 unlink($destFile) || die "Couldn't unlink $destFile'; err: $!";
             }
             if($debug) {
-                print STDERR "cp -p $cwd/$file $destFile\n";
-            }
-            if($minify && $suffix eq 'js') {
-                my $cmd = "/usr/bin/java -jar $minifyJar $cwd/$file -o $destFile";
-                print STDERR "cmd: $cmd\n" if($debug);
-                !system($cmd) || die "Couldn't run cmd '$cmd': err: $!";
-                my @destStat = stat($destFile);
-                if($destStat[7] >= $stat[7]) {
-                    # Don't bother to minify if minified file is larger than original (this happens when file has already been minified).
-                    print STDERR "Skipping minify for $cwd/$file because it is apparently already minified" if($debug);
-                } else {
-                    $done = 1;
-                }
-            }
-            if(!$done) {
-                !system("cp -p $cwd/$file $destFile") || die "Couldn't cp $cwd/file to $destFile: err: $!";
+                    print STDERR "cp -p $srcFile $destFile\n";
             }
+                !system("cp -p $srcFile $destFile") || die "Couldn't cp $srcFile to $destFile: err: $!";
         }
 
-        if($prefix && $suffix) {
             # make sure time is right, in case file; file might have been newer,
             # speculation that cp -p silently failed if user doesn't own destDir
             @stat = stat($destFile) or die "Couldn't stat '$destFile'; err: $!";
             $mtime = $stat[9];
 
             my $softLink = $file;
-            if($useMtimes) {
-                $softLink =~ s/\.${suffix}$/-$mtime.${suffix}/;
-            } else {
-                $softLink =~ s/\.${suffix}$/-v$cgiVersion.${suffix}/;
-            }
+            $softLink =~ s/\.$suffix$/-$mtime.$suffix/;
+
             # Delete obsolete symlinks
             for my $f (@destFiles) {
-                if(($useMtimes && $f =~ /^$prefix-\d+\.$suffix$/) || ($useMtimes && $f =~ /^$prefix-v\d+\.$suffix$/)) {
+                if($f =~ /^$prefix-\d+\.$suffix$/ || $f =~ /^$prefix-v\d+\.$suffix$/) {
                     if($f ne $softLink) {
                         print STDERR "Deleting old soft-link $f\n" if($debug);
-                        unlink($f) || die "Couldn't unlink obsolete softlink '$softLink'; err: $!";
+                        unlink($f) || die "Couldn't unlink obsolete softlink '$f'; err: $!";
                     }
                 }
             }
             # create new symlink
             if(!(-l "$softLink")) {
-                print STDERR "ln -s $file $softLink\n" if($debug);
-                !system("ln -s $file $softLink") || die "Couldn't ln -s $file; err: $!";
+                my $cmd = "ln -s $file $softLink";
+                print STDERR "cmd: $cmd\n" if($debug);
+                !system($cmd) || die "Couldn't $cmd; err: $!";
+            }
+        } else {
+            # On production machines, we make a copy of git file with the CGI version burned in (see redmine #5104).
+
+            my $destFile = $file;
+            $destFile =~ s/\.$suffix$/-v$cgiVersion.$suffix/;
+            my $update = 0;
+            my $exists = 0;
+            if(-e $destFile) {
+                my @destStat = stat("$destFile") or die "Couldn't stat '$destFile'; err: $!";
+                $update = ($destStat[9] < $mtime);
+                $exists = 1;
+            } else {
+                $update = 1;
+            }
+            $update = $update || $force;
+            if($update) {
+                # delete obsolete files
+                for my $f (@destFiles) {
+                    if($f =~ /^$prefix-v\d+\.$suffix$/) {
+                        if($f ne $destFile) {
+                            print STDERR "Deleting old version of file $file\n" if($debug);
+                            unlink($f) || die "Couldn't unlink obsolete versioned file '$f'; err: $!";
+                        }
+                    }
+                }
+                if($exists) {
+                    unlink($destFile) || die "Couldn't unlink '$destFile'";
+                }
+                if($minify && $suffix eq 'js') {
+                    my $cmd = "/usr/bin/java -jar $minifyJar $srcFile -o $destFile";
+                    print STDERR "cmd: $cmd\n" if($debug);
+                    !system($cmd) || die "Couldn't run cmd '$cmd': err: $!";
+                } else {
+                    my $cmd = "cp -p $srcFile $destFile";
+                    print STDERR "cmd: $cmd\n" if($debug);
+                    !system($cmd) || die "Couldn't $cmd; err: $!";
+                }
             }
         }
     }
 }