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

#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 SOAP::Lite;         # SOAP interface for s60build server

use Getopt::Long;       # parameter handling

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

# uncomment to get SOAP debug traces

# use SOAP::Lite +trace => 'debug';

# 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_no_soap,             # dont use soap connection

        @param_exclude,             # exclude list

        @param_include );           # include list

# 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

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

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

                                                'nosoap'        => \$param_no_soap );               # dont try using SOAP for s60builds server

# 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 $soapConnection;             # holding boolean value wheter we have connection s60builds server

my $soapSessionID;              # holds the session ID received from SOAP server

my $defaultPathToServer;    # default value for the server

my $soapServiceURL = undef;

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

my @graceList = ();

# must match to @graceList

my @graceNameList = ();

#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.0";

# 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'" ) ; 

  }

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( );

# if we have SOAP connection we should end it

if( $soapConnection ) {

    my $sessionInfo = EndSoapConnection( );

    print "\n\n".$sessionInfo->{'Info'}."\n\n" if( $sessionInfo->{'Info'} );

}

exit 0;

sub ValidateInputs {

    print_help( ) if ( $param_help );

    # try to get version info from s60builds SOAP server

    my $versionInfoFromServer = GetSoapVersion( ) if( !$param_no_soap );

    if( $versionInfoFromServer ) {

        # we have access to SOAP server

        printLog( "SOAP: access OK" );

        $soapConnection = 1;

        # lets not start soap if prompt only is defined

        $soapConnection = 0 if $param_print_only;

        printLog( "SOAP: latest OK version: ".$versionInfoFromServer->{'LatestOK'}->{'Version'} );

        printLog( "SOAP: latest OK date: ".$versionInfoFromServer->{'LatestOK'}->{'Date'} );

        printLog( "SOAP: latest version: ".$versionInfoFromServer->{'Latest'}->{'Version'} );

        printLog( "SOAP: latest date: ".$versionInfoFromServer->{'Latest'}->{'Date'} );

        # compare version nmbrs and prompt user if outdated getenv

        if( $getEnvVersion < $versionInfoFromServer->{'LatestOK'}->{'Version'} ) {

            HandleError( "Your getenv is outdated and can not be usedanymore\nPlease get newer from the server.", $cannotContinue );

        }       

    }

    else {

        printLog( "SOAP: we dont have SOAP access" );

        $soapConnection = 0;

    }

    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 GRACE samba share close to you.\n";

            # prompt user wheter he wants to use GRACE

            my $networkAccessVerified = 0;

            while( $networkAccessVerified eq 0 ) {

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

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

                    HandleError( "Please notice that access to $graceList[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";

    }

}

# 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";

        }

        # we should print traces for log file

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

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

        print LOGFILE $trace."\n";

    }

}

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 -nosoap     dont try to use SOAP connection for s60builds server

  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)

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

=========

  You can include or exclude certain types of packages to unzip.

  For example you can unzip only emulator binaries with -include emu (or -i emu)

  Or if you don't want test sources and documents use -exclude tsrc (or -x tsrc)

  Possible filters are emu, src, tsrc and we can put plenty more into metadata.xml if needed

  To get latest PRODUCT emulator environment use