Context Navigation

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

Last change on this file since 433 was 433, checked in by Bruno Cornec, 16 years ago
Fix a bug in the generation of the conf files for repository
Property svn:executable set to ``*
File size: 53.8 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';
[331]	13	use Getopt::Long qw(:config auto_abbrev no_ignore_case);
[9]	14	use Data::Dumper;
	15	use English;
[16]	16	use File::Basename;
[26]	17	use File::Copy;
[395]	18	use File::stat;
	19	use File::Temp qw(tempdir);
[13]	20	use POSIX qw(strftime);
[17]	21	use lib qw (lib);
[329]	22	use ProjectBuilder::Version;
[318]	23	use ProjectBuilder::Base;
[405]	24	use ProjectBuilder::Conf;
	25	use ProjectBuilder::Distribution;
	26	use ProjectBuilder::CMS;
[416]	27	use ProjectBuilder::Env;
[405]	28	use ProjectBuilder::Filter;
[5]	29
[397]	30	# Global variables
[5]	31	my %opts; # CLI Options
[9]	32	my $action; # action to realize
[320]	33	my $test = "FALSE"; # Not used
	34	my $force = 0; # Force VE/VM rebuild
	35	my $option = ""; # Not used
	36	my @pkgs; # list of packages
[95]	37	my $pbtag; # Global Tag variable
	38	my $pbver; # Global Version variable
[141]	39	my $pbscript; # Name of the script
[77]	40	my %pbver; # per package
	41	my %pbtag; # per package
[53]	42	my $pbrev; # Global REVISION variable
[152]	43	my $pbaccount; # Login to use to connect to the VM
[162]	44	my $pbport; # Port to use to connect to the VM
[199]	45	my $newver; # New version to create
[331]	46	my $iso; # ISO image for the VM to create
[5]	47
[320]	48	my @date = pb_get_date();
	49	my $pbdate = strftime("%Y-%m-%d", @date);
[5]	50
[331]	51	=pod
	52
	53	=head1 NAME
	54
	55	pb, aka project-builder.org - builds packages for your projects
	56
	57	=head1 DESCRIPTION
	58
	59	pb helps you build various packages directly from your project sources.
	60	Those sources could be handled by a CMS (Configuration Management System)
	61	such as Subversion, CVS, ... or being a simple reference to a compressed tar file.
	62	It's based on a set of configuration files, a set of provided macros to help
	63	you keeping build files as generic as possible. For example, a single .spec
	64	file should be required to generate for all rpm based distributions, even
	65	if you could also have multiple .spec files if required.
	66
	67	=head1 SYNOPSIS
	68
[332]	69	pb [-vhq][-r pbroot][-p project][[-s script -a account -P port][-m mach-1[,...]]][-i iso] <action> [<pkg1> ...]
[331]	70
[332]	71	pb [--verbose][--help][--man][--quiet][--revision pbroot][--project project][[--script script --account account --port port][--machine mach-1[,...]]][--iso iso] <action> [<pkg1> ...]
[331]	72
	73	=head1 OPTIONS
	74
	75	=over 4
	76
	77	=item B<-v\|--verbose>
	78
	79	Print a brief help message and exits.
	80
	81	=item B<-q\|--quiet>
	82
	83	Do not print any output.
	84
	85	=item B<-h\|--help>
	86
	87	Print a brief help message and exits.
	88
	89	=item B<--man>
	90
	91	Prints the manual page and exits.
	92
	93	=item B<-m\|--machine machine1[,machine2,...]>
	94
	95	Name of the Virtual Machines (VM) or Virtual Environments (VE) you want to build on (coma separated).
	96	All if none precised (or use the env variable PBV).
	97
	98	=item B<-s\|--script script>
	99
	100	Name of the script you want to execute on the related VMs or VEs.
	101
	102	=item B<-i\|--iso iso_image>
	103
	104	Name of the ISO image of the distribution you want to install on the related VMs.
	105
	106	=item B<-a\|--account account>
	107
	108	Name of the account to use to connect on the related VMs.
	109
	110	=item B<-P\|--port port_number>
	111
	112	Port number to use to connect on the related VMs.\n";
	113
	114	=item B<-p\|--project project_name>
	115
	116	Name of the project you're working on (or use the env variable PBPROJ)
	117
	118	=item B<-r\|--revision revision>
	119
	120	Path Name of the project revision under the CMS (or use the env variable PBROOT)
	121
	122	=item B<-V\|--version new_version>
	123
	124	New version of the project to create based on the current one.
	125
	126	=back
	127
	128	=head1 ARGUMENTS
	129
	130	<action> can be:
	131
	132	=over 4
	133
	134	=item B<cms2build>
	135
	136	Create tar files for the project under your CMS.
	137	CMS supported are SVN and CVS
	138	parameters are packages to build
	139	if not using default list
	140
	141	=item B<build2pkg>
	142
	143	Create packages for your running distribution
	144
	145	=item B<cms2pkg>
	146
	147	cms2build + build2pkg
	148
	149	=item B<build2ssh>
	150
	151	Send the tar files to a SSH host
	152
	153	=item B<cms2ssh>
	154
	155	cms2build + build2ssh
	156
	157	=item B<pkg2ssh>
	158
	159	Send the packages built to a SSH host
	160
	161	=item B<build2vm>
	162
	163	Create packages in VMs, launching them if needed
	164	and send those packages to a SSH host once built
	165	VM type supported are QEMU
	166
	167	=item B<build2ve>
	168
	169	Create packages in VEs, creating it if needed
	170	and send those packages to a SSH host once built
	171
	172	=item B<cms2vm>
	173
	174	cms2build + build2vm
	175
	176	=item B<cms2ve>
	177
	178	cms2build + build2ve
	179
	180	=item B<launchvm>
	181
	182	Launch one virtual machine
	183
	184	=item B<launchve>
	185
	186	Launch one virtual environment
	187
	188	=item B<script2vm>
	189
	190	Launch one virtual machine if needed
	191	and executes a script on it
	192
	193	=item B<script2ve>
	194
	195	Execute a script in a virtual environment
	196
	197	=item B<newvm>
	198
	199	Create a new virtual machine
	200
	201	=item B<newve>
	202
	203	Create a new virtual environment
	204
[346]	205	=item B<setupvm>
	206
	207	Setup a virtual machine for pb usage
	208
	209	=item B<setupve>
	210
	211	Setup a virtual environment for pb usage
	212
[331]	213	=item B<newver>
	214
	215	Create a new version of the project derived
	216	from the current one
	217
	218	=item B<newproj>
	219
	220	Create a new project and a template set of
	221	configuration files under pbconf
	222
	223	=back
	224
	225	<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).
	226
	227	=head1 WEB SITES
	228
	229	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/>.
	230
	231	=head1 USER MAILING LIST
	232
	233	None exists for the moment.
	234
	235	=head1 CONFIGURATION FILES
	236
	237	Each pb user may have a configuration in F<$HOME/.pbrc>. The values in this file may overwrite any other configuration file value.
	238
	239	Here is an example of such a configuration file:
	240
	241	#
	242	# Define for each project the URL of its pbconf repository
	243	# No default option allowed here as they need to be all different
	244	#
	245	# URL of the pbconf content
	246	# This is the format of a classical URL with the extension of additional schema such as
	247	# svn+ssh, cvs+ssh, ...
	248	#
	249	pbconfurl linuxcoe = cvs+ssh://:ext:bcornec@linuxcoe.cvs.sourceforge.net:/cvsroot/linuxcoe/pbconf
	250
	251	# This is normaly defined in the project's configuration file
	252	# Url of the project
	253	#
	254	pburl linuxcoe = cvs+ssh://:ext:bcornec@linuxcoe.cvs.sourceforge.net:/cvsroot/linuxcoe
	255
	256	# All these URLs needs to be defined here as the are the entry point
	257	# for how to build packages for the project
	258	#
	259	pbconfurl pb = svn+ssh://svn.project-builder.org/mondo/svn/pb/pbconf
	260	pbconfurl mondorescue = svn+ssh://svn.project-builder.org/mondo/svn/project-builder/mondorescue/pbconf
	261	pbconfurl collectl = svn+ssh://bruno@svn.mondorescue.org/mondo/svn/project-builder/collectl/pbconf
	262	pbconfurl netperf = svn+ssh://svn.mondorescue.org/mondo/svn/project-builder/netperf/pbconf
	263
	264	# Under that dir will take place everything related to pb
	265	# If you want to use VMs/chroot/..., then use $ENV{'HOME'} to make it portable
	266	# to your VMs/chroot/...
	267	# if not defined then /var/cache
	268	pbdefdir default = $ENV{'HOME'}/project-builder
	269	pbdefdir pb = $ENV{'HOME'}
	270	pbdefdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs
	271	pbdefdir mondorescue = $ENV{'HOME'}/mondo/svn
	272
	273	# pbconfdir points to the directory where the CMS content of the pbconfurl is checked out
	274	# If not defined, pbconfdir is under pbdefdir/pbproj/pbconf
	275	pbconfdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs/pbconf
	276	pbconfdir mondorescue = $ENV{'HOME'}/mondo/svn/pbconf
	277
	278	# pbdir points to the directory where the CMS content of the pburl is checked out
	279	# If not defined, pbdir is under pbdefdir/pbproj
	280	# Only defined if we have access to the dev of the project
	281	pbdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs
	282	pbdir mondorescue = $ENV{'HOME'}/mondo/svn
	283
	284	# -daemonize doesn't work with qemu 0.8.2
	285	vmopt default = -m 384
	286
	287	=head1 AUTHORS
	288
	289	The Project-Builder.org team L<http://trac.project-builder.org/> lead by Bruno Cornec L<mailto:bruno@project-builder.org>.
	290
	291	=head1 COPYRIGHT
	292
	293	Project-Builder.org is distributed under the GPL v2.0 license
	294	described in the file C<COPYING> included with the distribution.
	295
	296	=cut
	297
	298	# ---------------------------------------------------------------------------
	299
	300	# Old syntax
	301	#getopts('a:fhi:l:m:P:p:qr:s:vV:',\%opts);
	302
[75]	303	my ($projectbuilderver,$projectbuilderrev) = pb_version_init();
[331]	304
[397]	305	# Initialize the syntax string
	306
	307	pb_syntax_init("pb (aka project-builder.org) Version $projectbuilderver-$projectbuilderrev\n");
	308
[331]	309	GetOptions("help\|?\|h" => \$opts{'h'},
	310	"man" => \$opts{'man'},
	311	"verbose\|v+" => \$opts{'v'},
	312	"quiet\|q" => \$opts{'q'},
	313	"log-files\|l=s" => \$opts{'l'},
	314	"force\|f" => \$opts{'f'},
	315	"account\|a=s" => \$opts{'a'},
	316	"revision\|r=s" => \$opts{'r'},
	317	"script\|s=s" => \$opts{'s'},
	318	"machines\|mock\|m=s" => \$opts{'m'},
	319	"port\|P=i" => \$opts{'P'},
	320	"project\|p=s" => \$opts{'p'},
	321	"iso\|i=s" => \$opts{'i'},
	322	"version\|V=s" => \$opts{'V'},
	323	) \|\| pb_syntax(-1,0);
	324
[21]	325	if (defined $opts{'h'}) {
[331]	326	pb_syntax(0,1);
[21]	327	}
[331]	328	if (defined $opts{'man'}) {
	329	pb_syntax(0,2);
	330	}
[21]	331	if (defined $opts{'v'}) {
[331]	332	$debug = $opts{'v'};
[21]	333	}
[320]	334	if (defined $opts{'f'}) {
	335	$force=1;
	336	}
[21]	337	if (defined $opts{'q'}) {
	338	$debug=-1;
	339	}
[22]	340	if (defined $opts{'l'}) {
	341	open(LOG,"> $opts{'l'}") \|\| die "Unable to log to $opts{'l'}: $!";
[348]	342	$LOG = \*LOG;
[22]	343	$debug = 0 if ($debug == -1);
	344	}
[315]	345	pb_log_init($debug, $LOG);
	346
[67]	347	# Handle root of the project if defined
	348	if (defined $opts{'r'}) {
[340]	349	$ENV{'PBROOTDIR'} = $opts{'r'};
[67]	350	}
[91]	351	# Handle virtual machines if any
	352	if (defined $opts{'m'}) {
[320]	353	$ENV{'PBV'} = $opts{'m'};
[91]	354	}
[141]	355	if (defined $opts{'s'}) {
	356	$pbscript = $opts{'s'};
	357	}
[152]	358	if (defined $opts{'a'}) {
	359	$pbaccount = $opts{'a'};
[347]	360	die "option -a requires a -s script option" if (not defined $pbscript);
[152]	361	}
[162]	362	if (defined $opts{'P'}) {
	363	$pbport = $opts{'P'};
	364	}
[199]	365	if (defined $opts{'V'}) {
	366	$newver = $opts{'V'};
	367	}
[262]	368	if (defined $opts{'i'}) {
	369	$iso = $opts{'i'};
	370	}
[108]	371
	372	# Get Action
	373	$action = shift @ARGV;
[331]	374	die pb_syntax(-1,1) if (not defined $action);
[108]	375
[314]	376	my ($filteredfiles, $supfiles, $defpkgdir, $extpkgdir);
[273]	377	my $pbinit = undef;
	378	$pbinit = 1 if ($action =~ /^newproj$/);
[108]	379
[59]	380	# Handles project name if any
[108]	381	# And get global params
[353]	382	($filteredfiles, $supfiles, $defpkgdir, $extpkgdir) = pb_env_init($opts{'p'},$pbinit,$action);
[59]	383
[315]	384	pb_log(0,"Project: $ENV{'PBPROJ'}\n");
	385	pb_log(0,"Action: $action\n");
[9]	386
	387	# Act depending on action
	388	if ($action =~ /^cms2build$/) {
[77]	389	pb_cms2build();
	390	} elsif ($action =~ /^build2pkg$/) {
	391	pb_build2pkg();
	392	} elsif ($action =~ /^cms2pkg$/) {
	393	pb_cms2build();
	394	pb_build2pkg();
[88]	395	} elsif ($action =~ /^build2ssh$/) {
	396	pb_build2ssh();
[220]	397	} elsif ($action =~ /^cms2ssh$/) {
	398	pb_cms2build();
	399	pb_build2ssh();
[88]	400	} elsif ($action =~ /^pkg2ssh$/) {
	401	pb_pkg2ssh();
[320]	402	} elsif ($action =~ /^build2ve$/) {
	403	pb_build2v("ve");
[91]	404	} elsif ($action =~ /^build2vm$/) {
[320]	405	pb_build2v("vm");
	406	} elsif ($action =~ /^cms2ve$/) {
	407	pb_cms2build();
	408	pb_build2v("ve");
[91]	409	} elsif ($action =~ /^cms2vm$/) {
	410	pb_cms2build();
[320]	411	pb_build2v("vm");
[141]	412	} elsif ($action =~ /^launchvm$/) {
[320]	413	pb_launchv("vm",$ENV{'PBV'},0);
	414	} elsif ($action =~ /^launchve$/) {
	415	pb_launchv("ve",$ENV{'PBV'},0);
[142]	416	} elsif ($action =~ /^script2vm$/) {
[320]	417	pb_script2v($pbscript,"vm");
	418	} elsif ($action =~ /^script2ve$/) {
	419	pb_script2v($pbscript,"ve");
[199]	420	} elsif ($action =~ /^newver$/) {
	421	pb_newver();
[320]	422	} elsif ($action =~ /^newve$/) {
	423	pb_launchv("ve",$ENV{'PBV'},1);
[262]	424	} elsif ($action =~ /^newvm$/) {
[320]	425	pb_launchv("vm",$ENV{'PBV'},1);
[346]	426	} elsif ($action =~ /^setupve$/) {
[353]	427	pb_setup_v("ve");
[346]	428	} elsif ($action =~ /^setupvm$/) {
[353]	429	pb_setup_v("vm");
[273]	430	} elsif ($action =~ /^newproj$/) {
	431	# Nothing to do - already done in pb_env_init
[106]	432	} elsif ($action =~ /^clean$/) {
[77]	433	} else {
[315]	434	pb_log(0,"\'$action\' is not available\n");
[331]	435	pb_syntax(-2,1);
[77]	436	}
	437
	438	sub pb_cms2build {
	439
[357]	440	my $pkg = pb_cms_get_pkg($defpkgdir,$extpkgdir);
	441	my @pkgs = @$pkg;
	442	my %pkgs;
[9]	443
[341]	444	my ($scheme, $uri) = pb_cms_init($pbinit);
[331]	445
[313]	446	my ($pkgv, $pkgt) = pb_conf_get_if("pkgver","pkgtag");
[174]	447
[429]	448	# declare packager and repo for filtering
	449	my ($tmp1, $tmp2) = pb_conf_get("pbpackager","pbrepo");
	450	$ENV{'PBPACKAGER'} = $tmp1->{$ENV{'PBPROJ'}};
	451	$ENV{'PBREPO'} = $tmp2->{$ENV{'PBPROJ'}};
[174]	452
[27]	453	foreach my $pbpkg (@pkgs) {
[115]	454	$ENV{'PBPKG'} = $pbpkg;
[98]	455	if ((defined $pkgv) && (defined $pkgv->{$pbpkg})) {
	456	$pbver = $pkgv->{$pbpkg};
[9]	457	} else {
[353]	458	$pbver = $ENV{'PBPROJVER'};
[9]	459	}
[98]	460	if ((defined $pkgt) && (defined $pkgt->{$pbpkg})) {
	461	$pbtag = $pkgt->{$pbpkg};
[9]	462	} else {
[353]	463	$pbtag = $ENV{'PBPROJTAG'};
[9]	464	}
[95]	465
[16]	466	$pbrev = $ENV{'PBREVISION'};
[319]	467	pb_log(0,"\n");
	468	pb_log(0,"Management of $pbpkg $pbver-$pbtag (rev $pbrev)\n");
[9]	469	die "Unable to get env var PBDESTDIR" if (not defined $ENV{'PBDESTDIR'});
[16]	470	# Clean up dest if necessary. The export will recreate it
[27]	471	my $dest = "$ENV{'PBDESTDIR'}/$pbpkg-$pbver";
[74]	472	pb_rm_rf($dest) if (-d $dest);
[9]	473
	474	# Export CMS tree for the concerned package to dest
	475	# And generate some additional files
	476	$OUTPUT_AUTOFLUSH=1;
[29]	477
[9]	478	# computes in which dir we have to work
[113]	479	my $dir = $defpkgdir->{$pbpkg};
	480	$dir = $extpkgdir->{$pbpkg} if (not defined $dir);
[315]	481	pb_log(2,"def:".Dumper($defpkgdir)." ext: ".Dumper($extpkgdir)." \n");
[9]	482
[340]	483	# Exporting from CMS
	484	pb_cms_export($uri,"$ENV{'PBDIR'}/$dir",$dest);
[315]	485
[285]	486	# Get project info on authors and log file
[340]	487	my $chglog = "$ENV{'PBROOTDIR'}/$pbpkg/pbcl";
	488	$chglog = "$ENV{'PBROOTDIR'}/pbcl" if (! -f $chglog);
[285]	489	$chglog = undef if (! -f $chglog);
	490
[340]	491	my $authors = "$ENV{'PBROOTDIR'}/$pbpkg/pbauthors";
	492	$authors = "$ENV{'PBROOTDIR'}/pbauthors" if (! -f $authors);
[285]	493	$authors = "/dev/null" if (! -f $authors);
	494
[9]	495	# Extract cms log history and store it
[285]	496	if ((defined $chglog) && (! -f "$dest/NEWS")) {
[315]	497	pb_log(2,"Generating NEWS file from $chglog\n");
[285]	498	copy($chglog,"$dest/NEWS") \|\| die "Unable to create $dest/NEWS";
	499	}
[340]	500	pb_cms_log($scheme,"$ENV{'PBDIR'}/$dir",$dest,$chglog,$authors);
[29]	501
[21]	502	my %build;
[91]	503
[328]	504	my @pt;
	505	@pt = pb_conf_get_if("vmlist","velist");
[340]	506	my $tmpl = "";
	507	if (defined $pt[0]->{$ENV{'PBPROJ'}}) {
	508	$tmpl .= $pt[0]->{$ENV{'PBPROJ'}};
	509	}
	510	if (defined $pt[1]->{$ENV{'PBPROJ'}}) {
	511	# the 2 lists needs to be grouped with a ',' separated them
	512	if ($tmpl ne "") {
	513	$tmpl .= ",";
	514	}
	515	$tmpl .= $pt[1]->{$ENV{'PBPROJ'}}
	516	}
	517	foreach my $d (split(/,/,$tmpl)) {
[315]	518	my ($name,$ver,$arch) = split(/-/,$d);
	519	chomp($arch);
[99]	520	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($name,$ver);
[315]	521	pb_log(2,"DEBUG: distro tuple: ".Dumper($ddir, $dver, $dfam, $dtype, $pbsuf)."\n");
	522	pb_log(2,"DEBUG Filtering PBDATE => $pbdate, PBTAG => $pbtag, PBVER => $pbver\n");
[13]	523
[16]	524	# Filter build files from the less precise up to the most with overloading
[13]	525	# Filter all files found, keeping the name, and generating in dest
[16]	526
[340]	527	# Find all build files first relatively to PBROOTDIR
[300]	528	# Find also all specific files referenced in the .pb conf file
[320]	529	my %bfiles = ();
	530	my %pkgfiles = ();
[21]	531	$build{"$ddir-$dver"} = "yes";
[315]	532
[340]	533	if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$dtype") {
	534	pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$dtype",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
	535	} elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$dfam") {
	536	pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$dfam",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
	537	} elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$ddir") {
	538	pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$ddir",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
	539	} elsif (-d "$ENV{'PBROOTDIR'}/$pbpkg/$ddir-$dver") {
	540	pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$ddir-$dver",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
[13]	541	} else {
[21]	542	$build{"$ddir-$dver"} = "no";
[13]	543	next;
	544	}
[315]	545	pb_log(2,"DEBUG bfiles: ".Dumper(\%bfiles)."\n");
[13]	546
[15]	547	# Get all filters to apply
[77]	548	my $ptr = pb_get_filters($pbpkg, $dtype, $dfam, $ddir, $dver);
[15]	549
[19]	550	# Apply now all the filters on all the files concerned
	551	# destination dir depends on the type of file
	552	if (defined $ptr) {
[300]	553	foreach my $f (values %bfiles,values %pkgfiles) {
[429]	554	pb_filter_file_pb("$ENV{'PBROOTDIR'}/$f",$ptr,"$dest/pbconf/$ddir-$dver/".basename($f),$dtype,$pbsuf,$pbpkg,$pbver,$pbtag,$pbrev,$pbdate,$defpkgdir,$extpkgdir,$ENV{'PBPACKAGER'},$chglog,$ENV{'PBPROJ'},$ENV{'PBREPO'});
[16]	555	}
[15]	556	}
[18]	557	}
[315]	558	my @found;
	559	my @notfound;
	560	foreach my $b (keys %build) {
	561	push @found,$b if ($build{$b} =~ /yes/);
	562	push @notfound,$b if ($build{$b} =~ /no/);
[21]	563	}
[315]	564	pb_log(0,"Build files generated for ".join(',',@found)."\n");
	565	pb_log(0,"No Build files found for ".join(',',@notfound)."\n") if (@notfound);
[236]	566	# Get the generic filter (all.pbf) and
	567	# apply those to the non-build files including those
	568	# generated by pbinit if applicable
	569
	570	# Get only all.pbf filter
[357]	571	my $ptr = pb_get_filters($pbpkg);
[236]	572
	573	my $liste ="";
	574	if (defined $filteredfiles->{$pbpkg}) {
	575	foreach my $f (split(/,/,$filteredfiles->{$pbpkg})) {
[429]	576	pb_filter_file_inplace($ptr,"$dest/$f",$pbpkg,$pbver,$pbtag,$pbrev,$pbdate,$ENV{'PBPACKAGER'},$ENV{'PBPROJ'},$ENV{'PBREPO'});
[238]	577	$liste = "$f $liste";
[236]	578	}
	579	}
[315]	580	pb_log(2,"Files ".$liste."have been filtered\n");
[236]	581
[265]	582	# Prepare the dest directory for archive
[340]	583	if (-x "$ENV{'PBROOTDIR'}/$pbpkg/pbinit") {
[429]	584	pb_filter_file("$ENV{'PBROOTDIR'}/$pbpkg/pbinit",$ptr,"$ENV{'PBTMP'}/pbinit",$pbpkg,$pbver,$pbtag,$pbrev,$pbdate,$ENV{'PBPACKAGER'},$ENV{'PBPROJ'},$ENV{'PBREPO'});
[266]	585	chmod 0755,"$ENV{'PBTMP'}/pbinit";
[340]	586	pb_system("cd $dest ; $ENV{'PBTMP'}/pbinit","Executing init script from $ENV{'PBROOTDIR'}/$pbpkg/pbinit");
[265]	587	}
	588
[18]	589	# Archive dest dir
[69]	590	chdir "$ENV{'PBDESTDIR'}" \|\| die "Unable to change dir to $ENV{'PBDESTDIR'}";
[25]	591	# Possibility to look at PBSRC to guess more the filename
[94]	592	pb_system("tar cfz $pbpkg-$pbver.tar.gz $pbpkg-$pbver","Creating $pbpkg tar files compressed");
[344]	593	pb_log(0,"Under $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz\n");
[83]	594
[357]	595	# Keep track of version-tag per pkg
	596	$pkgs{$pbpkg} = "$pbver-$pbtag";
[83]	597
[288]	598	# Final cleanup
	599	pb_rm_rf($dest) if (-d $dest);
[9]	600	}
[357]	601
	602	# Keep track of per package version
	603	pb_log(2,"DEBUG pkgs: ".Dumper(%pkgs)."\n");
	604	open(PKG,"> $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb") \|\| die "Unable to create $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb";
	605	foreach my $pbpkg (@pkgs) {
	606	print PKG "pbpkg $pbpkg = $pkgs{$pbpkg}\n";
	607	}
	608	close(PKG);
	609
	610	# Keep track of what is generated by default
	611	# We need to store the dir and info on version-tag
	612	# Base our content on the existing .pb file
	613	copy("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb","$ENV{'PBDESTDIR'}/pbrc");
	614	open(LAST,">> $ENV{'PBDESTDIR'}/pbrc") \|\| die "Unable to create $ENV{'PBDESTDIR'}/pbrc";
	615	print LAST "pbroot $ENV{'PBPROJ'} = $ENV{'PBROOTDIR'}\n";
	616	print LAST "pbprojver $ENV{'PBPROJ'} = $ENV{'PBPROJVER'}\n";
	617	print LAST "pbprojtag $ENV{'PBPROJ'} = $ENV{'PBPROJTAG'}\n";
	618	print LAST "pbpackager $ENV{'PBPROJ'} = $ENV{'PBPACKAGER'}\n";
	619	close(LAST);
[77]	620	}
[22]	621
[77]	622	sub pb_build2pkg {
	623
[22]	624	# Get the running distro to build on
[99]	625	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init();
[315]	626	pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n");
[22]	627
[353]	628	# Get list of packages to build
[83]	629	# Get content saved in cms2build
[353]	630	my $ptr = pb_get_pkg();
	631	@pkgs = @$ptr;
	632
	633	my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
[83]	634	$pkg = { } if (not defined $pkg);
	635
[25]	636	chdir "$ENV{'PBBUILDDIR'}";
[126]	637	my $made = ""; # pkgs made during build
[27]	638	foreach my $pbpkg (@pkgs) {
[88]	639	my $vertag = $pkg->{$pbpkg};
[77]	640	# get the version of the current package - maybe different
	641	($pbver,$pbtag) = split(/-/,$vertag);
	642
[27]	643	my $src="$ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz";
[315]	644	pb_log(2,"Source file: $src\n");
[25]	645
[315]	646	pb_log(2,"Working directory: $ENV{'PBBUILDDIR'}\n");
[25]	647	if ($dtype eq "rpm") {
	648	foreach my $d ('RPMS','SRPMS','SPECS','SOURCES','BUILD') {
[28]	649	if (! -d "$ENV{'PBBUILDDIR'}/$d") {
[96]	650	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]	651	}
[25]	652	}
	653
[315]	654	# Remove in case a previous link/file was there
[301]	655	unlink "$ENV{'PBBUILDDIR'}/SOURCES/".basename($src);
[188]	656	symlink "$src","$ENV{'PBBUILDDIR'}/SOURCES/".basename($src) \|\| die "Unable to symlink $src in $ENV{'PBBUILDDIR'}/SOURCES";
[25]	657	# We need to first extract the spec file
[28]	658	my @specfile;
[77]	659	@specfile = pb_extract_build_files($src,"$pbpkg-$pbver/pbconf/$ddir-$dver/","$ENV{'PBBUILDDIR'}/SPECS");
[25]	660
[315]	661	pb_log(2,"specfile: ".Dumper(\@specfile)."\n");
[25]	662	# set LANGUAGE to check for correct log messages
	663	$ENV{'LANGUAGE'}="C";
[28]	664	foreach my $f (@specfile) {
	665	if ($f =~ /\.spec$/) {
[353]	666	pb_system("rpmbuild --define \'packager $ENV{'PBPACKAGER'}\' --define \"_topdir $ENV{'PBBUILDDIR'}\" -ba $f","Building package with $f under $ENV{'PBBUILDDIR'}");
[28]	667	last;
	668	}
	669	}
[136]	670	$made="$made RPMS//$pbpkg-$pbver-$pbtag$pbsuf..rpm SRPMS/$pbpkg-$pbver-$pbtag$pbsuf.src.rpm";
[149]	671	if (-f "/usr/bin/rpmlint") {
	672	pb_system("rpmlint $made","Checking validity of rpms with rpmlint");
[150]	673	}
[118]	674	} elsif ($dtype eq "deb") {
[149]	675	chdir "$ENV{'PBBUILDDIR'}" \|\| die "Unable to chdir to $ENV{'PBBUILDDIR'}";
[274]	676	pb_system("tar xfz $src","Extracting sources");
[149]	677
	678	chdir "$pbpkg-$pbver" \|\| die "Unable to chdir to $pbpkg-$pbver";
[310]	679	pb_rm_rf("debian");
[149]	680	symlink "pbconf/$ddir-$dver","debian" \|\| die "Unable to symlink to pbconf/$ddir-$dver";
[199]	681	chmod 0755,"debian/rules";
[149]	682	pb_system("dpkg-buildpackage -us -uc -rfakeroot","Building package");
[136]	683	$made="$made $pbpkg"."_.deb $pbpkg"."_.dsc $pbpkg"."_*.tar.gz";
[315]	684	if (-f "/usr/bin/lintian") {
	685	pb_system("lintian $made","Checking validity of debs with lintian");
	686	}
[87]	687	} elsif ($dtype eq "ebuild") {
[149]	688	my @ebuildfile;
	689	# For gentoo we need to take pb as subsystem name
[295]	690	# We put every apps here under sys-apps. hope it's correct
	691	# We use pb's home dir in order o have a single OVERLAY line
	692	my $tmpd = "$ENV{'HOME'}/portage/pb/sys-apps/$pbpkg";
	693	pb_mkdir_p($tmpd) if (! -d "$tmpd");
	694	pb_mkdir_p("$ENV{'HOME'}/portage/distfiles") if (! -d "$ENV{'HOME'}/portage/distfiles");
[149]	695
[295]	696	# We need to first extract the ebuild file
	697	@ebuildfile = pb_extract_build_files($src,"$pbpkg-$pbver/pbconf/$ddir-$dver/","$tmpd");
[149]	698
	699	# Prepare the build env for gentoo
	700	my $found = 0;
[295]	701	my $pbbd = $ENV{'HOME'};
[150]	702	$pbbd =~ s\|/\|\\/\|g;
[295]	703	if (-r "/etc/make.conf") {
	704	open(MAKE,"/etc/make.conf");
	705	while (<MAKE>) {
	706	$found = 1 if (/$pbbd\/portage/);
	707	}
	708	close(MAKE);
[149]	709	}
	710	if ($found == 0) {
[295]	711	pb_system("sudo sh -c 'echo PORTDIR_OVERLAY=\"$ENV{'HOME'}/portage\" >> /etc/make.conf'");
[149]	712	}
[295]	713	#$found = 0;
	714	#if (-r "/etc/portage/package.keywords") {
	715	#open(KEYW,"/etc/portage/package.keywords");
	716	#while (<KEYW>) {
	717	#$found = 1 if (/portage\/pb/);
	718	#}
	719	#close(KEYW);
	720	#}
	721	#if ($found == 0) {
	722	#pb_system("sudo sh -c \"echo portage/pb >> /etc/portage/package.keywords\"");
	723	#}
[149]	724
	725	# Build
	726	foreach my $f (@ebuildfile) {
	727	if ($f =~ /\.ebuild$/) {
[295]	728	move($f,"$tmpd/$pbpkg-$pbver.ebuild");
	729	pb_system("cd $tmpd ; ebuild $pbpkg-$pbver.ebuild clean ; ebuild $pbpkg-$pbver.ebuild digest ; ebuild $pbpkg-$pbver.ebuild package");
	730	# Now move it where pb expects it
	731	pb_mkdir_p("$ENV{'PBBUILDDIR'}/portage/pb/sys-apps/$pbpkg");
	732	move("$tmpd/$pbpkg-$pbver.ebuild","$ENV{'PBBUILDDIR'}/portage/pb/sys-apps/$pbpkg");
[149]	733	}
	734	}
	735
[295]	736	$made="$made portage/pb/sys-apps/$pbpkg/$pbpkg-$pbver.ebuild";
[118]	737	} elsif ($dtype eq "slackware") {
[136]	738	$made="$made build-$pbpkg/$pbpkg-$pbver-*-$pbtag.tgz";
[118]	739	pb_mkdir_p("$ENV{'PBBUILDDIR'}/install") if (! -d "$ENV{'PBBUILDDIR'}/install");
[87]	740	} else {
[118]	741	die "Unknown dtype format $dtype";
[87]	742	}
	743	}
[118]	744	# Keep track of what is generated so that we can get them back from VMs
[353]	745	open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to create $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
[118]	746	print KEEP "$made\n";
	747	close(KEEP);
[87]	748	}
	749
[88]	750	sub pb_build2ssh {
[320]	751	pb_send2target("Sources");
[90]	752	}
[87]	753
[90]	754	sub pb_pkg2ssh {
[320]	755	pb_send2target("Packages");
[90]	756	}
	757
[108]	758	# By default deliver to the the public site hosting the
[320]	759	# ftp structure (or whatever) or a VM/VE
	760	sub pb_send2target {
[90]	761
	762	my $cmt = shift;
[320]	763	my $v = shift \|\| undef;
[142]	764	my $vmexist = shift \|\| 0; # 0 is FALSE
[200]	765	my $vmpid = shift \|\| 0; # 0 is FALSE
[320]	766
	767	my $host = "sshhost";
	768	my $login = "sshlogin";
	769	my $dir = "sshdir";
	770	my $port = "sshport";
	771	my $conf = "sshconf";
	772	my $rebuild = "sshrebuild";
[415]	773	my $tmout = "vmtmout";
	774	my $path = "vmpath";
[348]	775	if (($cmt eq "vm") \|\| ($cmt eq "Script")) {
[320]	776	$login = "vmlogin";
[322]	777	$dir = "pbdefdir";
[320]	778	$tmout = "vmtmout";
	779	$rebuild = "vmrebuild";
	780	# Specific VM
	781	$host = "vmhost";
	782	$port = "vmport";
	783	} elsif ($cmt eq "ve") {
	784	$login = "velogin";
[322]	785	$dir = "pbdefdir";
[320]	786	$tmout = "vetmout";
	787	# Specific VE
	788	$path = "vepath";
	789	$conf = "veconf";
	790	$rebuild = "verebuild";
	791	}
[158]	792	my $cmd = "";
[90]	793
[353]	794	my $ptr = pb_get_pkg();
[87]	795	@pkgs = @$ptr;
	796
[136]	797	# Get the running distro to consider
[347]	798	my ($odir,$over,$oarch) = (undef, undef, undef);
[320]	799	if (defined $v) {
	800	($odir,$over,$oarch) = split(/-/,$v);
[118]	801	}
	802	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($odir,$over);
[315]	803	pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n");
[87]	804
[353]	805	# Get list of packages to build
[87]	806	# Get content saved in cms2build
[353]	807	my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
[87]	808	$pkg = { } if (not defined $pkg);
	809
[118]	810	my $src = "";
[87]	811	chdir "$ENV{'PBBUILDDIR'}";
	812	foreach my $pbpkg (@pkgs) {
[88]	813	my $vertag = $pkg->{$pbpkg};
[87]	814	# get the version of the current package - maybe different
	815	($pbver,$pbtag) = split(/-/,$vertag);
	816
[320]	817	if (($cmt eq "Sources") \|\| ($cmt eq "vm") \|\| ($cmt eq "ve")) {
[158]	818	$src = "$src $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz";
[166]	819	if ($cmd eq "") {
	820	$cmd = "ln -sf $pbpkg-$pbver.tar.gz $pbpkg-latest.tar.gz";
	821	} else {
	822	$cmd = "$cmd ; ln -sf $pbpkg-$pbver.tar.gz $pbpkg-latest.tar.gz";
	823	}
[118]	824	}
	825	}
[429]	826	# Adds conf file for availability of conf elements
[417]	827	pb_conf_add("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb");
	828
[320]	829	if (($cmt eq "vm") \|\| ($cmt eq "ve")) {
[429]	830	$src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc";
[142]	831	} elsif ($cmt eq "Script") {
[429]	832	# Nothing special to do
[118]	833	} elsif ($cmt eq "Packages") {
	834	# Get package list from file made during build2pkg
[353]	835	open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
[126]	836	$src = <KEEP>;
[118]	837	chomp($src);
	838	close(KEEP);
[429]	839
[87]	840	}
[429]	841	# Systematically adds the pbscript
	842	$src="$src $ENV{'PBDESTDIR'}/pbscript";
[320]	843	# Remove potential leading spaces (cause problem with basename)
[132]	844	$src =~ s/^ *//;
[129]	845	my $basesrc = "";
[131]	846	foreach my $i (split(/ +/,$src)) {
	847	$basesrc .= " ".basename($i);
[130]	848	}
[118]	849
[320]	850	pb_log(0,"Sources handled ($cmt): $src\n");
[355]	851	pb_log(2,"values: ".Dumper(($host,$login,$dir,$port,$tmout,$rebuild,$path,$conf))."\n");
[415]	852	my ($sshhost,$sshlogin,$sshdir,$sshport,$vtmout,$vepath) = pb_conf_get($host,$login,$dir,$port,$tmout,$path);
	853	my ($vrebuild,$veconf) = pb_conf_get_if($rebuild,$conf);
[320]	854	pb_log(2,"ssh: ".Dumper(($sshhost,$sshlogin,$sshdir,$sshport,$vtmout,$vrebuild,$vepath,$veconf))."\n");
	855	# Not mandatory
	856	my ($testver) = pb_conf_get_if("testver");
	857
	858	my $mac;
	859	# Useless for VE
	860	if ($cmt ne "ve") {
	861	$mac = "$sshlogin->{$ENV{'PBPROJ'}}\@$sshhost->{$ENV{'PBPROJ'}}";
	862	# Overwrite account value if passed as parameter
	863	$mac = "$pbaccount\@$sshhost->{$ENV{'PBPROJ'}}" if (defined $pbaccount);
[355]	864	pb_log(2, "DEBUG: pbaccount: $pbaccount => mac: $mac\n") if (defined $pbaccount);
[320]	865	}
	866
[108]	867	my $tdir;
[136]	868	my $bdir;
[142]	869	if (($cmt eq "Sources") \|\| ($cmt eq "Script")) {
[108]	870	$tdir = "$sshdir->{$ENV{'PBPROJ'}}/src";
[320]	871	} elsif (($cmt eq "vm") \|\| ($cmt eq "ve")) {
	872	$tdir = $sshdir->{$ENV{'PBPROJ'}}."/$ENV{'PBPROJ'}/delivery";
	873	$bdir = $sshdir->{$ENV{'PBPROJ'}}."/$ENV{'PBPROJ'}/build";
[136]	874	# Remove a potential $ENV{'HOME'} as bdir should be relative to pb's home
	875	$bdir =~ s\|\$ENV.+\}/\|\|;
[90]	876	} elsif ($cmt eq "Packages") {
[108]	877	$tdir = "$sshdir->{$ENV{'PBPROJ'}}/$ddir/$dver";
[429]	878
[337]	879	if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
[289]	880	# This is a test pkg => target dir is under test
[428]	881	$tdir = "$sshdir->{$ENV{'PBPROJ'}}/test/$ddir/$dver";
[291]	882	}
[429]	883
	884	my $repodir = $tdir;
	885	$repodir =~ s\|^$sshdir->{$ENV{'PBPROJ'}}/\|\|;
	886
	887	my ($pbrepo) = pb_conf_get("pbrepo");
	888
	889	# Repository management
	890	open(PBS,"> $ENV{'PBDESTDIR'}/pbscript") \|\| die "Unable to create $ENV{'PBDESTDIR'}/pbscript";
	891	if ($dtype eq "rpm") {
	892	# Also make a pbscript to generate yum/urpmi bases
	893	print PBS << "EOF";
[433]	894	#!/bin/bash
[429]	895	# Prepare a script to ease yum setup
	896	cat > $ENV{'PBPROJ'}.repo << EOT
	897	[$ENV{'PBPROJ'}]
	898	name=$ddir $dver - $ENV{'PBPROJ'} Vanilla Packages
[433]	899	baseurl=$pbrepo->{$ENV{'PBPROJ'}}/$repodir
[429]	900	enabled=1
	901	gpgcheck=0
	902	EOT
	903	chmod 644 $ENV{'PBPROJ'}.repo
	904
	905	# Clean up old repo content
	906	rm -rf headers/ repodata/
	907	# Create yum repo
	908	yum-arch .
	909	# Create repodata
	910	createrepo .
	911	EOF
	912	if ($dfam eq "md") {
	913	# For Mandriva add urpmi management
	914	print PBS << "EOF";
	915	# Prepare a script to ease urpmi setup
	916	cat > $ENV{'PBPROJ'}.addmedia << EOT
[433]	917	urpmi.addmedia $ENV{'PBPROJ'} $pbrepo->{$ENV{'PBPROJ'}}/$repodir with hdlist.cz
[429]	918	EOT
	919	chmod 755 $ENV{'PBPROJ'}.addmedia
	920
	921	# Clean up old repo content
	922	rm -f hdlist.cz
	923	# Create urpmi repo
	924	genhdlist .
	925	EOF
	926	}
	927	} elsif ($dtype eq "deb") {
	928	# Also make a pbscript to generate apt bases
	929	}
	930	close(PBS);
	931
[90]	932	} else {
	933	return;
[22]	934	}
[239]	935
[320]	936	# Useless for VE
	937	my $nport;
	938	if ($cmt ne "ve") {
	939	$nport = $sshport->{$ENV{'PBPROJ'}};
	940	$nport = "$pbport" if (defined $pbport);
	941	}
	942
[136]	943	# Remove a potential $ENV{'HOME'} as tdir should be relative to pb's home
[132]	944	$tdir =~ s\|\$ENV.+\}/\|\|;
	945
[320]	946	my $tm = $vtmout->{$ENV{'PBPROJ'}};
	947
	948	# ssh communication if not VE
[349]	949	# should use a hash instead...
[320]	950	my ($shcmd,$cpcmd,$cptarget,$cp2target);
	951	if ($cmt ne "ve") {
[347]	952	my $keyfile = pb_ssh_get(0);
	953	$shcmd = "ssh -i $keyfile -q -p $nport $mac";
	954	$cpcmd = "scp -i $keyfile -p -P $nport";
[320]	955	$cptarget = "$mac:$tdir";
[351]	956	if ($cmt eq "vm") {
	957	$cp2target = "$mac:$bdir";
	958	}
[320]	959	} else {
	960	my $tp = $vepath->{$ENV{'PBPROJ'}};
	961	$shcmd = "sudo chroot $tp/$v /bin/su - $sshlogin->{$ENV{'PBPROJ'}} -c ";
	962	$cpcmd = "cp -a ";
	963	$cptarget = "$tp/$tdir";
	964	$cp2target = "$tp/$bdir";
	965	}
	966
	967	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");
	968	pb_system("cd $ENV{'PBBUILDDIR'} ; $cpcmd $src $cptarget 2> /dev/null","$cmt delivery in $cptarget");
	969	# For VE we need to change the owner manually - To be tested if needed
	970	#if ($cmt eq "ve") {
	971	#pb_system("cd $cptarget ; sudo chown -R $sshlogin->{$ENV{'PBPROJ'}} .","$cmt chown in $cptarget to $sshlogin->{$ENV{'PBPROJ'}}");
	972	#}
	973	pb_system("$shcmd \"echo \'cd $tdir ; if [ -f pbscript ]; then ./pbscript; fi\' \| bash\"","Executing pbscript on $cptarget if needed");
	974	if (($cmt eq "vm") \|\| ($cmt eq "ve")) {
[128]	975	# Get back info on pkg produced, compute their name and get them from the VM
[353]	976	pb_system("$cpcmd $cp2target/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'} $ENV{'PBBUILDDIR'} 2> /dev/null","Get package names in $cp2target");
	977	open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
[118]	978	my $src = <KEEP>;
	979	chomp($src);
	980	close(KEEP);
[131]	981	$src =~ s/^ *//;
[136]	982	pb_mkdir_p("$ENV{'PBBUILDDIR'}/$odir/$over");
[320]	983	# Change pgben to make the next send2target happy
[143]	984	my $made = "";
[353]	985	open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to write $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
[136]	986	foreach my $p (split(/ +/,$src)) {
[139]	987	my $j = basename($p);
[320]	988	pb_system("$cpcmd $cp2target/\'$p\' $ENV{'PBBUILDDIR'}/$odir/$over 2> /dev/null","Package recovery of $j in $cp2target");
[144]	989	$made="$made $odir/$over/$j" if (($dtype ne "rpm") \|\| ($j !~ /.src.rpm$/));
[136]	990	}
[143]	991	print KEEP "$made\n";
[139]	992	close(KEEP);
[320]	993	pb_system("$shcmd \"rm -rf $tdir $bdir\"","$cmt cleanup");
[355]	994
	995	# We want to send them to the ssh account so overwrite what has been done before
	996	undef $pbaccount;
[357]	997	pb_log(2,"Before sending pkgs, vmexist: $vmexist, vmpid: $vmpid\n");
[355]	998	pb_send2target("Packages",$odir."-".$over."-".$oarch,$vmexist,$vmpid);
[320]	999	if ((! $vmexist) && ($cmt eq "vm")) {
	1000	pb_system("$shcmd \"sudo /sbin/halt -p \"; sleep $tm ; echo \'if [ -d /proc/$vmpid ]; then kill -9 $vmpid; fi \' \| bash ; sleep 10","VM $v halt (pid $vmpid)");
[142]	1001	}
[141]	1002	pb_rm_rf("$ENV{'PBBUILDDIR'}/$odir");
[108]	1003	}
[9]	1004	}
[16]	1005
[320]	1006	sub pb_script2v {
[142]	1007	my $pbscript=shift;
[320]	1008	my $vtype=shift;
[141]	1009
	1010	# Prepare the script to be executed on the VM
	1011	# in $ENV{'PBDESTDIR'}/pbscript
[142]	1012	if ((defined $pbscript ) && ($pbscript ne "$ENV{'PBDESTDIR'}/pbscript")) {
	1013	copy($pbscript,"$ENV{'PBDESTDIR'}/pbscript") \|\| die "Unable to create $ENV{'PBDESTDIR'}/pbscript";
	1014	chmod 0755,"$ENV{'PBDESTDIR'}/pbscript";
	1015	}
[141]	1016
[320]	1017	my ($vm,$all) = pb_get_v($vtype);
	1018	my ($vmexist,$vmpid) = (undef,undef);
[142]	1019
[141]	1020	foreach my $v (@$vm) {
[320]	1021	# Launch the VM/VE
	1022	if ($vtype eq "vm") {
	1023	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
[141]	1024
[320]	1025	# Skip that VM if something went wrong
	1026	next if (($vmpid == 0) && ($vmexist ==0));
	1027	}
[274]	1028
[142]	1029	# Gather all required files to send them to the VM
[320]	1030	# and launch the build through pbscript
	1031	pb_send2target("Script","$v",$vmexist,$vmpid);
[169]	1032
[142]	1033	}
	1034	}
	1035
[320]	1036	sub pb_launchv {
	1037	my $vtype = shift;
	1038	my $v = shift;
	1039	my $create = shift \|\| 0; # By default do not create a VM
[310]	1040
[320]	1041	die "No VM/VE defined, unable to launch" if (not defined $v);
	1042	# Keep only the first VM in case many were given
	1043	$v =~ s/,.*//;
[310]	1044
[320]	1045	# Which is our local arch ? (standardize on i386 for those platforms)
	1046	my $arch = `uname -m`;
	1047	chomp($arch);
	1048	$arch =~ s/i.86/i386/;
[310]	1049
[320]	1050	# Launch the VMs/VEs
	1051	if ($vtype eq "vm") {
	1052	die "-i iso parameter needed" if (((not defined $iso) \|\| ($iso eq "")) && ($create != 0));
[310]	1053
[415]	1054	my ($ptr,$vmopt,$vmpath,$vmport,$vmtmout,$vmsize) = pb_conf_get("vmtype","vmopt","vmpath","vmport","vmtmout","vmsize");
[320]	1055
	1056	my $vmtype = $ptr->{$ENV{'PBPROJ'}};
	1057	if (not defined $ENV{'PBVMOPT'}) {
	1058	$ENV{'PBVMOPT'} = "";
[310]	1059	}
[320]	1060	if (defined $vmopt->{$ENV{'PBPROJ'}}) {
	1061	$ENV{'PBVMOPT'} .= " $vmopt->{$ENV{'PBPROJ'}}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$ENV{'PBPROJ'}}/);
	1062	}
	1063	my $nport = $vmport->{$ENV{'PBPROJ'}};
	1064	$nport = "$pbport" if (defined $pbport);
	1065
	1066	my $cmd;
	1067	my $vmcmd; # has to be used for pb_check_ps
	1068	my $vmm; # has to be used for pb_check_ps
	1069	if ($vmtype eq "qemu") {
	1070	my $qemucmd32;
	1071	my $qemucmd64;
	1072	if ($arch eq "x86_64") {
	1073	$qemucmd32 = "/usr/bin/qemu-system-i386";
	1074	$qemucmd64 = "/usr/bin/qemu";
	1075	} else {
	1076	$qemucmd32 = "/usr/bin/qemu";
	1077	$qemucmd64 = "/usr/bin/qemu-system-x86_64";
	1078	}
	1079	if ($v =~ /x86_64/) {
	1080	$vmcmd = "$qemucmd64 -no-kqemu";
	1081	} else {
	1082	$vmcmd = "$qemucmd32";
	1083	}
	1084	$vmm = "$vmpath->{$ENV{'PBPROJ'}}/$v.qemu";
	1085	if ($create != 0) {
	1086	$ENV{'PBVMOPT'} .= " -cdrom $iso -boot d";
	1087	}
	1088	$cmd = "$vmcmd $ENV{'PBVMOPT'} -redir tcp:$nport:10.0.2.15:22 $vmm"
	1089	} elsif ($vmtype eq "xen") {
	1090	} elsif ($vmtype eq "vmware") {
[310]	1091	} else {
[320]	1092	die "VM of type $vmtype not supported. Report to the dev team";
[310]	1093	}
[320]	1094	my ($tmpcmd,$void) = split(/ +/,$cmd);
	1095	my $vmexist = pb_check_ps($tmpcmd,$vmm);
	1096	my $vmpid = 0;
	1097	if (! $vmexist) {
	1098	if ($create != 0) {
	1099	if (($vmtype eq "qemu") \|\| ($vmtype eq "xen")) {
	1100	pb_system("/usr/bin/qemu-img create -f qcow2 $vmm $vmsize->{$ENV{'PBPROJ'}}","Creating the QEMU VM");
	1101	} elsif ($vmtype eq "vmware") {
	1102	} else {
	1103	}
	1104	}
	1105	if (! -f "$vmm") {
	1106	pb_log(0,"Unable to find VM $vmm\n");
	1107	} else {
	1108	pb_system("$cmd &","Launching the VM $vmm");
	1109	pb_system("sleep $vmtmout->{$ENV{'PBPROJ'}}","Waiting for VM $v to come up");
	1110	$vmpid = pb_check_ps($tmpcmd,$vmm);
[357]	1111	pb_log(0,"VM $vmm launched (pid $vmpid)\n");
[320]	1112	}
[310]	1113	} else {
[320]	1114	pb_log(0,"Found an existing VM $vmm (pid $vmexist)\n");
[310]	1115	}
[320]	1116	return($vmexist,$vmpid);
	1117	# VE here
[310]	1118	} else {
[320]	1119	# Get VE context
[415]	1120	my ($ptr,$vetmout,$vepath,$verebuild,$veconf) = pb_conf_get("vetype","vetmout","vepath","verebuild","veconf");
[320]	1121	my $vetype = $ptr->{$ENV{'PBPROJ'}};
[310]	1122
[320]	1123	# Get distro context
	1124	my ($name,$ver,$darch) = split(/-/,$v);
	1125	chomp($darch);
	1126	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($name,$ver);
[142]	1127
[320]	1128	if ($vetype eq "chroot") {
	1129	# Architecture consistency
	1130	if ($arch ne $darch) {
	1131	die "Unable to launch a VE of architecture $darch on a $arch platform" if (not (($darch eq "x86_64") && ($arch =~ /i?86/)));
	1132	}
[142]	1133
[320]	1134	if (($create != 0) \|\| ($verebuild->{$ENV{'PBPROJ'}} eq "true") \|\| ($force == 1)) {
	1135	# We have to rebuild the chroot
	1136	if ($dtype eq "rpm") {
	1137	pb_system("sudo /usr/sbin/mock --init --resultdir=\"/tmp\" --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" -r $v","Creating the mock VE");
	1138	# Once setup we need to install some packages, the pb account, ...
	1139	pb_system("sudo /usr/sbin/mock --install --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" -r $v su","Configuring the mock VE");
	1140	#pb_system("sudo /usr/sbin/mock --init --resultdir=\"/tmp\" --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" --basedir=\"$vepath->{$ENV{'PBPROJ'}}\" -r $v","Creating the mock VE");
	1141	} elsif ($dtype eq "deb") {
	1142	pb_system("","Creating the pbuilder VE");
	1143	} elsif ($dtype eq "ebuild") {
	1144	die "Please teach the dev team how to build gentoo chroot";
	1145	} else {
	1146	die "Unknown distribution type $dtype. Report to dev team";
	1147	}
[310]	1148	}
[320]	1149	# Nothing more to do for VE. No real launch
[274]	1150	} else {
[320]	1151	die "VE of type $vetype not supported. Report to the dev team";
[262]	1152	}
[141]	1153	}
	1154	}
[142]	1155
[320]	1156	sub pb_build2v {
[118]	1157
[320]	1158	my $vtype = shift;
[142]	1159
[320]	1160	# Prepare the script to be executed on the VM/VE
	1161	# in $ENV{'PBDESTDIR'}/pbscript
[353]	1162	#my ($ntp) = pb_conf_get($vtype."ntp");
	1163	#my $vntp = $ntp->{$ENV{'PBPROJ'}};
[118]	1164
[320]	1165	open(SCRIPT,"> $ENV{'PBDESTDIR'}/pbscript") \|\| die "Unable to create $ENV{'PBDESTDIR'}/pbscript";
	1166	print SCRIPT "#!/bin/bash\n";
	1167	print SCRIPT "echo ... Execution needed\n";
	1168	print SCRIPT "# This is in directory delivery\n";
	1169	print SCRIPT "# Setup the variables required for building\n";
	1170	print SCRIPT "export PBPROJ=$ENV{'PBPROJ'}\n";
	1171	print SCRIPT "# Preparation for pb\n";
	1172	print SCRIPT "mv .pbrc \$HOME\n";
	1173	print SCRIPT "cd ..\n";
	1174	# Force new date to be in the future compared to the date of the tar file by adding 1 minute
	1175	my @date=pb_get_date();
	1176	$date[1]++;
	1177	my $upddate = strftime("%m%d%H%M%Y", @date);
[353]	1178	#print SCRIPT "echo Setting up date on $vntp...\n";
[320]	1179	# Or use ntpdate if available TBC
	1180	print SCRIPT "sudo date $upddate\n";
[353]	1181	# Get list of packages to build and get some ENV vars as well
	1182	my $ptr = pb_get_pkg();
	1183	@pkgs = @$ptr;
	1184	my $p = join(' ',@pkgs) if (@pkgs);
	1185	print SCRIPT "export PBPROJVER=$ENV{'PBPROJVER'}\n";
	1186	print SCRIPT "export PBPROJTAG=$ENV{'PBPROJTAG'}\n";
[320]	1187	print SCRIPT "export PBPACKAGER=\"$ENV{'PBPACKAGER'}\"\n";
	1188	print SCRIPT "# Build\n";
	1189	print SCRIPT "echo Building packages on $vtype...\n";
	1190	print SCRIPT "pb -p $ENV{'PBPROJ'} build2pkg $p\n";
	1191	close(SCRIPT);
	1192	chmod 0755,"$ENV{'PBDESTDIR'}/pbscript";
	1193
	1194	my ($v,$all) = pb_get_v($vtype);
	1195
	1196	# Send tar files when we do a global generation
	1197	pb_build2ssh() if ($all == 1);
	1198
	1199	my ($vmexist,$vmpid) = (undef,undef);
	1200
	1201	foreach my $v (@$v) {
	1202	if ($vtype eq "vm") {
[142]	1203	# Launch the VM
[357]	1204	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
[118]	1205
[274]	1206	# Skip that VM if it something went wrong
	1207	next if (($vmpid == 0) && ($vmexist == 0));
[118]	1208	}
[320]	1209	# Gather all required files to send them to the VM/VE
[347]	1210	# and launch the build through pbscript
[357]	1211	pb_log(2,"Calling send2target $vtype,$v,$vmexist,$vmpid\n");
[320]	1212	pb_send2target($vtype,"$v",$vmexist,$vmpid);
[105]	1213	}
[320]	1214	}
[105]	1215
[262]	1216
[199]	1217	sub pb_newver {
	1218
[204]	1219	die "-V Version parameter needed" if ((not defined $newver) \|\| ($newver eq ""));
[340]	1220
[366]	1221	# Need this call for PBDIR
	1222	my ($scheme2,$uri) = pb_cms_init($pbinit);
[361]	1223
[415]	1224	my ($pbconf) = pb_conf_get("pbconfurl");
[366]	1225	$uri = $pbconf->{$ENV{'PBPROJ'}};
	1226	my ($scheme, $account, $host, $port, $path) = pb_get_uri($uri);
	1227
[361]	1228	# Checking CMS repositories status
[358]	1229	my ($pburl) = pb_conf_get("pburl");
[366]	1230	($scheme2, $account, $host, $port, $path) = pb_get_uri($pburl->{$ENV{'PBPROJ'}});
[340]	1231
	1232	if ($scheme !~ /^svn/) {
[199]	1233	die "Only SVN is supported at the moment";
	1234	}
[358]	1235	my $res = pb_cms_isdiff($scheme,$ENV{'PBROOTDIR'});
[361]	1236	die "ERROR: No differences accepted in CMS for $ENV{'PBROOTDIR'} before creating a new version" if ($res != 0);
[358]	1237
	1238	$res = pb_cms_isdiff($scheme2,$ENV{'PBDIR'});
[361]	1239	die "ERROR: No differences accepted in CMS for $ENV{'PBDIR'} before creating a new version" if ($res != 0);
[358]	1240
	1241	# Tree identical between PBCONFDIR and PBROOTDIR. The delta is what
	1242	# we want to get for the root of the new URL
	1243
	1244	my $tmp = $ENV{'PBROOTDIR'};
	1245	$tmp =~ s\|^$ENV{'PBCONFDIR'}\|\|;
	1246
	1247	my $newurl = "$uri/".dirname($tmp)."/$newver";
[366]	1248	# Should probably use projver in the old file
	1249	my $oldver= basename($tmp);
[361]	1250
	1251	# Checking pbcl files
[366]	1252	foreach my $f (<$ENV{'PBROOTDIR'}/*/pbcl>) {
[361]	1253	open(PBCL,$f) \|\| die "Unable to open $f";
	1254	my $foundnew = 0;
	1255	while (<PBCL>) {
[363]	1256	$foundnew = 1 if (/^$newver \(/);
[361]	1257	}
	1258	close(PBCL);
[362]	1259	die "ERROR: version $newver not found in $f" if ($foundnew == 0);
[361]	1260	}
	1261
[366]	1262	# Duplicate and extract project-builder part
[361]	1263	pb_log(2,"Copying $uri/$tmp to $newurl\n");
[366]	1264	pb_cms_copy($scheme,"$uri/$tmp",$newurl);
	1265	pb_log(2,"Checkout $newurl to $ENV{'PBROOTDIR'}/../$newver\n");
[383]	1266	pb_cms_up($scheme,"$ENV{'PBCONFDIR'}/..");
[361]	1267
[366]	1268	# Duplicate and extract project
	1269	my $newurl2 = "$pburl->{$ENV{'PBPROJ'}}/".dirname($tmp)."/$newver";
	1270
	1271	pb_log(2,"Copying $pburl->{$ENV{'PBPROJ'}}/$tmp to $newurl2\n");
	1272	pb_cms_copy($scheme,"$pburl->{$ENV{'PBPROJ'}}/$tmp",$newurl2);
	1273	pb_log(2,"Checkout $newurl2 to $ENV{'PBDIR'}/../$newver\n");
[383]	1274	pb_cms_up($scheme,"$ENV{'PBDIR'}/..");
[366]	1275
[361]	1276	# Update the .pb file
[358]	1277	open(FILE,"$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb") \|\| die "Unable to open $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb";
	1278	open(OUT,"> $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new") \|\| die "Unable to write to $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new";
[208]	1279	while(<FILE>) {
[361]	1280	s/^projver\s+$ENV{'PBPROJ'}\s=\s$oldver/projver $ENV{'PBPROJ'} = $newver/;
	1281	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/);
	1282	s/^testver/#testver/;
	1283	pb_log(0,"Commenting testver in $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb\n") if (/^testver/);
[211]	1284	print OUT $_;
[208]	1285	}
	1286	close(FILE);
[211]	1287	close(OUT);
[358]	1288	rename("$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new","$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb");
[363]	1289
[358]	1290	pb_log(2,"Checkin $ENV{'PBROOTDIR'}/../$newver\n");
[363]	1291	pb_cms_checkin($scheme,"$ENV{'PBROOTDIR'}/../$newver");
[199]	1292	}
	1293
[293]	1294	#
[320]	1295	# Return the list of VMs/VEs we are working on
[105]	1296	# $all is a flag to know if we return all of them
	1297	# or only some (if all we publish also tar files in addition to pkgs
	1298	#
[320]	1299	sub pb_get_v {
[91]	1300
[320]	1301	my $vtype = shift;
	1302	my @v;
[105]	1303	my $all = 0;
[320]	1304	my $vlist;
	1305	my $pbv = 'PBV';
[91]	1306
[320]	1307	if ($vtype eq "vm") {
	1308	$vlist = "vmlist";
	1309	} elsif ($vtype eq "ve") {
	1310	$vlist = "velist";
	1311	}
	1312	# Get VM/VE list
	1313	if ((not defined $ENV{$pbv}) \|\| ($ENV{$pbv} =~ /^all$/)) {
	1314	my ($ptr) = pb_conf_get($vlist);
	1315	$ENV{$pbv} = $ptr->{$ENV{'PBPROJ'}};
[105]	1316	$all = 1;
[91]	1317	}
[320]	1318	pb_log(2,"$vtype: $ENV{$pbv}\n");
	1319	@v = split(/,/,$ENV{$pbv});
	1320	return(\@v,$all);
[91]	1321	}
	1322
[320]	1323	# Function to create a potentialy missing pb account on the VM/VE, and adds it to sudo
	1324	# Needs to use root account to connect to the VM/VE
	1325	# pb will take your local public SSH key to access
[346]	1326	# the pb account in the VM later on if needed
	1327	sub pb_setup_v {
[320]	1328
	1329	my $vtype = shift;
	1330
[353]	1331	my ($vm,$all) = pb_get_v($vtype);
	1332
[346]	1333	# Script generated
	1334	my $pbscript = "$ENV{'PBDESTDIR'}/setupv";
[320]	1335
[353]	1336	foreach my $v (@$vm) {
	1337	# Name of the account to deal with for VM/VE
	1338	# Do not use the one passed potentially with -a
	1339	my ($pbac) = pb_conf_get($vtype."login");
[354]	1340	my ($key,$zero0,$zero1,$zero2);
[357]	1341	my ($vmexist,$vmpid);
[346]	1342
[353]	1343	if ($vtype eq "vm") {
	1344	# Prepare the key to be used and transfered remotely
	1345	my $keyfile = pb_ssh_get(1);
	1346
	1347	my ($vmhost,$vmport) = pb_conf_get("vmhost","vmport");
	1348	my $nport = $vmport->{$ENV{'PBPROJ'}};
	1349	$nport = "$pbport" if (defined $pbport);
[347]	1350
[353]	1351	# Launch the VM
[357]	1352	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
[347]	1353
[353]	1354	# Skip that VM if something went wrong
	1355	return if (($vmpid == 0) && ($vmexist == 0));
	1356
[354]	1357	# Store the pub key part in a variable
	1358	open(FILE,"$keyfile.pub") \|\| die "Unable to open $keyfile.pub";
	1359	($zero0,$zero1,$zero2) = split(/ /,<FILE>);
	1360	close(FILE);
	1361
	1362	$key = "\Q$zero1";
	1363
[353]	1364	pb_system("cat $keyfile.pub \| ssh -q -p $nport -i $keyfile root\@$vmhost->{$ENV{'PBPROJ'}} \"mkdir -p .ssh ; chmod 700 .ssh ; cat >> .ssh/authorized_keys ; chmod 600 .ssh/authorized_keys\"","Copying local keys to $vtype. This will require the root password");
	1365	# once this is done, we can do what we want on the VM remotely
	1366	}
	1367
	1368	# Prepare the script to be executed on the VM/VE
	1369	# in $ENV{'PBDESTDIR'}/setupv
	1370
	1371	open(SCRIPT,"> $pbscript") \|\| die "Unable to create $pbscript";
	1372	print SCRIPT << 'EOF';
[320]	1373	#!/usr/bin/perl -w
	1374
[346]	1375	use strict;
	1376	use File::Copy;
	1377
[427]	1378	our $debug;
	1379	our $LOG;
	1380	our $synmsg = "pbscript";
	1381	pb_log_init($debug, $LOG);
	1382	pb_temp_init();
	1383
[354]	1384	EOF
	1385	if ($vtype eq "vm") {
	1386	print SCRIPT << 'EOF';
	1387	# Removes duplicate in .ssh/authorized_keys of our key if needed
	1388	#
	1389	my $file1="$ENV{'HOME'}/.ssh/authorized_keys";
	1390	open(PBFILE,$file1) \|\| die "Unable to open $file1";
	1391	open(PBOUT,"> $file1.new") \|\| die "Unable to open $file1.new";
	1392	my $count = 0;
	1393	while (<PBFILE>) {
	1394	EOF
	1395	print SCRIPT << "EOF";
	1396	if (/ $key /) {
	1397	\$count++;
	1398	}
	1399	print PBOUT \$_ if ((\$count <= 1) \|\| (\$_ !~ / $key /));
	1400	}
	1401	close(PBFILE);
	1402	close(PBOUT);
	1403	rename("\$file1.new",\$file1);
	1404	chmod 0600,\$file1;
	1405	EOF
	1406	}
	1407	print SCRIPT << 'EOF';
	1408
	1409	# Adds $pbac->{$ENV{'PBPROJ'}} as an account if needed
	1410	#
[346]	1411	my $file="/etc/passwd";
[320]	1412	open(PBFILE,$file) \|\| die "Unable to open $file";
	1413	my $found = 0;
	1414	while (<PBFILE>) {
[346]	1415	EOF
[353]	1416	print SCRIPT << "EOF";
	1417	\$found = 1 if (/^$pbac->{$ENV{'PBPROJ'}}:/);
[346]	1418	EOF
[353]	1419	print SCRIPT << 'EOF';
[320]	1420	}
	1421	close(PBFILE);
	1422
	1423	if ( $found == 0 ) {
	1424	if ( ! -d "/home" ) {
[427]	1425	pb_mkdir("/home");
[320]	1426	}
[346]	1427	EOF
[353]	1428	print SCRIPT << "EOF";
[427]	1429	pb_system("groupadd $pbac->{$ENV{'PBPROJ'}}","Adding group $pbac->{$ENV{'PBPROJ'}}");
	1430	pb_system("useradd $pbac->{$ENV{'PBPROJ'}} -g $pbac->{$ENV{'PBPROJ'}} -m -d /home/$pbac->{$ENV{'PBPROJ'}}","Adding user $pbac->{$ENV{'PBPROJ'}} (group $pbac->{$ENV{'PBPROJ'}} - home /home/$pbac->{$ENV{'PBPROJ'}}");
	1431	}
[320]	1432
[354]	1433	# allow ssh entry to build
	1434	#
[427]	1435	mkdir "/home/$pbac->{$ENV{'PBPROJ'}}/.ssh",0700;
[347]	1436	# Allow those accessing root to access the build account
[427]	1437	copy("\$ENV{'HOME'}/.ssh/authorized_keys","/home/$pbac->{$ENV{'PBPROJ'}}/.ssh/authorized_keys");
[320]	1438	chmod 0600,".ssh/authorized_keys";
[427]	1439	pb_system("chown -R $pbac->{$ENV{'PBPROJ'}}:$pbac->{$ENV{'PBPROJ'}} /home/$pbac->{$ENV{'PBPROJ'}}/.ssh","Finish setting up the SSH env for $pbac->{$ENV{'PBPROJ'}}");
[320]	1440
[346]	1441	EOF
[353]	1442	print SCRIPT << 'EOF';
[347]	1443	# No passwd for build account only keys
[320]	1444	$file="/etc/shadow";
	1445	open(PBFILE,$file) \|\| die "Unable to open $file";
	1446	open(PBOUT,"> $file.new") \|\| die "Unable to open $file.new";
	1447	while (<PBFILE>) {
[346]	1448	EOF
[353]	1449	print SCRIPT << "EOF";
	1450	s/^$pbac->{$ENV{'PBPROJ'}}:\!\!:/$pbac->{$ENV{'PBPROJ'}}:*:/;
	1451	s/^$pbac->{$ENV{'PBPROJ'}}:\!:/$pbac->{$ENV{'PBPROJ'}}:*:/; #SLES 9 e.g.
[346]	1452	EOF
[353]	1453	print SCRIPT << 'EOF';
[320]	1454	print PBOUT $_;
	1455	}
	1456	close(PBFILE);
	1457	close(PBOUT);
	1458	rename("$file.new",$file);
	1459	chmod 0640,$file;
	1460
	1461	# pb has to be added to portage group on gentoo
	1462
[346]	1463	# Adapt sudoers
	1464	$file="/etc/sudoers";
	1465	open(PBFILE,$file) \|\| die "Unable to open $file";
	1466	open(PBOUT,"> $file.new") \|\| die "Unable to open $file.new";
	1467	while (<PBFILE>) {
	1468	EOF
[353]	1469	print SCRIPT << "EOF";
	1470	next if (/^$pbac->{$ENV{'PBPROJ'}} /);
[346]	1471	EOF
[353]	1472	print SCRIPT << 'EOF';
[346]	1473	s/Defaults[ \t]+requiretty//;
	1474	print PBOUT $_;
	1475	}
	1476	close(PBFILE);
	1477	EOF
[353]	1478	print SCRIPT << "EOF";
	1479	# This is needed in order to be able to halt the machine from the $pbac->{$ENV{'PBPROJ'}} account at least
	1480	print PBOUT "$pbac->{$ENV{'PBPROJ'}} ALL=(ALL) NOPASSWD:ALL\n";
[346]	1481	EOF
[353]	1482	print SCRIPT << 'EOF';
[346]	1483	close(PBOUT);
	1484	rename("$file.new",$file);
	1485	chmod 0440,$file;
	1486
	1487	EOF
[353]	1488
	1489	my $SCRIPT = \*SCRIPT;
	1490
	1491	pb_install_deps($SCRIPT);
	1492
	1493	print SCRIPT << 'EOF';
[346]	1494	# Suse wants sudoers as 640
	1495	if (($ddir eq "sles") \|\| (($ddir eq "suse")) && ($dver ne "10.3")) {
	1496	chmod 0640,$file;
	1497	}
	1498
	1499	# Sync date
[353]	1500	#system "/usr/sbin/ntpdate ntp.pool.org";
[346]	1501
[427]	1502	pb_system("rm -rf perl-ProjectBuilder-* ; wget --passive-ftp ftp://ftp.mondorescue.org/src/perl-ProjectBuilder-latest.tar.gz ; tar xvfz perl-ProjectBuilder-latest.tar.gz ; cd perl-ProjectBuilder-* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf perl-ProjectBuilder-* ; rm -rf project-builder-* ; wget --passive-ftp ftp://ftp.mondorescue.org/src/project-builder-latest.tar.gz ; tar xvfz project-builder-latest.tar.gz ; cd project-builder-* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf project-builder-* ;","Building Project-Builder");
[358]	1503	system "pb 2>&1 \| head -5";
[357]	1504	EOF
	1505	if ((! $vmexist) && ($vtype eq "vm")) {
	1506	print SCRIPT << 'EOF';
[427]	1507	pb_system("sudo /sbin/halt -p","Halting the $vtype");
[346]	1508	EOF
[357]	1509	}
[353]	1510
	1511	# Adds pb_distro_init from ProjectBuilder::Distribution
	1512	foreach my $d (@INC) {
[405]	1513	my @f = ("$d/ProjectBuilder/Base.pm","$d/ProjectBuilder/Distribution.pm");
	1514	foreach my $f (@f) {
	1515	if (-f "$f") {
	1516	open(PBD,"$f") \|\| die "Unable to open $f";
	1517	while (<PBD>) {
[427]	1518	next if (/^package/);
	1519	next if (/^use Exporter/);
	1520	next if (/^use ProjectBuilder::/);
	1521	next if (/^our /);
[405]	1522	print SCRIPT $_;
	1523	}
	1524	close(PBD);
[353]	1525	}
[347]	1526	}
	1527	}
[353]	1528	close(SCRIPT);
	1529	chmod 0755,"$pbscript";
	1530
	1531	# That build script needs to be run as root
	1532	$pbaccount = "root";
	1533	pb_script2v($pbscript,$vtype);
[347]	1534	}
[353]	1535	return;
[346]	1536	}
	1537
[347]	1538	sub pb_install_deps {
[346]	1539
[348]	1540	my $SCRIPT = shift;
[346]	1541
[348]	1542	print {$SCRIPT} << 'EOF';
[346]	1543	# We need to have that pb_distro_init function
[347]	1544	# Get it from Project-Builder::Distribution
[320]	1545	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init();
	1546	print "distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n";
	1547
	1548	# Get and install pb
[357]	1549	my $insdm = "rm -rf Date-Manip* ; wget http://search.cpan.org/CPAN/authors/id/S/SB/SBECK/Date-Manip-5.48.tar.gz ; tar xvfz Date-Manip-5.48.tar.gz ; cd Date-Manip* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf Date-Manip*";
	1550	my $insmb = "rm -rf Module-Build* ; wget http://search.cpan.org/CPAN/authors/id/K/KW/KWILLIAMS/Module-Build-0.2808.tar.gz ; tar xvfz Module-Build-0.2808.tar.gz ; cd Module-Build* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf Module-Build*";
	1551	my $insfm = "rm -rf File-MimeInfo* ; wget http://search.cpan.org/CPAN/authors/id/P/PA/PARDUS/File-MimeInfo/File-MimeInfo-0.15.tar.gz ; tar xvfz File-MimeInfo-0.15.tar.gz ; cd File-MimeInfo* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf File-MimeInfo*";
	1552	my $insfb = "rm -rf File-Basedir* ; wget http://search.cpan.org/CPAN/authors/id/P/PA/PARDUS/File-BaseDir-0.03.tar.gz ; tar xvfz File-BaseDir-0.03.tar.gz ; cd File-BaseDir* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf File-BaseDir*";
[427]	1553	my $cmtdm = "Installing Date-Manip perl module";
	1554	my $cmtmb = "Installing Module-Build perl module";
	1555	my $cmtfm = "Installing File-MimeInfo perl module";
	1556	my $cmtfb = "Installing File-Basedir perl module";
	1557	my $cmtall = "Installing required modules";
[357]	1558
[320]	1559	if ( $ddir eq "fedora" ) {
[427]	1560	pb_system("yum clean all","Cleaning yum env");
[346]	1561	#system "yum update -y";
[320]	1562	my $arch=`uname -m`;
	1563	my $opt = "";
	1564	chomp($arch);
	1565	if ($arch eq "x86_64") {
	1566	$opt="--exclude=*.i?86";
	1567	}
	1568
[427]	1569	pb_system("yum -y $opt install rpm-build wget patch ntp sudo perl-DateManip perl-File-MimeInfo perl-ExtUtils-MakeMaker",$cmtall);
[357]	1570	if ($dver eq 4) {
[427]	1571	pb_system("$insmb","$cmtmb");
	1572	pb_system("$insfm","$cmtfm");
	1573	pb_system("$insfb","$cmtfb");
[357]	1574	}
	1575	} elsif (( $dfam eq "rh" ) \|\| ($ddir eq "sles") \|\| (($ddir eq "suse") && (($dver eq "10.1") \|\| ($dver eq "10.0"))) \|\| ($ddir eq "slackware")) {
[358]	1576	# Suppose pkg are installed already as no online mirror available
[427]	1577	pb_system("rpm -e lsb 2>&1 > /dev/null","Removing lsb package");
	1578	pb_system("$insdm","$cmtdm");
	1579	pb_system("$insmb","$cmtmb");
	1580	pb_system("$insfm","$cmtfm");
	1581	pb_system("$insfb","$cmtfb");
[320]	1582	} elsif ($ddir eq "suse") {
	1583	# New OpenSuSE
[427]	1584	pb_system("$insmb","$cmtmb");
	1585	pb_system("$insfm","$cmtfm");
	1586	pb_system("$insfb","$cmtfb");
	1587	pb_system("export TERM=linux ; liste=\"\" ; for i in make wget patch sudo perl-DateManip perl-File-HomeDir xntp; do rpm -q \$i 1> /dev/null 2> /dev/null ; if [ \$\? != 0 ]; then liste=\"\$liste \$i\"; fi; done; echo \"Liste: \$liste\" ; if [ \"\$liste\" != \"\" ]; then yast2 -i \$liste ; fi","$cmtall");
[320]	1588	} elsif ( $dfam eq "md" ) {
[427]	1589	pb_system("urpmi.update -a ; urpmi --auto rpm-build wget sudo patch ntp-client perl-File-MimeInfo","$cmtall");
[357]	1590	if (($ddir eq "mandrake") && ($dver eq "10.1")) {
[427]	1591	pb_system("$insdm","$cmtdm");
[357]	1592	} else {
[427]	1593	pb_system("urpmi --auto perl-DateManip","$cmtdm");
[357]	1594	}
[320]	1595	} elsif ( $dfam eq "du" ) {
	1596	if (( $dver eq "3.1" ) && ($ddir eq "debian")) {
[346]	1597	#system "apt-get update";
[427]	1598	pb_system("$insfb","$cmtfb");
	1599	pb_system("$insfm","$cmtfm");
	1600	pb_system("apt-get -y install wget patch ssh sudo debian-builder dh-make fakeroot ntpdate libmodule-build-perl libdate-manip-perl","$cmtall");
[320]	1601	} else {
[427]	1602	pb_system("apt-get update; apt-get -y install wget patch openssh-server dpkg-dev sudo debian-builder dh-make fakeroot ntpdate libfile-mimeinfo-perl libmodule-build-perl libdate-manip-perl","$cmtall");
[320]	1603	}
	1604	} elsif ( $dfam eq "gen" ) {
[427]	1605	#system "emerge -u system";
	1606	pb_system("emerge wget sudo ntp DateManip File-MimeInfo","$cmtall");
[320]	1607	} else {
	1608	print "No pkg to install\n";
	1609	}
	1610	EOF
	1611	}
	1612
[347]	1613	# Return the SSH key file to use
	1614	# Potentially create it if needed
	1615
	1616	sub pb_ssh_get {
	1617
	1618	my $create = shift \|\| 0; # Do not create keys by default
	1619
	1620	# Check the SSH environment
	1621	my $keyfile = undef;
	1622
	1623	# We have specific keys by default
	1624	$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa";
[348]	1625	if (!(-e $keyfile) && ($create eq 1)) {
[347]	1626	pb_system("ssh-keygen -q -b 1024 -N '' -f $keyfile -t dsa","Generating SSH keys for pb");
	1627	}
	1628
	1629	$keyfile = "$ENV{'HOME'}/.ssh/id_rsa" if (-s "$ENV{'HOME'}/.ssh/id_rsa");
	1630	$keyfile = "$ENV{'HOME'}/.ssh/id_dsa" if (-s "$ENV{'HOME'}/.ssh/id_dsa");
	1631	$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa" if (-s "$ENV{'HOME'}/.ssh/pb_dsa");
	1632	die "Unable to find your public ssh key under $keyfile" if (not defined $keyfile);
	1633	return($keyfile);
	1634	}
	1635
	1636
[145]	1637	# Returns the pid of a running VM command using a specific VM file
[142]	1638	sub pb_check_ps {
	1639	my $vmcmd = shift;
	1640	my $vmm = shift;
	1641	my $vmexist = 0; # FALSE by default
	1642
	1643	open(PS, "ps auxhww\|") \|\| die "Unable to call ps";
	1644	while (<PS>) {
	1645	next if (! /$vmcmd/);
	1646	next if (! /$vmm/);
	1647	my ($void1, $void2);
	1648	($void1, $vmexist, $void2) = split(/ +/);
	1649	last;
	1650	}
	1651	return($vmexist);
	1652	}
	1653
	1654
[77]	1655	sub pb_extract_build_files {
[25]	1656
	1657	my $src=shift;
	1658	my $dir=shift;
[26]	1659	my $ddir=shift;
[28]	1660	my @files;
[25]	1661
[188]	1662	if ($src =~ /tar\.gz$/) {
	1663	pb_system("tar xfpz $src $dir","Extracting build files");
	1664	} elsif ($src =~ /tar\.bz2$/) {
	1665	pb_system("tar xfpj $src $dir","Extracting build files");
	1666	} else {
	1667	die "Unknown compression algorithm for $src";
	1668	}
[25]	1669	opendir(DIR,"$dir") \|\| die "Unable to open directory $dir";
	1670	foreach my $f (readdir(DIR)) {
	1671	next if ($f =~ /^\./);
[26]	1672	move("$dir/$f","$ddir") \|\| die "Unable to move $dir/$f to $ddir";
[315]	1673	pb_log(2,"mv $dir/$f $ddir\n");
[28]	1674	push @files,"$ddir/$f";
[25]	1675	}
	1676	closedir(DIR);
[26]	1677	# Not enough but still a first cleanup
[74]	1678	pb_rm_rf("$dir");
[28]	1679	return(@files);
[25]	1680	}
	1681
[315]	1682	sub pb_list_bfiles {
	1683
	1684	my $dir = shift;
	1685	my $pbpkg = shift;
	1686	my $bfiles = shift;
	1687	my $pkgfiles = shift;
	1688	my $supfiles = shift;
	1689
	1690	opendir(BDIR,"$dir") \|\| die "Unable to open dir $dir: $!";
	1691	foreach my $f (readdir(BDIR)) {
	1692	next if ($f =~ /^\./);
	1693	$bfiles->{$f} = "$dir/$f";
[340]	1694	$bfiles->{$f} =~ s~$ENV{'PBROOTDIR'}~~;
[315]	1695	if (defined $supfiles->{$pbpkg}) {
	1696	$pkgfiles->{$f} = "$dir/$f" if ($f =~ /$supfiles->{$pbpkg}/);
	1697	}
	1698	}
	1699	closedir(BDIR);
	1700	}
	1701
[395]	1702
	1703	#
	1704	# Return the list of packages we are working on in a non CMS action
	1705	#
	1706	sub pb_get_pkg {
	1707
	1708	my @pkgs = ();
	1709
	1710	my ($var) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
	1711	@pkgs = keys %$var;
	1712
	1713	pb_log(0,"Packages: ".join(',',@pkgs)."\n");
	1714	return(\@pkgs);
	1715	}
	1716
	1717	1;

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

Download in other formats: