source: devel/pb/bin/pb @ 1359

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