solenv/bin/modules/installer/packagelist.pm

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