source: devel/pb/bin/pb @ 437

Last change on this file since 437 was 437, checked in by bruno, 12 years ago
  • Fix DateManip? latest version (should be replaced by a latest link)
  • Fix dtype as tgz for Slackware
  • Property svn:executable set to *
File size: 55.1 KB
Line 
1#!/usr/bin/perl -w
2#
3# Project Builder main application
4#
5# $Id$
6#
7# Copyright B. Cornec 2007
8# Provided under the GPL v2
9
10# Syntax: see at end
11
12use strict 'vars';
13use Getopt::Long qw(:config auto_abbrev no_ignore_case);
14use Data::Dumper;
15use English;
16use File::Basename;
17use File::Copy;
18use File::stat;
19use File::Temp qw(tempdir);
20use POSIX qw(strftime);
21use lib qw (lib);
22use ProjectBuilder::Version;
23use ProjectBuilder::Base;
24use ProjectBuilder::Conf;
25use ProjectBuilder::Distribution;
26use ProjectBuilder::CMS;
27use ProjectBuilder::Env;
28use ProjectBuilder::Filter;
29
30# Global variables
31my %opts;                   # CLI Options
32my $action;                 # action to realize
33my $test = "FALSE";         # Not used
34my $force = 0;              # Force VE/VM rebuild
35my $option = "";            # Not used
36my @pkgs;                   # list of packages
37my $pbtag;                  # Global Tag variable
38my $pbver;                  # Global Version variable
39my $pbscript;               # Name of the script
40my %pbver;                  # per package
41my %pbtag;                  # per package
42my $pbrev;                  # Global REVISION variable
43my $pbaccount;              # Login to use to connect to the VM
44my $pbport;                 # Port to use to connect to the VM
45my $newver;                 # New version to create
46my $iso;                    # ISO image for the VM to create
47
48my @date = pb_get_date();
49my $pbdate = strftime("%Y-%m-%d", @date);
50
51=pod
52
53=head1 NAME
54
55pb, aka project-builder.org - builds packages for your projects
56
57=head1 DESCRIPTION
58
59pb helps you build various packages directly from your project sources.
60Those sources could be handled by a CMS (Configuration Management System)
61such as Subversion, CVS, ... or being a simple reference to a compressed tar file.
62It's based on a set of configuration files, a set of provided macros to help
63you keeping build files as generic as possible. For example, a single .spec
64file should be required to generate for all rpm based distributions, even
65if you could also have multiple .spec files if required.
66
67=head1 SYNOPSIS
68
69pb [-vhq][-r pbroot][-p project][[-s script -a account -P port][-m mach-1[,...]]][-i iso] <action> [<pkg1> ...]
70
71pb [--verbose][--help][--man][--quiet][--revision pbroot][--project project][[--script script --account account --port port][--machine mach-1[,...]]][--iso iso] <action> [<pkg1> ...]
72
73=head1 OPTIONS
74
75=over 4
76
77=item B<-v|--verbose>
78
79Print a brief help message and exits.
80
81=item B<-q|--quiet>
82
83Do not print any output.
84
85=item B<-h|--help>
86
87Print a brief help message and exits.
88
89=item B<--man>
90
91Prints the manual page and exits.
92
93=item B<-m|--machine machine1[,machine2,...]>
94
95Name of the Virtual Machines (VM) or Virtual Environments (VE) you want to build on (coma separated).
96All if none precised (or use the env variable PBV).
97
98=item B<-s|--script script>
99
100Name of the script you want to execute on the related VMs or VEs.
101
102=item B<-i|--iso iso_image>
103
104Name of the ISO image of the distribution you want to install on the related VMs.
105
106=item B<-a|--account account>
107
108Name of the account to use to connect on the related VMs.
109
110=item B<-P|--port port_number>
111
112Port number to use to connect on the related VMs.\n";
113
114=item B<-p|--project project_name>
115
116Name of the project you're working on (or use the env variable PBPROJ)
117
118=item B<-r|--revision revision>
119
120Path Name of the project revision under the CMS (or use the env variable PBROOT)
121
122=item B<-V|--version new_version>
123
124New version of the project to create based on the current one.
125
126=back
127
128=head1 ARGUMENTS
129
130<action> can be:
131
132=over 4
133
134=item B<cms2build>
135
136Create tar files for the project under your CMS.
137CMS supported are SVN and CVS
138parameters are packages to build
139if not using default list
140
141=item B<build2pkg>
142
143Create packages for your running distribution
144
145=item B<cms2pkg>
146
147cms2build + build2pkg
148
149=item B<build2ssh>
150
151Send the tar files to a SSH host
152
153=item B<cms2ssh>
154
155cms2build + build2ssh
156
157=item B<pkg2ssh>
158
159Send the packages built to a SSH host
160
161=item B<build2vm>
162
163Create packages in VMs, launching them if needed
164and send those packages to a SSH host once built
165VM type supported are QEMU
166
167=item B<build2ve>
168
169Create packages in VEs, creating it if needed
170and send those packages to a SSH host once built
171
172=item B<cms2vm>
173
174cms2build + build2vm
175
176=item B<cms2ve>
177
178cms2build + build2ve
179
180=item B<launchvm>
181
182Launch one virtual machine
183
184=item B<launchve>
185
186Launch one virtual environment
187
188=item B<script2vm>
189
190Launch one virtual machine if needed
191and executes a script on it
192
193=item B<script2ve>
194
195Execute a script in a virtual environment
196
197=item B<newvm>
198
199Create a new virtual machine
200
201=item B<newve>
202
203Create a new virtual environment
204
205=item B<setupvm>
206
207Setup a virtual machine for pb usage
208
209=item B<setupve>
210
211Setup a virtual environment for pb usage
212
213=item B<newver>
214
215Create a new version of the project derived
216from the current one
217
218=item B<newproj>
219
220Create a new project and a template set of
221configuration files under pbconf
222
223=back
224
225<pkgs> can be a list of packages, the keyword 'all' or nothing, in which case the default list of packages is taken (corresponding to the defpkgdir list of arguments in the configuration file).
226
227=head1 WEB SITES
228
229The 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/>.
230
231=head1 USER MAILING LIST
232
233None exists for the moment.
234
235=head1 CONFIGURATION FILES
236
237Each pb user may have a configuration in F<$HOME/.pbrc>. The values in this file may overwrite any other configuration file value.
238
239Here is an example of such a configuration file:
240
241 #
242 # Define for each project the URL of its pbconf repository
243 # No default option allowed here as they need to be all different
244 #
245 # URL of the pbconf content
246 # This is the format of a classical URL with the extension of additional schema such as
247 # svn+ssh, cvs+ssh, ...
248 #
249 pbconfurl linuxcoe = cvs+ssh://:ext:bcornec@linuxcoe.cvs.sourceforge.net:/cvsroot/linuxcoe/pbconf
250
251 # This is normaly defined in the project's configuration file
252 # Url of the project
253 #
254 pburl linuxcoe = cvs+ssh://:ext:bcornec@linuxcoe.cvs.sourceforge.net:/cvsroot/linuxcoe
255 
256 # All these URLs needs to be defined here as the are the entry point
257 # for how to build packages for the project
258 #
259 pbconfurl pb = svn+ssh://svn.project-builder.org/mondo/svn/pb/pbconf
260 pbconfurl mondorescue = svn+ssh://svn.project-builder.org/mondo/svn/project-builder/mondorescue/pbconf
261 pbconfurl collectl = svn+ssh://bruno@svn.mondorescue.org/mondo/svn/project-builder/collectl/pbconf
262 pbconfurl netperf = svn+ssh://svn.mondorescue.org/mondo/svn/project-builder/netperf/pbconf
263 
264 # Under that dir will take place everything related to pb
265 # If you want to use VMs/chroot/..., then use $ENV{'HOME'} to make it portable
266 # to your VMs/chroot/...
267 # if not defined then /var/cache
268 pbdefdir default = $ENV{'HOME'}/project-builder
269 pbdefdir pb = $ENV{'HOME'}
270 pbdefdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs
271 pbdefdir mondorescue = $ENV{'HOME'}/mondo/svn
272 
273 # pbconfdir points to the directory where the CMS content of the pbconfurl is checked out
274 # If not defined, pbconfdir is under pbdefdir/pbproj/pbconf
275 pbconfdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs/pbconf
276 pbconfdir mondorescue = $ENV{'HOME'}/mondo/svn/pbconf
277 
278 # pbdir points to the directory where the CMS content of the pburl is checked out
279 # If not defined, pbdir is under pbdefdir/pbproj
280 # Only defined if we have access to the dev of the project
281 pbdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs
282 pbdir mondorescue = $ENV{'HOME'}/mondo/svn
283 
284 # -daemonize doesn't work with qemu 0.8.2
285 vmopt default = -m 384
286
287=head1 AUTHORS
288
289The Project-Builder.org team L<http://trac.project-builder.org/> lead by Bruno Cornec L<mailto:bruno@project-builder.org>.
290
291=head1 COPYRIGHT
292
293Project-Builder.org is distributed under the GPL v2.0 license
294described in the file C<COPYING> included with the distribution.
295
296=cut
297
298# ---------------------------------------------------------------------------
299
300# Old syntax
301#getopts('a:fhi:l:m:P:p:qr:s:vV:',\%opts);
302
303my ($projectbuilderver,$projectbuilderrev) = pb_version_init();
304
305# Initialize the syntax string
306
307pb_syntax_init("pb (aka project-builder.org) Version $projectbuilderver-$projectbuilderrev\n");
308
309GetOptions("help|?|h" => \$opts{'h'}, 
310        "man" => \$opts{'man'},
311        "verbose|v+" => \$opts{'v'},
312        "quiet|q" => \$opts{'q'},
313        "log-files|l=s" => \$opts{'l'},
314        "force|f" => \$opts{'f'},
315        "account|a=s" => \$opts{'a'},
316        "revision|r=s" => \$opts{'r'},
317        "script|s=s" => \$opts{'s'},
318        "machines|mock|m=s" => \$opts{'m'},
319        "port|P=i" => \$opts{'P'},
320        "project|p=s" => \$opts{'p'},
321        "iso|i=s" => \$opts{'i'},
322        "version|V=s" => \$opts{'V'},
323) || pb_syntax(-1,0);
324
325if (defined $opts{'h'}) {
326    pb_syntax(0,1);
327}
328if (defined $opts{'man'}) {
329    pb_syntax(0,2);
330}
331if (defined $opts{'v'}) {
332    $debug = $opts{'v'};
333}
334if (defined $opts{'f'}) {
335    $force=1;
336}
337if (defined $opts{'q'}) {
338    $debug=-1;
339}
340if (defined $opts{'l'}) {
341    open(LOG,"> $opts{'l'}") || die "Unable to log to $opts{'l'}: $!";
342    $LOG = \*LOG;
343    $debug = 0  if ($debug == -1);
344    }
345pb_log_init($debug, $LOG);
346
347# Handle root of the project if defined
348if (defined $opts{'r'}) {
349    $ENV{'PBROOTDIR'} = $opts{'r'};
350}
351# Handle virtual machines if any
352if (defined $opts{'m'}) {
353    $ENV{'PBV'} = $opts{'m'};
354}
355if (defined $opts{'s'}) {
356    $pbscript = $opts{'s'};
357}
358if (defined $opts{'a'}) {
359    $pbaccount = $opts{'a'};
360    die "option -a requires a -s script option" if (not defined $pbscript);
361}
362if (defined $opts{'P'}) {
363    $pbport = $opts{'P'};
364}
365if (defined $opts{'V'}) {
366    $newver = $opts{'V'};
367}
368if (defined $opts{'i'}) {
369    $iso = $opts{'i'};
370}
371
372# Get Action
373$action = shift @ARGV;
374die pb_syntax(-1,1) if (not defined $action);
375
376my ($filteredfiles, $supfiles, $defpkgdir, $extpkgdir);
377my $pbinit = undef;
378$pbinit = 1 if ($action =~ /^newproj$/);
379
380# Handles project name if any
381# And get global params
382($filteredfiles, $supfiles, $defpkgdir, $extpkgdir) = pb_env_init($opts{'p'},$pbinit,$action);
383
384pb_log(0,"Project: $ENV{'PBPROJ'}\n");
385pb_log(0,"Action: $action\n");
386
387# Act depending on action
388if ($action =~ /^cms2build$/) {
389    pb_cms2build();
390} elsif ($action =~ /^build2pkg$/) {
391    pb_build2pkg();
392} elsif ($action =~ /^cms2pkg$/) {
393    pb_cms2build();
394    pb_build2pkg();
395} elsif ($action =~ /^build2ssh$/) {
396    pb_build2ssh();
397} elsif ($action =~ /^cms2ssh$/) {
398    pb_cms2build();
399    pb_build2ssh();
400} elsif ($action =~ /^pkg2ssh$/) {
401    pb_pkg2ssh();
402} elsif ($action =~ /^build2ve$/) {
403    pb_build2v("ve");
404} elsif ($action =~ /^build2vm$/) {
405    pb_build2v("vm");
406} elsif ($action =~ /^cms2ve$/) {
407    pb_cms2build();
408    pb_build2v("ve");
409} elsif ($action =~ /^cms2vm$/) {
410    pb_cms2build();
411    pb_build2v("vm");
412} elsif ($action =~ /^launchvm$/) {
413    pb_launchv("vm",$ENV{'PBV'},0);
414} elsif ($action =~ /^launchve$/) {
415    pb_launchv("ve",$ENV{'PBV'},0);
416} elsif ($action =~ /^script2vm$/) {
417    pb_script2v($pbscript,"vm");
418} elsif ($action =~ /^script2ve$/) {
419    pb_script2v($pbscript,"ve");
420} elsif ($action =~ /^newver$/) {
421    pb_newver();
422} elsif ($action =~ /^newve$/) {
423    pb_launchv("ve",$ENV{'PBV'},1);
424} elsif ($action =~ /^newvm$/) {
425    pb_launchv("vm",$ENV{'PBV'},1);
426} elsif ($action =~ /^setupve$/) {
427    pb_setup_v("ve");
428} elsif ($action =~ /^setupvm$/) {
429    pb_setup_v("vm");
430} elsif ($action =~ /^newproj$/) {
431    # Nothing to do - already done in pb_env_init
432} elsif ($action =~ /^clean$/) {
433} else {
434    pb_log(0,"\'$action\' is not available\n");
435    pb_syntax(-2,1);
436}
437
438sub pb_cms2build {
439
440    my $pkg = pb_cms_get_pkg($defpkgdir,$extpkgdir);
441    my @pkgs = @$pkg;
442    my %pkgs;
443
444    my ($scheme, $uri) = pb_cms_init($pbinit);
445
446    my ($pkgv, $pkgt) = pb_conf_get_if("pkgver","pkgtag");
447
448    # declare packager and repo for filtering
449    my ($tmp1, $tmp2) = pb_conf_get("pbpackager","pbrepo");
450    $ENV{'PBPACKAGER'} = $tmp1->{$ENV{'PBPROJ'}};
451    $ENV{'PBREPO'} = $tmp2->{$ENV{'PBPROJ'}};
452
453    foreach my $pbpkg (@pkgs) {
454        $ENV{'PBPKG'} = $pbpkg;
455        if ((defined $pkgv) && (defined $pkgv->{$pbpkg})) {
456            $pbver = $pkgv->{$pbpkg};
457        } else {
458            $pbver = $ENV{'PBPROJVER'};
459        }
460        if ((defined $pkgt) && (defined $pkgt->{$pbpkg})) {
461            $pbtag = $pkgt->{$pbpkg};
462        } else {
463            $pbtag = $ENV{'PBPROJTAG'};
464        }
465
466        $pbrev = $ENV{'PBREVISION'};
467        pb_log(0,"\n");
468        pb_log(0,"Management of $pbpkg $pbver-$pbtag (rev $pbrev)\n");
469        die "Unable to get env var PBDESTDIR" if (not defined $ENV{'PBDESTDIR'});
470        # Clean up dest if necessary. The export will recreate it
471        my $dest = "$ENV{'PBDESTDIR'}/$pbpkg-$pbver";
472        pb_rm_rf($dest) if (-d $dest);
473
474        # Export CMS tree for the concerned package to dest
475        # And generate some additional files
476        $OUTPUT_AUTOFLUSH=1;
477
478        # computes in which dir we have to work
479        my $dir = $defpkgdir->{$pbpkg};
480        $dir = $extpkgdir->{$pbpkg} if (not defined $dir);
481        pb_log(2,"def:".Dumper($defpkgdir)." ext: ".Dumper($extpkgdir)." \n");
482
483        # Exporting from CMS
484        pb_cms_export($uri,"$ENV{'PBDIR'}/$dir",$dest);
485
486        # Generated fake content for test versions to speed up stuff
487        my ($testver) = pb_conf_get_if("testver");
488        my $chglog;
489
490        if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
491            if (! -f "$dest/NEWS") {
492                open(NEWS,"> $dest/NEWS") || die "Unable to create $dest/NEWS";
493                close(NEWS);
494            }
495            open(CL,"> $dest/ChangeLog") || die "Unable to create $dest/ChangeLog";
496            close(CL);
497            open(CL,"> $dest/$ENV{'PBCMSLOGFILE'}") || die "Unable to create $dest/$ENV{'PBCMSLOGFILE'}";
498            close(CL);
499            $chglog = undef;
500        } else {
501
502            # Get project info on authors and log file
503            $chglog = "$ENV{'PBROOTDIR'}/$pbpkg/pbcl";
504            $chglog = "$ENV{'PBROOTDIR'}/pbcl" if (! -f $chglog);
505            $chglog = undef if (! -f $chglog);
506
507            my $authors = "$ENV{'PBROOTDIR'}/$pbpkg/pbauthors";
508            $authors = "$ENV{'PBROOTDIR'}/pbauthors" if (! -f $authors);
509            $authors = "/dev/null" if (! -f $authors);
510
511            # Extract cms log history and store it
512            if ((defined $chglog) && (! -f "$dest/NEWS")) {
513                pb_log(2,"Generating NEWS file from $chglog\n");
514                copy($chglog,"$dest/NEWS") || die "Unable to create $dest/NEWS";
515            }
516            pb_cms_log($scheme,"$ENV{'PBDIR'}/$dir",$dest,$chglog,$authors);
517        }
518
519        my %build;
520        my @pt;
521        my $tmpl = "";
522
523        @pt = pb_conf_get_if("vmlist","velist");
524        if (defined $pt[0]->{$ENV{'PBPROJ'}}) {
525            $tmpl .= $pt[0]->{$ENV{'PBPROJ'}};
526        }
527        if (defined $pt[1]->{$ENV{'PBPROJ'}}) {
528            # the 2 lists needs to be grouped with a ',' separated them
529            if ($tmpl ne "") {
530                $tmpl .= ",";
531            }
532            $tmpl .= $pt[1]->{$ENV{'PBPROJ'}} 
533        }
534        foreach my $d (split(/,/,$tmpl)) {
535            my ($name,$ver,$arch) = split(/-/,$d);
536            chomp($arch);
537            my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($name,$ver);
538            pb_log(2,"DEBUG: distro tuple: ".Dumper($ddir, $dver, $dfam, $dtype, $pbsuf)."\n");
539            pb_log(2,"DEBUG Filtering PBDATE => $pbdate, PBTAG => $pbtag, PBVER => $pbver\n");
540
541            # Filter build files from the less precise up to the most with overloading
542            # Filter all files found, keeping the name, and generating in dest
543
544            # Find all build files first relatively to PBROOTDIR
545            # Find also all specific files referenced in the .pb conf file
546            my %bfiles = ();
547            my %pkgfiles = ();
548            $build{"$ddir-$dver"} = "yes";
549
550            if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$dtype") {
551                pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$dtype",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
552            } elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$dfam") {
553                pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$dfam",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
554            } elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$ddir") {
555                pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$ddir",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
556            } elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$ddir-$dver") {
557                pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$ddir-$dver",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
558            } else {
559                $build{"$ddir-$dver"} = "no";
560                next;
561            }
562            pb_log(2,"DEBUG bfiles: ".Dumper(\%bfiles)."\n");
563
564            # Get all filters to apply
565            my $ptr = pb_get_filters($pbpkg, $dtype, $dfam, $ddir, $dver);
566
567            # Apply now all the filters on all the files concerned
568            # destination dir depends on the type of file
569            if (defined $ptr) {
570                foreach my $f (values %bfiles,values %pkgfiles) {
571                    pb_filter_file_pb("$ENV{'PBROOTDIR'}/$f",$ptr,"$dest/pbconf/$ddir-$dver/".basename($f),$dtype,$pbsuf,$pbpkg,$pbver,$pbtag,$pbrev,$pbdate,$defpkgdir,$extpkgdir,$ENV{'PBPACKAGER'},$chglog,$ENV{'PBPROJ'},$ENV{'PBREPO'});
572                }
573            }
574        }
575        my @found;
576        my @notfound;
577        foreach my $b (keys %build) {
578            push @found,$b if ($build{$b} =~ /yes/);
579            push @notfound,$b if ($build{$b} =~ /no/);
580        }
581        pb_log(0,"Build files generated for ".join(',',@found)."\n");
582        pb_log(0,"No Build files found for ".join(',',@notfound)."\n") if (@notfound);
583        # Get the generic filter (all.pbf) and
584        # apply those to the non-build files including those
585        # generated by pbinit if applicable
586
587        # Get only all.pbf filter
588        my $ptr = pb_get_filters($pbpkg);
589
590        my $liste ="";
591        if (defined $filteredfiles->{$pbpkg}) {
592            foreach my $f (split(/,/,$filteredfiles->{$pbpkg})) {
593                pb_filter_file_inplace($ptr,"$dest/$f",$pbpkg,$pbver,$pbtag,$pbrev,$pbdate,$ENV{'PBPACKAGER'},$ENV{'PBPROJ'},$ENV{'PBREPO'});
594                $liste = "$f $liste";
595            }
596        }
597        pb_log(2,"Files ".$liste."have been filtered\n");
598
599        # Prepare the dest directory for archive
600        if (-x "$ENV{'PBROOTDIR'}/$pbpkg/pbinit") {
601            pb_filter_file("$ENV{'PBROOTDIR'}/$pbpkg/pbinit",$ptr,"$ENV{'PBTMP'}/pbinit",$pbpkg,$pbver,$pbtag,$pbrev,$pbdate,$ENV{'PBPACKAGER'},$ENV{'PBPROJ'},$ENV{'PBREPO'});
602            chmod 0755,"$ENV{'PBTMP'}/pbinit";
603            pb_system("cd $dest ; $ENV{'PBTMP'}/pbinit","Executing init script from $ENV{'PBROOTDIR'}/$pbpkg/pbinit");
604        }
605
606        # Archive dest dir
607        chdir "$ENV{'PBDESTDIR'}" || die "Unable to change dir to $ENV{'PBDESTDIR'}";
608        # Possibility to look at PBSRC to guess more the filename
609        pb_system("tar cfz $pbpkg-$pbver.tar.gz $pbpkg-$pbver","Creating $pbpkg tar files compressed");
610        pb_log(0,"Under $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz\n");
611
612        # Keep track of version-tag per pkg
613        $pkgs{$pbpkg} = "$pbver-$pbtag";
614
615        # Final cleanup
616        pb_rm_rf($dest) if (-d $dest);
617    }
618
619    # Keep track of per package version
620    pb_log(2,"DEBUG pkgs: ".Dumper(%pkgs)."\n");
621    open(PKG,"> $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb") || die "Unable to create $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb";
622    foreach my $pbpkg (@pkgs) {
623        print PKG "pbpkg $pbpkg = $pkgs{$pbpkg}\n";
624    }
625    close(PKG);
626
627    # Keep track of what is generated by default
628    # We need to store the dir and info on version-tag
629    # Base our content on the existing .pb file
630    copy("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb","$ENV{'PBDESTDIR'}/pbrc");
631    open(LAST,">> $ENV{'PBDESTDIR'}/pbrc") || die "Unable to create $ENV{'PBDESTDIR'}/pbrc";
632    print LAST "pbroot $ENV{'PBPROJ'} = $ENV{'PBROOTDIR'}\n";
633    print LAST "pbprojver $ENV{'PBPROJ'} = $ENV{'PBPROJVER'}\n";
634    print LAST "pbprojtag $ENV{'PBPROJ'} = $ENV{'PBPROJTAG'}\n";
635    print LAST "pbpackager $ENV{'PBPROJ'} = $ENV{'PBPACKAGER'}\n";
636    close(LAST);
637}
638
639sub pb_build2pkg {
640
641    # Get the running distro to build on
642    my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init();
643    pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n");
644
645    # Get list of packages to build
646    # Get content saved in cms2build
647    my $ptr = pb_get_pkg();
648    @pkgs = @$ptr;
649
650    my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
651    $pkg = { } if (not defined $pkg);
652
653    chdir "$ENV{'PBBUILDDIR'}";
654    my $made = ""; # pkgs made during build
655    foreach my $pbpkg (@pkgs) {
656        my $vertag = $pkg->{$pbpkg};
657        # get the version of the current package - maybe different
658        ($pbver,$pbtag) = split(/-/,$vertag);
659
660        my $src="$ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz";
661        pb_log(2,"Source file: $src\n");
662
663        pb_log(2,"Working directory: $ENV{'PBBUILDDIR'}\n");
664        if ($dtype eq "rpm") {
665            foreach my $d ('RPMS','SRPMS','SPECS','SOURCES','BUILD') {
666                if (! -d "$ENV{'PBBUILDDIR'}/$d") {
667                pb_mkdir_p("$ENV{'PBBUILDDIR'}/$d") || die "Please ensure that you can write into $ENV{'PBBUILDDIR'} to create $d\nchown the $ENV{'PBBUILDDIR'} directory to your uid";
668                }
669            }
670
671            # Remove in case a previous link/file was there
672            unlink "$ENV{'PBBUILDDIR'}/SOURCES/".basename($src);
673            symlink "$src","$ENV{'PBBUILDDIR'}/SOURCES/".basename($src) || die "Unable to symlink $src in $ENV{'PBBUILDDIR'}/SOURCES";
674            # We need to first extract the spec file
675            my @specfile;
676            @specfile = pb_extract_build_files($src,"$pbpkg-$pbver/pbconf/$ddir-$dver/","$ENV{'PBBUILDDIR'}/SPECS");
677
678            pb_log(2,"specfile: ".Dumper(\@specfile)."\n");
679            # set LANGUAGE to check for correct log messages
680            $ENV{'LANGUAGE'}="C";
681            foreach my $f (@specfile) {
682                if ($f =~ /\.spec$/) {
683                    pb_system("rpmbuild --define \'packager $ENV{'PBPACKAGER'}\' --define \"_topdir $ENV{'PBBUILDDIR'}\" -ba $f","Building package with $f under $ENV{'PBBUILDDIR'}");
684                    last;
685                }
686            }
687            $made="$made RPMS/*/$pbpkg-$pbver-$pbtag$pbsuf.*.rpm SRPMS/$pbpkg-$pbver-$pbtag$pbsuf.src.rpm";
688            if (-f "/usr/bin/rpmlint") {
689                pb_system("rpmlint $made","Checking validity of rpms with rpmlint");
690            }
691        } elsif ($dtype eq "deb") {
692            chdir "$ENV{'PBBUILDDIR'}" || die "Unable to chdir to $ENV{'PBBUILDDIR'}";
693            pb_system("tar xfz $src","Extracting sources");
694
695            chdir "$pbpkg-$pbver" || die "Unable to chdir to $pbpkg-$pbver";
696            pb_rm_rf("debian");
697            symlink "pbconf/$ddir-$dver","debian" || die "Unable to symlink to pbconf/$ddir-$dver";
698            chmod 0755,"debian/rules";
699            pb_system("dpkg-buildpackage -us -uc -rfakeroot","Building package");
700            $made="$made $pbpkg"."_*.deb $pbpkg"."_*.dsc $pbpkg"."_*.tar.gz";
701            if (-f "/usr/bin/lintian") {
702                pb_system("lintian $made","Checking validity of debs with lintian");
703            }
704        } elsif ($dtype eq "ebuild") {
705            my @ebuildfile;
706            # For gentoo we need to take pb as subsystem name
707            # We put every apps here under sys-apps. hope it's correct
708            # We use pb's home dir in order to have a single OVERLAY line
709            my $tmpd = "$ENV{'HOME'}/portage/pb/sys-apps/$pbpkg";
710            pb_mkdir_p($tmpd) if (! -d "$tmpd");
711            pb_mkdir_p("$ENV{'HOME'}/portage/distfiles") if (! -d "$ENV{'HOME'}/portage/distfiles");
712
713            # We need to first extract the ebuild file
714            @ebuildfile = pb_extract_build_files($src,"$pbpkg-$pbver/pbconf/$ddir-$dver/","$tmpd");
715
716            # Prepare the build env for gentoo
717            my $found = 0;
718            my $pbbd = $ENV{'HOME'};
719            $pbbd =~ s|/|\\/|g;
720            if (-r "/etc/make.conf") {
721                open(MAKE,"/etc/make.conf");
722                while (<MAKE>) {
723                    $found = 1 if (/$pbbd\/portage/);
724                }
725                close(MAKE);
726            }
727            if ($found == 0) {
728                pb_system("sudo sh -c 'echo PORTDIR_OVERLAY=\"$ENV{'HOME'}/portage\" >> /etc/make.conf'");
729            }
730            #$found = 0;
731            #if (-r "/etc/portage/package.keywords") {
732            #open(KEYW,"/etc/portage/package.keywords");
733            #while (<KEYW>) {
734            #$found = 1 if (/portage\/pb/);
735            #}
736            #close(KEYW);
737            #}
738            #if ($found == 0) {
739            #pb_system("sudo sh -c \"echo portage/pb >> /etc/portage/package.keywords\"");
740            #}
741
742            # Build
743            foreach my $f (@ebuildfile) {
744                if ($f =~ /\.ebuild$/) {
745                    move($f,"$tmpd/$pbpkg-$pbver.ebuild");
746                    pb_system("cd $tmpd ; ebuild $pbpkg-$pbver.ebuild clean ; ebuild $pbpkg-$pbver.ebuild digest ; ebuild $pbpkg-$pbver.ebuild package");
747                    # Now move it where pb expects it
748                    pb_mkdir_p("$ENV{'PBBUILDDIR'}/portage/pb/sys-apps/$pbpkg");
749                    move("$tmpd/$pbpkg-$pbver.ebuild","$ENV{'PBBUILDDIR'}/portage/pb/sys-apps/$pbpkg");
750                }
751            }
752
753            $made="$made portage/pb/sys-apps/$pbpkg/$pbpkg-$pbver.ebuild";
754        } elsif ($dtype eq "tgz") {
755            # Slackware family
756            $made="$made $pbpkg/$pbpkg-$pbver-*-$pbtag.tgz";
757
758            chdir "$ENV{'PBBUILDDIR'}" || die "Unable to chdir to $ENV{'PBBUILDDIR'}";
759            pb_system("tar xfz $src","Extracting sources");
760            chdir "$pbpkg-$pbver" || die "Unable to chdir to $pbpkg-$pbver";
761            symlink "pbconf/$ddir-$dver","install" || die "Unable to symlink to pbconf/$ddir-$dver";
762            if (-x "install/pbslack") {
763                pb_system("./install/pbslack","Building package");
764                pb_system("sudo /sbin/makepkg -p -l y -c y $pbpkg","Packaging $pbpkg");
765            }
766        } else {
767            die "Unknown dtype format $dtype";
768        }
769    }
770    # Keep track of what is generated so that we can get them back from VMs
771    open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") || die "Unable to create $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
772    print KEEP "$made\n";
773    close(KEEP);
774}
775
776sub pb_build2ssh {
777    pb_send2target("Sources");
778}
779
780sub pb_pkg2ssh {
781    pb_send2target("Packages");
782}
783
784# By default deliver to the the public site hosting the
785# ftp structure (or whatever) or a VM/VE
786sub pb_send2target {
787
788    my $cmt = shift;
789    my $v = shift || undef;
790    my $vmexist = shift || 0;           # 0 is FALSE
791    my $vmpid = shift || 0;             # 0 is FALSE
792
793    my $host = "sshhost";
794    my $login = "sshlogin";
795    my $dir = "sshdir";
796    my $port = "sshport";
797    my $conf = "sshconf";
798    my $rebuild = "sshrebuild";
799    my $tmout = "vmtmout";
800    my $path = "vmpath";
801    if (($cmt eq "vm") || ($cmt eq "Script")) {
802        $login = "vmlogin";
803        $dir = "pbdefdir";
804        $tmout = "vmtmout";
805        $rebuild = "vmrebuild";
806        # Specific VM
807        $host = "vmhost";
808        $port = "vmport";
809    } elsif ($cmt eq "ve") {
810        $login = "velogin";
811        $dir = "pbdefdir";
812        $tmout = "vetmout";
813        # Specific VE
814        $path = "vepath";
815        $conf = "veconf";
816        $rebuild = "verebuild";
817    }
818    my $cmd = "";
819
820    my $ptr = pb_get_pkg();
821    @pkgs = @$ptr;
822
823    # Get the running distro to consider
824    my ($odir,$over,$oarch) = (undef, undef, undef);
825    if (defined $v) {
826        ($odir,$over,$oarch) = split(/-/,$v);
827    }
828    my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($odir,$over);
829    pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n");
830
831    # Get list of packages to build
832    # Get content saved in cms2build
833    my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
834    $pkg = { } if (not defined $pkg);
835
836    my $src = "";
837    chdir "$ENV{'PBBUILDDIR'}";
838    foreach my $pbpkg (@pkgs) {
839        my $vertag = $pkg->{$pbpkg};
840        # get the version of the current package - maybe different
841        ($pbver,$pbtag) = split(/-/,$vertag);
842
843        if (($cmt eq "Sources") || ($cmt eq "vm") || ($cmt eq "ve")) {
844            $src = "$src $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz";
845            if ($cmd eq "") {
846                $cmd = "ln -sf $pbpkg-$pbver.tar.gz $pbpkg-latest.tar.gz";
847            } else {
848                $cmd = "$cmd ; ln -sf $pbpkg-$pbver.tar.gz $pbpkg-latest.tar.gz";
849            }
850        }
851    }
852    # Adds conf file for availability of conf elements
853    pb_conf_add("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb");
854
855    if (($cmt eq "vm") || ($cmt eq "ve")) {
856        $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc";
857    } elsif ($cmt eq "Script") {
858        # Nothing special to do
859    } elsif ($cmt eq "Packages") {
860        # Get package list from file made during build2pkg
861        open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") || die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
862        $src = <KEEP>;
863        chomp($src);
864        close(KEEP);
865
866    }
867    # Systematically adds the pbscript
868    $src="$src $ENV{'PBDESTDIR'}/pbscript";
869    # Remove potential leading spaces (cause problem with basename)
870    $src =~ s/^ *//;
871    my $basesrc = "";
872    foreach my $i (split(/ +/,$src)) {
873        $basesrc .= " ".basename($i);
874    }
875
876    pb_log(0,"Sources handled ($cmt): $src\n");
877    pb_log(2,"values: ".Dumper(($host,$login,$dir,$port,$tmout,$rebuild,$path,$conf))."\n");
878    my ($sshhost,$sshlogin,$sshdir,$sshport,$vtmout,$vepath) = pb_conf_get($host,$login,$dir,$port,$tmout,$path);
879    my ($vrebuild,$veconf) = pb_conf_get_if($rebuild,$conf);
880    pb_log(2,"ssh: ".Dumper(($sshhost,$sshlogin,$sshdir,$sshport,$vtmout,$vrebuild,$vepath,$veconf))."\n");
881    # Not mandatory
882    my ($testver) = pb_conf_get_if("testver");
883
884    my $mac;
885    # Useless for VE
886    if ($cmt ne "ve") {
887        $mac = "$sshlogin->{$ENV{'PBPROJ'}}\@$sshhost->{$ENV{'PBPROJ'}}";
888        # Overwrite account value if passed as parameter
889        $mac = "$pbaccount\@$sshhost->{$ENV{'PBPROJ'}}" if (defined $pbaccount);
890        pb_log(2, "DEBUG: pbaccount: $pbaccount => mac: $mac\n") if (defined $pbaccount);
891    }
892
893    my $tdir;
894    my $bdir;
895    if (($cmt eq "Sources") || ($cmt eq "Script")) {
896        $tdir = "$sshdir->{$ENV{'PBPROJ'}}/src";
897        if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
898            # This is a test pkg => target dir is under test
899            $tdir = "$sshdir->{$ENV{'PBPROJ'}}/test/src";
900        }
901    } elsif (($cmt eq "vm") || ($cmt eq "ve")) {
902        $tdir = $sshdir->{$ENV{'PBPROJ'}}."/$ENV{'PBPROJ'}/delivery";
903        $bdir = $sshdir->{$ENV{'PBPROJ'}}."/$ENV{'PBPROJ'}/build";
904        # Remove a potential $ENV{'HOME'} as bdir should be relative to pb's home
905        $bdir =~ s|\$ENV.+\}/||;
906    } elsif ($cmt eq "Packages") {
907        $tdir = "$sshdir->{$ENV{'PBPROJ'}}/$ddir/$dver";
908
909        if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
910            # This is a test pkg => target dir is under test
911            $tdir = "$sshdir->{$ENV{'PBPROJ'}}/test/$ddir/$dver";
912        }
913
914        my $repodir = $tdir;
915        $repodir =~ s|^$sshdir->{$ENV{'PBPROJ'}}/||;
916
917        my ($pbrepo) = pb_conf_get("pbrepo");
918
919        # Repository management
920        open(PBS,"> $ENV{'PBDESTDIR'}/pbscript") || die "Unable to create $ENV{'PBDESTDIR'}/pbscript";
921        if ($dtype eq "rpm") {
922            # Also make a pbscript to generate yum/urpmi bases
923            print PBS << "EOF";
924#!/bin/bash
925# Prepare a script to ease yum setup
926cat > $ENV{'PBPROJ'}.repo << EOT
927[$ENV{'PBPROJ'}]
928name=$ddir $dver - $ENV{'PBPROJ'} Vanilla Packages
929baseurl=$pbrepo->{$ENV{'PBPROJ'}}/$repodir
930enabled=1
931gpgcheck=0
932EOT
933chmod 644 $ENV{'PBPROJ'}.repo
934
935# Clean up old repo content
936rm -rf headers/ repodata/
937# Create yum repo
938yum-arch .
939# Create repodata
940createrepo .
941EOF
942            if ($dfam eq "md") {
943                # For Mandriva add urpmi management
944                print PBS << "EOF";
945# Prepare a script to ease urpmi setup
946cat > $ENV{'PBPROJ'}.addmedia << EOT
947urpmi.addmedia $ENV{'PBPROJ'} $pbrepo->{$ENV{'PBPROJ'}}/$repodir with hdlist.cz
948EOT
949chmod 755 $ENV{'PBPROJ'}.addmedia
950
951# Clean up old repo content
952rm -f hdlist.cz synthesis.hdlist.cz
953# Create urpmi repo
954genhdlist .
955EOF
956            }
957        } elsif ($dtype eq "deb") {
958            # Also make a pbscript to generate apt bases
959        }
960        close(PBS);
961
962    } else {
963        return;
964    }
965
966    # Useless for VE
967    my $nport;
968    if ($cmt ne "ve") {
969        $nport = $sshport->{$ENV{'PBPROJ'}};
970        $nport = "$pbport" if (defined $pbport);
971    }
972
973    # Remove a potential $ENV{'HOME'} as tdir should be relative to pb's home
974    $tdir =~ s|\$ENV.+\}/||;
975
976    my $tm = $vtmout->{$ENV{'PBPROJ'}};
977
978    # ssh communication if not VE
979    # should use a hash instead...
980    my ($shcmd,$cpcmd,$cptarget,$cp2target);
981    if ($cmt ne "ve") {
982        my $keyfile = pb_ssh_get(0);
983        $shcmd = "ssh -i $keyfile -q -o UserKnownHostsFile=/dev/null -p $nport $mac";
984        $cpcmd = "scp -i $keyfile -p -o UserKnownHostsFile=/dev/null -P $nport";
985        $cptarget = "$mac:$tdir";
986        if ($cmt eq "vm") {
987            $cp2target = "$mac:$bdir";
988        }
989    } else {
990        my $tp = $vepath->{$ENV{'PBPROJ'}};
991        $shcmd = "sudo chroot $tp/$v /bin/su - $sshlogin->{$ENV{'PBPROJ'}} -c ";
992        $cpcmd = "cp -a ";
993        $cptarget = "$tp/$tdir";
994        $cp2target = "$tp/$bdir";
995    }
996
997    pb_system("$shcmd \"mkdir -p $tdir ; cd $tdir ; echo \'for i in $basesrc; do if [ -f \$i ]; then rm -f \$i; fi; done\ ; $cmd' | bash\"","Preparing $tdir on $cptarget");
998    pb_system("cd $ENV{'PBBUILDDIR'} ; $cpcmd $src $cptarget 2> /dev/null","$cmt delivery in $cptarget");
999    # For VE we need to change the owner manually - To be tested if needed
1000    #if ($cmt eq "ve") {
1001    #pb_system("cd $cptarget ; sudo chown -R $sshlogin->{$ENV{'PBPROJ'}} .","$cmt chown in $cptarget to $sshlogin->{$ENV{'PBPROJ'}}");
1002    #}
1003    pb_system("$shcmd \"echo \'cd $tdir ; if [ -f pbscript ]; then ./pbscript; fi ; rm -f ./pbscript\' | bash\"","Executing pbscript on $cptarget if needed");
1004    if (($cmt eq "vm") || ($cmt eq "ve")) {
1005        # Get back info on pkg produced, compute their name and get them from the VM
1006        pb_system("$cpcmd $cp2target/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'} $ENV{'PBBUILDDIR'} 2> /dev/null","Get package names in $cp2target");
1007        open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") || die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
1008        my $src = <KEEP>;
1009        chomp($src);
1010        close(KEEP);
1011        $src =~ s/^ *//;
1012        pb_mkdir_p("$ENV{'PBBUILDDIR'}/$odir/$over");
1013        # Change pgben to make the next send2target happy
1014        my $made = "";
1015        open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") || die "Unable to write $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
1016        foreach my $p (split(/ +/,$src)) {
1017            my $j = basename($p);
1018            pb_system("$cpcmd $cp2target/\'$p\' $ENV{'PBBUILDDIR'}/$odir/$over 2> /dev/null","Package recovery of $j in $cp2target");
1019            $made="$made $odir/$over/$j" if (($dtype ne "rpm") || ($j !~ /.src.rpm$/));
1020        }
1021        print KEEP "$made\n";
1022        close(KEEP);
1023        pb_system("$shcmd \"rm -rf $tdir $bdir\"","$cmt cleanup");
1024
1025        # We want to send them to the ssh account so overwrite what has been done before
1026        undef $pbaccount;
1027        pb_log(2,"Before sending pkgs, vmexist: $vmexist, vmpid: $vmpid\n");
1028        pb_send2target("Packages",$odir."-".$over."-".$oarch,$vmexist,$vmpid);
1029        if ((! $vmexist) && ($cmt eq "vm")) {
1030            pb_system("$shcmd \"sudo /sbin/halt -p \"; sleep $tm ; echo \'if [ -d /proc/$vmpid ]; then kill -9 $vmpid; fi \' | bash ; sleep 10","VM $v halt (pid $vmpid)");
1031        }
1032        pb_rm_rf("$ENV{'PBBUILDDIR'}/$odir");
1033    }
1034}
1035
1036sub pb_script2v {
1037    my $pbscript=shift;
1038    my $vtype=shift;
1039
1040    # Prepare the script to be executed on the VM
1041    # in $ENV{'PBDESTDIR'}/pbscript
1042    if ((defined $pbscript ) && ($pbscript ne "$ENV{'PBDESTDIR'}/pbscript")) {
1043        copy($pbscript,"$ENV{'PBDESTDIR'}/pbscript") || die "Unable to create $ENV{'PBDESTDIR'}/pbscript";
1044        chmod 0755,"$ENV{'PBDESTDIR'}/pbscript";
1045    }
1046
1047    my ($vm,$all) = pb_get_v($vtype);
1048    my ($vmexist,$vmpid) = (undef,undef);
1049
1050    foreach my $v (@$vm) {
1051        # Launch the VM/VE
1052        if ($vtype eq "vm") {
1053            ($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1054
1055            # Skip that VM if something went wrong
1056            next if (($vmpid == 0) && ($vmexist ==0));
1057        }
1058
1059        # Gather all required files to send them to the VM
1060        # and launch the build through pbscript
1061        pb_send2target("Script","$v",$vmexist,$vmpid);
1062
1063    }
1064}
1065
1066sub pb_launchv {
1067    my $vtype = shift;
1068    my $v = shift;
1069    my $create = shift || 0;        # By default do not create a VM
1070
1071    die "No VM/VE defined, unable to launch" if (not defined $v);
1072    # Keep only the first VM in case many were given
1073    $v =~ s/,.*//;
1074
1075    # Which is our local arch ? (standardize on i386 for those platforms)
1076    my $arch = `uname -m`;
1077    chomp($arch);
1078    $arch =~ s/i.86/i386/;
1079
1080    # Launch the VMs/VEs
1081    if ($vtype eq "vm") {
1082        die "-i iso parameter needed" if (((not defined $iso) || ($iso eq "")) && ($create != 0));
1083
1084        my ($ptr,$vmopt,$vmpath,$vmport,$vmtmout,$vmsize) = pb_conf_get("vmtype","vmopt","vmpath","vmport","vmtmout","vmsize");
1085
1086        my $vmtype = $ptr->{$ENV{'PBPROJ'}};
1087        if (not defined $ENV{'PBVMOPT'}) {
1088            $ENV{'PBVMOPT'} = "";
1089        }
1090        if (defined $vmopt->{$ENV{'PBPROJ'}}) {
1091            $ENV{'PBVMOPT'} .= " $vmopt->{$ENV{'PBPROJ'}}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$ENV{'PBPROJ'}}/);
1092        }
1093        my $nport = $vmport->{$ENV{'PBPROJ'}};
1094        $nport = "$pbport" if (defined $pbport);
1095   
1096        my $cmd;
1097        my $vmcmd;      # has to be used for pb_check_ps
1098        my $vmm;        # has to be used for pb_check_ps
1099        if ($vmtype eq "qemu") {
1100            my $qemucmd32;
1101            my $qemucmd64;
1102            if ($arch eq "x86_64") {
1103                $qemucmd32 = "/usr/bin/qemu-system-i386";
1104                $qemucmd64 = "/usr/bin/qemu";
1105            } else {
1106                $qemucmd32 = "/usr/bin/qemu";
1107                $qemucmd64 = "/usr/bin/qemu-system-x86_64";
1108            }
1109        if ($v =~ /x86_64/) {
1110                $vmcmd = "$qemucmd64 -no-kqemu";
1111            } else {
1112                $vmcmd = "$qemucmd32";
1113            }
1114            $vmm = "$vmpath->{$ENV{'PBPROJ'}}/$v.qemu";
1115            if ($create != 0) {
1116                $ENV{'PBVMOPT'} .= " -cdrom $iso -boot d";
1117            }
1118            $cmd = "$vmcmd $ENV{'PBVMOPT'} -redir tcp:$nport:10.0.2.15:22 $vmm"
1119        } elsif ($vmtype eq "xen") {
1120        } elsif ($vmtype eq "vmware") {
1121        } else {
1122            die "VM of type $vmtype not supported. Report to the dev team";
1123        }
1124        my ($tmpcmd,$void) = split(/ +/,$cmd);
1125        my $vmexist = pb_check_ps($tmpcmd,$vmm);
1126        my $vmpid = 0;
1127        if (! $vmexist) {
1128            if ($create != 0) {
1129                if (($vmtype eq "qemu") || ($vmtype eq "xen")) {
1130                    pb_system("/usr/bin/qemu-img create -f qcow2 $vmm $vmsize->{$ENV{'PBPROJ'}}","Creating the QEMU VM");
1131                } elsif ($vmtype eq "vmware") {
1132                } else {
1133                }
1134            }
1135            if (! -f "$vmm") {
1136                pb_log(0,"Unable to find VM $vmm\n");
1137            } else {
1138                pb_system("$cmd &","Launching the VM $vmm");
1139                pb_system("sleep $vmtmout->{$ENV{'PBPROJ'}}","Waiting for VM $v to come up");
1140                $vmpid = pb_check_ps($tmpcmd,$vmm);
1141                pb_log(0,"VM $vmm launched (pid $vmpid)\n");
1142            }
1143        } else {
1144            pb_log(0,"Found an existing VM $vmm (pid $vmexist)\n");
1145        }
1146        return($vmexist,$vmpid);
1147    # VE here
1148    } else {
1149        # Get VE context
1150        my ($ptr,$vetmout,$vepath,$verebuild,$veconf) = pb_conf_get("vetype","vetmout","vepath","verebuild","veconf");
1151        my $vetype = $ptr->{$ENV{'PBPROJ'}};
1152
1153        # Get distro context
1154        my ($name,$ver,$darch) = split(/-/,$v);
1155        chomp($darch);
1156        my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($name,$ver);
1157
1158        if ($vetype eq "chroot") {
1159            # Architecture consistency
1160            if ($arch ne $darch) {
1161                die "Unable to launch a VE of architecture $darch on a $arch platform" if (not (($darch eq "x86_64") && ($arch =~ /i?86/)));
1162            }
1163
1164            if (($create != 0) || ($verebuild->{$ENV{'PBPROJ'}} eq "true") || ($force == 1)) {
1165                # We have to rebuild the chroot
1166                if ($dtype eq "rpm") {
1167                    pb_system("sudo /usr/sbin/mock --init --resultdir=\"/tmp\" --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" -r $v","Creating the mock VE");
1168                    # Once setup we need to install some packages, the pb account, ...
1169                    pb_system("sudo /usr/sbin/mock --install --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" -r $v su","Configuring the mock VE");
1170                    #pb_system("sudo /usr/sbin/mock --init --resultdir=\"/tmp\" --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" --basedir=\"$vepath->{$ENV{'PBPROJ'}}\" -r $v","Creating the mock VE");
1171                } elsif ($dtype eq "deb") {
1172                    pb_system("","Creating the pbuilder VE");
1173                } elsif ($dtype eq "ebuild") {
1174                    die "Please teach the dev team how to build gentoo chroot";
1175                } else {
1176                    die "Unknown distribution type $dtype. Report to dev team";
1177                }
1178            }
1179            # Nothing more to do for VE. No real launch
1180        } else {
1181            die "VE of type $vetype not supported. Report to the dev team";
1182        }
1183    }
1184}
1185
1186sub pb_build2v {
1187
1188my $vtype = shift;
1189
1190# Prepare the script to be executed on the VM/VE
1191# in $ENV{'PBDESTDIR'}/pbscript
1192#my ($ntp) = pb_conf_get($vtype."ntp");
1193#my $vntp = $ntp->{$ENV{'PBPROJ'}};
1194
1195open(SCRIPT,"> $ENV{'PBDESTDIR'}/pbscript") || die "Unable to create $ENV{'PBDESTDIR'}/pbscript";
1196print SCRIPT "#!/bin/bash\n";
1197print SCRIPT "echo ... Execution needed\n";
1198print SCRIPT "# This is in directory delivery\n";
1199print SCRIPT "# Setup the variables required for building\n";
1200print SCRIPT "export PBPROJ=$ENV{'PBPROJ'}\n";
1201print SCRIPT "# Preparation for pb\n";
1202print SCRIPT "mv .pbrc \$HOME\n";
1203print SCRIPT "cd ..\n";
1204# Force new date to be in the future compared to the date of the tar file by adding 1 minute
1205my @date=pb_get_date();
1206$date[1]++;
1207my $upddate = strftime("%m%d%H%M%Y", @date);
1208#print SCRIPT "echo Setting up date on $vntp...\n";
1209# Or use ntpdate if available TBC
1210print SCRIPT "sudo date $upddate\n";
1211# Get list of packages to build and get some ENV vars as well
1212my $ptr = pb_get_pkg();
1213@pkgs = @$ptr;
1214my $p = join(' ',@pkgs) if (@pkgs);
1215print SCRIPT "export PBPROJVER=$ENV{'PBPROJVER'}\n";
1216print SCRIPT "export PBPROJTAG=$ENV{'PBPROJTAG'}\n";
1217print SCRIPT "export PBPACKAGER=\"$ENV{'PBPACKAGER'}\"\n";
1218print SCRIPT "# Build\n";
1219print SCRIPT "echo Building packages on $vtype...\n";
1220print SCRIPT "pb -p $ENV{'PBPROJ'} build2pkg $p\n";
1221close(SCRIPT);
1222chmod 0755,"$ENV{'PBDESTDIR'}/pbscript";
1223
1224my ($v,$all) = pb_get_v($vtype);
1225
1226# Send tar files when we do a global generation
1227pb_build2ssh() if ($all == 1);
1228
1229my ($vmexist,$vmpid) = (undef,undef);
1230
1231foreach my $v (@$v) {
1232    if ($vtype eq "vm") {
1233        # Launch the VM
1234        ($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1235
1236        # Skip that VM if it something went wrong
1237        next if (($vmpid == 0) && ($vmexist == 0));
1238    }
1239    # Gather all required files to send them to the VM/VE
1240    # and launch the build through pbscript
1241    pb_log(2,"Calling send2target $vtype,$v,$vmexist,$vmpid\n");
1242    pb_send2target($vtype,"$v",$vmexist,$vmpid);
1243}
1244}
1245
1246
1247sub pb_newver {
1248
1249    die "-V Version parameter needed" if ((not defined $newver) || ($newver eq ""));
1250
1251    # Need this call for PBDIR
1252    my ($scheme2,$uri) = pb_cms_init($pbinit);
1253
1254    my ($pbconf) = pb_conf_get("pbconfurl");
1255    $uri = $pbconf->{$ENV{'PBPROJ'}};
1256    my ($scheme, $account, $host, $port, $path) = pb_get_uri($uri);
1257
1258    # Checking CMS repositories status
1259    my ($pburl) = pb_conf_get("pburl");
1260    ($scheme2, $account, $host, $port, $path) = pb_get_uri($pburl->{$ENV{'PBPROJ'}});
1261
1262    if ($scheme !~ /^svn/) {
1263        die "Only SVN is supported at the moment";
1264    }
1265    my $res = pb_cms_isdiff($scheme,$ENV{'PBROOTDIR'});
1266    die "ERROR: No differences accepted in CMS for $ENV{'PBROOTDIR'} before creating a new version" if ($res != 0);
1267
1268    $res = pb_cms_isdiff($scheme2,$ENV{'PBDIR'});
1269    die "ERROR: No differences accepted in CMS for $ENV{'PBDIR'} before creating a new version" if ($res != 0);
1270
1271    # Tree identical between PBCONFDIR and PBROOTDIR. The delta is what
1272    # we want to get for the root of the new URL
1273
1274    my $tmp = $ENV{'PBROOTDIR'};
1275    $tmp =~ s|^$ENV{'PBCONFDIR'}||;
1276
1277    my $newurl = "$uri/".dirname($tmp)."/$newver";
1278    # Should probably use projver in the old file
1279    my $oldver= basename($tmp);
1280
1281    # Checking pbcl files
1282    foreach my $f (<$ENV{'PBROOTDIR'}/*/pbcl>) {
1283        open(PBCL,$f) || die "Unable to open $f";
1284        my $foundnew = 0;
1285        while (<PBCL>) {
1286            $foundnew = 1 if (/^$newver \(/);
1287        }
1288        close(PBCL);
1289        die "ERROR: version $newver not found in $f" if ($foundnew == 0);
1290    }
1291
1292    # Duplicate and extract project-builder part
1293    pb_log(2,"Copying $uri/$tmp to $newurl\n");
1294    pb_cms_copy($scheme,"$uri/$tmp",$newurl);
1295    pb_log(2,"Checkout $newurl to $ENV{'PBROOTDIR'}/../$newver\n");
1296    pb_cms_up($scheme,"$ENV{'PBCONFDIR'}/..");
1297
1298    # Duplicate and extract project
1299    my $newurl2 = "$pburl->{$ENV{'PBPROJ'}}/".dirname($tmp)."/$newver";
1300
1301    pb_log(2,"Copying $pburl->{$ENV{'PBPROJ'}}/$tmp to $newurl2\n");
1302    pb_cms_copy($scheme,"$pburl->{$ENV{'PBPROJ'}}/$tmp",$newurl2);
1303    pb_log(2,"Checkout $newurl2 to $ENV{'PBDIR'}/../$newver\n");
1304    pb_cms_up($scheme,"$ENV{'PBDIR'}/..");
1305
1306    # Update the .pb file
1307    open(FILE,"$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb") || die "Unable to open $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb";
1308    open(OUT,"> $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new") || die "Unable to write to $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new";
1309    while(<FILE>) {
1310        s/^projver\s+$ENV{'PBPROJ'}\s*=\s*$oldver/projver $ENV{'PBPROJ'} = $newver/;
1311        pb_log(0,"Changing projver from $oldver to $newver in $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb\n") if (/^projver\s+$ENV{'PBPROJ'}\s*=\s*$oldver/);
1312        s/^testver/#testver/;
1313        pb_log(0,"Commenting testver in $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb\n") if (/^testver/);
1314        print OUT $_;
1315    }
1316    close(FILE);
1317    close(OUT);
1318    rename("$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new","$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb");
1319
1320    pb_log(2,"Checkin $ENV{'PBROOTDIR'}/../$newver\n");
1321    pb_cms_checkin($scheme,"$ENV{'PBROOTDIR'}/../$newver");
1322}
1323
1324#
1325# Return the list of VMs/VEs we are working on
1326# $all is a flag to know if we return all of them
1327# or only some (if all we publish also tar files in addition to pkgs
1328#
1329sub pb_get_v {
1330
1331my $vtype = shift;
1332my @v;
1333my $all = 0;
1334my $vlist;
1335my $pbv = 'PBV';
1336
1337if ($vtype eq "vm") {
1338    $vlist = "vmlist";
1339} elsif ($vtype eq "ve") {
1340    $vlist = "velist";
1341}
1342# Get VM/VE list
1343if ((not defined $ENV{$pbv}) || ($ENV{$pbv} =~ /^all$/)) {
1344    my ($ptr) = pb_conf_get($vlist);
1345    $ENV{$pbv} = $ptr->{$ENV{'PBPROJ'}};
1346    $all = 1;
1347}
1348pb_log(2,"$vtype: $ENV{$pbv}\n");
1349@v = split(/,/,$ENV{$pbv});
1350return(\@v,$all);
1351}
1352
1353# Function to create a potentialy missing pb account on the VM/VE, and adds it to sudo
1354# Needs to use root account to connect to the VM/VE
1355# pb will take your local public SSH key to access
1356# the pb account in the VM later on if needed
1357sub pb_setup_v {
1358
1359my $vtype = shift;
1360
1361my ($vm,$all) = pb_get_v($vtype);
1362
1363# Script generated
1364my $pbscript = "$ENV{'PBDESTDIR'}/setupv";
1365
1366foreach my $v (@$vm) {
1367    # Name of the account to deal with for VM/VE
1368    # Do not use the one passed potentially with -a
1369    my ($pbac) = pb_conf_get($vtype."login");
1370    my ($key,$zero0,$zero1,$zero2);
1371    my ($vmexist,$vmpid);
1372
1373    if ($vtype eq "vm") {
1374        # Prepare the key to be used and transfered remotely
1375        my $keyfile = pb_ssh_get(1);
1376       
1377        my ($vmhost,$vmport) = pb_conf_get("vmhost","vmport");
1378        my $nport = $vmport->{$ENV{'PBPROJ'}};
1379        $nport = "$pbport" if (defined $pbport);
1380   
1381        # Launch the VM
1382        ($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1383
1384        # Skip that VM if something went wrong
1385        return if (($vmpid == 0) && ($vmexist == 0));
1386   
1387        # Store the pub key part in a variable
1388        open(FILE,"$keyfile.pub") || die "Unable to open $keyfile.pub";
1389        ($zero0,$zero1,$zero2) = split(/ /,<FILE>);
1390        close(FILE);
1391
1392        $key = "\Q$zero1";
1393
1394        pb_system("cat $keyfile.pub | ssh -q -o UserKnownHostsFile=/dev/null -p $nport -i $keyfile root\@$vmhost->{$ENV{'PBPROJ'}} \"mkdir -p .ssh ; chmod 700 .ssh ; cat >> .ssh/authorized_keys ; chmod 600 .ssh/authorized_keys\"","Copying local keys to $vtype. This will require the root password");
1395        # once this is done, we can do what we want on the VM remotely
1396    }
1397   
1398    # Prepare the script to be executed on the VM/VE
1399    # in $ENV{'PBDESTDIR'}/setupv
1400   
1401    open(SCRIPT,"> $pbscript") || die "Unable to create $pbscript";
1402    print SCRIPT << 'EOF';
1403#!/usr/bin/perl -w
1404
1405use strict;
1406use File::Copy;
1407
1408our $debug;
1409our $LOG;
1410our $synmsg = "pbscript";
1411pb_log_init($debug, $LOG);
1412pb_temp_init();
1413
1414EOF
1415    if ($vtype eq "vm") {
1416        print SCRIPT << 'EOF';
1417# Removes duplicate in .ssh/authorized_keys of our key if needed
1418#
1419my $file1="$ENV{'HOME'}/.ssh/authorized_keys";
1420open(PBFILE,$file1) || die "Unable to open $file1";
1421open(PBOUT,"> $file1.new") || die "Unable to open $file1.new";
1422my $count = 0;
1423while (<PBFILE>) {
1424EOF
1425        print SCRIPT << "EOF";
1426    if (/ $key /) {
1427        \$count++;
1428    }
1429print PBOUT \$_ if ((\$count <= 1) || (\$_ !~ / $key /));
1430}
1431close(PBFILE);
1432close(PBOUT);
1433rename("\$file1.new",\$file1);
1434chmod 0600,\$file1;
1435EOF
1436    }
1437    print SCRIPT << 'EOF';
1438
1439# Adds $pbac->{$ENV{'PBPROJ'}} as an account if needed
1440#
1441my $file="/etc/passwd";
1442open(PBFILE,$file) || die "Unable to open $file";
1443my $found = 0;
1444while (<PBFILE>) {
1445EOF
1446    print SCRIPT << "EOF";
1447    \$found = 1 if (/^$pbac->{$ENV{'PBPROJ'}}:/);
1448EOF
1449    print SCRIPT << 'EOF';
1450}
1451close(PBFILE);
1452
1453if ( $found == 0 ) {
1454    if ( ! -d "/home" ) {
1455        pb_mkdir("/home");
1456    }
1457EOF
1458    print SCRIPT << "EOF";
1459pb_system("groupadd $pbac->{$ENV{'PBPROJ'}}","Adding group $pbac->{$ENV{'PBPROJ'}}");
1460pb_system("useradd $pbac->{$ENV{'PBPROJ'}} -g $pbac->{$ENV{'PBPROJ'}} -m -d /home/$pbac->{$ENV{'PBPROJ'}}","Adding user $pbac->{$ENV{'PBPROJ'}} (group $pbac->{$ENV{'PBPROJ'}} - home /home/$pbac->{$ENV{'PBPROJ'}}");
1461}
1462
1463# allow ssh entry to build
1464#
1465mkdir "/home/$pbac->{$ENV{'PBPROJ'}}/.ssh",0700;
1466# Allow those accessing root to access the build account
1467copy("\$ENV{'HOME'}/.ssh/authorized_keys","/home/$pbac->{$ENV{'PBPROJ'}}/.ssh/authorized_keys");
1468chmod 0600,".ssh/authorized_keys";
1469pb_system("chown -R $pbac->{$ENV{'PBPROJ'}}:$pbac->{$ENV{'PBPROJ'}} /home/$pbac->{$ENV{'PBPROJ'}}/.ssh","Finish setting up the SSH env for $pbac->{$ENV{'PBPROJ'}}");
1470
1471EOF
1472    print SCRIPT << 'EOF';
1473# No passwd for build account only keys
1474$file="/etc/shadow";
1475open(PBFILE,$file) || die "Unable to open $file";
1476open(PBOUT,"> $file.new") || die "Unable to open $file.new";
1477while (<PBFILE>) {
1478EOF
1479    print SCRIPT << "EOF";
1480    s/^$pbac->{$ENV{'PBPROJ'}}:\!\!:/$pbac->{$ENV{'PBPROJ'}}:*:/;
1481    s/^$pbac->{$ENV{'PBPROJ'}}:\!:/$pbac->{$ENV{'PBPROJ'}}:*:/; #SLES 9 e.g.
1482EOF
1483    print SCRIPT << 'EOF';
1484    print PBOUT $_;
1485}
1486close(PBFILE);
1487close(PBOUT);
1488rename("$file.new",$file);
1489chmod 0640,$file;
1490
1491# pb has to be added to portage group on gentoo
1492
1493# Adapt sudoers
1494$file="/etc/sudoers";
1495open(PBFILE,$file) || die "Unable to open $file";
1496open(PBOUT,"> $file.new") || die "Unable to open $file.new";
1497while (<PBFILE>) {
1498EOF
1499    print SCRIPT << "EOF";
1500    next if (/^$pbac->{$ENV{'PBPROJ'}}   /);
1501EOF
1502    print SCRIPT << 'EOF';
1503    s/Defaults[ \t]+requiretty//;
1504    print PBOUT $_;
1505}
1506close(PBFILE);
1507EOF
1508    print SCRIPT << "EOF";
1509# This is needed in order to be able to halt the machine from the $pbac->{$ENV{'PBPROJ'}} account at least
1510print PBOUT "$pbac->{$ENV{'PBPROJ'}}   ALL=(ALL) NOPASSWD:ALL\n";
1511EOF
1512    print SCRIPT << 'EOF';
1513close(PBOUT);
1514rename("$file.new",$file);
1515chmod 0440,$file;
1516
1517EOF
1518       
1519    my $SCRIPT = \*SCRIPT;
1520   
1521    pb_install_deps($SCRIPT);
1522   
1523    print SCRIPT << 'EOF';
1524# Suse wants sudoers as 640
1525if (($ddir eq "sles") || (($ddir eq "suse")) && ($dver ne "10.3")) {
1526    chmod 0640,$file;
1527}
1528
1529# Sync date
1530#system "/usr/sbin/ntpdate ntp.pool.org";
1531
1532pb_system("rm -rf perl-ProjectBuilder-* ; wget --passive-ftp ftp://ftp.mondorescue.org/src/perl-ProjectBuilder-latest.tar.gz ; tar xvfz perl-ProjectBuilder-latest.tar.gz ; cd perl-ProjectBuilder-* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf perl-ProjectBuilder-* ; rm -rf project-builder-* ; wget --passive-ftp ftp://ftp.mondorescue.org/src/project-builder-latest.tar.gz ; tar xvfz project-builder-latest.tar.gz ; cd project-builder-* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf project-builder-* ;","Building Project-Builder");
1533system "pb 2>&1 | head -5";
1534EOF
1535    if ((! $vmexist) && ($vtype eq "vm")) {
1536        print SCRIPT << 'EOF';
1537pb_system("sudo /sbin/halt -p","Halting the VM");
1538EOF
1539    }
1540   
1541    # Adds pb_distro_init from ProjectBuilder::Distribution
1542    foreach my $d (@INC) {
1543        my @f = ("$d/ProjectBuilder/Base.pm","$d/ProjectBuilder/Distribution.pm");
1544        foreach my $f (@f) {
1545            if (-f "$f") {
1546                open(PBD,"$f") || die "Unable to open $f";
1547                while (<PBD>) {
1548                        next if (/^package/);
1549                        next if (/^use Exporter/);
1550                        next if (/^use ProjectBuilder::/);
1551                        next if (/^our /);
1552                    print SCRIPT $_;
1553                }
1554                close(PBD);
1555            }
1556        }
1557    }
1558    close(SCRIPT);
1559    chmod 0755,"$pbscript";
1560
1561    # That build script needs to be run as root
1562    $pbaccount = "root";
1563    pb_script2v($pbscript,$vtype);
1564}
1565return;
1566}
1567
1568sub pb_install_deps {
1569
1570my $SCRIPT = shift;
1571
1572print {$SCRIPT} << 'EOF';
1573# We need to have that pb_distro_init function
1574# Get it from Project-Builder::Distribution
1575my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init(); 
1576print "distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n";
1577
1578# Get and install pb
1579my $insdm = "rm -rf Date-Manip* ; wget http://search.cpan.org/CPAN/authors/id/S/SB/SBECK/Date-Manip-5.54.tar.gz ; tar xvfz Date-Manip-5.54.tar.gz ; cd Date-Manip* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf Date-Manip*";
1580my $insmb = "rm -rf Module-Build* ; wget http://search.cpan.org/CPAN/authors/id/K/KW/KWILLIAMS/Module-Build-0.2808.tar.gz ; tar xvfz Module-Build-0.2808.tar.gz ; cd Module-Build* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf Module-Build*";
1581my $insfm = "rm -rf File-MimeInfo* ; wget http://search.cpan.org/CPAN/authors/id/P/PA/PARDUS/File-MimeInfo/File-MimeInfo-0.15.tar.gz ; tar xvfz File-MimeInfo-0.15.tar.gz ; cd File-MimeInfo* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf File-MimeInfo*";
1582my $insfb = "rm -rf File-Basedir* ; wget http://search.cpan.org/CPAN/authors/id/P/PA/PARDUS/File-BaseDir-0.03.tar.gz ; tar xvfz File-BaseDir-0.03.tar.gz ; cd File-BaseDir* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf File-BaseDir*";
1583my $cmtdm = "Installing Date-Manip perl module";
1584my $cmtmb = "Installing Module-Build perl module";
1585my $cmtfm = "Installing File-MimeInfo perl module";
1586my $cmtfb = "Installing File-Basedir perl module";
1587my $cmtall = "Installing required modules";
1588
1589if ( $ddir eq "fedora" ) {
1590    pb_system("yum clean all","Cleaning yum env");
1591    #system "yum update -y";
1592    my $arch=`uname -m`;
1593    my $opt = "";
1594    chomp($arch);
1595    if ($arch eq "x86_64") {
1596        $opt="--exclude=*.i?86";
1597    }
1598
1599    pb_system("yum -y $opt install rpm-build wget patch ntp sudo perl-DateManip perl-File-MimeInfo perl-ExtUtils-MakeMaker",$cmtall);
1600    if ($dver eq 4) {
1601        pb_system("$insmb","$cmtmb");
1602        pb_system("$insfm","$cmtfm");
1603        pb_system("$insfb","$cmtfb");
1604    }
1605} elsif (( $dfam eq "rh" ) || ($ddir eq "sles") || (($ddir eq "suse") && (($dver eq "10.1") || ($dver eq "10.0"))) || ($ddir eq "slackware")) {
1606    # Suppose pkg are installed already as no online mirror available
1607    pb_system("rpm -e lsb 2>&1 > /dev/null","Removing lsb package");
1608    pb_system("$insdm","$cmtdm");
1609    pb_system("$insmb","$cmtmb");
1610    pb_system("$insfm","$cmtfm");
1611    pb_system("$insfb","$cmtfb");
1612} elsif ($ddir eq "suse") { 
1613    # New OpenSuSE
1614    pb_system("$insmb","$cmtmb");
1615    pb_system("$insfm","$cmtfm");
1616    pb_system("$insfb","$cmtfb");
1617    pb_system("export TERM=linux ; liste=\"\" ; for i in make wget patch sudo perl-DateManip perl-File-HomeDir xntp; do rpm -q \$i 1> /dev/null 2> /dev/null ; if [ \$\? != 0 ]; then liste=\"\$liste \$i\"; fi; done; echo \"Liste: \$liste\" ; if [ \"\$liste\" != \"\" ]; then yast2 -i \$liste ; fi","$cmtall");
1618} elsif ( $dfam eq "md" ) {
1619        pb_system("urpmi.update -a ; urpmi --auto rpm-build wget sudo patch ntp-client perl-File-MimeInfo","$cmtall");
1620        if (($ddir eq "mandrake") && ($dver eq "10.1")) {
1621            pb_system("$insdm","$cmtdm");
1622        } else {
1623            pb_system("urpmi --auto perl-DateManip","$cmtdm");
1624        }
1625} elsif ( $dfam eq "du" ) {
1626    if (( $dver eq "3.1" ) && ($ddir eq "debian")) {
1627        #system "apt-get update";
1628        pb_system("$insfb","$cmtfb");
1629        pb_system("$insfm","$cmtfm");
1630        pb_system("apt-get -y install wget patch ssh sudo debian-builder dh-make fakeroot ntpdate libmodule-build-perl libdate-manip-perl","$cmtall");
1631    } else  {
1632        pb_system("apt-get update; apt-get -y install wget patch openssh-server dpkg-dev sudo debian-builder dh-make fakeroot ntpdate libfile-mimeinfo-perl libmodule-build-perl libdate-manip-perl","$cmtall");
1633    }
1634} elsif ( $dfam eq "gen" ) {
1635        #system "emerge -u system";
1636        pb_system("emerge wget sudo ntp DateManip File-MimeInfo","$cmtall");
1637} else {
1638    print "No pkg to install\n";
1639}
1640EOF
1641}
1642
1643# Return the SSH key file to use
1644# Potentially create it if needed
1645
1646sub pb_ssh_get {
1647
1648my $create = shift || 0;    # Do not create keys by default
1649
1650# Check the SSH environment
1651my $keyfile = undef;
1652
1653# We have specific keys by default
1654$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa";
1655if (!(-e $keyfile) && ($create eq 1)) {
1656    pb_system("ssh-keygen -q -b 1024 -N '' -f $keyfile -t dsa","Generating SSH keys for pb");
1657}
1658
1659$keyfile = "$ENV{'HOME'}/.ssh/id_rsa" if (-s "$ENV{'HOME'}/.ssh/id_rsa");
1660$keyfile = "$ENV{'HOME'}/.ssh/id_dsa" if (-s "$ENV{'HOME'}/.ssh/id_dsa");
1661$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa" if (-s "$ENV{'HOME'}/.ssh/pb_dsa");
1662die "Unable to find your public ssh key under $keyfile" if (not defined $keyfile);
1663return($keyfile);
1664}
1665
1666
1667# Returns the pid of a running VM command using a specific VM file
1668sub pb_check_ps {
1669    my $vmcmd = shift;
1670    my $vmm = shift;
1671    my $vmexist = 0;        # FALSE by default
1672
1673    open(PS, "ps auxhww|") || die "Unable to call ps";
1674    while (<PS>) {
1675        next if (! /$vmcmd/);
1676        next if (! /$vmm/);
1677        my ($void1, $void2);
1678        ($void1, $vmexist, $void2) = split(/ +/);
1679        last;
1680    }
1681    return($vmexist);
1682}
1683
1684
1685sub pb_extract_build_files {
1686
1687my $src=shift;
1688my $dir=shift;
1689my $ddir=shift;
1690my @files;
1691
1692if ($src =~ /tar\.gz$/) {
1693    pb_system("tar xfpz $src $dir","Extracting build files");
1694} elsif ($src =~ /tar\.bz2$/) {
1695    pb_system("tar xfpj $src $dir","Extracting build files");
1696} else {
1697    die "Unknown compression algorithm for $src";
1698}
1699opendir(DIR,"$dir") || die "Unable to open directory $dir";
1700foreach my $f (readdir(DIR)) {
1701    next if ($f =~ /^\./);
1702    move("$dir/$f","$ddir") || die "Unable to move $dir/$f to $ddir";
1703    pb_log(2,"mv $dir/$f $ddir\n");
1704    push @files,"$ddir/$f";
1705}
1706closedir(DIR);
1707# Not enough but still a first cleanup
1708pb_rm_rf("$dir");
1709return(@files);
1710}
1711
1712sub pb_list_bfiles {
1713
1714my $dir = shift;
1715my $pbpkg = shift;
1716my $bfiles = shift;
1717my $pkgfiles = shift;
1718my $supfiles = shift;
1719
1720opendir(BDIR,"$dir") || die "Unable to open dir $dir: $!";
1721foreach my $f (readdir(BDIR)) {
1722    next if ($f =~ /^\./);
1723    $bfiles->{$f} = "$dir/$f";
1724    $bfiles->{$f} =~ s~$ENV{'PBROOTDIR'}~~;
1725    if (defined $supfiles->{$pbpkg}) {
1726        $pkgfiles->{$f} = "$dir/$f" if ($f =~ /$supfiles->{$pbpkg}/);
1727    }
1728}
1729closedir(BDIR);
1730}
1731
1732
1733#
1734# Return the list of packages we are working on in a non CMS action
1735#
1736sub pb_get_pkg {
1737
1738my @pkgs = ();
1739
1740my ($var) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
1741@pkgs = keys %$var;
1742
1743pb_log(0,"Packages: ".join(',',@pkgs)."\n");
1744return(\@pkgs);
1745}
1746
17471;
Note: See TracBrowser for help on using the repository browser.