Context Navigation

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

Last change on this file since 1156 was 1156, checked in by Bruno Cornec, 13 years ago
Adds a global variable REVISION for version management Do not return in pb_send2target if pb file not available in order to shutdown VM in all cases Code and test sbx2setupvm setup_v now needs a fake pb_version_init fct added at the end of the script Fix pbdistrocheck install comand printing Fix mandralinux old distro build in pb.conf (Note only non symlink release files are important)
Property svn:executable set to ``*
File size: 115.2 KB

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

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

Download in other formats: