source: devel/pb/bin/pb @ 1173

Last change on this file since 1173 was 1173, checked in by Bruno Cornec, 9 years ago

-Add somr structure creation in case we start from nothing and fix display for deb pkg generation

  • Property svn:executable set to *
File size: 115.3 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';
13
14# The modules mentioned here are required by pb when used both
15# locally or inside a VE/VM
16# Additional required modules only used locally are called with a require
17# in their respective section
18use Getopt::Long qw(:config auto_abbrev no_ignore_case);
19use Data::Dumper;
20use English;
21use File::Basename;
22use File::Copy;
23use File::stat;
24use File::Temp qw(tempdir);
25use File::Find;
26use Time::localtime qw(localtime);
27use POSIX qw(strftime);
28use lib qw (lib);
29use ProjectBuilder::Version;
30use ProjectBuilder::Base;
31use ProjectBuilder::Display;
32use ProjectBuilder::Conf;
33use ProjectBuilder::Distribution;
34use ProjectBuilder::CMS;
35use ProjectBuilder::Env;
36use ProjectBuilder::Filter;
37use ProjectBuilder::Changelog;
38
39# Global variables
40my %opts;                   # CLI Options
41my $action;                 # action to realize
42my $test = "FALSE";         # Not used
43my $pbforce = 0;            # Force VE/VM rebuild
44my $pbsnap = 0;             # Do not use snapshot mode for VM/VE by default
45my $option = "";            # Not used
46my @pkgs;                   # list of packages
47my $pbtag;                  # Global Tag variable
48my $pbver;                  # Global Version variable
49my $pbscript;               # Name of the script
50my %pbver;                  # per package
51my %pbtag;                  # per package
52my $pbrev;                  # Global REVISION variable
53my $pbaccount;              # Login to use to connect to the VM
54my $pbtarget;               # Target os-ver-arch you want to build for
55my $pbport;                 # Port to use to connect to the VM
56my $newver;                 # New version to create
57my $iso = undef;            # ISO image for the VM to create
58
59my @date = pb_get_date();
60my $pbdate = strftime("%Y-%m-%d", @date);
61
62=pod
63
64=head1 NAME
65
66pb, aka project-builder.org - builds packages for your projects
67
68=head1 DESCRIPTION
69
70pb helps you build various packages directly from your project sources.
71Those sources could be handled by a CMS (Configuration Management System)
72such as Subversion, CVS, Git, Mercurial... or being a simple reference to a compressed tar file.
73It's based on a set of configuration files, a set of provided macros to help
74you keeping build files as generic as possible. For example, a single .spec
75file should be required to generate for all rpm based distributions, even
76if you could also have multiple .spec files if required.
77
78=head1 SYNOPSIS
79
80pb [-vhSq][-r pbroot][-p project][[-s script -a account -P port][-t os-ver-arch][-m os-ver-arch[,...]]][-g][-i iso] <action> [<pkg1> ...]
81
82pb [--verbose][--help][--man][--quiet][--snapshot][--revision pbroot][--project project][[--script script --account account --port port][--target os-ver-arch][--machine os-ver-arch[,...]]][--nographic][--iso iso] <action> [<pkg1> ...]
83
84=head1 OPTIONS
85
86=over 4
87
88=item B<-v|--verbose>
89
90Print a brief help message and exits.
91
92=item B<-q|--quiet>
93
94Do not print any output.
95
96=item B<-h|--help>
97
98Print a brief help message and exits.
99
100=item B<-S|--snapshot>
101
102Use the snapshot mode of VMs or VEs
103
104=item B<--man>
105
106Prints the manual page and exits.
107
108=item B<-t|--target os-ver-arch>
109
110Name of the target system you want to build for.
111All if none precised.
112
113=item B<-m|--machine os-ver-arch[,os-ver-arch,...]>
114
115Name of the Virtual Machines (VM) or Virtual Environments (VE) you want to build on (coma separated).
116All if none precised (or use the env variable PBV).
117
118=item B<-s|--script script>
119
120Name of the script you want to execute on the related VMs or VEs.
121
122=item B<-g|--nographic>
123
124Do not launch VMs in graphical mode.
125
126=item B<-i|--iso iso_image>
127
128Name of the ISO image of the distribution you want to install on the related VMs.
129
130=item B<-a|--account account>
131
132Name of the account to use to connect on the related VMs.
133
134=item B<-P|--port port_number>
135
136Port number to use to connect on the related VMs.\n";
137
138=item B<-p|--project project_name>
139
140Name of the project you're working on (or use the env variable PBPROJ)
141
142=item B<-r|--revision revision>
143
144Path Name of the project revision under the CMS (or use the env variable PBROOT)
145
146=item B<-V|--version new_version>
147
148New version of the project to create based on the current one.
149
150=back
151
152=head1 ARGUMENTS
153
154<action> can be:
155
156=over 4
157
158=item B<sbx2build>
159
160Create tar files for the project under your CMS.
161Current state of the exported content is taken.
162CMS supported are SVN, SVK, CVS, Git and Mercurial
163parameters are packages to build
164if not using default list
165
166=item B<cms2build>
167
168Create tar files for the project under your CMS.
169Current state of the CMS is taken.
170CMS supported are SVN, SVK, CVS, Git and Mercurial
171parameters are packages to build
172if not using default list
173
174=item B<build2pkg>
175
176Create packages for your running distribution
177
178=item B<cms2pkg>
179
180cms2build + build2pkg
181
182=item B<sbx2pkg>
183
184sbx2build + build2pkg
185
186=item B<build2ssh>
187
188Send the tar files to a SSH host
189
190=item B<sbx2ssh>
191
192sbx2build + build2ssh
193
194=item B<cms2ssh>
195
196cms2build + build2ssh
197
198=item B<pkg2ssh>
199
200Send the packages built to a SSH host
201
202=item B<build2vm>
203
204Create packages in VMs, launching them if needed
205and send those packages to a SSH host once built
206VM type supported are QEMU
207
208=item B<build2ve>
209
210Create packages in VEs, creating it if needed
211and send those packages to a SSH host once built
212
213=item B<sbx2vm>
214
215sbx2build + build2vm
216
217=item B<sbx2ve>
218
219sbx2build + build2ve
220
221=item B<cms2vm>
222
223cms2build + build2vm
224
225=item B<cms2ve>
226
227cms2build + build2ve
228
229=item B<launchvm>
230
231Launch one virtual machine
232
233=item B<launchve>
234
235Launch one virtual environment
236
237=item B<script2vm>
238
239Launch one virtual machine if needed
240and executes a script on it
241
242=item B<script2ve>
243
244Execute a script in a virtual environment
245
246=item B<newvm>
247
248Create a new virtual machine
249
250=item B<newve>
251
252Create a new virtual environment
253
254=item B<setupvm>
255
256Setup a virtual machine for pb usage
257
258=item B<setupve>
259
260Setup a virtual environment for pb usage
261
262=item B<sbx2setupvm>
263
264Setup a virtual machine for pb usage using the sandbox version of pb instead of the latest stable
265Reserved to dev team.
266
267=item B<sbx2setupve>
268
269Setup a virtual environment for pb usage using the sandbox version of pb instead of the latest stable
270Reserved to dev team.
271
272=item B<snapvm>
273
274Snapshot a virtual machine for pb usage
275
276=item B<snapve>
277
278Snapshot a virtual environment for pb usage
279
280=item B<updatevm>
281
282Update the distribution in the virtual machine
283
284=item B<updateve>
285
286Update the distribution in the virtual environment
287
288=item B<test2pkg>
289
290Test a package locally
291
292=item B<test2vm>
293
294Test a package in a virtual machine
295
296=item B<test2ve>
297
298Test a package in a virtual environment
299
300=item B<newver>
301
302Create a new version of the project derived
303from the current one
304
305=item B<newproj>
306
307Create a new project and a template set of
308configuration files under pbconf
309
310=item B<announce>
311
312Announce the availability of the project through various means
313
314=item B<sbx2webssh>
315
316Create tar files for the website under your CMS.
317Current state of the exported content is taken.
318Deliver the content to the target server using ssh from the exported dir.
319
320=item B<cms2webssh>
321
322Create tar files for the website from your CMS.
323Deliver the content to the target server using ssh from the DVCS.
324
325=item B<sbx2webpkg>
326
327Create tar files for the website under your CMS.
328Current state of the exported content is taken.
329
330=item B<cms2webpkg>
331
332Create tar files for the website under your CMS.
333
334=item B<clean>
335
336Purge the build and delivery directories related to the current project
337
338=back
339
340<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).
341
342=head1 WEB SITES
343
344The 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/>.
345
346=head1 USER MAILING LIST
347
348None exists for the moment.
349
350=head1 CONFIGURATION FILES
351
352Each pb user may have a configuration in F<$HOME/.pbrc>. The values in this file may overwrite any other configuration file value.
353
354Here is an example of such a configuration file:
355
356 #
357 # Define for each project the URL of its pbconf repository
358 # No default option allowed here as they need to be all different
359 #
360 # URL of the pbconf content
361 # This is the format of a classical URL with the extension of additional schema such as
362 # svn+ssh, cvs+ssh, ...
363 #
364 pbconfurl linuxcoe = cvs+ssh://:ext:bcornec@linuxcoe.cvs.sourceforge.net:/cvsroot/linuxcoe/pbconf
365
366 # This is normaly defined in the project's configuration file
367 # Url of the project
368 #
369 pburl linuxcoe = cvs+ssh://:ext:bcornec@linuxcoe.cvs.sourceforge.net:/cvsroot/linuxcoe
370 
371 # All these URLs needs to be defined here as the are the entry point
372 # for how to build packages for the project
373 #
374 pbconfurl pb = svn+ssh://svn.project-builder.org/mondo/svn/pb/pbconf
375 pbconfurl mondorescue = svn+ssh://svn.project-builder.org/mondo/svn/project-builder/mondorescue/pbconf
376 pbconfurl collectl = svn+ssh://bruno@svn.mondorescue.org/mondo/svn/project-builder/collectl/pbconf
377 pbconfurl netperf = svn+ssh://svn.mondorescue.org/mondo/svn/project-builder/netperf/pbconf
378 
379 # Under that dir will take place everything related to pb
380 # If you want to use VMs/chroot/..., then use $ENV{'HOME'} to make it portable
381 # to your VMs/chroot/...
382 # if not defined then /var/cache
383 pbdefdir default = $ENV{'HOME'}/project-builder
384 pbdefdir pb = $ENV{'HOME'}
385 pbdefdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs
386 pbdefdir mondorescue = $ENV{'HOME'}/mondo/svn
387 
388 # pbconfdir points to the directory where the CMS content of the pbconfurl is checked out
389 # If not defined, pbconfdir is under pbdefdir/pbproj/pbconf
390 pbconfdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs/pbconf
391 pbconfdir mondorescue = $ENV{'HOME'}/mondo/svn/pbconf
392 
393 # pbdir points to the directory where the CMS content of the pburl is checked out
394 # If not defined, pbdir is under pbdefdir/pbproj
395 # Only defined if we have access to the dev of the project
396 pbdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs
397 pbdir mondorescue = $ENV{'HOME'}/mondo/svn
398 
399 # -daemonize doesn't work with qemu 0.8.2
400 vmopt default = -m 384
401
402=head1 AUTHORS
403
404The Project-Builder.org team L<http://trac.project-builder.org/> lead by Bruno Cornec L<mailto:bruno@project-builder.org>.
405
406=head1 COPYRIGHT
407
408Project-Builder.org is distributed under the GPL v2.0 license
409described in the file C<COPYING> included with the distribution.
410
411=cut
412
413# ---------------------------------------------------------------------------
414
415my ($projectbuilderver,$projectbuilderrev) = pb_version_init();
416my $appname = "pb";
417
418# Initialize the syntax string
419
420pb_syntax_init("$appname (aka project-builder.org) Version $projectbuilderver-$projectbuilderrev\n");
421
422GetOptions("help|?|h" => \$opts{'h'}, 
423        "man" => \$opts{'man'},
424        "verbose|v+" => \$opts{'v'},
425        "snapshot|S" => \$opts{'S'},
426        "quiet|q" => \$opts{'q'},
427        "log-files|l=s" => \$opts{'l'},
428        "force|f" => \$opts{'f'},
429        "account|a=s" => \$opts{'a'},
430        "revision|r=s" => \$opts{'r'},
431        "script|s=s" => \$opts{'s'},
432        "machines|mock|m=s" => \$opts{'m'},
433        "target|t=s" => \$opts{'t'},
434        "nographic|g" => \$opts{'g'},
435        "port|P=i" => \$opts{'P'},
436        "project|p=s" => \$opts{'p'},
437        "iso|i=s" => \$opts{'i'},
438        "version|V=s" => \$opts{'V'},
439) || pb_syntax(-1,0);
440
441if (defined $opts{'h'}) {
442    pb_syntax(0,1);
443}
444if (defined $opts{'man'}) {
445    pb_syntax(0,2);
446}
447if (defined $opts{'v'}) {
448    $pbdebug = $opts{'v'};
449}
450if (defined $opts{'f'}) {
451    $pbforce=1;
452}
453if (defined $opts{'q'}) {
454    $pbdebug=-1;
455}
456if (defined $opts{'S'}) {
457    $pbsnap=1;
458}
459if (defined $opts{'l'}) {
460    open(pbLOG,"> $opts{'l'}") || die "Unable to log to $opts{'l'}: $!";
461    $pbLOG = \*pbLOG;
462    $pbdebug = 0  if ($pbdebug == -1);
463    }
464pb_log_init($pbdebug, $pbLOG);
465pb_display_init("text","");
466
467# Handle root of the project if defined
468if (defined $opts{'r'}) {
469    $ENV{'PBROOTDIR'} = $opts{'r'};
470}
471# Handle virtual machines if any
472if (defined $opts{'m'}) {
473    $ENV{'PBV'} = $opts{'m'};
474}
475if (defined $opts{'s'}) {
476    $pbscript = $opts{'s'};
477}
478if (defined $opts{'a'}) {
479    $pbaccount = $opts{'a'};
480    die "option -a requires a -s script option" if (not defined $pbscript);
481}
482if (defined $opts{'P'}) {
483    $pbport = $opts{'P'};
484}
485if (defined $opts{'V'}) {
486    $newver = $opts{'V'};
487}
488if (defined $opts{'i'}) {
489    $iso = $opts{'i'};
490}
491if (defined $opts{'t'}) {
492    $pbtarget = $opts{'t'};
493}
494
495# Get Action
496$action = shift @ARGV;
497die pb_syntax(-1,1) if (not defined $action);
498
499my ($filteredfiles, $supfiles, $defpkgdir, $extpkgdir);
500my $pbinit = undef;
501$pbinit = 1 if ($action =~ /^newproj$/);
502
503# Handles project name if any
504# And get global params
505($filteredfiles, $supfiles, $defpkgdir, $extpkgdir) = pb_env_init($opts{'p'},$pbinit,$action);
506
507#
508# Check for command requirements
509#
510my ($req,$opt,$pbpara) = pb_conf_get_if("oscmd","oscmdopt","pbparallel");
511pb_check_requirements($req,$opt,$appname);
512
513#
514# Check if we can launch some actions in // with Parallel::ForkManager
515#
516my $pbparallel = $pbpara->{$appname} if (defined $pbpara);
517if (not defined $pbparallel) {
518    eval
519    {
520        require Sys::CPU;
521        Sys::CPU->import();
522    };
523    if ($@) {
524        # Sys::CPU not found, defaulting to 1
525        pb_log(1,"ADVISE: Install Sys::CPU to benefit from automatic parallelism optimization.\nOr use pbparallel in your pb.conf file\nOnly 1 process at a time for the moment\n");
526        $pbparallel = 1;
527    } else {
528        # Using the number of cores
529        $pbparallel = Sys::CPU::cpu_count();
530        pb_log(1,"Using parallel mode with $pbparallel processes\n");
531    }
532}
533
534eval
535{
536    require Parallel::ForkManager;
537    Parallel::ForkManager->import();
538};
539# Parallel::ForkManager not found so no // actions
540if ($@) {
541    $pbparallel = undef;
542    pb_log(1,"ADVISE: Install Parallel::ForkManager to benefit from automatic parallelism optimization.\nOnly 1 process at a time for the moment\n");
543}
544
545pb_log(0,"Project: $ENV{'PBPROJ'}\n");
546pb_log(0,"Action: $action\n");
547
548# Act depending on action
549if ($action =~ /^cms2build$/) {
550    pb_cms2build("CMS");
551} elsif ($action =~ /^sbx2build$/) {
552    pb_cms2build("SandBox");
553} elsif ($action =~ /^build2pkg$/) {
554    pb_build2pkg();
555} elsif ($action =~ /^cms2pkg$/) {
556    pb_cms2build("CMS");
557    pb_build2pkg();
558} elsif ($action =~ /^sbx2pkg$/) {
559    pb_cms2build("SandBox");
560    pb_build2pkg();
561} elsif ($action =~ /^build2ssh$/) {
562    pb_build2ssh();
563} elsif ($action =~ /^cms2ssh$/) {
564    pb_cms2build("CMS");
565    pb_build2ssh();
566} elsif ($action =~ /^sbx2ssh$/) {
567    pb_cms2build("SandBox");
568    pb_build2ssh();
569} elsif ($action =~ /^pkg2ssh$/) {
570    pb_pkg2ssh();
571} elsif ($action =~ /^build2ve$/) {
572    pb_build2v("ve","build");
573} elsif ($action =~ /^build2vm$/) {
574    pb_build2v("vm","build");
575} elsif ($action =~ /^cms2ve$/) {
576    pb_cms2build("CMS");
577    pb_build2v("ve","build");
578} elsif ($action =~ /^sbx2ve$/) {
579    pb_cms2build("SandBox");
580    pb_build2v("ve","build");
581} elsif ($action =~ /^cms2vm$/) {
582    pb_cms2build("CMS");
583    pb_build2v("vm","build");
584} elsif ($action =~ /^sbx2vm$/) {
585    pb_cms2build("SandBox");
586    pb_build2v("vm","build");
587} elsif ($action =~ /^launchvm$/) {
588    pb_launchv("vm",$ENV{'PBV'},0);
589} elsif ($action =~ /^launchve$/) {
590    pb_launchv("ve",$ENV{'PBV'},0);
591} elsif ($action =~ /^script2vm$/) {
592    pb_script2v($pbscript,"vm");
593} elsif ($action =~ /^script2ve$/) {
594    pb_script2v($pbscript,"ve");
595} elsif ($action =~ /^newver$/) {
596    pb_newver();
597} elsif ($action =~ /^newve$/) {
598    pb_launchv("ve",$ENV{'PBV'},1);
599} elsif ($action =~ /^newvm$/) {
600    pb_launchv("vm",$ENV{'PBV'},1);
601    pb_log(0, "Please ensure that sshd is running in your VM by default\n");
602    pb_log(0, "and that it allows remote root login (PermitRootLogin yes in /etc/ssh/sshd_config)\n");
603    pb_log(0, "Also ensure that network is up, firewalling correctly configured\n");
604    pb_log(0, "and perl, sudo, ntpdate and scp/ssh installed\n");
605    pb_log(0, "You should then be able to login with ssh -p VMPORT root\@localhost (if VM started with pb)\n");
606} elsif ($action =~ /^setupve$/) {
607    pb_setup2v("ve");
608} elsif ($action =~ /^setupvm$/) {
609    pb_setup2v("vm");
610} elsif ($action =~ /^sbx2setupve$/) {
611    die "This feature is limited to the pb project" if ($ENV{'PBPROJ'} ne $appname);
612    pb_cms2build("SandBox");
613    pb_setup2v("ve","SandBox");
614} elsif ($action =~ /^sbx2setupvm$/) {
615    die "This feature is limited to the pb project" if ($ENV{'PBPROJ'} ne $appname);
616    pb_cms2build("SandBox");
617    pb_setup2v("vm","SandBox");
618} elsif ($action =~ /^updateve$/) {
619    pb_update2v("ve");
620} elsif ($action =~ /^updatevm$/) {
621    pb_update2v("vm");
622} elsif ($action =~ /^snapve$/) {
623    pb_snap2v("ve");
624} elsif ($action =~ /^snapvm$/) {
625    pb_snap2v("vm");
626} elsif ($action =~ /^test2pkg$/) {
627    pb_test2pkg();
628} elsif ($action =~ /^test2ve$/) {
629    pb_build2v("ve","test");
630} elsif ($action =~ /^test2vm$/) {
631    pb_build2v("vm","test");
632} elsif ($action =~ /^newproj$/) {
633    # Nothing to do - already done in pb_env_init
634} elsif ($action =~ /^clean$/) {
635    pb_clean();
636} elsif ($action =~ /^announce$/) {
637    # For announce only. Require avoids the systematic load of these modules
638    require DBI;
639    require DBD::SQLite;
640
641    pb_announce();
642} elsif ($action =~ /^sbx2webpkg$/) {
643    require DBI;
644    require DBD::SQLite;
645
646    pb_cms2build("SandBox","Web");
647} elsif ($action =~ /^sbx2webssh$/) {
648    require DBI;
649    require DBD::SQLite;
650
651    pb_cms2build("SandBox","Web");
652    pb_send2target("Web");
653} elsif ($action =~ /^cms2webpkg$/) {
654    require DBI;
655    require DBD::SQLite;
656
657    pb_cms2build("CMS","Web");
658} elsif ($action =~ /^cms2webssh$/) {
659    require DBI;
660    require DBD::SQLite;
661
662    pb_cms2build("CMS","Web");
663    pb_send2target("Web");
664} else {
665    pb_log(0,"\'$action\' is not available\n");
666    pb_syntax(-2,1);
667}
668
669sub pb_cms2build {
670
671    my $param = shift || undef;
672    my $web = shift || undef;
673
674    my $pkg;
675    my @pkgs;
676    my $webdir;
677
678    my %pkgs;
679    my %pb;             # Structure to store conf info
680
681    die "pb_cms2build requires a parameter: SandBox or CMS" if (not defined $param);
682
683    # If Website, then pkg is only the website
684    if (defined $web) {
685        ($webdir) = pb_conf_get("webdir");
686        pb_log(2,"webdir: ".Dumper($webdir)."\n");
687        $pkgs[0] = $webdir->{$ENV{'PBPROJ'}};
688        $extpkgdir = $webdir;
689        pb_log(0,"Package: $pkgs[0]\n");
690    } else {
691        $pkg = pb_cms_get_pkg($defpkgdir,$extpkgdir);
692        @pkgs = @$pkg;
693    }
694
695    my ($scheme, $uri) = pb_cms_init($pbinit,$param);
696
697    # We need 2 lines here
698    my ($pkgv, $pkgt, $testver) = pb_conf_get_if("pkgver","pkgtag","testver");
699
700    # declare packager and repo for filtering
701    # TODO: Is pbrepo needed so early in the process ?
702    my ($tmp1, $tmp2) = pb_conf_get("pbpackager","pbrepo");
703    $ENV{'PBPACKAGER'} = $tmp1->{$ENV{'PBPROJ'}};
704    $ENV{'PBREPO'} = $tmp2->{$ENV{'PBPROJ'}};
705
706    foreach my $pbpkg (@pkgs) {
707        $ENV{'PBPKG'} = $pbpkg;
708
709        if ((defined $pkgv) && (defined $pkgv->{$pbpkg})) {
710            $pbver = $pkgv->{$pbpkg};
711        } else {
712            $pbver = $ENV{'PBPROJVER'};
713        }
714        # If it's a test version, then tag == 0.date
715        if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
716            $pbtag = "0.".strftime("%Y%m%d%H%M%S", @date);
717            $ENV{'PBPROJTAG'} = $pbtag;
718        } elsif ((defined $pkgt) && (defined $pkgt->{$pbpkg})) {
719            $pbtag = $pkgt->{$pbpkg};
720        } else {
721            $pbtag = $ENV{'PBPROJTAG'};
722        }
723
724        $pbrev = $ENV{'PBREVISION'};
725        pb_log(0,"\n");
726        pb_log(0,"Management of $pbpkg $pbver-$pbtag (rev $pbrev)\n");
727        die "Unable to get env var PBDESTDIR" if (not defined $ENV{'PBDESTDIR'});
728
729        my $dest = "$ENV{'PBDESTDIR'}/$pbpkg-$pbver";
730        # Create the structure if needed
731        pb_mkdir_p($dest);
732        # Clean up dest if necessary. The export will recreate it
733        pb_rm_rf($dest) if (-d $dest);
734
735        # Export CMS tree for the concerned package to dest
736        # And generate some additional files
737        $OUTPUT_AUTOFLUSH=1;
738
739        # computes in which dir we have to work
740        my $dir = $defpkgdir->{$pbpkg};
741        $dir = $extpkgdir->{$pbpkg} if (not defined $dir);
742        $dir = $webdir->{$ENV{'PBPROJ'}} if (defined $web);
743        die "Variable \$dir not defined. Please report to dev team with log of a verbose run and this info ".Dumper($webdir) if (not defined $dir);
744        pb_log(2,"def:".Dumper($defpkgdir)." ext: ".Dumper($extpkgdir)." \n");
745
746        # Exporting content from CMS
747        my $sourcedir = undef;
748        my $sourceuri = $uri;
749        if ($param eq "SandBox") {
750            # Point to the local instance
751            $sourcedir = "$ENV{'PBDIR'}/$dir";
752        } else {
753            # Get it from a subdir of the URI with same version as localy but different root
754            $sourceuri = "$ENV{'PBDIR'}/$dir";
755            $sourceuri =~ s|^$ENV{'PBPROJDIR'}/|$uri|;
756        }
757        my $preserve = pb_cms_export($sourceuri,$sourcedir,$dest);
758
759        # Generated fake content for test versions to speed up stuff
760        my $chglog;
761
762        # Get project info on authors and log file
763        $chglog = "$ENV{'PBROOTDIR'}/$pbpkg/pbcl";
764        $chglog = "$ENV{'PBROOTDIR'}/pbcl" if (! -f $chglog);
765        $chglog = undef if (! -f $chglog);
766
767        my $authors = "$ENV{'PBROOTDIR'}/$pbpkg/pbauthors";
768        $authors = "$ENV{'PBROOTDIR'}/pbauthors" if (! -f $authors);
769        $authors = "/dev/null" if (! -f $authors);
770
771        # Extract cms log history and store it
772        if ((defined $chglog) && (! -f "$dest/NEWS")) {
773            pb_log(2,"Generating NEWS file from $chglog\n");
774            copy($chglog,"$dest/NEWS") || die "Unable to create $dest/NEWS";
775        }
776        pb_cms_log($scheme,"$ENV{'PBDIR'}/$dir",$dest,$chglog,$authors,$testver);
777
778        my %build;
779        my %patches;
780        my %sources;
781        # We want to at least build for the underlying distro
782        # except if a target was given, in which case we only build for it
783        my ($tdir,$tver,$tarch);
784        ($tdir,$tver,$tarch) = split(/-/,$pbtarget) if (defined ($pbtarget));
785
786        my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf, $pbupd, $pbins, $arch) = pb_distro_init($tdir,$tver,$tarch);
787        my $tmpl = "$ddir-$dver-$arch,";
788
789        # Get list of distributions for which we need to generate build files if no target
790        if (not defined ($pbtarget)) {
791            my @pt = pb_conf_get_if("vmlist","velist");
792            if (defined $pt[0]->{$ENV{'PBPROJ'}}) {
793                $tmpl .= $pt[0]->{$ENV{'PBPROJ'}};
794            }
795            if (defined $pt[1]->{$ENV{'PBPROJ'}}) {
796                # The 2 lists needs to be grouped with a ',' separating them
797                if ($tmpl ne "") {
798                    $tmpl .= ",";
799                }
800                $tmpl .= $pt[1]->{$ENV{'PBPROJ'}} 
801            }
802        }
803   
804        # Setup %pb structure to allow filtering later on, on files using that structure
805        $pb{'tag'} = $pbtag;
806        $pb{'rev'} = $pbrev;
807        $pb{'ver'} = $pbver;
808        $pb{'pkg'} = $pbpkg;
809        $pb{'realpkg'} = $pbpkg;
810        $pb{'date'} = $pbdate;
811        $pb{'defpkgdir'} = $defpkgdir;
812        $pb{'extpkgdir'} = $extpkgdir;
813        $pb{'chglog'} = $chglog;
814        $pb{'packager'} = $ENV{'PBPACKAGER'};
815        $pb{'proj'} = $ENV{'PBPROJ'};
816        $pb{'repo'} = $ENV{'PBREPO'};
817        $pb{'patches'} = \%patches;
818        $pb{'sources'} = \%sources;
819        pb_log(2,"DEBUG: pb: ".Dumper(%pb)."\n");
820   
821        # Do not do that for website
822        if (not defined $web) {
823            pb_log(0,"Build files are being generated for ...\n");
824            my %virt;
825            # De-duplicate similar VM and VE
826            foreach my $d (split(/,/,$tmpl)) {
827                # skip ill-formatted vms (name-ver-arch)
828                next if ($d !~ /-/);
829                $virt{$d} = $d;
830            }
831
832            # Try to use // processing here
833            my $pm = new Parallel::ForkManager($pbparallel) if (defined $pbparallel);
834
835            foreach my $d (keys %virt) {
836                $pm->start and next if (defined $pbparallel);
837                my ($name,$ver,$arch) = split(/-/,$d);
838                pb_log(0,"Bad format for $d") if ((not defined $name) || (not defined $ver) || (not defined $arch)) ;
839                chomp($arch);
840                my ($ddir, $dver, $dfam);
841                ($ddir, $dver, $dfam, $pb{'dtype'}, $pb{'os'}, $pb{'suf'}, $pb{'upd'}, $pb{'arch'}) = pb_distro_init($name,$ver,$arch);
842                pb_log(2,"DEBUG: distro tuple: ".Dumper($ddir, $dver, $dfam, $pb{'dtype'}, $pb{'suf'})."\n");
843                pb_log(2,"DEBUG Filtering PBDATE => $pbdate, PBTAG => $pbtag, PBVER => $pbver\n");
844   
845                # We need to compute the real name of the package
846                my $pbrealpkg = pb_cms_get_real_pkg($pbpkg,$pb{'dtype'});
847                $pb{'realpkg'} = $pbrealpkg;
848                pb_log(1,"Virtual package $pbpkg has a real package name of $pbrealpkg on $ddir-$dver\n") if ($pbrealpkg ne $pbpkg);
849   
850                # Filter build files from the less precise up to the most with overloading
851                # Filter all files found, keeping the name, and generating in dest
852   
853                # Find all build files first relatively to PBROOTDIR
854                # Find also all specific files referenced in the .pb conf file
855                my %bfiles = ();
856                my %pkgfiles = ();
857                $build{"$ddir-$dver-$arch"} = "yes";
858   
859                if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$pb{'dtype'}") {
860                    pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$pb{'dtype'}",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
861                } elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$dfam") {
862                    pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$dfam",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
863                } elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$ddir") {
864                    pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$ddir",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
865                } elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$ddir-$dver") {
866                    pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$ddir-$dver",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
867                } elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$ddir-$dver-$arch") {
868                    pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$ddir-$dver-$arch",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
869                } else {
870                    $build{"$ddir-$dver-$arch"} = "no";
871                    next;
872                }
873                pb_log(2,"DEBUG bfiles: ".Dumper(\%bfiles)."\n");
874   
875                # Get all filters to apply
876                my $ptr = pb_get_filters($pbpkg, $pb{'dtype'}, $dfam, $ddir, $dver);
877   
878                # Apply now all the filters on all the files concerned
879                # destination dir depends on the type of file
880                if (defined $ptr) {
881                    # For patch support
882                    $pb{'tuple'} = "$ddir-$dver-$arch";
883                    foreach my $f (values %bfiles,values %pkgfiles) {
884                        pb_filter_file("$ENV{'PBROOTDIR'}/$f",$ptr,"$dest/pbconf/$ddir-$dver-$arch/".basename($f),\%pb);
885                    }
886                }
887                pb_list_sfiles("$ENV{'PBROOTDIR'}/$pbpkg/pbpatch", \%patches, $pb{'dtype'}, $dfam, $ddir, $dver, $arch, "$ENV{'PBROOTDIR'}/$pbpkg/pbextpatch");
888                pb_list_sfiles("$ENV{'PBROOTDIR'}/$pbpkg/pbsrc", \%sources, $pb{'dtype'}, $dfam, $ddir, $dver, $arch, "$ENV{'PBROOTDIR'}/$pbpkg/pbextsrc");
889
890                $pm->finish if (defined $pbparallel);
891            }
892            $pm->wait_all_children if (defined $pbparallel);
893            my @found;
894            my @notfound;
895            foreach my $b (keys %build) {
896                push @found,$b if ($build{$b} =~ /yes/);
897                push @notfound,$b if ($build{$b} =~ /no/);
898            }
899            pb_log(0," ... ".join(',',sort(@found))."\n");
900            pb_log(0,"No Build files found for ".join(',',sort(@notfound))."\n") if (@notfound);
901            pb_log(2,"DEBUG: patches: ".Dumper(%patches)."\n");
902            pb_log(2,"DEBUG: sources: ".Dumper(%sources)."\n");
903        }
904
905        # Get the generic filter (all.pbf) and
906        # apply those to the non-build files including those
907        # generated by pbinit if applicable
908
909        # Get only all.pbf filter
910        my $ptr = pb_get_filters($pbpkg);
911
912        my $liste ="";
913        if (defined $filteredfiles->{$pbpkg}) {
914            foreach my $f (split(/,/,$filteredfiles->{$pbpkg})) {
915                pb_filter_file_inplace($ptr,"$dest/$f",\%pb);
916                $liste = "$f $liste";
917            }
918        }
919        pb_log(2,"Files ".$liste."have been filtered\n");
920
921        # Do not do that for website
922        if (not defined $web) {
923            my %tmp;
924            my $warnptcflag = 0;
925            my $warnsrcflag = 0;
926            # Filter potential patches (local + remote)
927            pb_log(0,"Delivering and compressing patches ");
928            foreach my $v (keys %patches) {
929                pb_mkdir_p("$dest/pbconf/$v/pbpatch");
930                foreach my $pf (split(/,/,$patches{$v})) {
931                    my $pp = basename($pf);
932                    if ($param eq "SandBox") {
933                        $warnptcflag = 1;
934                    }
935                    pb_cms_export($pf,undef,"$dest/pbconf/$v/pbpatch");
936                    pb_filter_file_inplace($ptr,"$dest/pbconf/$v/pbpatch/$pp",\%pb);
937                    pb_system("gzip -9f $dest/pbconf/$v/pbpatch/$pp","","quiet");
938                    $tmp{$pf} = "";
939                }
940            }
941            pb_log(0,"Delivering additional sources ");
942            foreach my $v (keys %sources) {
943                pb_mkdir_p("$dest/pbconf/$v/pbsrc");
944                foreach my $pf (split(/,/,$sources{$v})) {
945                    my $pp = basename($pf);
946                    if ($param eq "SandBox") {
947                        $warnsrcflag = 1;
948                    }
949                    pb_cms_export($pf,undef,"$dest/pbconf/$v/pbsrc");
950                    pb_filter_file_inplace($ptr,"$dest/pbconf/$v/pbsrc/$pp",\%pb);
951                    $tmp{$pf} = "";
952                }
953            }
954            foreach my $v (keys %tmp) {
955                pb_log(0,"$v ");
956            }
957            pb_log(0,"\n");
958            pb_log(0,"WARNING: Patches are always taken from repository not local export\n") if ($warnptcflag == 1);
959            pb_log(0,"WARNING: Sources are always taken from repository not local export\n") if ($warnsrcflag == 1);
960        } else {
961            # Instead call News generation
962            pb_web_news2html($dest);
963            # And create an empty pbconf
964            pb_mkdir_p("$dest/pbconf");
965            # And prepare the pbscript to execute remotely
966            open(SCRIPT,"> $ENV{'PBTMP'}/pbscript") || die "Unable to create $ENV{'PBTMP'}/pbscript";
967            print SCRIPT "#!/bin/bash\n";
968            print SCRIPT "#set -x\n";
969            print SCRIPT "echo ... Extracting Website content\n";
970            print SCRIPT "find . -type f | grep -Ev '^./$pbpkg-$pbver.tar.gz|^./pbscript' | xargs rm -f non-existent\n";
971            print SCRIPT "find * -type d -depth | xargs rmdir 2> /dev/null \n";
972            print SCRIPT "tar xfz $pbpkg-$pbver.tar.gz\n";
973            print SCRIPT "mv $pbpkg-$pbver/* .\n";
974            print SCRIPT "rm -f $pbpkg-$pbver.tar.gz\n";
975            print SCRIPT "rmdir $pbpkg-$pbver\n";
976            close(SCRIPT);
977            chmod 0755,"$ENV{'PBTMP'}/pbscript";
978        }
979
980        # Prepare the dest directory for archive
981        if (-x "$ENV{'PBROOTDIR'}/$pbpkg/pbinit") {
982            pb_filter_file("$ENV{'PBROOTDIR'}/$pbpkg/pbinit",$ptr,"$ENV{'PBTMP'}/pbinit",\%pb);
983            chmod 0755,"$ENV{'PBTMP'}/pbinit";
984            pb_system("cd $dest ; $ENV{'PBTMP'}/pbinit","Executing init script from $ENV{'PBROOTDIR'}/$pbpkg/pbinit","verbose");
985        }
986
987        # Do we have additional script to run to prepare the environement for the project ?
988        # Then include it in the pbconf delivery
989        foreach my $pbvf (<$ENV{'PBROOTDIR'}/pbv*.pre>,<$ENV{'PBROOTDIR'}/pbv*.post>, <$ENV{'PBROOTDIR'}/pbtest*>) {
990            if (-x "$pbvf") {
991                my $target = "$ENV{'PBDESTDIR'}/".basename($pbvf);
992                pb_filter_file("$pbvf",$ptr,$target,\%pb);
993                chmod 0755,"$target";
994            }
995        }
996
997        # Archive dest dir
998        chdir "$ENV{'PBDESTDIR'}" || die "Unable to change dir to $ENV{'PBDESTDIR'}";
999        if (defined $preserve) {
1000            # In that case we want to preserve the original tar file for checksum purposes
1001            # The one created is btw equivalent in that case to this one
1002            # Maybe check basename of both to be sure they are the same ?
1003            pb_log(0,"Preserving original tar file ");
1004            move("$preserve","$pbpkg-$pbver.tar.gz");
1005        } else {
1006            # Possibility to look at PBSRC to guess more the filename
1007            pb_system("tar cfz $pbpkg-$pbver.tar.gz --exclude=$pbpkg-$pbver/pbconf $pbpkg-$pbver","Creating $pbpkg tar files compressed");
1008        }
1009        pb_log(0,"Under $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz\n");
1010        pb_system("tar cfz $pbpkg-$pbver.pbconf.tar.gz $pbpkg-$pbver/pbconf","Creating pbconf tar files compressed");
1011        pb_log(0,"Under $ENV{'PBDESTDIR'}/$pbpkg-$pbver.pbconf.tar.gz\n");
1012
1013        # Keep track of version-tag per pkg
1014        $pkgs{$pbpkg} = "$pbver-$pbtag";
1015
1016        # Final cleanup
1017        pb_rm_rf($dest) if (-d $dest);
1018    }
1019
1020    # Keep track of per package version
1021    pb_log(2,"DEBUG pkgs: ".Dumper(%pkgs)."\n");
1022    open(PKG,"> $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb") || die "Unable to create $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb";
1023    foreach my $pbpkg (keys %pkgs) {
1024        print PKG "pbpkg $pbpkg = $pkgs{$pbpkg}\n";
1025    }
1026    close(PKG);
1027
1028    # Keep track of what is generated by default
1029    # We need to store the dir and info on version-tag
1030    # Base our content on the existing .pb file
1031    copy("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb","$ENV{'PBDESTDIR'}/pbrc");
1032    open(LAST,">> $ENV{'PBDESTDIR'}/pbrc") || die "Unable to create $ENV{'PBDESTDIR'}/pbrc";
1033    print LAST "pbroot $ENV{'PBPROJ'} = $ENV{'PBROOTDIR'}\n";
1034    print LAST "projver $ENV{'PBPROJ'} = $ENV{'PBPROJVER'}\n";
1035    print LAST "projtag $ENV{'PBPROJ'} = $ENV{'PBPROJTAG'}\n";
1036    print LAST "pbpackager $ENV{'PBPROJ'} = $ENV{'PBPACKAGER'}\n";
1037    close(LAST);
1038}
1039
1040sub pb_test2pkg {
1041    # Get the running distro to test on
1042    my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf, $pbupd, $pbins, $arch) = pb_distro_init();
1043    pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf, $pbupd, $pbins, $arch))."\n");
1044
1045    # Get list of packages to test
1046    # Get content saved in cms2build
1047    my $ptr = pb_get_pkg();
1048    @pkgs = @$ptr;
1049
1050    # Additional potential repo
1051    pb_distro_setuprepo($ddir,$dver,$arch,$dtype,$dfam,$dos);
1052    foreach my $pbpkg (@pkgs) {
1053        # We need to install the package to test, and deps brought with it
1054        pb_distro_installdeps(undef,$dtype,$pbins,$pbpkg);
1055        pb_system("$ENV{'PBDESTDIR'}/pbtest","Launching test for $pbpkg","verbose");
1056    }
1057}
1058
1059sub pb_build2pkg {
1060
1061    # Get the running distro to build on
1062    my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf, $pbupd, $pbins, $arch) = pb_distro_init();
1063    pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf, $pbupd, $pbins, $arch))."\n");
1064
1065    # If needed we may add repository to the build env
1066    pb_distro_setuprepo($ddir,$dver,$arch,$dtype,$dfam,$dos);
1067
1068    # Get list of packages to build
1069    my $ptr = pb_get_pkg();
1070    @pkgs = @$ptr;
1071
1072    # Get content saved in cms2build
1073    my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
1074    $pkg = { } if (not defined $pkg);
1075
1076    chdir "$ENV{'PBBUILDDIR'}";
1077    my $made = ""; # pkgs made during build
1078    my $pm = new Parallel::ForkManager($pbparallel) if (defined $pbparallel);
1079
1080    # We need to communicate info back from the children if parallel so prepare a dir for that
1081    my $tmpd = "$ENV{'PBTMP'}/build.$$";
1082    pb_mkdir_p($tmpd) if (defined $pbparallel);
1083
1084    foreach my $pbpkg (@pkgs) {
1085        $pm->start and next if (defined $pbparallel);
1086
1087        my $vertag = $pkg->{$pbpkg};
1088        # get the version of the current package - maybe different
1089        ($pbver,$pbtag) = split(/-/,$vertag);
1090
1091        my $src="$ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz";
1092        my $src2="$ENV{'PBDESTDIR'}/$pbpkg-$pbver.pbconf.tar.gz";
1093        pb_log(2,"Source file: $src\n");
1094        pb_log(2,"Pbconf file: $src2\n");
1095
1096        pb_log(2,"Working directory: $ENV{'PBBUILDDIR'}\n");
1097        if ($dtype eq "rpm") {
1098            foreach my $d ('RPMS','SRPMS','SPECS','SOURCES','BUILD') {
1099                if (! -d "$ENV{'PBBUILDDIR'}/$d") {
1100                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";
1101                }
1102            }
1103
1104            # Remove in case a previous link/file was there
1105            unlink "$ENV{'PBBUILDDIR'}/SOURCES/".basename($src);
1106            symlink "$src","$ENV{'PBBUILDDIR'}/SOURCES/".basename($src) || die "Unable to symlink $src in $ENV{'PBBUILDDIR'}/SOURCES";
1107            # We need to first extract the spec file
1108            my @specfile = pb_extract_build_files($src2,"$pbpkg-$pbver/pbconf/$ddir-$dver-$arch/","$ENV{'PBBUILDDIR'}/SPECS","spec");
1109
1110            # We need to handle potential patches to upstream sources
1111            pb_extract_build_files($src2,"$pbpkg-$pbver/pbconf/$ddir-$dver-$arch/pbpatch/","$ENV{'PBBUILDDIR'}/SOURCES","patch");
1112
1113            pb_log(2,"specfile: ".Dumper(\@specfile)."\n");
1114            # set LANGUAGE to check for correct log messages
1115            $ENV{'LANGUAGE'}="C";
1116            # Older Redhat use _target_platform in %configure incorrectly
1117            my $specialdef = "";
1118            if (($ddir eq "redhat") || (($ddir eq "rhel") && ($dver eq "2.1"))) {
1119                $specialdef = "--define \'_target_platform \"\"\'";
1120            }
1121
1122            foreach my $f (@specfile) {
1123                if ($f =~ /\.spec$/) {
1124                    # This could cause an issue in // mode
1125                    pb_distro_installdeps($f,$dtype,$pbins);
1126                    pb_system("rpmbuild $specialdef --define \"packager $ENV{'PBPACKAGER'}\" --define \"_topdir $ENV{'PBBUILDDIR'}\" -ba $f","Building package with $f under $ENV{'PBBUILDDIR'}","verbose");
1127                    last;
1128                }
1129            }
1130            # Get the name of the generated packages
1131            open(LOG,"$ENV{'PBTMP'}/system.$$.log") || die "Unable to open $ENV{'PBTMP'}/system.$$.log";
1132            while (<LOG>) {
1133                chomp($_);
1134                next if ($_ !~ /^Wrote:/);
1135                s|.*/([S]*RPMS.*)|$1|;
1136                $made .=" $_";
1137            }
1138            close(LOG);
1139
1140        } elsif ($dtype eq "deb") {
1141            chdir "$ENV{'PBBUILDDIR'}" || die "Unable to chdir to $ENV{'PBBUILDDIR'}";
1142            pb_system("tar xfz $src","Extracting sources");
1143            pb_system("tar xfz $src2","Extracting pbconf");
1144
1145            chdir "$pbpkg-$pbver" || die "Unable to chdir to $pbpkg-$pbver";
1146            pb_rm_rf("debian");
1147            symlink "pbconf/$ddir-$dver-$arch","debian" || die "Unable to symlink to pbconf/$ddir-$dver-$arch";
1148            chmod 0755,"debian/rules";
1149
1150            pb_distro_installdeps("debian/control",$dtype,$pbins);
1151            pb_system("dpkg-buildpackage -us -uc -rfakeroot","Building package","verbose");
1152            # Get the name of the generated packages
1153            open(LOG,"$ENV{'PBTMP'}/system.$$.log") || die "Unable to open $ENV{'PBTMP'}/system.$$.log";
1154            while (<LOG>) {
1155                chomp();
1156                my $tmp = $_;
1157                next if ($tmp !~ /^dpkg-deb.*:/);
1158                $tmp =~ s|.*../(.*)_(.*).deb.*|$1|;
1159                $made="$made $tmp.dsc $tmp.tar.gz $tmp"."_*.deb $tmp"."_*.changes";
1160            }
1161            close(LOG);
1162        } elsif ($dtype eq "ebuild") {
1163            my @ebuildfile;
1164            # For gentoo we need to take pb as subsystem name
1165            # We put every apps here under sys-apps. hope it's correct
1166            # We use pb's home dir in order to have a single OVERLAY line
1167            my $tmpd = "$ENV{'HOME'}/portage/pb/sys-apps/$pbpkg";
1168            pb_mkdir_p($tmpd) if (! -d "$tmpd");
1169            pb_mkdir_p("$ENV{'HOME'}/portage/distfiles") if (! -d "$ENV{'HOME'}/portage/distfiles");
1170
1171            # We need to first extract the ebuild file
1172            @ebuildfile = pb_extract_build_files($src2,"$pbpkg-$pbver/pbconf/$ddir-$dver-$arch/","$tmpd","ebuild");
1173
1174            # Prepare the build env for gentoo
1175            my $found = 0;
1176            my $pbbd = $ENV{'HOME'};
1177            $pbbd =~ s|/|\\/|g;
1178            if (-r "/etc/make.conf") {
1179                open(MAKE,"/etc/make.conf");
1180                while (<MAKE>) {
1181                    $found = 1 if (/$pbbd\/portage/);
1182                }
1183                close(MAKE);
1184            }
1185            if ($found == 0) {
1186                pb_system("sudo sh -c 'echo PORTDIR_OVERLAY=\"$ENV{'HOME'}/portage\" >> /etc/make.conf'");
1187            }
1188            #$found = 0;
1189            #if (-r "/etc/portage/package.keywords") {
1190            #open(KEYW,"/etc/portage/package.keywords");
1191            #while (<KEYW>) {
1192            #$found = 1 if (/portage\/pb/);
1193            #}
1194            #close(KEYW);
1195            #}
1196            #if ($found == 0) {
1197            #pb_system("sudo sh -c \"echo portage/pb >> /etc/portage/package.keywords\"");
1198            #}
1199
1200            # Build
1201            foreach my $f (@ebuildfile) {
1202                if ($f =~ /\.ebuild$/) {
1203                    pb_distro_installdeps($f,$dtype,$pbins);
1204                    move($f,"$tmpd/$pbpkg-$pbver.ebuild");
1205                    pb_system("cd $tmpd ; ebuild $pbpkg-$pbver.ebuild clean ; ebuild $pbpkg-$pbver.ebuild digest ; ebuild $pbpkg-$pbver.ebuild package","verbose");
1206                    # Now move it where pb expects it
1207                    pb_mkdir_p("$ENV{'PBBUILDDIR'}/portage/pb/sys-apps/$pbpkg");
1208                    move("$tmpd/$pbpkg-$pbver.ebuild","$ENV{'PBBUILDDIR'}/portage/pb/sys-apps/$pbpkg/$pbpkg-$pbver-r$pbtag.ebuild");
1209                }
1210            }
1211
1212            $made="$made portage/pb/sys-apps/$pbpkg/$pbpkg-$pbver-r$pbtag.ebuild";
1213        } elsif ($dtype eq "tgz") {
1214            # Slackware family
1215            $made="$made $pbpkg/$pbpkg-$pbver-*-$pbtag.tgz";
1216
1217            chdir "$ENV{'PBBUILDDIR'}" || die "Unable to chdir to $ENV{'PBBUILDDIR'}";
1218            pb_system("tar xfz $src","Extracting sources");
1219            pb_system("tar xfz $src2","Extracting pbconf");
1220            chdir "$pbpkg-$pbver" || die "Unable to chdir to $pbpkg-$pbver";
1221            symlink "pbconf/$ddir-$dver-$arch","install" || die "Unable to symlink to pbconf/$ddir-$dver-$arch";
1222            if (-x "install/pbslack") {
1223                pb_distro_installdeps("./install/pbslack",$dtype,$pbins);
1224                pb_system("./install/pbslack","Building software");
1225                pb_system("sudo /sbin/makepkg -p -l y -c y $pbpkg","Packaging $pbpkg","verbose");
1226            }
1227        } elsif ($dtype eq "pkg") {
1228            # Solaris
1229            $made="$made $pbpkg-$pbver-$pbtag.pkg.gz";
1230            my $pkgdestdir="$ENV{'PBBUILDDIR'}/install";
1231
1232            chdir "$ENV{'PBBUILDDIR'}" || die "Unable to chdir to $ENV{'PBBUILDDIR'}";
1233            # Will host resulting packages
1234            pb_mkdir_p("$dtype");
1235            pb_mkdir_p("$pkgdestdir/delivery");
1236            pb_system("tar xfz $src","Extracting sources under $ENV{'PBBUILDDIR'}");
1237            pb_system("tar xfz $src2","Extracting pbconf under $ENV{'PBBUILDDIR'}");
1238            chdir "$pbpkg-$pbver" || die "Unable to chdir to $pbpkg-$pbver";
1239            if (-f "pbconf/$ddir-$dver-$arch/pbbuild") {
1240                chmod 0755,"pbconf/$ddir-$dver-$arch/pbbuild";
1241                # pkginfo file is mandatory
1242                die "Unable to find pkginfo file in pbconf/$ddir-$dver-$arch" if (! -f "pbconf/$ddir-$dver-$arch/pkginfo");
1243                # Build
1244                pb_system("pbconf/$ddir-$dver-$arch/pbbuild $pkgdestdir/delivery","Building software and installing under $pkgdestdir/delivery");
1245                # Copy complementary files
1246                if (-f "pbconf/$ddir-$dver-$arch/prototype") {
1247                    copy("pbconf/$ddir-$dver-$arch/prototype", $pkgdestdir) 
1248                } else {
1249                    # No prototype provided, calculating it
1250                    open(PROTO,"> $pkgdestdir/prototype") || die "Unable to create prototype file";
1251                    print PROTO "i pkginfo\n";
1252                    print PROTO "i depend\n" if (-f "pbconf/$ddir-$dver-$arch/depend");
1253                    $ENV{'PBSOLDESTDIR'} = "$pkgdestdir/delivery";
1254                    find(\&create_solaris_prototype, "$pkgdestdir/delivery");
1255                }
1256                copy("pbconf/$ddir-$dver-$arch/depend", $pkgdestdir) if (-f "pbconf/$ddir-$dver-$arch/depend");
1257                copy("pbconf/$ddir-$dver-$arch/pkginfo", $pkgdestdir);
1258                pb_system("cd $pkgdestdir/delivery ; pkgmk -o -f ../prototype -r $pkgdestdir/delivery -d $ENV{'PBBUILDDIR'}/$dtype","Packaging $pbpkg","verbose");
1259                pb_system("cd $ENV{'PBBUILDDIR'}/$dtype ;  echo \"\" | pkgtrans -o -n -s $ENV{'PBBUILDDIR'}/$dtype $ENV{'PBBUILDDIR'}/$pbpkg-$pbver-$pbtag.pkg all","Transforming $pbpkg","verbose");
1260                pb_system("cd $ENV{'PBBUILDDIR'} ;  gzip -9f $pbpkg-$pbver-$pbtag.pkg","Compressing $pbpkg-$pbver-$pbtag.pkg","verbose");
1261            } else {
1262                pb_log(0,"No pbconf/$ddir-$dver-$arch/pbbuild file found for $pbpkg-$pbver in \n");
1263            }
1264            chdir ".." || die "Unable to chdir to parent dir";
1265            pb_system("rm -rf $pbpkg-$pbver $ENV{'PBBUILDDIR'}/$dtype $pkgdestdir", "Cleanup");
1266        } else {
1267            die "Unknown dtype format $dtype";
1268        }
1269        if (defined $pbparallel) {
1270            # Communicate results back to parent
1271            pb_set_content("$tmpd/$$",$made);
1272            $pm->finish;
1273        }
1274    }
1275    if (defined $pbparallel) {
1276        # In the parent, we need to get the result from the children
1277        $pm->wait_all_children;
1278        foreach my $f (<$tmpd/*>) {
1279            $made .= " ".pb_get_content($f);
1280        }
1281        pb_rm_rf($tmpd);
1282    }
1283
1284    # Find the appropriate check cmd/opts
1285    my ($oschkcmd,$oschkopt) = pb_conf_get_if("oschkcmd","oschkopt");
1286    my $chkcmd .= pb_distro_get_param($ddir,$dver,$arch,$oschkcmd,$dtype,$dfam,$dos);
1287    my $chkopt .= pb_distro_get_param($ddir,$dver,$arch,$oschkopt,$dtype,$dfam,$dos);
1288
1289    # Packages check if needed
1290    if ($dtype eq "rpm") {
1291        if (-x $chkcmd) {
1292            pb_system("$chkcmd $chkopt $made","Checking validity of rpms with $chkcmd","verbose");
1293        }
1294        my $rpms ="";
1295        my $srpms ="";
1296        foreach my $f (split(/ /,$made)) {
1297            $rpms .= "$ENV{'PBBUILDDIR'}/$f " if ($f =~ /^RPMS\//);
1298            $srpms .= "$ENV{'PBBUILDDIR'}/$f " if ($f =~ /^SRPMS\//);
1299        }
1300        pb_log(0,"SRPM packages generated: $srpms\n");
1301        pb_log(0,"RPM packages generated: $rpms\n");
1302    } elsif ($dtype eq "deb") {
1303        my $made2 = "";
1304        foreach my $f (split(/ /,$made)) {
1305            $made2 .= "../$f " if ($f =~ /\.deb$/);
1306        }
1307        if (-x $chkcmd) {
1308            pb_system("$chkcmd $chkopt $made2","Checking validity of debs with $chkcmd","verbose");
1309        } else {
1310            pb_log(0,"deb packages generated: $made2\n");
1311        }
1312    } else {
1313        pb_log(0,"No check done for $dtype yet\n");
1314        pb_log(0,"Packages generated: $made\n");
1315    }
1316
1317    # Keep track of what is generated so that we can get them back from VMs
1318    open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") || die "Unable to create $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
1319    print KEEP "$made\n";
1320    close(KEEP);
1321}
1322
1323sub create_solaris_prototype {
1324
1325    my $uidgid = "bin bin";
1326    my $pkgdestdir = $ENV{'PBSOLDESTDIR'};
1327
1328    return if ($_ =~ /^$pkgdestdir$/);
1329    if (-d $_) {
1330        my $n = $File::Find::name;
1331        $n =~ s~$pkgdestdir/~~;
1332        print PROTO "d none $n 0755 $uidgid\n";
1333    } elsif (-x $_) {
1334        my $n = $File::Find::name;
1335        $n =~ s~$pkgdestdir/~~;
1336        print PROTO "f none $n 0755 $uidgid\n";
1337    } elsif (-f $_) {
1338        my $n = $File::Find::name;
1339        $n =~ s~$pkgdestdir/~~;
1340        print PROTO "f none $n 0644 $uidgid\n";
1341    }
1342}
1343
1344sub pb_build2ssh {
1345    pb_send2target("Sources");
1346}
1347
1348sub pb_pkg2ssh {
1349    pb_send2target("Packages");
1350}
1351
1352# By default deliver to the the public site hosting the
1353# ftp structure (or whatever) or a VM/VE
1354sub pb_send2target {
1355
1356    my $cmt = shift;
1357    my $v = shift || undef;
1358    my $vmexist = shift || 0;           # 0 is FALSE
1359    my $vmpid = shift || 0;             # 0 is FALSE
1360    my $snapme = shift || 0;            # 0 is FALSE
1361
1362    pb_log(2,"DEBUG: pb_send2target($cmt,".Dumper($v).",$vmexist,$vmpid)\n");
1363    my $host = "sshhost";
1364    my $login = "sshlogin";
1365    my $dir = "sshdir";
1366    my $port = "sshport";
1367    my $conf = "sshconf";
1368    my $tmout = undef;
1369    my $path = undef;
1370    if ($cmt =~ /^VM/) {
1371        $login = "vmlogin";
1372        $dir = "pbdefdir";
1373        # Specific VM
1374        $tmout = "vmtmout";
1375        $path = "vmpath";
1376        $host = "vmhost";
1377        $port = "vmport";
1378    } elsif ($cmt =~ /^VE/) {
1379        $login = "velogin";
1380        $dir = "pbdefdir";
1381        # Specific VE
1382        $path = "vepath";
1383        $conf = "rbsconf";
1384    } elsif ($cmt eq "Web") {
1385        $host = "websshhost";
1386        $login = "websshlogin";
1387        $dir = "websshdir";
1388        $port = "websshport";
1389    }
1390    my $cmd = "";
1391    my $src = "";
1392    my ($odir,$over,$oarch) = (undef, undef, undef);
1393    my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf, $pbupd, $pbins, $darch);
1394
1395    if ($cmt ne "Announce") {
1396        # Get list of packages to build
1397        my $ptr = pb_get_pkg();
1398        @pkgs = @$ptr;
1399
1400        # Get the running distro to consider
1401        if (defined $v) {
1402            ($odir,$over,$oarch) = split(/-/,$v);
1403        }
1404        ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf, $pbupd, $pbins, $darch) = pb_distro_init($odir,$over,$oarch);
1405        pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf, $pbupd, $pbins, $darch))."\n");
1406
1407        # Get list of packages to build
1408        # Get content saved in cms2build
1409        my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
1410        $pkg = { } if (not defined $pkg);
1411
1412        chdir "$ENV{'PBBUILDDIR'}";
1413        foreach my $pbpkg (@pkgs) {
1414            my $vertag = $pkg->{$pbpkg};
1415            # get the version of the current package - maybe different
1416            ($pbver,$pbtag) = split(/-/,$vertag);
1417
1418            if (($cmt eq "Sources") || ($cmt =~ /V[EM]build/)) {
1419                $src = "$src $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz $ENV{'PBDESTDIR'}/$pbpkg-$pbver.pbconf.tar.gz";
1420                if ($cmd eq "") {
1421                    $cmd = "ln -sf $pbpkg-$pbver.tar.gz $pbpkg-latest.tar.gz";
1422                } else {
1423                    $cmd = "$cmd ; ln -sf $pbpkg-$pbver.tar.gz $pbpkg-latest.tar.gz";
1424                }
1425            } elsif ($cmt eq "Web") {
1426                $src = "$src $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz"
1427            }
1428        }
1429        # Adds conf file for availability of conf elements
1430        pb_conf_add("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb");
1431    }
1432
1433    if ($cmt =~ /V[EM]build/) {
1434        $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc $ENV{'PBDESTDIR'}/pbscript.$$";
1435    } elsif ($cmt =~ /V[EM]Script/) {
1436        $src="$src $ENV{'PBDESTDIR'}/pbscript.$$";
1437    } elsif ($cmt =~ /V[EM]test/) {
1438        $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc $ENV{'PBDESTDIR'}/pbscript.$$ $ENV{'PBDESTDIR'}/pbtest";
1439    } elsif (($cmt eq "Announce") || ($cmt eq "Web")) {
1440        $src="$src $ENV{'PBTMP'}/pbscript";
1441    } elsif ($cmt eq "Packages") {
1442        # Get package list from file made during build2pkg
1443        open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") || die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
1444        $src = <KEEP>;
1445        chomp($src);
1446        close(KEEP);
1447        $src="$src $ENV{'PBBUILDDIR'}/pbscript";
1448    }
1449    # Remove potential leading spaces (cause problem with basename)
1450    $src =~ s/^ *//;
1451    my $basesrc = "";
1452    foreach my $i (split(/ +/,$src)) {
1453        $basesrc .= " ".basename($i);
1454    }
1455
1456    pb_log(0,"Sources handled ($cmt): $src\n");
1457    pb_log(2,"values: ".Dumper(($host,$login,$dir,$port,$tmout,$path,$conf))."\n");
1458    my ($sshhost,$sshlogin,$sshdir,$sshport) = pb_conf_get($host,$login,$dir,$port);
1459    # Not mandatory...
1460    my ($rbsconf,$testver,$delivery) = pb_conf_get_if($conf,"testver","delivery");
1461    $delivery->{$ENV{'PBPROJ'}} = "" if (not defined $delivery->{$ENV{'PBPROJ'}});
1462    my ($vtmout,$vepath);
1463    # ...Except those in virtual context
1464    if ($cmt =~ /^VE/) {
1465        ($vepath) = pb_conf_get($path);
1466    }
1467    if ($cmt =~ /^VM/) {
1468        ($vtmout) = pb_conf_get($tmout);
1469    }
1470    pb_log(2,"ssh: ".Dumper(($sshhost,$sshlogin,$sshdir,$sshport,$vtmout,$vepath,$rbsconf))."\n");
1471
1472    my $mac;
1473    if ($cmt !~ /^VE/) {
1474        $mac = "$sshlogin->{$ENV{'PBPROJ'}}\@$sshhost->{$ENV{'PBPROJ'}}";
1475        # Overwrite account value if passed as parameter
1476        $mac = "$pbaccount\@$sshhost->{$ENV{'PBPROJ'}}" if (defined $pbaccount);
1477        pb_log(2, "DEBUG: pbaccount: $pbaccount => mac: $mac\n") if (defined $pbaccount);
1478    } else {
1479        # VE
1480        # Overwrite account value if passed as parameter (typically for setup2v)
1481        $mac = $sshlogin->{$ENV{'PBPROJ'}};
1482        $mac = $pbaccount if (defined $pbaccount);
1483    }
1484
1485    my $tdir;
1486    my $bdir;
1487    if (($cmt eq "Sources") || ($cmt =~ /V[EM]Script/)) {
1488        $tdir = "$sshdir->{$ENV{'PBPROJ'}}/$delivery->{$ENV{'PBPROJ'}}/src";
1489    } elsif (($cmt =~ /V[EM]build/)  || ($cmt =~ /V[EM]test/)) {
1490        $tdir = $sshdir->{$ENV{'PBPROJ'}}."/$ENV{'PBPROJ'}/delivery";
1491        $bdir = $sshdir->{$ENV{'PBPROJ'}}."/$ENV{'PBPROJ'}/build";
1492        # Remove a potential $ENV{'HOME'} as bdir should be relative to pb's home
1493        $bdir =~ s|\$ENV.+\}/||;
1494    } elsif ($cmt eq "Announce") {
1495        $tdir = "$sshdir->{$ENV{'PBPROJ'}}/$delivery->{$ENV{'PBPROJ'}}";
1496    } elsif ($cmt eq "Web") {
1497        $tdir = "$sshdir->{$ENV{'PBPROJ'}}/$delivery->{$ENV{'PBPROJ'}}";
1498    } elsif ($cmt eq "Packages") {
1499        $tdir = "$sshdir->{$ENV{'PBPROJ'}}/$delivery->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch";
1500
1501        my $repodir = $tdir;
1502        $repodir =~ s|^$sshdir->{$ENV{'PBPROJ'}}/||;
1503
1504        my ($pbrepo) = pb_conf_get("pbrepo");
1505
1506        # Repository management
1507        open(PBS,"> $ENV{'PBBUILDDIR'}/pbscript") || die "Unable to create $ENV{'PBBUILDDIR'}/pbscript";
1508        if ($dtype eq "rpm") {
1509            # Also make a pbscript to generate yum/urpmi bases
1510            print PBS << "EOF";
1511#!/bin/bash
1512# Prepare a script to ease yum setup
1513cat > $ENV{'PBPROJ'}.repo << EOT
1514[$ENV{'PBPROJ'}]
1515name=$ddir $dver $darch - $ENV{'PBPROJ'} Vanilla Packages
1516baseurl=$pbrepo->{$ENV{'PBPROJ'}}/$repodir
1517enabled=1
1518gpgcheck=0
1519EOT
1520chmod 644 $ENV{'PBPROJ'}.repo
1521
1522# Clean up old repo content
1523rm -rf headers/ repodata/
1524# Create yum repo
1525if [ -x /usr/bin/yum-arch ]; then
1526    yum-arch .
1527fi
1528# Create repodata
1529createrepo .
1530EOF
1531            if ($dfam eq "md") {
1532                # For Mandriva add urpmi management
1533                print PBS << "EOF";
1534# Prepare a script to ease urpmi setup
1535cat > $ENV{'PBPROJ'}.addmedia << EOT
1536urpmi.addmedia $ENV{'PBPROJ'} $pbrepo->{$ENV{'PBPROJ'}}/$repodir with media_info/hdlist.cz
1537EOT
1538chmod 755 $ENV{'PBPROJ'}.addmedia
1539
1540# Clean up old repo content
1541rm -f hdlist.cz synthesis.hdlist.cz
1542# Create urpmi repo
1543genhdlist2 --clean .
1544if [ \$\? -ne 0 ]; then
1545    genhdlist .
1546fi
1547EOF
1548            }
1549            if ($ddir eq "fedora") {
1550                # Extract the spec file to please Fedora maintainers :-(
1551                print PBS << "EOF";
1552for p in $basesrc; do
1553    echo \$p | grep -q 'src.rpm'
1554    if [ \$\? -eq 0 ]; then
1555        rpm2cpio \$p | cpio -ivdum --quiet '*.spec'
1556    fi
1557done
1558EOF
1559            }
1560            if ($dfam eq "novell") {
1561                # Add ymp scripts for one-click install on SuSE
1562                print PBS << "EOF";
1563# Prepare a script to ease SuSE one-click install
1564# Cf: http://de.opensuse.org/1-Klick-Installation/ISV
1565#
1566cat > $ENV{'PBPROJ'}.ymp << EOT
1567<?xml version="1.0" encoding="utf-8"?>
1568<!-- vim: set sw=2 ts=2 ai et: -->
1569<metapackage xmlns:os="http://opensuse.org/Standards/One_Click_Install" xmlns="http://opensuse.org/Standards/One_Click_Install">
1570    <group><!-- The group of software, typically one for project-builder.org -->
1571        <name>$ENV{'PBPROJ'} Bundle</name> <!-- Name of the software group -->
1572        <summary>Software bundle for the $ENV{'PBPROJ'} project</summary> <!--This message is shown to the user and should describe the whole bundle -->
1573        <description>This is the summary of the $ENV{'PBPROJ'} Project
1574             
1575            Details are available on a per package basis below
1576
1577        </description><!--This is also shown to the user -->
1578        <remainSubscribed>false</remainSubscribed> <!-- Don't know what it mean -->
1579        <repositories><!-- List of needed repositories -->
1580            <repository>
1581                <name>$ENV{'PBPROJ'} Repository</name> <!-- Name of the repository  -->
1582                <summary>This repository contains the $ENV{'PBPROJ'} project packages.</summary> <!-- Summary of the repository -->
1583                <description>This repository contains the $ENV{'PBPROJ'} project packages.</description><!-- This description is shown to the user -->
1584                <url>$pbrepo->{$ENV{'PBPROJ'}}/$repodir</url><!--URL of repository, which is added -->
1585            </repository>
1586        </repositories>
1587        <software><!-- A List of packages, which should be added through the one-click-installation -->
1588EOT
1589for p in $basesrc; do
1590    sum=`rpm -q --qf '%{SUMMARY}' \$p`
1591    name=`rpm -q --qf '%{NAME}' \$p`
1592    desc=`rpm -q --qf '%{description}' \$p`
1593    cat >> $ENV{'PBPROJ'}.ymp << EOT
1594            <item>
1595                <name>\$name</name><!-- Name of the package, is shown to the user and used to identify the package at the repository -->
1596                <summary>\$sum</summary> <!-- Summary of the package -->
1597                <description>\$desc</description> <!-- Description, is shown to the user -->
1598            </item>
1599EOT
1600done
1601cat >> $ENV{'PBPROJ'}.ymp << EOT
1602        </software>
1603    </group>
1604</metapackage>
1605EOT
1606chmod 644 $ENV{'PBPROJ'}.ymp
1607EOF
1608            }
1609        } elsif ($dtype eq "deb") {
1610            # Also make a pbscript to generate apt bases
1611            # Cf: http://www.debian.org/doc/manuals/repository-howto/repository-howto.fr.html
1612            # This dirname removes arch
1613            my $rpd = dirname("$pbrepo->{$ENV{'PBPROJ'}}/$repodir");
1614            # this one removes the ver
1615            $rpd = dirname($rpd);
1616            print PBS << "EOF";
1617#!/bin/bash
1618# Prepare a script to ease apt setup
1619cat > $ENV{'PBPROJ'}.sources.list << EOT
1620deb $rpd $dver contrib
1621deb-src $rpd $dver contrib
1622EOT
1623chmod 644 $ENV{'PBPROJ'}.sources.list
1624
1625# Up two levels to deal with the dist dir cross versions
1626cd ../..
1627mkdir -p dists/$dver/contrib/binary-$darch dists/$dver/contrib/source
1628
1629# Prepare a script to create apt info file
1630TMPD=`mktemp -d /tmp/pb.XXXXXXXXXX` || exit 1
1631mkdir -p \$TMPD
1632cat > \$TMPD/Release << EOT
1633Archive: unstable
1634Component: contrib
1635Origin: $ENV{'PBPROJ'}
1636Label: $ENV{'PBPROJ'} dev repository $pbrepo->{$ENV{'PBPROJ'}}
1637EOT
1638
1639echo "Creating Packages metadata ($darch)"
1640dpkg-scanpackages -a$darch $dver/$darch /dev/null | gzip -c9 > dists/$dver/contrib/binary-$darch/Packages.gz
1641dpkg-scanpackages -a$darch $dver/$darch /dev/null | bzip2 -c9 > dists/$dver/contrib/binary-$darch/Packages.bz2
1642echo "Creating Contents metadata ($darch)"
1643apt-ftparchive contents $dver | gzip -c9 > dists/$dver/Contents-$darch.gz
1644echo "Creating Release metadata ($darch)"
1645cat \$TMPD/Release > dists/$dver/contrib/binary-$darch/Release
1646echo "Architecture: $darch" >> dists/$dver/contrib/binary-$darch/Release
1647echo "Creating Source metadata"
1648dpkg-scansources $dver/$darch /dev/null | gzip -c9 > dists/$dver/contrib/source/Sources.gz
1649cat \$TMPD/Release > dists/$dver/contrib/source/Release
1650echo "Architecture: Source" >> dists/$dver/contrib/source/Release
1651echo "Creating Release metadata"
1652apt-ftparchive release dists/$dver > dists/$dver/Release
1653rm -rf \$TMPD
1654EOF
1655        } elsif ($dtype eq "ebuild") {
1656            # make a pbscript to generate links to latest version
1657            print PBS << "EOF";
1658#!/bin/bash
1659# Prepare a script to create correct links
1660for p in $src; do
1661    echo \$p | grep -q '.ebuild'
1662    if [ \$\? -eq 0 ]; then
1663        j=`basename \$p`
1664        pp=`echo \$j | cut -d'-' -f1`
1665        ln -sf \$j \$pp.ebuild
1666    fi
1667done
1668EOF
1669        }
1670        close(PBS);
1671        chmod 0755,"$ENV{'PBBUILDDIR'}/pbscript";
1672    } else {
1673        return;
1674    }
1675
1676    # Useless for VE
1677    my $nport = pb_get_port($sshport->{$ENV{'PBPROJ'}},$cmt) if ($cmt !~ /^VE/);
1678
1679    # Remove a potential $ENV{'HOME'} as tdir should be relative to pb's home
1680    $tdir =~ s|\$ENV.+\}/||;
1681
1682    my $tm = undef;
1683    if ($cmt =~ /^VM/) {
1684        $tm = $vtmout->{$ENV{'PBPROJ'}};
1685    }
1686
1687    # ssh communication if not VE
1688    # should use a hash instead...
1689    my ($shcmd,$cpcmd,$cptarget,$cp2target);
1690    if ($cmt !~ /^VE/) {
1691        my $keyfile = pb_ssh_get(0);
1692        $shcmd = "ssh -i $keyfile -q -o UserKnownHostsFile=/dev/null -p $nport $mac";
1693        $cpcmd = "scp -i $keyfile -p -o UserKnownHostsFile=/dev/null -P $nport";
1694        $cptarget = "$mac:$tdir";
1695        if ($cmt =~ /^VMbuild/) {
1696            $cp2target = "$mac:$bdir";
1697        }
1698    } else {
1699        my $tp = $vepath->{$ENV{'PBPROJ'}};
1700        ($odir,$over,$oarch) = split(/-/,$v);
1701        my $tpdir = "$tp/$odir/$over/$oarch";
1702        my ($ptr) = pb_conf_get("vetype");
1703        my $vetype = $ptr->{$ENV{'PBPROJ'}};
1704        if ($vetype eq "chroot") {
1705            $shcmd = "sudo chroot $tpdir /bin/su - $mac -c ";
1706        } elsif ($vetype eq "schroot") {
1707            $shcmd = "schroot $tp -u $mac -- ";
1708        }
1709        $cpcmd = "sudo cp -r ";
1710        # We need to get the home dir of the target account to deliver in the right place
1711        open(PASS,"$tpdir/etc/passwd") || die "Unable to open $tpdir/etc/passwd";
1712        my $homedir = "";
1713        while (<PASS>) {
1714            my ($c1,$c2,$c3,$c4,$c5,$c6,$c7) = split(/:/);
1715            $homedir = $c6 if ($c1 =~ /^$mac$/);
1716            pb_log(3,"Homedir: $homedir - account: $c6\n");
1717        }
1718        close(PASS);
1719        $cptarget = "$tpdir/$homedir/$tdir";
1720        if ($cmt eq "VEbuild") {
1721            $cp2target = "$tpdir/$homedir/$bdir";
1722        }
1723        pb_log(2,"On VE using $cptarget as target dir to copy to\n");
1724    }
1725
1726    my $logres = "";
1727    # Do not touch when just announcing
1728    if ($cmt ne "Announce") {
1729        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");
1730    } else {
1731        $logres = "> ";
1732    }
1733    pb_system("cd $ENV{'PBBUILDDIR'} ; $cpcmd $src $cptarget 2> /dev/null","$cmt delivery in $cptarget");
1734
1735    # For VE we need to change the owner manually
1736    if ($cmt =~ /^VE/) {
1737        pb_system("$shcmd \"sudo chown -R $mac $tdir\"","Adapt owner in $tdir to $mac");
1738    }
1739
1740    # Use the right script name depending on context
1741    my $pbscript;
1742    if ($cmt =~ /^V[EM]/) {
1743        $pbscript = "pbscript.$$";
1744    } else {
1745        $pbscript = "pbscript";
1746    }
1747
1748    pb_system("$shcmd \"echo \'cd $tdir ; if [ -x $pbscript ]; then ./$pbscript; fi ; rm -f ./$pbscript\' | bash\"","Executing pbscript on $cptarget if needed","verbose");
1749    if ($cmt =~ /^V[EM]build/) {
1750        # Get back info on pkg produced, compute their name and get them from the VM
1751        pb_system("$cpcmd $cp2target/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'} $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$ 2> /dev/null","Get package names in $cp2target");
1752        # For VE we need to change the owner manually
1753        if ($cmt eq "VEbuild") {
1754            pb_system("sudo chown $UID $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$","Adapt owner in $tdir to $UID");
1755        }
1756        if (not -f "$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$") {
1757            pb_log(0,"Problem with VM $v on $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$");
1758        } else {
1759            open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$") || die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$";
1760            my $src = <KEEP>;
1761            chomp($src);
1762            close(KEEP);
1763            unlink("$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$");
1764
1765            $src =~ s/^ *//;
1766            pb_mkdir_p("$ENV{'PBBUILDDIR'}/$odir/$over/$oarch");
1767            # Change pgben to make the next send2target happy
1768            my $made = "";
1769   
1770            # For VM we don't want shell expansion to hapen locally but remotely
1771            my $delim = '\'';
1772            if ($cmt =~ /^VEbuild/) {
1773                # For VE we need to support shell expansion locally
1774                $delim = "";
1775            }   
1776
1777            open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") || die "Unable to write $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
1778            foreach my $p (split(/ +/,$src)) {
1779                my $j = basename($p);
1780                pb_system("$cpcmd $cp2target/$delim$p$delim $ENV{'PBBUILDDIR'}/$odir/$over/$oarch 2> /dev/null","Recovery of package $j in $ENV{'PBBUILDDIR'}/$odir/$over/$oarch");
1781                $made="$made $odir/$over/$oarch/$j"; # if (($dtype ne "rpm") || ($j !~ /.src.rpm$/));
1782            }
1783            print KEEP "$made\n";
1784            close(KEEP);
1785            pb_system("$shcmd \"rm -rf $tdir $bdir\"","$cmt cleanup");
1786
1787            # Sign packages locally
1788            if ($dtype eq "rpm") {
1789                #pb_system("rpm --addsign --define \"_signature gpg\" --define \"_gpg_name $ENV{'PBPACKAGER'}\" --define \"__gpg_sign_cmd /usr/bin/gpg --batch --no-verbose --no-armor --no-tty --no-secmem-warning -sbo %{__signature_filename} %{__plaintext_filename} --use-agent\" $made","Signing RPM packages packages");
1790            } elsif ($dtype eq "deb") {
1791                #pb_system("debsign $made","Signing DEB packages");
1792            } else {
1793                pb_log(0,"I don't know yet how to sign packages for type $dtype.\nPlease give feedback to dev team\n");
1794            }
1795
1796            # We want to send them to the ssh account so overwrite what has been done before
1797            undef $pbaccount;
1798            pb_log(2,"Before sending pkgs, vmexist: $vmexist, vmpid: $vmpid\n");
1799            pb_send2target("Packages",$odir."-".$over."-".$oarch,$vmexist,$vmpid);
1800            pb_rm_rf("$ENV{'PBBUILDDIR'}/$odir/$over/$oarch");
1801        }
1802    }
1803    unlink("$ENV{'PBDESTDIR'}/pbscript.$$") if ($cmt =~ /^V[ME]/);
1804
1805    pb_log(2,"Before halt, vmexist: $vmexist, vmpid: $vmpid\n");
1806    if ((! $vmexist) && ($cmt =~ /^VM/)) {
1807        # If in setupvm then takes a snapshot just before halting
1808        if ($snapme != 0) {
1809            my ($vmmonport,$vmtype) = pb_conf_get("vmmonport","vmtype");
1810            # For monitoring control
1811            if ((($vmtype->{$ENV{'PBPROJ'}}) eq "kvm") || (($vmtype->{$ENV{'PBPROJ'}}) eq "qemu")) {
1812                eval
1813                {
1814                require Net::Telnet;
1815                Net::Telnet->import();
1816                };
1817                if ($@) {
1818                    # Net::Telnet not found
1819                    pb_log(1,"ADVISE: Install Net::Telnet to benefit from monitoring control and snapshot feature.\nWARNING: No snapshot created");
1820                } else {
1821                    my $t = new Net::Telnet (Timeout => 120, Host => "localhost", Port => $vmmonport->{$ENV{'PBPROJ'}}) || die "Unable to dialog on the monitor";
1822                    # move to monitor mode
1823                    my @lines = $t->cmd("c");
1824                    # Create a snapshot named pb
1825                    @lines = $t->cmd("savevm pb");
1826                    # Write the new status in the VM
1827                    @lines = $t->cmd("commit all");
1828                    # End
1829                    @lines = $t->cmd("quit");
1830                }
1831            }
1832        }
1833        my $hoption = "-p";
1834        my $hpath = "/sbin";
1835        # Solaris doesn't support -h and has halt elsewhere
1836        if ($dtype eq "pkg") {
1837            $hoption = "" ;
1838            $hpath = "/usr/sbin";
1839        }
1840        pb_system("$shcmd \"sudo $hpath/halt $hoption \"; sleep $tm ; echo \'if [ -d /proc/$vmpid ]; then kill -9 $vmpid; fi \' | bash ; sleep 10","VM $v halt (pid $vmpid)");
1841    }
1842    if (($cmt =~ /^VE/) && ($snapme != 0)) {
1843        ($odir,$over,$oarch) = split(/-/,$v);
1844        my $tpdir = "$vepath->{$ENV{'PBPROJ'}}/$odir/$over/$oarch";
1845        pb_system("sudo tar cz -f $vepath->{$ENV{'PBPROJ'}}/$odir-$over-$oarch.tar.gz -C $tpdir .","Creating a snapshot of $tpdir");
1846    }
1847}
1848
1849sub pb_script2v {
1850    my $pbscript=shift;
1851    my $vtype=shift;
1852    my $pbforce=shift || 0; # Force stop of VM. Default not.
1853    my $vm1=shift || undef; # Only that VM to treat. Default all.
1854    my $snapme=shift || 0;  # Do we have to create a snapshot. Default not.
1855    my $vm;
1856    my $all;
1857
1858    pb_log(2,"DEBUG: pb_script2v($pbscript,$vtype,$pbforce,".Dumper($vm1).",$snapme)\n");
1859    # Prepare the script to be executed on the VM
1860    # in $ENV{'PBDESTDIR'}/pbscript.$$
1861    if ((defined $pbscript ) && ($pbscript ne "$ENV{'PBDESTDIR'}/pbscript.$$")) {
1862        copy($pbscript,"$ENV{'PBDESTDIR'}/pbscript.$$") || die "Unable to create $ENV{'PBDESTDIR'}/pbscript.$$";
1863        chmod 0755,"$ENV{'PBDESTDIR'}/pbscript.$$";
1864    }
1865
1866    if (not defined $vm1) {
1867        ($vm,$all) = pb_get2v($vtype);
1868    } else {
1869        @$vm = ($vm1);
1870    }
1871    my ($vmexist,$vmpid) = (undef,undef);
1872
1873    foreach my $v (@$vm) {
1874        # Launch VM/VE
1875        ($vmexist,$vmpid) = pb_launchv($vtype,$v,0,$snapme,$pbsnap);
1876
1877        if ($vtype eq "vm") {
1878            pb_log(2,"DEBUG: After pb_launchv, vmexist: $vmexist, vmpid: $vmpid\n");
1879
1880            # Skip that VM if something went wrong
1881            next if (($vmpid == 0) && ($vmexist == 0));
1882
1883            # If force stopping the VM then reset vmexist
1884            if ($pbforce == 1) {
1885                $vmpid = $vmexist;
1886                $vmexist = 0;
1887            }
1888        } else {
1889            #VE
1890            $vmexist = 0;
1891            $vmpid = 0;
1892        }
1893
1894        # Gather all required files to send them to the VM
1895        # and launch the build through pbscript
1896        pb_log(2,"DEBUG: Before send2target, vmexist: $vmexist, vmpid: $vmpid\n");
1897        pb_send2target(uc($vtype)."Script","$v",$vmexist,$vmpid,$snapme);
1898
1899    }
1900}
1901
1902sub pb_launchv {
1903    my $vtype = shift;
1904    my $v = shift;
1905    my $create = shift || 0;        # By default do not create a VM/VE
1906    my $snapme = shift || 0;        # By default do not snap a VM/VE
1907    my $usesnap = shift || 1;       # By default study the usage of the snapshot feature of VM/VE
1908
1909    # If creation or snapshot creation mode, no snapshot usable
1910    if (($create == 1) || ($snapme == 1)) {
1911        $usesnap = 0;
1912    }
1913
1914    pb_log(2,"DEBUG: pb_launchv($vtype,$v,$create,$snapme,$usesnap)\n");
1915    die "No VM/VE defined, unable to launch" if (not defined $v);
1916    # Keep only the first VM in case many were given
1917    $v =~ s/,.*//;
1918
1919    my $arch = pb_get_arch();
1920
1921    # Launch the VMs/VEs
1922    if ($vtype eq "vm") {
1923        die "-i iso parameter needed" if (((not defined $iso) || ($iso eq "")) && ($create != 0));
1924
1925        # TODO: vmmonport should be optional
1926        my ($ptr,$ptr2,$vmpath,$vmport,$vmsize,$vmmonport) = pb_conf_get("vmtype","vmcmd","vmpath","vmport","vmsize","vmmonport");
1927        my ($vmopt,$vmmem,$vmtmout,$vmsnap,$vmbuildtm) = pb_conf_get_if("vmopt","vmmem","vmtmout","vmsnap","vmbuildtm");
1928
1929        my $vmtype = $ptr->{$ENV{'PBPROJ'}};
1930        my $vmcmd = $ptr2->{$ENV{'PBPROJ'}};
1931
1932        if (defined $opts{'g'}) {
1933            if (($vmtype eq "kvm") || ($vmtype eq "qemu")) {
1934                $ENV{'PBVMOPT'} = "--nographic";
1935            }
1936        }
1937        if (not defined $ENV{'PBVMOPT'}) {
1938            $ENV{'PBVMOPT'} = "";
1939        }
1940        # Save the current status for later restoration
1941        $ENV{'PBOLDVMOPT'} = $ENV{'PBVMOPT'};
1942        # Set a default timeout of 2 minutes
1943        if (not defined $ENV{'PBVMTMOUT'}) {
1944            $ENV{'PBVMTMOUT'} = "120";
1945        }
1946        if (defined $vmopt->{$v}) {
1947            $ENV{'PBVMOPT'} .= " $vmopt->{$v}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$v}/);
1948        } elsif (defined $vmopt->{$ENV{'PBPROJ'}}) {
1949            $ENV{'PBVMOPT'} .= " $vmopt->{$ENV{'PBPROJ'}}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$ENV{'PBPROJ'}}/);
1950        }
1951
1952        # How much memory to allocate for VMs
1953        if (defined $vmmem->{$v}) {
1954            $ENV{'PBVMOPT'} .= " -m $vmmem->{$v}";
1955        } elsif (defined $vmmem->{$ENV{'PBPROJ'}}) {
1956            $ENV{'PBVMOPT'} .= " -m $vmmem->{$ENV{'PBPROJ'}}";
1957        }
1958
1959        # Are we allowed to use snapshot feature
1960        if ($usesnap == 1) {
1961            if ((defined $vmsnap->{$v}) && ($vmsnap->{$v} =~ /true/i)) {
1962                $ENV{'PBVMOPT'} .= " -snapshot";
1963            } elsif ((defined $vmsnap->{$ENV{'PBPROJ'}}) && ($vmsnap->{$ENV{'PBPROJ'}} =~ /true/i)) {
1964                $ENV{'PBVMOPT'} .= " -snapshot";
1965            } elsif ($pbsnap eq 1) {
1966                $ENV{'PBVMOPT'} .= " -snapshot";
1967            }
1968        } 
1969        if ($snapme != 0) {
1970            if (($vmtype eq "kvm") || ($vmtype eq "qemu")) {
1971                # Configure the monitoring to automate the creation of the 'pb' snapshot
1972                $ENV{'PBVMOPT'} .= " -serial mon:telnet::$vmmonport->{$ENV{'PBPROJ'}},server,nowait";
1973                # In that case no snapshot call needed
1974                $ENV{'PBVMOPT'} =~ s/ -snapshot//;
1975            }
1976        }
1977        if (defined $vmtmout->{$v}) {
1978            $ENV{'PBVMTMOUT'} = $vmtmout->{$v};
1979        } elsif (defined $vmtmout->{$ENV{'PBPROJ'}}) {
1980            $ENV{'PBVMTMOUT'} = $vmtmout->{$ENV{'PBPROJ'}};
1981        }
1982        my $nport = pb_get_port($vmport->{$ENV{'PBPROJ'}});
1983   
1984        my $cmd;
1985        my $vmm;        # has to be used for pb_check_ps
1986        if (($vmtype eq "qemu") || ($vmtype eq "kvm")) {
1987            $vmm = "$vmpath->{$ENV{'PBPROJ'}}/$v.qemu";
1988            if (($create != 0) || (defined $iso)) {
1989                $ENV{'PBVMOPT'} .= " -cdrom $iso -boot d";
1990            }
1991            # Always redirect the network and always try to use a 'pb' snapshot
1992            $cmd = "$vmcmd $ENV{'PBVMOPT'} -redir tcp:$nport:10.0.2.15:22 -loadvm pb $vmm"
1993        } elsif ($vmtype eq "xen") {
1994        } elsif ($vmtype eq "vmware") {
1995        } else {
1996            die "VM of type $vmtype not supported. Report to the dev team";
1997        }
1998        # Restore the ENV VAR Value
1999        $ENV{'PBVMOPT'} = $ENV{'PBOLDVMOPT'};
2000
2001        my ($tmpcmd,$void) = split(/ +/,$cmd);
2002        my $vmexist = pb_check_ps($tmpcmd,$vmm);
2003        my $vmpid = 0;
2004        if (! $vmexist) {
2005            if ($create != 0) {
2006                die("Found an existing Virtual machine $vmm. Won't overwrite") if (-r $vmm);
2007                if (($vmtype eq "qemu") || ($vmtype eq "xen") || ($vmtype eq "kvm")) {
2008                    my $command = pb_check_req("qemu-img",0);
2009                    pb_system("$command create -f qcow2 $vmm $vmsize->{$ENV{'PBPROJ'}}","Creating the QEMU VM");
2010                } elsif ($vmtype eq "vmware") {
2011                } else {
2012                }
2013            }
2014            if (! -f "$vmm") {
2015                pb_log(0,"Unable to find VM $vmm\n");
2016            } else {
2017                # Is the SSH port free? if not kill the existing process using it after a build timeout period
2018                my $vmssh = pb_check_ps($tmpcmd,"tcp:$nport:10.0.2.15:22");
2019                if ($vmssh) {
2020                    my $buildtm = $ENV{'PBVMTMOUT'};
2021                    if (defined $vmbuildtm->{$v}) {
2022                        $buildtm = $vmbuildtm->{$v};
2023                    } elsif (defined $vmbuildtm->{$ENV{'PBPROJ'}}) {
2024                        $buildtm = $vmbuildtm->{$ENV{'PBPROJ'}};
2025                    }
2026
2027                    sleep $buildtm;
2028                    pb_log(0,"WARNING: Killing the process ($vmssh) using port $nport (previous failed VM ?)\n");
2029                    kill 15,$vmssh;
2030                    # Let it time to exit
2031                    sleep 5;
2032                }
2033                pb_system("$cmd &","Launching the VM $vmm");
2034                # Using system allows to kill it externaly if needed
2035                pb_system("sleep $ENV{'PBVMTMOUT'}","Waiting $ENV{'PBVMTMOUT'} s for VM $v to come up");
2036                $vmpid = pb_check_ps($tmpcmd,$vmm);
2037                pb_log(0,"VM $vmm launched (pid $vmpid)\n");
2038            }
2039        } else {
2040            pb_log(0,"Found an existing VM $vmm (pid $vmexist)\n");
2041        }
2042        pb_log(2,"DEBUG: pb_launchv returns ($vmexist,$vmpid)\n");
2043        return($vmexist,$vmpid);
2044    # VE here
2045    } else {
2046        # Get distro context
2047        my ($name,$ver,$darch) = split(/-/,$v);
2048        chomp($darch);
2049        my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf) = pb_distro_init($name,$ver,$darch);
2050
2051        # Get VE context
2052        my ($ptr,$vepath) = pb_conf_get("vetype","vepath");
2053        my $vetype = $ptr->{$ENV{'PBPROJ'}};
2054
2055        # We can probably only get those params now we have the distro context
2056        my ($rbsb4pi,$rbspi,$vesnap,$oscodename,$osmindep,$verebuild,$rbsmirrorsrv) = pb_conf_get_if("rbsb4pi","rbspi","vesnap","oscodename","osmindep","verebuild","rbsmirrorsrv");
2057
2058        # We need to avoid umask propagation to the VE
2059        umask 0022;
2060
2061        if (($vetype eq "chroot") || ($vetype eq "schroot")) {
2062            # Architecture consistency
2063            if ($arch ne $darch) {
2064                die "Unable to launch a VE of architecture $darch on a $arch platform" if (($darch eq "x86_64") && ($arch =~ /i?86/));
2065            }
2066
2067            my ($verpmtype,$vedebtype) = pb_conf_get("verpmtype","vedebtype");
2068            if (($create != 0) || ((defined $verebuild) && ($verebuild->{$ENV{'PBPROJ'}} =~ /true/i)) || ($pbforce == 1)) {
2069                my ($rbsopt1) = pb_conf_get_if("rbsopt");
2070
2071                # We have to rebuild the chroot
2072                if ($dtype eq "rpm") {
2073
2074                    # Which tool is used
2075                    my $verpmstyle = $verpmtype->{$ENV{'PBPROJ'}};
2076
2077                    # Get potential rbs option
2078                    my $rbsopt = "";
2079                    if (defined $rbsopt1) {
2080                        if (defined $rbsopt1->{$verpmstyle}) {
2081                            $rbsopt = $rbsopt1->{$verpmstyle};
2082                        } elsif (defined $rbsopt1->{$ENV{'PBPROJ'}}) {
2083                            $rbsopt = $rbsopt1->{$ENV{'PBPROJ'}};
2084                        } else {
2085                            $rbsopt = "";
2086                        }
2087                    }
2088
2089                    my $postinstall = pb_get_postinstall($ddir,$dver,$darch,$rbspi,$verpmstyle);
2090                    if ($verpmstyle eq "rinse") {
2091                        # Need to reshape the mirrors generated with local before-post-install script
2092                        my $b4post = "--before-post-install ";
2093                        my $postparam = pb_distro_get_param($ddir,$dver,$darch,$rbsb4pi);
2094                        if ($postparam eq "") {
2095                            $b4post = "";
2096                        } else {
2097                            $b4post .= $postparam;
2098                        }
2099
2100                        # Need to reshape the package list for pb
2101                        my $addpkgs;
2102                        $postparam = "";
2103                        $postparam .= pb_distro_get_param($ddir,$dver,$darch,$osmindep);
2104                        if ($postparam eq "") {
2105                            $addpkgs = "";
2106                        } else {
2107                            my $pkgfile = "$ENV{'PBTMP'}/addpkgs.lis";
2108                            open(PKG,"> $pkgfile") || die "Unable to create $pkgfile";
2109                            foreach my $p (split(/,/,$postparam)) {
2110                                print PKG "$p\n";
2111                            }
2112                            close(PKG);
2113                            $addpkgs = "--add-pkg-list $pkgfile";
2114                        }
2115
2116                        my $rinseverb = "";
2117                        $rinseverb = "--verbose" if ($pbdebug gt 0);
2118                        my ($rbsconf) = pb_conf_get("rbsconf");
2119
2120                        my $command = pb_check_req("rinse",0);
2121                        pb_system("sudo $command --directory \"$vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch\" --arch \"$darch\" --distribution \"$ddir-$dver\" --config \"$rbsconf->{$ENV{'PBPROJ'}}\" $b4post $postinstall $rbsopt $addpkgs $rinseverb","Creating the rinse VE for $ddir-$dver ($darch)", "verbose");
2122                    } elsif ($verpmstyle eq "rpmbootstrap") {
2123                        my $rbsverb = "";
2124                        foreach my $i (1..$pbdebug) {
2125                            $rbsverb .= " -v";
2126                        }
2127                        my $addpkgs = "";
2128                        my $postparam = "";
2129                        $postparam .= pb_distro_get_param($ddir,$dver,$darch,$osmindep);
2130                        if ($postparam eq "") {
2131                            $addpkgs = "";
2132                        } else {
2133                            $addpkgs = "-a $postparam";
2134                        }
2135                        my $command = pb_check_req("rpmbootstrap",0);
2136                        pb_system("sudo $command $rbsopt $postinstall $addpkgs $ddir-$dver-$darch $rbsverb","Creating the rpmbootstrap VE for $ddir-$dver ($darch)", "verbose");
2137                    } elsif ($verpmstyle eq "mock") {
2138                        my ($rbsconf) = pb_conf_get("rbsconf");
2139                        my $command = pb_check_req("mock",0);
2140                        pb_system("sudo $command --init --resultdir=\"/tmp\" --configdir=\"$rbsconf->{$ENV{'PBPROJ'}}\" -r $v $rbsopt","Creating the mock VE for $ddir-$dver ($darch)");
2141                        # Once setup we need to install some packages, the pb account, ...
2142                        pb_system("sudo $command --install --configdir=\"$rbsconf->{$ENV{'PBPROJ'}}\" -r $v su","Configuring the mock VE");
2143                    } else {
2144                        die "Unknown verpmtype type $verpmstyle. Report to dev team";
2145                    }
2146                } elsif ($dtype eq "deb") {
2147                    my $vedebstyle = $vedebtype->{$ENV{'PBPROJ'}};
2148
2149                    my $codename = pb_distro_get_param($ddir,$dver,$darch,$oscodename);
2150                    my $postparam = "";
2151                    my $addpkgs;
2152                    $postparam .= pb_distro_get_param($ddir,$dver,$darch,$osmindep);
2153                    if ($postparam eq "") {
2154                        $addpkgs = "";
2155                    } else {
2156                        $addpkgs = "--include $postparam";
2157                    }
2158                    my $debmir = "";
2159                    $debmir .= pb_distro_get_param($ddir,$dver,$darch,$rbsmirrorsrv);
2160
2161                    # Get potential rbs option
2162                    my $rbsopt = "";
2163                    if (defined $rbsopt1) {
2164                        if (defined $rbsopt1->{$vedebstyle}) {
2165                            $rbsopt = $rbsopt1->{$vedebstyle};
2166                        } elsif (defined $rbsopt1->{$ENV{'PBPROJ'}}) {
2167                            $rbsopt = $rbsopt1->{$ENV{'PBPROJ'}};
2168                        } else {
2169                            $rbsopt = "";
2170                        }
2171                    }
2172   
2173                    # debootstrap works with amd64 not x86_64
2174                    my $debarch = $darch;
2175                    $debarch = "amd64" if ($darch eq "x86_64");
2176                    if ($vedebstyle eq "debootstrap") {
2177                        my $dbsverb = "";
2178                        $dbsverb = "--verbose" if ($pbdebug gt 0);
2179
2180                        # Some perl modules are in Universe on Ubuntu
2181                        $rbsopt .= " --components=main,universe" if ($ddir eq "ubuntu");
2182
2183                        pb_system("sudo /usr/sbin/debootstrap $dbsverb $rbsopt --arch=$debarch $addpkgs $codename \"$vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch\" $debmir","Creating the debootstrap VE for $ddir-$dver ($darch)", "verbose");
2184                        # debootstrap doesn't create an /etc/hosts file
2185                        if (! -f "$vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch/etc/hosts" ) {
2186                            pb_system("sudo cp /etc/hosts $vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch/etc/hosts");
2187                        }
2188                    } else {
2189                        die "Unknown vedebtype type $vedebstyle. Report to dev team";
2190                    }
2191                } elsif ($dtype eq "ebuild") {
2192                    die "Please teach the dev team how to build gentoo chroot";
2193                } else {
2194                    die "Unknown distribution type $dtype. Report to dev team";
2195                }
2196            }
2197            # Fix modes to allow access to the VE for pb user
2198            pb_system("sudo chmod 755 $vepath->{$ENV{'PBPROJ'}}/$ddir $vepath->{$ENV{'PBPROJ'}}/$ddir/$dver $vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch","Fixing permissions");
2199
2200            # Test if an existing snapshot exists and use it if appropriate
2201            # And also use it of no local extracted VE is present
2202            if ((-f "$vepath->{$ENV{'PBPROJ'}}/$ddir-$dver-$darch.tar.gz") &&
2203                (((defined $vesnap->{$v}) && ($vesnap->{$v} =~ /true/i)) ||
2204                    ((defined $vesnap->{$ENV{'PBPROJ'}}) && ($vesnap->{$ENV{'PBPROJ'}} =~ /true/i)) ||
2205                    ($pbsnap eq 1) ||
2206                    (! -d "$vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch"))) {
2207                        pb_system("sudo rm -rf $vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch ; sudo mkdir -p $vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch ; sudo tar xz  -C $vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch -f $vepath->{$ENV{'PBPROJ'}}/$ddir-$dver-$darch.tar.gz","Extracting snapshot of $ddir-$dver-$darch.tar.gz under $vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch");
2208            }
2209            # Nothing more to do for VE. No real launch
2210        } else {
2211            die "VE of type $vetype not supported. Report to the dev team";
2212        }
2213    }
2214}
2215
2216# Return string for date synchro
2217sub pb_date2v {
2218
2219my $vtype = shift;
2220my $v = shift;
2221
2222my ($ntp) = pb_conf_get_if($vtype."ntp");
2223my $vntp = $ntp->{$ENV{'PBPROJ'}} if (defined $ntp);
2224my $ntpline;
2225
2226if (defined $vntp) {
2227    my ($ntpcmd) = pb_conf_get($vtype."ntpcmd");
2228    my $vntpcmd;
2229    if (defined $ntpcmd->{$v}) {
2230        $vntpcmd = $ntpcmd->{$v};
2231    } elsif (defined $ntpcmd->{$ENV{'PBPROJ'}}) {
2232        $vntpcmd = $ntpcmd->{$ENV{'PBPROJ'}};
2233    } else {
2234        $vntpcmd = "/bin/true";
2235    }
2236    $ntpline = "sudo $vntpcmd $vntp";
2237} else {
2238    $ntpline = undef;
2239}
2240# Force new date to be in the future compared to the date
2241# of the host by adding 1 minute
2242my @date=pb_get_date();
2243$date[1]++;
2244my $upddate = strftime("%m%d%H%M%Y", @date);
2245my $dateline = "sudo date $upddate";
2246return($ntpline,$dateline);
2247}
2248
2249sub pb_build2v {
2250
2251my $vtype = shift;
2252my $action = shift || "build";
2253
2254my ($v,$all) = pb_get2v($vtype);
2255
2256# Send tar files when we do a global generation
2257pb_build2ssh() if (($all == 1) && ($action eq "build"));
2258
2259# Adapt // mode to memory size
2260$pbparallel = pb_set_parallel($vtype);
2261
2262my ($vmexist,$vmpid) = (undef,undef);
2263my $pm = new Parallel::ForkManager($pbparallel) if (defined $pbparallel);
2264
2265# Set which port the VM will use to communicate
2266$pm->run_on_start(\&pb_set_port);
2267
2268my $counter = 0;
2269foreach my $v (@$v) {
2270    $counter++;
2271    # Modulo 2 * pbparallel (to avoid synchronization problems)
2272    $counter = 1 if ($counter > 2 * $pbparallel);
2273    $pm->start($counter) and next if (defined $pbparallel);
2274    # Prepare the script to be executed on the VM/VE
2275    # in $ENV{'PBDESTDIR'}/pbscript.$$
2276    open(SCRIPT,"> $ENV{'PBDESTDIR'}/pbscript.$$") || die "Unable to create $ENV{'PBDESTDIR'}/pbscript.$$";
2277    print SCRIPT "#!/bin/bash\n";
2278
2279    # Transmit the verbosity level to the virtual env/mach.
2280    my $verbose = "";
2281    my $i = 0;                          # minimal debug level
2282    while ($i lt $pbdebug) {
2283        $verbose .= "-v ";
2284        $i++;
2285    }
2286    # Activate script verbosity if at least 2 for pbdebug
2287    print SCRIPT "set -x\n" if ($i gt 1);
2288    # Quiet if asked to be so on the original system
2289    $verbose = "-q" if ($pbdebug eq -1);
2290
2291    print SCRIPT "echo ... Execution needed\n";
2292    print SCRIPT "# This is in directory delivery\n";
2293    print SCRIPT "# Setup the variables required for building\n";
2294    print SCRIPT "export PBPROJ=$ENV{'PBPROJ'}\n";
2295
2296    if ($action eq "build") {
2297        print SCRIPT "# Preparation for pb\n";
2298        print SCRIPT "mv .pbrc \$HOME\n";
2299        print SCRIPT "cd ..\n";
2300    }
2301
2302    # VE needs a good /proc
2303    if ($vtype eq "ve") {
2304        print SCRIPT "sudo mount -t proc /proc /proc\n";
2305    }
2306
2307    my ($ntpline,$dateline) = pb_date2v($vtype,$v);
2308    print SCRIPT "# Time sync\n";
2309    print SCRIPT "echo 'setting up date with '";
2310    if (defined $ntpline) {
2311        print SCRIPT "echo $ntpline\n";
2312        print SCRIPT "$ntpline\n";
2313    } else {
2314        print SCRIPT "echo $dateline\n";
2315        print SCRIPT "$dateline\n";
2316    }
2317    # Use potential local proxy declaration in case we need it to download repo, pkgs, ...
2318    if (defined $ENV{'http_proxy'}) {
2319        print SCRIPT "export http_proxy=\"$ENV{'http_proxy'}\"\n";
2320    }
2321
2322    if (defined $ENV{'ftp_proxy'}) {
2323        print SCRIPT "export ftp_proxy=\"$ENV{'ftp_proxy'}\"\n";
2324    }
2325
2326    # Get list of packages to build/test and get some ENV vars as well
2327    my $ptr = pb_get_pkg();
2328    @pkgs = @$ptr;
2329    my $p = join(' ',@pkgs) if (@pkgs);
2330    print SCRIPT "export PBPROJVER=$ENV{'PBPROJVER'}\n";
2331    print SCRIPT "export PBPROJTAG=$ENV{'PBPROJTAG'}\n";
2332    print SCRIPT "export PBPACKAGER=\"$ENV{'PBPACKAGER'}\"\n";
2333
2334    # We may need to do some other tasks before building. Read a script here to finish setup
2335    if (-x "$ENV{'PBDESTDIR'}/pb$vtype".".pre") {
2336        print SCRIPT "# Special pre-instructions to be launched\n";
2337        print SCRIPT pb_get_content("$ENV{'PBDESTDIR'}/pb$vtype".".pre");
2338    }
2339
2340    if (-x "$ENV{'PBDESTDIR'}/pb$vtype"."$action.pre") {
2341        print SCRIPT "# Special pre-$action instructions to be launched\n";
2342        print SCRIPT pb_get_content("$ENV{'PBDESTDIR'}/pb$vtype"."$action.pre");
2343    }
2344
2345    print SCRIPT "# $action\n";
2346    print SCRIPT "echo $action"."ing packages on $vtype...\n";
2347
2348    if (($action eq "test") && (! -x "$ENV{'PBDESTDIR'}/pbtest")) {
2349            die "No test script ($ENV{'PBDESTDIR'}/pbtest) found when in test mode. Aborting ...";
2350    }
2351    print SCRIPT "pb $verbose -p $ENV{'PBPROJ'} $action"."2pkg $p\n";
2352
2353    if ($vtype eq "ve") {
2354        print SCRIPT "sudo umount /proc\n";
2355    }
2356
2357    # We may need to do some other tasks after building. Read a script here to exit properly
2358    if (-x "$ENV{'PBDESTDIR'}/pb$vtype"."$action.post") {
2359        print SCRIPT "# Special post-$action instructions to be launched\n";
2360        print SCRIPT pb_get_content("$ENV{'PBDESTDIR'}/pb$vtype"."$action.post");
2361    }
2362
2363    if (-x "$ENV{'PBDESTDIR'}/pb$vtype".".post") {
2364        print SCRIPT "# Special post-instructions to be launched\n";
2365        print SCRIPT pb_get_content("$ENV{'PBDESTDIR'}/pb$vtype".".post");
2366    }
2367
2368    close(SCRIPT);
2369    chmod 0755,"$ENV{'PBDESTDIR'}/pbscript.$$";
2370   
2371    # Launch the VM/VE
2372    ($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
2373
2374
2375    if ($vtype eq "vm") {
2376        # Skip that VM if something went wrong
2377        if (($vmpid == 0) && ($vmexist == 0)) {
2378            $pm->finish if (defined $pbparallel);
2379            next;
2380        }
2381    } else {
2382        # VE
2383        $vmexist = 0;
2384        $vmpid = 0;
2385    }
2386    # Gather all required files to send them to the VM/VE
2387    # and launch the build through pbscript
2388    pb_log(2,"Calling send2target $vtype,$v,$vmexist,$vmpid\n");
2389    pb_send2target(uc($vtype).$action,"$v",$vmexist,$vmpid);
2390    $pm->finish if (defined $pbparallel);
2391}
2392if (defined $pbparallel) {
2393    $pm->wait_all_children;
2394}
2395}
2396
2397
2398sub pb_clean {
2399
2400    my $sleep=10;
2401    die "Unable to get env var PBDESTDIR" if (not defined $ENV{'PBDESTDIR'});
2402    die "Unable to get env var PBBUILDDIR" if (not defined $ENV{'PBBUILDDIR'});
2403    pb_log(0,"We will now wait $sleep s before removing both directories\n$ENV{'PBDESTDIR'} and $ENV{'PBBUILDDIR'}.\nPlease break me if this is wrong\n");
2404    sleep $sleep;
2405    pb_rm_rf($ENV{'PBDESTDIR'});
2406    pb_rm_rf($ENV{'PBBUILDDIR'});
2407}
2408
2409sub pb_newver {
2410
2411    die "-V Version parameter needed" if ((not defined $newver) || ($newver eq ""));
2412
2413    # Need this call for PBDIR
2414    my ($scheme2,$uri) = pb_cms_init($pbinit);
2415
2416    my ($pbconf,$pburl) = pb_conf_get("pbconfurl","pburl");
2417    $uri = $pbconf->{$ENV{'PBPROJ'}};
2418    my ($scheme, $account, $host, $port, $path) = pb_get_uri($uri);
2419
2420    # Checking CMS repositories status
2421    ($scheme2, $account, $host, $port, $path) = pb_get_uri($pburl->{$ENV{'PBPROJ'}});
2422
2423    if ($scheme !~ /^svn/) {
2424        die "Only SVN is supported at the moment";
2425    }
2426
2427    my $res = pb_cms_isdiff($scheme,$ENV{'PBROOTDIR'});
2428    die "ERROR: No differences accepted in CMS for $ENV{'PBROOTDIR'} before creating a new version" if ($res != 0);
2429
2430    $res = pb_cms_isdiff($scheme2,$ENV{'PBDIR'});
2431    die "ERROR: No differences accepted in CMS for $ENV{'PBDIR'} before creating a new version" if ($res != 0);
2432
2433    # Tree identical between PBCONFDIR and PBROOTDIR. The delta is what
2434    # we want to get for the root of the new URL
2435
2436    my $tmp = $ENV{'PBROOTDIR'};
2437    $tmp =~ s|^$ENV{'PBCONFDIR'}||;
2438
2439    my $newurl = "$uri/".dirname($tmp)."/$newver";
2440    # Should probably use projver in the old file
2441    my $oldver= basename($tmp);
2442
2443    # Duplicate and extract project-builder part
2444    pb_log(2,"Copying $uri/$tmp to $newurl\n");
2445    pb_cms_copy($scheme,"$uri/$tmp",$newurl);
2446    pb_log(2,"Checkout $newurl to $ENV{'PBROOTDIR'}/../$newver\n");
2447    pb_cms_up($scheme,"$ENV{'PBCONFDIR'}/..");
2448
2449    # Duplicate and extract project
2450    my $newurl2 = "$pburl->{$ENV{'PBPROJ'}}/".dirname($tmp)."/$newver";
2451
2452    pb_log(2,"Copying $pburl->{$ENV{'PBPROJ'}}/$tmp to $newurl2\n");
2453    pb_cms_copy($scheme2,"$pburl->{$ENV{'PBPROJ'}}/$tmp",$newurl2);
2454    pb_log(2,"Checkout $newurl2 to $ENV{'PBDIR'}/../$newver\n");
2455    pb_cms_up($scheme2,"$ENV{'PBDIR'}/..");
2456
2457    # Update the .pb file
2458    open(FILE,"$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb") || die "Unable to open $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb";
2459    open(OUT,"> $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new") || die "Unable to write to $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new";
2460    while(<FILE>) {
2461        s/^projver\s+$ENV{'PBPROJ'}\s*=\s*$oldver/projver $ENV{'PBPROJ'} = $newver/;
2462        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/);
2463        pb_log(0,"Commenting testver in $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb\n") if (/^testver/);
2464        s/^testver/#testver/;
2465        print OUT $_;
2466        pb_log(0,"Please check delivery (".chomp($_).") in $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb\n") if (/^delivery/);
2467    }
2468    close(FILE);
2469    close(OUT);
2470    rename("$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new","$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb");
2471
2472    # Checking pbcl files
2473    foreach my $f (<$ENV{'PBROOTDIR'}/*/pbcl>) {
2474        # Compute new pbcl file
2475        my $f2 = $f;
2476        $f2 =~ s|$ENV{'PBROOTDIR'}|$ENV{'PBROOTDIR'}/../$newver/|;
2477        open(PBCL,$f) || die "Unable to open $f";
2478        my $foundnew = 0;
2479        while (<PBCL>) {
2480            $foundnew = 1 if (/^$newver \(/);
2481        }
2482        close(PBCL);
2483        open(OUT,"> $f2") || die "Unable to write to $f2: $!";
2484        open(PBCL,$f) || die "Unable to open $f";
2485        while (<PBCL>) {
2486            print OUT "$_" if (not /^$oldver \(/);
2487            if ((/^$oldver \(/) && ($foundnew == 0)) {
2488                print OUT "$newver ($pbdate)\n";
2489                print OUT "- TBD\n";
2490                print OUT "\n";
2491                pb_log(0,"WARNING: version $newver not found in $f so added to $f2...\n") if ($foundnew == 0);
2492            }
2493        }
2494        close(OUT);
2495        close(PBCL);
2496    }
2497
2498    pb_log(2,"Checkin $ENV{'PBROOTDIR'}/../$newver\n");
2499    pb_cms_checkin($scheme,"$ENV{'PBROOTDIR'}/../$newver",undef);
2500}
2501
2502#
2503# Return the list of VMs/VEs we are working on
2504# $all is a flag to know if we return all of them
2505# or only some (if all we publish also tar files in addition to pkgs
2506#
2507sub pb_get2v {
2508
2509my $vtype = shift;
2510my @v;
2511my $all = 0;
2512my $vlist;
2513my $pbv = 'PBV';
2514
2515if ($vtype eq "vm") {
2516    $vlist = "vmlist";
2517} elsif ($vtype eq "ve") {
2518    $vlist = "velist";
2519}
2520# Get VM/VE list
2521if ((not defined $ENV{$pbv}) || ($ENV{$pbv} =~ /^all$/)) {
2522    my ($ptr) = pb_conf_get($vlist);
2523    $ENV{$pbv} = $ptr->{$ENV{'PBPROJ'}};
2524    $all = 1;
2525}
2526pb_log(2,"$vtype: $ENV{$pbv}\n");
2527@v = split(/,/,$ENV{$pbv});
2528return(\@v,$all);
2529}
2530
2531# Function to create a potentialy missing pb account on the VM/VE, and adds it to sudo
2532# Needs to use root account to connect to the VM/VE
2533# pb will take your local public SSH key to access
2534# the pb account in the VM later on if needed
2535sub pb_setup2v {
2536
2537my $vtype = shift;
2538my $sbx = shift || undef;
2539
2540my ($vm,$all) = pb_get2v($vtype);
2541
2542# Script generated
2543my $pbscript = "$ENV{'PBDESTDIR'}/setupv";
2544
2545# Adapt // mode to memory size
2546$pbparallel = pb_set_parallel($vtype);
2547
2548my $pm = new Parallel::ForkManager($pbparallel) if (defined $pbparallel);
2549
2550# Set which port the VM will use to communicate
2551$pm->run_on_start(\&pb_set_port);
2552
2553my $counter = 0;
2554foreach my $v (@$vm) {
2555    $counter++;
2556    # Modulo pbparallel
2557    $counter = 1 if ($counter > $pbparallel);
2558    $pm->start($counter) and next if (defined $pbparallel);
2559
2560    # Deal with date sync.
2561    my ($ntpline,$dateline) = pb_date2v($vtype,$v);
2562
2563    # Get distro context
2564    my ($name,$ver,$darch) = split(/-/,$v);
2565    chomp($darch);
2566    my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf, $pbupd, $pbins) = pb_distro_init($name,$ver,$darch);
2567   
2568    # Name of the account to deal with for VM/VE
2569    # Do not use the one passed potentially with -a
2570    my ($pbac) = pb_conf_get($vtype."login");
2571    my ($key,$zero0,$zero1,$zero2);
2572    my ($vmexist,$vmpid);
2573
2574    # Prepare the script to be executed on the VM/VE
2575    # in $ENV{'PBDESTDIR'}/setupv
2576    open(SCRIPT,"> $pbscript") || die "Unable to create $pbscript";
2577   
2578    print SCRIPT << 'EOF';
2579#!/usr/bin/perl -w
2580
2581use strict;
2582use File::Copy;
2583
2584# We should not need in this script more functions than what is provided
2585# by Base, Conf and Distribution to avoid problems at exec time.
2586# They are appended at the end.
2587
2588# Define mandatory global vars
2589our $pbdebug;
2590our $pbLOG;
2591our $pbsynmsg = "pbscript";
2592our $pbdisplaytype = "text";
2593our $pblocale = "";
2594pb_log_init($pbdebug, $pbLOG);
2595pb_temp_init();
2596
2597EOF
2598
2599    # Launch the VM/VE - Usage of snapshot disabled
2600    ($vmexist,$vmpid) = pb_launchv($vtype,$v,0,0,0);
2601
2602    my $keyfile;
2603    my $nport;
2604    my $vmhost;
2605
2606    if ($vtype eq "vm") {
2607        # Prepare the key to be used and transfered remotely
2608        $keyfile = pb_ssh_get(1);
2609       
2610        my ($vmport,$vmntp);
2611        ($vmhost,$vmport,$vmntp) = pb_conf_get("vmhost","vmport","vmntp");
2612        $nport = pb_get_port($vmport->{$ENV{'PBPROJ'}});
2613   
2614        # Skip that VM if something went wrong
2615        next if (($vmpid == 0) && ($vmexist == 0));
2616   
2617        # Store the pub key part in a variable
2618        open(FILE,"$keyfile.pub") || die "Unable to open $keyfile.pub";
2619        ($zero0,$zero1,$zero2) = split(/ /,<FILE>);
2620        close(FILE);
2621
2622        $key = "\Q$zero1";
2623
2624        # We call true to avoid problems if SELinux is not activated, but chcon is present and returns in that case 1
2625        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 ; if [ -x /usr/bin/chcon ]; then /usr/bin/chcon -Rt home_ssh_t .ssh 2> /dev/null; /bin/true; fi\"","Copying local keys to $vtype. This may require the root password");
2626        # once this is done, we can do what we want on the VM remotely
2627    } elsif ($vtype eq "ve") {
2628        print SCRIPT << "EOF";
2629# For VE we need a good null dev
2630pb_system("rm -f /dev/null; mknod /dev/null c 1 3; chmod 777 /dev/null");
2631EOF
2632        print SCRIPT << "EOF";
2633# For VE we first need to mount some FS
2634pb_system("mount -t proc /proc /proc");
2635
2636EOF
2637    }
2638
2639if ($vtype eq "vm") {
2640        print SCRIPT << 'EOF';
2641# Removes duplicate in .ssh/authorized_keys of our key if needed
2642#
2643my $file1="$ENV{'HOME'}/.ssh/authorized_keys";
2644open(PBFILE,$file1) || die "Unable to open $file1";
2645open(PBOUT,"> $file1.new") || die "Unable to open $file1.new";
2646my $count = 0;
2647while (<PBFILE>) {
2648
2649EOF
2650        print SCRIPT << "EOF";
2651    if (/ $key /) {
2652        \$count++;
2653    }
2654print PBOUT \$_ if ((\$count <= 1) || (\$_ !~ / $key /));
2655}
2656close(PBFILE);
2657close(PBOUT);
2658rename("\$file1.new",\$file1);
2659chmod 0600,\$file1;
2660
2661# Sync date
2662EOF
2663        if (defined $ntpline) {
2664            print SCRIPT "pb_system(\"$ntpline\");\n";
2665        } else {
2666            print SCRIPT "pb_system(\"$dateline\");\n";
2667        }
2668    }
2669    print SCRIPT << 'EOF';
2670
2671# Adds $pbac->{$ENV{'PBPROJ'}} as an account if needed
2672#
2673my $file="/etc/passwd";
2674open(PBFILE,$file) || die "Unable to open $file";
2675my $found = 0;
2676while (<PBFILE>) {
2677EOF
2678    print SCRIPT << "EOF";
2679    \$found = 1 if (/^$pbac->{$ENV{'PBPROJ'}}:/);
2680EOF
2681
2682my $home = "/home";
2683# Solaris doesn't like that we use /home
2684$home = "/export/home" if ($dtype eq "pkg");
2685
2686    print SCRIPT << "EOF";
2687}
2688close(PBFILE);
2689
2690if ( \$found == 0 ) {
2691    if ( ! -d "$home" ) {
2692        pb_mkdir_p("$home");
2693    }
2694EOF
2695    print SCRIPT << "EOF";
2696pb_system("/usr/sbin/groupadd $pbac->{$ENV{'PBPROJ'}}","Adding group $pbac->{$ENV{'PBPROJ'}}");
2697pb_system("/usr/sbin/useradd -g $pbac->{$ENV{'PBPROJ'}} -m -d $home/$pbac->{$ENV{'PBPROJ'}} $pbac->{$ENV{'PBPROJ'}}","Adding user $pbac->{$ENV{'PBPROJ'}} (group $pbac->{$ENV{'PBPROJ'}} - home $home/$pbac->{$ENV{'PBPROJ'}})");
2698}
2699EOF
2700
2701    # Copy the content of our local conf file to the VM/VE
2702    my $content = pb_get_content(pb_distro_conffile());
2703    print SCRIPT << "EOF";
2704    #
2705    # Create a temporary local conf file for distribution support
2706    # This is created here before its use later. Its place is hardcoded, so no choice for the path
2707    #
2708    my \$tempconf = pb_distro_conffile();
2709    pb_mkdir_p(dirname(\$tempconf));
2710    open(CONF,"> \$tempconf") || die "Unable to create \$tempconf";
2711    print CONF q{$content};
2712    close(CONF);
2713EOF
2714
2715    if ($vtype eq "vm") {
2716        print SCRIPT << "EOF";
2717# allow ssh entry to build
2718#
2719mkdir "$home/$pbac->{$ENV{'PBPROJ'}}/.ssh",0700;
2720# Allow those accessing root to access the build account
2721copy("\$ENV{'HOME'}/.ssh/authorized_keys","$home/$pbac->{$ENV{'PBPROJ'}}/.ssh/authorized_keys");
2722chmod 0600,".ssh/authorized_keys";
2723pb_system("chown -R $pbac->{$ENV{'PBPROJ'}}:$pbac->{$ENV{'PBPROJ'}} $home/$pbac->{$ENV{'PBPROJ'}}","Finish setting up the account env for $pbac->{$ENV{'PBPROJ'}}");
2724
2725EOF
2726}
2727    print SCRIPT << 'EOF';
2728# No passwd for build account only keys
2729$file="/etc/shadow";
2730if (-f $file) {
2731    open(PBFILE,$file) || die "Unable to open $file";
2732    open(PBOUT,"> $file.new") || die "Unable to open $file.new";
2733    while (<PBFILE>) {
2734EOF
2735    print SCRIPT << "EOF";
2736        s/^$pbac->{$ENV{'PBPROJ'}}:\!\!:/$pbac->{$ENV{'PBPROJ'}}:*:/;
2737        s/^$pbac->{$ENV{'PBPROJ'}}:\!:/$pbac->{$ENV{'PBPROJ'}}:*:/; #SLES 9 e.g.
2738        s/^$pbac->{$ENV{'PBPROJ'}}:\\*LK\\*:/$pbac->{$ENV{'PBPROJ'}}:NP:/;  #Solaris e.g.
2739EOF
2740        print SCRIPT << 'EOF';
2741        print PBOUT $_;
2742    }
2743    close(PBFILE);
2744    close(PBOUT);
2745    rename("$file.new",$file);
2746    chmod 0640,$file;
2747    }
2748
2749# Keep the VM in text mode
2750$file="/etc/inittab";
2751if (-f $file) {
2752    open(PBFILE,$file) || die "Unable to open $file";
2753    open(PBOUT,"> $file.new") || die "Unable to open $file.new";
2754    while (<PBFILE>) {
2755        s/^(..):5:initdefault:$/$1:3:initdefault:/;
2756        print PBOUT $_;
2757    }
2758    close(PBFILE);
2759    close(PBOUT);
2760    rename("$file.new",$file);
2761    chmod 0640,$file;
2762}
2763
2764# pb has to be added to portage group on gentoo
2765
2766# We need to have that pb_distro_init function
2767# Get it from Project-Builder::Distribution
2768# And we now need the conf file required for this to work created above
2769
2770my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf, $pbupd, $pbins, $darch) = pb_distro_init(); 
2771print "distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf, $pbupd, $pbins, $darch))."\n";
2772
2773# Adapt sudoers
2774# sudo is not default on Solaris and needs to be installed first
2775# from http://www.sunfreeware.com/programlistsparc10.html#sudo
2776if ($dtype eq "pkg") {
2777    $file="/usr/local/etc/sudoers";
2778} else {
2779    $file="/etc/sudoers";
2780}
2781open(PBFILE,$file) || die "Unable to open $file";
2782open(PBOUT,"> $file.new") || die "Unable to open $file.new";
2783while (<PBFILE>) {
2784EOF
2785    print SCRIPT << "EOF";
2786    next if (/^$pbac->{$ENV{'PBPROJ'}}   /);
2787EOF
2788    print SCRIPT << 'EOF';
2789    s/Defaults[ \t]+requiretty//;
2790    print PBOUT $_;
2791}
2792close(PBFILE);
2793EOF
2794    print SCRIPT << "EOF";
2795# Some distro force requiretty at compile time, so disable here
2796print PBOUT "Defaults:$pbac->{$ENV{'PBPROJ'}} !requiretty\n";
2797print PBOUT "Defaults:root !requiretty\n";
2798# This is needed in order to be able to halt the machine from the $pbac->{$ENV{'PBPROJ'}} account at least
2799print PBOUT "Defaults:$pbac->{$ENV{'PBPROJ'}} env_keep += \\\"http_proxy ftp_proxy\\\"\n";
2800print PBOUT "$pbac->{$ENV{'PBPROJ'}}   ALL=(ALL) NOPASSWD:ALL\n";
2801EOF
2802    print SCRIPT << 'EOF';
2803close(PBOUT);
2804rename("$file.new",$file);
2805chmod 0440,$file;
2806
2807EOF
2808
2809    # We may need a proxy configuration. Get it from the local env
2810
2811    if (defined $ENV{'http_proxy'}) {
2812        print SCRIPT "\$ENV\{'http_proxy'\}=\"$ENV{'http_proxy'}\";\n";
2813    }
2814
2815    if (defined $ENV{'ftp_proxy'}) {
2816        print SCRIPT "\$ENV\{'ftp_proxy'\}=\"$ENV{'ftp_proxy'}\";\n";
2817    }
2818
2819    print SCRIPT << 'EOF';
2820   
2821# Suse wants sudoers as 640
2822if ((($ddir eq "sles") && (($dver =~ /10/) || ($dver =~ /9/))) || (($ddir eq "opensuse") && ($dver =~ /10.[012]/))) {
2823    chmod 0640,$file;
2824}
2825
2826# First install all required packages
2827pb_system("yum clean all","Cleaning yum env") if (($ddir eq "fedora") || ($ddir eq "asianux") || ($ddir eq "rhel"));
2828my ($ospkgdep) = pb_conf_get_if("ospkgdep");
2829   
2830my $pkgdep = pb_distro_get_param($ddir,$dver,$darch,$ospkgdep,$dfam,$dtype,$dos);
2831pb_distro_installdeps(undef,$dtype,$pbins,pb_distro_only_deps_needed($dtype,join(' ',split(/,/,$pkgdep))));
2832
2833EOF
2834    my ($instype) = pb_conf_get("pbinstalltype");
2835    my $itype = pb_distro_get_param($ddir,$dver,$darch,$instype,$dfam,$dtype,$dos);
2836    if (defined $sbx) {
2837        # Install from sandbox mean a file base install
2838        $itype = "file";
2839    }
2840    if ($itype =~ /^file/) {
2841        my $cmdget;
2842        if (defined $sbx) {
2843            # Install from sandbox mean using the result of the just passed sbx2build command
2844            # Get content saved in cms2build
2845            my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
2846            die "Unable to get package list" if (not defined $pkg);
2847
2848            # We consider 2 specific packages
2849            my $vertag1 = $pkg->{"ProjectBuilder"};
2850            my $vertag2 = $pkg->{"project-builder"};
2851            # get the version of the current package - maybe different
2852            my ($pbver1,$tmp1) = split(/-/,$vertag1);
2853            my ($pbver2,$tmp2) = split(/-/,$vertag2);
2854            # Copy inside the VE
2855            if ($vtype eq "ve") {
2856                my ($vepath) = pb_conf_get("vepath");
2857                copy("$ENV{'PBDESTDIR'}/ProjectBuilder-$pbver1.tar.gz","$vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch/tmp");
2858                copy("$ENV{'PBDESTDIR'}/project-builder-$pbver2.tar.gz","$vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch/tmp");
2859            } else {
2860                pb_system("scp -i $keyfile -p -o UserKnownHostsFile=/dev/null -P $nport $ENV{'PBDESTDIR'}/ProjectBuilder-$pbver1.tar.gz $ENV{'PBDESTDIR'}/project-builder-$pbver2.tar.gz root\@$vmhost->{$ENV{'PBPROJ'}}:/tmp","Copying local project files to $vtype.");
2861            }
2862            $cmdget = "mv /tmp/ProjectBuilder-$pbver1.tar.gz ProjectBuilder-latest.tar.gz ; mv /tmp/project-builder-$pbver2.tar.gz project-builder-latest.tar.gz";
2863        } else {
2864            $cmdget = "wget --passive-ftp ftp://ftp.project-builder.org/src/ProjectBuilder-latest.tar.gz; wget --passive-ftp ftp://ftp.project-builder.org/src/project-builder-latest.tar.gz";
2865        }
2866        print SCRIPT << 'EOF';
2867# Then install manually the missing perl modules
2868my ($osperldep,$osperlver) = pb_conf_get_if("osperldep","osperlver");
2869   
2870my $perldep = pb_distro_get_param($ddir,$dver,$darch,$osperldep,$dfam,$dtype,$dos);
2871foreach my $m (split(/,/,$perldep)) {
2872    # Skip empty deps
2873    next if ($m =~ /^\s*$/);
2874    my $dir = $m;
2875    $dir =~ s/-.*//;
2876    pb_system("echo \"rm -rf $m* ; wget http://search.cpan.org/CPAN/modules/by-module/$dir/$m-$osperlver->{$m}.tar.gz ; gzip -cd $m-$osperlver->{$m}.tar.gz | tar xf - ; cd $m* ; if [ -f Build.PL ]; then perl Build.PL; ./Build ; ./Build install ; else perl Makefile.PL; make ; make install ; fi; cd .. ; rm -rf $m*\" | bash" ,"Installing perl module $m-$osperlver->{$m}");
2877}
2878EOF
2879
2880        print SCRIPT << "EOF";
2881pb_system("rm -rf ProjectBuilder-* ; rm -rf project-builder-* ; $cmdget ; gzip -cd ProjectBuilder-latest.tar.gz | tar xf - ; cd ProjectBuilder-* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf ProjectBuilder-* ; gzip -cd project-builder-latest.tar.gz | tar xf - ; cd project-builder-* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf project-builder-* ;","Building Project-Builder");
2882EOF
2883    } elsif ($itype =~ /^pkg/) {
2884        # pkg based install. We need to point to the project-builder.org repository
2885        print SCRIPT << 'EOF';
2886my ($ospkg) = pb_conf_get_if("ospkg");
2887
2888my $pkgforpb = pb_distro_get_param($ddir,$dver,$darch,$ospkg,$dfam,$dtype,$dos);
2889pb_distro_setuposrepo($ddir,$dver,$darch,$dtype,$dfam,$dos);
2890pb_distro_installdeps(undef,$dtype,$pbins,pb_distro_only_deps_needed($dtype,join(' ',split(/,/,$pkgforpb))));
2891EOF
2892    } else {
2893        # Unknown install type
2894        die("Unknown install type $itype->{$ENV{'PBPROJ'}} for param pbinstalltype");
2895    }
2896    print SCRIPT << 'EOF';
2897pb_system("pb 2>&1 | head -5",undef,"verbose");
2898EOF
2899    if ($vtype eq "ve") {
2900            print SCRIPT << 'EOF';
2901# For VE we need to umount some FS at the end
2902
2903pb_system("umount /proc");
2904
2905# Create a basic network file if not already there
2906
2907my $nf="/etc/sysconfig/network";
2908if ((! -f $nf) && ($dtype eq "rpm")) {
2909    open(NF,"> $nf") || die "Unable to create $nf";
2910    print NF "NETWORKING=yes\n";
2911    print NF "HOSTNAME=localhost\n";
2912    close(NF);
2913}
2914chmod 0755,$nf;
2915EOF
2916    }
2917
2918    # Adds pb_distro_init and all functions needed from ProjectBuilder::Distribution, Conf and Base
2919    foreach my $d (@INC) {
2920        my @f = ("$d/ProjectBuilder/Base.pm","$d/ProjectBuilder/Distribution.pm","$d/ProjectBuilder/Conf.pm");
2921        foreach my $f (@f) {
2922            if (-f "$f") {
2923                open(PBD,"$f") || die "Unable to open $f";
2924                while (<PBD>) {
2925                    next if (/^package/);
2926                    next if (/^use Exporter/);
2927                    next if (/^use ProjectBuilder::/);
2928                    next if (/^our /);
2929                    print SCRIPT $_;
2930                }
2931                close(PBD);
2932            }
2933        }
2934    }
2935    # Use a fake pb_version_init version here
2936    print SCRIPT << "EOF";
2937sub pb_version_init {
2938
2939return("$projectbuilderver","$projectbuilderrev");
2940}
29411;
2942EOF
2943    close(SCRIPT);
2944    chmod 0755,"$pbscript";
2945
2946    # That build script needs to be run as root and force stop of VM at end
2947    $pbaccount = "root";
2948
2949    # Force shutdown of VM except if it was already launched
2950    my $pbforce = 0;
2951    if ((! $vmexist) && ($vtype eq "vm")) {
2952        $pbforce = 1;
2953    }
2954   
2955    pb_script2v($pbscript,$vtype,$pbforce,$v);
2956    $pm->finish if (defined $pbparallel);
2957}
2958if (defined $pbparallel) {
2959    $pm->wait_all_children;
2960}
2961return;
2962}
2963
2964# Function to create a snapshot named 'pb' for VMs and a compressed tar for VEs
2965sub pb_snap2v {
2966
2967my $vtype = shift;
2968
2969my ($vm,$all) = pb_get2v($vtype);
2970
2971# Script generated
2972my $pbscript = "$ENV{'PBDESTDIR'}/snapv";
2973
2974my ($pbac) = pb_conf_get($vtype."login");
2975
2976foreach my $v (@$vm) {
2977    if ($vtype eq "ve") {
2978        # Get distro context
2979        my ($name,$ver,$darch) = split(/-/,$v);
2980        chomp($darch);
2981        my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf) = pb_distro_init($name,$ver,$darch);
2982        my ($vepath) = pb_conf_get("vepath");
2983
2984        # Test if an existing snapshot exists and remove it if there is a VE
2985        if ((-f "$vepath->{$ENV{'PBPROJ'}}/$ddir-$dver-$darch.tar.gz") &&
2986            (! -d "$vepath->{$ENV{'PBPROJ'}}/$ddir/$dver/$darch")) {
2987                pb_system("sudo rm -f $vepath->{$ENV{'PBPROJ'}}/$ddir-$dver-$darch.tar.gz","Removing previous snapshot $ddir-$dver-$darch.tar.gz");
2988        }
2989    }
2990
2991    # Prepare the script to be executed on the VM/VE
2992    open(SCRIPT,"> $pbscript") || die "Unable to create $pbscript";
2993    print SCRIPT << 'EOF';
2994    #!/bin/bash
2995    sleep 2
2996EOF
2997    close(SCRIPT);
2998    chmod 0755,"$pbscript";
2999
3000    # Force shutdown of VM/VE
3001    # Force snapshot of VM/VE
3002    pb_script2v($pbscript,$vtype,1,$v,1);
3003}
3004return;
3005}
3006
3007# Function to update a VMs or VEs with the latest distribution content
3008sub pb_update2v {
3009
3010my $vtype = shift;
3011
3012my ($vm,$all) = pb_get2v($vtype);
3013
3014# Script generated
3015my $pbscript = "$ENV{'PBDESTDIR'}/updatev";
3016
3017my ($pbac) = pb_conf_get($vtype."login");
3018
3019foreach my $v (@$vm) {
3020    # Get distro context
3021    my ($name,$ver,$darch) = split(/-/,$v);
3022    chomp($darch);
3023    my ($ddir, $dver, $dfam, $dtype, $dos, $pbsuf, $pbupd, $pbins) = pb_distro_init($name,$ver,$darch);
3024
3025    # Prepare the script to be executed on the VM/VE
3026    # in $ENV{'PBDESTDIR'}/updatev
3027    open(SCRIPT,"> $pbscript") || die "Unable to create $pbscript";
3028   
3029    print SCRIPT << 'EOF';
3030    #!/bin/bash
3031    sleep 2
3032EOF
3033    # VE needs a good /proc
3034    if ($vtype eq "ve") {
3035        print SCRIPT "sudo mount -t proc /proc /proc\n";
3036    }
3037    print SCRIPT "$pbupd\n";
3038    if ($vtype eq "ve") {
3039        print SCRIPT "sudo umount /proc\n";
3040    }
3041    close(SCRIPT);
3042    chmod 0755,"$pbscript";
3043
3044    # Force shutdown of VM except
3045    pb_script2v($pbscript,$vtype,1,$v);
3046}
3047return;
3048}
3049
3050sub pb_announce {
3051
3052    # Get all required parameters
3053    my ($pbpackager,$pbrepo,$pbml,$pbsmtp) = pb_conf_get("pbpackager","pbrepo","pbml","pbsmtp");
3054    my ($pkgv, $pkgt, $testver) = pb_conf_get_if("pkgver","pkgtag","testver");
3055    my $pkg = pb_cms_get_pkg($defpkgdir,$extpkgdir);
3056    my @pkgs = @$pkg;
3057    my %pkgs;
3058    my $first = 0;
3059
3060    # Command to find packages on repo
3061    my $findstr = "find . ";
3062    # Generated announce files
3063    my @files;
3064
3065    foreach my $pbpkg (@pkgs) {
3066        if ($first != 0) {
3067            $findstr .= "-o ";
3068        }
3069        $first++;
3070        if ((defined $pkgv) && (defined $pkgv->{$pbpkg})) {
3071            $pbver = $pkgv->{$pbpkg};
3072        } else {
3073            $pbver = $ENV{'PBPROJVER'};
3074        }
3075        if ((defined $pkgt) && (defined $pkgt->{$pbpkg})) {
3076            $pbtag = $pkgt->{$pbpkg};
3077        } else {
3078            $pbtag = $ENV{'PBPROJTAG'};
3079        }
3080
3081        # TODO: use virtual/real names here now
3082        $findstr .= "-name \'$pbpkg-$pbver-$pbtag\.*.rpm\' -o -name \'$pbpkg"."_$pbver*\.deb\' -o -name \'$pbpkg-$pbver*\.ebuild\' ";
3083
3084        my $chglog;
3085
3086        # Get project info on log file and generate tmp files used later on
3087        pb_cms_init($pbinit);
3088        $chglog = "$ENV{'PBROOTDIR'}/$pbpkg/pbcl";
3089        $chglog = "$ENV{'PBROOTDIR'}/pbcl" if (! -f $chglog);
3090        $chglog = undef if (! -f $chglog);
3091
3092        open(OUT,"> $ENV{'PBTMP'}/$pbpkg.ann") || die "Unable to create $ENV{'PBTMP'}/$pbpkg.ann: $!";
3093        my %pb;
3094        $pb{'dtype'} = "announce";
3095        $pb{'realpkg'} = $pbpkg;
3096        $pb{'ver'} = $pbver;
3097        $pb{'tag'} = $pbtag;
3098        $pb{'suf'} = "N/A";     # Should not be empty even if unused
3099        $pb{'date'} = $pbdate;
3100        $pb{'chglog'} = $chglog;
3101        $pb{'packager'} = $pbpackager;
3102        $pb{'proj'} = $ENV{'PBPROJ'};
3103        $pb{'repo'} = $pbrepo;
3104        pb_changelog(\%pb,\*OUT,"yes");
3105        close(OUT);
3106        push(@files,"$ENV{'PBTMP'}/$pbpkg.ann");
3107    }
3108    $findstr .= " | grep -Ev \'src.rpm\'";
3109
3110    # Prepare the command to run and execute it
3111    open(PBS,"> $ENV{'PBTMP'}/pbscript") || die "Unable to create $ENV{'PBTMP'}/pbscript";
3112    print PBS "$findstr\n";
3113    close(PBS);
3114    chmod 0755,"$ENV{'PBTMP'}/pbscript";
3115    pb_send2target("Announce");
3116
3117    # Get subject line
3118    my $sl = "Project $ENV{'PBPROJ'} version $ENV{'PBPROJVER'} is now available";
3119    pb_log(0,"Please enter the title of your announce\n");
3120    pb_log(0,"(By default: $sl)\n");
3121    my $sl2 = <STDIN>;
3122    $sl = $sl2 if ($sl2 !~ /^$/);
3123
3124    # Prepare a template of announce
3125    open(ANN,"> $ENV{'PBTMP'}/announce.html") || die "Unable to create $ENV{'PBTMP'}/announce.html: $!";
3126    print ANN << "EOF";
3127$sl</p>
3128
3129<p>The project team is happy to announce the availability of a newest version of $ENV{'PBPROJ'} $ENV{'PBPROJVER'}. Enjoy it as usual!</p>
3130<p>
3131Now available at <a href="$pbrepo->{$ENV{'PBPROJ'}}">$pbrepo->{$ENV{'PBPROJ'}}</a>
3132</p>
3133<p>
3134EOF
3135    open(LOG,"$ENV{'PBTMP'}/system.$$.log") || die "Unable to read $ENV{'PBTMP'}/system.$$.log: $!";
3136    my $col = 2;
3137    my $i = 1;
3138    print ANN << 'EOF';
3139<TABLE WIDTH="700" CELLPADDING="0" CELLSPACING="0" BORDER="0">
3140<TR>
3141EOF
3142    while (<LOG>) {
3143        print ANN "<TD><A HREF=\"$pbrepo->{$ENV{'PBPROJ'}}/$_\">$_</A></TD>";
3144        $i++;
3145        if ($i > $col) {
3146            print ANN "</TR>\n<TR>";
3147            $i = 1;
3148        }
3149    }
3150    close(LOG);
3151    print ANN << "EOF";
3152</TR>
3153</TABLE>
3154</p>
3155
3156<p>As usual source packages are also available in the same directory.</p>
3157
3158<p>
3159Changes are :
3160</p>
3161<p>
3162EOF
3163    # Get each package changelog content
3164    foreach my $f (sort(@files)) {
3165        open(IN,"$f") || die "Unable to read $f:$!";
3166        while (<IN>) {
3167            print ANN $_;
3168        }
3169        close(IN);
3170        print ANN "</p><p>\n";
3171    }
3172    print ANN "</p>\n";
3173    close(ANN);
3174
3175    # Allow for modification
3176    my $editor = "vi";
3177    $editor = $ENV{'EDITOR'} if (defined $ENV{'EDITOR'});
3178    pb_system("$editor $ENV{'PBTMP'}/announce.html","Allowing modification of the announce","noredir");
3179
3180    # Store it in DB for external usage (Web pages generation)
3181    my $db = "$ENV{'PBCONFDIR'}/announces3.sql";
3182
3183    my $precmd = "";
3184    if (! -f $db) {
3185        $precmd = "CREATE TABLE announces (id INTEGER PRIMARY KEY AUTOINCREMENT, date DATE, announce VARCHAR[65535])";
3186    }
3187
3188    my $dbh = DBI->connect("dbi:SQLite:dbname=$db","","",
3189                        { RaiseError => 1, AutoCommit => 1 })
3190                        || die "Unable to connect to $db";
3191
3192    if ($precmd ne "") {
3193        my $sth = $dbh->prepare(qq{$precmd})
3194                    || die "Unable to create table into $db";
3195        $sth->execute();
3196    }
3197
3198    # To read whole file
3199    local $/;
3200    open(ANN,"$ENV{'PBTMP'}/announce.html") || die "Unable to read $ENV{'PBTMP'}/announce.html: $!";
3201    my $announce = <ANN>;
3202    close(ANN);
3203   
3204    pb_log(2,"INSERT INTO announces VALUES (NULL, $pbdate, $announce)");
3205    my $sth = $dbh->prepare(qq{INSERT INTO announces VALUES (NULL,?,?)})
3206                    || die "Unable to insert into $db";
3207    $sth->execute($pbdate, $announce);
3208    $sth->finish();
3209    $dbh->disconnect;
3210
3211    # Then deliver it on the Web
3212    # $TOOLHOME/livwww www
3213
3214    # Mail it to project's ML
3215    open(ML,"| w3m -dump -T text/html > $ENV{'PBTMP'}/announce.txt") || die "Unable to create $ENV{'PBTMP'}/announce.txt: $!";
3216    print ML << 'EOF';
3217<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/x html1/DTD/xhtml1-strict.dtd">
3218
3219<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" xml:lang="en" lang="en">
3220  <head>
3221  </head>
3222  <body>
3223  <p>
3224EOF
3225    open(ANN,"$ENV{'PBTMP'}/announce.html") || die "Unable to read $ENV{'PBTMP'}/announce.html: $!";
3226    while(<ANN>) {
3227        print ML $_;
3228    }
3229    print ML << 'EOF';
3230</body>
3231</html>
3232EOF
3233    close(ML);
3234
3235    # To read whole file
3236    local $/;
3237    open(ANN,"$ENV{'PBTMP'}/announce.txt") || die "Unable to read $ENV{'PBTMP'}/announce.txt: $!";
3238    my $msg = <ANN>;
3239    close(ANN);
3240   
3241    # Preparation of headers
3242    eval
3243    {
3244        require Mail::Sendmail;
3245        Mail::Sendmail->import();
3246    };
3247    if ($@) {
3248        # Mail::Sendmail not found not sending mail !
3249        pb_log(0,"No Mail::Sendmail module found so not sending any mail !\n");
3250    } else {
3251        my %mail = (   
3252            To          =>  $pbml->{$ENV{'PBPROJ'}},
3253            From        =>  $pbpackager->{$ENV{'PBPROJ'}},
3254            Smtp        =>  $pbsmtp->{$ENV{'PBPROJ'}},
3255            Body        =>  $msg,
3256            Subject     =>  "[ANNOUNCE] $sl",
3257        );
3258           
3259        # Send mail
3260        if (! sendmail(%mail)) {
3261            if ((defined $Mail::Sendmail::error) and (defined $Mail::Sendmail::log)) {
3262                die "Unable to send mail ($Mail::Sendmail::error): $Mail::Sendmail::log";
3263            }
3264        }
3265    }
3266}
3267
3268#
3269# Creates a set of HTML file containing the news for the project
3270# based on what has been generated by the pb_announce function
3271#
3272sub pb_web_news2html {
3273
3274    my $dest = shift || $ENV{'PBTMP'};
3275
3276    # Get all required parameters
3277    my ($pkgv, $pkgt) = pb_conf_get_if("pkgver","pkgtag");
3278
3279    # DB of announces for external usage (Web pages generation)
3280    my $db = "$ENV{'PBCONFDIR'}/announces3.sql";
3281
3282    my $dbh = DBI->connect("dbi:SQLite:dbname=$db","","",
3283                        { RaiseError => 1, AutoCommit => 1 })
3284                        || die "Unable to connect to $db";
3285    # For date handling
3286    $ENV{LANGUAGE}="C";
3287    my $firstjan = strftime("%Y-%m-%d", 0, 0, 0, 1, 0, localtime->year(), 0, 0, -1);
3288    my $oldfirst = strftime("%Y-%m-%d", 0, 0, 0, 1, 0, localtime->year()-1, 0, 0, -1);
3289    pb_log(2,"firstjan: $firstjan, oldfirst: $oldfirst, pbdate:$pbdate\n");
3290    my $all = $dbh->selectall_arrayref("SELECT id,date,announce FROM announces ORDER BY date DESC");
3291    my %news;
3292    $news{"cy"} = "";   # current year's news
3293    $news{"ly"} = "";   # last year news
3294    $news{"py"} = "";   # previous years news
3295    $news{"fp"} = "";   # first page news
3296    my $cpt = 4;        # how many news for first page
3297    # Extract info from DB
3298    foreach my $row (@$all) {
3299        my ($id, $date, $announce) = @$row;
3300        $news{"cy"} = $news{"cy"}."<p><B>$date</B> $announce\n" if ((($date cmp $pbdate) le 0) && (($firstjan cmp $date) le 0));
3301        $news{"ly"} = $news{"ly"}."<p><B>$date</B> $announce\n" if ((($date cmp $firstjan) le 0) && (($oldfirst cmp $date) le 0));
3302        $news{"py"} = $news{"py"}."<p><B>$date</B> $announce\n" if (($date cmp $oldfirst) le 0);
3303        $news{"fp"} = $news{"fp"}."<p><B>$date</B> $announce\n" if ($cpt > 0);
3304        $cpt--;
3305    }
3306    pb_log(1,"news{fp}: ".$news{"fp"}."\n");
3307    $dbh->disconnect;
3308
3309    # Generate the HTML content
3310    foreach my $pref (keys %news) {
3311        open(NEWS,"> $dest/pb_web_$pref"."news.html") || die "Unable to create $dest/pb_web_$pref"."news.html: $!";
3312        print NEWS "$news{$pref}";
3313        close(NEWS);
3314    }
3315}
3316
3317
3318# Return the SSH key file to use
3319# Potentially create it if needed
3320
3321sub pb_ssh_get {
3322
3323my $create = shift || 0;    # Do not create keys by default
3324
3325# Check the SSH environment
3326my $keyfile = undef;
3327
3328# We have specific keys by default
3329$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa";
3330if (!(-e $keyfile) && ($create eq 1)) {
3331    pb_system("ssh-keygen -q -b 1024 -N '' -f $keyfile -t dsa","Generating SSH keys for pb");
3332}
3333
3334$keyfile = "$ENV{'HOME'}/.ssh/id_rsa" if (-s "$ENV{'HOME'}/.ssh/id_rsa");
3335$keyfile = "$ENV{'HOME'}/.ssh/id_dsa" if (-s "$ENV{'HOME'}/.ssh/id_dsa");
3336$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa" if (-s "$ENV{'HOME'}/.ssh/pb_dsa");
3337die "Unable to find your public ssh key under $keyfile" if (not defined $keyfile);
3338return($keyfile);
3339}
3340
3341
3342# Returns the pid of a running VM command using a specific VM file
3343sub pb_check_ps {
3344    my $vmcmd = shift;
3345    my $vmm = shift;
3346    my $vmexist = 0;        # FALSE by default
3347
3348    open(PS, "ps auxhww|") || die "Unable to call ps";
3349    while (<PS>) {
3350        next if (! /$vmcmd/);
3351        next if (! /$vmm/);
3352        my ($void1, $void2);
3353        ($void1, $vmexist, $void2) = split(/ +/);
3354        last;
3355    }
3356    return($vmexist);
3357}
3358
3359
3360sub pb_extract_build_files {
3361
3362my $src=shift;
3363my $dir=shift;
3364my $ddir=shift;
3365my $mandatory=shift || "spec";
3366my @files;
3367
3368my $flag = "mayfail" if ($mandatory eq "patch");
3369my $res;
3370
3371if ($src =~ /tar\.gz$/) {
3372    $res = pb_system("tar xfpz $src $dir","Extracting $mandatory files from $src",$flag);
3373} elsif ($src =~ /tar\.bz2$/) {
3374    $res = pb_system("tar xfpj $src $dir","Extracting $mandatory files from $src",$flag);
3375} else {
3376    die "Unknown compression algorithm for $src";
3377}
3378# If not mandatory return now
3379return() if (($res != 0) and ($mandatory eq "patch"));
3380opendir(DIR,"$dir") || die "Unable to open directory $dir";
3381foreach my $f (readdir(DIR)) {
3382    next if ($f =~ /^\./);
3383    # Skip potential patch dir
3384    next if ($f =~ /^pbpatch/);
3385    move("$dir/$f","$ddir") || die "Unable to move $dir/$f to $ddir";
3386    pb_log(2,"mv $dir/$f $ddir\n");
3387    push @files,"$ddir/$f";
3388}
3389closedir(DIR);
3390# Not enough but still a first cleanup
3391pb_rm_rf("$dir");
3392return(@files);
3393}
3394
3395sub pb_list_bfiles {
3396
3397my $dir = shift;
3398my $pbpkg = shift;
3399my $bfiles = shift;
3400my $pkgfiles = shift;
3401my $supfiles = shift;
3402
3403opendir(BDIR,"$dir") || die "Unable to open dir $dir: $!";
3404foreach my $f (readdir(BDIR)) {
3405    next if ($f =~ /^\./);
3406    if (-d $f) {
3407        # Recurse for directories (Debian 3.0 format e.g.)
3408        pb_list_bfiles($f,$pbpkg,$bfiles,$pkgfiles,$supfiles);
3409        next;
3410    }
3411    $bfiles->{$f} = "$dir/$f";
3412    $bfiles->{$f} =~ s~$ENV{'PBROOTDIR'}~~;
3413    if (defined $supfiles->{$pbpkg}) {
3414        $pkgfiles->{$f} = "$dir/$f" if ($f =~ /$supfiles->{$pbpkg}/);
3415    }
3416}
3417closedir(BDIR);
3418}
3419
3420sub pb_list_sfiles {
3421
3422my $sdir = shift;
3423my $sources = shift;
3424my $dtype = shift;
3425my $dfam = shift;
3426my $ddir = shift;
3427my $dver = shift;
3428my $arch = shift;
3429my $extdir = shift;
3430
3431# Prepare local sources for this distro - They are always applied first - May be a problem one day
3432# This function works for both patches and additional sources
3433foreach my $p (sort(<$sdir/*>)) {
3434    $sources->{"$ddir-$dver-$arch"} .= "," if ((defined $sources->{"$ddir-$dver-$arch"}) and ($p =~ /\.all$/));
3435    $sources->{"$ddir-$dver-$arch"} .= "file://$p" if ($p =~ /\.all$/);
3436    $sources->{"$ddir-$dver-$arch"} .= "," if ((defined $sources->{"$ddir-$dver-$arch"}) and ($p =~ /\.$dtype$/));
3437    $sources->{"$ddir-$dver-$arch"} .= "file://$p" if ($p =~ /\.$dtype$/);
3438    $sources->{"$ddir-$dver-$arch"} .= "," if ((defined $sources->{"$ddir-$dver-$arch"}) and ($p =~ /\.$dfam$/));
3439    $sources->{"$ddir-$dver-$arch"} .= "file://$p" if ($p =~ /\.$dfam$/);
3440    $sources->{"$ddir-$dver-$arch"} .= "," if ((defined $sources->{"$ddir-$dver-$arch"}) and ($p =~ /\.$ddir$/));
3441    $sources->{"$ddir-$dver-$arch"} .= "file://$p" if ($p =~ /\.$ddir$/);
3442    $sources->{"$ddir-$dver-$arch"} .= "," if ((defined $sources->{"$ddir-$dver-$arch"}) and ($p =~ /\.$ddir-$dver$/));
3443    $sources->{"$ddir-$dver-$arch"} .= "file://$p" if ($p =~ /\.$ddir-$dver$/);
3444    $sources->{"$ddir-$dver-$arch"} .= "," if ((defined $sources->{"$ddir-$dver-$arch"}) and ($p =~ /\.$ddir-$dver-$arch$/));
3445    $sources->{"$ddir-$dver-$arch"} .= "file://$p" if ($p =~ /\.$ddir-$dver-$arch$/);
3446}
3447
3448# Prepare also remote sources to be included - Applied after the local ones
3449foreach my $p ("all","$dtype","$dfam","$ddir","$ddir-$dver","$ddir-$dver-$arch") {
3450    my $f = "$extdir.".".$p";
3451    next if (not -f $f);
3452    if (not open(PATCH,$f)) {
3453        pb_display("Unable to open existing external source file content $f\n");
3454        next;
3455    }
3456    while (<PATCH>) {
3457        chomp();
3458        $sources->{"$ddir-$dver-$arch"} .= "," if (defined $sources->{"$ddir-$dver-$arch"});
3459        $sources->{"$ddir-$dver-$arch"} .= "$_";
3460    }
3461    close(PATCH);
3462}
3463pb_log(2,"DEBUG: sources: ".Dumper($sources)."\n");
3464}
3465   
3466#
3467# Return the list of packages we are working on in a non CMS action
3468#
3469sub pb_get_pkg {
3470
3471my @pkgs = ();
3472
3473my ($var) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
3474@pkgs = keys %$var;
3475
3476pb_log(0,"Packages: ".join(',',@pkgs)."\n");
3477return(\@pkgs);
3478}
3479
3480#
3481# Return the postinstall line if needed
3482#
3483
3484sub pb_get_postinstall {
3485
3486my $ddir = shift;
3487my $dver = shift;
3488my $darch = shift;
3489my $rbspi = shift;
3490my $vestyle = shift;
3491my $post = "";
3492
3493# Do we have a local post-install script
3494if ($vestyle eq "rinse") {
3495    $post = "--post-install ";
3496} elsif ($vestyle eq "rpmbootstrap") {
3497    $post = "-s ";
3498}
3499
3500my $postparam = pb_distro_get_param($ddir,$dver,$darch,$rbspi);
3501if ($postparam eq "") {
3502    $post = "";
3503} else {
3504    $post .= $postparam;
3505}
3506return($post);
3507}
3508
3509# Manages VM SSH port communication
3510sub pb_get_port {
3511
3512my $port = shift;
3513my $cmt = shift;
3514
3515die "No port passed in parameter. Report to dev team\n" if (not defined $port);
3516pb_log(2,"pb_get_port with $port\n");
3517my $nport = $port;
3518# Maybe a port was given as parameter so overwrite
3519$nport = "$pbport" if (defined $pbport);
3520# Maybe in // mode so use the env var set up as an offset to the base port, except when called from send2target for Packages
3521if ((not defined $cmt) || ($cmt ne "Packages")) {
3522    $nport += $ENV{'PBVMPORT'} if ((defined $pbparallel) && (defined $ENV{'PBVMPORT'}));
3523}
3524pb_log(2,"pb_get_port returns $nport\n");
3525return($nport);
3526}
3527
3528sub pb_set_port { 
3529       
3530my ($pid,$ident) = @_;
3531pb_log(2,"pb_set_port for VM ($pid), id $ident\n");
3532$ENV{'PBVMPORT'} = $ident;
3533pb_log(2,"pb_set_port sets PBVMPORT in env to $ENV{'PBVMPORT'}\n");
3534}
3535
3536sub pb_set_parallel {
3537
3538my $vtype = shift;
3539
3540pb_log(2,"pb_set_parallel vtype: $vtype\n");
3541# Take care of memory size if VM, parallel mode and more than 1 action
3542if ((defined $pbparallel) && ($pbparallel ne 1) && ($vtype eq "vm")) {
3543    eval
3544    {
3545        require Linux::SysInfo;
3546        Linux::SysInfo->import();
3547    };
3548    if ($@) {
3549        # Linux::SysInfo not found
3550        pb_log(1,"ADVISE: Install Linux::SysInfo to benefit from automatic parallelism optimization.\nOr optimize manually pbparallel in your pb.conf file\nUsing $pbparallel processes max at a time for the moment\nWARNING: This may consume too much memory for your system");
3551    } else {
3552        # Using the memory size
3553        my $si = Linux::SysInfo::sysinfo();
3554        if (not defined $si) {
3555            pb_log(1,"ADVISE: Install Linux::SysInfo to benefit from automatic parallelism optimization.\nOr optimize manually pbparallel in your pb.conf file\nUsing $pbparallel processes max at a time for the moment\nWARNING: This may consume too much memory for your system");
3556        } else {
3557            # Keep the number of VM whose memory can be allocated
3558            my $ram = $si->{"totalram"}-$si->{"sharedram"}-$si->{"bufferram"};
3559            my $ram2;
3560            my ($vmmem) = pb_conf_get_if("vmmem");
3561
3562            my $v = "default";
3563            if ((defined $vmmem) and (defined $vmmem->{$v})) {
3564                $ram2 = $vmmem->{$v};
3565            } else {
3566                # Default for KVM/QEMU
3567                $ram2 = 128;
3568            }
3569            $pbparallel = sprintf("%d",$ram/$ram2);
3570        }
3571        pb_log(1,"Using $pbparallel processes at a time\n");
3572    }
3573}
3574pb_log(2,"pb_set_parallel returns: $pbparallel\n");
3575return($pbparallel);
3576}
3577
3578
35791;
Note: See TracBrowser for help on using the repository browser.