Context Navigation

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

Last change on this file since 434 was 434, checked in by Bruno Cornec, 16 years ago
remobes pbscript at the end of execution
Property svn:executable set to ``*
File size: 53.8 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
30	# Global variables
31	my %opts; # CLI Options
32	my $action; # action to realize
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
37	my $pbtag; # Global Tag variable
38	my $pbver; # Global Version variable
39	my $pbscript; # Name of the script
40	my %pbver; # per package
41	my %pbtag; # per package
42	my $pbrev; # Global REVISION variable
43	my $pbaccount; # Login to use to connect to the VM
44	my $pbport; # Port to use to connect to the VM
45	my $newver; # New version to create
46	my $iso; # ISO image for the VM to create
47
48	my @date = pb_get_date();
49	my $pbdate = strftime("%Y-%m-%d", @date);
50
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
69	pb [-vhq][-r pbroot][-p project][[-s script -a account -P port][-m mach-1[,...]]][-i iso] <action> [<pkg1> ...]
70
71	pb [--verbose][--help][--man][--quiet][--revision pbroot][--project project][[--script script --account account --port port][--machine mach-1[,...]]][--iso iso] <action> [<pkg1> ...]
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
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
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
303	my ($projectbuilderver,$projectbuilderrev) = pb_version_init();
304
305	# Initialize the syntax string
306
307	pb_syntax_init("pb (aka project-builder.org) Version $projectbuilderver-$projectbuilderrev\n");
308
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
325	if (defined $opts{'h'}) {
326	pb_syntax(0,1);
327	}
328	if (defined $opts{'man'}) {
329	pb_syntax(0,2);
330	}
331	if (defined $opts{'v'}) {
332	$debug = $opts{'v'};
333	}
334	if (defined $opts{'f'}) {
335	$force=1;
336	}
337	if (defined $opts{'q'}) {
338	$debug=-1;
339	}
340	if (defined $opts{'l'}) {
341	open(LOG,"> $opts{'l'}") \|\| die "Unable to log to $opts{'l'}: $!";
342	$LOG = \*LOG;
343	$debug = 0 if ($debug == -1);
344	}
345	pb_log_init($debug, $LOG);
346
347	# Handle root of the project if defined
348	if (defined $opts{'r'}) {
349	$ENV{'PBROOTDIR'} = $opts{'r'};
350	}
351	# Handle virtual machines if any
352	if (defined $opts{'m'}) {
353	$ENV{'PBV'} = $opts{'m'};
354	}
355	if (defined $opts{'s'}) {
356	$pbscript = $opts{'s'};
357	}
358	if (defined $opts{'a'}) {
359	$pbaccount = $opts{'a'};
360	die "option -a requires a -s script option" if (not defined $pbscript);
361	}
362	if (defined $opts{'P'}) {
363	$pbport = $opts{'P'};
364	}
365	if (defined $opts{'V'}) {
366	$newver = $opts{'V'};
367	}
368	if (defined $opts{'i'}) {
369	$iso = $opts{'i'};
370	}
371
372	# Get Action
373	$action = shift @ARGV;
374	die pb_syntax(-1,1) if (not defined $action);
375
376	my ($filteredfiles, $supfiles, $defpkgdir, $extpkgdir);
377	my $pbinit = undef;
378	$pbinit = 1 if ($action =~ /^newproj$/);
379
380	# Handles project name if any
381	# And get global params
382	($filteredfiles, $supfiles, $defpkgdir, $extpkgdir) = pb_env_init($opts{'p'},$pbinit,$action);
383
384	pb_log(0,"Project: $ENV{'PBPROJ'}\n");
385	pb_log(0,"Action: $action\n");
386
387	# Act depending on action
388	if ($action =~ /^cms2build$/) {
389	pb_cms2build();
390	} elsif ($action =~ /^build2pkg$/) {
391	pb_build2pkg();
392	} elsif ($action =~ /^cms2pkg$/) {
393	pb_cms2build();
394	pb_build2pkg();
395	} elsif ($action =~ /^build2ssh$/) {
396	pb_build2ssh();
397	} elsif ($action =~ /^cms2ssh$/) {
398	pb_cms2build();
399	pb_build2ssh();
400	} elsif ($action =~ /^pkg2ssh$/) {
401	pb_pkg2ssh();
402	} elsif ($action =~ /^build2ve$/) {
403	pb_build2v("ve");
404	} elsif ($action =~ /^build2vm$/) {
405	pb_build2v("vm");
406	} elsif ($action =~ /^cms2ve$/) {
407	pb_cms2build();
408	pb_build2v("ve");
409	} elsif ($action =~ /^cms2vm$/) {
410	pb_cms2build();
411	pb_build2v("vm");
412	} elsif ($action =~ /^launchvm$/) {
413	pb_launchv("vm",$ENV{'PBV'},0);
414	} elsif ($action =~ /^launchve$/) {
415	pb_launchv("ve",$ENV{'PBV'},0);
416	} elsif ($action =~ /^script2vm$/) {
417	pb_script2v($pbscript,"vm");
418	} elsif ($action =~ /^script2ve$/) {
419	pb_script2v($pbscript,"ve");
420	} elsif ($action =~ /^newver$/) {
421	pb_newver();
422	} elsif ($action =~ /^newve$/) {
423	pb_launchv("ve",$ENV{'PBV'},1);
424	} elsif ($action =~ /^newvm$/) {
425	pb_launchv("vm",$ENV{'PBV'},1);
426	} elsif ($action =~ /^setupve$/) {
427	pb_setup_v("ve");
428	} elsif ($action =~ /^setupvm$/) {
429	pb_setup_v("vm");
430	} elsif ($action =~ /^newproj$/) {
431	# Nothing to do - already done in pb_env_init
432	} elsif ($action =~ /^clean$/) {
433	} else {
434	pb_log(0,"\'$action\' is not available\n");
435	pb_syntax(-2,1);
436	}
437
438	sub pb_cms2build {
439
440	my $pkg = pb_cms_get_pkg($defpkgdir,$extpkgdir);
441	my @pkgs = @$pkg;
442	my %pkgs;
443
444	my ($scheme, $uri) = pb_cms_init($pbinit);
445
446	my ($pkgv, $pkgt) = pb_conf_get_if("pkgver","pkgtag");
447
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'}};
452
453	foreach my $pbpkg (@pkgs) {
454	$ENV{'PBPKG'} = $pbpkg;
455	if ((defined $pkgv) && (defined $pkgv->{$pbpkg})) {
456	$pbver = $pkgv->{$pbpkg};
457	} else {
458	$pbver = $ENV{'PBPROJVER'};
459	}
460	if ((defined $pkgt) && (defined $pkgt->{$pbpkg})) {
461	$pbtag = $pkgt->{$pbpkg};
462	} else {
463	$pbtag = $ENV{'PBPROJTAG'};
464	}
465
466	$pbrev = $ENV{'PBREVISION'};
467	pb_log(0,"\n");
468	pb_log(0,"Management of $pbpkg $pbver-$pbtag (rev $pbrev)\n");
469	die "Unable to get env var PBDESTDIR" if (not defined $ENV{'PBDESTDIR'});
470	# Clean up dest if necessary. The export will recreate it
471	my $dest = "$ENV{'PBDESTDIR'}/$pbpkg-$pbver";
472	pb_rm_rf($dest) if (-d $dest);
473
474	# Export CMS tree for the concerned package to dest
475	# And generate some additional files
476	$OUTPUT_AUTOFLUSH=1;
477
478	# computes in which dir we have to work
479	my $dir = $defpkgdir->{$pbpkg};
480	$dir = $extpkgdir->{$pbpkg} if (not defined $dir);
481	pb_log(2,"def:".Dumper($defpkgdir)." ext: ".Dumper($extpkgdir)." \n");
482
483	# Exporting from CMS
484	pb_cms_export($uri,"$ENV{'PBDIR'}/$dir",$dest);
485
486	# Get project info on authors and log file
487	my $chglog = "$ENV{'PBROOTDIR'}/$pbpkg/pbcl";
488	$chglog = "$ENV{'PBROOTDIR'}/pbcl" if (! -f $chglog);
489	$chglog = undef if (! -f $chglog);
490
491	my $authors = "$ENV{'PBROOTDIR'}/$pbpkg/pbauthors";
492	$authors = "$ENV{'PBROOTDIR'}/pbauthors" if (! -f $authors);
493	$authors = "/dev/null" if (! -f $authors);
494
495	# Extract cms log history and store it
496	if ((defined $chglog) && (! -f "$dest/NEWS")) {
497	pb_log(2,"Generating NEWS file from $chglog\n");
498	copy($chglog,"$dest/NEWS") \|\| die "Unable to create $dest/NEWS";
499	}
500	pb_cms_log($scheme,"$ENV{'PBDIR'}/$dir",$dest,$chglog,$authors);
501
502	my %build;
503
504	my @pt;
505	@pt = pb_conf_get_if("vmlist","velist");
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)) {
518	my ($name,$ver,$arch) = split(/-/,$d);
519	chomp($arch);
520	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($name,$ver);
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");
523
524	# Filter build files from the less precise up to the most with overloading
525	# Filter all files found, keeping the name, and generating in dest
526
527	# Find all build files first relatively to PBROOTDIR
528	# Find also all specific files referenced in the .pb conf file
529	my %bfiles = ();
530	my %pkgfiles = ();
531	$build{"$ddir-$dver"} = "yes";
532
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);
541	} else {
542	$build{"$ddir-$dver"} = "no";
543	next;
544	}
545	pb_log(2,"DEBUG bfiles: ".Dumper(\%bfiles)."\n");
546
547	# Get all filters to apply
548	my $ptr = pb_get_filters($pbpkg, $dtype, $dfam, $ddir, $dver);
549
550	# Apply now all the filters on all the files concerned
551	# destination dir depends on the type of file
552	if (defined $ptr) {
553	foreach my $f (values %bfiles,values %pkgfiles) {
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'});
555	}
556	}
557	}
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/);
563	}
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);
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
571	my $ptr = pb_get_filters($pbpkg);
572
573	my $liste ="";
574	if (defined $filteredfiles->{$pbpkg}) {
575	foreach my $f (split(/,/,$filteredfiles->{$pbpkg})) {
576	pb_filter_file_inplace($ptr,"$dest/$f",$pbpkg,$pbver,$pbtag,$pbrev,$pbdate,$ENV{'PBPACKAGER'},$ENV{'PBPROJ'},$ENV{'PBREPO'});
577	$liste = "$f $liste";
578	}
579	}
580	pb_log(2,"Files ".$liste."have been filtered\n");
581
582	# Prepare the dest directory for archive
583	if (-x "$ENV{'PBROOTDIR'}/$pbpkg/pbinit") {
584	pb_filter_file("$ENV{'PBROOTDIR'}/$pbpkg/pbinit",$ptr,"$ENV{'PBTMP'}/pbinit",$pbpkg,$pbver,$pbtag,$pbrev,$pbdate,$ENV{'PBPACKAGER'},$ENV{'PBPROJ'},$ENV{'PBREPO'});
585	chmod 0755,"$ENV{'PBTMP'}/pbinit";
586	pb_system("cd $dest ; $ENV{'PBTMP'}/pbinit","Executing init script from $ENV{'PBROOTDIR'}/$pbpkg/pbinit");
587	}
588
589	# Archive dest dir
590	chdir "$ENV{'PBDESTDIR'}" \|\| die "Unable to change dir to $ENV{'PBDESTDIR'}";
591	# Possibility to look at PBSRC to guess more the filename
592	pb_system("tar cfz $pbpkg-$pbver.tar.gz $pbpkg-$pbver","Creating $pbpkg tar files compressed");
593	pb_log(0,"Under $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz\n");
594
595	# Keep track of version-tag per pkg
596	$pkgs{$pbpkg} = "$pbver-$pbtag";
597
598	# Final cleanup
599	pb_rm_rf($dest) if (-d $dest);
600	}
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);
620	}
621
622	sub pb_build2pkg {
623
624	# Get the running distro to build on
625	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init();
626	pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n");
627
628	# Get list of packages to build
629	# Get content saved in cms2build
630	my $ptr = pb_get_pkg();
631	@pkgs = @$ptr;
632
633	my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
634	$pkg = { } if (not defined $pkg);
635
636	chdir "$ENV{'PBBUILDDIR'}";
637	my $made = ""; # pkgs made during build
638	foreach my $pbpkg (@pkgs) {
639	my $vertag = $pkg->{$pbpkg};
640	# get the version of the current package - maybe different
641	($pbver,$pbtag) = split(/-/,$vertag);
642
643	my $src="$ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz";
644	pb_log(2,"Source file: $src\n");
645
646	pb_log(2,"Working directory: $ENV{'PBBUILDDIR'}\n");
647	if ($dtype eq "rpm") {
648	foreach my $d ('RPMS','SRPMS','SPECS','SOURCES','BUILD') {
649	if (! -d "$ENV{'PBBUILDDIR'}/$d") {
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";
651	}
652	}
653
654	# Remove in case a previous link/file was there
655	unlink "$ENV{'PBBUILDDIR'}/SOURCES/".basename($src);
656	symlink "$src","$ENV{'PBBUILDDIR'}/SOURCES/".basename($src) \|\| die "Unable to symlink $src in $ENV{'PBBUILDDIR'}/SOURCES";
657	# We need to first extract the spec file
658	my @specfile;
659	@specfile = pb_extract_build_files($src,"$pbpkg-$pbver/pbconf/$ddir-$dver/","$ENV{'PBBUILDDIR'}/SPECS");
660
661	pb_log(2,"specfile: ".Dumper(\@specfile)."\n");
662	# set LANGUAGE to check for correct log messages
663	$ENV{'LANGUAGE'}="C";
664	foreach my $f (@specfile) {
665	if ($f =~ /\.spec$/) {
666	pb_system("rpmbuild --define \'packager $ENV{'PBPACKAGER'}\' --define \"_topdir $ENV{'PBBUILDDIR'}\" -ba $f","Building package with $f under $ENV{'PBBUILDDIR'}");
667	last;
668	}
669	}
670	$made="$made RPMS//$pbpkg-$pbver-$pbtag$pbsuf..rpm SRPMS/$pbpkg-$pbver-$pbtag$pbsuf.src.rpm";
671	if (-f "/usr/bin/rpmlint") {
672	pb_system("rpmlint $made","Checking validity of rpms with rpmlint");
673	}
674	} elsif ($dtype eq "deb") {
675	chdir "$ENV{'PBBUILDDIR'}" \|\| die "Unable to chdir to $ENV{'PBBUILDDIR'}";
676	pb_system("tar xfz $src","Extracting sources");
677
678	chdir "$pbpkg-$pbver" \|\| die "Unable to chdir to $pbpkg-$pbver";
679	pb_rm_rf("debian");
680	symlink "pbconf/$ddir-$dver","debian" \|\| die "Unable to symlink to pbconf/$ddir-$dver";
681	chmod 0755,"debian/rules";
682	pb_system("dpkg-buildpackage -us -uc -rfakeroot","Building package");
683	$made="$made $pbpkg"."_.deb $pbpkg"."_.dsc $pbpkg"."_*.tar.gz";
684	if (-f "/usr/bin/lintian") {
685	pb_system("lintian $made","Checking validity of debs with lintian");
686	}
687	} elsif ($dtype eq "ebuild") {
688	my @ebuildfile;
689	# For gentoo we need to take pb as subsystem name
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");
695
696	# We need to first extract the ebuild file
697	@ebuildfile = pb_extract_build_files($src,"$pbpkg-$pbver/pbconf/$ddir-$dver/","$tmpd");
698
699	# Prepare the build env for gentoo
700	my $found = 0;
701	my $pbbd = $ENV{'HOME'};
702	$pbbd =~ s\|/\|\\/\|g;
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);
709	}
710	if ($found == 0) {
711	pb_system("sudo sh -c 'echo PORTDIR_OVERLAY=\"$ENV{'HOME'}/portage\" >> /etc/make.conf'");
712	}
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	#}
724
725	# Build
726	foreach my $f (@ebuildfile) {
727	if ($f =~ /\.ebuild$/) {
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");
733	}
734	}
735
736	$made="$made portage/pb/sys-apps/$pbpkg/$pbpkg-$pbver.ebuild";
737	} elsif ($dtype eq "slackware") {
738	$made="$made build-$pbpkg/$pbpkg-$pbver-*-$pbtag.tgz";
739	pb_mkdir_p("$ENV{'PBBUILDDIR'}/install") if (! -d "$ENV{'PBBUILDDIR'}/install");
740	} else {
741	die "Unknown dtype format $dtype";
742	}
743	}
744	# Keep track of what is generated so that we can get them back from VMs
745	open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to create $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
746	print KEEP "$made\n";
747	close(KEEP);
748	}
749
750	sub pb_build2ssh {
751	pb_send2target("Sources");
752	}
753
754	sub pb_pkg2ssh {
755	pb_send2target("Packages");
756	}
757
758	# By default deliver to the the public site hosting the
759	# ftp structure (or whatever) or a VM/VE
760	sub pb_send2target {
761
762	my $cmt = shift;
763	my $v = shift \|\| undef;
764	my $vmexist = shift \|\| 0; # 0 is FALSE
765	my $vmpid = shift \|\| 0; # 0 is FALSE
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";
773	my $tmout = "vmtmout";
774	my $path = "vmpath";
775	if (($cmt eq "vm") \|\| ($cmt eq "Script")) {
776	$login = "vmlogin";
777	$dir = "pbdefdir";
778	$tmout = "vmtmout";
779	$rebuild = "vmrebuild";
780	# Specific VM
781	$host = "vmhost";
782	$port = "vmport";
783	} elsif ($cmt eq "ve") {
784	$login = "velogin";
785	$dir = "pbdefdir";
786	$tmout = "vetmout";
787	# Specific VE
788	$path = "vepath";
789	$conf = "veconf";
790	$rebuild = "verebuild";
791	}
792	my $cmd = "";
793
794	my $ptr = pb_get_pkg();
795	@pkgs = @$ptr;
796
797	# Get the running distro to consider
798	my ($odir,$over,$oarch) = (undef, undef, undef);
799	if (defined $v) {
800	($odir,$over,$oarch) = split(/-/,$v);
801	}
802	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($odir,$over);
803	pb_log(2,"DEBUG: distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n");
804
805	# Get list of packages to build
806	# Get content saved in cms2build
807	my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
808	$pkg = { } if (not defined $pkg);
809
810	my $src = "";
811	chdir "$ENV{'PBBUILDDIR'}";
812	foreach my $pbpkg (@pkgs) {
813	my $vertag = $pkg->{$pbpkg};
814	# get the version of the current package - maybe different
815	($pbver,$pbtag) = split(/-/,$vertag);
816
817	if (($cmt eq "Sources") \|\| ($cmt eq "vm") \|\| ($cmt eq "ve")) {
818	$src = "$src $ENV{'PBDESTDIR'}/$pbpkg-$pbver.tar.gz";
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	}
824	}
825	}
826	# Adds conf file for availability of conf elements
827	pb_conf_add("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb");
828
829	if (($cmt eq "vm") \|\| ($cmt eq "ve")) {
830	$src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc";
831	} elsif ($cmt eq "Script") {
832	# Nothing special to do
833	} elsif ($cmt eq "Packages") {
834	# Get package list from file made during build2pkg
835	open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
836	$src = <KEEP>;
837	chomp($src);
838	close(KEEP);
839
840	}
841	# Systematically adds the pbscript
842	$src="$src $ENV{'PBDESTDIR'}/pbscript";
843	# Remove potential leading spaces (cause problem with basename)
844	$src =~ s/^ *//;
845	my $basesrc = "";
846	foreach my $i (split(/ +/,$src)) {
847	$basesrc .= " ".basename($i);
848	}
849
850	pb_log(0,"Sources handled ($cmt): $src\n");
851	pb_log(2,"values: ".Dumper(($host,$login,$dir,$port,$tmout,$rebuild,$path,$conf))."\n");
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);
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);
864	pb_log(2, "DEBUG: pbaccount: $pbaccount => mac: $mac\n") if (defined $pbaccount);
865	}
866
867	my $tdir;
868	my $bdir;
869	if (($cmt eq "Sources") \|\| ($cmt eq "Script")) {
870	$tdir = "$sshdir->{$ENV{'PBPROJ'}}/src";
871	} elsif (($cmt eq "vm") \|\| ($cmt eq "ve")) {
872	$tdir = $sshdir->{$ENV{'PBPROJ'}}."/$ENV{'PBPROJ'}/delivery";
873	$bdir = $sshdir->{$ENV{'PBPROJ'}}."/$ENV{'PBPROJ'}/build";
874	# Remove a potential $ENV{'HOME'} as bdir should be relative to pb's home
875	$bdir =~ s\|\$ENV.+\}/\|\|;
876	} elsif ($cmt eq "Packages") {
877	$tdir = "$sshdir->{$ENV{'PBPROJ'}}/$ddir/$dver";
878
879	if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
880	# This is a test pkg => target dir is under test
881	$tdir = "$sshdir->{$ENV{'PBPROJ'}}/test/$ddir/$dver";
882	}
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";
894	#!/bin/bash
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
899	baseurl=$pbrepo->{$ENV{'PBPROJ'}}/$repodir
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
917	urpmi.addmedia $ENV{'PBPROJ'} $pbrepo->{$ENV{'PBPROJ'}}/$repodir with hdlist.cz
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
932	} else {
933	return;
934	}
935
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
943	# Remove a potential $ENV{'HOME'} as tdir should be relative to pb's home
944	$tdir =~ s\|\$ENV.+\}/\|\|;
945
946	my $tm = $vtmout->{$ENV{'PBPROJ'}};
947
948	# ssh communication if not VE
949	# should use a hash instead...
950	my ($shcmd,$cpcmd,$cptarget,$cp2target);
951	if ($cmt ne "ve") {
952	my $keyfile = pb_ssh_get(0);
953	$shcmd = "ssh -i $keyfile -q -p $nport $mac";
954	$cpcmd = "scp -i $keyfile -p -P $nport";
955	$cptarget = "$mac:$tdir";
956	if ($cmt eq "vm") {
957	$cp2target = "$mac:$bdir";
958	}
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 ; rm -f ./pbscript\' \| bash\"","Executing pbscript on $cptarget if needed");
974	if (($cmt eq "vm") \|\| ($cmt eq "ve")) {
975	# Get back info on pkg produced, compute their name and get them from the VM
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'}";
978	my $src = <KEEP>;
979	chomp($src);
980	close(KEEP);
981	$src =~ s/^ *//;
982	pb_mkdir_p("$ENV{'PBBUILDDIR'}/$odir/$over");
983	# Change pgben to make the next send2target happy
984	my $made = "";
985	open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to write $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
986	foreach my $p (split(/ +/,$src)) {
987	my $j = basename($p);
988	pb_system("$cpcmd $cp2target/\'$p\' $ENV{'PBBUILDDIR'}/$odir/$over 2> /dev/null","Package recovery of $j in $cp2target");
989	$made="$made $odir/$over/$j" if (($dtype ne "rpm") \|\| ($j !~ /.src.rpm$/));
990	}
991	print KEEP "$made\n";
992	close(KEEP);
993	pb_system("$shcmd \"rm -rf $tdir $bdir\"","$cmt cleanup");
994
995	# We want to send them to the ssh account so overwrite what has been done before
996	undef $pbaccount;
997	pb_log(2,"Before sending pkgs, vmexist: $vmexist, vmpid: $vmpid\n");
998	pb_send2target("Packages",$odir."-".$over."-".$oarch,$vmexist,$vmpid);
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)");
1001	}
1002	pb_rm_rf("$ENV{'PBBUILDDIR'}/$odir");
1003	}
1004	}
1005
1006	sub pb_script2v {
1007	my $pbscript=shift;
1008	my $vtype=shift;
1009
1010	# Prepare the script to be executed on the VM
1011	# in $ENV{'PBDESTDIR'}/pbscript
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	}
1016
1017	my ($vm,$all) = pb_get_v($vtype);
1018	my ($vmexist,$vmpid) = (undef,undef);
1019
1020	foreach my $v (@$vm) {
1021	# Launch the VM/VE
1022	if ($vtype eq "vm") {
1023	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1024
1025	# Skip that VM if something went wrong
1026	next if (($vmpid == 0) && ($vmexist ==0));
1027	}
1028
1029	# Gather all required files to send them to the VM
1030	# and launch the build through pbscript
1031	pb_send2target("Script","$v",$vmexist,$vmpid);
1032
1033	}
1034	}
1035
1036	sub pb_launchv {
1037	my $vtype = shift;
1038	my $v = shift;
1039	my $create = shift \|\| 0; # By default do not create a VM
1040
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/,.*//;
1044
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/;
1049
1050	# Launch the VMs/VEs
1051	if ($vtype eq "vm") {
1052	die "-i iso parameter needed" if (((not defined $iso) \|\| ($iso eq "")) && ($create != 0));
1053
1054	my ($ptr,$vmopt,$vmpath,$vmport,$vmtmout,$vmsize) = pb_conf_get("vmtype","vmopt","vmpath","vmport","vmtmout","vmsize");
1055
1056	my $vmtype = $ptr->{$ENV{'PBPROJ'}};
1057	if (not defined $ENV{'PBVMOPT'}) {
1058	$ENV{'PBVMOPT'} = "";
1059	}
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") {
1091	} else {
1092	die "VM of type $vmtype not supported. Report to the dev team";
1093	}
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);
1111	pb_log(0,"VM $vmm launched (pid $vmpid)\n");
1112	}
1113	} else {
1114	pb_log(0,"Found an existing VM $vmm (pid $vmexist)\n");
1115	}
1116	return($vmexist,$vmpid);
1117	# VE here
1118	} else {
1119	# Get VE context
1120	my ($ptr,$vetmout,$vepath,$verebuild,$veconf) = pb_conf_get("vetype","vetmout","vepath","verebuild","veconf");
1121	my $vetype = $ptr->{$ENV{'PBPROJ'}};
1122
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);
1127
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	}
1133
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	}
1148	}
1149	# Nothing more to do for VE. No real launch
1150	} else {
1151	die "VE of type $vetype not supported. Report to the dev team";
1152	}
1153	}
1154	}
1155
1156	sub pb_build2v {
1157
1158	my $vtype = shift;
1159
1160	# Prepare the script to be executed on the VM/VE
1161	# in $ENV{'PBDESTDIR'}/pbscript
1162	#my ($ntp) = pb_conf_get($vtype."ntp");
1163	#my $vntp = $ntp->{$ENV{'PBPROJ'}};
1164
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);
1178	#print SCRIPT "echo Setting up date on $vntp...\n";
1179	# Or use ntpdate if available TBC
1180	print SCRIPT "sudo date $upddate\n";
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";
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") {
1203	# Launch the VM
1204	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1205
1206	# Skip that VM if it something went wrong
1207	next if (($vmpid == 0) && ($vmexist == 0));
1208	}
1209	# Gather all required files to send them to the VM/VE
1210	# and launch the build through pbscript
1211	pb_log(2,"Calling send2target $vtype,$v,$vmexist,$vmpid\n");
1212	pb_send2target($vtype,"$v",$vmexist,$vmpid);
1213	}
1214	}
1215
1216
1217	sub pb_newver {
1218
1219	die "-V Version parameter needed" if ((not defined $newver) \|\| ($newver eq ""));
1220
1221	# Need this call for PBDIR
1222	my ($scheme2,$uri) = pb_cms_init($pbinit);
1223
1224	my ($pbconf) = pb_conf_get("pbconfurl");
1225	$uri = $pbconf->{$ENV{'PBPROJ'}};
1226	my ($scheme, $account, $host, $port, $path) = pb_get_uri($uri);
1227
1228	# Checking CMS repositories status
1229	my ($pburl) = pb_conf_get("pburl");
1230	($scheme2, $account, $host, $port, $path) = pb_get_uri($pburl->{$ENV{'PBPROJ'}});
1231
1232	if ($scheme !~ /^svn/) {
1233	die "Only SVN is supported at the moment";
1234	}
1235	my $res = pb_cms_isdiff($scheme,$ENV{'PBROOTDIR'});
1236	die "ERROR: No differences accepted in CMS for $ENV{'PBROOTDIR'} before creating a new version" if ($res != 0);
1237
1238	$res = pb_cms_isdiff($scheme2,$ENV{'PBDIR'});
1239	die "ERROR: No differences accepted in CMS for $ENV{'PBDIR'} before creating a new version" if ($res != 0);
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";
1248	# Should probably use projver in the old file
1249	my $oldver= basename($tmp);
1250
1251	# Checking pbcl files
1252	foreach my $f (<$ENV{'PBROOTDIR'}/*/pbcl>) {
1253	open(PBCL,$f) \|\| die "Unable to open $f";
1254	my $foundnew = 0;
1255	while (<PBCL>) {
1256	$foundnew = 1 if (/^$newver \(/);
1257	}
1258	close(PBCL);
1259	die "ERROR: version $newver not found in $f" if ($foundnew == 0);
1260	}
1261
1262	# Duplicate and extract project-builder part
1263	pb_log(2,"Copying $uri/$tmp to $newurl\n");
1264	pb_cms_copy($scheme,"$uri/$tmp",$newurl);
1265	pb_log(2,"Checkout $newurl to $ENV{'PBROOTDIR'}/../$newver\n");
1266	pb_cms_up($scheme,"$ENV{'PBCONFDIR'}/..");
1267
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");
1274	pb_cms_up($scheme,"$ENV{'PBDIR'}/..");
1275
1276	# Update the .pb file
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";
1279	while(<FILE>) {
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/);
1284	print OUT $_;
1285	}
1286	close(FILE);
1287	close(OUT);
1288	rename("$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new","$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb");
1289
1290	pb_log(2,"Checkin $ENV{'PBROOTDIR'}/../$newver\n");
1291	pb_cms_checkin($scheme,"$ENV{'PBROOTDIR'}/../$newver");
1292	}
1293
1294	#
1295	# Return the list of VMs/VEs we are working on
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	#
1299	sub pb_get_v {
1300
1301	my $vtype = shift;
1302	my @v;
1303	my $all = 0;
1304	my $vlist;
1305	my $pbv = 'PBV';
1306
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'}};
1316	$all = 1;
1317	}
1318	pb_log(2,"$vtype: $ENV{$pbv}\n");
1319	@v = split(/,/,$ENV{$pbv});
1320	return(\@v,$all);
1321	}
1322
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
1326	# the pb account in the VM later on if needed
1327	sub pb_setup_v {
1328
1329	my $vtype = shift;
1330
1331	my ($vm,$all) = pb_get_v($vtype);
1332
1333	# Script generated
1334	my $pbscript = "$ENV{'PBDESTDIR'}/setupv";
1335
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");
1340	my ($key,$zero0,$zero1,$zero2);
1341	my ($vmexist,$vmpid);
1342
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);
1350
1351	# Launch the VM
1352	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1353
1354	# Skip that VM if something went wrong
1355	return if (($vmpid == 0) && ($vmexist == 0));
1356
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
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';
1373	#!/usr/bin/perl -w
1374
1375	use strict;
1376	use File::Copy;
1377
1378	our $debug;
1379	our $LOG;
1380	our $synmsg = "pbscript";
1381	pb_log_init($debug, $LOG);
1382	pb_temp_init();
1383
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	#
1411	my $file="/etc/passwd";
1412	open(PBFILE,$file) \|\| die "Unable to open $file";
1413	my $found = 0;
1414	while (<PBFILE>) {
1415	EOF
1416	print SCRIPT << "EOF";
1417	\$found = 1 if (/^$pbac->{$ENV{'PBPROJ'}}:/);
1418	EOF
1419	print SCRIPT << 'EOF';
1420	}
1421	close(PBFILE);
1422
1423	if ( $found == 0 ) {
1424	if ( ! -d "/home" ) {
1425	pb_mkdir("/home");
1426	}
1427	EOF
1428	print SCRIPT << "EOF";
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	}
1432
1433	# allow ssh entry to build
1434	#
1435	mkdir "/home/$pbac->{$ENV{'PBPROJ'}}/.ssh",0700;
1436	# Allow those accessing root to access the build account
1437	copy("\$ENV{'HOME'}/.ssh/authorized_keys","/home/$pbac->{$ENV{'PBPROJ'}}/.ssh/authorized_keys");
1438	chmod 0600,".ssh/authorized_keys";
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'}}");
1440
1441	EOF
1442	print SCRIPT << 'EOF';
1443	# No passwd for build account only keys
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>) {
1448	EOF
1449	print SCRIPT << "EOF";
1450	s/^$pbac->{$ENV{'PBPROJ'}}:\!\!:/$pbac->{$ENV{'PBPROJ'}}:*:/;
1451	s/^$pbac->{$ENV{'PBPROJ'}}:\!:/$pbac->{$ENV{'PBPROJ'}}:*:/; #SLES 9 e.g.
1452	EOF
1453	print SCRIPT << 'EOF';
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
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
1469	print SCRIPT << "EOF";
1470	next if (/^$pbac->{$ENV{'PBPROJ'}} /);
1471	EOF
1472	print SCRIPT << 'EOF';
1473	s/Defaults[ \t]+requiretty//;
1474	print PBOUT $_;
1475	}
1476	close(PBFILE);
1477	EOF
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";
1481	EOF
1482	print SCRIPT << 'EOF';
1483	close(PBOUT);
1484	rename("$file.new",$file);
1485	chmod 0440,$file;
1486
1487	EOF
1488
1489	my $SCRIPT = \*SCRIPT;
1490
1491	pb_install_deps($SCRIPT);
1492
1493	print SCRIPT << 'EOF';
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
1500	#system "/usr/sbin/ntpdate ntp.pool.org";
1501
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");
1503	system "pb 2>&1 \| head -5";
1504	EOF
1505	if ((! $vmexist) && ($vtype eq "vm")) {
1506	print SCRIPT << 'EOF';
1507	pb_system("sudo /sbin/halt -p","Halting the $vtype");
1508	EOF
1509	}
1510
1511	# Adds pb_distro_init from ProjectBuilder::Distribution
1512	foreach my $d (@INC) {
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>) {
1518	next if (/^package/);
1519	next if (/^use Exporter/);
1520	next if (/^use ProjectBuilder::/);
1521	next if (/^our /);
1522	print SCRIPT $_;
1523	}
1524	close(PBD);
1525	}
1526	}
1527	}
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);
1534	}
1535	return;
1536	}
1537
1538	sub pb_install_deps {
1539
1540	my $SCRIPT = shift;
1541
1542	print {$SCRIPT} << 'EOF';
1543	# We need to have that pb_distro_init function
1544	# Get it from Project-Builder::Distribution
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
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*";
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";
1558
1559	if ( $ddir eq "fedora" ) {
1560	pb_system("yum clean all","Cleaning yum env");
1561	#system "yum update -y";
1562	my $arch=`uname -m`;
1563	my $opt = "";
1564	chomp($arch);
1565	if ($arch eq "x86_64") {
1566	$opt="--exclude=*.i?86";
1567	}
1568
1569	pb_system("yum -y $opt install rpm-build wget patch ntp sudo perl-DateManip perl-File-MimeInfo perl-ExtUtils-MakeMaker",$cmtall);
1570	if ($dver eq 4) {
1571	pb_system("$insmb","$cmtmb");
1572	pb_system("$insfm","$cmtfm");
1573	pb_system("$insfb","$cmtfb");
1574	}
1575	} elsif (( $dfam eq "rh" ) \|\| ($ddir eq "sles") \|\| (($ddir eq "suse") && (($dver eq "10.1") \|\| ($dver eq "10.0"))) \|\| ($ddir eq "slackware")) {
1576	# Suppose pkg are installed already as no online mirror available
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");
1582	} elsif ($ddir eq "suse") {
1583	# New OpenSuSE
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");
1588	} elsif ( $dfam eq "md" ) {
1589	pb_system("urpmi.update -a ; urpmi --auto rpm-build wget sudo patch ntp-client perl-File-MimeInfo","$cmtall");
1590	if (($ddir eq "mandrake") && ($dver eq "10.1")) {
1591	pb_system("$insdm","$cmtdm");
1592	} else {
1593	pb_system("urpmi --auto perl-DateManip","$cmtdm");
1594	}
1595	} elsif ( $dfam eq "du" ) {
1596	if (( $dver eq "3.1" ) && ($ddir eq "debian")) {
1597	#system "apt-get update";
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");
1601	} else {
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");
1603	}
1604	} elsif ( $dfam eq "gen" ) {
1605	#system "emerge -u system";
1606	pb_system("emerge wget sudo ntp DateManip File-MimeInfo","$cmtall");
1607	} else {
1608	print "No pkg to install\n";
1609	}
1610	EOF
1611	}
1612
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";
1625	if (!(-e $keyfile) && ($create eq 1)) {
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
1637	# Returns the pid of a running VM command using a specific VM file
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
1655	sub pb_extract_build_files {
1656
1657	my $src=shift;
1658	my $dir=shift;
1659	my $ddir=shift;
1660	my @files;
1661
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	}
1669	opendir(DIR,"$dir") \|\| die "Unable to open directory $dir";
1670	foreach my $f (readdir(DIR)) {
1671	next if ($f =~ /^\./);
1672	move("$dir/$f","$ddir") \|\| die "Unable to move $dir/$f to $ddir";
1673	pb_log(2,"mv $dir/$f $ddir\n");
1674	push @files,"$ddir/$f";
1675	}
1676	closedir(DIR);
1677	# Not enough but still a first cleanup
1678	pb_rm_rf("$dir");
1679	return(@files);
1680	}
1681
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";
1694	$bfiles->{$f} =~ s~$ENV{'PBROOTDIR'}~~;
1695	if (defined $supfiles->{$pbpkg}) {
1696	$pkgfiles->{$f} = "$dir/$f" if ($f =~ /$supfiles->{$pbpkg}/);
1697	}
1698	}
1699	closedir(BDIR);
1700	}
1701
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: