Context Navigation

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

Last change on this file since 2180 was 2180, checked in by Bruno Cornec, 7 years ago
Add option --version to pb and use it
Property svn:executable set to ``*
File size: 176.7 KB

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

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

Download in other formats: