Context Navigation

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

Last change on this file since 484 was 484, checked in by Bruno Cornec, 16 years ago
Improve Fedora official package build
Property svn:executable set to ``*
File size: 64.1 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'}","verbose");
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	if ($ddir eq "fedora") {
974	# Extract the spec file to please Fedora maintainers :-(
975	print PBS << "EOF";
976	for p in $basesrc; do
977	echo \$p \| grep -q 'src.rpm'
978	if [ \$\? -eq 0 ]; then
979	rpm2cpio \$p \| cpio -ivdum --quiet '*.spec'
980	fi
981	done
982	EOF
983	}
984	} elsif ($dtype eq "deb") {
985	# Also make a pbscript to generate apt bases
986	# Cf: http://www.debian.org/doc/manuals/repository-howto/repository-howto.fr.html
987	my $rpd = dirname("$pbrepo->{$ENV{'PBPROJ'}}/$repodir");
988	print PBS << "EOF";
989	#!/bin/bash
990	# Prepare a script to ease apt setup
991	cat > $ENV{'PBPROJ'}.sources.list << EOT
992	deb $rpd $dver contrib
993	deb-src $rpd $dver contrib
994	EOT
995	chmod 644 $ENV{'PBPROJ'}.sources.list
996
997	# Prepare a script to create apt info file
998	(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)
999	#(cd .. ; rm -f dists/$dver/Release ; apt-ftparchive release dists/$dver > dists/$dver/Release; gpg --sign -ba -o dists/$dver/Release.gpg dists/$dver/Release)
1000	EOF
1001	}
1002	close(PBS);
1003	chmod 0755,"$ENV{'PBBUILDDIR'}/pbscript";
1004
1005	} else {
1006	return;
1007	}
1008
1009	# Useless for VE
1010	my $nport;
1011	if ($cmt ne "ve") {
1012	$nport = $sshport->{$ENV{'PBPROJ'}};
1013	$nport = "$pbport" if (defined $pbport);
1014	}
1015
1016	# Remove a potential $ENV{'HOME'} as tdir should be relative to pb's home
1017	$tdir =~ s\|\$ENV.+\}/\|\|;
1018
1019	my $tm = $vtmout->{$ENV{'PBPROJ'}};
1020
1021	# ssh communication if not VE
1022	# should use a hash instead...
1023	my ($shcmd,$cpcmd,$cptarget,$cp2target);
1024	if ($cmt ne "ve") {
1025	my $keyfile = pb_ssh_get(0);
1026	$shcmd = "ssh -i $keyfile -q -o UserKnownHostsFile=/dev/null -p $nport $mac";
1027	$cpcmd = "scp -i $keyfile -p -o UserKnownHostsFile=/dev/null -P $nport";
1028	$cptarget = "$mac:$tdir";
1029	if ($cmt eq "vm") {
1030	$cp2target = "$mac:$bdir";
1031	}
1032	} else {
1033	my $tp = $vepath->{$ENV{'PBPROJ'}};
1034	$shcmd = "sudo chroot $tp/$v /bin/su - $sshlogin->{$ENV{'PBPROJ'}} -c ";
1035	$cpcmd = "cp -a ";
1036	$cptarget = "$tp/$tdir";
1037	$cp2target = "$tp/$bdir";
1038	}
1039
1040	my $logres = "";
1041	# Do not touch when just announcing
1042	if ($cmt ne "Announce") {
1043	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");
1044	} else {
1045	$logres = "> ";
1046	}
1047	pb_system("cd $ENV{'PBBUILDDIR'} ; $cpcmd $src $cptarget 2> /dev/null","$cmt delivery in $cptarget");
1048
1049	# For VE we need to change the owner manually - To be tested if needed
1050	#if ($cmt eq "ve") {
1051	#pb_system("cd $cptarget ; sudo chown -R $sshlogin->{$ENV{'PBPROJ'}} .","$cmt chown in $cptarget to $sshlogin->{$ENV{'PBPROJ'}}");
1052	#}
1053	pb_system("$shcmd \"echo \'cd $tdir ; if [ -f pbscript ]; then ./pbscript; fi ; rm -f ./pbscript\' \| bash\"","Executing pbscript on $cptarget if needed");
1054	if (($cmt eq "vm") \|\| ($cmt eq "ve")) {
1055	# Get back info on pkg produced, compute their name and get them from the VM
1056	pb_system("$cpcmd $cp2target/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'} $ENV{'PBBUILDDIR'} 2> /dev/null","Get package names in $cp2target");
1057	open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
1058	my $src = <KEEP>;
1059	chomp($src);
1060	close(KEEP);
1061	$src =~ s/^ *//;
1062	pb_mkdir_p("$ENV{'PBBUILDDIR'}/$odir/$over");
1063	# Change pgben to make the next send2target happy
1064	my $made = "";
1065	open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}") \|\| die "Unable to write $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}";
1066	foreach my $p (split(/ +/,$src)) {
1067	my $j = basename($p);
1068	pb_system("$cpcmd $cp2target/\'$p\' $ENV{'PBBUILDDIR'}/$odir/$over 2> /dev/null","Package recovery of $j in $cp2target");
1069	$made="$made $odir/$over/$j" if (($dtype ne "rpm") \|\| ($j !~ /.src.rpm$/));
1070	}
1071	print KEEP "$made\n";
1072	close(KEEP);
1073	pb_system("$shcmd \"rm -rf $tdir $bdir\"","$cmt cleanup");
1074
1075	# We want to send them to the ssh account so overwrite what has been done before
1076	undef $pbaccount;
1077	pb_log(2,"Before sending pkgs, vmexist: $vmexist, vmpid: $vmpid\n");
1078	pb_send2target("Packages",$odir."-".$over."-".$oarch,$vmexist,$vmpid);
1079	pb_rm_rf("$ENV{'PBBUILDDIR'}/$odir");
1080	}
1081	pb_log(2,"Before halt, vmexist: $vmexist, vmpid: $vmpid\n");
1082	if ((! $vmexist) && (($cmt eq "vm") \|\| ($cmt eq "Script"))) {
1083	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)");
1084	}
1085	}
1086
1087	sub pb_script2v {
1088	my $pbscript=shift;
1089	my $vtype=shift;
1090	my $force=shift \|\| 0; # Force stop of VM. Default not
1091	my $vm1=shift \|\| undef; # Only that VM to treat
1092	my $vm;
1093	my $all;
1094
1095	pb_log(2,"DEBUG: pb_script2v($pbscript,$vtype,$force,$vm1)\n");
1096	# Prepare the script to be executed on the VM
1097	# in $ENV{'PBDESTDIR'}/pbscript
1098	if ((defined $pbscript ) && ($pbscript ne "$ENV{'PBDESTDIR'}/pbscript")) {
1099	copy($pbscript,"$ENV{'PBDESTDIR'}/pbscript") \|\| die "Unable to create $ENV{'PBDESTDIR'}/pbscript";
1100	chmod 0755,"$ENV{'PBDESTDIR'}/pbscript";
1101	}
1102
1103	if (not defined $vm1) {
1104	($vm,$all) = pb_get_v($vtype);
1105	} else {
1106	@$vm = ($vm1);
1107	}
1108	my ($vmexist,$vmpid) = (undef,undef);
1109
1110	foreach my $v (@$vm) {
1111	# Launch the VM/VE
1112	if ($vtype eq "vm") {
1113	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1114	pb_log(2,"DEBUG: After pb_launchv, vmexist: $vmexist, vmpid: $vmpid\n");
1115
1116	# Skip that VM if something went wrong
1117	next if (($vmpid == 0) && ($vmexist == 0));
1118
1119	# If force stopping the VM then reset vmexist
1120	if ($force == 1) {
1121	$vmpid = $vmexist;
1122	$vmexist = 0;
1123	}
1124	}
1125
1126	# Gather all required files to send them to the VM
1127	# and launch the build through pbscript
1128	pb_log(2,"DEBUG: Before send2target, vmexist: $vmexist, vmpid: $vmpid\n");
1129	pb_send2target("Script","$v",$vmexist,$vmpid);
1130
1131	}
1132	}
1133
1134	sub pb_launchv {
1135	my $vtype = shift;
1136	my $v = shift;
1137	my $create = shift \|\| 0; # By default do not create a VM
1138
1139	pb_log(2,"DEBUG: pb_launchv($vtype,$v,$create)\n");
1140	die "No VM/VE defined, unable to launch" if (not defined $v);
1141	# Keep only the first VM in case many were given
1142	$v =~ s/,.*//;
1143
1144	# Which is our local arch ? (standardize on i386 for those platforms)
1145	my $arch = `uname -m`;
1146	chomp($arch);
1147	$arch =~ s/i.86/i386/;
1148
1149	# Launch the VMs/VEs
1150	if ($vtype eq "vm") {
1151	die "-i iso parameter needed" if (((not defined $iso) \|\| ($iso eq "")) && ($create != 0));
1152
1153	my ($ptr,$vmopt,$vmpath,$vmport,$vmtmout,$vmsize) = pb_conf_get("vmtype","vmopt","vmpath","vmport","vmtmout","vmsize");
1154
1155	my $vmtype = $ptr->{$ENV{'PBPROJ'}};
1156	if (not defined $ENV{'PBVMOPT'}) {
1157	$ENV{'PBVMOPT'} = "";
1158	}
1159	# Set a default timeout of 2 minutes
1160	if (not defined $ENV{'PBVMTMOUT'}) {
1161	$ENV{'PBVMTMOUT'} = "120";
1162	}
1163	if (defined $vmopt->{$v}) {
1164	$ENV{'PBVMOPT'} .= " $vmopt->{$v}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$v}/);
1165	} elsif (defined $vmopt->{$ENV{'PBPROJ'}}) {
1166	$ENV{'PBVMOPT'} .= " $vmopt->{$ENV{'PBPROJ'}}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$ENV{'PBPROJ'}}/);
1167	}
1168	if (defined $vmtmout->{$v}) {
1169	$ENV{'PBVMTMOUT'} = $vmtmout->{$v};
1170	} elsif (defined $vmtmout->{$ENV{'PBPROJ'}}) {
1171	$ENV{'PBVMTMOUT'} = $vmtmout->{$ENV{'PBPROJ'}};
1172	}
1173	my $nport = $vmport->{$ENV{'PBPROJ'}};
1174	$nport = "$pbport" if (defined $pbport);
1175
1176	my $cmd;
1177	my $vmcmd; # has to be used for pb_check_ps
1178	my $vmm; # has to be used for pb_check_ps
1179	if ($vmtype eq "qemu") {
1180	my $qemucmd32;
1181	my $qemucmd64;
1182	if ($arch eq "x86_64") {
1183	$qemucmd32 = "/usr/bin/qemu-system-i386";
1184	$qemucmd64 = "/usr/bin/qemu";
1185	} else {
1186	$qemucmd32 = "/usr/bin/qemu";
1187	$qemucmd64 = "/usr/bin/qemu-system-x86_64";
1188	}
1189	if ($v =~ /x86_64/) {
1190	$vmcmd = "$qemucmd64 -no-kqemu";
1191	} else {
1192	$vmcmd = "$qemucmd32";
1193	}
1194	$vmm = "$vmpath->{$ENV{'PBPROJ'}}/$v.qemu";
1195	if ($create != 0) {
1196	$ENV{'PBVMOPT'} .= " -cdrom $iso -boot d";
1197	}
1198	$cmd = "$vmcmd $ENV{'PBVMOPT'} -redir tcp:$nport:10.0.2.15:22 $vmm"
1199	} elsif ($vmtype eq "xen") {
1200	} elsif ($vmtype eq "vmware") {
1201	} else {
1202	die "VM of type $vmtype not supported. Report to the dev team";
1203	}
1204	my ($tmpcmd,$void) = split(/ +/,$cmd);
1205	my $vmexist = pb_check_ps($tmpcmd,$vmm);
1206	my $vmpid = 0;
1207	if (! $vmexist) {
1208	if ($create != 0) {
1209	if (($vmtype eq "qemu") \|\| ($vmtype eq "xen")) {
1210	pb_system("/usr/bin/qemu-img create -f qcow2 $vmm $vmsize->{$ENV{'PBPROJ'}}","Creating the QEMU VM");
1211	} elsif ($vmtype eq "vmware") {
1212	} else {
1213	}
1214	}
1215	if (! -f "$vmm") {
1216	pb_log(0,"Unable to find VM $vmm\n");
1217	} else {
1218	pb_system("$cmd &","Launching the VM $vmm");
1219	pb_system("sleep $ENV{'PBVMTMOUT'}","Waiting $ENV{'PBVMTMOUT'} s for VM $v to come up");
1220	$vmpid = pb_check_ps($tmpcmd,$vmm);
1221	pb_log(0,"VM $vmm launched (pid $vmpid)\n");
1222	}
1223	} else {
1224	pb_log(0,"Found an existing VM $vmm (pid $vmexist)\n");
1225	}
1226	pb_log(2,"DEBUG: pb_launchv returns ($vmexist,$vmpid)\n");
1227	return($vmexist,$vmpid);
1228	# VE here
1229	} else {
1230	# Get VE context
1231	my ($ptr,$vetmout,$vepath,$verebuild,$veconf) = pb_conf_get("vetype","vetmout","vepath","verebuild","veconf");
1232	my $vetype = $ptr->{$ENV{'PBPROJ'}};
1233
1234	# Get distro context
1235	my ($name,$ver,$darch) = split(/-/,$v);
1236	chomp($darch);
1237	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init($name,$ver);
1238
1239	if ($vetype eq "chroot") {
1240	# Architecture consistency
1241	if ($arch ne $darch) {
1242	die "Unable to launch a VE of architecture $darch on a $arch platform" if (not (($darch eq "x86_64") && ($arch =~ /i?86/)));
1243	}
1244
1245	if (($create != 0) \|\| ($verebuild->{$ENV{'PBPROJ'}} eq "true") \|\| ($force == 1)) {
1246	# We have to rebuild the chroot
1247	if ($dtype eq "rpm") {
1248	pb_system("sudo /usr/sbin/mock --init --resultdir=\"/tmp\" --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" -r $v","Creating the mock VE");
1249	# Once setup we need to install some packages, the pb account, ...
1250	pb_system("sudo /usr/sbin/mock --install --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" -r $v su","Configuring the mock VE");
1251	#pb_system("sudo /usr/sbin/mock --init --resultdir=\"/tmp\" --configdir=\"$veconf->{$ENV{'PBPROJ'}}\" --basedir=\"$vepath->{$ENV{'PBPROJ'}}\" -r $v","Creating the mock VE");
1252	} elsif ($dtype eq "deb") {
1253	pb_system("","Creating the pbuilder VE");
1254	} elsif ($dtype eq "ebuild") {
1255	die "Please teach the dev team how to build gentoo chroot";
1256	} else {
1257	die "Unknown distribution type $dtype. Report to dev team";
1258	}
1259	}
1260	# Nothing more to do for VE. No real launch
1261	} else {
1262	die "VE of type $vetype not supported. Report to the dev team";
1263	}
1264	}
1265	}
1266
1267	sub pb_build2v {
1268
1269	my $vtype = shift;
1270
1271	# Prepare the script to be executed on the VM/VE
1272	# in $ENV{'PBDESTDIR'}/pbscript
1273	#my ($ntp) = pb_conf_get($vtype."ntp");
1274	#my $vntp = $ntp->{$ENV{'PBPROJ'}};
1275
1276	open(SCRIPT,"> $ENV{'PBDESTDIR'}/pbscript") \|\| die "Unable to create $ENV{'PBDESTDIR'}/pbscript";
1277	print SCRIPT "#!/bin/bash\n";
1278	print SCRIPT "echo ... Execution needed\n";
1279	print SCRIPT "# This is in directory delivery\n";
1280	print SCRIPT "# Setup the variables required for building\n";
1281	print SCRIPT "export PBPROJ=$ENV{'PBPROJ'}\n";
1282	print SCRIPT "# Preparation for pb\n";
1283	print SCRIPT "mv .pbrc \$HOME\n";
1284	print SCRIPT "cd ..\n";
1285	# Force new date to be in the future compared to the date of the tar file by adding 1 minute
1286	my @date=pb_get_date();
1287	$date[1]++;
1288	my $upddate = strftime("%m%d%H%M%Y", @date);
1289	#print SCRIPT "echo Setting up date on $vntp...\n";
1290	# Or use ntpdate if available TBC
1291	print SCRIPT "sudo date $upddate\n";
1292	# Get list of packages to build and get some ENV vars as well
1293	my $ptr = pb_get_pkg();
1294	@pkgs = @$ptr;
1295	my $p = join(' ',@pkgs) if (@pkgs);
1296	print SCRIPT "export PBPROJVER=$ENV{'PBPROJVER'}\n";
1297	print SCRIPT "export PBPROJTAG=$ENV{'PBPROJTAG'}\n";
1298	print SCRIPT "export PBPACKAGER=\"$ENV{'PBPACKAGER'}\"\n";
1299	print SCRIPT "# Build\n";
1300	print SCRIPT "echo Building packages on $vtype...\n";
1301	print SCRIPT "pb -p $ENV{'PBPROJ'} build2pkg $p\n";
1302	close(SCRIPT);
1303	chmod 0755,"$ENV{'PBDESTDIR'}/pbscript";
1304
1305	my ($v,$all) = pb_get_v($vtype);
1306
1307	# Send tar files when we do a global generation
1308	pb_build2ssh() if ($all == 1);
1309
1310	my ($vmexist,$vmpid) = (undef,undef);
1311
1312	foreach my $v (@$v) {
1313	if ($vtype eq "vm") {
1314	# Launch the VM
1315	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1316
1317	# Skip that VM if it something went wrong
1318	next if (($vmpid == 0) && ($vmexist == 0));
1319	}
1320	# Gather all required files to send them to the VM/VE
1321	# and launch the build through pbscript
1322	pb_log(2,"Calling send2target $vtype,$v,$vmexist,$vmpid\n");
1323	pb_send2target($vtype,"$v",$vmexist,$vmpid);
1324	}
1325	}
1326
1327
1328	sub pb_newver {
1329
1330	die "-V Version parameter needed" if ((not defined $newver) \|\| ($newver eq ""));
1331
1332	# Need this call for PBDIR
1333	my ($scheme2,$uri) = pb_cms_init($pbinit);
1334
1335	my ($pbconf) = pb_conf_get("pbconfurl");
1336	$uri = $pbconf->{$ENV{'PBPROJ'}};
1337	my ($scheme, $account, $host, $port, $path) = pb_get_uri($uri);
1338
1339	# Checking CMS repositories status
1340	my ($pburl) = pb_conf_get("pburl");
1341	($scheme2, $account, $host, $port, $path) = pb_get_uri($pburl->{$ENV{'PBPROJ'}});
1342
1343	if ($scheme !~ /^svn/) {
1344	die "Only SVN is supported at the moment";
1345	}
1346
1347	my $res = pb_cms_isdiff($scheme,$ENV{'PBROOTDIR'});
1348	die "ERROR: No differences accepted in CMS for $ENV{'PBROOTDIR'} before creating a new version" if ($res != 0);
1349
1350	$res = pb_cms_isdiff($scheme2,$ENV{'PBDIR'});
1351	die "ERROR: No differences accepted in CMS for $ENV{'PBDIR'} before creating a new version" if ($res != 0);
1352
1353	# Tree identical between PBCONFDIR and PBROOTDIR. The delta is what
1354	# we want to get for the root of the new URL
1355
1356	my $tmp = $ENV{'PBROOTDIR'};
1357	$tmp =~ s\|^$ENV{'PBCONFDIR'}\|\|;
1358
1359	my $newurl = "$uri/".dirname($tmp)."/$newver";
1360	# Should probably use projver in the old file
1361	my $oldver= basename($tmp);
1362
1363	# Duplicate and extract project-builder part
1364	pb_log(2,"Copying $uri/$tmp to $newurl\n");
1365	pb_cms_copy($scheme,"$uri/$tmp",$newurl);
1366	pb_log(2,"Checkout $newurl to $ENV{'PBROOTDIR'}/../$newver\n");
1367	pb_cms_up($scheme,"$ENV{'PBCONFDIR'}/..");
1368
1369	# Duplicate and extract project
1370	my $newurl2 = "$pburl->{$ENV{'PBPROJ'}}/".dirname($tmp)."/$newver";
1371
1372	pb_log(2,"Copying $pburl->{$ENV{'PBPROJ'}}/$tmp to $newurl2\n");
1373	pb_cms_copy($scheme,"$pburl->{$ENV{'PBPROJ'}}/$tmp",$newurl2);
1374	pb_log(2,"Checkout $newurl2 to $ENV{'PBDIR'}/../$newver\n");
1375	pb_cms_up($scheme,"$ENV{'PBDIR'}/..");
1376
1377	# Update the .pb file
1378	open(FILE,"$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb") \|\| die "Unable to open $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb";
1379	open(OUT,"> $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new") \|\| die "Unable to write to $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new";
1380	while(<FILE>) {
1381	s/^projver\s+$ENV{'PBPROJ'}\s=\s$oldver/projver $ENV{'PBPROJ'} = $newver/;
1382	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/);
1383	s/^testver/#testver/;
1384	pb_log(0,"Commenting testver in $ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb\n") if (/^testver/);
1385	print OUT $_;
1386	}
1387	close(FILE);
1388	close(OUT);
1389	rename("$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb.new","$ENV{'PBROOTDIR'}/../$newver/$ENV{'PBPROJ'}.pb");
1390
1391	# Checking pbcl files
1392	foreach my $f (<$ENV{'PBROOTDIR'}/*/pbcl>) {
1393	open(PBCL,$f) \|\| die "Unable to open $f";
1394	my $foundnew = 0;
1395	while (<PBCL>) {
1396	$foundnew = 1 if (/^$newver \(/);
1397	}
1398	close(PBCL);
1399	open(OUT,"> $f.new") \|\| die "Unable to write to $f.new: $!";
1400	open(PBCL,$f) \|\| die "Unable to open $f";
1401	while (<PBCL>) {
1402	print OUT "$_" if (not /^$oldver \(/);
1403	if ((/^$oldver \(/) && ($foundnew == 0)) {
1404	print OUT "$newver ($pbdate)\n";
1405	print OUT "- TBD\n";
1406	print OUT "\n";
1407	pb_log(0,"WARNING: version $newver not found in $f so added...") if ($foundnew == 0);
1408	}
1409	}
1410	close(OUT);
1411	close(PBCL);
1412	rename("$f.new","$f");
1413	}
1414
1415	pb_log(2,"Checkin $ENV{'PBROOTDIR'}/../$newver\n");
1416	pb_cms_checkin($scheme,"$ENV{'PBROOTDIR'}/../$newver",undef);
1417	}
1418
1419	#
1420	# Return the list of VMs/VEs we are working on
1421	# $all is a flag to know if we return all of them
1422	# or only some (if all we publish also tar files in addition to pkgs
1423	#
1424	sub pb_get_v {
1425
1426	my $vtype = shift;
1427	my @v;
1428	my $all = 0;
1429	my $vlist;
1430	my $pbv = 'PBV';
1431
1432	if ($vtype eq "vm") {
1433	$vlist = "vmlist";
1434	} elsif ($vtype eq "ve") {
1435	$vlist = "velist";
1436	}
1437	# Get VM/VE list
1438	if ((not defined $ENV{$pbv}) \|\| ($ENV{$pbv} =~ /^all$/)) {
1439	my ($ptr) = pb_conf_get($vlist);
1440	$ENV{$pbv} = $ptr->{$ENV{'PBPROJ'}};
1441	$all = 1;
1442	}
1443	pb_log(2,"$vtype: $ENV{$pbv}\n");
1444	@v = split(/,/,$ENV{$pbv});
1445	return(\@v,$all);
1446	}
1447
1448	# Function to create a potentialy missing pb account on the VM/VE, and adds it to sudo
1449	# Needs to use root account to connect to the VM/VE
1450	# pb will take your local public SSH key to access
1451	# the pb account in the VM later on if needed
1452	sub pb_setup_v {
1453
1454	my $vtype = shift;
1455
1456	my ($vm,$all) = pb_get_v($vtype);
1457
1458	# Script generated
1459	my $pbscript = "$ENV{'PBDESTDIR'}/setupv";
1460
1461	foreach my $v (@$vm) {
1462	# Name of the account to deal with for VM/VE
1463	# Do not use the one passed potentially with -a
1464	my ($pbac) = pb_conf_get($vtype."login");
1465	my ($key,$zero0,$zero1,$zero2);
1466	my ($vmexist,$vmpid);
1467
1468	if ($vtype eq "vm") {
1469	# Prepare the key to be used and transfered remotely
1470	my $keyfile = pb_ssh_get(1);
1471
1472	my ($vmhost,$vmport) = pb_conf_get("vmhost","vmport");
1473	my $nport = $vmport->{$ENV{'PBPROJ'}};
1474	$nport = "$pbport" if (defined $pbport);
1475
1476	# Launch the VM
1477	($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
1478
1479	# Skip that VM if something went wrong
1480	next if (($vmpid == 0) && ($vmexist == 0));
1481
1482	# Store the pub key part in a variable
1483	open(FILE,"$keyfile.pub") \|\| die "Unable to open $keyfile.pub";
1484	($zero0,$zero1,$zero2) = split(/ /,<FILE>);
1485	close(FILE);
1486
1487	$key = "\Q$zero1";
1488
1489	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");
1490	# once this is done, we can do what we want on the VM remotely
1491	}
1492
1493	# Prepare the script to be executed on the VM/VE
1494	# in $ENV{'PBDESTDIR'}/setupv
1495
1496	open(SCRIPT,"> $pbscript") \|\| die "Unable to create $pbscript";
1497	print SCRIPT << 'EOF';
1498	#!/usr/bin/perl -w
1499
1500	use strict;
1501	use File::Copy;
1502
1503	our $debug;
1504	our $LOG;
1505	our $synmsg = "pbscript";
1506	pb_log_init($debug, $LOG);
1507	pb_temp_init();
1508
1509	EOF
1510	if ($vtype eq "vm") {
1511	print SCRIPT << 'EOF';
1512	# Removes duplicate in .ssh/authorized_keys of our key if needed
1513	#
1514	my $file1="$ENV{'HOME'}/.ssh/authorized_keys";
1515	open(PBFILE,$file1) \|\| die "Unable to open $file1";
1516	open(PBOUT,"> $file1.new") \|\| die "Unable to open $file1.new";
1517	my $count = 0;
1518	while (<PBFILE>) {
1519	EOF
1520	print SCRIPT << "EOF";
1521	if (/ $key /) {
1522	\$count++;
1523	}
1524	print PBOUT \$_ if ((\$count <= 1) \|\| (\$_ !~ / $key /));
1525	}
1526	close(PBFILE);
1527	close(PBOUT);
1528	rename("\$file1.new",\$file1);
1529	chmod 0600,\$file1;
1530	EOF
1531	}
1532	print SCRIPT << 'EOF';
1533
1534	# Adds $pbac->{$ENV{'PBPROJ'}} as an account if needed
1535	#
1536	my $file="/etc/passwd";
1537	open(PBFILE,$file) \|\| die "Unable to open $file";
1538	my $found = 0;
1539	while (<PBFILE>) {
1540	EOF
1541	print SCRIPT << "EOF";
1542	\$found = 1 if (/^$pbac->{$ENV{'PBPROJ'}}:/);
1543	EOF
1544	print SCRIPT << 'EOF';
1545	}
1546	close(PBFILE);
1547
1548	if ( $found == 0 ) {
1549	if ( ! -d "/home" ) {
1550	pb_mkdir("/home");
1551	}
1552	EOF
1553	print SCRIPT << "EOF";
1554	pb_system("groupadd $pbac->{$ENV{'PBPROJ'}}","Adding group $pbac->{$ENV{'PBPROJ'}}");
1555	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'}}");
1556	}
1557
1558	# allow ssh entry to build
1559	#
1560	mkdir "/home/$pbac->{$ENV{'PBPROJ'}}/.ssh",0700;
1561	# Allow those accessing root to access the build account
1562	copy("\$ENV{'HOME'}/.ssh/authorized_keys","/home/$pbac->{$ENV{'PBPROJ'}}/.ssh/authorized_keys");
1563	chmod 0600,".ssh/authorized_keys";
1564	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'}}");
1565
1566	EOF
1567	print SCRIPT << 'EOF';
1568	# No passwd for build account only keys
1569	$file="/etc/shadow";
1570	open(PBFILE,$file) \|\| die "Unable to open $file";
1571	open(PBOUT,"> $file.new") \|\| die "Unable to open $file.new";
1572	while (<PBFILE>) {
1573	EOF
1574	print SCRIPT << "EOF";
1575	s/^$pbac->{$ENV{'PBPROJ'}}:\!\!:/$pbac->{$ENV{'PBPROJ'}}:*:/;
1576	s/^$pbac->{$ENV{'PBPROJ'}}:\!:/$pbac->{$ENV{'PBPROJ'}}:*:/; #SLES 9 e.g.
1577	EOF
1578	print SCRIPT << 'EOF';
1579	print PBOUT $_;
1580	}
1581	close(PBFILE);
1582	close(PBOUT);
1583	rename("$file.new",$file);
1584	chmod 0640,$file;
1585
1586	# Keep the VM in text mode
1587	$file="/etc/inittab";
1588	if (-f $file) {
1589	open(PBFILE,$file) \|\| die "Unable to open $file";
1590	open(PBOUT,"> $file.new") \|\| die "Unable to open $file.new";
1591	while (<PBFILE>) {
1592	s/^(..):5:initdefault:$/$1:3:initdefault:/;
1593	print PBOUT $_;
1594	}
1595	close(PBFILE);
1596	close(PBOUT);
1597	rename("$file.new",$file);
1598	chmod 0640,$file;
1599	}
1600
1601	# pb has to be added to portage group on gentoo
1602
1603	# Adapt sudoers
1604	$file="/etc/sudoers";
1605	open(PBFILE,$file) \|\| die "Unable to open $file";
1606	open(PBOUT,"> $file.new") \|\| die "Unable to open $file.new";
1607	while (<PBFILE>) {
1608	EOF
1609	print SCRIPT << "EOF";
1610	next if (/^$pbac->{$ENV{'PBPROJ'}} /);
1611	EOF
1612	print SCRIPT << 'EOF';
1613	s/Defaults[ \t]+requiretty//;
1614	print PBOUT $_;
1615	}
1616	close(PBFILE);
1617	EOF
1618	print SCRIPT << "EOF";
1619	# This is needed in order to be able to halt the machine from the $pbac->{$ENV{'PBPROJ'}} account at least
1620	print PBOUT "$pbac->{$ENV{'PBPROJ'}} ALL=(ALL) NOPASSWD:ALL\n";
1621	EOF
1622	print SCRIPT << 'EOF';
1623	close(PBOUT);
1624	rename("$file.new",$file);
1625	chmod 0440,$file;
1626
1627	EOF
1628
1629	my $SCRIPT = \*SCRIPT;
1630
1631	pb_install_deps($SCRIPT);
1632
1633	print SCRIPT << 'EOF';
1634	# Suse wants sudoers as 640
1635	if (($ddir eq "sles") \|\| (($ddir eq "suse")) && ($dver ne "10.3")) {
1636	chmod 0640,$file;
1637	}
1638
1639	# Sync date
1640	#system "/usr/sbin/ntpdate ntp.pool.org";
1641
1642	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");
1643	system "pb 2>&1 \| head -5";
1644	EOF
1645	# Adds pb_distro_init from ProjectBuilder::Distribution
1646	foreach my $d (@INC) {
1647	my @f = ("$d/ProjectBuilder/Base.pm","$d/ProjectBuilder/Distribution.pm");
1648	foreach my $f (@f) {
1649	if (-f "$f") {
1650	open(PBD,"$f") \|\| die "Unable to open $f";
1651	while (<PBD>) {
1652	next if (/^package/);
1653	next if (/^use Exporter/);
1654	next if (/^use ProjectBuilder::/);
1655	next if (/^our /);
1656	print SCRIPT $_;
1657	}
1658	close(PBD);
1659	}
1660	}
1661	}
1662	close(SCRIPT);
1663	chmod 0755,"$pbscript";
1664
1665	# That build script needs to be run as root and force stop of VM at end
1666	$pbaccount = "root";
1667
1668	# Force shutdown of VM exept if it was already launched
1669	my $force = 0;
1670	if ((! $vmexist) && ($vtype eq "vm")) {
1671	$force = 1;
1672	}
1673
1674	pb_script2v($pbscript,$vtype,$force,$v);
1675	}
1676	return;
1677	}
1678
1679	sub pb_install_deps {
1680
1681	my $SCRIPT = shift;
1682
1683	print {$SCRIPT} << 'EOF';
1684	# We need to have that pb_distro_init function
1685	# Get it from Project-Builder::Distribution
1686	my ($ddir, $dver, $dfam, $dtype, $pbsuf) = pb_distro_init();
1687	print "distro tuple: ".join(',',($ddir, $dver, $dfam, $dtype, $pbsuf))."\n";
1688
1689	# Get and install pb
1690	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*";
1691	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*";
1692	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*";
1693	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*";
1694	my $cmtdm = "Installing Date-Manip perl module";
1695	my $cmtmb = "Installing Module-Build perl module";
1696	my $cmtfm = "Installing File-MimeInfo perl module";
1697	my $cmtfb = "Installing File-Basedir perl module";
1698	my $cmtall = "Installing required modules";
1699
1700	if ( $ddir eq "fedora" ) {
1701	pb_system("yum clean all","Cleaning yum env");
1702	#system "yum update -y";
1703	my $arch=`uname -m`;
1704	my $opt = "";
1705	chomp($arch);
1706	if ($arch eq "x86_64") {
1707	$opt="--exclude=*.i?86";
1708	}
1709
1710	pb_system("yum -y $opt install rpm-build wget patch ntp sudo perl-DateManip perl-File-MimeInfo perl-ExtUtils-MakeMaker",$cmtall);
1711	if ($dver eq 4) {
1712	pb_system("$insmb","$cmtmb");
1713	pb_system("$insfm","$cmtfm");
1714	pb_system("$insfb","$cmtfb");
1715	}
1716	} elsif (( $dfam eq "rh" ) \|\| ($ddir eq "sles") \|\| (($ddir eq "suse") && (($dver eq "10.1") \|\| ($dver eq "10.0"))) \|\| ($ddir eq "slackware")) {
1717	# Suppose pkg are installed already as no online mirror available
1718	pb_system("rpm -e lsb 2>&1 > /dev/null","Removing lsb package");
1719	pb_system("$insdm","$cmtdm");
1720	pb_system("$insmb","$cmtmb");
1721	pb_system("$insfm","$cmtfm");
1722	pb_system("$insfb","$cmtfb");
1723	} elsif ($ddir eq "suse") {
1724	# New OpenSuSE
1725	pb_system("$insmb","$cmtmb");
1726	pb_system("$insfm","$cmtfm");
1727	pb_system("$insfb","$cmtfb");
1728	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");
1729	} elsif ( $dfam eq "md" ) {
1730	pb_system("urpmi.update -a ; urpmi --auto rpm-build wget sudo patch ntp-client perl-File-MimeInfo","$cmtall");
1731	if (($ddir eq "mandrake") && ($dver eq "10.1")) {
1732	pb_system("$insdm","$cmtdm");
1733	} else {
1734	pb_system("urpmi --auto perl-DateManip","$cmtdm");
1735	}
1736	} elsif ( $dfam eq "du" ) {
1737	if (( $dver eq "3.1" ) && ($ddir eq "debian")) {
1738	#system "apt-get update";
1739	pb_system("$insfb","$cmtfb");
1740	pb_system("$insfm","$cmtfm");
1741	pb_system("apt-get -y install wget patch ssh sudo debian-builder dh-make fakeroot ntpdate libmodule-build-perl libdate-manip-perl","$cmtall");
1742	} else {
1743	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");
1744	}
1745	} elsif ( $dfam eq "gen" ) {
1746	#system "emerge -u system";
1747	pb_system("emerge wget sudo ntp DateManip File-MimeInfo","$cmtall");
1748	} else {
1749	print "No pkg to install\n";
1750	}
1751	EOF
1752	}
1753
1754	sub pb_announce {
1755
1756	# Get all required parameters
1757	my ($pbpackager,$pbrepo,$pbml,$pbsmtp) = pb_conf_get("pbpackager","pbrepo","pbml","pbsmtp");
1758	my ($pkgv, $pkgt, $testver) = pb_conf_get_if("pkgver","pkgtag","testver");
1759	my $pkg = pb_cms_get_pkg($defpkgdir,$extpkgdir);
1760	my @pkgs = @$pkg;
1761	my %pkgs;
1762	my $first = 0;
1763
1764	# Command to find packages on repo
1765	my $findstr = "find . ";
1766	# Generated announce files
1767	my @files;
1768
1769	foreach my $pbpkg (@pkgs) {
1770	if ($first != 0) {
1771	$findstr .= "-o ";
1772	}
1773	$first++;
1774	if ((defined $pkgv) && (defined $pkgv->{$pbpkg})) {
1775	$pbver = $pkgv->{$pbpkg};
1776	} else {
1777	$pbver = $ENV{'PBPROJVER'};
1778	}
1779	if ((defined $pkgt) && (defined $pkgt->{$pbpkg})) {
1780	$pbtag = $pkgt->{$pbpkg};
1781	} else {
1782	$pbtag = $ENV{'PBPROJTAG'};
1783	}
1784
1785	$findstr .= "-name \'$pbpkg-$pbver-$pbtag\..rpm\' -o -name \'$pbpkg"."_$pbver\.deb\' -o -name \'$pbpkg-$pbver\.ebuild\' ";
1786
1787	my $chglog;
1788
1789	# Get project info on log file and generate tmp files used later on
1790	pb_cms_init($pbinit);
1791	$chglog = "$ENV{'PBROOTDIR'}/$pbpkg/pbcl";
1792	$chglog = "$ENV{'PBROOTDIR'}/pbcl" if (! -f $chglog);
1793	$chglog = undef if (! -f $chglog);
1794
1795	open(OUT,"> $ENV{'PBTMP'}/$pbpkg.ann") \|\| die "Unable to create $ENV{'PBTMP'}/$pbpkg.ann: $!";
1796	pb_changelog("announce",$pbpkg,$pbver,"N/A","N/A","N/A",\*OUT,"yes",$chglog);
1797	close(OUT);
1798	push(@files,"$ENV{'PBTMP'}/$pbpkg.ann");
1799	}
1800	$findstr .= " \| grep -Ev \'src.rpm\'";
1801	if ((not defined $testver) \|\| (not defined $testver->{$ENV{'PBPROJ'}}) \|\| ($testver->{$ENV{'PBPROJ'}} !~ /true/i)) {
1802	$findstr .= " \| grep -v ./test/";
1803	}
1804
1805	# Prepare the command to run and execute it
1806	open(PBS,"> $ENV{'PBTMP'}/pbscript") \|\| die "Unable to create $ENV{'PBTMP'}/pbscript";
1807	print PBS "$findstr\n";
1808	close(PBS);
1809	chmod 0755,"$ENV{'PBTMP'}/pbscript";
1810	pb_send2target("Announce");
1811
1812	# Prepare a template of announce
1813	open(ANN,"> $ENV{'PBTMP'}/announce.html") \|\| die "Unable to create $ENV{'PBTMP'}/announce.html: $!";
1814	print ANN << "EOF";
1815	Project $ENV{'PBPROJ'} version $ENV{'PBPROJVER'} is now available</p>
1816
1817	<p>The project team is happy to announce the availability of a newest version of $ENV{'PBPROJ'} $ENV{'PBPROJVER'}. Enjoy it as usual!</p>
1818	<p>
1819	Now available at <a href="$pbrepo->{$ENV{'PBPROJ'}}">$pbrepo->{$ENV{'PBPROJ'}}</a>
1820	</p>
1821	<p>
1822	EOF
1823	open(LOG,"$ENV{'PBTMP'}/system.log") \|\| die "Unable to read $ENV{'PBTMP'}/system.log: $!";
1824	my $col = 2;
1825	my $i = 1;
1826	print ANN << 'EOF';
1827	<TABLE WIDTH="700" CELLPADDING="0" CELLSPACING="0" BORDER="0">
1828	<TR>
1829	EOF
1830	while (<LOG>) {
1831	print ANN "<TD>$_</TD>";
1832	$i++;
1833	if ($i > $col) {
1834	print ANN "</TR>\n<TR>";
1835	$i = 1;
1836	}
1837	}
1838	close(LOG);
1839	print ANN << "EOF";
1840	</TR>
1841	</TABLE>
1842	</p>
1843
1844	<p>As usual source packages are also available in the same directory.</p>
1845
1846	<p>
1847	Changes are :
1848	</p>
1849	<p>
1850	EOF
1851	# Get each package changelog content
1852	foreach my $f (sort(@files)) {
1853	open(IN,"$f") \|\| die "Unable to read $f:$!";
1854	while (<IN>) {
1855	print ANN $_;
1856	}
1857	close(IN);
1858	print ANN "</p><p>\n";
1859	}
1860	print ANN "</p>\n";
1861	close(ANN);
1862
1863	# Allow for modification
1864	pb_system("vi $ENV{'PBTMP'}/announce.html","Allowing modification of the announce","noredir");
1865
1866	# Store it in DB for external usage (Web pages generation)
1867	my $db = "$ENV{'PBCONFDIR'}/announces3.sql";
1868
1869	my $precmd = "";
1870	if (! -f $db) {
1871	$precmd = "CREATE TABLE announces (id INTEGER PRIMARY KEY AUTOINCREMENT, date DATE, announce VARCHAR[65535])";
1872	}
1873
1874	my $dbh = DBI->connect("dbi:SQLite:dbname=$db","","",
1875	{ RaiseError => 1, AutoCommit => 1 })
1876	\|\| die "Unable to connect to $db";
1877
1878	if ($precmd ne "") {
1879	my $sth = $dbh->prepare(qq{$precmd})
1880	\|\| die "Unable to create table into $db";
1881	$sth->execute();
1882	}
1883
1884	# To read whole file
1885	local $/;
1886	open(ANN,"$ENV{'PBTMP'}/announce.html") \|\| die "Unable to read $ENV{'PBTMP'}/announce.html: $!";
1887	my $announce = <ANN>;
1888	close(ANN);
1889
1890	pb_log(2,"INSERT INTO announces VALUES (NULL, $pbdate, $announce)");
1891	my $sth = $dbh->prepare(qq{INSERT INTO announces VALUES (NULL,?,?)})
1892	\|\| die "Unable to insert into $db";
1893	$sth->execute($pbdate, $announce);
1894	$dbh->disconnect;
1895
1896	# Then deliver it on the Web
1897	# $TOOLHOME/livwww www
1898
1899	# Mail it to project's ML
1900	open(ML,"\| w3m -dump -T text/html > $ENV{'PBTMP'}/announce.txt") \|\| die "Unable to create $ENV{'PBTMP'}/announce.txt: $!";
1901	print ML << 'EOF';
1902	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/x html1/DTD/xhtml1-strict.dtd">
1903
1904	<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" xml:lang="en" lang="en">
1905	<head>
1906	</head>
1907	<body>
1908	<p>
1909	EOF
1910	open(ANN,"$ENV{'PBTMP'}/announce.html") \|\| die "Unable to read $ENV{'PBTMP'}/announce.html: $!";
1911	while(<ANN>) {
1912	print ML $_;
1913	}
1914	print ML << 'EOF';
1915	</body>
1916	</html>
1917	EOF
1918	close(ML);
1919
1920	# To read whole file
1921	local $/;
1922	open(ANN,"$ENV{'PBTMP'}/announce.txt") \|\| die "Unable to read $ENV{'PBTMP'}/announce.txt: $!";
1923	my $msg = <ANN>;
1924	close(ANN);
1925
1926	# Preparation of headers
1927
1928	my %mail = (
1929	To => $pbml->{$ENV{'PBPROJ'}},
1930	From => $pbpackager->{$ENV{'PBPROJ'}},
1931	Smtp => $pbsmtp->{$ENV{'PBPROJ'}},
1932	Body => $msg,
1933	Subject => "ANNOUNCE: Project $ENV{'PBPROJ'} version $ENV{'PBPROJVER'} is now available",
1934	);
1935
1936	# Send mail
1937	sendmail(%mail) or die "Unable to send mail ($Mail::Sendmail::error): $Mail::Sendmail::log";
1938	}
1939
1940	# Return the SSH key file to use
1941	# Potentially create it if needed
1942
1943	sub pb_ssh_get {
1944
1945	my $create = shift \|\| 0; # Do not create keys by default
1946
1947	# Check the SSH environment
1948	my $keyfile = undef;
1949
1950	# We have specific keys by default
1951	$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa";
1952	if (!(-e $keyfile) && ($create eq 1)) {
1953	pb_system("ssh-keygen -q -b 1024 -N '' -f $keyfile -t dsa","Generating SSH keys for pb");
1954	}
1955
1956	$keyfile = "$ENV{'HOME'}/.ssh/id_rsa" if (-s "$ENV{'HOME'}/.ssh/id_rsa");
1957	$keyfile = "$ENV{'HOME'}/.ssh/id_dsa" if (-s "$ENV{'HOME'}/.ssh/id_dsa");
1958	$keyfile = "$ENV{'HOME'}/.ssh/pb_dsa" if (-s "$ENV{'HOME'}/.ssh/pb_dsa");
1959	die "Unable to find your public ssh key under $keyfile" if (not defined $keyfile);
1960	return($keyfile);
1961	}
1962
1963
1964	# Returns the pid of a running VM command using a specific VM file
1965	sub pb_check_ps {
1966	my $vmcmd = shift;
1967	my $vmm = shift;
1968	my $vmexist = 0; # FALSE by default
1969
1970	open(PS, "ps auxhww\|") \|\| die "Unable to call ps";
1971	while (<PS>) {
1972	next if (! /$vmcmd/);
1973	next if (! /$vmm/);
1974	my ($void1, $void2);
1975	($void1, $vmexist, $void2) = split(/ +/);
1976	last;
1977	}
1978	return($vmexist);
1979	}
1980
1981
1982	sub pb_extract_build_files {
1983
1984	my $src=shift;
1985	my $dir=shift;
1986	my $ddir=shift;
1987	my @files;
1988
1989	if ($src =~ /tar\.gz$/) {
1990	pb_system("tar xfpz $src $dir","Extracting build files");
1991	} elsif ($src =~ /tar\.bz2$/) {
1992	pb_system("tar xfpj $src $dir","Extracting build files");
1993	} else {
1994	die "Unknown compression algorithm for $src";
1995	}
1996	opendir(DIR,"$dir") \|\| die "Unable to open directory $dir";
1997	foreach my $f (readdir(DIR)) {
1998	next if ($f =~ /^\./);
1999	move("$dir/$f","$ddir") \|\| die "Unable to move $dir/$f to $ddir";
2000	pb_log(2,"mv $dir/$f $ddir\n");
2001	push @files,"$ddir/$f";
2002	}
2003	closedir(DIR);
2004	# Not enough but still a first cleanup
2005	pb_rm_rf("$dir");
2006	return(@files);
2007	}
2008
2009	sub pb_list_bfiles {
2010
2011	my $dir = shift;
2012	my $pbpkg = shift;
2013	my $bfiles = shift;
2014	my $pkgfiles = shift;
2015	my $supfiles = shift;
2016
2017	opendir(BDIR,"$dir") \|\| die "Unable to open dir $dir: $!";
2018	foreach my $f (readdir(BDIR)) {
2019	next if ($f =~ /^\./);
2020	$bfiles->{$f} = "$dir/$f";
2021	$bfiles->{$f} =~ s~$ENV{'PBROOTDIR'}~~;
2022	if (defined $supfiles->{$pbpkg}) {
2023	$pkgfiles->{$f} = "$dir/$f" if ($f =~ /$supfiles->{$pbpkg}/);
2024	}
2025	}
2026	closedir(BDIR);
2027	}
2028
2029
2030	#
2031	# Return the list of packages we are working on in a non CMS action
2032	#
2033	sub pb_get_pkg {
2034
2035	my @pkgs = ();
2036
2037	my ($var) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
2038	@pkgs = keys %$var;
2039
2040	pb_log(0,"Packages: ".join(',',@pkgs)."\n");
2041	return(\@pkgs);
2042	}
2043
2044	1;

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

Download in other formats: