Changeset 27303

Show
Ignore:
Timestamp:
06.05.2013 15:23:45 (6 years ago)
Author:
jmt12
Message:

Replacing hardcoded additions to INC and PATH environment variables with conditional ones - this allows us to use the order of values in these variables for precedence, thus allows better support for extensions that override classifiers, plugins etc. ENV and PATH functions already exists in util, but augmentINC() is a new function

Location:
main/trunk/greenstone2/perllib
Files:
6 modified

Legend:

Unmodified
Added
Removed
  • main/trunk/greenstone2/perllib/IncrementalBuildUtils.pm

    r21646 r27303  
    4242    die "GSDLHOME not set\n" unless defined $ENV{'GSDLHOME'}; 
    4343    die "GSDLOS not set\n" unless defined $ENV{'GSDLOS'}; 
    44     unshift (@INC, "$ENV{'GSDLHOME'}/perllib"); 
    45     unshift (@INC, "$ENV{'GSDLHOME'}/perllib/cpan"); 
    46     unshift (@INC, "$ENV{'GSDLHOME'}/perllib/plugins"); 
    47     unshift (@INC, "$ENV{'GSDLHOME'}/perllib/classify"); 
     44 
     45    # - ensure we only add perllib paths to INC if they weren't already there 
     46    # as otherwise we lose the ability to use order in INC as a guide for 
     47    # inheritence/overriding [jmt12] 
     48    my $gsdl_perllib_path = $ENV{'GSDLHOME'} . '/perllib'; 
     49    my $found_path = 0; 
     50    foreach my $inc_path (@INC) 
     51    { 
     52      if ($inc_path eq $gsdl_perllib_path) 
     53      { 
     54        $found_path = 1; 
     55        last; 
     56      } 
     57    } 
     58    if (!$found_path) 
     59    { 
     60      unshift (@INC, $gsdl_perllib_path); 
     61      unshift (@INC, $gsdl_perllib_path . '/cpan'); 
     62      unshift (@INC, $gsdl_perllib_path . '/plugins'); 
     63      unshift (@INC, $gsdl_perllib_path . '/classify'); 
     64    } 
    4865} 
    4966 
     
    6582  $path_separator = ";"; 
    6683} 
    67 $ENV{'PATH'} = &util::filename_cat($ENV{'GSDLHOME'}, "bin", $ENV{'GSDLOS'}) . $path_separator . &util::filename_cat($ENV{'GSDLHOME'}, "bin", "script") . $path_separator.$ENV{'PATH'}; 
     84# - once again we need to ensure we aren't duplicating paths on the environment 
     85# otherwise things like extension executables won't be correctly used in 
     86# preference to main Greenstone ones [jmt12] 
     87my @env_path = split($path_separator, $ENV{'PATH'}); 
     88my $os_binary_path = &util::filename_cat($ENV{'GSDLHOME'}, 'bin', $ENV{'GSDLOS'}); 
     89my $script_path = &util::filename_cat($ENV{'GSDLHOME'}, 'bin', 'script'); 
     90my $found_os_bin = 0; 
     91foreach my $path (@env_path) 
     92{ 
     93  if ($path eq $os_binary_path) 
     94  { 
     95    $found_os_bin = 1; 
     96    last; 
     97  } 
     98} 
     99if (!$found_os_bin) 
     100{ 
     101  $ENV{'PATH'} = $os_binary_path . $path_separator . $script_path . $path_separator . $ENV{'PATH'}; 
     102} 
     103 
    68104 
    69105# /** 
  • main/trunk/greenstone2/perllib/classify.pm

    r23118 r27303  
    2929 
    3030require util; 
     31use FileUtils; 
    3132require AllList; 
    3233 
     
    4647 
    4748    # find the classifier 
    48     my $customclassname; 
     49    # - used to have hardcoded list of places to load classifier from. We 
     50    # should, instead, try loading from all of the perllib places on the 
     51    # library path, as that improves support for extensions. Special cases 
     52    # needed for collection specific and custom classifier. [jmt12] 
     53    my @possible_class_paths; 
    4954    if (defined($ENV{'GSDLCOLLECTION'})) 
    5055    { 
    51     $customclassname = &util::filename_cat($ENV{'GSDLCOLLECTDIR'}, "custom", $ENV{'GSDLCOLLECTION'}, 
    52                                               "perllib", "classify", "${classifier}.pm"); 
    53     } 
    54     my $colclassname = &util::filename_cat($ENV{'GSDLCOLLECTDIR'}, "perllib", "classify", "${classifier}.pm"); 
    55     my $mainclassname = &util::filename_cat($ENV{'GSDLHOME'}, "perllib", "classify", "${classifier}.pm"); 
    56  
    57     if (defined($customclassname) && -e $customclassname) { require $customclassname; } 
    58     elsif (-e $colclassname) { require $colclassname; } 
    59     elsif (-e $mainclassname) { require $mainclassname; } 
    60     else {  
    61     &gsprintf(STDERR, "{classify.could_not_find_classifier}\n", $classifier) && die "\n"; 
    62     } 
     56      push(@possible_class_paths, &FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'}, 'custom', $ENV{'GSDLCOLLECTION'}, 'perllib', 'classify', $classifier . '.pm')); 
     57    } 
     58    # (why does GSDLCOLLECTDIR get set to GSDLHOME for classinfo calls?) 
     59    if ($ENV{'GSDLCOLLECTDIR'} ne $ENV{'GSDLHOME'}) 
     60    { 
     61      push(@possible_class_paths, &FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'}, 'perllib', 'classify', $classifier . '.pm')); 
     62    } 
     63    foreach my $library_path (@INC) 
     64    { 
     65      # only interested in classify paths found in the library paths 
     66      if ($library_path =~ /classify$/) 
     67      { 
     68       push(@possible_class_paths, &FileUtils::filenameConcatenate($library_path, $classifier . '.pm')); 
     69      } 
     70    } 
     71    my $found_class = 0; 
     72    foreach my $possible_class_path (@possible_class_paths) 
     73    { 
     74      if (-e $possible_class_path) 
     75      { 
     76        require $possible_class_path; 
     77        $found_class = 1; 
     78        last; 
     79      } 
     80    } 
     81    if (!$found_class) 
     82    { 
     83      &gsprintf(STDERR, "{classify.could_not_find_classifier}\n", $classifier) && die "\n"; 
     84    } 
     85 
    6386    my ($classobj); 
    6487    my $options = "-gsdlinfo"; 
     
    7497    my $classify_number  = 1; 
    7598 
    76      my $colclassdir = &util::filename_cat($ENV{'GSDLCOLLECTDIR'},"perllib/classify"); 
    77      unshift (@INC, $colclassdir); 
    78      
     99    my $colclassdir = &FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'},"perllib/classify"); 
     100    # - ensure colclassdir doesn't already exist in INC before adding, other- 
     101    # wise we risk clobbering classifier inheritence implied by order of paths 
     102    # in INC [jmt12] 
     103    my $inc_paths = join(':',@INC); 
     104    if ($inc_paths !~ /$colclassdir/) 
     105    { 
     106      unshift (@INC, $colclassdir); 
     107    } 
     108 
    79109    foreach my $classifyoption (@$classify_list) { 
    80110 
     
    84114 
    85115    # find the classifier 
    86         my $customclassname = &util::filename_cat($ENV{'GSDLCOLLECTDIR'}, "custom", $ENV{'GSDLCOLLECTION'}, 
    87                                                   "perllib", "classify", "${classname}.pm"); 
    88         my $colclassname = &util::filename_cat($ENV{'GSDLCOLLECTDIR'}, "perllib", "classify", "${classname}.pm"); 
    89         my $mainclassname = &util::filename_cat($ENV{'GSDLHOME'}, "perllib", "classify", "${classname}.pm"); 
    90  
    91     if (-e $customclassname) { require $customclassname; } 
    92     elsif (-e $colclassname) { require $colclassname; } 
    93     elsif (-e $mainclassname) { require $mainclassname; } 
    94     else { &gsprintf(STDERR, "{classify.could_not_find_classifier}\n", $classname) && die "\n"; 
    95            # die "ERROR - couldn't find classifier \"$classname\"\n"; 
     116        # - replaced as explained in load_classifier_for_info() [jmt12] 
     117        my @possible_class_paths; 
     118        if (defined($ENV{'GSDLCOLLECTION'})) 
     119        { 
     120          push(@possible_class_paths, &FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'}, 'custom', $ENV{'GSDLCOLLECTION'}, 'perllib', 'classify', $classname . '.pm')); 
     121        } 
     122        # (why does GSDLCOLLECTDIR get set to GSDLHOME for classinfo calls?) 
     123        if ($ENV{'GSDLCOLLECTDIR'} ne $ENV{'GSDLHOME'}) 
     124        { 
     125          push(@possible_class_paths,&FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'}, 'perllib', 'classify', $classname . '.pm')); 
     126        } 
     127        foreach my $library_path (@INC) 
     128        { 
     129          # only interested in classify paths found in the library paths 
     130          if ($library_path =~ /classify$/) 
     131          { 
     132            push(@possible_class_paths, &FileUtils::filenameConcatenate($library_path, $classname . '.pm')); 
     133          } 
     134        } 
     135        my $found_class = 0; 
     136        foreach my $possible_class_path (@possible_class_paths) 
     137        { 
     138          if (-e $possible_class_path) 
     139          { 
     140            require $possible_class_path; 
     141            $found_class = 1; 
     142            last; 
     143          } 
     144        } 
     145        if (!$found_class) 
     146        { 
     147          &gsprintf(STDERR, "{classify.could_not_find_classifier}\n", $classname) && die "\n"; 
    96148        } 
    97149 
  • main/trunk/greenstone2/perllib/parse2.pm

    r22732 r27303  
    3535    die "GSDLHOME not set\n" unless defined $ENV{'GSDLHOME'}; 
    3636    die "GSDLOS not set\n" unless defined $ENV{'GSDLOS'}; 
    37     unshift (@INC, "$ENV{'GSDLHOME'}/perllib"); 
    38     unshift (@INC, "$ENV{'GSDLHOME'}/perllib/cpan"); 
     37 
     38    # - ensure perllib paths don't already exist in INC before adding, other- 
     39    # wise we risk clobbering plugin/classifier inheritence implied by order 
     40    # of paths in INC [jmt12] 
     41    my $gsdl_perllib_path = $ENV{'GSDLHOME'} . '/perllib'; 
     42    my $found_path = 0; 
     43    foreach my $inc_path (@INC) 
     44    { 
     45      if ($inc_path eq $gsdl_perllib_path) 
     46      { 
     47        $found_path = 1; 
     48        last; 
     49      } 
     50    } 
     51    if (!$found_path) 
     52    { 
     53      unshift (@INC, $gsdl_perllib_path); 
     54      unshift (@INC, $gsdl_perllib_path . '/cpan'); 
     55    } 
    3956} 
    4057 
  • main/trunk/greenstone2/perllib/parse3.pm

    r16125 r27303  
    88    die "GSDLHOME not set\n" unless defined $ENV{'GSDLHOME'}; 
    99    die "GSDLOS not set\n" unless defined $ENV{'GSDLOS'}; 
    10     unshift (@INC, "$ENV{'GSDLHOME'}/perllib"); 
    11     unshift (@INC, "$ENV{'GSDLHOME'}/perllib/cpan"); 
     10 
     11    # - ensure perllib paths don't already exist in INC before adding, other- 
     12    # wise we risk clobbering plugin/classifier inheritence implied by order 
     13    # of paths in INC [jmt12] 
     14    my $gsdl_perllib_path = $ENV{'GSDLHOME'} . '/perllib'; 
     15    my $found_path = 0; 
     16    foreach my $inc_path (@INC) 
     17    { 
     18      if ($inc_path eq $gsdl_perllib_path) 
     19      { 
     20        $found_path = 1; 
     21        last; 
     22      } 
     23    } 
     24    if (!$found_path) 
     25    { 
     26      unshift (@INC, $gsdl_perllib_path); 
     27      unshift (@INC, $gsdl_perllib_path . '/cpan'); 
     28    } 
    1229} 
    1330 
  • main/trunk/greenstone2/perllib/plugin.pm

    r26223 r27303  
    3232 
    3333require util; 
     34use FileUtils; 
    3435use gsprintf 'gsprintf'; 
    3536 
     
    8485    # pp_plugname shorthand for 'perllib' 'plugin' '$pluginname.pm'  
    8586    my $pp_plugname  
    86     = &util::filename_cat('perllib', 'plugins', "${pluginname}.pm"); 
     87    = &FileUtils::filenameConcatenate('perllib', 'plugins', "${pluginname}.pm"); 
    8788    my $collectdir = $ENV{'GSDLCOLLECTDIR'}; 
    8889 
     
    9192    { 
    9293    my $customplugname  
    93         = &util::filename_cat($collectdir, "custom",$ENV{'GSDLCOLLECTION'}, 
     94        = &FileUtils::filenameConcatenate($collectdir, "custom",$ENV{'GSDLCOLLECTION'}, 
    9495                  $pp_plugname); 
    9596    push(@check_list,$customplugname); 
    9697    } 
    9798 
    98     my $colplugname = &util::filename_cat($collectdir, $pp_plugname); 
     99    my $colplugname = &FileUtils::filenameConcatenate($collectdir, $pp_plugname); 
    99100    push(@check_list,$colplugname); 
    100101 
    101102    if (defined $ENV{'GSDLEXTS'}) { 
    102103 
    103     my $ext_prefix = &util::filename_cat($ENV{'GSDLHOME'}, "ext"); 
     104    my $ext_prefix = &FileUtils::filenameConcatenate($ENV{'GSDLHOME'}, "ext"); 
    104105 
    105106    my @extensions = split(/:/,$ENV{'GSDLEXTS'}); 
    106107    foreach my $e (@extensions) { 
    107         my $extplugname = &util::filename_cat($ext_prefix, $e, $pp_plugname); 
     108        my $extplugname = &FileUtils::filenameConcatenate($ext_prefix, $e, $pp_plugname); 
    108109        push(@check_list,$extplugname); 
    109110 
     
    112113    if (defined $ENV{'GSDL3EXTS'}) { 
    113114 
    114     my $ext_prefix = &util::filename_cat($ENV{'GSDL3SRCHOME'}, "ext"); 
     115    my $ext_prefix = &FileUtils::filenameConcatenate($ENV{'GSDL3SRCHOME'}, "ext"); 
    115116 
    116117    my @extensions = split(/:/,$ENV{'GSDL3EXTS'}); 
    117118    foreach my $e (@extensions) { 
    118         my $extplugname = &util::filename_cat($ext_prefix, $e, $pp_plugname); 
     119        my $extplugname = &FileUtils::filenameConcatenate($ext_prefix, $e, $pp_plugname); 
    119120        push(@check_list,$extplugname); 
    120121 
     
    123124 
    124125 
    125     my $mainplugname = &util::filename_cat($ENV{'GSDLHOME'}, $pp_plugname); 
     126    my $mainplugname = &FileUtils::filenameConcatenate($ENV{'GSDLHOME'}, $pp_plugname); 
    126127    push(@check_list,$mainplugname); 
    127128 
     
    130131    if (-e $plugname) { 
    131132        # lets add perllib folder to INC 
     133          # check it isn't already there first [jmt12] 
    132134        my ($perllibfolder) = $plugname =~ /^(.*[\/\\]perllib)[\/\\]plugins/; 
    133         if (-d $perllibfolder) { 
     135        if (-d $perllibfolder) 
     136            { 
     137              my $found_perllibfolder = 0; 
     138              foreach my $path (@INC) 
     139              { 
     140                if ($path eq $perllibfolder) 
     141                { 
     142                  $found_perllibfolder = 1; 
     143                  last; 
     144                } 
     145              } 
     146              if (!$found_perllibfolder) 
     147              { 
    134148        unshift (@INC, $perllibfolder); 
    135         }  
     149              } 
     150        } 
    136151        require $plugname; 
    137152        $success=1; 
     
    171186    $failhandle = 'STDERR' unless defined $failhandle; 
    172187 
    173     my $colperllibdir = &util::filename_cat($ENV{'GSDLCOLLECTDIR'},"perllib"); 
    174     unshift (@INC, $colperllibdir);   
    175     my $colplugindir = &util::filename_cat($colperllibdir,"plugins"); 
    176      unshift (@INC, $colplugindir);   
     188    # before pushing collection perl and plugin directories onto INC, test that 
     189    # they aren't already there [jmt12] 
     190    &util::augmentINC(&FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'},'perllib')); 
     191    &util::augmentINC(&FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'},'perllib','plugins')); 
    177192 
    178193    map { $_ = "\"$_\""; } @$globaloptions; 
     
    270285    # the .kill file is a handy (if not very elegant) way of aborting  
    271286    # an import.pl or buildcol.pl process 
    272     if (-e &util::filename_cat ($ENV{'GSDLCOLLECTDIR'}, ".kill")) { 
     287    if (-e &FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'}, ".kill")) { 
    273288    gsprintf($outhandle, "{plugin.kill_file}\n"); 
    274289    die "\n"; 
     
    301316    # the .kill file is a handy (if not very elegant) way of aborting  
    302317    # an import.pl or buildcol.pl process 
    303     if (-e &util::filename_cat ($ENV{'GSDLCOLLECTDIR'}, ".kill")) { 
     318    if (-e &FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'}, ".kill")) { 
    304319    gsprintf($outhandle, "{plugin.kill_file}\n"); 
    305320    die "\n"; 
     
    352367    # the .kill file is a handy (if not very elegant) way of aborting  
    353368    # an import.pl or buildcol.pl process 
    354     if (-e &util::filename_cat ($ENV{'GSDLCOLLECTDIR'}, ".kill")) { 
     369    if (-e &FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'}, ".kill")) { 
    355370    gsprintf($outhandle, "{plugin.kill_file}\n"); 
    356371    die "\n"; 
  • main/trunk/greenstone2/perllib/util.pm

    r26976 r27303  
    3535# $^X works better in some cases to return the path to perl used to launch the script, 
    3636# but if launched with plain "perl" (no full-path), that will be just what it returns. 
    37 use Config;  
     37use Config; 
     38# New module for file related utility functions - intended as a 
     39# placeholder for an extension that allows a variety of different 
     40# filesystems (FTP, HTTP, SAMBA, WEBDav, HDFS etc) 
     41use FileUtils; 
    3842 
    3943# removes files (but not directories) 
    4044sub rm { 
    41     my (@files) = @_; 
    42  
    43     my @filefiles = (); 
    44  
    45     # make sure the files we want to delete exist  
    46     # and are regular files 
    47     foreach my $file (@files) { 
    48     if (!-e $file) { 
    49         print STDERR "util::rm $file does not exist\n"; 
    50     } elsif ((!-f $file) && (!-l $file)) { 
    51         print STDERR "util::rm $file is not a regular (or symbolic) file\n"; 
    52     } else { 
    53         push (@filefiles, $file); 
    54     } 
    55     } 
    56      
    57     # remove the files 
    58     my $numremoved = unlink @filefiles; 
    59  
    60     # check to make sure all of them were removed 
    61     if ($numremoved != scalar(@filefiles)) { 
    62     print STDERR "util::rm Not all files were removed\n"; 
    63     } 
    64 } 
    65  
    66 # removes files (but not directories) - can rename this to the default 
    67 # "rm" subroutine  when debugging the deletion of individual files. 
    68 sub rm_debug { 
    69     my (@files) = @_; 
    70     my @filefiles = (); 
    71  
    72     # make sure the files we want to delete exist  
    73     # and are regular files 
    74     foreach my $file (@files) { 
    75         if (!-e $file) { 
    76             print STDERR "util::rm $file does not exist\n"; 
    77         } elsif ((!-f $file) && (!-l $file)) { 
    78             print STDERR "util::rm $file is not a regular (or symbolic) file\n"; 
    79         } else { # debug message 
    80             unlink($file) or warn "Could not delete file $file: $!\n"; 
    81         } 
    82     } 
    83 } 
    84  
     45  warnings::warnif("deprecated", "util::rm() is deprecated, using FileUtils::removeFiles() instead"); 
     46  return &FileUtils::removeFiles(@_); 
     47} 
    8548 
    8649# recursive removal 
    8750sub filtered_rm_r { 
    88     my ($files,$file_accept_re,$file_reject_re) = @_; 
    89  
    90 #   my ($cpackage,$cfilename,$cline,$csubr,$chas_args,$cwantarray) = caller(2); 
    91 #   my ($lcfilename) = ($cfilename =~ m/([^\\\/]*)$/); 
    92 #   print STDERR "** Calling method (2): $lcfilename:$cline $cpackage->$csubr\n"; 
    93      
    94     my @files_array = (ref $files eq "ARRAY") ? @$files : ($files); 
    95  
    96     # recursively remove the files 
    97     foreach my $file (@files_array) { 
    98     $file =~ s/[\/\\]+$//; # remove trailing slashes 
    99      
    100     if (!-e $file) { 
    101         print STDERR "util::filtered_rm_r $file does not exist\n"; 
    102  
    103     } elsif ((-d $file) && (!-l $file)) { # don't recurse down symbolic link 
    104         # get the contents of this directory 
    105         if (!opendir (INDIR, $file)) { 
    106         print STDERR "util::filtered_rm_r could not open directory $file\n"; 
    107         } else { 
    108         my @filedir = grep (!/^\.\.?$/, readdir (INDIR)); 
    109         closedir (INDIR); 
    110                  
    111         # remove all the files in this directory 
    112         map {$_="$file/$_";} @filedir; 
    113         &filtered_rm_r (\@filedir,$file_accept_re,$file_reject_re); 
    114  
    115         if (!defined $file_accept_re && !defined $file_reject_re) { 
    116             # remove this directory 
    117             if (!rmdir $file) { 
    118             print STDERR "util::filtered_rm_r couldn't remove directory $file\n"; 
    119             } 
    120         } 
    121         } 
    122     } else { 
    123         next if (defined $file_reject_re && ($file =~ m/$file_reject_re/)); 
    124  
    125         if ((!defined $file_accept_re) || ($file =~ m/$file_accept_re/)) { 
    126         # remove this file   
    127         &rm ($file); 
    128         } 
    129     } 
    130     } 
    131 } 
    132  
     51  warnings::warnif("deprecated", "util::filtered_rm_r() is deprecated, using FileUtils::removeFilesFiltered() instead"); 
     52  return &FileUtils::removeFilesFiltered(@_); 
     53} 
    13354 
    13455# recursive removal 
    13556sub rm_r { 
    136     my (@files) = @_; 
    137      
    138     # use the more general (but reterospectively written function 
    139     # filtered_rm_r function() 
    140  
    141     filtered_rm_r(\@files,undef,undef); # no accept or reject expressions 
    142 } 
    143  
    144  
    145  
     57  warnings::warnif("deprecated", "util::rm_r() is deprecated, using FileUtils::recursiveRemoveFiles() instead"); 
     58  return &FileUtils::removeFilesRecursive(@_); 
     59} 
    14660 
    14761# moves a file or a group of files 
    14862sub mv { 
    149     my $dest = pop (@_); 
    150     my (@srcfiles) = @_; 
    151  
    152     # remove trailing slashes from source and destination files 
    153     $dest =~ s/[\\\/]+$//; 
    154     map {$_ =~ s/[\\\/]+$//;} @srcfiles; 
    155  
    156     # a few sanity checks 
    157     if (scalar (@srcfiles) == 0) { 
    158     print STDERR "util::mv no destination directory given\n"; 
    159     return; 
    160     } elsif ((scalar (@srcfiles) > 1) && (!-d $dest)) { 
    161     print STDERR "util::mv if multiple source files are given the ". 
    162         "destination must be a directory\n"; 
    163     return; 
    164     } 
    165  
    166     # move the files 
    167     foreach my $file (@srcfiles) { 
    168     my $tempdest = $dest; 
    169     if (-d $tempdest) { 
    170         my ($filename) = $file =~ /([^\\\/]+)$/; 
    171         $tempdest .= "/$filename"; 
    172     } 
    173     if (!-e $file) { 
    174         print STDERR "util::mv $file does not exist\n"; 
    175     } else { 
    176         if(!rename ($file, $tempdest)) { 
    177         print STDERR "**** Failed to rename $file to $tempdest\n"; 
    178         &File::Copy::copy($file, $tempdest); 
    179         &rm($file); 
    180         }  
    181         elsif(-e $file) { # rename (partially) succeeded) but srcfile still exists after rename 
    182         #print STDERR "*** srcfile $file still exists after rename to $tempdest\n"; 
    183         if(!-e $tempdest) { 
    184             print STDERR "@@@@ ERROR: $tempdest does not exist\n"; 
    185         } 
    186         # Sometimes the rename operation fails (as does File::Copy::move). 
    187         # This turns out to be because the files are hardlinked.  
    188         # Need to do a copy-delete in this case, however, the copy step is not necessary:  
    189         # the srcfile got renamed into tempdest, but srcfile itself still exists, delete it. 
    190         #&File::Copy::copy($file, $tempdest); 
    191  
    192         &rm($file);      
    193         } 
    194     } 
    195     } 
     63  warnings::warnif("deprecated", "util::mv() is deprecated, using FileUtils::moveFiles() instead"); 
     64  return &FileUtils::moveFiles(@_); 
    19665} 
    19766 
     
    20170# but other files and folders in the target will continue to exist 
    20271sub mv_dir_contents { 
    203     my ($src_dir, $dest_dir) = @_; 
    204      
    205     # Obtain listing of all files within src_dir 
    206     # Note that readdir lists relative paths, as well as . and .. 
    207     opendir(DIR, "$src_dir"); 
    208     my @files= readdir(DIR);  
    209     close(DIR); 
    210      
    211     my @full_path_files = (); 
    212     foreach my $file (@files) {  
    213         # process all except . and .. 
    214         unless($file eq "." || $file eq "..") { 
    215              
    216             my $dest_subdir = &filename_cat($dest_dir, $file); # $file is still a relative path 
    217          
    218             # construct absolute paths 
    219             $file = &filename_cat($src_dir, $file); # $file is now an absolute path 
    220              
    221             # Recurse on directories which have an equivalent in target dest_dir 
    222             # If $file is a directory that already exists in target $dest_dir,  
    223             # then a simple move operation will fail (definitely on Windows). 
    224             if(-d $file && -d $dest_subdir) {  
    225                 #print STDERR "**** $file is a directory also existing in target, its contents to be copied to $dest_subdir\n"; 
    226                 &mv_dir_contents($file, $dest_subdir); 
    227                  
    228                 # now all content is moved across, delete empty dir in source folder 
    229                 if(&is_dir_empty($file)) { 
    230                     if (!rmdir $file) { 
    231                         print STDERR "ERROR. util::mv_dir_contents couldn't remove directory $file\n"; 
    232                     }  
    233                 } else { # error 
    234                     print STDERR "ERROR. util::mv_dir_contents: subfolder $file still non-empty after moving contents to $dest_subdir\n"; 
    235                 } 
    236             } else { # process files and any directories that don't already exist with a simple move 
    237                 push(@full_path_files, $file); 
    238             }            
    239         } 
    240     } 
    241      
    242     if(!&dir_exists($dest_dir)) { # create target toplevel folder or subfolders if they don't exist 
    243         &mk_dir($dest_dir); 
    244     } 
    245  
    246     #print STDERR "@@@@@ Copying files |".join(",", @full_path_files)."| to: $dest_dir\n"; 
    247  
    248     if(@full_path_files) { # if non-empty, there's something to copy across 
    249         &mv(@full_path_files, $dest_dir); 
    250     } 
    251 } 
    252  
     72  warnings::warnif("deprecated", "util::mv_dir_contents() is deprecated, using FileUtils::moveDirectoryContents() instead"); 
     73  return &FileUtils::moveDirectoryContents(@_); 
     74} 
    25375 
    25476# copies a file or a group of files 
    25577sub cp { 
    256     my $dest = pop (@_); 
    257     my (@srcfiles) = @_; 
    258  
    259     # remove trailing slashes from source and destination files 
    260     $dest =~ s/[\\\/]+$//; 
    261     map {$_ =~ s/[\\\/]+$//;} @srcfiles; 
    262  
    263     # a few sanity checks 
    264     if (scalar (@srcfiles) == 0) { 
    265     print STDERR "util::cp no destination directory given\n"; 
    266     return; 
    267     } elsif ((scalar (@srcfiles) > 1) && (!-d $dest)) { 
    268     print STDERR "util::cp if multiple source files are given the ". 
    269         "destination must be a directory\n"; 
    270     return; 
    271     } 
    272  
    273     # copy the files 
    274     foreach my $file (@srcfiles) { 
    275     my $tempdest = $dest; 
    276     if (-d $tempdest) { 
    277         my ($filename) = $file =~ /([^\\\/]+)$/; 
    278         $tempdest .= "/$filename"; 
    279     } 
    280     if (!-e $file) { 
    281         print STDERR "util::cp $file does not exist\n"; 
    282     } elsif (!-f $file) { 
    283         print STDERR "util::cp $file is not a plain file\n"; 
    284     } else { 
    285         &File::Copy::copy ($file, $tempdest); 
    286     } 
    287     } 
    288 } 
    289  
    290  
     78  warnings::warnif("deprecated", "util::cp() is deprecated, using FileUtils::copyFiles() instead"); 
     79  return &FileUtils::copyFiles(@_); 
     80} 
    29181 
    29282# recursively copies a file or group of files 
     
    29585# another use cp instead 
    29686sub cp_r { 
    297     my $dest = pop (@_); 
    298     my (@srcfiles) = @_; 
    299  
    300     # a few sanity checks 
    301     if (scalar (@srcfiles) == 0) { 
    302     print STDERR "util::cp_r no destination directory given\n"; 
    303     return; 
    304     } elsif (-f $dest) { 
    305     print STDERR "util::cp_r destination must be a directory\n"; 
    306     return; 
    307     } 
    308      
    309     # create destination directory if it doesn't exist already 
    310     if (! -d $dest) { 
    311     my $store_umask = umask(0002); 
    312     mkdir ($dest, 0777); 
    313     umask($store_umask); 
    314     }  
    315  
    316     # copy the files 
    317     foreach my $file (@srcfiles) { 
    318  
    319     if (!-e $file) { 
    320         print STDERR "util::cp_r $file does not exist\n"; 
    321  
    322     } elsif (-d $file) { 
    323         # make the new directory 
    324         my ($filename) = $file =~ /([^\\\/]*)$/; 
    325         $dest = &util::filename_cat ($dest, $filename); 
    326         my $store_umask = umask(0002); 
    327         mkdir ($dest, 0777); 
    328         umask($store_umask); 
    329  
    330         # get the contents of this directory 
    331         if (!opendir (INDIR, $file)) { 
    332         print STDERR "util::cp_r could not open directory $file\n"; 
    333         } else { 
    334         my @filedir = readdir (INDIR); 
    335         closedir (INDIR); 
    336         foreach my $f (@filedir) { 
    337             next if $f =~ /^\.\.?$/; 
    338             # copy all the files in this directory 
    339             my $ff = &util::filename_cat ($file, $f);  
    340             &cp_r ($ff, $dest); 
    341         } 
    342         } 
    343  
    344     } else { 
    345         &cp($file, $dest); 
    346     } 
    347     } 
    348 } 
     87  warnings::warnif("deprecated", "util::cp_r() is deprecated, using FileUtils::copyFilesrecursive() instead"); 
     88  return &FileUtils::copyFilesRecursive(@_); 
     89} 
     90 
    34991# recursively copies a file or group of files 
    35092# syntax: cp_r (sourcefiles, destination directory) 
     
    35294# another use cp instead 
    35395sub cp_r_nosvn { 
    354     my $dest = pop (@_); 
    355     my (@srcfiles) = @_; 
    356  
    357     # a few sanity checks 
    358     if (scalar (@srcfiles) == 0) { 
    359     print STDERR "util::cp_r no destination directory given\n"; 
    360     return; 
    361     } elsif (-f $dest) { 
    362     print STDERR "util::cp_r destination must be a directory\n"; 
    363     return; 
    364     } 
    365      
    366     # create destination directory if it doesn't exist already 
    367     if (! -d $dest) { 
    368     my $store_umask = umask(0002); 
    369     mkdir ($dest, 0777); 
    370     umask($store_umask); 
    371     }  
    372  
    373     # copy the files 
    374     foreach my $file (@srcfiles) { 
    375  
    376     if (!-e $file) { 
    377         print STDERR "util::cp_r $file does not exist\n"; 
    378  
    379     } elsif (-d $file) { 
    380         # make the new directory 
    381         my ($filename) = $file =~ /([^\\\/]*)$/; 
    382         $dest = &util::filename_cat ($dest, $filename); 
    383         my $store_umask = umask(0002); 
    384         mkdir ($dest, 0777); 
    385         umask($store_umask); 
    386  
    387         # get the contents of this directory 
    388         if (!opendir (INDIR, $file)) { 
    389         print STDERR "util::cp_r could not open directory $file\n"; 
    390         } else { 
    391         my @filedir = readdir (INDIR); 
    392         closedir (INDIR); 
    393         foreach my $f (@filedir) { 
    394             next if $f =~ /^\.\.?$/; 
    395             next if $f =~ /^\.svn$/; 
    396             # copy all the files in this directory 
    397             my $ff = &util::filename_cat ($file, $f);  
    398             &cp_r ($ff, $dest); 
    399         } 
    400         } 
    401  
    402     } else { 
    403         &cp($file, $dest); 
    404     } 
    405     } 
     96  warnings::warnif("deprecated", "util::cp_r_nosvn() is deprecated, using FileUtils::copyFilesRecursiveNoSVN() instead"); 
     97  return &FileUtils::copyFilesRecursiveNoSVN(@_); 
    40698} 
    40799 
    408100# copies a directory and its contents, excluding subdirectories, into a new directory 
    409101sub cp_r_toplevel { 
    410     my $dest = pop (@_); 
    411     my (@srcfiles) = @_; 
    412  
    413     # a few sanity checks 
    414     if (scalar (@srcfiles) == 0) { 
    415     print STDERR "util::cp_r no destination directory given\n"; 
    416     return; 
    417     } elsif (-f $dest) { 
    418     print STDERR "util::cp_r destination must be a directory\n"; 
    419     return; 
    420     } 
    421      
    422     # create destination directory if it doesn't exist already 
    423     if (! -d $dest) { 
    424     my $store_umask = umask(0002); 
    425     mkdir ($dest, 0777); 
    426     umask($store_umask); 
    427     }  
    428  
    429     # copy the files 
    430     foreach my $file (@srcfiles) { 
    431  
    432     if (!-e $file) { 
    433         print STDERR "util::cp_r $file does not exist\n"; 
    434  
    435     } elsif (-d $file) { 
    436         # make the new directory 
    437         my ($filename) = $file =~ /([^\\\/]*)$/; 
    438         $dest = &util::filename_cat ($dest, $filename); 
    439         my $store_umask = umask(0002); 
    440         mkdir ($dest, 0777); 
    441         umask($store_umask); 
    442  
    443         # get the contents of this directory 
    444         if (!opendir (INDIR, $file)) { 
    445         print STDERR "util::cp_r could not open directory $file\n"; 
    446         } else { 
    447         my @filedir = readdir (INDIR); 
    448         closedir (INDIR); 
    449         foreach my $f (@filedir) { 
    450             next if $f =~ /^\.\.?$/; 
    451              
    452             # copy all the files in this directory, but not directories 
    453             my $ff = &util::filename_cat ($file, $f);  
    454             if (-f $ff) { 
    455             &cp($ff, $dest); 
    456             #&cp_r ($ff, $dest); 
    457             } 
    458         } 
    459         } 
    460  
    461     } else { 
    462         &cp($file, $dest); 
    463     } 
    464     } 
     102  warnings::warnif("deprecated", "util::cp_r_toplevel() is deprecated, using FileUtils::recursiveCopyTopLevel() instead"); 
     103  return &FileUtils::recursiveCopyTopLevel(@_); 
    465104} 
    466105 
    467106sub mk_dir { 
    468     my ($dir) = @_; 
    469  
    470     my $store_umask = umask(0002); 
    471     my $mkdir_ok = mkdir ($dir, 0777); 
    472     umask($store_umask); 
    473      
    474     if (!$mkdir_ok)  
    475     { 
    476     print STDERR "util::mk_dir could not create directory $dir\n"; 
    477     return; 
    478     } 
     107  warnings::warnif("deprecated", "util::mk_dir() is deprecated, using FileUtils::makeDirectory() instead"); 
     108  return &FileUtils::makeDirectory(@_); 
    479109} 
    480110 
     
    483113# slightly faster (surprisingly) - Stefan. 
    484114sub mk_all_dir { 
    485     my ($dir) = @_; 
    486  
    487     # use / for the directory separator, remove duplicate and 
    488     # trailing slashes 
    489     $dir=~s/[\\\/]+/\//g;  
    490     $dir=~s/[\\\/]+$//; 
    491  
    492     # make sure the cache directory exists 
    493     my $dirsofar = ""; 
    494     my $first = 1; 
    495     foreach my $dirname (split ("/", $dir)) { 
    496     $dirsofar .= "/" unless $first; 
    497     $first = 0; 
    498  
    499     $dirsofar .= $dirname; 
    500  
    501     next if $dirname =~ /^(|[a-z]:)$/i; 
    502     if (!-e $dirsofar) 
    503         { 
    504         my $store_umask = umask(0002); 
    505         my $mkdir_ok = mkdir ($dirsofar, 0777); 
    506         umask($store_umask); 
    507         if (!$mkdir_ok) 
    508         { 
    509             print STDERR "util::mk_all_dir could not create directory $dirsofar\n"; 
    510             return; 
    511         } 
    512         } 
    513     } 
     115  warnings::warnif("deprecated", "util::mk_all_dir() is deprecated, using FileUtils::makeAllDirectories() instead"); 
     116  return &FileUtils::makeAllDirectories(@_); 
    514117} 
    515118 
    516119# make hard link to file if supported by OS, otherwise copy the file 
    517120sub hard_link { 
    518     my ($src, $dest, $verbosity) = @_; 
    519  
    520     # remove trailing slashes from source and destination files 
    521     $src =~ s/[\\\/]+$//; 
    522     $dest =~ s/[\\\/]+$//; 
    523  
    524 ##    print STDERR "**** src = ", unicode::debug_unicode_string($src),"\n"; 
    525     # a few sanity checks 
    526     if (-e $dest) { 
    527     # destination file already exists 
    528     return; 
    529     } 
    530     elsif (!-e $src) { 
    531     print STDERR "util::hard_link source file \"$src\" does not exist\n"; 
    532     return 1; 
    533     } 
    534     elsif (-d $src) { 
    535     print STDERR "util::hard_link source \"$src\" is a directory\n"; 
    536     return 1; 
    537     } 
    538  
    539     my $dest_dir = &File::Basename::dirname($dest); 
    540     mk_all_dir($dest_dir) if (!-e $dest_dir); 
    541  
    542  
    543     if (!link($src, $dest)) { 
    544     if ((!defined $verbosity) || ($verbosity>2)) { 
    545         print STDERR "util::hard_link: unable to create hard link. "; 
    546         print STDERR " Copying file: $src -> $dest\n"; 
    547     } 
    548     &File::Copy::copy ($src, $dest); 
    549     } 
    550     return 0; 
     121  warnings::warnif("deprecated", "util::hard_link() is deprecated, using FileUtils::hardLink() instead"); 
     122  return &FileUtils::hardLink(@_); 
    551123} 
    552124 
    553125# make soft link to file if supported by OS, otherwise copy file 
    554126sub soft_link { 
    555     my ($src, $dest, $ensure_paths_absolute) = @_; 
    556  
    557     # remove trailing slashes from source and destination files 
    558     $src =~ s/[\\\/]+$//; 
    559     $dest =~ s/[\\\/]+$//; 
    560  
    561     # Ensure file paths are absolute IF requested to do so  
    562     # Soft_linking didn't work for relative paths 
    563     if(defined $ensure_paths_absolute && $ensure_paths_absolute) { 
    564     # We need to ensure that the src file is the absolute path  
    565     # See http://perldoc.perl.org/File/Spec.html 
    566     if(!File::Spec->file_name_is_absolute( $src ))  { # it's relative 
    567         $src = File::Spec->rel2abs($src); # make absolute 
    568     } 
    569     # Might as well ensure that the destination file's absolute path is used 
    570     if(!File::Spec->file_name_is_absolute( $dest )) { 
    571         $dest = File::Spec->rel2abs($dest); # make absolute 
    572     } 
    573     } 
    574  
    575     # a few sanity checks 
    576     if (!-e $src) { 
    577     print STDERR "util::soft_link source file $src does not exist\n"; 
    578     return 0; 
    579     } 
    580  
    581     my $dest_dir = &File::Basename::dirname($dest); 
    582     mk_all_dir($dest_dir) if (!-e $dest_dir); 
    583  
    584     if ($ENV{'GSDLOS'} =~ /^windows$/i) { 
    585          
    586     # symlink not supported on windows 
    587     &File::Copy::copy ($src, $dest); 
    588  
    589     } elsif (!eval {symlink($src, $dest)}) { 
    590     print STDERR "util::soft_link: unable to create soft link.\n"; 
    591     return 0; 
    592     } 
    593  
    594     return 1; 
     127  warnings::warnif("deprecated", "util::soft_link() is deprecated, using FileUtils::softLink() instead"); 
     128  return &FileUtils::softLink(@_); 
    595129} 
    596130 
     
    625159} 
    626160 
    627  
    628 sub fd_exists 
    629 { 
    630     my $filename_full_path = shift @_; 
    631     my $test_op = shift @_ || "-e"; 
    632  
    633     # By default tests for existance of file or directory (-e) 
    634     # Can be made more specific by providing second parameter (e.g. -f or -d) 
    635  
    636     my $exists = 0; 
    637  
    638     if ($ENV{'GSDLOS'} =~ m/^windows$/i) { 
    639     require Win32; 
    640     my $filename_short_path = Win32::GetShortPathName($filename_full_path);  
    641     if (!defined $filename_short_path) { 
    642         # Was probably still in UTF8 form (not what is needed on Windows) 
    643         my $unicode_filename_full_path = eval "decode(\"utf8\",\$filename_full_path)"; 
    644         if (defined $unicode_filename_full_path) { 
    645         $filename_short_path = Win32::GetShortPathName($unicode_filename_full_path); 
    646         } 
    647     } 
    648     $filename_full_path = $filename_short_path; 
    649     } 
    650  
    651     if (defined $filename_full_path) { 
    652     $exists = eval "($test_op \$filename_full_path)"; 
    653     } 
    654  
    655     return $exists; 
    656 } 
    657  
    658 sub file_exists 
    659 { 
    660     my ($filename_full_path) = @_; 
    661  
    662     return fd_exists($filename_full_path,"-f"); 
    663 } 
    664  
    665 sub dir_exists 
    666 { 
    667     my ($filename_full_path) = @_; 
    668  
    669     return fd_exists($filename_full_path,"-d"); 
    670 } 
    671  
    672  
     161sub fd_exists { 
     162  warnings::warnif("deprecated", "util::fd_exists() is deprecated, using FileUtils::fileTest() instead"); 
     163  return &FileUtils::fileTest(@_); 
     164} 
     165 
     166sub file_exists { 
     167  warnings::warnif("deprecated", "util::file_exists() is deprecated, using FileUtils::fileExists() instead"); 
     168  return &FileUtils::fileExists(@_); 
     169} 
     170 
     171sub dir_exists { 
     172  warnings::warnif("deprecated", "util::dir_exists() is deprecated, using FileUtils::directoryExists() instead"); 
     173  return &FileUtils::directoryExists(@_); 
     174} 
    673175 
    674176# updates a copy of a directory in some other part of the filesystem 
     
    676178# both $fromdir and $todir should be absolute paths 
    677179sub cachedir { 
    678     my ($fromdir, $todir, $verbosity) = @_; 
    679     $verbosity = 1 unless defined $verbosity; 
    680  
    681     # use / for the directory separator, remove duplicate and 
    682     # trailing slashes 
    683     $fromdir=~s/[\\\/]+/\//g;  
    684     $fromdir=~s/[\\\/]+$//; 
    685     $todir=~s/[\\\/]+/\//g;  
    686     $todir=~s/[\\\/]+$//; 
    687  
    688     &mk_all_dir ($todir); 
    689  
    690     # get the directories in ascending order 
    691     if (!opendir (FROMDIR, $fromdir)) { 
    692     print STDERR "util::cachedir could not read directory $fromdir\n"; 
    693     return; 
    694     } 
    695     my @fromdir = grep (!/^\.\.?$/, sort(readdir (FROMDIR))); 
    696     closedir (FROMDIR); 
    697  
    698     if (!opendir (TODIR, $todir)) { 
    699     print STDERR "util::cacedir could not read directory $todir\n"; 
    700     return; 
    701     } 
    702     my @todir = grep (!/^\.\.?$/, sort(readdir (TODIR))); 
    703     closedir (TODIR); 
    704  
    705     my $fromi = 0; 
    706     my $toi = 0; 
    707              
    708     while ($fromi < scalar(@fromdir) || $toi < scalar(@todir)) { 
    709 #   print "fromi: $fromi toi: $toi\n"; 
    710  
    711     # see if we should delete a file/directory 
    712     # this should happen if the file/directory 
    713     # is not in the from list or if its a different 
    714     # size, or has an older timestamp 
    715     if ($toi < scalar(@todir)) { 
    716         if (($fromi >= scalar(@fromdir)) || 
    717         ($todir[$toi] lt $fromdir[$fromi] ||  
    718          ($todir[$toi] eq $fromdir[$fromi] &&  
    719           &differentfiles("$fromdir/$fromdir[$fromi]","$todir/$todir[$toi]", 
    720                   $verbosity)))) { 
    721  
    722         # the files are different 
    723         &rm_r("$todir/$todir[$toi]"); 
    724         splice(@todir, $toi, 1); # $toi stays the same 
    725  
    726         } elsif ($todir[$toi] eq $fromdir[$fromi]) { 
    727         # the files are the same 
    728         # if it is a directory, check its contents 
    729         if (-d "$todir/$todir[$toi]") { 
    730             &cachedir ("$fromdir/$fromdir[$fromi]", 
    731                    "$todir/$todir[$toi]", $verbosity); 
    732         } 
    733  
    734         $toi++; 
    735         $fromi++; 
    736         next; 
    737         } 
    738     } 
    739    
    740     # see if we should insert a file/directory 
    741     # we should insert a file/directory if there 
    742     # is no tofiles left or if the tofile does not exist 
    743     if ($fromi < scalar(@fromdir) && ($toi >= scalar(@todir) ||  
    744                       $todir[$toi] gt $fromdir[$fromi])) { 
    745         &cp_r ("$fromdir/$fromdir[$fromi]", "$todir/$fromdir[$fromi]"); 
    746         splice (@todir, $toi, 0, $fromdir[$fromi]); 
    747  
    748         $toi++; 
    749         $fromi++; 
    750     } 
    751     } 
     180  warnings::warnif("deprecated", "util::cachedir() is deprecated, using FileUtils::synchronizeDirectories() instead"); 
     181  return &FileUtils::synchronizeDirectories(@_); 
    752182} 
    753183 
     
    757187# $file2 is allowed to be newer than $file1 
    758188sub differentfiles { 
    759     my ($file1, $file2, $verbosity) = @_; 
    760     $verbosity = 1 unless defined $verbosity; 
    761  
    762     $file1 =~ s/\/+$//; 
    763     $file2 =~ s/\/+$//; 
    764      
    765     my ($file1name) = $file1 =~ /\/([^\/]*)$/; 
    766     my ($file2name) = $file2 =~ /\/([^\/]*)$/; 
    767  
    768     return -1 unless (-e $file1 && -e $file2); 
    769     if ($file1name ne $file2name) { 
    770     print STDERR "filenames are not the same\n" if ($verbosity >= 2); 
    771     return 1; 
    772     } 
    773  
    774     my @file1stat = stat ($file1); 
    775     my @file2stat = stat ($file2); 
    776  
    777     if (-d $file1) { 
    778     if (! -d $file2) { 
    779         print STDERR "one file is a directory\n" if ($verbosity >= 2); 
    780         return 1; 
    781     } 
    782     return 0; 
    783     } 
    784  
    785     # both must be regular files 
    786     unless (-f $file1 && -f $file2) { 
    787     print STDERR "one file is not a regular file\n" if ($verbosity >= 2); 
    788     return 1; 
    789     } 
    790  
    791     # the size of the files must be the same 
    792     if ($file1stat[7] != $file2stat[7]) { 
    793     print STDERR "different sized files\n" if ($verbosity >= 2); 
    794     return 1; 
    795     } 
    796  
    797     # the second file cannot be older than the first 
    798     if ($file1stat[9] > $file2stat[9]) { 
    799     print STDERR "file is older\n" if ($verbosity >= 2); 
    800     return 1; 
    801     } 
    802  
    803     return 0; 
     189  warnings::warnif("deprecated", "util::differentfiles() is deprecated, using FileUtils::differentFiles() instead"); 
     190  return &FileUtils::differentFiles(@_); 
    804191} 
    805192 
     
    822209    } 
    823210 
    824     my $tmpdir = filename_cat($ENV{'GSDLHOME'}, "tmp"); 
     211    my $tmpdir = &FileUtils::filenameConcatenate($ENV{'GSDLHOME'}, "tmp"); 
    825212    &mk_all_dir ($tmpdir) unless -e $tmpdir; 
    826213 
    827214    my $count = 1000; 
    828215    my $rand = int(rand $count); 
    829     my $full_tmp_filename = &filename_cat($tmpdir, "F$rand$opt_dot_file_ext"); 
     216    my $full_tmp_filename = &FileUtils::filenameConcatenate($tmpdir, "F$rand$opt_dot_file_ext"); 
    830217 
    831218    while (-e $full_tmp_filename) { 
    832219    $rand = int(rand $count); 
    833     $full_tmp_filename = &filename_cat($tmpdir, "F$rand$opt_dot_file_ext"); 
     220    $full_tmp_filename = &FileUtils::filenameConcatenate($tmpdir, "F$rand$opt_dot_file_ext"); 
    834221    $count++; 
    835222    } 
     
    850237    } 
    851238 
    852     $tmp_dirname = &util::filename_cat($tmp_dirname, "tmp"); 
     239    $tmp_dirname = &FileUtils::filenameConcatenate($tmp_dirname, "tmp"); 
    853240    &util::mk_dir($tmp_dirname) if (!-e $tmp_dirname); 
    854241 
     
    856243    # if documents have the same name 
    857244    my $timestamp = time; 
    858     my $time_tmp_dirname = &util::filename_cat($tmp_dirname, $timestamp); 
     245    my $time_tmp_dirname = &FileUtils::filenameConcatenate($tmp_dirname, $timestamp); 
    859246    $tmp_dirname = $time_tmp_dirname; 
    860247    my $i = 1; 
     
    895282    } 
    896283    $output_ext= lc($output_ext); 
    897     my $tmp_filename = &util::filename_cat($tmp_dirname, "$tailname$output_ext"); 
     284    my $tmp_filename = &FileUtils::filenameConcatenate($tmp_dirname, "$tailname$output_ext"); 
    898285     
    899286    return $tmp_filename; 
     
    902289sub get_toplevel_tmp_dir 
    903290{ 
    904     return filename_cat($ENV{'GSDLHOME'}, "tmp"); 
     291    return &FileUtils::filenameConcatenate($ENV{'GSDLHOME'}, "tmp"); 
    905292} 
    906293 
     
    940327 
    941328sub filename_cat { 
    942     my $first_file = shift(@_); 
    943     my (@filenames) = @_; 
    944  
    945 #   Useful for debugging  
    946 #     -- might make sense to call caller(0) rather than (1)?? 
    947 #   my ($cpackage,$cfilename,$cline,$csubr,$chas_args,$cwantarray) = caller(1); 
    948 #   print STDERR "Calling method: $cfilename:$cline $cpackage->$csubr\n"; 
    949     
    950     # If first_file is not null or empty, then add it back into the list 
    951     if (defined $first_file && $first_file =~ /\S/) { 
    952     unshift(@filenames, $first_file); 
    953     } 
    954  
    955     my $filename = join("/", @filenames); 
    956  
    957     # remove duplicate slashes and remove the last slash 
    958     if ($ENV{'GSDLOS'} =~ /^windows$/i) { 
    959     $filename =~ s/[\\\/]+/\\/g; 
    960     } else { 
    961     $filename =~ s/[\/]+/\//g;  
    962     # DB: want a filename abc\de.html to remain like this 
    963     } 
    964     $filename =~ s/[\\\/]$//; 
    965  
    966     return $filename; 
     329  # I've disabled this warning for now, as every Greenstone perl 
     330  # script seems to make use of this function and so you drown in a 
     331  # sea of deprecated warnings [jmt12] 
     332#  warnings::warnif("deprecated", "util::filename_cat() is deprecated, using FileUtils::filenameConcatenate() instead"); 
     333  return &FileUtils::filenameConcatenate(@_); 
    967334} 
    968335 
     
    1074441    my $filename_full_path = $file; 
    1075442    # add on directory if present 
    1076     $filename_full_path = &util::filename_cat ($base_dir, $file) if $base_dir =~ /\S/; 
     443    $filename_full_path = &FileUtils::filenameConcatenate($base_dir, $file) if $base_dir =~ /\S/; 
    1077444     
    1078445    my $filename_no_path = $file; 
     
    1106473    # use filename_cat to clean up trailing slashes and  
    1107474    # multiple slashes 
    1108     $filename1 = filename_cat ($filename1); 
    1109     $filename2 = filename_cat ($filename2); 
     475    $filename1 = &FileUtils::filenameConcatenate($filename1); 
     476    $filename2 = &FileUtils::filenameConcatenate($filename2); 
    1110477 
    1111478    # filenames not case sensitive on windows 
     
    1237604    my ($base_dir,$file,$gli) = @_; 
    1238605 
    1239     my $filename_full_path = &util::filename_cat($base_dir,$file); 
     606    my $filename_full_path = &FileUtils::filenameConcatenate($base_dir,$file); 
    1240607 
    1241608    if ($ENV{'GSDLOS'} =~ m/^windows$/i) { 
     
    1327694sub filename_is_absolute 
    1328695{ 
    1329     my ($filename) = @_; 
    1330  
    1331     if ($ENV{'GSDLOS'} =~ /^windows$/i) { 
    1332     return ($filename =~ m/^(\w:)?\\/); 
    1333     } 
    1334     else { 
    1335     return ($filename =~ m/^\//); 
    1336     } 
     696  warnings::warnif("deprecated", "util::filename_is_absolute() is deprecated, using FileUtils::isFilenameAbsolute() instead"); 
     697  return &FileUtils::isFilenameAbsolute(@_); 
    1337698} 
    1338699 
     
    1441802 
    1442803    if (!defined $collectdir || $collectdir eq "") { 
    1443     $collectdir = &filename_cat ($ENV{'GSDLHOME'}, "collect"); 
     804    $collectdir = &FileUtils::filenameConcatenate($ENV{'GSDLHOME'}, "collect"); 
    1444805    } 
    1445806 
     
    1462823    # are defined 
    1463824    $ENV{'GSDLCOLLECTION'} = $collection; 
    1464     $ENV{'GSDLCOLLECTDIR'} = &filename_cat ($collectdir, $collection); 
     825    $ENV{'GSDLCOLLECTDIR'} = &FileUtils::filenameConcatenate($collectdir, $collection); 
    1465826 
    1466827    # make sure this collection exists 
     
    1487848    if (!defined $collectdir || $collectdir eq "") { 
    1488849    die "GSDL3HOME not set.\n" unless defined $ENV{'GSDL3HOME'}; 
    1489     $collectdir = &filename_cat ($ENV{'GSDL3HOME'}, "sites", $site, "collect"); 
     850    $collectdir = &FileUtils::filenameConcatenate($ENV{'GSDL3HOME'}, "sites", $site, "collect"); 
    1490851    } 
    1491852 
     
    1523884    if (defined $ENV{'GSDLCOLLECTDIR'} && $ENV{'GSDLCOLLECTDIR'} ne "") { 
    1524885        my $test_collect_etc_filename  
    1525         = &util::filename_cat($ENV{'GSDLCOLLECTDIR'},"etc", $file); 
     886        = &FileUtils::filenameConcatenate($ENV{'GSDLCOLLECTDIR'},"etc", $file); 
    1526887         
    1527888        if (-e $test_collect_etc_filename) { 
     
    1530891    } 
    1531892    my $test_main_etc_filename  
    1532         = &util::filename_cat($ENV{'GSDLHOME'},"etc", $file); 
     893        = &FileUtils::filenameConcatenate($ENV{'GSDLHOME'},"etc", $file); 
    1533894    if (-e $test_main_etc_filename) { 
    1534895        push(@locations,$test_main_etc_filename); 
     
    1553914# A method to check if a directory is empty (note that an empty directory still has non-zero size!!!)  
    1554915# Code is from http://episteme.arstechnica.com/eve/forums/a/tpc/f/6330927813/m/436007700831 
    1555 sub is_dir_empty 
    1556 { 
    1557     my ($path) = @_; 
    1558     opendir DIR, $path; 
    1559     while(my $entry = readdir DIR) { 
    1560         next if($entry =~ /^\.\.?$/); 
    1561         closedir DIR; 
    1562         return 0; 
    1563     } 
    1564     closedir DIR; 
    1565     return 1; 
     916sub is_dir_empty { 
     917  warnings::warnif("deprecated", "util::is_dir_empty() is deprecated, using FileUtils::isDirectoryEmpty() instead"); 
     918  return &FileUtils::isDirectoryEmpty(@_); 
    1566919} 
    1567920 
     
    16691022    if($ENV{'GSDL3SRCHOME'}) { 
    16701023    $defaultUrlprefix = "/greenstone3"; 
    1671     $configfile = &util::filename_cat($ENV{'GSDL3SRCHOME'}, "packages", "tomcat", "conf", "Catalina", "localhost", "greenstone3.xml"); 
     1024    $configfile = &FileUtils::filenameConcatenate($ENV{'GSDL3SRCHOME'}, "packages", "tomcat", "conf", "Catalina", "localhost", "greenstone3.xml"); 
    16721025    push(@propertynames, qw/path\s*\=/); 
    16731026    } else { 
    16741027    $defaultUrlprefix = "/greenstone"; 
    1675     $configfile = &util::filename_cat($ENV{'GSDLHOME'}, "cgi-bin", &os_dir(), "gsdlsite.cfg"); 
     1028    $configfile = &FileUtils::filenameConcatenate($ENV{'GSDLHOME'}, "cgi-bin", &os_dir(), "gsdlsite.cfg"); 
    16761029    push(@propertynames, (qw/\nhttpprefix/, qw/\ngwcgi/)); # inspect one property then the other  
    16771030    } 
     
    17771130     
    17781131    if($ENV{'PERLPATH'}) { 
    1779         # OR: # $perl_exec = &util::filename_cat($ENV{'PERLPATH'},"perl"); 
     1132        # OR: # $perl_exec = &FileUtils::filenameConcatenate($ENV{'PERLPATH'},"perl"); 
    17801133        if($ENV{'GSDLOS'} =~ m/windows/) { 
    17811134            $perl_exec = "$ENV{'PERLPATH'}\\Perl.exe"; 
     
    18041157    if(defined $ENV{'GSDLHOME'}) { # should be, as this script would be launched from the cmd line  
    18051158                               # after running setup.bat or from GLI which also runs setup.bat 
    1806     my $java_bin = &util::filename_cat($ENV{'GSDLHOME'},"packages","jre","bin"); 
     1159    my $java_bin = &FileUtils::filenameConcatenate($ENV{'GSDLHOME'},"packages","jre","bin"); 
    18071160    if(-d $java_bin) { 
    1808         $java = &util::filename_cat($java_bin,"java"); 
     1161        $java = &FileUtils::filenameConcatenate($java_bin,"java"); 
    18091162        $java = "\"".$java."\""; # quoted to preserve spaces in path 
    18101163    } 
     
    18441197     
    18451198    if (defined $collect_dir && $collect_dir) { # ensure not empty string either 
    1846         return &util::filename_cat($collect_dir,$colgroup, $collection); 
     1199        return &FileUtils::filenameConcatenate($collect_dir,$colgroup, $collection); 
    18471200    } 
    18481201    elsif (defined($ENV{'GSDLCOLLECTDIR'})) { 
     
    18511204    else { 
    18521205        if (defined $site) { 
    1853             return &util::filename_cat($ENV{'GSDL3HOME'},"sites",$site,"collect",$colgroup, $collection); 
     1206            return &FileUtils::filenameConcatenate($ENV{'GSDL3HOME'},"sites",$site,"collect",$colgroup, $collection); 
    18541207        } 
    18551208        else { 
    1856             return &util::filename_cat($ENV{'GSDLHOME'},"collect",$colgroup, $collection); 
     1209            return &FileUtils::filenameConcatenate($ENV{'GSDLHOME'},"collect",$colgroup, $collection); 
    18571210        } 
    18581211    } 
     
    18641217{ 
    18651218    my ($output_dir, $convert_basename, $convert_to) = @_; 
    1866     opendir(DIR, $output_dir) || die "can't opendir $output_dir: $!";   
    1867  
    18681219    my $page_num = ""; 
     1220 
     1221    opendir(DIR, $output_dir) || die "can't opendir $output_dir: $!"; 
    18691222    my @dir_files = grep {-f "$output_dir/$_"} readdir(DIR); 
    1870  
    1871     # Sort files in the directory by page_num     
     1223    closedir DIR; 
     1224 
     1225    # Sort files in the directory by page_num 
    18721226    sub page_number { 
    18731227    my ($dir) = @_; 
     
    18781232    } 
    18791233 
    1880     # sort the files in the directory in the order of page_num rather than lexically.  
     1234    # sort the files in the directory in the order of page_num rather than lexically. 
    18811235    @dir_files = sort { page_number($a) <=> page_number($b) } @dir_files; 
    18821236 
     
    18891243    } 
    18901244 
    1891     my $item_file = &util::filename_cat($output_dir, $convert_basename.".item"); 
    1892     open(FILE,">$item_file");     
    1893     print FILE "<PagedDocument>\n"; 
     1245    my $item_file = &FileUtils::filenameConcatenate($output_dir, $convert_basename.".item"); 
     1246    my $item_fh; 
     1247    &FileUtils::openFileHandle($item_file, 'w', \$item_fh); 
     1248    print $item_fh "<PagedDocument>\n"; 
    18941249 
    18951250    foreach my $file (@dir_files){ 
     
    18971252        $page_num = page_number($file); 
    18981253        $page_num++ if $starts_at_0; # image numbers start at 0, so add 1 
    1899         print FILE "   <Page pagenum=\"$page_num\" imgfile=\"$file\" txtfile=\"\"/>\n"; 
    1900     }  
    1901     } 
    1902  
    1903     print FILE "</PagedDocument>\n"; 
    1904     close FILE; 
    1905     closedir DIR; 
     1254        print $item_fh "   <Page pagenum=\"$page_num\" imgfile=\"$file\" txtfile=\"\"/>\n"; 
     1255    } 
     1256    } 
     1257 
     1258    print $item_fh "</PagedDocument>\n"; 
     1259    &FileUtils::closeFileHandle($item_file, \$item_fh); 
    19061260    return $item_file; 
    19071261} 
    19081262 
     1263 
     1264# /** @function augmentINC() 
     1265#  * Prepend a path (if it exists) onto INC but only if it isn't already in 
     1266#  * INC 
     1267#  * @param $new_path The path to add as necessary 
     1268#  * @author jmt12 
     1269#  */ 
     1270sub augmentINC 
     1271{ 
     1272  my ($new_path) = @_; 
     1273  my $did_add_path = 0; 
     1274  # will need to be replaced with FileUtils::directoryExists() call eventually 
     1275  if (-d $new_path) 
     1276  { 
     1277    my $did_find_path = 0; 
     1278    foreach my $existing_path (@INC) 
     1279    { 
     1280      if ($existing_path eq $new_path) 
     1281      { 
     1282        $did_find_path = 1; 
     1283        last; 
     1284      } 
     1285    } 
     1286    if (!$did_find_path) 
     1287    { 
     1288      unshift(@INC, $new_path); 
     1289      $did_add_path = 1; 
     1290    } 
     1291  } 
     1292  return $did_add_path; 
     1293} 
     1294# /** augmentINC($new_path) **/ 
     1295 
    190912961;