source: devel/pb-modules/lib/ProjectBuilder/Distribution.pm

Last change on this file was 2511, checked in by Bruno Cornec, 8 weeks ago

Fix pbgetparam and pb_distro_conf_print by relacing key value checking

File size: 33.0 KB
Line 
1#!/usr/bin/perl -w
2#
3# Creates common environment for distributions
4#
5# Copyright B. Cornec 2007-today
6# Eric Anderson's changes are (c) Copyright 2012 Hewlett Packard
7# Provided under the GPL v2
8#
9# $Id$
10#
11
12package ProjectBuilder::Distribution;
13
14use strict;
15use Data::Dumper;
16use Carp qw/cluck confess/;
17use ProjectBuilder::Version;
18use ProjectBuilder::Base;
19use ProjectBuilder::Conf;
20use File::Basename;
21use File::Copy;
22# requires perl 5.004 minimum in VM/VE
23use File::Compare;
24
25# Global vars
26# Inherit from the "Exporter" module which handles exporting functions.
27 
28use vars qw(@ISA @EXPORT);
29use Exporter;
30 
31# Export, by default, all the functions into the namespace of
32# any code which uses this module.
33 
34our @ISA = qw(Exporter);
35our @EXPORT = qw(pb_distro_init pb_distro_conffile pb_distro_sysconffile pb_distro_api pb_distro_get pb_distro_get_if pb_distro_getlsb pb_distro_installdeps pb_distro_installpkgs pb_distro_getdeps pb_distro_only_deps_needed pb_distro_setuprepo pb_distro_setuposrepo pb_distro_setuprepo_gen pb_distro_get_context pb_distro_to_keylist pb_distro_conf_print pb_apply_conf_proxy);
36our ($VERSION,$REVISION,$PBCONFVER) = pb_version_init();
37
38=pod
39
40=head1 NAME
41
42ProjectBuilder::Distribution, part of the project-builder.org - module dealing with distribution detection
43
44=head1 DESCRIPTION
45
46This modules provides functions to allow detection of Linux distributions, and giving back some attributes concerning them.
47
48=head1 SYNOPSIS
49
50  use ProjectBuilder::Distribution;
51
52  #
53  # Return information on the running distro
54  #
55  my $pbos = pb_distro_get_context();
56  print "distro tuple: ".Dumper($pbos->name, $pbos->ver, $pbos->fam, $pbos->type, $pbos->pbsuf, $pbos->pbupd, $pbos->pbins, $pbos->arch)."\n";
57  #
58  # Return information on the requested distro
59  #
60  my $pbos = pb_distro_get_context("ubuntu-7.10-x86_64");
61  print "distro tuple: ".Dumper($pbos->name, $pbos->ver, $pbos->fam, $pbos->type, $pbos->pbsuf, $pbos->pbupd, $pbos->pbins, $pbos->arch)."\n";
62  #
63  # Return information on the running distro
64  #
65  my ($ddir,$dver) = pb_distro_guess();
66
67=head1 USAGE
68
69=over 4
70
71=item B<pb_distro_api>
72
73This function returns the mandatory configuration file used for api
74
75=cut
76
77sub pb_distro_api {
78
79return("CCCC/api.yml");
80}
81
82
83=item B<pb_distro_conffile>
84
85This function returns the mandatory configuration file used for distribution/OS detection
86
87=cut
88
89sub pb_distro_conffile {
90
91if ($PBCONFVER < 1) {
92    return("CCCC/pb.conf");
93} else {
94    return("CCCC/pb.yml");
95}
96}
97
98=item B<pb_distro_sysconffile>
99
100This function returns the optional configuration file used for local customization
101
102=cut
103
104sub pb_distro_sysconffile {
105
106if ($PBCONFVER < 1) {
107    return("SSSS/pb.conf");
108} else {
109    return("SSSS/pb.yml");
110}
111}
112
113
114=item B<pb_distro_init>
115
116This function returns a hash of parameters indicating the distribution name, version, family, type of build system, suffix of packages, update command line, installation command line and architecture of the underlying Linux distribution. The value of the fields may be "unknown" in case the function was unable to recognize on which distribution it is running.
117
118As an example, Ubuntu and Debian are in the same "du" family. As well as RedHat, RHEL, CentOS, fedora are on the same "rh" family.
119Mandriva, Open SuSE and Fedora have all the same "rpm" type of build system. Ubuntu and Debian have the same "deb" type of build system.
120And "fc" is the extension generated for all Fedora packages (Version will be added by pb).
121All this information is stored in an external configuration file typically at /etc/pb/pb.yml
122
123When passing the distribution name and version as parameters, the B<pb_distro_init> function returns the parameter of that distribution instead of the underlying one.
124
125Cf: http://linuxmafia.com/faq/Admin/release-files.html
126Ideas taken from http://search.cpan.org/~kerberus/Linux-Distribution-0.14/lib/Linux/Distribution.pm
127
128=cut
129
130
131sub pb_distro_init {
132
133my $pbos = {
134    'name' => undef,
135    'version' => undef,
136    'arch' => undef,
137    'family' => "unknown",
138    'suffix' => "unknown",
139    'update' => "unknown",
140    'install' => "unknown",
141    'type' => "unknown",
142    'os' => "unknown",
143    'nover' => "false",
144    'rmdot' => "false",
145    'useminor' => "false",
146    };
147$pbos->{'name'} = shift;
148$pbos->{'version'} = shift;
149$pbos->{'arch'} = shift;
150
151# Adds conf file for distribution description
152# the location of the conf file is finalyzed at install time
153# depending whether we deal with package install or tar file install
154
155pb_conf_add(pb_distro_sysconffile());
156
157# Similarly for the local file available for sysadmin. After the previous one to allow overwrite to work
158pb_conf_add(pb_distro_conffile());
159
160# If we don't know which distribution we're on, then guess it
161($pbos->{'name'},$pbos->{'version'}) = pb_distro_guess() if ((not defined $pbos->{'name'}) || (not defined $pbos->{'version'}));
162
163# For some rare cases, typically nover ones
164$pbos->{'name'} = "unknown" if (not defined $pbos->{'name'});
165$pbos->{'version'} = "unknown" if (not defined $pbos->{'version'});
166
167# Initialize arch
168$pbos->{'arch'} = pb_get_arch() if (not defined $pbos->{'arch'});
169# Solves a bug on Red Hat 6.x where real arch is not detected when using setarch and a chroot
170# As it was only i386 forcing it here.
171$pbos->{'arch'} = "i386" if (($pbos->{'name'} eq "redhat") && ($pbos->{'version'} =~ /^6\./));
172
173# Dig into the tuple to find the best answer
174# Do NOT factorize here, as it won't work as of now for hash creation
175# Do NOT change order without caution
176$pbos->{'useminor'} = pb_distro_get($pbos,"osuseminorrel");
177$pbos->{'family'} = pb_distro_get($pbos,"osfamily");
178$pbos->{'type'} = pb_distro_get($pbos,"ostype");
179($pbos->{'os'},$pbos->{'install'},$pbos->{'update'}) = pb_distro_get($pbos,("os","osins","osupd"));
180($pbos->{'localinstall'},$pbos->{'nover'},$pbos->{'rmdot'},$pbos->{'suffix'}) = pb_distro_get_if($pbos,"oslocalins","osnover","osremovedotinver","ossuffix");
181
182# Some OS have no interesting version
183$pbos->{'version'} = "nover" if ((defined $pbos->{'nover'}) && ($pbos->{'nover'} eq "true"));
184
185# For some OS remove the . in version name for extension
186my $dver2 = $pbos->{'version'};
187$dver2 =~ s/\.//g if ((defined $pbos->{'rmdot'}) && ($pbos->{'rmdot'} eq "true"));
188
189if ((not defined $pbos->{'suffix'}) || ($pbos->{'suffix'} eq "")) {
190    # By default suffix is a concatenation of name and version
191    $pbos->{'suffix'} = ".$pbos->{'name'}$dver2" 
192} else {
193    # concat just the version to what has been found
194    $pbos->{'suffix'} = ".$pbos->{'suffix'}$dver2";
195}
196
197#   if ($arch eq "x86_64") {
198#   $opt="--exclude=*.i?86";
199#   }
200pb_log(2,"DEBUG: pb_distro_init: ".Dumper($pbos)."\n");
201
202return($pbos);
203}
204
205=item B<pb_distro_guess>
206
207This function returns a list of 2 parameters indicating the distribution name and version of the underlying Linux distribution. The value of those 2 fields may be "unknown" in case the function was unable to recognize on which distribution it is running.
208
209On my home machine it would currently report ("mandriva","2010.2").
210
211=cut
212
213sub pb_distro_guess {
214
215# 1: List of files that unambiguously indicates what distro we have
216# 2: List of files that ambiguously indicates what distro we have
217# 3: Should have the same keys as the previous one. If ambiguity, which other distributions should be checked
218# 4: Matching Rg. Expr to detect distribution and version
219my ($single_rel_files, $ambiguous_rel_files,$distro_similar,$distro_match,$nover) = pb_conf_get("osrelfile","osrelambfile","osambiguous","osrelexpr","osnover");
220
221my $release;
222my $distro;
223
224# Begin to test presence of non-ambiguous files
225# that way we reduce the choice
226my ($d,$r);
227while (($d,$r) = each %$single_rel_files) {
228    if (defined $ambiguous_rel_files->{$d}) {
229        print STDERR "The key $d is considered as both unambiguous and ambiguous.\n";
230        confess "Please fix your configuration file.\n"
231    }
232    if (-f "$r" && ! -l "$r") {
233        my $tmp=pb_get_content("$r");
234        # Found the only possibility.
235        # Try to get version and return
236        if (defined ($distro_match->{$d})) {
237            ($release) = $tmp =~ m/$distro_match->{$d}/m;
238        } else {
239            if (not defined ($nover->{$d})) {
240                print STDERR "Unable to find $d version in $r (non-ambiguous)\n";
241                confess "Please report to the maintainer bruno_at_project-builder.org\n";
242            }
243            $release = "unknown";
244        }
245        return($d,$release);
246    }
247}
248
249# Now look at ambiguous files
250# Ubuntu before 10.04 includes a /etc/debian_version file that creates an ambiguity with debian
251# So we need to look at distros in reverse alphabetic order to treat ubuntu always first via lsb
252my $found = 0;
253foreach $d (reverse keys %$ambiguous_rel_files) {
254    $r = $ambiguous_rel_files->{$d};
255    if (-f "$r" && !-l "$r") {
256        # Found one possibility.
257        # Get all distros concerned by that file
258        my $tmp = pb_get_content("$r");
259        my $ptr = $distro_similar->{$d};
260        pb_log(2,"amb: ".Dumper($ptr)."\n");
261        $release = "unknown";
262        foreach my $dd (split(/,/,$ptr)) {
263            pb_log(2,"check $dd\n");
264            # Try to check pattern
265            if (defined $distro_match->{$dd}) {
266                pb_log(2,"cmp: $distro_match->{$dd} - vs - $tmp\n");
267                ($release) = $tmp =~ m/$distro_match->{$dd}/m;
268                if ((defined $release) && ($release ne "unknown")) {
269                    $distro = $dd;
270                    $found = 1;
271                    last;
272                }
273            }
274        }
275        last if ($found == 1);
276    }
277}
278if ($found == 0) {
279    #
280    # Now look at the os-release file to see if we have a std distribution description
281    #
282    foreach my $r ("/usr/lib/os-release","/etc/os-release") {
283        if (-r $r) {
284            my $tmp = pb_get_content("$r");
285            ($release) = $tmp =~ m/.*\nVERSION_ID=[\"\']*([0-9a-z\._-]+)[\"\']*\n/m;
286            ($distro) = $tmp =~ m/.*\nID=[\"\']*([0-9A-z\._-]+)[\"\']*\n/m;
287            # Remove the leap suffix if present (OpenSUSE)
288            $distro =~ s/-leap//;
289            if ((defined $release) && (defined $distro)) {
290                $found = 1;
291                last;
292            }
293        }
294    }
295}
296if ($found == 0) {
297    print STDERR "Unable to find a version in ".join(' ',keys %$ambiguous_rel_files)." (ambiguous)\n";
298    confess "Please report to the maintainer bruno_at_project-builder.org\n";
299} else {
300    return($distro,$release);
301}
302}
303
304=item B<pb_distro_getlsb>
305
306This function returns the 5 lsb values LSB version, distribution ID, Description, release and codename.
307As entry it takes an optional parameter to specify whether the output is short or not.
308
309=cut
310
311sub pb_distro_getlsb {
312
313my $s = shift;
314pb_log(3,"Entering pb_distro_getlsb\n");
315
316my ($ambiguous_rel_files) = pb_conf_get("osrelambfile");
317my $lsbf = $ambiguous_rel_files->{"lsb"};
318
319# LSB has not been configured.
320if (not defined $lsbf) {
321    print STDERR "no lsb entry defined for osrelambfile\n";
322    confess "You modified upstream delivery and lost !\n";
323}
324
325if (-r $lsbf) {
326    my $rep = pb_get_content($lsbf);
327    # Create elementary fields
328    my ($c, $r, $d, $i, $l) = ("", "", "", "", "");
329    for my $f (split(/\n/,$rep)) {
330        pb_log(3,"Reading file part ***$f***\n");
331        $c = $f if ($f =~ /^DISTRIB_CODENAME/);
332        $c =~ s/DISTRIB_CODENAME=/Codename:\t/;
333        $r = $f if ($f =~ /^DISTRIB_RELEASE/);
334        $r =~ s/DISTRIB_RELEASE=/Release:\t/;
335        $d = $f if ($f =~ /^DISTRIB_DESCRIPTION/);
336        $d =~ s/DISTRIB_DESCRIPTION=/Description:\t/;
337        $d =~ s/"//g;
338        $i = $f if ($f =~ /^DISTRIB_ID/);
339        $i =~ s/DISTRIB_ID=/Distributor ID:\t/;
340        $l = $f if ($f =~ /^LSB_VERSION/);
341        $l =~ s/LSB_VERSION=/LSB Version:\t/;
342    }
343    my $regexp = "^[A-z ]*:[\t ]*";
344    $c =~ s/$regexp// if (defined $s);
345    $r =~ s/$regexp// if (defined $s);
346    $d =~ s/$regexp// if (defined $s);
347    $i =~ s/$regexp// if (defined $s);
348    $l =~ s/$regexp// if (defined $s);
349    return($l, $i, $d, $r, $c);
350} else {
351    print STDERR "Unable to read $lsbf file\n";
352    confess "Please report to the maintainer bruno_at_project-builder.org\n";
353}
354}
355
356# Internal function
357
358sub pb_apply_conf_proxy {
359my ($pbos) = @_;
360
361my $ftp_proxy = pb_distro_get_if($pbos,"ftp_proxy");
362my $http_proxy = pb_distro_get_if($pbos,"http_proxy");
363my $https_proxy = pb_distro_get_if($pbos,"https_proxy");
364
365# We do not overwrite shell settings
366$ENV{'ftp_proxy'} ||= $ftp_proxy if ((defined $ftp_proxy) && ($ftp_proxy ne ""));
367$ENV{'http_proxy'} ||= $http_proxy if ((defined $http_proxy) && ($http_proxy ne ""));
368$ENV{'https_proxy'} ||= $https_proxy if ((defined $https_proxy) && ($https_proxy ne ""));
369}
370
371=item B<pb_distro_installpkgs>
372
373This function install the packages passed as parameters on a distribution.
374
375=cut
376
377sub pb_distro_installpkgs {
378
379my $pbos = shift;
380my $pkgs = shift;    # list of pkgs to install
381my $local = shift;   # optional should we install local packages or remote (for deb command is different)
382
383# Protection
384confess "Missing install command for $pbos->{name}-$pbos->{version}-$pbos->{arch}" unless (defined $pbos->{install} && $pbos->{install} =~ /\w/);
385pb_apply_conf_proxy($pbos);
386pb_log(1, "ftp_proxy=$ENV{'ftp_proxy'}\n") if (defined $ENV{'ftp_proxy'});
387pb_log(1, "http_proxy=$ENV{'http_proxy'}\n")  if (defined $ENV{'http_proxy'});
388pb_log(1, "https_proxy=$ENV{'https_proxy'}\n")  if (defined $ENV{'https_proxy'});
389
390# This may not be // proof. We should test for availability of repo and sleep if not
391my $cmd = "$pbos->{'install'} $pkgs";
392$cmd = "$pbos->{'localinstall'} $pkgs" if ((defined $local) && (defined $pbos->{'localinstall'}) && ($pbos->{'localinstall'} !~ /[ ]*/));
393my $ret = pb_system($cmd, "Installing packages ($cmd)","mayfail");
394# Try to accomodate deficient proxies
395if ($ret != 0) {
396    $ret = pb_system($cmd, "Re-trying installing packages ($cmd)");
397}
398confess "Some packages did not install" if (($ret != 0) && ($Global::pb_stop_on_error));
399}
400
401
402=item B<pb_distro_installdeps>
403
404This function install the dependencies required to build the package on a distro.
405If $forcerepo is defined then do not assume packages are alredy installed, but reinstall them
406(useful if you add a repo which contains more up to date packages that you need)
407Dependencies can be passed as the 4th parameter in which case they are not computed
408
409=cut
410
411sub pb_distro_installdeps {
412
413# SPEC file
414my $f = shift;
415my $pbos = shift;
416my $forcerepo = shift;
417my $deps = shift;   # optional list of deps to install
418my $local = shift;   # optional should we install local packages or remote (for deb command is different)
419my $deps2;
420
421if (not defined $deps) {
422    $deps = pb_distro_getdeps($f,$pbos, $forcerepo);
423}
424pb_log(2,"DEBUG: Packages to install: $deps\n") if (defined $deps);
425return if ((not defined $deps) || ($deps =~ /^\s*$/));
426
427pb_distro_installpkgs($pbos,$deps,$local);
428# Check that all deps have been installed correctly
429# This time we don't forcerepo to avoid getting a list as a return as we have
430# already forced it previously, and this time we just want to check
431$deps = pb_distro_getdeps($f, $pbos, undef);
432confess "Some dependencies did not install ($deps)" if ((defined $deps) && ($deps =~ /\S/) && ($Global::pb_stop_on_error));
433}
434
435=item B<pb_distro_getdeps>
436
437This function computes the dependencies indicated in the build file and return them as a string of packages to install
438
439=cut
440
441sub pb_distro_getdeps {
442
443my $f = shift;
444my $pbos = shift;
445my $forcerepo = shift;
446
447my $regexp = "";
448my $deps = "";
449my $sep = $/;
450
451# Protection
452return("") if (not defined $pbos->{'type'});
453return("") if (not defined $f);
454
455pb_log(3,"entering pb_distro_getdeps: $pbos->{'type'} - $f\n");
456if ($pbos->{'type'} eq  "rpm") {
457    # In RPM this could include files, but we do not handle them atm.
458    $regexp = '^BuildRequires:(.*)$';
459} elsif ($pbos->{'type'} eq "deb") {
460    $regexp = '^Build-Depends:(.*)$';
461} elsif ($pbos->{'type'} eq "apk") {
462    $regexp = '^makedepends=(.*)$';
463} elsif ($pbos->{'type'} eq "ebuild") {
464    $sep = '"'.$/;
465    $regexp = '^DEPEND="(.*)"\n';
466} else {
467    # No idea
468    return("");
469}
470pb_log(2,"regexp: $regexp\n");
471
472# Preserve separator before using the one we need
473my $oldsep = $/;
474$/ = $sep;
475open(DESC,"$f") || (cluck "Unable to open $f" && return(""));
476while (<DESC>) {
477    pb_log(4,"read: $_\n");
478    next if (! /$regexp/);
479    chomp();
480
481    my $nextline;
482    # Support multi-lines deps for .deb
483    if ($pbos->{type} eq 'deb') {
484        while ($nextline = <DESC>) {
485            last unless $nextline =~ /^\s+(.+)$/o;
486            $_ .= $1;
487        }
488    }
489
490    # What we found with the regexp is the list of deps.
491    pb_log(2,"found deps: $_\n");
492    s/$regexp/$1/i;
493    pb_log(4,"found deps 1: $_\n");
494    # Remove conditions in the middle and at the end for deb
495    s/\([><=]+[^,]*,/,/g;
496    pb_log(4,"found deps 2: $_\n");
497    s/\([><=]+[^,]*$//g;
498    pb_log(4,"found deps 3: $_\n");
499    # Same for rpm
500    s/[><=]+[^,]*,/,/g;
501    pb_log(4,"found deps 4: $_\n");
502    s/[><=]+.*$//g;
503    pb_log(4,"found deps 5: $_\n");
504    # Improve string format (remove , and spaces at start, end and in double
505    s/,/ /g;
506    pb_log(4,"found deps 6: $_\n");
507    s/^\s*//;
508    pb_log(4,"found deps 7: $_\n");
509    # $ here removes the \n
510    s/\s*$//;
511    pb_log(4,"found deps 8: $_\n");
512    s/\s+/ /g;
513    pb_log(4,"found deps 9: $_\n");
514    $deps .= " ".$_;
515    pb_log(4,"found deps end: $deps\n");
516
517    # Support multi-lines deps for .deb (fwup)
518    if (defined $nextline) {
519        $_ = $nextline;
520        redo;
521    }
522}
523close(DESC);
524$/ = $oldsep;
525pb_log(2,"now deps: $deps\n");
526if (defined $forcerepo) {
527    # We want to force installation of all pkgs
528    # because a repo was setup in between, which may contains updated versions
529    pb_log(0,"Forcing installation of all packages due to previous repo setup\n");
530    return($deps);
531} else {
532    pb_log(0,"Installation of only necessary packages\n");
533    my $deps2 = pb_distro_only_deps_needed($pbos,$deps);
534    return($deps2);
535}
536}
537
538
539=item B<pb_distro_only_deps_needed>
540
541This function returns only the dependencies not yet installed
542
543=cut
544
545sub pb_distro_only_deps_needed {
546
547my $pbos = shift;
548my $deps = shift;
549
550return("") if ((not defined $deps) || ($deps =~ /^\s*$/));
551my $deps2 = "";
552# Avoid to install what is already there
553delete $ENV{'COLUMNS'};
554foreach my $p (split(/\s+/,$deps)) {
555    next if $p =~ /^\s*$/o;
556    if ($pbos->{'type'} eq  "rpm") {
557        my $rpmcmd = "rpm -q --whatprovides --quiet";
558        # whatprovides doesn't work for RH6.2
559        $rpmcmd = "rpm -q --quiet" if (($pbos->{'name'} eq "redhat") && ($pbos->{'version'} =~ /6/));
560        my $res = pb_system("$rpmcmd $p","Looking for $p","mayfail");
561        next if ($res eq 0);
562        pb_log(1, "INFO: missing dependency $p\n");
563    } elsif ($pbos->{'type'} eq "deb") {
564        my $res = pb_system("dpkg -L $p","Looking for $p","mayfail");
565        next if ($res eq 0);
566        open(CMD,"dpkg -l $p |") || (cluck "Unable to run dpkg -l $p: $!" && next);
567        my $ok = 0;
568        while (<CMD>) {
569            $ok = 1 if /^ii\s+$p/;
570        }
571        close(CMD);
572        next if $ok;
573        pb_log(1, "INFO: missing dependency $p\n");
574    } elsif ($pbos->{'type'} eq "ebuild") {
575    } elsif ($pbos->{'type'} eq "apk") {
576        my $res = pb_system("apk -e info $p","Looking for $p","mayfail");
577        next if ($res eq 0);
578        pb_log(1, "INFO: missing dependency $p\n");
579    } else {
580        # Not reached
581    }
582    $deps2 .= " $p";
583}
584
585$deps2 =~ s/^\s*//;
586pb_log(2,"List of missing packages: $deps2\n");
587return($deps2);
588}
589
590# Internal
591sub pb_distro_compare_repo {
592
593my $src = shift;
594my $dest = shift;
595
596if (not -f $dest) {
597    pb_log(1, "INFO: Creating new file $dest\n");
598} elsif (-f $dest && -s $dest == 0) {
599    pb_log(1, "INFO: Overwriting empty file $dest\n");
600} elsif (-f $dest && compare("$src", $dest) == 0) {
601    pb_log(1, "INFO: Overwriting identical file $dest\n");
602} else {
603    pb_log(0, "ERROR: destination file $dest exists and is different than source $src\n");
604    pb_system("cat $dest","INFO: Dest...\n","verbose");
605    pb_system("cat $src","INFO: New...\n","verbose");
606    pb_log(1, "INFO: Returning...\n");
607    return(1);
608}
609return(0);
610}
611
612
613=item B<pb_distro_setuposrepo>
614
615This function sets up potential additional repository for the setup phase
616
617=cut
618
619sub pb_distro_setuposrepo {
620
621my $pbos = shift;
622
623pb_log(3, "INFO: Adding osrepo from config file\n");
624my %h;
625my $h = \%h;
626# Adds conf file for availability of conf elements either from the local build env or from a VE/VM/RM in which the conf file has been passed
627$h = pb_conf_cache(pb_distro_conffile(),$h);
628#my $repo = pb_distro_get_param($pbos,$osrepo);
629my $repo = pb_distro_get_in_hash_if($pbos,$h,"osrepo");
630return(pb_distro_setuprepo_gen($pbos,$repo));
631}
632
633=item B<pb_distro_setuprepo>
634
635This function sets up potential additional repository to the build/install/test environment
636If done, it returns forcerepo if a repo was added, if not undef
637
638=cut
639
640sub pb_distro_setuprepo {
641
642my $pbos = shift;
643my $repotype = shift;
644
645my %h;
646my $h = \%h;
647# Adds conf file for availability of conf elements either from the local build env or from a VE/VM/RM in which the conf file has been passed
648$h = pb_conf_cache("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.yml",$h) if ((defined $ENV{'PBROOTDIR'}) && (-f "$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.yml"));
649$h = pb_conf_cache("$ENV{'PBDESTDIR'}/pbrc.yml",$h) if ((defined $ENV{'PBDESTDIR'}) && (-f "$ENV{'PBDESTDIR'}/pbrc.yml"));
650
651my $repo = pb_distro_get_in_hash_if($pbos,$h,"add".$repotype."repo");
652# If no repo then set it up as undef so the return value is correct from pb_distro_setuprepo_gen
653$repo = undef if ((defined $repo) && ($repo eq ""));
654if ($repotype =~ /install/) {
655    # Give a probable default if nothing is provided to avoid overloading conf files
656    #
657    if (not defined $repo) {
658        my ($pbrepo) = pb_conf_get_in_hash_if($h,"pbrepo");
659        if (not defined $pbrepo) {
660            cluck("No pbrepo parameter defined in your project configuration file, please fix !");
661            return(undef);
662        }
663        my $url = "$pbrepo->{$ENV{'PBPROJ'}}";
664        my ($testver,$delivery) = pb_conf_get_in_hash_if($h,"testver","delivery");
665        $delivery->{$ENV{'PBPROJ'}} = "" if (not defined $delivery->{$ENV{'PBPROJ'}});
666        $url .= "/$delivery->{$ENV{'PBPROJ'}}/";
667        my $repotag = "";
668        $repotag = "-$delivery->{$ENV{'PBPROJ'}}" if ($delivery->{$ENV{'PBPROJ'}} ne "");
669        $url .= "/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}/$ENV{PBPROJ}$repotag.";
670        my $ext = "";
671        if ($pbos->{'type'} eq "rpm") {
672            $ext = "repo";
673            if ($pbos->{'family'} eq "md") {
674                $ext = "addmedia";
675            }
676        } elsif ($pbos->{'type'} eq "deb") {
677            $ext = ".sources.list";
678        }
679        $repo = $url.$ext;
680    }
681}
682pb_log(1, "INFO: Adding $repo from config file for $repotype step\n") if (defined $repo);
683return(pb_distro_setuprepo_gen($pbos,$repo));
684}
685
686=item B<pb_distro_setuprepo_gen>
687
688This functionthe sets up in a generic way potential additional repository passed as a param
689It returns forcerepo if one was added, else undef
690
691=cut
692
693sub pb_distro_setuprepo_gen {
694
695my $pbos = shift;
696my $param = shift;
697
698return(undef) if (not defined $param);
699
700pb_apply_conf_proxy($pbos);
701
702# Loop on the list of additional repo
703foreach my $i (split(/,/,$param)) {
704
705    pb_log(1,"Adding repository defined by $i\n");
706    my ($scheme, $account, $host, $port, $path) = pb_get_uri($i);
707    my $bn = basename($i);
708
709    # The repo file can be local or remote. download or copy at the right place
710    if (($scheme eq "ftp") || ($scheme =~ /http/)) {
711        pb_system("wget -O $ENV{'PBTMP'}/$bn $i","Downloading additional repository file $i");
712    } else {
713        copy($i,"$ENV{'PBTMP'}/$bn");
714    }
715
716    # The repo file can be a real file or a package
717    if ($pbos->{'type'} eq "rpm") {
718        if ($bn =~ /\.rpm$/) {
719            my $pn = $bn;
720            $pn =~ s/\.rpm//;
721            if (pb_system("rpm -q --quiet $pn","","mayfail") != 0) {
722                pb_system("sudo rpm -Uvh $ENV{'PBTMP'}/$bn","Adding package $bn to setup repository");
723            }
724        } elsif ($bn =~ /\.repo$/) {
725            my $dirdest = "";
726            my $reponame = "";
727            # TODO: could go in pb.yml in fact
728            if ($pbos->{install} =~ /\byum\b/) {
729                $reponame="yum";
730                $dirdest = "/etc/yum.repos.d";
731            } elsif ($pbos->{install} =~ /\bdnf\b/) {
732                $reponame="dnf";
733                $dirdest = "/etc/yum.repos.d";
734            } elsif ($pbos->{install} =~ /\bzypper\b/) {
735                $reponame="zypper";
736                $dirdest = "/etc/zypp/repos.d";
737            } else {
738                cluck "Unknown location for repository file for '$pbos->{install}' command";
739                next;
740            }
741            my $dest = "$dirdest/$bn";
742            return(undef) if (pb_distro_compare_repo("$ENV{'PBTMP'}/$bn",$dest) == 1);
743            if (! -d $dirdest) {
744                cluck "Missing directory $dirdest ($reponame)";
745                return(undef);
746            }
747            pb_system("sudo mv $ENV{'PBTMP'}/$bn $dest","Adding $reponame repository") if (not -f "$dest");
748            # OpenSUSE does't seem to import keys automatically
749            # :-(
750            if ($pbos->{install} =~ /\bzypper\b/) {
751                my $keyfile = undef;
752                open(REPO,"$dest") || (cluck "Unable to open $dest" && next);
753                while (<REPO>) {
754                    $keyfile = $_;
755                    if ($keyfile =~ /^gpgkey=/) {
756                        $keyfile =~ s/gpgkey=//;
757                        last;
758                    }
759                }
760                close(REPO);
761                if (defined $keyfile) {
762                    pb_system("wget -O $ENV{'PBTMP'}/$bn $keyfile","Downloading GPG key file $keyfile");
763                    pb_system("sudo rpm --import $ENV{'PBTMP'}/$bn","Importing GPG key file $keyfile");
764                    unlink("$ENV{'PBTMP'}/$bn");
765                }
766            }
767        } elsif ($bn =~ /\.addmedia/) {
768            # URPMI repo
769            # We should test that it's not an already setup urpmi repo
770            open(URPMI,"/etc/urpmi/urpmi.cfg") || (cluck "Unable to open /etc/urpmi/urpmi.cfg" && next);
771            my $found = 0;
772            my $entry = $bn;
773            $entry =~ s/.addmedia$//;
774            while (<URPMI>) {
775                $found = 1 if ($_ =~ /^$entry /);
776            }
777            pb_system("chmod 755 $ENV{'PBTMP'}/$bn ; sudo $ENV{'PBTMP'}/$bn 2>&1 > /dev/null","Adding urpmi repository") if ($found == 0);
778            pb_log(0,"INFO urpmi $bn already set up\n") if ($found == 1);
779        } else {
780            pb_log(0,"ERROR: Unable to deal with repository file $i on rpm distro ! Please report to dev team\n");
781        }
782    } elsif ($pbos->{'type'} eq "deb") {
783        if ($bn =~ /\.sources.list$/) {
784            my $dest = "/etc/apt/sources.list.d/$bn";
785            return(undef) if (pb_distro_compare_repo("$ENV{'PBTMP'}/$bn",$dest) == 1);
786            pb_system("sudo mv $ENV{'PBTMP'}/$bn $dest","Adding apt repository $dest");
787            # Check whether GPG keys for this repo are already known and if
788            # not add them
789            open(REPO,"$dest") || (cluck "Unable to open $dest" && next);
790            my $debrepo;
791            while (<REPO>) {
792                if (/^deb\s/) {
793                    $debrepo = $_;
794                    chomp($debrepo);
795                    $debrepo =~ s|^deb ([^\s]+)\s([^\s]+)\s([^\s]+)|$1/dists/$2|;
796                    last;
797                }
798            }
799            close(REPO);
800            return(undef) if (not defined $debrepo);
801
802            pb_system("wget -O $ENV{'PBTMP'}/Release $debrepo/Release","Downloading $debrepo/Release");
803            pb_system("wget -O $ENV{'PBTMP'}/Release.gpg $debrepo/Release.gpg","Downloading $debrepo/Release.gpg");
804            my $signature = undef;
805            my ($pbgpgserver) = pb_conf_get("pbgpgserver");
806            confess "Unable to find a GPG server in configuration, please define pbgpgserver" if (not defined $pbgpgserver);
807            my $keyserver = $pbgpgserver->{$ENV{'PBPROJ'}};
808            $keyserver = $pbgpgserver->{'default'} if (not defined $keyserver);
809            confess "Unable to find a GPG server in configuration, please define correctly pbgpgserver" if (not defined $keyserver);
810            open(SIGN,"LANGUAGE=C LANG=C gpg --verify --keyid-format=long $ENV{'PBTMP'}/Release.gpg $ENV{'PBTMP'}/Release 2>&1 |") || (cluck "Unable to verify GPG signature from Release.gpg\n" && next);
811            while(<SIGN>) {
812                chomp();
813                if (/^gpg: .*key /) {
814                    $signature = $_;
815                    $signature =~ s/^gpg: .*key [ID ]*([A-Z0-9]+)/$1/;
816                    pb_system("gpg --recv-keys --keyserver $keyserver $signature","Importing GPG signature for $signature");
817                    last;
818                }
819            }
820            close(SIGN);
821            return(undef) if (not defined $signature);
822
823            pb_log(3, "GnuPG repo verify returned: $signature\n");
824            pb_system("gpg -a --export -o $ENV{'PBTMP'}/apt.sig \'$signature\'","Exporting GnuPG signature of $signature");
825            pb_system("sudo apt-key add $ENV{'PBTMP'}/apt.sig","Adding GnuPG signature of $signature to APT key ring");
826            pb_system("sudo apt-get update","Updating apt repository");
827        } else {
828            pb_log(0,"ERROR: Unable to deal with repository file $i on deb distro ! Please report to dev team\n");
829        }
830    } else {
831        pb_log(0,"ERROR: Unable to deal with repository file $i on that distro ! Please report to dev team\n");
832    }
833}
834return("forcerepo");
835}
836
837=item B<pb_distro_to_keylist>
838
839Given a pbos object (first param) and the generic key (second param), get the list of possible keys for looking up variable for
840filter names.  The list will be sorted most-specific to least specific.
841
842=cut
843
844sub pb_distro_to_keylist ($$) {
845
846my ($pbos, $generic) = @_;
847
848foreach my $key (qw/name version arch family type os/) {
849    confess "missing pbos key $key" unless (defined $pbos->{$key});
850}
851
852my @keylist = ("$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}", "$pbos->{'name'}-$pbos->{'version'}");
853
854# Loop to include also previous minor versions
855# if configured so
856if ((defined $pbos->{'useminor'}) && ($pbos->{'useminor'} eq "true") && ($pbos->{'version'} =~ /^(\d+)\.(\d+)$/o)) {
857        my ($major, $minor) = ($1, $2);
858        while ($minor > 0) {
859                $minor--;
860                push (@keylist, "$pbos->{'name'}-${major}.$minor");
861        }
862        push (@keylist, "$pbos->{'name'}-$major");
863}
864
865push (@keylist, $pbos->{'name'}, $pbos->{'family'}, $pbos->{'type'}, $pbos->{'os'}, $generic);
866return @keylist;
867}
868
869=item B<pb_distro_get_param>
870
871This internal function gets the parameters in the conf file from the most precise tuple up to default
872
873=cut
874
875sub pb_distro_get_param {
876
877my $pbos = shift;
878my $var = shift; 
879my @param = ();
880my $i = 0;
881pb_log(3,"var: ".Dumper($var));
882
883my @keylist = pb_distro_to_keylist($pbos,"default");
884pb_log(3,"keylist: ".Dumper(@keylist));
885
886my $p = $var->{"ptr"};
887foreach my $opt (@$p) {
888    pb_log(3,'opt: '.Dumper($opt));
889    my $param = undef;
890    my $fkey = undef;
891    foreach my $key (@keylist) {
892        pb_log(3,"key: $key\n");
893        if (defined $opt->{$key}) {
894            $param = $opt->{$key};
895            $fkey = $key;
896            last;
897        }
898    }
899    my $field = $var->{"val"};
900    pb_log(3,"field: ".Dumper($field));
901    $fkey = "default" if (not defined $fkey);
902    pb_log(3,"key: $fkey\n");
903    pb_log(2,"DEBUG: pb_distro_get_if on $pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'} for $field->[$i]".'{'.$fkey.'}'." returns ");
904    if (defined $param) {
905        # Allow replacement of variables inside the parameter such as name, version, arch for rpmbootstrap
906        # but not shell variable which are backslashed
907        if ($param =~ /[^\\]\$/) {
908            pb_log(3,"Expanding variable on $param\n");
909            eval { $param =~ s/(\$\w+->\{\'\w+\'\})/$1/eeg };
910        }
911        pb_log(2,"$param\n");
912    } else {
913        pb_log(2,"undefined\n");
914    }
915    push @param,$param;
916    $i++;
917}
918
919# Return one param if user only asked for one lookup, an array if not.
920my $nb = @param;
921pb_log(3,"Param".Dumper(@param)." has $nb members\n");
922if ($nb eq 1) {
923    pb_log(3,"Return param $param[0]\n") if (defined $param[0]);
924    return($param[0]);
925} else {
926    return(@param);
927}
928}
929
930
931=item B<pb_distro_get_if>
932
933This function gets the parameters in the conf file from the most precise tuple up to default
934
935=cut
936
937sub pb_distro_get_if {
938
939my $pbos = shift;
940my @ptr = pb_conf_get_if(@_);
941my $var;
942$var->{"ptr"} = \@ptr;
943$var->{"val"} = \@_;
944return(pb_distro_get_param($pbos,$var));
945}
946
947=item B<pb_distro_get>
948
949This function gets the parameters in the conf file from the most precise tuple up to default.
950Aborts of one param doesn't exist whereas it should
951
952=cut
953
954sub pb_distro_get {
955
956my $pbos = shift;
957my @param = @_;
958my @return = pb_distro_get_if($pbos,@param);
959
960foreach my $i (0..$#param) {
961    confess "No $param[$i] defined for $pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}" if (not defined $return[$i]);
962}
963my $nb = @return;
964if ($nb eq 1) {
965    return($return[0]);
966} else {
967    return(@return);
968}
969}
970
971=item B<pb_distro_get_in_hash_if>
972
973This function gets the parameters in the conf file passed as hash from the most precise tuple up to default
974
975=cut
976
977sub pb_distro_get_in_hash_if {
978
979my $pbos = shift;
980my $lh = shift || return(());
981
982my @ptr = pb_conf_get_in_hash_if($lh,@_);
983my $var;
984$var->{"ptr"} = \@ptr;
985$var->{"val"} = \@_;
986return(pb_distro_get_param($pbos,$var));
987}
988
989=item B<pb_distro_get_context>
990
991This function gets the OS context passed as parameter and return the corresponding distribution hash
992If passed undef or "" then auto-detects
993
994=cut
995
996
997sub pb_distro_get_context {
998
999my $os = shift;
1000my $pbos;
1001
1002if ((defined $os) && ($os ne "")) {
1003    my ($name,$ver,$darch) = split(/-/,$os);
1004    pb_log(0,"Bad format for $os") if ((not defined $name) || (not defined $ver) || (not defined $darch)) ;
1005    chomp($darch);
1006    $pbos = pb_distro_init($name,$ver,$darch);
1007} else {
1008    $pbos = pb_distro_init();
1009}
1010return($pbos);
1011}
1012
1013=item B<pb_distro_conf_print>
1014
1015This function prints every configuration parameter in order to help debug stacking issues with conf files. If a VM/VE/RM is given, restrict display to this distribution. If parameters are passed, restrict again the display to these values only.
1016
1017=cut
1018
1019sub pb_distro_conf_print {
1020
1021my $pbos = shift;
1022my @keys = @_;
1023my $all = 0;
1024
1025if ($#keys == -1) {
1026    pb_log(0,"Full pb configuration for project $ENV{'PBPROJ'}\n");
1027    pb_log(0,"================================================\n");
1028    @keys = pb_conf_get_all();
1029    $all = 1;
1030}
1031if (defined $ENV{'PBV'}) {
1032    pb_log(1,"Distribution $ENV{'PBV'}\n");
1033    pb_log(1,"========================\n");
1034} else {
1035    pb_log(1,"Local Distribution\n");
1036    pb_log(1,"==================\n");
1037}
1038
1039my %rep;
1040my $i = 0;
1041# Index on distro
1042foreach my $r (pb_distro_get_if($pbos,@keys)) {
1043    $rep{$keys[$i]} = $r if (defined $keys[$i]);
1044    $i++;
1045}
1046$i = 0;
1047# Then Index on prj to overwrite previous value if needed
1048foreach my $r (pb_conf_get_if(@keys)) {
1049    $rep{$keys[$i]} = $r->{'default'} if (defined  $r->{'default'});
1050    $rep{$keys[$i]} = $r->{$ENV{'PBPROJ'}} if (defined  $r->{$ENV{'PBPROJ'}});
1051    $i++;
1052}
1053foreach my $r (keys %rep) {
1054    pb_log(1, "$r => ");
1055    pb_log(0, "$rep{$r}\n") if (($all == 0) && (defined $rep{$r}));
1056    pb_log(0, "$r = $rep{$r}\n") if (($all == 1) && (defined $rep{$r}));
1057}
1058}
1059
1060
1061=back
1062
1063=head1 WEB SITES
1064
1065The main Web site of the project is available at L<http://www.project-builder.org/>. Bug reports should be filled using the trac instance of the project at L<http://trac.project-builder.org/>.
1066
1067=head1 USER MAILING LIST
1068
1069None exists for the moment.
1070
1071=head1 AUTHORS
1072
1073The Project-Builder.org team L<http://trac.project-builder.org/> lead by Bruno Cornec L<mailto:bruno@project-builder.org>.
1074
1075=head1 COPYRIGHT
1076
1077Project-Builder.org is distributed under the GPL v2.0 license
1078described in the file C<COPYING> included with the distribution.
1079
1080=cut
1081
1082
10831;
Note: See TracBrowser for help on using the repository browser.