#!/usr/bin/perl -w
###########################################################################
#                                                                         #
# This script synchronizes files from a local machine to and from         #
# HPSS using the "hsi" command line tool.                                 #
#                                                                         #
# Copyright 2009 Theodore S. Kisner <tskisner@lbl.gov>                    #
#                                                                         #
# Redistribution and use in source and binary forms, with or without      #
# modification, are permitted provided that the following conditions      #
# are met:                                                                #
#                                                                         #
# 1. Redistributions of source code must retain the above copyright       #
#    notice, this list of conditions and the following disclaimer.        #
# 2. Redistributions in binary form must reproduce the above copyright    #
#    notice, this list of conditions and the following disclaimer in the  #
#    documentation and/or other materials provided with the distribution. #
#                                                                         #
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR    #
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED          #
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE  #
# DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,     #
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES      #
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR      #
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)      #
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,     #
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING   #
# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE      #
# POSSIBILITY OF SUCH DAMAGE.                                             #
###########################################################################

use strict;
use POSIX;
use Getopt::Std;
use File::Basename;
use File::stat;
use File::Path;
use Time::Local;

# The version of this program
my $version = "1.1";

# The path to the "hsi" command
my $hsiexec = "hsi";

# Mapping from HPSS month string to POSIX number
my %month2num = qw(
Jan   0
Feb   1
Mar   2
Apr   3
May   4
Jun   5
Jul   6
Aug   7
Sep   8
Oct   9
Nov  10
Dec  11
);

# The list of local files newer than HPSS
my @files_lnew = ();

# The list of HPSS files newer than local disk
my @files_hnew = ();

# The list of HPSS files that do not exist locally
my @files_honly = ();

# The list of local files that do not exist on HPSS
my @files_lonly = ();

# The HPSS list of actions
my @hpss_actions_commit = ();
my @hpss_actions_update = ();

# The list of local actions
my @local_actions_commit = ();
my @local_actions_update = ();

# The name of the per-directory files containing HPSS location
my $syncfile = ".synchsi";

# The current date and time
my $now = time();
my @nowdate = localtime($now);

# The current year
my $thisyear = 1900 + $nowdate[5];

# The name of the temporary HPSS execution list
my $hpsscomfile = "hsync-TEMP_".$now;


# Useage information
sub useage {
  print "\n<**************************************************************>\n\n";
  print "  Usage:  hsync [<options>] <command> [<option 1>] [<option 2>] ...\n\n";
  print "          General Options are:\n";
  print "            -v (print hsync version)\n";
  print "            -d (force deletion of missing files on update/commit)\n";
  print "            -A <authmethod> (passed to hsi)\n";
  print "            -h <host/port> (passed to hsi)\n";
  print "            -k <keytab path> (passed to hsi)\n";
  print "            -l <login name> (passed to hsi)\n";
  print "            -S (disable staging during update)\n";
  print "            -b (for debugging, status prints all local and hpss commands)\n\n";
  print "          Available commands and options are:\n\n";
  print "          checkout <path to HPSS directory> [<optional local directory>]\n";
  print "            Get a local copy of the specified HPSS directory.\n\n";
  print "          commit [<optional path>]\n";
  print "            Recursively synchronize files from current\n";
  print "            working directory (or optional path) to HPSS.\n";
  print "            The local directory must be the result of a\n";
  print "            previous checkout command.\n\n";
  print "          update [<optional path>]\n";
  print "            Recursively update local copy of files in current\n";
  print "            working directory (or optional path) from HPSS.\n";
  print "            Locally modified files (with newer timestamps) \n";
  print "            are not overwritten.\n\n";
  print "          status [<optional path>]\n";
  print "            Display the changes that will happen during the \n";
  print "            the next update or commit on the current working\n";
  print "            directory or the specified path.  Character keys are\n";
  print "            U|A  : next update adds this local file\n";
  print "            U|M  : next update overwrites this existing local file\n";
  print "            U|D  : next update deletes this local file\n";
  print "            C|A  : next commit adds this file to HPSS\n";
  print "            C|M  : next commit overwrites HPSS file with local one\n";
  print "            C|D  : next commit deletes HPSS file\n\n";
  print "          export [<optional path>]\n";
  print "            Recursively remove the .synchsi files in current working\n";
  print "            directory or specified path. hsync will no longer\n";
  print "            consider this directory to be a checkout.\n\n";
  print "<****************************************************************>\n\n";
  die;
}

my %opts = ();
getopts('A:h:k:l:Sdvb', \%opts);

if ($opts{v}) {
  print $0," is version ",$version,"\n";
  exit(0);
}

my $hsiopts = "";
my $hsinostage = 0;
if ($opts{A}) {
  $hsiopts = $hsiopts." -A ".$opts{A};
}
if ($opts{h}) {
  $hsiopts = $hsiopts." -h ".$opts{h};
}
if ($opts{k}) {
  $hsiopts = $hsiopts." -k ".$opts{k};
}
if ($opts{l}) {
  $hsiopts = $hsiopts." -l ".$opts{l};
}
if ($opts{S}) {
  $hsinostage = 1;
}

$hsiexec = $hsiexec.$hsiopts;


# Escape any filename characters that need it for /bin/sh

sub shell_esc {
  my ($path) = @_;
  if ($path =~ /[\*]/) {
    die("\nPath name $path contains illegal HPSS characters\n\n");
  }
  $path =~ s/([\s;<>\*\|`&\$!#\(\)\[\]\{\}:'"])/\\$1/g;
  return $path;
}


# These functions add/remove key/value pairs to/from an array.  
# Unlike using a hash, these entries will stay in order.

sub add_entries {
  my ($arr, $key, $val) = @_;
  push(@$arr, $key);
  push(@$arr, $val);
  return;
}

sub shift_entries {
  my ($arr) = @_;
  return splice(@$arr, 0, 2);
}

sub pop_entries {
  my ($arr) = @_;
  return splice(@$arr, 0, -2);
}


# See if a directory exists on HPSS

sub hpss_dirstat {
  my ($path) = @_;
  my $file = basename($path);
  my $dir = dirname($path);
  my $safefile = shell_esc($file);
  my $safedir = shell_esc($dir);
  my $hsicom = $hsiexec." -q find ".$safedir." -name ".$safefile." -type d 2>&1 | grep -e \'".$file."\' > /dev/null";
  my $hsiret = system($hsicom);
  if ($hsiret == 0) {
    return 1;
  } else {
    return 0;
  }
}


# Return the full path of an HPSS directory

sub hpss_dirpath {
  my ($path) = @_;
  my $safepath = shell_esc($path);
  my $hsiret = $safepath;
  if (!($safepath =~ /^\//)) { # not already absolute path
    my $hsicom = $hsiexec." -q find . -name ".$safepath." -type d 2>&1 | head -q -n 1";
    $hsiret = `$hsicom`;
    chomp($hsiret);
    if ($hsiret =~ /.*\/$/) {
      chop($hsiret);
    }
  }
#  print "chop / dirpath: $hsiret#\n";
  return $hsiret;
}


# Functions to manipulate file listings on HPSS

sub hpss_listing_add_dir {
  my ($rootref, $rootdir, $name) = @_;
  my $empty = {};
  my $path;
  if ($rootdir eq "") {
    $$rootref{"type"} = "d";
    $$rootref{"path"} = $name;
    $$rootref{"parent"} = undef;
    $$rootref{"tree"} = $empty;
  } else {
    $path = $rootdir."/".$name;
    my $record = {"type"=>"d", "path"=>$path, "parent"=>$rootref, "tree"=>$empty};
    ${$$rootref{"tree"}}{$name} = $record;
  }
  return;
}

sub hpss_listing_add_file {
  my ($rootref, $rootdir, $name, $size, $year, $month, $day, $hour, $minute, $second) = @_;
  my $path = $rootdir."/".$name;
  my $record = {"type"=>"f", "path"=>$path, "size"=>$size, "year"=>$year, "month"=>$month, "day"=>$day, "hour"=>$hour, "minute"=>$minute, "second"=>$second};
  ${$$rootref{"tree"}}{$name} = $record;
  return;
}

sub hpss_listing_node_comp {
  my ($record, $year, $month, $day, $hour, $minute, $second) = @_;
  my $localtime;
  my $hpsstime;
  my $result;
  $localtime = POSIX::mktime($second, $minute, $hour, $day, $month, $year - 1900);
  $hpsstime = POSIX::mktime($$record{"second"}, $$record{"minute"}, $$record{"hour"}, $$record{"day"}, $$record{"month"}, $$record{"year"} - 1900);
  return $hpsstime - $localtime;
} 

sub hpss_listing {
  my ($path) = @_;
  my $root = {};
  my $curroot = $root;
  
  print "hsync:  Looking up root path of HPSS files...";
  my $currootpath = hpss_dirpath($path);
  hpss_listing_add_dir($curroot, "", $currootpath);
  print "      DONE\n";
  
  print "hsync:  Retrieving list of HPSS files...";
  my $filecount = 0;
  my $saferootpath = shell_esc($currootpath);
  my $lstcom = $hsiexec." -q ls -R -O -l -D \"".$saferootpath."\" 2>&1 |";
  open(LST, $lstcom) || die("\nCannot get HPSS directory listing of $saferootpath\n\n");
  
  while (<LST>) {
    chomp;
    if (/^\s\//) { # we are at the start of a directory- stupid carriage returns!
      my $dirpath = $_;
      chop($dirpath);
      $dirpath =~ s/^.//s;
      my $dirbase = basename($dirpath);
      my $dirname = dirname($dirpath);
      if (length($currootpath) > length($dirname)) { # ascend to correct level
        while ($dirname ne $currootpath) {
          $curroot = $$curroot{"parent"};
          $currootpath = $$curroot{"path"};
        }
      }
      hpss_listing_add_dir($curroot, $dirname, $dirbase);
      $curroot = ${$$curroot{"tree"}}{$dirbase};
      $currootpath = $dirpath;
    } else { # this is a regular file
      if (! /^d/) { # skip directories- they are handled above
        /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.*)/;
        my $size = $5;
        my $month = $month2num{$7};
        my $day = $8;
        my $modtime = $9;
        my $year = $10;
        my $name = $11;
        my $hour;
        my $minute;
        my $second;
        my @hms = split(/:/, $modtime);
        $hour = $hms[0];
        $minute = $hms[1];
        $second = $hms[2];
        hpss_listing_add_file($curroot, $currootpath, $name, $size, $year, $month, $day, $hour, $minute, $second);
        $filecount++;
      }
    }
  }
  close(LST);
  print "           DONE\nhsync:  ($filecount HPSS files to consider)\n";
  return $root;
}

sub hpss_listing_print {
  my ($root, $offset) = @_;
  my $key;
  my $value;
  my $tree = $$root{"tree"};
  while (($key,$value) = each %$tree) {
    if ($$value{"type"} eq "d") { # descend directory
      print $offset,$key,"\n";
      my $newoff = $offset."  ";
      hpss_listing_print($value, $newoff);
    } else {
      print $offset,$key,"  ",$$value{"size"},"\n";
    }
  }
}


# Get the HPSS source location of a local checkout

sub hpss_source {
  my ($local) = @_;
  my $file = $local."/".$syncfile;
  my $source;
  if ( !( -z $file) && ( -r $file)) {
    open(IN, "$file") || die("\nCannot open $file\; Are you sure this directory is part of a checkout?\n\n");
    while (<IN>) {
      my @F = split(/=/, $_);
      if ($F[0] eq "SOURCE") {
        $source = $F[1];
        chomp($source);
      }
    }
    close(IN);
    if (length($source) < 1) {
      die("\nHPSS source not specified in $file\n\n");
    }
  } else {
    die("\nCannot open $file\; Are you sure this directory is part of a checkout?\n\n");
  }
  return $source;
}


# Recursively remove source location files

sub purge_source {
  my ($local) = @_;
  # get a listing of the directory
  opendir(DIR, $local) || die("\nCannot open local directory $local\n\n");
  my @listing = readdir(DIR);
  closedir(DIR);
  
  my $file;
  foreach $file (@listing) {
    if (($file ne ".") && ($file ne "..")) {
      my $filepath = $local."/".$file;
      if ($file eq $syncfile) {
        unlink($filepath);
      } elsif ( -d $filepath ) {
        purge_source($filepath);
      }
    }
  }
  return;
}


# Recursively add source location files

sub add_source {
  my ($local, $hpss) = @_;
  # get a listing of the directory
  opendir(DIR, $local) || die("\nCannot open local directory $local\n\n");
  my @listing = readdir(DIR);
  closedir(DIR);
  
  my $file;
  foreach $file (@listing) {
    if (($file ne ".") && ($file ne "..")) {
      my $filepath = $local."/".$file;
      my $hpsspath = $hpss."/".$file;
      if ( -d $filepath ) { # descend
        add_source($filepath, $hpsspath);
      }
    }
  }
  my $source = $local."/".$syncfile;
  open(SYN, ">$source") || die("\nCannot write .synchsi file in directory $local\n\n");
  print SYN "SOURCE=",$hpss,"\n";
  close(SYN);
  
  return;
}


# Given a "residual" HPSS sub-tree, update global file lists

sub compute_hpss_diff {
  my ($local, $hpss) = @_;
  my $file;
  my $record;
  my $action;
  my $newlocal;
  my $safelocal;
  my $safehpss;
  my $tempsync;
  my $tree = $$hpss{"tree"};
  while (($file,$record) = each %$tree) {
    $newlocal = $local."/".$file;
    $safelocal = shell_esc($newlocal);
    $safehpss = shell_esc($$record{"path"});
    if ($$record{"type"} eq "f") {
      if ($opts{d}) {
        $action = "rm ".$safehpss;
        push(@hpss_actions_commit, $action);
      }
      if ($hsinostage) {
        $action = "get -S -p -U ".$safelocal." : ".$safehpss;
      } else {
        $action = "get -p -U ".$safelocal." : ".$safehpss;
      }
      push(@hpss_actions_update, $action);
      add_entries(\@files_honly, $newlocal, $$record{"path"});
    } else { # descend directory
      $action = "mkdir -p ".$safelocal;
      push(@local_actions_update, $action);
      $tempsync = $safelocal."/".$syncfile;
      $action = "echo \'SOURCE=".$$record{"path"}."\' > ".$tempsync;
      push(@local_actions_update, $action);
      add_entries(\@files_honly, $newlocal, $$record{"path"});
      compute_hpss_diff($newlocal, $record);
      if ($opts{d}) {
        $action = "rmdir ".$safehpss;
        push(@hpss_actions_commit, $action);
      }
    }
  }
  return;
}


# Descend local directory and compute differences

sub compute_diff {
  my ($local, $hpss, $hpsspath, $rlocalcount) = @_;
 
  # get a listing of the directory
  opendir(DIR, $local) || die("\nCannot open local directory $local\n\n");
  my @listing = readdir(DIR);
  closedir(DIR);
  
  # recursively compare directory contents to the corresponding entries on HPSS
  
  my $file;
  my $hdir;
  my $hfile;
  my $lyear;
  my $lmonth;
  my $lday;
  my $lhour;
  my $lmin;
  my $lsec;
  my $tree;
  my $ret;
  my $action;
  my $tempsync;
  if ($hpss) {
    $tree = $$hpss{"tree"};
  } else {
    $tree = undef;
  }
  foreach $file (@listing) {
    if (($file ne ".") && ($file ne "..") && ($file ne $syncfile)) {
      my $filepath = $local."/".$file;
      my $safelocal = shell_esc($filepath);
      my $hpssfilepath = $hpsspath."/".$file;
      my $safehpss = shell_esc($hpssfilepath);
      if (-d $filepath) { # this is a directory
        if ($tree) {        
          $hdir = $$tree{$file};
          if ($hdir) { # names match
            if ($$hdir{"type"} eq "d") { # types match; descend
              compute_diff($filepath, $hdir, $hpssfilepath, $rlocalcount);
            } else { # type mismatch
              die("\nERROR: $filepath is a regular file, and corresponding\n         location on HPSS is a directory!\n       Please resolve this situation manually.\n\n");
            }
            
            # remove this matching directory from tree
            $ret = delete($$tree{$file});
        
          } else { # corresponding hpss directory missing
            $action = "mkdir ".$safehpss;
            push(@hpss_actions_commit, $action);
            $tempsync = $safelocal."/".$syncfile;
            $action = "echo \'SOURCE=".$hpssfilepath."\' > ".$tempsync;
            push(@local_actions_commit, $action);
            add_entries(\@files_lonly, $filepath, $hpssfilepath);
            compute_diff($filepath, undef, $hpssfilepath, $rlocalcount);
            if ($opts{d}) {
              $action = "rm -f ".$tempsync;
              push(@local_actions_update, $action);
              $action = "rmdir ".$safelocal;
              push(@local_actions_update, $action);
            }
          }
        } else { # corresponding hpss directory missing
          $action = "mkdir ".$safehpss;
          push(@hpss_actions_commit, $action);
          $tempsync = $safelocal."/".$syncfile;
          $action = "echo \'SOURCE=".$hpssfilepath."\' > ".$tempsync;
          push(@local_actions_commit, $action);          
          add_entries(\@files_lonly, $filepath, $hpssfilepath);
          compute_diff($filepath, undef, $hpssfilepath, $rlocalcount); 
          if ($opts{d}) {
            $action = "rm -f ".$tempsync;
            push(@local_actions_update, $action);
            $action = "rmdir ".$safelocal;
            push(@local_actions_update, $action);
          }
        }
      } else { # this is a file
        if ($tree) {
          $hfile = $$tree{$file};
          if ($hfile) { # names match
            if ($$hfile{"type"} eq "f") { # types match
              my $stats = stat($filepath);
              my $size = $stats->size;
              my $mtime = $stats->mtime;
              my $wday;
              my $yday;
              my $isdst;
              ($lsec, $lmin, $lhour, $lday, $lmonth, $lyear, $wday, $yday, $isdst) = localtime($mtime);
              $lyear += 1900;
              my $diff = hpss_listing_node_comp($hfile, $lyear, $lmonth, $lday, $lhour, $lmin, $lsec);
              if (($diff == 0) && ($$hfile{"size"} != $size)) {
                if ($size > $$hfile{"size"}) {
                  $diff = -1;
                } else {
                  $diff = 1;
                }
              }
              if ($diff < 0) {
                $action = "put -p ".$safelocal." : ".$safehpss;
                push(@hpss_actions_commit, $action);
                add_entries(\@files_lnew, $filepath, $$hfile{"path"});
              } elsif ($diff > 0) {
                if ($hsinostage) {
                  $action = "get -S -p -U ".$safelocal." : ".$safehpss;
                } else {
                  $action = "get -p -U ".$safelocal." : ".$safehpss;
                }
                push(@hpss_actions_update, $action);
                add_entries(\@files_hnew, $filepath, $$hfile{"path"});
              }
            } else { # type mismatch
              die("\nERROR: $filepath is a regular file, and corresponding\n         location on HPSS is a directory!\n       Please resolve this situation manually.\n\n");
            }
            
            # delete matching names from tree
            $ret = delete($$tree{$file});
            
          } else { # hpss file missing
            if ($opts{d}) {
              $action = "rm ".$safelocal;
              push(@local_actions_update, $action);
            }
            $action = "put -p ".$safelocal." : ".$safehpss;
            push(@hpss_actions_commit, $action);
            add_entries(\@files_lonly, $filepath, $hpssfilepath);
          }
        } else { # hpss file missing
          if ($opts{d}) {
            $action = "rm ".$safelocal;
            push(@local_actions_update, $action);
          }
          $action = "put -p ".$safelocal." : ".$safehpss;
          push(@hpss_actions_commit, $action);
          add_entries(\@files_lonly, $filepath, $hpssfilepath);
        }
        $$rlocalcount++;
      }
    }
  }
  
  # Now go through the remaining HPSS tree and see what is missing on local disk
  
  if ($hpss) {
    compute_hpss_diff($local, $hpss);
  }
  
  return;
}



# ----- Main Program -----

if (!$ARGV[0]) {
  useage();
}

my $local_path;
my $hpss_relpath;
my $hpss_path;
my $hpss_tree;
my $safelocal;
my $safehpss;

my $key;
my $value;
my $action;
my $localcount = 0;
my $hsicom;

if ($ARGV[0] eq "checkout") {
  if (!$ARGV[1]) {
    print "\nYou must specify an HPSS directory as the source of the checkout\n\n";
    useage();
  }
  
  $hpss_relpath = $ARGV[1];
  if ($hpss_relpath =~ /.*\/$/) {
    chop($hpss_relpath);
  }
  
  $hpss_path = hpss_dirpath($hpss_relpath);
  
  my $exists = hpss_dirstat($hpss_path);
  if (!$exists) {
    die("\nThe directory \"$hpss_path\" does not exist on HPSS!\n\n");
  }
  
  if (!$ARGV[2]) {
    $local_path = "./".basename($hpss_path);
  } else {
    $local_path = $ARGV[2];
  }
  if ($local_path =~ /.*\/$/) {
    chop($local_path);
  }
  my $stats = stat($local_path);
  if ($stats) {
    die("\nThe local directory \"$local_path\" already exists!\n\n");
  }

  # create the local directory
  mkpath($local_path, 0, 0700);
  
  # get files from HPSS
  $safelocal = shell_esc($local_path);
  $safehpss = shell_esc($hpss_path);
  if ($hsinostage) {
    $hsicom = $hsiexec." -q get -S -R -p ".$safelocal." : ".$safehpss;
  } else {
    $hsicom = $hsiexec." -q get -R -p ".$safelocal." : ".$safehpss;
  }
  system($hsicom);
  
  # write source files
  add_source($local_path, $hpss_path);
  

} elsif ($ARGV[0] eq "commit") {
  
  
  $local_path = ".";
  if ($ARGV[1]) {
    $local_path = $ARGV[1];
  }
  $hpss_path = hpss_source($local_path);
  
  $hpss_tree = hpss_listing($hpss_path);
  
  print "hsync:  Computing differences with local copy...";
  
  compute_diff($local_path, $hpss_tree, $$hpss_tree{"path"}, \$localcount);
  
  print "   DONE\nhsync:  ($localcount local files to consider)\n";
  
  if (@hpss_actions_commit > 0) {
    $hpsscomfile = $local_path."/".$hpsscomfile;
    open(OUT, ">$hpsscomfile")||die("\nCannot write temporary HPSS command file to $hpsscomfile\n\n");
    
    foreach $action (@hpss_actions_commit) {
      print OUT $action,"\n";
    }
    
    close(OUT);
    
    # Run HSI commands
    $hsicom = $hsiexec." -q in ".$hpsscomfile;
    system($hsicom);
    
    # Run local commands
    foreach $action (@local_actions_commit) {
      system($action);
    }
    unlink($hpsscomfile);
  }
  
  print "hsync:  HPSS changes complete.\n";
  
  
} elsif ($ARGV[0] eq "update") {
  
  
  $local_path = ".";
  if ($ARGV[1]) {
    $local_path = $ARGV[1];
  }
  $hpss_path = hpss_source($local_path);
  
  $hpss_tree = hpss_listing($hpss_path);
  
  print "hsync:  Computing differences with local copy...";
  
  compute_diff($local_path, $hpss_tree, $$hpss_tree{"path"}, \$localcount);
  
  print "   DONE\nhsync:  ($localcount local files to consider)\n";
  
  if ((@local_actions_update > 0) || (@hpss_actions_update > 0)) {
    $hpsscomfile = $local_path."/".$hpsscomfile;
    open(OUT, ">$hpsscomfile")||die("\nCannot write temporary HPSS command file to $hpsscomfile\n\n");
    
    foreach $action (@hpss_actions_update) {
      print OUT $action,"\n";
    }

    close(OUT);
  
    # Run local commands
    foreach $action (@local_actions_update) {
      system($action);
    }
  
    # Run HSI commands
    $hsicom = $hsiexec." -q in ".$hpsscomfile;
    system($hsicom);
    unlink($hpsscomfile);
  }
  
  print "hsync:  Local copy is up to date.\n";
  
  
} elsif ($ARGV[0] eq "export") {
  
  
  $local_path = ".";
  if ($ARGV[1]) {
    $local_path = $ARGV[1];
  }
  print "hsync:  recursively removing .synchsi files...";
  
  purge_source($local_path);
  
  print "     DONE\n";
  
  
} elsif ($ARGV[0] eq "status") {
  
  
  $local_path = ".";
  if ($ARGV[1]) {
    $local_path = $ARGV[1];
  }
  if ($local_path =~ /.*\/$/) {
    chop($local_path);
  }
  $hpss_path = hpss_source($local_path);
  
  $hpss_tree = hpss_listing($hpss_path);
  
  print "hsync:  Computing differences with local copy...";
  
  compute_diff($local_path, $hpss_tree, $$hpss_tree{"path"}, \$localcount);
  
  print "   DONE\nhsync:  ($localcount local files to consider)\n";
  
  my $totalupdate;
  my $totalcommit;
  if ($opts{d}) {
    $totalupdate = @files_hnew + @files_honly + @files_lonly;
    $totalcommit = @files_lnew + @files_lonly + @files_honly;
  } else {
    $totalupdate = @files_hnew + @files_honly;
    $totalcommit = @files_lnew + @files_lonly;
  }
  my @files_hdel = @files_honly;
  my @files_ldel = @files_lonly;
  
  print "-+-----------------------------------------------------\n";
  if ($totalupdate > 0) { 
    ($key,$value) = shift_entries(\@files_honly);
    while ($key) {
      print "U|A $key\n";
      ($key,$value) = shift_entries(\@files_honly);
    }
    ($key,$value) = shift_entries(\@files_hnew);
    while ($key) {
      print "U|M $key\n";
      ($key,$value) = shift_entries(\@files_hnew);
    }
    if ($opts{d}) {
      ($key,$value) = shift_entries(\@files_ldel);
      while ($key) {
        print "U|D $value\n";
        ($key,$value) = shift_entries(\@files_ldel);
      }
    }
  } else {
    print "   No Changes on Update\n";
  }
  print "-+-----------------------------------------------------\n";
  if ($totalcommit > 0) { 
    ($key,$value) = shift_entries(\@files_lnew);
    while ($key) {
      print "C|M $value\n";
      ($key,$value) = shift_entries(\@files_lnew);
    }
    ($key,$value) = shift_entries(\@files_lonly);
    while ($key) {
      print "C|A $value\n";
      ($key,$value) = shift_entries(\@files_lonly);
    }
    if ($opts{d}) {
      ($key,$value) = shift_entries(\@files_hdel);
      while ($key) {
        print "C|D $value\n";
        ($key,$value) = shift_entries(\@files_hdel);
      }
    }
  } else {
    print "   No Changes on Commit\n";
  }
  print "-+-----------------------------------------------------\n";
  
  if ($opts{b}) {
    print "\n            ACTIONS:\n\n";
    print "------ On Update ------\n";
    foreach $action (@local_actions_update) {
      print "LOCAL:  ", $action, "\n";
    }
    foreach $action (@hpss_actions_update) {
      print "HPSS:   ", $action, "\n";
    }
    
    print "------ On Commit ------\n";
    foreach $action (@local_actions_commit) {
      print "LOCAL:  ", $action, "\n";
    }
    foreach $action (@hpss_actions_commit) {
      print "HPSS:   ", $action, "\n";
    }
    print "\n";
  }

} else {
  print "\nUnrecognized command \"$ARGV[0]\"\n\n";
  useage;
}