Context Navigation

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

Last change on this file since 1386 was 1386, checked in by Bruno Cornec, 12 years ago
Adds option checkexclude and command checkssh with the -rebuild option: this allows to check after the build which packages have not been built correctly and to potentially relaunch the build (however why it didn't built is left as an exercise to the reader !)
Property svn:executable set to ``*
File size: 129.3 KB

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

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

Download in other formats: