Context Navigation

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

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

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

Download in other formats: