#============================================================================ 

#Name        : getenv.pl 

#Part of     : Helium 

#Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

#All rights reserved.

#This component and the accompanying materials are made available

#under the terms of the License "Eclipse Public License v1.0"

#which accompanies this distribution, and is available

#at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

#Initial Contributors:

#Nokia Corporation - initial contribution.

#

#Contributors:

#

#Description: Cleaned version.

#============================================================================

use strict;         # strict naming rules

use Cwd;            # figuring out directories

use Data::Dumper;   # debugging purposes

use XML::Simple;    # for using xml parser

use File::Copy;     # for copying files

use Getopt::Long;   # parameter handling

Getopt::Long::Configure( "bundling_override","ignore_case_always" );

use File::Temp qw/ tempdir /; # for creating unique temp directories

# uncomment to get temp dir debug traces

$File::Temp::DEBUG = 1;

# variables for commandline params

my( $param_help,          # print help

    $param_server,        # manually select server

    $param_release_path,  # where are the releases located in the server

    $param_debug,         # parameter for controlling extra debug prints

    $param_latest,        # just grab the latest build (requires product name)

    $param_keepgoing,     # continue even if dependency is missing

    $param_print_only,    # do nothing but print system calls

    $param_skipITD,       # do not extract internal, testsources and documentation

    $param_emuenv,        # extract only emulator environment

    $param_start_directly,# starts extracting directly without waiting user acceptance

    $param_product,       # manually insert product name

    $param_skip_deps,     # do not extract dependencies

    $param_grace,         # do not check for grace access

    @param_exclude,       # exclude list

    @param_include,       # include list

    @force_include,       # force include list

    $param_all );         # extract all zips

# read commandline parameters

my $result = GetOptions('help'      => \$param_help,            # print help

                        'h'         => \$param_help,            # print help

                        'latest'    => \$param_latest,          # just grab the latest build (requires product name)

                        'server=s'  => \$param_server,          # manually select server

                        'path=s'    => \$param_release_path,    # extract this release directly

                        'verbose'   => \$param_debug,           # verbose debug print

                        'k'         => \$param_keepgoing,       # continue even if there is any problems

                        'p'         => \$param_print_only,      # do nothing but print system calls

                        'skipitd'   => \$param_skipITD,         # Deprecated: do not extract internal, testsources and documentation

                        'emu'       => \$param_emuenv,          # Deprecated: extract only emulator environment

                        'start'     => \$param_start_directly,  # starts extracting directly without waiting user acceptance

                        'product=s' => \$param_product,         # manually insert product name

                        'x=s'       => \@param_exclude,         # filer list for excluding zips

                        'exclude=s' => \@param_exclude,         # filer list for excluding zips

                        'i=s'       => \@param_include,         # filer list for including zips

                        'include=s' => \@param_include,         # filer list for including zips

                        'f=s'       => \@force_include,         # filer list for including zips if default tag is false

                        'force=s'   => \@force_include,         # filer list for including zips if default tag is false

                        'all'       => \$param_all,             # extract all zip whether default tag is true or false

                        'nodeps'    => \$param_skip_deps,       # do not extract dependencies

                        'grace'     => \$param_grace);          # try to DL from GRACE

# enums for error situations

my $warning = 1;

my $promptUser = 2;

my $dependencyMissing = 3;

my $cannotContinue = 4;

# common global variables

my $metaDataXml;            # path to metadata file

my $currentReleaseXml;      # path to currentRelease.xml if exists

my $pathToReleaseFolder;    # path to server that has releases

my $defaultServiceName;     # default name for service (s60rnd)

my $pathToUnzip;            # path to unzip tool

my $tmpDlDir;               # path to temp dir where we'll DL packages to

my $tmpDir;                 # path to temp dir where we extract packages from

my $returnValue;            # holds the error codes coming from 7-zip

my $graceServer;            # path to local grace server if accessible

my $logFile;                # log file for troubleshooting

my %packageHash;            # hash containing zips to extract

my @finalZipList;           # contains final list of files to unzip

my $getEnvVersion;          # version of this getenv script

my $defaultPathToServer;    # default value for the server

# list of GRACE samba shares - must match to @graceNameList

my @hydraList = ();

# must match to @graceList

my @hydraNameList = ();

#these 2 lists need to match                    

my @serviceList = ();

my @serviceNameList = ();

# default values

$tmpDir = FixPaths( getcwd )."temp";

$tmpDlDir = FixPaths( getcwd )."DlTemp";

$defaultServiceName = undef;

#$logFile = getcwd."/getenv.log";

$pathToReleaseFolder = undef;

$defaultPathToServer = undef;

$pathToUnzip = "7za";

$getEnvVersion = "2.4.9";

print "S60 RnD environment getter v.$getEnvVersion\n\n";

printLog( "getenv.pl version $getEnvVersion" );

# The actual functionality

if( $param_grace ) {

# ToDo: find more clever way to figure out access

    $graceServer = FindGraceServer( );

}

else {

#   print "GRACE access is temporary disabled due to access problems\nEnable GRACE access by running getenv.pl -grace\n";

}

ValidateInputs( );

printLog( "Following release we will extract: $metaDataXml" );

PrintFinalWarning( );

DownloadRelease( );

exit 0;

sub ValidateInputs {

  print_help( ) if ( $param_help );

  if( @param_exclude and @param_include ) {

    HandleError( "you cant specify include and exclude lists at the same time!", $cannotContinue );

  }

  # checking wheter we are in root of the substituted drive (if -start param is not specified)

  if( ! $param_start_directly and

      ! getcwd =~ /[a-zA-Z]:\// and

        $param_keepgoing ) {

    HandleError( "You should run getenv only in root of the substituted drive\nYou can use -k as keep going parameter if you think it is ok to proceed", $cannotContinue );

  }

  # ok we are in root. Is the drive empty?

  my $xmlFile = 0;

  my $driveEmpty = 1;

  opendir( ROOT, "/" ) or HandleError( "cant read root dir: $!", $warning );

  my @filesFound = readdir( ROOT );

  closedir( ROOT );

  foreach my $file( @filesFound ) {

      next if $file =~ /^\.[\.]?$/;

      next if $file =~ /getenv/;

      $xmlFile = 1 if $file =~ /.*metadata.*\.xml/;

      $xmlFile = 1 if $file =~ /currentRelease\.xml/;

      $driveEmpty = 0;

  }

  printLog( "xml files: $xmlFile" );

  printLog( "drive empty: $driveEmpty" );

  # if drive is not empty and no xmls found ==> print warning (if -start param not specified)

  if( ! $param_start_directly and ! $xmlFile and ! $driveEmpty ) {

      HandleError( "The drive you are about to extract environment is not empty!\nHit CTRL-C to break now or <enter> to continue", $promptUser );

  }

  # if there is valid metadata.xml in root, params like path or latest doesn't make any sense

  if( $xmlFile ) {

      foreach my $file( @filesFound ) {

          if( $file =~ /.*metadata(_(\d*))?.xml$/i ) {

              print "metadata file found!\n";

              if( ValidateXmlFile( getcwd.$file ) ) {

                  $metaDataXml = getcwd.$file;

                  last;

              }

          }

      }

  }

  if( $metaDataXml ) {

    if( $param_latest or $param_release_path ) {

          print "It doesnt make sense to use 'path' or 'latest' parameter while having metadata.xml in root!\n\n";

          print_help( );

          exit 0;

    }

  # we should ask correct grace share if xmlfile !server !start       

    if( !$param_server and ! $param_start_directly ) {

      print "For your convenience it is recommended to use HYDRA samba share close to you.\n";

      # prompt user wheter he wants to use GRACE

      my $networkAccessVerified = 0;

      while( $networkAccessVerified eq 0 ) {

        my $wantedServer = FixPaths( $hydraList[ ReturnMenuIndex( "Please select share closest to you", @hydraNameList ) ] );

        if( $wantedServer eq FixPaths( $hydraList[0] ) ) {

              HandleError( "Please notice that access to $hydraList[0] will be removed from wk50 onwards. Now would be perfect time to get yourself a GRACE access.", $promptUser );

        }

        printLog( "selected: $wantedServer - accessing.." );

        if( opendir( GRACETEST, $wantedServer ) ) {

          printLog( "connection tested OK" );

          $networkAccessVerified = 1;

          $pathToReleaseFolder = $wantedServer;

        }

        else {

              print "Unable to access $wantedServer\nPlease select another network share.\n";

        }

      }

    }

          # in case we have metadata in \ and -start defined, look grace automatically

    elsif( !$param_server and $param_start_directly ) {

              $pathToReleaseFolder = FindGraceServer( );

    }

  }

  # ToDo: if there is not metadata.xml in root check if we have already env. Possibly update?

  # is 'path' parameter is used, find out (wheter there exists) valid metadata.xml

  if( $param_release_path ) {

    if( $param_latest or $param_product ) {

      print "It doesnt make sense to use 'path' or 'latest' parameter while having metadata.xml in root!\n\n";

      print_help( );

      exit 0;

    }

    $metaDataXml = FixPaths( $param_release_path );

    $metaDataXml .= SearchValidXml( $metaDataXml );

    printLog( "setting metadata: $metaDataXml" );

  }

  # handle server parameter

  # simply just verify accessablility and fix path

  if( $param_server ) {

      $pathToReleaseFolder = FixPaths( $param_server );

      opendir( OPENTEST, $pathToReleaseFolder ) or HandleError( "Unable to access given server path: $pathToReleaseFolder\n$!", $cannotContinue );

      closedir( OPENTEST );

  }

  # param_latest is used to just get latest release - requires product

  if( $param_latest ) {

    if( $param_product ) {

      $param_product = FixPaths( $param_product );

      # once the network share is unavailable then tries to find grace share

      $pathToReleaseFolder = FindGraceServer( );

      opendir( RELDIR, $pathToReleaseFolder.$defaultServiceName.$param_product ) or die "unable to open $pathToReleaseFolder$defaultServiceName$param_product\n$!";

      # scan all xml files to @files_found

# salmarko starts

      my @files_found = grep { /^pf_|^S60_|^dfs_/i } readdir RELDIR;

# salmarko ends

      close RELDIR;

      if( @files_found ) {

          foreach( reverse sort ( @files_found ) ) {

              # we only want to get the last dir name..

              s/.*\///i;

              my $productToDl = $pathToReleaseFolder.$defaultServiceName.$param_product;

              $productToDl .= FixPaths( $_ );

              print "Searching metadata.xml files from $productToDl\n" if $param_debug;

              $metaDataXml = SearchValidXml( $productToDl ) ;

              if( $metaDataXml ) {

                  $metaDataXml = $productToDl.$metaDataXml;

                  printLog( "selected xml: $metaDataXml" );

                  last;

              }

          }

      }

      else {

          HandleError( "cannot find releases from $pathToReleaseFolder$defaultServiceName$param_product", $cannotContinue );

      }

    }

    else {

        die "If you specify -latest parameter you have to define -product also!\n";

    }

  }

  # use wizard to find out what to DL

  if( ! $metaDataXml ) {

      printLog( "Not enought valid inputs provided - running wizard..." );

      RunWizard( );

  }

  # check wheter metadata and currentRelease adds up

  if( -e FixPaths( getcwd )."currentRelease.xml") {

      printLog( "CurrenRelease.xml exists. Checking wheter update is possible" );

      # compare service, product and release with xml files

      my $CurrentRelXmlParser = new XML::Simple( );

      my $currentReleaseData = $CurrentRelXmlParser->XMLin( FixPaths( getcwd )."currentRelease.xml" );

      my $xmlParser = new XML::Simple( );

      my $xmlData = $xmlParser->XMLin( $metaDataXml );

# salmarko starts

      my $currentRelease = '';

      my $newRelease = '';

      if ( !defined $xmlData->{releaseDetails}->{dependsOf}->{service}->{name} ) { # no dependencies, lets compare current to new

          # compare services

          if( $currentReleaseData->{releaseDetails}->{releaseID}->{service}->{name} ne

                  $xmlData->{releaseDetails}->{releaseID}->{service}->{name} ) {

              HandleError( "Can not extract ".$xmlData->{releaseDetails}->{releaseID}->{service}->{name} .

              " release on top of ".$currentReleaseData->{releaseDetails}->{releaseID}->{service}->{name}, $cannotContinue );

          }

          # compare products

          if( $currentReleaseData->{releaseDetails}->{releaseID}->{product}->{name} ne

                  $xmlData->{releaseDetails}->{releaseID}->{product}->{name} ) {

              HandleError( "Can not extract ".$xmlData->{releaseDetails}->{releaseID}->{product}->{name} .

              " release on top of ".$currentReleaseData->{releaseDetails}->{releaseID}->{product}->{name}, $cannotContinue );

          }

          printLog( "service and product matches.. checking release" );

          $currentRelease = $currentReleaseData->{releaseDetails}->{releaseID}->{release}->{name};

          $newRelease = $xmlData->{releaseDetails}->{releaseID}->{release}->{name};

      }

      else{

          # compare services

          if( $currentReleaseData->{releaseDetails}->{releaseID}->{service}->{name} ne

                  $xmlData->{releaseDetails}->{dependsOf}->{service}->{name} ) {

              HandleError( "Can not extract ".$xmlData->{releaseDetails}->{dependsOf}->{service}->{name} .

              " release on top of ".$currentReleaseData->{releaseDetails}->{releaseID}->{service}->{name}, $cannotContinue );

          }

          # compare products

          if( $currentReleaseData->{releaseDetails}->{releaseID}->{product}->{name} ne

                  $xmlData->{releaseDetails}->{dependsOf}->{product}->{name} ) {

              HandleError( "Can not extract ".$xmlData->{releaseDetails}->{dependsOf}->{product}->{name} .

              " release on top of ".$currentReleaseData->{releaseDetails}->{releaseID}->{product}->{name}, $cannotContinue );

          }

          printLog( "service and product matches.. checking release" );

          # compare releases

          $currentRelease = $currentReleaseData->{releaseDetails}->{releaseID}->{release}->{name};

          $newRelease = $xmlData->{releaseDetails}->{dependsOf}->{release}->{name};

          if ( $currentRelease =~ m/^(S60_\d_\d+_\d{6})/i or $currentRelease =~ m/^(pf_\d{4}_\d{6})/ ) {

              $currentRelease = $1;

          }

          else {

              HandleError( "Current release info unknown or missing: $currentRelease", $cannotContinue );

          }

          if ( $newRelease =~ m/^(S60_\d_\d+_\d{6})/i or $newRelease =~ m/^(pf_\d{4}_\d{6})/ ) {

              $newRelease = $1;

          }

          else {

              HandleError( "New release info unknown or missing: $newRelease", $cannotContinue );

          }

      }

      printLog( "current release: $currentRelease" );

      printLog( "release to extract: $newRelease" );

#salmarko ends

      if( $currentRelease ne $newRelease ) {

          HandleError( "Can not extract $newRelease release on top of $currentRelease", $cannotContinue );

      }

      printLog( "release matches - update possible" );

      $currentRelease = FixPaths( getcwd )."currentRelease.xml";

  }

  # check wheter we can use c-disc as temp

  my $df = getFreeDisk(  $ENV{'TEMP'}  );

  if( $df > 2147483648 && $df < 2147483648000 ) {

    printLog( "amount of free space seems sane: $df" );

    $tmpDir = FixPaths( tempdir( CLEANUP => 0 ) );

    printLog( "setting tmpDir: $tmpDir" );

    $tmpDlDir = FixPaths( tempdir( CLEANUP => 0 ) );

    printLog( "setting tmpDlDir: $tmpDlDir" );

  }

}

# Make sure paths are as perl likes 'em

# change '\' ==> '/' and make sure last char is /

sub FixPaths {

    my $tmpParam = shift;

    $tmpParam =~ s/\\/\//g;

    if( substr( $tmpParam, -1 ) eq "/" ) {

        return $tmpParam;

    }

    else {

        return $tmpParam."/";

    }

}

# smarter handling of logging

sub printLog {

    foreach my $trace ( @_ ) {

        if( $param_debug ) {

            # we should print traces for STDOUT as well

            my ($sec,$min,$hr) = localtime();

        printf( "%02d:%02d:%02d: ", $hr, $min, $sec );

            print $trace."\n";

        }

        # first open/create log file

        #open( LOGFILE, ">> $logFile" ) or handleError( "cant create log file: $!", $warning );

        eval {

            open( LOGFILE, ">> getcwd.'/output/logs/getenv.log'" );

        }; 

        if ($@) #if exception

        {

            open( LOGFILE, ">> getcwd.'/getenv.log'" ) or handleError( "cant create log file: $!", $warning );

        }

        # we should print traces for log file

        my ($sec,$min,$hr) = localtime();

        printf LOGFILE ( "%02d:%02d:%02d: ", $hr, $min, $sec );

        print LOGFILE $trace."\n";

		close (LOGFILE);

    }

}

sub HandleError {

    my( $errorString, $errorType ) = @_;

    printLog( "HandleError: $errorString, type: $errorType" );

    if( $errorType eq $warning ) {

        print "\nWARNING: $errorString\n";

    }

    if( $errorType eq $promptUser ) {

        print "\nWARNING: $errorString\n\n";

        print "Press <enter> to continue..\n" if( ! $param_start_directly );

        my $selection = <STDIN> if( ! $param_start_directly );

    }

    elsif( $errorType eq $dependencyMissing ) {

        if( $param_keepgoing ) {

            print "\nERROR: Required dependency missing: $errorString\n\n";

        }

        else {

            die "ERROR: all the needed dependencies doesn't exist!\n$errorString\nIf you think it is ok to ignore this error you can use -k as keep-going parameter\nYou should report this to administrator of the server\n\ngetenv will now exit\n\n";

        }

    }

    elsif( $errorType eq $cannotContinue ) {

        if( $param_keepgoing ) {

            print "\nWARNING: $errorString\n\n";

        }

        else {

            die "\nERROR:\n============\n$errorString\ngetenv will now exit\nIf you think it is ok to ignore this error you can use -k as keep going parameter\n\n";

        }

    }

}

# checks wheter the xml file seems sane (has service, product and name set)

sub ValidateXmlFile {

    my $xmlFile = shift( @_ );

    printLog( "Validating $xmlFile" );

    # open the xml file and check wheter it is something we want

    my $dependencyXmlParser = new XML::Simple( );

    my $dependencyData = $dependencyXmlParser->XMLin( $xmlFile );

    # if releaseDetails->releaseID->service&product&release are found consider this as valid file

    if( $dependencyData->{releaseDetails}->{releaseID}->{service}->{name} and

            $dependencyData->{releaseDetails}->{releaseID}->{product}->{name} and

            $dependencyData->{releaseDetails}->{releaseID}->{release}->{name} ) {

        # return xml file with path

        printLog( "xml file OK" );

        return 1;

    }

    else {

        printLog( "xml file doesn't seem to be sane!" );

        return 0;

    }

}

sub print_help {

    print "

usage

=====

getenv.pl [params]

  getenv.pl             use no parameters to run small wizard

  getenv.pl -h(elp)     print help

  getenv.pl -k          keep going even when errors occurs

  getenv.pl -p          do nothing, but print system calls

  getenv.pl -emu        DEPRECATED - prefer filtering: get only emulator environment

  getenv.pl -start      starts extracting without user confirmation (nice for scripts)

  getenv.pl -nodeps     do not download dependencies for the release

  getenv.pl -skipitd    DEPRECATED - prefer filtering: skips useless doc, internal, tsrc zips

  getenv.pl -verbose    print debug traces

  getenv.pl -Include    include only some types of packages (emu, src, tsrc)

  getenv.pl -eXclude    exclude some types of packages (emu, src, tsrc)

  getenv.pl -all        extract all zips

  getenv.pl -Force      forces to extract some filtered packages ( tsrc ) including default zips

examples

========

  get latest PRODUCT release:

      getenv.pl -latest -product PRODUCT

  get s60 release from server \\\\SERVER\\LOCATION:

      getenv.pl -server \\\\SERVER\\LOCATION

  get s60 release located in \\\\SERVER\\LOCATION\\BUILDS\\PRODUCT\\RELEASE:

      getenv.pl -path \\\\SERVER\\LOCATION\\BUILDS\\PRODUCT\\RELEASE

  get s60 release pointed with -path and print verbose messages:

      getenv.pl -path \\\\SERVER\\LOCATION\\BUILDS\\PRODUCT\\RELEASE -verbose

Filtering