Context Navigation

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

Last change on this file since 477 was 477, checked in by Bruno Cornec, 16 years ago
use Mail::Sendmail instead of mutt to deliver mail (From: header issue)
Property svn:executable set to ``*
File size: 62.9 KB

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

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

Download in other formats: