solenv/bin/modules/installer/packagelist.pm

   1 #*************************************************************************
   2 #
   3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4 #
   5 # Copyright 2008 by Sun Microsystems, Inc.
   6 #
   7 # OpenOffice.org - a multi-platform office productivity suite
   8 #
   9 # $RCSfile: packagelist.pm,v $
  10 #
  11 # $Revision: 1.19 $
  12 #
  13 # This file is part of OpenOffice.org.
  14 #
  15 # OpenOffice.org is free software: you can redistribute it and/or modify
  16 # it under the terms of the GNU Lesser General Public License version 3
  17 # only, as published by the Free Software Foundation.
  18 #
  19 # OpenOffice.org is distributed in the hope that it will be useful,
  20 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 # GNU Lesser General Public License version 3 for more details
  23 # (a copy is included in the LICENSE file that accompanied this code).
  24 #
  25 # You should have received a copy of the GNU Lesser General Public License
  26 # version 3 along with OpenOffice.org.  If not, see
  27 # <http://www.openoffice.org/license.html>
  28 # for a copy of the LGPLv3 License.
  29 #
  30 #*************************************************************************
  31
  32 package installer::packagelist;
  33
  34 use installer::converter;
  35 use installer::exiter;
  36 use installer::globals;
  37 use installer::remover;
  38 use installer::scriptitems;
  39
  40 ########################################
  41 # Check existence of module
  42 ########################################
  43
  44 sub check_module_existence
  45 {
  46     my ($onegid, $moduleslist) = @_;
  47
  48     my $foundgid = 0;
  49
  50     for ( my $i = 0; $i <= $#{$moduleslist}; $i++ )
  51     {
  52         my $gid = ${$moduleslist}[$i]->{'gid'};
  53
  54         if ( $gid eq $onegid )
  55         {
  56             $foundgid = 1;
  57             last;
  58         }
  59     }
  60
  61     return $foundgid;
  62 }
  63
  64 ###################################################
  65 # Analyzing the gids, defined in the packagelist
  66 ###################################################
  67
  68 sub analyze_list
  69 {
  70     my ($packagelist, $moduleslist) = @_;
  71
  72     @allpackages = ();
  73
  74     my $moduleshash = get_module_hash($moduleslist);
  75
  76     for ( my $i = 0; $i <= $#{$packagelist}; $i++ )
  77     {
  78         my $onepackage = ${$packagelist}[$i];
  79
  80         my $onegid = $onepackage->{'module'};
  81
  82         installer::remover::remove_leading_and_ending_whitespaces(\$onegid);
  83
  84         my $moduleexists = check_module_existence($onegid, $moduleslist);
  85
  86         if ( ! $moduleexists ) { next; }
  87
  88         my @allmodules = ();
  89
  90         push(@allmodules, $onegid);
  91
  92         # get_children($moduleslist, $onegid, \@allmodules);
  93         get_children_with_hash($moduleshash, $onegid, \@allmodules);
  94
  95         $onepackage->{'allmodules'} = \@allmodules;
  96
  97         push(@allpackages, $onepackage);
  98     }
  99
 100     return \@allpackages;
 101 }
 102
 103 ###################################################
 104 # Creating a hash, that contains the module gids
 105 # as keys and the parentids as values
 106 ###################################################
 107
 108 sub get_module_hash
 109 {
 110     my ($moduleslist) = @_;
 111
 112     my %modulehash = ();
 113
 114     for ( my $i = 0; $i <= $#{$moduleslist}; $i++ )
 115     {
 116         my $gid = ${$moduleslist}[$i]->{'gid'};
 117         # Containing only modules with parent. Root modules can be ignored.
 118         if ( ${$moduleslist}[$i]->{'ParentID'} ) { $modulehash{$gid} = ${$moduleslist}[$i]->{'ParentID'}; }
 119     }
 120
 121     return \%modulehash;
 122 }
 123
 124 ########################################################
 125 # Recursively defined procedure to order
 126 # modules and directories
 127 ########################################################
 128
 129 sub get_children_with_hash
 130 {
 131     my ($modulehash, $parentgid, $newitemorder) = @_;
 132
 133     foreach my $gid ( keys %{$modulehash} )
 134     {
 135         my $parent = $modulehash->{$gid};
 136
 137         if ( $parent eq $parentgid )
 138         {
 139             push(@{$newitemorder}, $gid);
 140             my $parent = $gid;
 141             get_children_with_hash($modulehash, $parent, $newitemorder);        # recursive!
 142         }
 143     }
 144 }
 145
 146 ########################################################
 147 # Recursively defined procedure to order
 148 # modules and directories
 149 ########################################################
 150
 151 sub get_children
 152 {
 153     my ($allitems, $startparent, $newitemorder) = @_;
 154
 155     for ( my $i = 0; $i <= $#{$allitems}; $i++ )
 156     {
 157         my $gid = ${$allitems}[$i]->{'gid'};
 158         my $parent = "";
 159         if ( ${$allitems}[$i]->{'ParentID'} ) { $parent = ${$allitems}[$i]->{'ParentID'}; }
 160
 161         if ( $parent eq $startparent )
 162         {
 163             push(@{$newitemorder}, $gid);
 164             my $parent = $gid;
 165             get_children($allitems, $parent, $newitemorder);    # recursive!
 166         }
 167     }
 168 }
 169
 170 #####################################################################
 171 # All modules below a defined gid_Module_A are collected now for
 172 # each modules defined in the packagelist. Now the modules have
 173 # to be removed, that are part of more than one package.
 174 #####################################################################
 175
 176 sub remove_multiple_modules_packages
 177 {
 178     my ($allpackagemodules) = @_;
 179
 180     # iterating over all packages
 181
 182     for ( my $i = 0; $i <= $#{$allpackagemodules}; $i++ )
 183     {
 184         my $onepackage = ${$allpackagemodules}[$i];
 185         my $allmodules = $onepackage->{'allmodules'};
 186
 187         # print "Modules below $onepackage->{'module'}: $#{$allmodules}\n";
 188
 189         # Comparing each package, with all following packages. If a
 190         # gid for the module is part of more than one package, it is
 191         # removed if the number of modules in the package is greater
 192         # in the current package than in the compare package.
 193
 194         # Taking all modules from package $i
 195
 196         my $packagecount = $#{$allmodules};
 197
 198         my @optimizedpackage = ();
 199
 200         # iterating over all modules of this package
 201
 202         for ( my $j = 0; $j <= $#{$allmodules}; $j++ )
 203         {
 204             my $onemodule = ${$allmodules}[$j]; # this is the module, that shall be removed or not
 205
 206             my $put_module_into_new_package = 1;
 207
 208             # iterating over all other packages
 209
 210             for ( my $k = 0; $k <= $#{$allpackagemodules}; $k++ )
 211             {
 212                 if ( $k == $i ) { next; }       # not comparing equal module
 213
 214                 if (! $put_module_into_new_package) { next; } # do not compare, if already found
 215
 216                 my $comparepackage = ${$allpackagemodules}[$k];
 217                 my $allcomparemodules = $comparepackage->{'allmodules'};
 218
 219                 my $comparepackagecount = $#{$allcomparemodules};
 220
 221                 # modules will only be removed from packages, that have more modules
 222                 # than the compare package
 223
 224                 if ( $packagecount <= $comparepackagecount ) { next; }  # nothing to do, take next package
 225
 226                 # iterating over all modules of this package
 227
 228                 for ( my $m = 0; $m <= $#{$allcomparemodules}; $m++ )
 229                 {
 230                     my $onecomparemodule = ${$allcomparemodules}[$m];
 231
 232                     if ( $onemodule eq $onecomparemodule )      # this $onemodule has to be removed
 233                     {
 234                         $put_module_into_new_package = 0;
 235                     }
 236                 }
 237             }
 238
 239             if ( $put_module_into_new_package )
 240             {
 241                 push(@optimizedpackage, $onemodule)
 242             }
 243         }
 244
 245         $onepackage->{'allmodules'} = \@optimizedpackage;
 246     }
 247
 248     # for ( my $i = 0; $i <= $#{$allpackagemodules}; $i++ )
 249     # {
 250     #   my $onepackage = ${$allpackagemodules}[$i];
 251     #   my $allmodules = $onepackage->{'allmodules'};
 252     #   print "New: Modules below $onepackage->{'module'}: $#{$allmodules}\n";
 253     # }
 254
 255 }
 256
 257 #####################################################################
 258 # Analyzing all files if they belong to a special package.
 259 # A package is described by a list of modules.
 260 #####################################################################
 261
 262 sub find_files_for_package
 263 {
 264     my ($filelist, $onepackage) = @_;
 265
 266     my @newfilelist = ();
 267
 268     for ( my $i = 0; $i <= $#{$filelist}; $i++ )
 269     {
 270         my $onefile = ${$filelist}[$i];
 271         my $modulesstring = $onefile->{'modules'};       # comma separated modules list
 272         my $moduleslist = installer::converter::convert_stringlist_into_array(\$modulesstring, ",");
 273
 274         my $includefile = 0;
 275
 276         # iterating over all modules of this file
 277
 278         for ( my $j = 0; $j <= $#{$moduleslist}; $j++ )
 279         {
 280             if ( $includefile ) { next; }
 281             my $filemodule = ${$moduleslist}[$j];
 282             installer::remover::remove_leading_and_ending_whitespaces(\$filemodule);
 283
 284             # iterating over all modules of the package
 285
 286             my $packagemodules = $onepackage->{'allmodules'};
 287
 288             for ( my $k = 0; $k <= $#{$packagemodules}; $k++ )
 289             {
 290                 if ( $includefile ) { next; }
 291                 my $packagemodule = ${$packagemodules}[$k];
 292
 293                 if ( $filemodule eq $packagemodule )
 294                 {
 295                     $includefile = 1;
 296                     last;
 297                 }
 298             }
 299         }
 300
 301         if ( $includefile )
 302         {
 303             push(@newfilelist, $onefile);
 304         }
 305     }
 306
 307     return \@newfilelist;
 308 }
 309
 310 #####################################################################
 311 # Analyzing all links if they belong to a special package.
 312 # A package is described by a list of modules.
 313 # A link is inserted into the package, if the corresponding
 314 # file is also inserted.
 315 #####################################################################
 316
 317 sub find_links_for_package
 318 {
 319     my ($linklist, $filelist) = @_;
 320
 321     # First looking for all links with a FileID.
 322     # Then looking for all links with a ShortcutID.
 323
 324     my @newlinklist = ();
 325
 326     for ( my $i = 0; $i <= $#{$linklist}; $i++ )
 327     {
 328         my $includelink = 0;
 329
 330         my $onelink = ${$linklist}[$i];
 331
 332         my $fileid = "";
 333         if ( $onelink->{'FileID'} ) { $fileid = $onelink->{'FileID'}; }
 334
 335         if ( $fileid eq "" ) { next; }   # A link with a ShortcutID
 336
 337         for ( my $j = 0; $j <= $#{$filelist}; $j++ )     # iterating over file list
 338         {
 339             my $onefile = ${$filelist}[$j];
 340             my $gid = $onefile->{'gid'};
 341
 342             if ( $gid eq $fileid )
 343             {
 344                 $includelink = 1;
 345                 last;
 346             }
 347         }
 348
 349         if ( $includelink )
 350         {
 351             push(@newlinklist, $onelink);
 352         }
 353     }
 354
 355     # iterating over the new list, because of all links with a ShortcutID
 356
 357     for ( my $i = 0; $i <= $#{$linklist}; $i++ )
 358     {
 359         my $includelink = 0;
 360
 361         my $onelink = ${$linklist}[$i];
 362
 363         my $shortcutid = "";
 364         if ( $onelink->{'ShortcutID'} ) { $shortcutid = $onelink->{'ShortcutID'}; }
 365
 366         if ( $shortcutid eq "" ) { next; }       # A link with a ShortcutID
 367
 368         for ( my $j = 0; $j <= $#newlinklist; $j++ )     # iterating over newly created link list
 369         {
 370             my $onefilelink = $newlinklist[$j];
 371             my $gid = $onefilelink->{'gid'};
 372
 373             if ( $gid eq $shortcutid )
 374             {
 375                 $includelink = 1;
 376                 last;
 377             }
 378         }
 379
 380         if ( $includelink )
 381         {
 382             push(@newlinklist, $onelink);
 383         }
 384     }
 385
 386     return \@newlinklist;
 387 }
 388
 389 #####################################################################
 390 # Analyzing all directories if they belong to a special package.
 391 # A package is described by a list of modules.
 392 # Directories are included into the package, if they are needed
 393 # by a file or a link included into the package.
 394 # Attention: A directory with the flag CREATE, is only included
 395 # into the root module:
 396 # ($packagename eq $installer::globals::rootmodulegid)
 397 #####################################################################
 398
 399 sub find_dirs_for_package
 400 {
 401     my ($dirlist, $onepackage) = @_;
 402
 403     my @newdirlist = ();
 404
 405     for ( my $i = 0; $i <= $#{$dirlist}; $i++ )
 406     {
 407         my $onedir = ${$dirlist}[$i];
 408         my $modulesstring = $onedir->{'modules'};        # comma separated modules list
 409         my $moduleslist = installer::converter::convert_stringlist_into_array(\$modulesstring, ",");
 410
 411         my $includedir = 0;
 412
 413         # iterating over all modules of this dir
 414
 415         for ( my $j = 0; $j <= $#{$moduleslist}; $j++ )
 416         {
 417             if ( $includedir ) { last; }
 418             my $dirmodule = ${$moduleslist}[$j];
 419             installer::remover::remove_leading_and_ending_whitespaces(\$dirmodule);
 420
 421             # iterating over all modules of the package
 422
 423             my $packagemodules = $onepackage->{'allmodules'};
 424
 425             for ( my $k = 0; $k <= $#{$packagemodules}; $k++ )
 426             {
 427                 my $packagemodule = ${$packagemodules}[$k];
 428
 429                 if ( $dirmodule eq $packagemodule )
 430                 {
 431                     $includedir = 1;
 432                     last;
 433                 }
 434             }
 435         }
 436
 437         if ( $includedir )
 438         {
 439             push(@newdirlist, $onedir);
 440         }
 441     }
 442
 443     return \@newdirlist;
 444 }
 445
 446 #####################################################################
 447 # Resolving all variables in the packagename.
 448 #####################################################################
 449
 450 sub resolve_packagevariables
 451 {
 452     my ($packagenameref, $variableshashref, $make_lowercase) = @_;
 453
 454     my $key;
 455
 456     # Special handling for dictionaries
 457     if ( $$packagenameref =~ /-dict-/ )
 458     {
 459         if (exists($variableshashref->{'DICTIONARYUNIXPRODUCTNAME'}) ) { $$packagenameref =~ s/\%UNIXPRODUCTNAME/$variableshashref->{'DICTIONARYUNIXPRODUCTNAME'}/g; }
 460         if (exists($variableshashref->{'DICTIONARYBRANDPACKAGEVERSION'}) ) { $$packagenameref =~ s/\%BRANDPACKAGEVERSION/$variableshashref->{'DICTIONARYBRANDPACKAGEVERSION'}/g; }
 461     }
 462
 463     foreach $key (keys %{$variableshashref})
 464     {
 465         my $value = $variableshashref->{$key};
 466         if ( $make_lowercase ) { $value = lc($value); }
 467         $$packagenameref =~ s/\%$key/$value/g;
 468     }
 469 }
 470
 471 #####################################################################
 472 # Resolving all variables in the packagename.
 473 #####################################################################
 474
 475 sub resolve_packagevariables2
 476 {
 477     my ($packagenameref, $variableshashref, $make_lowercase, $isdict ) = @_;
 478
 479     my $key;
 480
 481     # Special handling for dictionaries
 482     if ( $isdict )
 483     {
 484         if (exists($variableshashref->{'DICTIONARYUNIXPRODUCTNAME'}) ) { $$packagenameref =~ s/\%UNIXPRODUCTNAME/$variableshashref->{'DICTIONARYUNIXPRODUCTNAME'}/g; }
 485         if (exists($variableshashref->{'DICTIONARYBRANDPACKAGEVERSION'}) ) { $$packagenameref =~ s/\%BRANDPACKAGEVERSION/$variableshashref->{'DICTIONARYBRANDPACKAGEVERSION'}/g; }
 486     }
 487
 488     foreach $key (keys %{$variableshashref})
 489     {
 490         my $value = $variableshashref->{$key};
 491         if ( $make_lowercase ) { $value = lc($value); }
 492         $$packagenameref =~ s/\%$key/$value/g;
 493     }
 494 }
 495
 496 #####################################################################
 497 # New packages system.
 498 #####################################################################
 499
 500 ##################################################################
 501 # Controlling the content of the packagelist
 502 # 1. Items in @installer::globals::packagelistitems must exist
 503 # 2. If a shellscript file is defined, it must exist
 504 ##################################################################
 505
 506 sub check_packagelist
 507 {
 508     my ($packages) = @_;
 509
 510     if ( ! ( $#{$packages} > -1 )) { installer::exiter::exit_program("ERROR: No packages defined!", "check_packagelist"); }
 511
 512     for ( my $i = 0; $i <= $#{$packages}; $i++ )
 513     {
 514         my $onepackage = ${$packages}[$i];
 515
 516         my $element;
 517
 518         # checking all items that must be defined
 519
 520         foreach $element (@installer::globals::packagelistitems)
 521         {
 522             if ( ! exists($onepackage->{$element}) )
 523             {
 524                 installer::exiter::exit_program("ERROR in package list: No value for $element !", "check_packagelist");
 525             }
 526         }
 527
 528         # checking the existence of the script file, if defined
 529
 530         if ( $onepackage->{'script'} )
 531         {
 532             my $scriptfile = $onepackage->{'script'};
 533             my $gid =  $onepackage->{'module'};
 534             my $fileref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$scriptfile, "" , 0);
 535
 536             if ( $$fileref eq "" ) { installer::exiter::exit_program("ERROR: Could not find script file $scriptfile for module $gid!", "check_packagelist"); }
 537
 538             my $infoline = "$gid: Using script file: \"$$fileref\"!\n";
 539             push( @installer::globals::logfileinfo, $infoline);
 540
 541             $onepackage->{'script'} = $$fileref;
 542         }
 543     }
 544 }
 545
 546 #####################################################################
 547 # Reading pack info for one module from packinfo file.
 548 #####################################################################
 549
 550 sub get_packinfo
 551 {
 552     my ($gid, $filename, $packages, $onelanguage, $islanguagemodule) = @_;
 553
 554     my $packagelist     = installer::files::read_file($filename);
 555
 556     my @allpackages = ();
 557
 558     for ( my $i = 0; $i <= $#{$packagelist}; $i++ )
 559     {
 560         my $line = ${$packagelist}[$i];
 561
 562         if ( $line =~ /^\s*\#/ ) { next; }      # this is a comment line
 563
 564         if ( $line =~ /^\s*Start\s*$/i )        # a new package definition
 565         {
 566             my %onepackage = ();
 567
 568             my $counter = $i + 1;
 569
 570             while (!( ${$packagelist}[$counter] =~ /^\s*End\s*$/i ))
 571             {
 572                 if ( ${$packagelist}[$counter] =~ /^\s*(\S+)\s*\=\s*\"(.*)\"/ )
 573                 {
 574                     my $key = $1;
 575                     my $value = $2;
 576                     $onepackage{$key} = $value;
 577                 }
 578
 579                 $counter++;
 580             }
 581
 582             $onepackage{'islanguagemodule'} = $islanguagemodule;
 583             if ( $islanguagemodule )
 584             {
 585                 $saveonelanguage = $onelanguage;
 586                 $saveonelanguage =~ s/_/-/g;
 587                 $onepackage{'language'} = $saveonelanguage;
 588             }
 589
 590             push(@allpackages, \%onepackage);
 591         }
 592     }
 593
 594     # looking for the packinfo with the correct gid
 595
 596     my $foundgid = 0;
 597     my $onepackage;
 598     foreach $onepackage (@allpackages)
 599     {
 600         # Adding the language to the module gid for LanguagePacks !
 601         # Making the module gid language specific: gid_Module_Root -> gir_Module_Root_pt_BR (as defined in scp2)
 602         if ( $onelanguage ne "" ) { $onepackage->{'module'} = $onepackage->{'module'} . "_$onelanguage"; }
 603
 604         if ( $onepackage->{'module'} eq $gid )
 605         {
 606             # Resolving the language identifier
 607             my $onekey;
 608             foreach $onekey ( keys %{$onepackage} )
 609             {
 610                 # Some keys require "-" instead of "_" for example in "en-US". All package names do not use underlines.
 611                 my $locallang = $onelanguage;
 612                 if (( $onekey eq "solarispackagename" ) ||
 613                    ( $onekey eq "solarisrequires" ) ||
 614                    ( $onekey eq "packagename" ) ||
 615                    ( $onekey eq "requires" )) { $locallang =~ s/_/-/g; } # avoiding illegal package abbreviation
 616                 $onepackage->{$onekey} =~ s/\%LANGUAGESTRING/$locallang/g;
 617             }
 618
 619             # Saving the language for the package
 620             my $lang = $onelanguage;
 621             $lang =~ s/_/-/g;
 622             $onepackage->{'specificlanguage'} = $lang;
 623
 624             push(@{$packages}, $onepackage);
 625             $foundgid = 1;
 626             last;
 627         }
 628     }
 629
 630     if ( ! $foundgid )
 631     {
 632         installer::exiter::exit_program("ERROR: Could not find package info for module $gid in file \"$filename\"!", "get_packinfo");
 633     }
 634 }
 635
 636 #####################################################################
 637 # Collecting all packages from scp project.
 638 #####################################################################
 639
 640 sub collectpackages
 641 {
 642     my ( $allmodules, $languagesarrayref ) = @_;
 643
 644     installer::logger::include_header_into_logfile("Collecting packages:");
 645
 646     my @packages = ();
 647     my %gid_analyzed = ();
 648
 649     my $onemodule;
 650     foreach $onemodule ( @{$allmodules} )
 651     {
 652         my $packageinfo = "PackageInfo";
 653         if (( $installer::globals::tab ) && ( $onemodule->{"TabPackageInfo"} )) { $packageinfo = "TabPackageInfo" }
 654
 655         if ( $onemodule->{$packageinfo} )       # this is a package module!
 656         {
 657             my $modulegid = $onemodule->{'gid'};
 658
 659             # Only collecting modules with correct language for language packs
 660 #                       if ( $installer::globals::languagepack ) { if ( ! ( $modulegid =~ /_$onelanguage\s*$/ )) { next; } }
 661             # Resetting language, if this is no language pack
 662 #                       if ( ! $installer::globals::languagepack ) { $onelanguage = ""; }
 663
 664             my $styles = "";
 665             if ( $onemodule->{'Styles'} ) { $styles = $onemodule->{'Styles'}; }
 666
 667             # checking modules with style LANGUAGEMODULE
 668             my $islanguagemodule = 0;
 669             my $onelanguage = "";
 670             if ( $styles =~ /\bLANGUAGEMODULE\b/ )
 671             {
 672                 $islanguagemodule = 1;
 673                 $onelanguage = $onemodule->{'Language'}; # already checked, that it is set.
 674                 $onelanguage =~ s/-/_/g; # pt-BR -> pt_BR in scp
 675             }
 676
 677             # Modules in different languages are listed more than once in multilingual installation sets
 678             if ( exists($gid_analyzed{$modulegid}) ) { next; }
 679             $gid_analyzed{$modulegid} = 1;
 680
 681             my $packinfofile = $onemodule->{$packageinfo};
 682
 683             # The file with package information has to be found in path list
 684             my $fileref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$packinfofile, "" , 0);
 685
 686             if ( $$fileref eq "" ) { installer::exiter::exit_program("ERROR: Could not find file $packinfofile for module $modulegid!", "collectpackages"); }
 687
 688             my $infoline = "$modulegid: Using packinfo: \"$$fileref\"!\n";
 689             push( @installer::globals::logfileinfo, $infoline);
 690
 691             get_packinfo($modulegid, $$fileref, \@packages, $onelanguage, $islanguagemodule);
 692         }
 693     }
 694
 695     return \@packages;
 696 }
 697
 698 #####################################################################
 699 # Printing packages content for debugging purposes
 700 #####################################################################
 701
 702 sub log_packages_content
 703 {
 704     my ($packages) = @_;
 705
 706     if ( ! ( $#{$packages} > -1 )) { installer::exiter::exit_program("ERROR: No packages defined!", "print_content"); }
 707
 708     installer::logger::include_header_into_logfile("Logging packages content:");
 709
 710     my $infoline = "";
 711
 712     for ( my $i = 0; $i <= $#{$packages}; $i++ )
 713     {
 714         my $onepackage = ${$packages}[$i];
 715
 716         # checking all items that must be defined
 717
 718         $infoline = "Package $onepackage->{'module'}\n";
 719         push(@installer::globals::logfileinfo, $infoline);
 720
 721         my $key;
 722         foreach $key (sort keys %{$onepackage})
 723         {
 724             if ( $key =~ /^\s*\;/ ) { next; }
 725
 726             if ( $key eq "allmodules" )
 727             {
 728                 $infoline = "\t$key:\n";
 729                 push(@installer::globals::logfileinfo, $infoline);
 730                 my $onemodule;
 731                 foreach $onemodule ( @{$onepackage->{$key}} )
 732                 {
 733                     $infoline = "\t\t$onemodule\n";
 734                     push(@installer::globals::logfileinfo, $infoline);
 735                 }
 736             }
 737             else
 738             {
 739                 $infoline = "\t$key: $onepackage->{$key}\n";
 740                 push(@installer::globals::logfileinfo, $infoline);
 741             }
 742         }
 743
 744         $infoline = "\n";
 745         push(@installer::globals::logfileinfo, $infoline);
 746
 747     }
 748 }
 749
 750 #####################################################################
 751 # Creating assignments from modules to destination pathes.
 752 # This is required for logging in fileinfo file. Otherwise
 753 # the complete destination file would not be known in file list.
 754 # Saved in %installer::globals::moduledestination
 755 #####################################################################
 756
 757 sub create_module_destination_hash
 758 {
 759     my ($packages, $allvariables) = @_;
 760
 761     for ( my $i = 0; $i <= $#{$packages}; $i++ )
 762     {
 763         my $onepackage = ${$packages}[$i];
 764
 765         my $defaultdestination = $onepackage->{'destpath'};
 766         resolve_packagevariables(\$defaultdestination, $allvariables, 1);
 767         if ( $^O =~ /darwin/i ) { $defaultdestination =~ s/\/opt\//\/Applications\//; }
 768
 769         foreach my $onemodule ( @{$onepackage->{'allmodules'}} )
 770         {
 771             $installer::globals::moduledestination{$onemodule} = $defaultdestination;
 772         }
 773     }
 774 }
 775
 776 #####################################################################
 777 # Adding the default pathes into the files collector for Unixes.
 778 # This is necessary to know the complete destination path in
 779 # fileinfo log file.
 780 #####################################################################
 781
 782 sub add_defaultpathes_into_filescollector
 783 {
 784     my ($allfiles) = @_;
 785
 786     for ( my $i = 0; $i <= $#{$allfiles}; $i++ )
 787     {
 788         my $onefile = ${$allfiles}[$i];
 789
 790         if ( ! $onefile->{'destination'} ) { installer::exiter::exit_program("ERROR: No destination found at file $onefile->{'gid'}!", "add_defaultpathes_into_filescollector"); }
 791         my $destination = $onefile->{'destination'};
 792
 793         if ( ! $onefile->{'modules'} ) { installer::exiter::exit_program("ERROR: No modules found at file $onefile->{'gid'}!", "add_defaultpathes_into_filescollector"); }
 794         my $module = $onefile->{'modules'};
 795         # If modules contains a list of modules, only taking the first one.
 796         if ( $module =~ /^\s*(.*?)\,/ ) { $module = $1; }
 797
 798         if ( ! exists($installer::globals::moduledestination{$module}) ) { installer::exiter::exit_program("ERROR: No default destination path found for module $module!", "add_defaultpathes_into_filescollector"); }
 799         my $defaultpath = $installer::globals::moduledestination{$module};
 800         $defaultpath =~ s/\/\s*$//; # removing ending slashes
 801         my $fulldestpath = $defaultpath . $installer::globals::separator . $destination;
 802
 803         $onefile->{'fulldestpath'} = $fulldestpath;
 804     }
 805 }
 806
 807 #####################################################################
 808 # Creating list of cabinet files from packages
 809 #####################################################################
 810
 811 sub prepare_cabinet_files
 812 {
 813     my ($packages, $allvariables) = @_;
 814
 815     if ( ! ( $#{$packages} > -1 )) { installer::exiter::exit_program("ERROR: No packages defined!", "print_content"); }
 816
 817     installer::logger::include_header_into_logfile("Preparing cabinet files:");
 818
 819     my $infoline = "";
 820
 821     for ( my $i = 0; $i <= $#{$packages}; $i++ )
 822     {
 823         my $onepackage = ${$packages}[$i];
 824
 825         my $cabinetfile = "$onepackage->{'packagename'}\.cab";
 826
 827         resolve_packagevariables(\$cabinetfile, $allvariables, 0);
 828
 829         $installer::globals::allcabinets{$cabinetfile} = 1;
 830
 831         # checking all items that must be defined
 832
 833         $infoline = "Package $onepackage->{'module'}\n";
 834         push(@installer::globals::logfileinfo, $infoline);
 835
 836         # Assigning the cab file to the module and also to all corresponding sub modules
 837
 838         my $onemodule;
 839         foreach $onemodule ( @{$onepackage->{'allmodules'}} )
 840         {
 841             if ( ! exists($installer::globals::allcabinetassigns{$onemodule}) )
 842             {
 843                 $installer::globals::allcabinetassigns{$onemodule} = $cabinetfile;
 844             }
 845             else
 846             {
 847                 my $infoline = "Warning: Already existing assignment: $onemodule : $installer::globals::allcabinetassigns{$onemodule}\n";
 848                 push(@installer::globals::logfileinfo, $infoline);
 849                 $infoline = "Ignoring further assignment: $onemodule : $cabinetfile\n";
 850                 push(@installer::globals::logfileinfo, $infoline);
 851             }
 852         }
 853     }
 854 }
 855
 856 #####################################################################
 857 # Logging assignments of cabinet files
 858 #####################################################################
 859
 860 sub log_cabinet_assignments
 861 {
 862     installer::logger::include_header_into_logfile("Logging cabinet files:");
 863
 864     my $infoline = "List of cabinet files:\n";
 865     push(@installer::globals::logfileinfo, $infoline);
 866
 867     my $key;
 868     foreach $key ( sort keys %installer::globals::allcabinets ) { push(@installer::globals::logfileinfo, "\t$key\n"); }
 869
 870     $infoline = "\nList of assignments from modules to cabinet files:\n";
 871     push(@installer::globals::logfileinfo, $infoline);
 872
 873     foreach $key ( sort keys %installer::globals::allcabinetassigns ) { push(@installer::globals::logfileinfo, "\t$key : $installer::globals::allcabinetassigns{$key}\n"); }
 874 }
 875
 876 1;