Context Navigation

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

Last change on this file since 1589 was 1589, checked in by Bruno Cornec, 12 years ago
Fix a typo where bash-e was called instead of bash -e
Property svn:executable set to ``*
File size: 148.5 KB

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

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

Download in other formats: