| #************************************************************** |
| # |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| #************************************************************** |
| |
| |
| |
| package installer::packagelist; |
| |
| use installer::converter; |
| use installer::exiter; |
| use installer::globals; |
| use installer::remover; |
| use installer::scriptitems; |
| |
| ######################################## |
| # Check existence of module |
| ######################################## |
| |
| sub check_module_existence |
| { |
| my ($onegid, $moduleslist) = @_; |
| |
| my $foundgid = 0; |
| |
| for ( my $i = 0; $i <= $#{$moduleslist}; $i++ ) |
| { |
| my $gid = ${$moduleslist}[$i]->{'gid'}; |
| |
| if ( $gid eq $onegid ) |
| { |
| $foundgid = 1; |
| last; |
| } |
| } |
| |
| return $foundgid; |
| } |
| |
| ################################################### |
| # Analyzing the gids, defined in the packagelist |
| ################################################### |
| |
| sub analyze_list |
| { |
| my ($packagelist, $moduleslist) = @_; |
| |
| @allpackages = (); |
| |
| my $moduleshash = get_module_hash($moduleslist); |
| |
| for ( my $i = 0; $i <= $#{$packagelist}; $i++ ) |
| { |
| my $onepackage = ${$packagelist}[$i]; |
| |
| my $onegid = $onepackage->{'module'}; |
| |
| installer::remover::remove_leading_and_ending_whitespaces(\$onegid); |
| |
| my $moduleexists = check_module_existence($onegid, $moduleslist); |
| |
| if ( ! $moduleexists ) { next; } |
| |
| my @allmodules = (); |
| |
| push(@allmodules, $onegid); |
| |
| # get_children($moduleslist, $onegid, \@allmodules); |
| get_children_with_hash($moduleshash, $onegid, \@allmodules); |
| |
| $onepackage->{'allmodules'} = \@allmodules; |
| |
| push(@allpackages, $onepackage); |
| } |
| |
| return \@allpackages; |
| } |
| |
| ################################################### |
| # Creating a hash, that contains the module gids |
| # as keys and the parentids as values |
| ################################################### |
| |
| sub get_module_hash |
| { |
| my ($moduleslist) = @_; |
| |
| my %modulehash = (); |
| |
| for ( my $i = 0; $i <= $#{$moduleslist}; $i++ ) |
| { |
| my $gid = ${$moduleslist}[$i]->{'gid'}; |
| # Containing only modules with parent. Root modules can be ignored. |
| if ( ${$moduleslist}[$i]->{'ParentID'} ) { $modulehash{$gid} = ${$moduleslist}[$i]->{'ParentID'}; } |
| } |
| |
| return \%modulehash; |
| } |
| |
| ######################################################## |
| # Recursively defined procedure to order |
| # modules and directories |
| ######################################################## |
| |
| sub get_children_with_hash |
| { |
| my ($modulehash, $parentgid, $newitemorder) = @_; |
| |
| foreach my $gid ( keys %{$modulehash} ) |
| { |
| my $parent = $modulehash->{$gid}; |
| |
| if ( $parent eq $parentgid ) |
| { |
| push(@{$newitemorder}, $gid); |
| my $parent = $gid; |
| get_children_with_hash($modulehash, $parent, $newitemorder); # recursive! |
| } |
| } |
| } |
| |
| ######################################################## |
| # Recursively defined procedure to order |
| # modules and directories |
| ######################################################## |
| |
| sub get_children |
| { |
| my ($allitems, $startparent, $newitemorder) = @_; |
| |
| for ( my $i = 0; $i <= $#{$allitems}; $i++ ) |
| { |
| my $gid = ${$allitems}[$i]->{'gid'}; |
| my $parent = ""; |
| if ( ${$allitems}[$i]->{'ParentID'} ) { $parent = ${$allitems}[$i]->{'ParentID'}; } |
| |
| if ( $parent eq $startparent ) |
| { |
| push(@{$newitemorder}, $gid); |
| my $parent = $gid; |
| get_children($allitems, $parent, $newitemorder); # recursive! |
| } |
| } |
| } |
| |
| ##################################################################### |
| # All modules below a defined gid_Module_A are collected now for |
| # each modules defined in the packagelist. Now the modules have |
| # to be removed, that are part of more than one package. |
| ##################################################################### |
| |
| sub remove_multiple_modules_packages |
| { |
| my ($allpackagemodules) = @_; |
| |
| # iterating over all packages |
| |
| for ( my $i = 0; $i <= $#{$allpackagemodules}; $i++ ) |
| { |
| my $onepackage = ${$allpackagemodules}[$i]; |
| my $allmodules = $onepackage->{'allmodules'}; |
| |
| # print "Modules below $onepackage->{'module'}: $#{$allmodules}\n"; |
| |
| # Comparing each package, with all following packages. If a |
| # gid for the module is part of more than one package, it is |
| # removed if the number of modules in the package is greater |
| # in the current package than in the compare package. |
| |
| # Taking all modules from package $i |
| |
| my $packagecount = $#{$allmodules}; |
| |
| my @optimizedpackage = (); |
| |
| # iterating over all modules of this package |
| |
| for ( my $j = 0; $j <= $#{$allmodules}; $j++ ) |
| { |
| my $onemodule = ${$allmodules}[$j]; # this is the module, that shall be removed or not |
| |
| my $put_module_into_new_package = 1; |
| |
| # iterating over all other packages |
| |
| for ( my $k = 0; $k <= $#{$allpackagemodules}; $k++ ) |
| { |
| if ( $k == $i ) { next; } # not comparing equal module |
| |
| if (! $put_module_into_new_package) { next; } # do not compare, if already found |
| |
| my $comparepackage = ${$allpackagemodules}[$k]; |
| my $allcomparemodules = $comparepackage->{'allmodules'}; |
| |
| my $comparepackagecount = $#{$allcomparemodules}; |
| |
| # modules will only be removed from packages, that have more modules |
| # than the compare package |
| |
| if ( $packagecount <= $comparepackagecount ) { next; } # nothing to do, take next package |
| |
| # iterating over all modules of this package |
| |
| for ( my $m = 0; $m <= $#{$allcomparemodules}; $m++ ) |
| { |
| my $onecomparemodule = ${$allcomparemodules}[$m]; |
| |
| if ( $onemodule eq $onecomparemodule ) # this $onemodule has to be removed |
| { |
| $put_module_into_new_package = 0; |
| } |
| } |
| } |
| |
| if ( $put_module_into_new_package ) |
| { |
| push(@optimizedpackage, $onemodule) |
| } |
| } |
| |
| $onepackage->{'allmodules'} = \@optimizedpackage; |
| } |
| |
| # for ( my $i = 0; $i <= $#{$allpackagemodules}; $i++ ) |
| # { |
| # my $onepackage = ${$allpackagemodules}[$i]; |
| # my $allmodules = $onepackage->{'allmodules'}; |
| # print "New: Modules below $onepackage->{'module'}: $#{$allmodules}\n"; |
| # } |
| |
| } |
| |
| ##################################################################### |
| # Analyzing all files if they belong to a special package. |
| # A package is described by a list of modules. |
| ##################################################################### |
| |
| sub find_files_for_package |
| { |
| my ($filelist, $onepackage) = @_; |
| |
| my @newfilelist = (); |
| |
| for ( my $i = 0; $i <= $#{$filelist}; $i++ ) |
| { |
| my $onefile = ${$filelist}[$i]; |
| my $modulesstring = $onefile->{'modules'}; # comma separated modules list |
| my $moduleslist = installer::converter::convert_stringlist_into_array(\$modulesstring, ","); |
| |
| my $includefile = 0; |
| |
| # iterating over all modules of this file |
| |
| for ( my $j = 0; $j <= $#{$moduleslist}; $j++ ) |
| { |
| if ( $includefile ) { next; } |
| my $filemodule = ${$moduleslist}[$j]; |
| installer::remover::remove_leading_and_ending_whitespaces(\$filemodule); |
| |
| # iterating over all modules of the package |
| |
| my $packagemodules = $onepackage->{'allmodules'}; |
| |
| for ( my $k = 0; $k <= $#{$packagemodules}; $k++ ) |
| { |
| if ( $includefile ) { next; } |
| my $packagemodule = ${$packagemodules}[$k]; |
| |
| if ( $filemodule eq $packagemodule ) |
| { |
| $includefile = 1; |
| last; |
| } |
| } |
| } |
| |
| if ( $includefile ) |
| { |
| push(@newfilelist, $onefile); |
| } |
| } |
| |
| return \@newfilelist; |
| } |
| |
| ##################################################################### |
| # Analyzing all links if they belong to a special package. |
| # A package is described by a list of modules. |
| # A link is inserted into the package, if the corresponding |
| # file is also inserted. |
| ##################################################################### |
| |
| sub find_links_for_package |
| { |
| my ($linklist, $filelist) = @_; |
| |
| # First looking for all links with a FileID. |
| # Then looking for all links with a ShortcutID. |
| |
| my @newlinklist = (); |
| |
| for ( my $i = 0; $i <= $#{$linklist}; $i++ ) |
| { |
| my $includelink = 0; |
| |
| my $onelink = ${$linklist}[$i]; |
| |
| my $fileid = ""; |
| if ( $onelink->{'FileID'} ) { $fileid = $onelink->{'FileID'}; } |
| |
| if ( $fileid eq "" ) { next; } # A link with a ShortcutID |
| |
| for ( my $j = 0; $j <= $#{$filelist}; $j++ ) # iterating over file list |
| { |
| my $onefile = ${$filelist}[$j]; |
| my $gid = $onefile->{'gid'}; |
| |
| if ( $gid eq $fileid ) |
| { |
| $includelink = 1; |
| last; |
| } |
| } |
| |
| if ( $includelink ) |
| { |
| push(@newlinklist, $onelink); |
| } |
| } |
| |
| # iterating over the new list, because of all links with a ShortcutID |
| |
| for ( my $i = 0; $i <= $#{$linklist}; $i++ ) |
| { |
| my $includelink = 0; |
| |
| my $onelink = ${$linklist}[$i]; |
| |
| my $shortcutid = ""; |
| if ( $onelink->{'ShortcutID'} ) { $shortcutid = $onelink->{'ShortcutID'}; } |
| |
| if ( $shortcutid eq "" ) { next; } # A link with a ShortcutID |
| |
| for ( my $j = 0; $j <= $#newlinklist; $j++ ) # iterating over newly created link list |
| { |
| my $onefilelink = $newlinklist[$j]; |
| my $gid = $onefilelink->{'gid'}; |
| |
| if ( $gid eq $shortcutid ) |
| { |
| $includelink = 1; |
| last; |
| } |
| } |
| |
| if ( $includelink ) |
| { |
| push(@newlinklist, $onelink); |
| } |
| } |
| |
| return \@newlinklist; |
| } |
| |
| ##################################################################### |
| # Analyzing all directories if they belong to a special package. |
| # A package is described by a list of modules. |
| # Directories are included into the package, if they are needed |
| # by a file or a link included into the package. |
| # Attention: A directory with the flag CREATE, is only included |
| # into the root module: |
| # ($packagename eq $installer::globals::rootmodulegid) |
| ##################################################################### |
| |
| sub find_dirs_for_package |
| { |
| my ($dirlist, $onepackage) = @_; |
| |
| my @newdirlist = (); |
| |
| for ( my $i = 0; $i <= $#{$dirlist}; $i++ ) |
| { |
| my $onedir = ${$dirlist}[$i]; |
| my $modulesstring = $onedir->{'modules'}; # comma separated modules list |
| my $moduleslist = installer::converter::convert_stringlist_into_array(\$modulesstring, ","); |
| |
| my $includedir = 0; |
| |
| # iterating over all modules of this dir |
| |
| for ( my $j = 0; $j <= $#{$moduleslist}; $j++ ) |
| { |
| if ( $includedir ) { last; } |
| my $dirmodule = ${$moduleslist}[$j]; |
| installer::remover::remove_leading_and_ending_whitespaces(\$dirmodule); |
| |
| # iterating over all modules of the package |
| |
| my $packagemodules = $onepackage->{'allmodules'}; |
| |
| for ( my $k = 0; $k <= $#{$packagemodules}; $k++ ) |
| { |
| my $packagemodule = ${$packagemodules}[$k]; |
| |
| if ( $dirmodule eq $packagemodule ) |
| { |
| $includedir = 1; |
| last; |
| } |
| } |
| } |
| |
| if ( $includedir ) |
| { |
| push(@newdirlist, $onedir); |
| } |
| } |
| |
| return \@newdirlist; |
| } |
| |
| ##################################################################### |
| # Resolving all variables in the packagename. |
| ##################################################################### |
| |
| sub resolve_packagevariables |
| { |
| my ($packagenameref, $variableshashref, $make_lowercase) = @_; |
| |
| my $key; |
| |
| # Special handling for dictionaries |
| if ( $$packagenameref =~ /-dict-/ ) |
| { |
| if (exists($variableshashref->{'DICTIONARYUNIXPRODUCTNAME'}) ) { $$packagenameref =~ s/\%UNIXPRODUCTNAME/$variableshashref->{'DICTIONARYUNIXPRODUCTNAME'}/g; } |
| if (exists($variableshashref->{'DICTIONARYBRANDPACKAGEVERSION'}) ) { $$packagenameref =~ s/\%BRANDPACKAGEVERSION/$variableshashref->{'DICTIONARYBRANDPACKAGEVERSION'}/g; } |
| } |
| |
| foreach $key (keys %{$variableshashref}) |
| { |
| my $value = $variableshashref->{$key}; |
| if ( $make_lowercase ) { $value = lc($value); } |
| $$packagenameref =~ s/\%$key/$value/g; |
| } |
| } |
| |
| ##################################################################### |
| # Resolving all variables in the packagename. |
| ##################################################################### |
| |
| sub resolve_packagevariables2 |
| { |
| my ($packagenameref, $variableshashref, $make_lowercase, $isdict ) = @_; |
| |
| my $key; |
| |
| # Special handling for dictionaries |
| if ( $isdict ) |
| { |
| if (exists($variableshashref->{'DICTIONARYUNIXPRODUCTNAME'}) ) { $$packagenameref =~ s/\%UNIXPRODUCTNAME/$variableshashref->{'DICTIONARYUNIXPRODUCTNAME'}/g; } |
| if (exists($variableshashref->{'DICTIONARYBRANDPACKAGEVERSION'}) ) { $$packagenameref =~ s/\%BRANDPACKAGEVERSION/$variableshashref->{'DICTIONARYBRANDPACKAGEVERSION'}/g; } |
| } |
| |
| foreach $key (keys %{$variableshashref}) |
| { |
| my $value = $variableshashref->{$key}; |
| if ( $make_lowercase ) { $value = lc($value); } |
| $$packagenameref =~ s/\%$key/$value/g; |
| } |
| } |
| |
| ##################################################################### |
| # New packages system. |
| ##################################################################### |
| |
| ################################################################## |
| # Controlling the content of the packagelist |
| # 1. Items in @installer::globals::packagelistitems must exist |
| # 2. If a shellscript file is defined, it must exist |
| ################################################################## |
| |
| sub check_packagelist |
| { |
| my ($packages) = @_; |
| |
| if ( ! ( $#{$packages} > -1 )) { installer::exiter::exit_program("ERROR: No packages defined!", "check_packagelist"); } |
| |
| for ( my $i = 0; $i <= $#{$packages}; $i++ ) |
| { |
| my $onepackage = ${$packages}[$i]; |
| |
| my $element; |
| |
| # checking all items that must be defined |
| |
| foreach $element (@installer::globals::packagelistitems) |
| { |
| if ( ! exists($onepackage->{$element}) ) |
| { |
| installer::exiter::exit_program("ERROR in package list: No value for $element !", "check_packagelist"); |
| } |
| } |
| |
| # checking the existence of the script file, if defined |
| |
| if ( $onepackage->{'script'} ) |
| { |
| my $scriptfile = $onepackage->{'script'}; |
| my $gid = $onepackage->{'module'}; |
| my $fileref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$scriptfile, "" , 0); |
| |
| if ( $$fileref eq "" ) { installer::exiter::exit_program("ERROR: Could not find script file $scriptfile for module $gid!", "check_packagelist"); } |
| |
| $installer::logger::Lang->printf("%s: Using script file: \"%s\"!\n", $gid, $$fileref); |
| |
| $onepackage->{'script'} = $$fileref; |
| } |
| } |
| } |
| |
| ##################################################################### |
| # Reading pack info for one module from packinfo file. |
| ##################################################################### |
| |
| sub get_packinfo |
| { |
| my ($gid, $filename, $packages, $onelanguage, $islanguagemodule) = @_; |
| |
| my $packagelist = installer::files::read_file($filename); |
| |
| my @allpackages = (); |
| |
| for ( my $i = 0; $i <= $#{$packagelist}; $i++ ) |
| { |
| my $line = ${$packagelist}[$i]; |
| |
| if ( $line =~ /^\s*\#/ ) { next; } # this is a comment line |
| |
| if ( $line =~ /^\s*Start\s*$/i ) # a new package definition |
| { |
| my %onepackage = (); |
| |
| my $counter = $i + 1; |
| |
| while (!( ${$packagelist}[$counter] =~ /^\s*End\s*$/i )) |
| { |
| if ( ${$packagelist}[$counter] =~ /^\s*(\S+)\s*\=\s*\"(.*)\"/ ) |
| { |
| my $key = $1; |
| my $value = $2; |
| $onepackage{$key} = $value; |
| } |
| |
| $counter++; |
| } |
| |
| $onepackage{'islanguagemodule'} = $islanguagemodule; |
| if ( $islanguagemodule ) |
| { |
| $saveonelanguage = $onelanguage; |
| $saveonelanguage =~ s/_/-/g; |
| $onepackage{'language'} = $saveonelanguage; |
| } |
| |
| push(@allpackages, \%onepackage); |
| } |
| } |
| |
| # looking for the packinfo with the correct gid |
| |
| my $foundgid = 0; |
| my $onepackage; |
| foreach $onepackage (@allpackages) |
| { |
| # Adding the language to the module gid for LanguagePacks ! |
| # Making the module gid language specific: gid_Module_Root -> gir_Module_Root_pt_BR (as defined in scp2) |
| if ( $onelanguage ne "" ) { $onepackage->{'module'} = $onepackage->{'module'} . "_$onelanguage"; } |
| |
| if ( $onepackage->{'module'} eq $gid ) |
| { |
| # Resolving the language identifier |
| my $onekey; |
| foreach $onekey ( keys %{$onepackage} ) |
| { |
| # Some keys require "-" instead of "_" for example in "en-US". All package names do not use underlines. |
| my $locallang = $onelanguage; |
| if (( $onekey eq "solarispackagename" ) || |
| ( $onekey eq "solarisrequires" ) || |
| ( $onekey eq "packagename" ) || |
| ( $onekey eq "linuxreplaces" ) || |
| ( $onekey eq "provides" ) || |
| ( $onekey eq "requires" )) { $locallang =~ s/_/-/g; } # avoiding illegal package abbreviation |
| $onepackage->{$onekey} =~ s/\%LANGUAGESTRING/$locallang/g; |
| } |
| |
| # Saving the language for the package |
| my $lang = $onelanguage; |
| $lang =~ s/_/-/g; |
| $onepackage->{'specificlanguage'} = $lang; |
| |
| push(@{$packages}, $onepackage); |
| $foundgid = 1; |
| last; |
| } |
| } |
| |
| if ( ! $foundgid ) |
| { |
| installer::exiter::exit_program("ERROR: Could not find package info for module $gid in file \"$filename\"!", "get_packinfo"); |
| } |
| } |
| |
| ##################################################################### |
| # Collecting all packages from scp project. |
| ##################################################################### |
| |
| sub collectpackages |
| { |
| my ( $allmodules, $languagesarrayref ) = @_; |
| |
| installer::logger::include_header_into_logfile("Collecting packages:"); |
| |
| my @packages = (); |
| my %gid_analyzed = (); |
| |
| my $onemodule; |
| foreach $onemodule ( @{$allmodules} ) |
| { |
| my $packageinfo = "PackageInfo"; |
| if (( $installer::globals::tab ) && ( $onemodule->{"TabPackageInfo"} )) { $packageinfo = "TabPackageInfo" } |
| |
| if ( $onemodule->{$packageinfo} ) # this is a package module! |
| { |
| my $modulegid = $onemodule->{'gid'}; |
| |
| # Only collecting modules with correct language for language packs |
| # if ( $installer::globals::languagepack ) { if ( ! ( $modulegid =~ /_$onelanguage\s*$/ )) { next; } } |
| # Resetting language, if this is no language pack |
| # if ( ! $installer::globals::languagepack ) { $onelanguage = ""; } |
| |
| my $styles = ""; |
| if ( $onemodule->{'Styles'} ) { $styles = $onemodule->{'Styles'}; } |
| |
| # checking modules with style LANGUAGEMODULE |
| my $islanguagemodule = 0; |
| my $onelanguage = ""; |
| if ( $styles =~ /\bLANGUAGEMODULE\b/ ) |
| { |
| $islanguagemodule = 1; |
| $onelanguage = $onemodule->{'Language'}; # already checked, that it is set. |
| $onelanguage =~ s/-/_/g; # pt-BR -> pt_BR in scp |
| } |
| |
| # Modules in different languages are listed more than once in multilingual installation sets |
| if ( exists($gid_analyzed{$modulegid}) ) { next; } |
| $gid_analyzed{$modulegid} = 1; |
| |
| my $packinfofile = $onemodule->{$packageinfo}; |
| |
| # The file with package information has to be found in path list |
| my $fileref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$packinfofile, "" , 0); |
| |
| if ( $$fileref eq "" ) { installer::exiter::exit_program("ERROR: Could not find file $packinfofile for module $modulegid!", "collectpackages"); } |
| |
| $installer::logger::Lang->printf("%s: Using packinfo: \"%s\"!\n", $modulegid, $$fileref); |
| |
| get_packinfo($modulegid, $$fileref, \@packages, $onelanguage, $islanguagemodule); |
| } |
| } |
| |
| return \@packages; |
| } |
| |
| ##################################################################### |
| # Printing packages content for debugging purposes |
| ##################################################################### |
| |
| sub log_packages_content |
| { |
| my ($packages) = @_; |
| |
| if ( ! ( $#{$packages} > -1 )) { installer::exiter::exit_program("ERROR: No packages defined!", "print_content"); } |
| |
| installer::logger::include_header_into_logfile("Logging packages content:"); |
| |
| my $infoline = ""; |
| |
| for ( my $i = 0; $i <= $#{$packages}; $i++ ) |
| { |
| my $onepackage = ${$packages}[$i]; |
| |
| # checking all items that must be defined |
| |
| $installer::logger::Lang->printf("Package %s\n", $onepackage->{'module'}); |
| |
| my $key; |
| foreach $key (sort keys %{$onepackage}) |
| { |
| if ( $key =~ /^\s*\;/ ) { next; } |
| |
| if ( $key eq "allmodules" ) |
| { |
| $installer::logger::Lang->printf("\t%s:\n", $key); |
| my $onemodule; |
| foreach $onemodule ( @{$onepackage->{$key}} ) |
| { |
| $installer::logger::Lang->printf("\t\t%s\n", $onemodule); |
| } |
| } |
| else |
| { |
| $installer::logger::Lang->printf("\t%s: %s\n", $key, $onepackage->{$key}); |
| } |
| } |
| |
| $installer::logger::Lang->printf("\n"); |
| |
| } |
| } |
| |
| ##################################################################### |
| # Creating assignments from modules to destination pathes. |
| # This is required for logging in fileinfo file. Otherwise |
| # the complete destination file would not be known in file list. |
| # Saved in %installer::globals::moduledestination |
| ##################################################################### |
| |
| sub create_module_destination_hash |
| { |
| my ($packages, $allvariables) = @_; |
| |
| for ( my $i = 0; $i <= $#{$packages}; $i++ ) |
| { |
| my $onepackage = ${$packages}[$i]; |
| |
| my $defaultdestination = $onepackage->{'destpath'}; |
| resolve_packagevariables(\$defaultdestination, $allvariables, 1); |
| if ( $^O =~ /darwin/i ) { $defaultdestination =~ s/\/opt\//\/Applications\//; } |
| |
| foreach my $onemodule ( @{$onepackage->{'allmodules'}} ) |
| { |
| $installer::globals::moduledestination{$onemodule} = $defaultdestination; |
| } |
| } |
| } |
| |
| ##################################################################### |
| # Adding the default pathes into the files collector for Unixes. |
| # This is necessary to know the complete destination path in |
| # fileinfo log file. |
| ##################################################################### |
| |
| sub add_defaultpathes_into_filescollector |
| { |
| my ($allfiles) = @_; |
| |
| for ( my $i = 0; $i <= $#{$allfiles}; $i++ ) |
| { |
| my $onefile = ${$allfiles}[$i]; |
| |
| if ( ! $onefile->{'destination'} ) { installer::exiter::exit_program("ERROR: No destination found at file $onefile->{'gid'}!", "add_defaultpathes_into_filescollector"); } |
| my $destination = $onefile->{'destination'}; |
| |
| if ( ! $onefile->{'modules'} ) { installer::exiter::exit_program("ERROR: No modules found at file $onefile->{'gid'}!", "add_defaultpathes_into_filescollector"); } |
| my $module = $onefile->{'modules'}; |
| # If modules contains a list of modules, only taking the first one. |
| if ( $module =~ /^\s*(.*?)\,/ ) { $module = $1; } |
| |
| if ( ! exists($installer::globals::moduledestination{$module}) ) { installer::exiter::exit_program("ERROR: No default destination path found for module $module!", "add_defaultpathes_into_filescollector"); } |
| my $defaultpath = $installer::globals::moduledestination{$module}; |
| $defaultpath =~ s/\/\s*$//; # removing ending slashes |
| my $fulldestpath = $defaultpath . $installer::globals::separator . $destination; |
| |
| $onefile->{'fulldestpath'} = $fulldestpath; |
| } |
| } |
| |
| ##################################################################### |
| # Creating list of cabinet files from packages |
| ##################################################################### |
| |
| sub prepare_cabinet_files |
| { |
| my ($packages, $allvariables) = @_; |
| |
| if ( ! ( $#{$packages} > -1 )) { installer::exiter::exit_program("ERROR: No packages defined!", "print_content"); } |
| |
| installer::logger::include_header_into_logfile("Preparing cabinet files:"); |
| |
| my $infoline = ""; |
| |
| for ( my $i = 0; $i <= $#{$packages}; $i++ ) |
| { |
| my $onepackage = ${$packages}[$i]; |
| |
| my $cabinetfile = "$onepackage->{'packagename'}\.cab"; |
| |
| resolve_packagevariables(\$cabinetfile, $allvariables, 0); |
| |
| $installer::globals::allcabinets{$cabinetfile} = 1; |
| |
| # checking all items that must be defined |
| |
| $installer::logger::Lang->printf("Package %s\n", $onepackage->{'module'}); |
| |
| # Assigning the cab file to the module and also to all corresponding sub modules |
| |
| my $onemodule; |
| foreach $onemodule ( @{$onepackage->{'allmodules'}} ) |
| { |
| if ( ! exists($installer::globals::allcabinetassigns{$onemodule}) ) |
| { |
| $installer::globals::allcabinetassigns{$onemodule} = $cabinetfile; |
| } |
| else |
| { |
| $installer::logger::Lang->printf("Warning: Already existing assignment: %s : %s\n", |
| $onemodule, |
| $installer::globals::allcabinetassigns{$onemodule}); |
| $installer::logger::Lang->printf("Ignoring further assignment: %s : %s\n", |
| $onemodule, |
| $cabinetfile); |
| } |
| } |
| } |
| } |
| |
| ##################################################################### |
| # Logging assignments of cabinet files |
| ##################################################################### |
| |
| sub log_cabinet_assignments |
| { |
| installer::logger::include_header_into_logfile("Logging cabinet files:"); |
| |
| $installer::logger::Lang->printf("List of cabinet files:\n"); |
| |
| my $key; |
| foreach $key ( sort keys %installer::globals::allcabinets ) |
| { |
| $installer::logger::Lang->printf("\t%s\n", $key); |
| } |
| |
| $installer::logger::Lang->printf("\n"); |
| $installer::logger::Lang->printf("List of assignments from modules to cabinet files:\n"); |
| |
| foreach $key ( sort keys %installer::globals::allcabinetassigns ) |
| { |
| $installer::logger::Lang->printf("\t%s : %s\n", |
| $key, |
| $installer::globals::allcabinetassigns{$key}); |
| } |
| } |
| |
| 1; |