Context Navigation

source: ProjectBuilder/devel/pb/bin/pb@ 1359

Last change on this file since 1359 was 1359, checked in by Bruno Cornec, 12 years ago
Add support of patches for Debian/Ubuntu distributions (useful for fixing a MondoRescue bug only in that distro)
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
12	use 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
18	use Getopt::Long qw(:config auto_abbrev no_ignore_case);
19	use Data::Dumper;
20	use English;
21	use File::Basename;
22	use File::Copy;
23	use File::stat;
24	use File::Temp qw(tempdir);
25	use File::Find;
26	use Time::localtime qw(localtime);
27	use POSIX qw(strftime);
28	use lib qw (lib);
29	use ProjectBuilder::Version;
30	use ProjectBuilder::Base;
31	use ProjectBuilder::Display;
32	use ProjectBuilder::Conf;
33	use ProjectBuilder::Distribution;
34	use ProjectBuilder::CMS;
35	use ProjectBuilder::Env;
36	use ProjectBuilder::Filter;
37	use ProjectBuilder::Changelog;
38	use ProjectBuilder::VE;
39
40	# Global variables
41	my %opts; # CLI Options
42	my $action; # action to realize
43	my $test = "FALSE"; # Not used
44	my $pbforce = 0; # Force VE/VM rebuild
45	my $pbsnap = 0; # Do not use snapshot mode for VM/VE by default
46	my $option = ""; # Not used
47	my @pkgs; # list of packages
48	my $pbtag; # Global Tag variable
49	my $pbver; # Global Version variable
50	my $pbscript; # Name of the script
51	my %pbver; # per package
52	my %pbtag; # per package
53	my $pbrev; # Global REVISION variable
54	my $pbaccount; # Login to use to connect to the VM/RM
55	my $pbtarget; # Target os-ver-arch you want to build for
56	my $pbport; # Port to use to connect to the VM/RM
57	my $newver; # New version to create
58	my $iso = undef; # ISO image for the VM to create
59
60	my @date = pb_get_date();
61	my $pbdate = strftime("%Y-%m-%d", @date);
62
63	=pod
64
65	=head1 NAME
66
67	pb, aka project-builder.org - builds packages for your projects
68
69	=head1 DESCRIPTION
70
71	pb helps you build various packages directly from your project sources.
72	Those sources could be handled by a CMS (Configuration Management System)
73	such as Subversion, CVS, Git, Mercurial... or being a simple reference to a compressed tar file.
74	It's based on a set of configuration files, a set of provided macros to help
75	you keeping build files as generic as possible. For example, a single .spec
76	file should be required to generate for all rpm based distributions, even
77	if you could also have multiple .spec files if required.
78
79	=head1 SYNOPSIS
80
81	pb [-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
83	pb [--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
91	Print a brief help message and exits.
92
93	=item B<-q\|--quiet>
94
95	Do not print any output.
96
97	=item B<-h\|--help>
98
99	Print a brief help message and exits.
100
101	=item B<-S\|--snapshot>
102
103	Use the snapshot mode of VMs or VEs
104
105	=item B<--man>
106
107	Prints the manual page and exits.
108
109	=item B<-t\|--target os-ver-arch>
110
111	Name of the target system you want to build for.
112	All if none precised.
113
114	=item B<-m\|--machine os-ver-arch[,os-ver-arch,...]>
115
116	Name of the Virtual Machines (VM), Virtual Environments (VE) or Remote Machines (RM)
117	you want to build on (coma separated).
118	All if none precised (or use the env variable PBV).
119
120	=item B<-s\|--script script>
121
122	Name of the script you want to execute on the related VMs/VEs/RMs.
123
124	=item B<-g\|--nographic>
125
126	Do not launch VMs in graphical mode.
127
128	=item B<-i\|--iso iso_image>
129
130	Name of the ISO image of the distribution you want to install on the related VMs.
131
132	=item B<-a\|--account account>
133
134	Name of the account to use to connect on the related VMs/RMs.
135
136	=item B<-P\|--port port_number>
137
138	Port number to use to connect on the related VMs/RMs.";
139
140	=item B<-p\|--project project_name>
141
142	Name of the project you're working on (or use the env variable PBPROJ)
143
144	=item B<-r\|--revision revision>
145
146	Path Name of the project revision under the CMS (or use the env variable PBROOT)
147
148	=item B<-V\|--version new_version>
149
150	New 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
162	Create tar files for the project under your CMS.
163	Current state of the exported content is taken.
164	CMS supported are SVN, SVK, CVS, Git and Mercurial
165	parameters are packages to build
166	if not using default list
167
168	=item B<cms2build>
169
170	Create tar files for the project under your CMS.
171	Current state of the CMS is taken.
172	CMS supported are SVN, SVK, CVS, Git and Mercurial
173	parameters are packages to build
174	if not using default list
175
176	=item B<build2pkg>
177
178	Create packages for your running distribution
179
180	=item B<cms2pkg>
181
182	cms2build + build2pkg
183
184	=item B<sbx2pkg>
185
186	sbx2build + build2pkg
187
188	=item B<build2ssh>
189
190	Send the tar files to a SSH host
191
192	=item B<sbx2ssh>
193
194	sbx2build + build2ssh
195
196	=item B<cms2ssh>
197
198	cms2build + build2ssh
199
200	=item B<pkg2ssh>
201
202	Send the packages built to a SSH host
203
204	=item B<build2vm>
205
206	Create packages in VMs, launching them if needed
207	and send those packages to a SSH host once built
208	VM type supported are QEMU and KVM
209
210	=item B<build2ve>
211
212	Create packages in VEs, creating it if needed
213	and send those packages to a SSH host once built
214
215	=item B<build2rm>
216
217	Create packages in RMs, which should pre-exist,
218	and send those packages to a SSH host once built
219	RM means Remote Machine, and could be a physical or Virtual one.
220	This is one buildfarm integration for pb.
221
222	=item B<sbx2vm>
223
224	sbx2build + build2vm
225
226	=item B<sbx2ve>
227
228	sbx2build + build2ve
229
230	=item B<sbx2rm>
231
232	sbx2build + build2rm
233
234	=item B<cms2vm>
235
236	cms2build + build2vm
237
238	=item B<cms2ve>
239
240	cms2build + build2ve
241
242	=item B<cms2rm>
243
244	cms2build + build2rm
245
246	=item B<launchvm>
247
248	Launch one virtual machine
249
250	=item B<launchve>
251
252	Launch one virtual environment
253
254	=item B<script2vm>
255
256	Launch one virtual machine if needed
257	and executes a script on it
258
259	=item B<script2ve>
260
261	Execute a script in a virtual environment
262
263	=item B<script2rm>
264
265	Execute a script on a remote machine
266
267	=item B<newvm>
268
269	Create a new virtual machine
270
271	=item B<newve>
272
273	Create a new virtual environment
274
275	=item B<setupvm>
276
277	Setup a virtual machine for pb usage
278
279	=item B<setupve>
280
281	Setup a virtual environment for pb usage
282
283	=item B<setuprm>
284
285	Setup a remote machine for pb usage
286
287	=item B<sbx2setupvm>
288
289	Setup a virtual machine for pb usage using the sandbox version of pb instead of the latest stable
290	Reserved to dev team.
291
292	=item B<sbx2setupve>
293
294	Setup a virtual environment for pb usage using the sandbox version of pb instead of the latest stable
295	Reserved to dev team.
296
297	=item B<sbx2setuprm>
298
299	Setup a remote machine for pb usage using the sandbox version of pb instead of the latest stable
300	Reserved to dev team.
301
302	=item B<snapvm>
303
304	Snapshot a virtual machine for pb usage
305
306	=item B<snapve>
307
308	Snapshot a virtual environment for pb usage
309
310	=item B<updatevm>
311
312	Update the distribution in the virtual machine
313
314	=item B<updateve>
315
316	Update the distribution in the virtual environment
317
318	=item B<updaterm>
319
320	Update the distribution in the remote machine
321
322	=item B<test2pkg>
323
324	Test a package locally
325
326	=item B<test2vm>
327
328	Test a package in a virtual machine
329
330	=item B<test2ve>
331
332	Test a package in a virtual environment
333
334	=item B<test2rm>
335
336	Test a package in a remote machine
337
338	=item B<newver>
339
340	Create a new version of the project derived
341	from the current one
342
343	=item B<newproj>
344
345	Create a new project and a template set of
346	configuration files under pbconf
347
348	=item B<announce>
349
350	Announce the availability of the project through various means
351
352	=item B<sbx2webssh>
353
354	Create tar files for the website under your CMS.
355	Current state of the exported content is taken.
356	Deliver the content to the target server using ssh from the exported dir.
357
358	=item B<cms2webssh>
359
360	Create tar files for the website from your CMS.
361	Deliver the content to the target server using ssh from the DVCS.
362
363	=item B<sbx2webpkg>
364
365	Create tar files for the website under your CMS.
366	Current state of the exported content is taken.
367
368	=item B<cms2webpkg>
369
370	Create tar files for the website under your CMS.
371
372	=item B<clean>
373
374	Purge 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
382	The 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
386	None exists for the moment.
387
388	=head1 CONFIGURATION FILES
389
390	Each pb user may have a configuration in F<$HOME/.pbrc>. The values in this file may overwrite any other configuration file value.
391
392	Here 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
442	The 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
446	Project-Builder.org is distributed under the GPL v2.0 license
447	described in the file C<COPYING> included with the distribution.
448
449	=cut
450
451	# ---------------------------------------------------------------------------
452
453	my ($projectbuilderver,$projectbuilderrev) = pb_version_init();
454	my $appname = "pb";
455
456	# Initialize the syntax string
457
458	pb_syntax_init("$appname (aka project-builder.org) Version $projectbuilderver-$projectbuilderrev\n");
459
460	GetOptions("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
479	if (defined $opts{'h'}) {
480	pb_syntax(0,1);
481	}
482	if (defined $opts{'man'}) {
483	pb_syntax(0,2);
484	}
485	if (defined $opts{'v'}) {
486	$pbdebug = $opts{'v'};
487	}
488	if (defined $opts{'f'}) {
489	$pbforce=1;
490	}
491	if (defined $opts{'q'}) {
492	$pbdebug=-1;
493	}
494	if (defined $opts{'S'}) {
495	$pbsnap=1;
496	}
497	if (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	}
502	pb_log_init($pbdebug, $pbLOG);
503	pb_display_init("text","");
504
505	# Handle root of the project if defined
506	if (defined $opts{'r'}) {
507	$ENV{'PBROOTDIR'} = $opts{'r'};
508	}
509	# Handle virtual machines if any
510	if (defined $opts{'m'}) {
511	$ENV{'PBV'} = $opts{'m'};
512	}
513	if (defined $opts{'s'}) {
514	$pbscript = $opts{'s'};
515	}
516	if (defined $opts{'a'}) {
517	$pbaccount = $opts{'a'};
518	die "option -a requires a -s script option" if (not defined $pbscript);
519	}
520	if (defined $opts{'P'}) {
521	$pbport = $opts{'P'};
522	}
523	if (defined $opts{'V'}) {
524	$newver = $opts{'V'};
525	}
526	if (defined $opts{'i'}) {
527	$iso = $opts{'i'};
528	}
529	if (defined $opts{'t'}) {
530	$pbtarget = $opts{'t'};
531	}
532
533	# Get Action
534	$action = shift @ARGV;
535	die pb_syntax(-1,1) if (not defined $action);
536
537	my ($filteredfiles, $supfiles, $defpkgdir, $extpkgdir);
538	my $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	#
548	my ($req,$opt,$pbpara) = pb_conf_get_if("oscmd","oscmdopt","pbparallel");
549	pb_check_requirements($req,$opt,$appname);
550
551	#
552	# Check if we can launch some actions in // with Parallel::ForkManager
553	#
554	my $pbparallel = $pbpara->{$appname} if (defined $pbpara);
555	if (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
572	eval
573	{
574	require Parallel::ForkManager;
575	Parallel::ForkManager->import();
576	};
577	# Parallel::ForkManager not found so no // actions
578	if ($@) {
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
583	pb_log(0,"Project: $ENV{'PBPROJ'}\n");
584	pb_log(0,"Action: $action\n");
585
586	# Act depending on action
587	if ($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
727	sub 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
1137	sub 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
1155	sub 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
1475	sub 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
1496	sub pb_build2ssh {
1497	pb_send2target("Sources");
1498	}
1499
1500	sub 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
1506	sub 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
1694	EOF
1695	print PBS "set -x\n" if ($pbdebug gt 1);
1696	print PBS << "EOF";
1697	cat > $ENV{'PBPROJ'}.repo << EOT
1698	[$ENV{'PBPROJ'}]
1699	name=$pbos->{'name'} $pbos->{'version'} $pbos->{'arch'} - $ENV{'PBPROJ'} Vanilla Packages
1700	baseurl=$pbrepo->{$ENV{'PBPROJ'}}/$repodir
1701	enabled=1
1702	gpgcheck=1
1703	gpgkey=$pbrepo->{$ENV{'PBPROJ'}}/$repodir/$ENV{'PBPROJ'}.pubkey
1704	EOT
1705	chmod 644 $ENV{'PBPROJ'}.repo
1706
1707	# Clean up old repo content
1708	rm -rf headers/ repodata/
1709	# Create yum repo
1710	if [ -x /usr/bin/yum-arch ]; then
1711	yum-arch .
1712	fi
1713	# Create repodata
1714	createrepo -s $pbsha .
1715	EOF
1716	if ($pbos->{'family'} eq "md") {
1717	# For Mandriva add urpmi management
1718	print PBS << "EOF";
1719	# Prepare a script to ease urpmi setup
1720	cat > $ENV{'PBPROJ'}.addmedia << EOT
1721	urpmi.addmedia $ENV{'PBPROJ'} $pbrepo->{$ENV{'PBPROJ'}}/$repodir with media_info/hdlist.cz
1722	EOT
1723	chmod 755 $ENV{'PBPROJ'}.addmedia
1724
1725	# Clean up old repo content
1726	rm -f hdlist.cz synthesis.hdlist.cz
1727	# Create urpmi repo
1728	genhdlist2 --clean .
1729	if [ \$\? -ne 0 ]; then
1730	genhdlist .
1731	fi
1732	EOF
1733	}
1734	if ($pbos->{'name'} eq "fedora") {
1735	# Extract the spec file to please Fedora maintainers :-(
1736	print PBS << "EOF";
1737	for 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
1742	done
1743	EOF
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	#
1751	cat > $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 -->
1773	EOT
1774	for 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>
1784	EOT
1785	done
1786	cat >> $ENV{'PBPROJ'}.ymp << EOT
1787	</software>
1788	</group>
1789	</metapackage>
1790	EOT
1791	chmod 644 $ENV{'PBPROJ'}.ymp
1792	EOF
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
1806	cat > $ENV{'PBPROJ'}.sources.list << EOT
1807	deb $rpd $pbos->{'version'} contrib
1808	deb-src $rpd $pbos->{'version'} contrib
1809	EOT
1810	chmod 644 $ENV{'PBPROJ'}.sources.list
1811
1812	# Up two levels to deal with the dist dir cross versions
1813	cd ..
1814	mkdir -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
1818	TMPD=`mktemp -d /tmp/pb.XXXXXXXXXX` \|\| exit 1
1819	mkdir -p \$TMPD
1820	cat > \$TMPD/Release << EOT
1821	Archive: unstable
1822	Component: contrib
1823	Origin: $ENV{'PBPROJ'}
1824	Label: $ENV{'PBPROJ'} dev repository $pbrepo->{$ENV{'PBPROJ'}}
1825	EOT
1826
1827	echo "Creating Packages metadata ($pbos->{'arch'} aka $debarch)"
1828	dpkg-scanpackages -a$debarch $pbos->{'version'} /dev/null \| gzip -c9 > dists/$pbos->{'version'}/contrib/binary-$debarch/Packages.gz
1829	dpkg-scanpackages -a$debarch $pbos->{'version'} /dev/null \| bzip2 -c9 > dists/$pbos->{'version'}/contrib/binary-$debarch/Packages.bz2
1830	echo "Creating Contents metadata"
1831	apt-ftparchive contents $pbos->{'version'} \| gzip -c9 > dists/$pbos->{'version'}/Contents.gz
1832	echo "Creating Release metadata ($pbos->{'arch'} aka $debarch)"
1833	cat \$TMPD/Release > dists/$pbos->{'version'}/contrib/binary-$debarch/Release
1834	echo "Architecture: $debarch" >> dists/$pbos->{'version'}/contrib/binary-$debarch/Release
1835	echo "Creating Source metadata"
1836	dpkg-scansources $pbos->{'version'} /dev/null \| gzip -c9 > dists/$pbos->{'version'}/contrib/source/Sources.gz
1837	cat \$TMPD/Release > dists/$pbos->{'version'}/contrib/source/Release
1838	echo "Architecture: Source" >> dists/$pbos->{'version'}/contrib/source/Release
1839	echo "Creating Release metadata"
1840	apt-ftparchive release dists/$pbos->{'version'} > dists/$pbos->{'version'}/Release
1841	rm -rf \$TMPD
1842	EOF
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
1848	for 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
1855	done
1856	EOF
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
2028	sub 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
2081	sub 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
2241	sub pb_date2v {
2242
2243	my $vtype = shift;
2244	my $pbos = shift;
2245
2246	my ($ntp) = pb_conf_get_if($vtype."ntp");
2247	my $vntp = $ntp->{$ENV{'PBPROJ'}} if (defined $ntp);
2248	my $ntpline = undef;
2249
2250	if (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
2257	my @date=pb_get_date();
2258	$date[1]++;
2259	my $upddate = strftime("%m%d%H%M%Y", @date);
2260	my $dateline = "sudo /bin/date $upddate";
2261	if (defined $ntpline) {
2262	return($ntpline);
2263	} else {
2264	return($dateline);
2265	}
2266	}
2267
2268	sub pb_build2v {
2269
2270	my $vtype = shift;
2271	my $action = shift \|\| "build";
2272
2273	my ($v,$all) = pb_get2v($vtype);
2274
2275	# Send tar files when we do a global generation
2276	pb_build2ssh() if (($all == 1) && ($action eq "build"));
2277
2278	# Adapt // mode to memory size
2279	$pbparallel = pb_set_parallel($vtype);
2280
2281	my ($vmexist,$vmpid) = (undef,undef);
2282	my $pm;
2283	if (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
2290	my $counter = 0;
2291	foreach 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
2416	sub 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
2427	sub 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	#
2525	sub pb_get2v {
2526
2527	my $vtype = shift;
2528	my @v;
2529	my $all = 0;
2530	my $pbv = 'PBV';
2531	my $vlist = $vtype."list";
2532
2533	# Get VM/VE list
2534	if ((not defined $ENV{$pbv}) \|\| ($ENV{$pbv} =~ /^all$/)) {
2535	my ($ptr) = pb_conf_get($vlist);
2536	$ENV{$pbv} = $ptr->{$ENV{'PBPROJ'}};
2537	$all = 1;
2538	}
2539	pb_log(2,"$vtype: $ENV{$pbv}\n");
2540	@v = split(/,/,$ENV{$pbv});
2541	return(\@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
2548	sub pb_setup2v {
2549
2550	my $vtype = shift;
2551	my $sbx = shift \|\| undef;
2552
2553	my ($vm,$all) = pb_get2v($vtype);
2554
2555	# Script generated
2556	my $pbscript = "$ENV{'PBDESTDIR'}/setupv";
2557
2558	# Adapt // mode to memory size
2559	$pbparallel = pb_set_parallel($vtype);
2560
2561	my $pm;
2562	if (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
2569	my $counter = 0;
2570	foreach 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
2595	use strict;
2596	use 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
2603	our $pbdebug;
2604	our $pbLOG;
2605	our $pbsynmsg = "pbscript";
2606	our $pbdisplaytype = "text";
2607	our $pblocale = "";
2608	pb_log_init($pbdebug, $pbLOG);
2609	pb_temp_init();
2610
2611	EOF
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
2644	pb_system("rm -f /dev/null; mknod /dev/null c 1 3; chmod 777 /dev/null");
2645	EOF
2646	print SCRIPT << "EOF";
2647	# For VE we first need to mount some FS
2648	pb_system("mount -t proc /proc /proc");
2649
2650	EOF
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	#
2657	my $file1="$ENV{'HOME'}/.ssh/authorized_keys";
2658	open(PBFILE,$file1) \|\| die "Unable to open $file1";
2659	open(PBOUT,"> $file1.new") \|\| die "Unable to open $file1.new";
2660	my $count = 0;
2661	while (<PBFILE>) {
2662
2663	EOF
2664	print SCRIPT << "EOF";
2665	if (/ $key /) {
2666	\$count++;
2667	}
2668	print PBOUT \$_ if ((\$count <= 1) \|\| (\$_ !~ / $key /));
2669	}
2670	close(PBFILE);
2671	close(PBOUT);
2672	rename("\$file1.new",\$file1);
2673	chmod 0600,\$file1;
2674
2675	EOF
2676	}
2677	print SCRIPT << 'EOF';
2678
2679	# Adds $pbac->{$ENV{'PBPROJ'}} as an account if needed
2680	#
2681	my $file="/etc/passwd";
2682	open(PBFILE,$file) \|\| die "Unable to open $file";
2683	my $found = 0;
2684	while (<PBFILE>) {
2685	EOF
2686	print SCRIPT << "EOF";
2687	\$found = 1 if (/^$pbac->{$ENV{'PBPROJ'}}:/);
2688	EOF
2689
2690	# TODO: use an external parameter
2691	my $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	}
2697	close(PBFILE);
2698
2699	if ( \$found == 0 ) {
2700	if ( ! -d "$home" ) {
2701	pb_mkdir_p("$home");
2702	}
2703	EOF
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";
2707	pb_system("/usr/sbin/groupadd $pbac->{$ENV{'PBPROJ'}}","Adding group $pbac->{$ENV{'PBPROJ'}}");
2708	pb_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	}
2710	EOF
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);
2724	EOF
2725
2726	if ($vtype =~ /(v\|r)m/) {
2727	print SCRIPT << "EOF";
2728	# allow ssh entry to build
2729	#
2730	mkdir "$home/$pbac->{$ENV{'PBPROJ'}}/.ssh",0700;
2731	# Allow those accessing root to access the build account
2732	copy("\$ENV{'HOME'}/.ssh/authorized_keys","$home/$pbac->{$ENV{'PBPROJ'}}/.ssh/authorized_keys");
2733	chmod 0600,".ssh/authorized_keys";
2734	pb_system("chown -R $pbac->{$ENV{'PBPROJ'}}:$pbac->{$ENV{'PBPROJ'}} $home/$pbac->{$ENV{'PBPROJ'}}","Finish setting up the account env for $pbac->{$ENV{'PBPROJ'}}");
2735
2736	EOF
2737	}
2738	print SCRIPT << 'EOF';
2739	# No passwd for build account only keys
2740	$file="/etc/shadow";
2741	if (-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>) {
2745	EOF
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.
2750	EOF
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";
2762	if (-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
2781	my $pbos = pb_distro_get_context();
2782	print "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
2787	if ($pbos->{'type'} eq "pkg") {
2788	$file="/usr/local/etc/sudoers";
2789	} else {
2790	$file="/etc/sudoers";
2791	}
2792	open(PBFILE,$file) \|\| die "Unable to open $file";
2793	open(PBOUT,"> $file.new") \|\| die "Unable to open $file.new";
2794	while (<PBFILE>) {
2795	EOF
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/);
2801	EOF
2802	print SCRIPT << 'EOF';
2803	s/Defaults[ \t]+requiretty//;
2804	print PBOUT $_;
2805	}
2806	close(PBFILE);
2807	EOF
2808	print SCRIPT << "EOF";
2809	# Some distro force requiretty at compile time, so disable here
2810	print PBOUT "Defaults:$pbac->{$ENV{'PBPROJ'}} !requiretty\n";
2811	print PBOUT "Defaults:root !requiretty\n";
2812	# Keep proxy configuration while using sudo
2813	print PBOUT "Defaults:$pbac->{$ENV{'PBPROJ'}} env_keep += \\\"http_proxy ftp_proxy\\\"\n";
2814	EOF
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
2823	EOF
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
2831	EOF
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
2838	print PBOUT "$pbac->{$ENV{'PBPROJ'}} ALL=(ALL) NOPASSWD:ALL\n";
2839	EOF
2840	}
2841	print SCRIPT << 'EOF';
2842	close(PBOUT);
2843	rename("$file.new",$file);
2844	chmod 0440,$file;
2845
2846	EOF
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
2866	if ((($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
2871	pb_system("yum clean all","Cleaning yum env") if (($pbos->{'name'} eq "fedora") \|\| ($pbos->{'name'} eq "asianux") \|\| ($pbos->{'name'} eq "rhel"));
2872	my ($ospkgdep) = pb_conf_get_if("ospkgdep");
2873
2874	my $pkgdep = pb_distro_get_param($pbos,$ospkgdep);
2875	pb_distro_installdeps(undef,$pbos,pb_distro_only_deps_needed($pbos,join(' ',split(/,/,$pkgdep))));
2876
2877	EOF
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
2909	my ($osperldep,$osperlver) = pb_conf_get_if("osperldep","osperlver");
2910
2911	my $perldep = pb_distro_get_param($pbos,$osperldep);
2912	foreach 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	}
2919	EOF
2920
2921	print SCRIPT << "EOF";
2922	pb_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");
2923	EOF
2924	} elsif ($itype =~ /^pkg/) {
2925	# pkg based install. We need to point to the project-builder.org repository
2926	print SCRIPT << 'EOF';
2927	my $pkgforpb = pb_distro_get_param($pbos,pb_conf_get_if("ospkg"));
2928	pb_distro_setuposrepo($pbos);
2929	pb_distro_installdeps(undef,$pbos,pb_distro_only_deps_needed($pbos,join(' ',split(/,/,$pkgforpb))));
2930	EOF
2931	} else {
2932	# Unknown install type
2933	die("Unknown install type $itype->{$ENV{'PBPROJ'}} for param pbinstalltype");
2934	}
2935	print SCRIPT << 'EOF';
2936	pb_system("pb 2>&1 \| head -5",undef,"verbose");
2937	pb_system("pbdistrocheck",undef,"verbose");
2938	EOF
2939	if ($vtype eq "ve") {
2940	print SCRIPT << 'EOF';
2941	# For VE we need to umount some FS at the end
2942
2943	pb_system("umount /proc");
2944
2945	# Create a basic network file if not already there
2946
2947	my $nf="/etc/sysconfig/network";
2948	if ((! -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	}
2954	chmod 0755,$nf;
2955	EOF
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";
2977	sub pb_version_init {
2978
2979	return("$projectbuilderver","$projectbuilderrev");
2980	}
2981	1;
2982	EOF
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);
2999	return;
3000	}
3001
3002	# Function to create a snapshot named 'pb' for VMs and a compressed tar for VEs
3003	sub pb_snap2v {
3004
3005	my $vtype = shift;
3006
3007	my ($vm,$all) = pb_get2v($vtype);
3008
3009	# Script generated
3010	my $pbscript = "$ENV{'PBDESTDIR'}/snapv";
3011
3012	my ($pbac) = pb_conf_get($vtype."login");
3013
3014	foreach 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
3032	EOF
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	}
3040	return;
3041	}
3042
3043	# Function to update VMs/VEs/RMs with the latest distribution content
3044	sub pb_update2v {
3045
3046	my $vtype = shift;
3047
3048	my ($vm,$all) = pb_get2v($vtype);
3049
3050	# Script generated
3051	my $pbscript = "$ENV{'PBDESTDIR'}/updatev";
3052
3053	my ($pbac) = pb_conf_get($vtype."login");
3054
3055	foreach 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
3066	EOF
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	}
3081	return;
3082	}
3083
3084	sub 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>
3178	Now available at <a href="$pbrepo->{$ENV{'PBPROJ'}}">$pbrepo->{$ENV{'PBPROJ'}}</a>
3179	</p>
3180	<p>
3181	EOF
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>
3188	EOF
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>
3206	Changes are :
3207	</p>
3208	<p>
3209	EOF
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>
3271	EOF
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>
3279	EOF
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	#
3319	sub 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
3368	sub pb_ssh_get {
3369
3370	my $create = shift \|\| 0; # Do not create keys by default
3371
3372	# Check the SSH environment
3373	my $keyfile = undef;
3374
3375	# We have specific keys by default
3376	$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa";
3377	if (!(-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");
3384	die "Unable to find your public ssh key under $keyfile" if (not defined $keyfile);
3385	return($keyfile);
3386	}
3387
3388
3389	# Returns the pid of a running VM command using a specific VM file
3390	sub 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
3407	sub pb_extract_build_files {
3408
3409	my $src=shift;
3410	my $dir=shift;
3411	my $ddir=shift;
3412	my $mandatory=shift \|\| "spec";
3413	my @files;
3414
3415	my $flag = "mayfail" if (($mandatory eq "patch") \|\| ($mandatory eq "src"));
3416	my $res;
3417
3418	if ($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
3426	return() if (($res != 0) and (($mandatory eq "patch") \|\| ($mandatory eq "src")));
3427	opendir(DIR,"$dir") \|\| die "Unable to open directory $dir";
3428	foreach 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	}
3438	closedir(DIR);
3439	# Not enough but still a first cleanup
3440	pb_rm_rf("$dir");
3441	return(@files);
3442	}
3443
3444	sub pb_list_bfiles {
3445
3446	my $dir = shift;
3447	my $pbpkg = shift;
3448	my $bfiles = shift;
3449	my $pkgfiles = shift;
3450	my $supfiles = shift;
3451
3452	pb_log(2,"DEBUG: entering pb_list_bfiles: ".Dumper($bfiles)."\n");
3453	opendir(BDIR,"$dir") \|\| die "Unable to open dir $dir: $!";
3454	foreach 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	}
3467	closedir(BDIR);
3468	pb_log(2,"DEBUG: exiting pb_list_bfiles: ".Dumper($bfiles)."\n");
3469	}
3470
3471	sub pb_add_coma {
3472
3473	my $str = shift;
3474	my $addstr = shift;
3475
3476	$str .= "," if (defined $str);
3477	$str .= $addstr;
3478	return($str);
3479	}
3480
3481	sub pb_list_sfiles {
3482
3483	my $sdir = shift;
3484	my $ptr = shift;
3485	my $pbos = shift;
3486	my $extdir = shift;
3487
3488	pb_log(2,"DEBUG: entering pb_list_sfiles: ".Dumper($ptr)."\n");
3489	my $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
3493	foreach 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
3498	foreach 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	}
3511	pb_log(2,"DEBUG: exiting pb_list_sfiles: ".Dumper($ptr)."\n");
3512	return($ptr);
3513	}
3514
3515	#
3516	# Return the list of packages we are working on in a non CMS action
3517	#
3518	sub pb_get_pkg {
3519
3520	my @pkgs = ();
3521
3522	my ($var) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
3523	@pkgs = keys %$var;
3524
3525	pb_log(0,"Packages: ".join(',',@pkgs)."\n");
3526	return(\@pkgs);
3527	}
3528
3529	# Manages VM/RM SSH port communication
3530	sub pb_get_port {
3531
3532	my $port = shift;
3533	my $pbos = shift;
3534	my $cmt = shift;
3535	my $nport;
3536
3537	die "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
3539	if ($cmt =~ /^RM/i) {
3540	$nport = $port->{"$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}"};
3541	} else {
3542	$nport = $port->{$ENV{'PBPROJ'}};
3543	}
3544	pb_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
3548	if (($cmt ne "Packages") && ($cmt !~ /^RM/i)) {
3549	$nport += $ENV{'PBVMPORT'} if ((defined $pbparallel) && (defined $ENV{'PBVMPORT'}));
3550	}
3551	pb_log(2,"pb_get_port returns $nport\n");
3552	return($nport);
3553	}
3554
3555	sub pb_set_port {
3556
3557	my ($pid,$ident) = @_;
3558	pb_log(2,"pb_set_port for VM ($pid), id $ident\n");
3559	$ENV{'PBVMPORT'} = $ident;
3560	pb_log(2,"pb_set_port sets PBVMPORT in env to $ENV{'PBVMPORT'}\n");
3561	}
3562
3563	sub pb_set_parallel {
3564
3565	my $vtype = shift;
3566
3567	pb_log(2,"pb_set_parallel vtype: $vtype\n");
3568	# Take care of memory size if VM, parallel mode and more than 1 action
3569	if ((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	}
3601	pb_log(2,"pb_set_parallel returns: $pbparallel\n") if (defined $pbparallel);
3602	return($pbparallel);
3603	}
3604
3605	sub pb_get_sudocmds {
3606
3607	my $pbos = shift;
3608	my %sudocmds;
3609
3610	pb_log(2,"pb_get_sudocmds entering with lines:".Dumper(@_)."\n");
3611	foreach 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	}
3620	pb_log(2,"pb_get_sudocmds returns ".Dumper(keys %sudocmds)."\n");
3621	return(keys %sudocmds);
3622	}
3623
3624	sub pb_sign_pkgs {
3625
3626	my $pbos = shift;
3627	my $made = shift;
3628
3629	pb_log(2,"entering pb_sign_pkg: $made ".Dumper($pbos)."\n");
3630	my ($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
3640	if ($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	}
3671	pb_log(2,"exiting pb_sign_pkg\n");
3672	}
3673
3674	# return list of all distributins supported, coma separated
3675	sub pb_get_distros {
3676
3677	my $pbos = shift;
3678	my $pbtarget = shift;
3679
3680	my $tmpl = "$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'},";
3681
3682	# Get list of distributions for which we need to generate build files if no target
3683	if (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	}
3703	return($tmpl);
3704	}
3705
3706	1;

Note: See TracBrowser for help on using the repository browser.

Download in other formats: