root/branches/newmole/scripts/nightly_copy_files_original.pl

#!perl -w

# This script copies source and test suite from pc to linux cluster

# This is a perl script to convert ascii pc source files into unix eol files

# bring in the perl module that includes copy
use File::Copy;


# --------------------------------------------------------------------------
# this block - set up paths to all targets on various machines 

# this is where the original source files live on my pc
$original_source_dir = "c:/projects/cloudy/trunk/source";
$original_data_dir =   "c:/projects/cloudy/trunk/data";
$original_tsuite_dir = "c:/projects/cloudy/trunk/tsuite/auto";

# this is the current debug exe, will bail out if $local_unix_source_dir/source.tar.gz source
# is younger than this
$original_exe = "c:/projects/cloudy/trunk/debug/trunk.exe";


# the root dir where the unix files will live on the linux cluster
$cluster_unix_source_dir = "u:/cloudy/trunk/source";
$cluster_unix_tsuite_dir = "u:/cloudy/trunk/tsuite";
$cluster_unix_data_dir =   "u:/cloudy/trunk/data";

# this is the ftp site on gradj
$ftp_last = "u:/pub/gary/bleeding_edge/last/";

# the root dir where the unix files will live on my pc
$local_unix_source_dir = "c:/projects/cloudy/trunk/unix/source";
$local_unix_tsuite_dir = "c:/projects/cloudy/trunk/unix/tsuite";
$local_unix_data_dir = "c:/projects/cloudy/trunk/unix/data";
$local_unix_main_dir = "c:/projects/cloudy/trunk/unix";

# this is the last source.tar.gz, will compare this time stamp with debug exe
# and bail if tar file is younger than exe
$local_unix_sourcetar = "$local_unix_main_dir"."/source.tar.gz";

# the win dir within the unix set
$local_win_source_dir = "c:/projects/cloudy/trunk/win/source"; 
$local_win_tsuite_dir = "c:/projects/cloudy/trunk/win/tsuite";
$local_win_data_dir = "c:/projects/cloudy/trunk/win/data";

#this is where backup files will be dropped
$unixhome = "c:/projects/cloudy/trunk/unix";
$winhome = "c:/projects/cloudy/trunk/win";

# do we want to check timestamp? 
$lgCheckTime=1;
# end block - set up paths to all targets on various machines

# now compare ages of debug exe and last source.tar.gz, and bail if
# debug has not been updated
if( $lgCheckTime && (-M $local_unix_sourcetar) < (-M $original_exe ) )
{
      # no need to run tests, just quit
      exit;
}


# --------------------------------------------------------------------------
# --------------------------------------------------------------------------
# this block - clean out the target directories so we get fresh copies
# move to the old unix source directory, where we will delete all files
#
# dir that are cleaned out:
#  unix source
#  unix tsuite
#
# --------
#
# move to pc unix source dir
if( !chdir( "$local_unix_source_dir" ) )
{
       printf(" invalid pc unix target directory for source\n");
       exit(1);
}
print(" moved to pc unix target source directory, about to delete all files\n");
# remove the unix source files
unlink <*> ; 

# move to win source dir
if( !chdir( "$local_win_source_dir" ) )
{
       printf(" invalid win target directory for source\n");
       exit(1);
}
print(" moved to win target source directory, about to delete all files\n");
# remove the win source files
unlink <*> ; 

# move to the cluster source directory
if( !chdir( "$cluster_unix_source_dir" ) )
{
       printf(" invalid cluster target directory for source\n");
       exit(1);
}
print(" moved to unix target source directory, about to delete all files\n");
# remove the old source files
unlink <*.cpp> ; 
#
# --------
#
# move to the pc unix tsuite dir
if( !chdir( "$local_unix_tsuite_dir" ) )
{
       printf(" invalid directory for pc unix target tsuite\n");
       exit(1);
}
print(" moved to tsuite unix target directory, about to delete all files\n");
# remove the unix tsuite files
unlink <*> ; 

# move to the win tsuite directory
if( !chdir( "$local_win_tsuite_dir" ) )
{
       printf(" invalid directory for win target tsuite\n");
       exit(1);
}
print(" moved to tsuite win target directory, about to delete all files\n");
# remove the win tsuite files
unlink <*> ; 

# move to cluster tsuite directory
if( !chdir( "$cluster_unix_tsuite_dir" ) )
{
       printf(" invalid directory for cluster target tsuite\n");
       exit(1);
}
print(" moved to tsuite unix target directory, about to delete all files\n");
# remove the old unix tsuite files - do not do * since want to keep perl files
unlink <*.in>; 
# do not remove the *.out since a job may be running
# unlink <*.out>; 

#
# --------
#
# move to pc unix data dir
if( !chdir( "$local_unix_data_dir" ) )
{
       printf(" invalid unix data directory for data\n");
       exit(1);
}
print(" moved to unix target data directory, about to delete all files\n");
# remove the unix data files
unlink <*> ; 

# move to win data dir
if( !chdir( "$local_win_data_dir" ) )
{
       printf(" invalid win data directory for data\n");
       exit(1);
}
print(" moved to win target data directory, about to delete all files\n");
# remove the win data files
unlink <*> ;

# do not remove data files, since need compiled stars files
# move to cluster data dir
#if( !chdir( "$cluster_unix_data_dir" ) )
#{
#       printf(" invalid directory for cluster data\n");
#       exit(1);
#}
#print(" moved to cluster data target directory, about to delete all files\n");
# remove the old unix tsuite files
#unlink <*> ; 


# end block - all target directories cleaned out the so we get fresh copies

# --------------------------------------------------------------------------
# --------------------------------------------------------------------------
#
# this block, copy source to various places
#
# move to where the original source files live 
if( !chdir( "$original_source_dir" ) )
{
       printf(" invalid original target directory for source\n");
       exit(1);
}
# this loops over all files in the original source directory
# and copies unix eol version to subdir unix, which is now empty
# also copies win version to subdir win/source, which is now empty
while( defined( $input = glob("*") ) )
{
        print( "$input going to " );
        $output = "$local_unix_source_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
#
#       now do win version
        print( "$input going to " );
        $output = "$local_win_source_dir"."/"."$input";
        print("$output\n");
        # simply copy the source here
        copy( $input  , $output );
}

# this jpeg file was damaged above, so now copy straight version over 
copy( "clouds.jpg" , "$local_unix_source_dir"."/"."clouds.jpg" );

print("\n=========================\n");
print("All source files have been copies to unix/source subdir\n");
print("=========================\n");

#
#------------ tsuite loop
#
# move to original tsuite directory
if( !chdir( "$original_tsuite_dir" ) )
{
       printf(" invalid directory for original tsuite directory\n");
       exit(1);
}
# this loops over all input files in the original tsuite directory
# and copies unix eol version to subdir unix, which is now empty
# and windows eol version to subdir win/tsuite, which is not empty
# later we will copy the pc unix version to the cluster 
while( defined( $input = glob("*.in") ) )
{
        print( "$input going to " );
        $output = "$local_unix_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually copy the file
        system "dos2unix < $input  > $output";
#
#       now do win version
        print( "$input going to " );
        $output = "$local_win_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        copy( $input  , $output );
}


# now copy all dat files scripts 
while( defined( $input = glob("*.htm") ) )
{
        print( "$input going to " );
        $output = "$local_unix_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
        $output = "$local_win_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        copy( $input , $output );
}
# copy all ascii html documents
#$input = "readme_tests.htm";
#$output = "$local_unix_tsuite_dir"."/"."$input";
#system "dos2unix < $input  > $output" ;
#$output = "$local_win_tsuite_dir"."/"."$input";
#copy( $input  , $output );

# lowd.dat moved to data files
#$input = "lowd.dat";
#$output = "$local_unix_tsuite_dir"."/"."$input";
#system "dos2unix < $input  > $output" ;
#$output = "$local_win_tsuite_dir"."/"."$input";
#copy( $input  , $output );


# now copy all dat files scripts 
while( defined( $input = glob("*.dat") ) )
{
        print( "$input going to " );
        $output = "$local_unix_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
        $output = "$local_win_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        copy( $input , $output );
}
#$input = "starburst99.dat";
#$output = "$local_unix_tsuite_dir"."/"."$input";
#system "dos2unix < $input  > $output" ;
#$output = "$local_win_tsuite_dir"."/"."$input";
#copy( $input  , $output );

# the clouds image is a binary file do a straight copy
copy( "clouds.jpg" , "$local_unix_tsuite_dir"."/"."clouds.jpg" );
# the clouds image is a binary file
copy( "clouds.jpg" , "$local_win_tsuite_dir"."/"."clouds.jpg" );

# now copy all perl scripts 
while( defined( $input = glob("*.pl") ) )
{
        print( "$input going to " );
        $output = "$local_unix_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
        $output = "$local_win_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        copy( $input , $output );
}

# now copy all ini files scripts 
while( defined( $input = glob("*.ini") ) )
{
        print( "$input going to " );
        $output = "$local_unix_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
        $output = "$local_win_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        copy( $input , $output );
}


print("\n=========================\n");
print("All tsuite files have been copied to unix/tsuite subdir\n");
print("=========================\n");


# move to original data directory
if( !chdir( $original_data_dir ) )
{
       printf(" invalid directory for input\n");
       exit(1);
}

# now do all data files in data dir
# there is a different set of data files tar'd into data.tar in tsuite/auto, this is done
# by the autorun.pl script
$input = "readme_data.htm";
$output = "$local_unix_data_dir"."/"."readme_data.htm";
system "dos2unix < $input  > $output" ;
$output = "$local_win_data_dir"."/"."$input";
# simply copy the source here
copy( $input  , $output );

# treate this as a binary file
copy( "clouds.jpg" , "$local_unix_data_dir"."/"."clouds.jpg" );
copy( "clouds.jpg" , "$local_win_data_dir"."/"."clouds.jpg" );

# the tex and pdf file for P van Hoof's writeup on the new grains
# first do the pdf version as a binary file
copy( "vanhoof_grain_model.pdf" , "$local_unix_data_dir"."/"."vanhoof_grain_model.pdf" );
copy( "vanhoof_grain_model.pdf" , "$local_win_data_dir"."/"."vanhoof_grain_model.pdf" );
# next the tex master document
$input = "vanhoof_grain_model.tex";
$output = "$local_unix_data_dir"."/"."vanhoof_grain_model.tex";
# convert eol for unix version
system "dos2unix < $input  > $output" ;
$output = "$local_win_data_dir"."/"."$input";
# simply copy the source to the win dir
copy( $input  , $output );
# next the ps output
$input = "vanhoof_grain_model.ps";
$output = "$local_unix_data_dir"."/"."vanhoof_grain_model.ps";
# convert eol for unix version
system "dos2unix < $input  > $output" ;
$output = "$local_win_data_dir"."/"."$input";
# simply copy the source to the win dir
copy( $input  , $output );

# copy all data files
while( defined( $input = glob("*.dat") ) )
{
        print( "$input going to " );
        $output = "$local_unix_data_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
#
#       now do win version
        print( "$input going to " );
        $output = "$local_win_data_dir"."/"."$input";
        print("$output\n");
        # simply copy the source here
        copy( $input  , $output );
}

# copy all opacity files
while( defined( $input = glob("*.opc") ) )
{
        print( "$input going to " );
        $output = "$local_unix_data_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
#
#       now do win version
        print( "$input going to " );
        $output = "$local_win_data_dir"."/"."$input";
        print("$output\n");
        # simply copy the source here
        copy( $input  , $output );
}

# copy all input scripts
while( defined( $input = glob("*.in") ) )
{
        print( "$input going to " );
        $output = "$local_unix_data_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
#
#       now do win version
        print( "$input going to " );
        $output = "$local_win_data_dir"."/"."$input";
        print("$output\n");
        # simply copy the source here
        copy( $input  , $output );
}

# copy all ini scripts
while( defined( $input = glob("*.ini") ) )
{
        print( "$input going to " );
        $output = "$local_unix_data_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
#
#       now do win version
        print( "$input going to " );
        $output = "$local_win_data_dir"."/"."$input";
        print("$output\n");
        # simply copy the source here
        copy( $input  , $output );
}

# copy all rfi scripts
while( defined( $input = glob("*.rfi") ) )
{
        print( "$input going to " );
        $output = "$local_unix_data_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
#
#       now do win version
        print( "$input going to " );
        $output = "$local_win_data_dir"."/"."$input";
        print("$output\n");
        # simply copy the source here
        copy( $input  , $output );
}

# copy all szd scripts
while( defined( $input = glob("*.szd") ) )
{
        print( "$input going to " );
        $output = "$local_unix_data_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        system "dos2unix < $input  > $output";
#
#       now do win version
        print( "$input going to " );
        $output = "$local_win_data_dir"."/"."$input";
        print("$output\n");
        # simply copy the source here
        copy( $input  , $output );
}


print("\n=========================\n");
print("All data files have been copied to trunk/unix/data subdir\n");
print("=========================\n");

print( "data, source, tsuite files copied to win and pc unix \n");

#
#------------ source loop
#

# move to local unix source directory with unix eol source
if( !chdir( $local_unix_source_dir ) )
{
       printf(" invalid local unix source directory for input\n");
       exit(1);
}

# this loops over all files in the trunk directory
# and copies unix version to subdir unix, which should be empty
while( defined( $input = glob("*") ) )
{
        print( "$input going to " );
        $output = "$cluster_unix_source_dir"."/"."$input";
        print("$output\n");
        # actually execute the code
        copy( $input  , $output);
}
# we have now clobbered the path.cpp file, and need to copy a valid one from 1 dir up
copy( "u:/cloudy/trunk/path.cpp" , "u:/cloudy/trunk/source/path.cpp" );

# move to pc unix tsuite directory
if( !chdir( $local_unix_tsuite_dir ) )
{
       printf(" invalid directory for local unix tsuite directory\n");
       exit(1);
}
# this loops over all files in the pc unix tsuite directory
# and copies unix version to subdir unix on cluster, which is now empty
while( defined( $input = glob("*") ) )
{
        print( "$input going to " );
        $output = "$cluster_unix_tsuite_dir"."/"."$input";
        print("$output\n");
        # actually copy the file
        copy( $input  , $output );
}


# move to pc unix data directory
if( !chdir( $local_unix_data_dir ) )
{
       printf(" invalid directory for local unix data directory\n");
       exit(1);
}
# this loops over all files in the pc unix data directory
# and copies unix version to subdir unix on cluster, which is now empty
while( defined( $input = glob("*") ) )
{
        print( "$input going to " );
        $output = "$cluster_unix_data_dir"."/"."$input";
        print("$output\n");
        # actually copy the file
        copy( $input  , $output );
}

# now zip up the files we created
if( !chdir( "$unixhome" ) )
{
       printf(" invalid unix home directory for source\n");
       exit(1);
}
print(" moved to unix home directory\n");

# remove old gzipd file if it exists
if( -e "source.tar.gz" )
{
   unlink("source.tar.gz" );
}
# remove old gzipd file if it exists
if( -e "tsuite.tar.gz" )
{
   unlink("tsuite.tar.gz" );
}
# remove old gzipd file if it exists
if( -e "data.tar.gz" )
{
   unlink("data.tar.gz" );
}

# ----------------------------------------------------------
#   tar the files
#
#  unix source
#
# tar pc unix source
if( !chdir( "$local_unix_source_dir" ) )
{
       printf(" invalid directory for local unix source\n");
       exit(1);
}
$tarfile = "../"."source.tar";
system "tar -cf $tarfile * ";
print( "about to gzip $tarfile\n" );
system "gzip $tarfile ";

# tar pc unix source
if( !chdir( "$local_unix_tsuite_dir" ) )
{
       printf(" invalid directory for local tsuite source\n");
       exit(1);
}
$tarfile = "../"."tsuite.tar";
system "tar -cf $tarfile * ";
print( "about to gzip $tarfile\n" );
system "gzip $tarfile ";

# tar pc unix data
if( !chdir( "$local_unix_data_dir" ) )
{
       printf(" invalid directory for local data source\n");
       exit(1);
}
$tarfile = "../"."data.tar";
system "tar -cf $tarfile * ";
print( "about to gzip $tarfile\n" );
system "gzip $tarfile ";

# move to main dir so that we can copy tar.gz files to ftp site
if( !chdir( "$local_unix_main_dir" ) )
{
       printf(" invalid directory for main unix\n");
       exit(1);
}
# finally copy the newly created files to the ftp site
#copy( "source.tar.gz" , "u:/pub/gjf/source.tar.gz" );
#copy( "tsuite.tar.gz" , "u:/pub/gjf/tsuite.tar.gz" );
#copy( "data.tar.gz" , "u:/pub/gjf/data.tar.gz" );
copy( "source.tar.gz" , $ftp_last );
copy( "tsuite.tar.gz" , $ftp_last );
copy( "data.tar.gz" , $ftp_last );

# how go to win home and zip the win source dir
#
# move to win home directory
if( !chdir( "$winhome" ) )
{
       printf(" invalid directory for win home\n");
       exit(1);
}
if( -e "source.zip" )
{
   unlink("source.zip" );
}
# remove old gzipd file if it exists
if( -e "tsuite.zip" )
{
   unlink("tsuite.zip" );
}
# remove old gzipd file if it exists
if( -e "data.zip" )
{
   unlink("data.zip" );
}

# win source
system "c:\\u\\wzzip source.zip $local_win_source_dir ";
system "c:\\u\\wzzip tsuite.zip $local_win_tsuite_dir ";
system "c:\\u\\wzzip   data.zip $local_win_data_dir ";

# finally copy the newly created files to the ftp site
#copy( "source.zip" , "u:/pub/gjf/source.zip" );
#copy( "tsuite.zip" , "u:/pub/gjf/tsuite.zip" );
#copy( "data.zip"   , "u:/pub/gjf/data.zip" );
copy( "source.zip" , $ftp_last );
copy( "tsuite.zip" , $ftp_last );
copy( "data.zip"   , $ftp_last );

print("\n=========================\n");