source: soft/build_system/build_system/mkcd/tags/v2-9-3/pm/Mkcd/Group.pm @ 1

Last change on this file since 1 was 1, checked in by fasma, 13 years ago

Initial Import from Mandriva's soft revision 224062 and package revision 45733

File size: 21.3 KB
Line 
1package Mkcd::Group;
2
3my $VERSION = '1.0.1';
4
5use strict;
6use File::NCopy qw(copy);       
7use File::Path;
8use Mkcd::Disc;
9use Mkcd::List;
10use Mkcd::Tools qw(cleanrpmsrate printTable printDiscsFile readBatchFile printBatchFile);
11use Mkcd::Package qw(genDeps getRPMsKeys getSize);
12
13=head1 NAME
14
15Group - mkcd module
16
17=head1 SYNOPSYS
18
19    require Mkcd::Group;
20
21=head1 DESCRIPTION
22
23C<Mkcd::Group> include the mkcd high level disc building routines.
24
25=head1 SEE ALSO
26
27mkcd
28
29=head1 COPYRIGHT
30
31Copyright (C) 2000,2001 MandrakeSoft <warly@mandrakesoft.com>
32
33This program is free software; you can redistribute it and/or modify
34it under the terms of the GNU General Public License as published by
35the Free Software Foundation; either version 2, or (at your option)
36any later version.
37
38This program is distributed in the hope that it will be useful,
39but WITHOUT ANY WARRANTY; without even the implied warranty of
40MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
41GNU General Public License for more details.
42
43You should have received a copy of the GNU General Public License
44along with this program; if not, write to the Free Software
45Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
46
47=cut
48
49my $config;
50
51sub new {
52    my ($class, $conf) = @_;
53    $config = $conf;
54    bless {
55            config      => $conf,
56            list        => new Mkcd::List($conf),
57            disc        => new Mkcd::Disc($conf)
58       }, $class;
59}
60
61#
62# group structure
63#
64# $group[group number]{list}{rpm/srpm} = { list => [[cd, repname, {options}],[], ...,[]] }
65#
66## 2002 03 14 deprecated
67## $group[group number]{sourcerep} = { list => [[ srpm cd, srpm repname], [srpm cd 2, srpm repname 2], ..., [srpm cd n, srpm repname n]] }
68#
69# $group[group number]{params} = rpmtools::params
70#
71# $group[group number]{rpmsratepath} = rpmsrate path
72#
73# $group[group number]{rpmsrate} = { rpmsrate }
74#
75# $group[group number]{size} = { rpm_name => [filesize, list number, directory], ... }
76#
77# $group[group number]{listsize}{rpm} = { list => total rpm size, ... }
78#
79# $group[group number]{score} = [ score weight ]
80#
81# $group[group number]{scoredlist} = { rpm_name => score }
82#
83# $group[group number]{maxsize} = rpm maxsize
84#
85# $group[group number]{depsrep} = deps repository name
86#
87# $group[group number]{depslistid} = [ depslist id ]
88#
89# $group[group number]{pkgdeps} = { package_name => [depslist dependencies ] }
90#
91# $group[group number]{revdeps} = [ reversed depslist ]
92#
93# $group[group number]{lang} = { locale1 => 1, locale2 => 1}
94#
95# $group[group number]{filelist} = [FILELIST]
96#
97# $group[group number]{listrpm} = { list => [ rpm ] }
98#
99# $group[group number]{brokendeps} = { rpm_depending_on_non_listed_locales => 1 , rpm_which_deps_are_broken => 2 }
100#
101# $group[group number]{installDisc} = install disc for this group
102#
103# $group[group number]{discdeps} = { cd => { cds it depends on ] }
104#
105# $group[group number]{missingdeps} = { rpm => [ missing dependencies ] }
106#
107# $group[group number]{pkgrate} = { rpm => rpmsrate_increase }
108#
109# $group[group number]{done} = { rpm => rep number }
110#
111# $group[group number]{globrpm} = [ "path1/rpm1" ... "pathn/rpmq" ]
112#
113# $group[group number]{srpmname} = srpm-version-release
114#
115# $group[group number]{orderedrep}{rpm/srpm} = { "rep_name" => num }
116#
117# $group[group number]{maxrep} = max ordered rep_name number
118#
119# $group[group number]{listmaxrep}{rpm/srpm}{list} = max ordered rep_name number for list list
120#
121# $group[group number]{nodeps} = { list => 1}
122#
123# 0  {list}
124# 1  {sourcerep}
125# 2  {params}
126# 3  {rpmsratepath}
127# 4  {rpmsrate}
128# 5  {size}
129# 6  {score}
130# 7  {scoredlist}
131# 8  {maxsize}
132# 9  {depsrep}
133# 10
134# 11 {depslistid}
135# 12 {pkgdeps}
136# 13 {revdeps}
137# 14 {lang}
138# 15 {filelist}
139# 16 {listrpm}
140# 17 {brokendeps}
141# 18 {installDisc}
142# 19 {discdeps}
143# 20 {missingdeps}
144#
145#
146#  FIXME
147#
148# Weigh should be put in the first loop with list so that generic
149# groups without installation can get scoring. At present the implementation
150# prevent from using the -o option with generic and as a consequence
151# generic groups will be sorted with (1,1,0) (no install means no rpmsrate)
152#
153
154sub getGroups {
155    my ($config,$lists) = @_;
156    my @list;
157    my %cd;
158    my %done;
159    my %list;
160    my %repname;
161    print {$config->{LOG}} "getGroups\n";
162    foreach my $i (keys %{$lists}){
163        $config->{verbose} and print {$config->{LOG}} "getGroups: disc $i\n";
164        $cd{$i} = 1;
165        ref $config->{disc}[$i]{fastgeneric} or next;
166        my @l = @{$config->{disc}[$i]{fastgeneric}};
167        foreach (@l){
168            $config->{verbose} and print {$config->{LOG}} "getGroups: list $_->[1]{list} repname $_->[1]{repname} options (", keys %{$_->[1]} ,")\n";
169            my $idx;
170            # 2002 03 19 source/binary are handled later
171            #if ($_->[1]{source}) {
172            ## 2002 03 14 deprecated
173            ## $_->[1]{score} = $_->[1]{priority} ? $_->[1]{priority} + $config->{discMax} : $config->{disc}[$i]{name};
174            #   push @{$list[$_->[1]{list}][1]}, [$i, $_->[1]{repname}, $_->[1], {}]
175            #} else {
176            #   $idx = push @{$list[$_->[1]{list}]}, [$i, $_->[1]{repname}, $_->[1], {}];
177            #}
178            $idx = push @{$list[$_->[1]{list}]}, [$i, $_->[1]{repname}, $_->[1], {}];
179            push @{$repname{$i}{$_->[1]{repname}}}, [ $_->[1]{list}, $idx - 1 ];
180            $config->{verbose} and print {$config->{LOG}} "getGroups: cd $i repname $_->[1]{repname} list $_->[1]{list}\n";
181            $list{$_->[1]{list}} = 1
182        }
183    }
184    my @group;
185    my $g;
186    my %donerep;
187    foreach my $i (keys %{$lists}){
188        my $t = $config->{disc}[$i]{function}{data}{installation};
189        $config->{verbose} and print {$config->{LOG}} "getGroups: disc $i ($t)\n";
190        ref $t and do {
191            print {$config->{LOG}} "getGroups: install disc for group $g => ($i)\n";
192            $group[$g]{installDisc} = $i;
193            $group[$g]{options} = $t->[1];
194            $group[$g]{score} ||= $t->[1]{score} || [1,1,1];
195            ($group[$g]{maxrep}{rpm},$group[$g]{maxlist}{rpm}) = addRepList("rpm",$group[$g],$g,$t->[1]{rpmsdir},$donerep{$g},\%done,\%list,\%cd,\%repname,$i,\@list);
196            ($group[$g]{maxrep}{srpm},$group[$g]{maxlist}{srpm}) = addRepList("srpm",$group[$g],$g,$t->[1]{srpmsdir},$donerep{$g},\%done,\%list,\%cd,\%repname,$i,\@list);
197            $group[$g]{rpmsratepath} ||= $t->[1]{rpmsrate} || "$t->[1]{install}/Mandrake/base/rpmsrate";
198            print {$config->{LOG}} "getGroups: using $group[$g]{rpmsratepath} as rpmsrate file\n";
199            $group[$g]{list} and $group[$g]{depsrep} = join '-', keys %{$group[$g]{list}};
200            print {$config->{LOG}} "getGroups: $group[$g]{depsrep} defined as deps file directory\n";
201            if (ref $t->[1]{lang}) {
202                foreach (@{$t->[1]{lang}}) {$group[$g]{lang}{$_} = 1 }
203            }
204
205            $group[$g]{discdeps}{$i} ||= {};
206            print {$config->{LOG}} "getGroups DEBUG: discdep for group $g => ($group[$g]{discdep})\n";
207            $g++;
208        }
209    }
210    foreach (keys %list){
211        $config->{verbose} and print {$config->{LOG}} "getGroups: searching alone groups list $_\n";
212        if ($list{$_} == 1){ 
213            print {$config->{LOG}} "WARNING getGroups: list $_ does not belong to any installation disc, setting alone groups\n";
214            $group[$g]{score} = [1,1,1];
215            $group[$g]{depsrep} = $_;
216            getAlone($list[$_],$group[$g],$g,\%done);
217            $list{$_}++;
218            $g++
219        }
220    }
221
222    foreach my $i (keys %{$lists}){
223        $done{$i} and next;
224        $config->{verbose} and print {$config->{LOG}} "getGroups: searching alone disc disc $i does not handled by any group, setting alone group\n";
225        $group[$g]{discdeps}{$i} ||= {};
226        $g++
227    }
228   
229    for (my $i; $i < @group; $i++){
230        $group[$i]{orderedlist}{rpm} ||= [];
231        foreach (@{$group[$i]{orderedlist}{rpm}}){
232            $group[$i]{list}{$_}{srpm} ||= []
233        }
234        $group[$i]{orderedlist}{srpm} ||= [];
235        print {$config->{LOG}} "getGroups: ordered rpm list for group $i: @{$group[$i]{orderedlist}{rpm}}\n";   
236        print {$config->{LOG}} "getGroups: ordered srpm list for group $i: @{$group[$i]{orderedlist}{srpm}}\n"; 
237    }
238
239    $config->{verbose} and printTable(\@group);
240    \@group
241}
242
243sub getAlone{
244    my ($list,$group,$g,$done) = @_;
245    my $num = 1;
246    $list or return;
247    my $lnsort = 1;
248    foreach my $l (@{$list}){
249        my ($cd,$rep,$opt) = @$l;
250        my $type = $opt->{source} ? "srpm" : "rpm";
251        my $ls = $opt->{list};
252        $config->{verbose} and print {$config->{LOG}} "getGroups: searching alone groups list $ls cd $cd rep $rep type $type\n";
253        $group->{list}{$ls}{$type} or push @{$group->{orderedlist}{$type}}, $ls;       
254        $group->{listmatrix}{$type}{$ls}{$ls} = 1;
255        push @{$config->{list}[$ls]{disc}{$cd}{$rep}{master}}, $g;
256        push @{$group->{list}{$ls}{$type}}, $l;
257        $group->{orderedrep}{$type}{"$cd/$rep"} = $num++;
258        if (!$group->{listsort}{$ls}{$type}) { $group->{listsort}{$ls}{$type} = $lnsort++ };
259        $done->{$cd}{$rep}{$ls}++;
260        print {$config->{LOG}} "getGroups: searching alone groups group $g handle disc $l->[0]\n";
261        $group->{discdeps}{$l->[0]} ||= {};
262    }
263}
264
265sub addRepList{
266    my ($type,$group,$g,$replist,$donerep,$done,$list,$disc,$repname,$i,$listTable) = @_;
267    my $num = 1;
268    my $lnsort = 1;
269    foreach (@$replist){
270        my ($cdlist,$cd,$name) = ($_->[0],$_->[1],$_->[2]);
271        my $opt = $_->[3] || {};
272        $config->{verbose} and print {$config->{LOG}} "getGroups: group $g cd $cd repname $name list $cdlist\n";
273        $donerep->{$type}{$cd}{$name}{$cdlist} and print {$config->{LOG}} "ERROR getGroups: $cd/$name/$cdlist is defined multiple time for group $g, ignoring\n" and next;
274        $donerep->{$type}{$cd}{$name}{$cdlist} = 1;
275        $disc->{$cd} or print {$config->{LOG}} "ERROR getGroups: disc $cd not in list, ignoring\n" and next;
276        my $ln = $repname->{$cd}{$name};
277        $ln or print {$config->{LOG}} "ERROR getGroups: $name on disc $cd does not exist\n" and next;
278        $group->{orderedrep}{$type}{"$cd/$name"} = $num++;
279        $cd != $i and $group->{discdeps}{$i}{$cd}++;
280        $cd != $i and print {$config->{LOG}} "getGroups: group $g handle disc $i\n";
281        foreach my $l (@$ln){
282            my ($ls,$idx) = @$l;
283            next if $cdlist && $cdlist != $ls;
284            if ($group->{listmaxrep}{$type}{$ls} < $group->{orderedrep}{$type}{"$cd/$name"}) { $group->{listmaxrep}{$type}{$ls} = $group->{orderedrep}{$type}{"$cd/$name"} }
285            $group->{list}{$ls}{$type} or push @{$group->{orderedlist}{$type}}, $ls;   
286            foreach my $lst (@{$group->{orderedlist}{$type}}) { $group->{listmatrix}{$type}{$ls}{$lst} = 1 }
287            if (!$group->{listsort}{$ls}{$type}) { $group->{listsort}{$ls}{$type} = $lnsort++ };
288            push @{$group->{list}{$ls}{$type}}, [$cd, $name, $listTable->[$ls][$idx][2], $opt];
289            if ($opt->{fixed}){
290                push @{$config->{list}[$ls]{disc}{$cd}{$name}{master}}, $g             
291            }else{
292                # this group is the master for this rep
293                unshift @{$config->{list}[$ls]{disc}{$cd}{$name}{master}}, $g
294            }
295            $list->{$ls}++;
296            $done->{$cd}{$name}{$ls}++;
297        }       
298    }
299    return ($num,$lnsort)
300}
301
302sub preCheck{
303    # TODO
304    # may not be necessary
305}
306
307sub orderGroups{
308    my ($config,$groups,$lists,$acds) = @_;
309    my @metagroups;
310    my @groupmeta;
311    my $ok;
312    # FIXME This algo can create empty metagroups
313    while (!$ok){
314        print {$config->{LOG}} "orderGroups: ordering metagroups\n";
315        $ok = 1;
316        for (my $i; $i < @$groups; $i++){
317            if ($groups->[$i]{installDisc}){
318                $lists->{$groups->[$i]{installDisc}} == 2 or next
319            }
320            print {$config->{LOG}} "Group $i (install disc $groups->[$i]{installDisc})\n";
321            foreach my $list (keys %{$groups->[$i]{list}}){
322                foreach my $type (keys %{$groups->[$i]{list}{$list}}){
323                    foreach my $rep (@{$groups->[$i]{list}{$list}{$type}}){
324                        my ($cd,$r) = ($rep->[0],$rep->[1]);
325                        $lists->{$cd} == 2 or next;
326                        my $og = $config->{list}[$list]{disc}{$cd}{$r}{master}[0];
327                        print {$config->{LOG}} "Master of disc $cd/$r = ($og)\n";
328                        if ($og != $i && $groupmeta[$i] == $groupmeta[$og]){ $ok = 0;$groupmeta[$i] = $groupmeta[$og] + 1 }
329                    }
330                }
331            }
332        }
333    }
334    for (my $i; $i < @$groups; $i++){
335        if ($groups->[$i]{installDisc}){
336            $lists->{$groups->[$i]{installDisc}} == 2 or next
337        }
338        print {$config->{LOG}} "orderGroups: group $i metagroup $groupmeta[$i]\n";
339        push @{$metagroups[$groupmeta[$i]][0]}, $groups->[$i];
340    }
341    my %donedisc;
342    foreach (@metagroups){
343        my %cd;
344        my %cdg;
345        my $i = 1;
346        foreach (@$acds) { $cd{$_} = $i++ }
347        my $grps = $_->[0];
348        my $loop;
349        my $ok = 0;
350        $_->[1] = [];
351        while (!$ok && !$loop){
352            $ok = 1;
353            foreach my $g (@{$grps}){
354                print {$config->{LOG}} "orderGroups: discs ", keys %{$g->{discdeps}},"\n";
355                foreach my $cd (keys %{$g->{discdeps}}){
356                    $donedisc{$cd} and next;
357                    print {$config->{LOG}} "orderGroups: disc $cd\n";
358                    $lists->{$cd} >= 1 or next;
359                    $cdg{$cd} = {};
360                    if (ref $g->{discdeps}{$cd}){
361                        foreach (keys %{$g->{discdeps}{$cd}}){
362                            $donedisc{$_} and next;
363                            print {$config->{LOG}} "orderGroups: disc $cd => $_\n";
364                            $cdg{$cd}{$_} and print {$config->{LOG}} "ERROR: orderGroups: loop in discs dependencies, taking manual order\n" and $loop = 1;
365                            $cdg{$cd}{$_} = 1;
366                            $cdg{$_} = {};
367                            if ($cd{$cd} <= $cd{$_}){ 
368                                $cd{$cd} = $cd{$_} + 1;
369                                $ok = 0
370                            }
371                        }
372                    }
373                }
374            }
375        }
376        if ($loop){
377            foreach my $c (@$acds) { $cdg{$c} and $lists->{$c} == 2 and push @{$_->[1]}, $c and $donedisc{$c} = 1} 
378        }else{
379            my @scds = sort { $cd{$a} <=> $cd{$b} }  keys %cdg;
380            foreach my $c (@scds) { $lists->{$c} == 2 and push @{$_->[1]}, $c and $donedisc{$c} = 1}   
381        }
382        print {$config->{LOG}} "orderGroup: disc sorting @{$_->[1]}\n"
383    }
384    # add alone discs
385    my @cd;
386    foreach (keys %donedisc){
387        $donedisc{$_} or push @cd, $_ 
388    }
389    @cd and push @metagroups, [0,\@cd];
390    \@metagroups
391}
392
393sub getGroupReps{
394    my ($config,$groups) = @_;
395    my @reps;
396    my @sreps;
397    foreach my $listnumber (keys %{$groups->{list}}){
398        my $ok;
399        foreach (@{$groups->{list}{$listnumber}{rpm}}){
400            !$_->[3]{nodeps} and $ok = 1
401        }
402        if (!$ok) { $groups->{nodeps}{$listnumber} = 1; next }
403        print {$config->{LOG}} "getGroupReps list $listnumber\n";
404        foreach (@{$config->{list}[$listnumber]{packages}}) {
405            print {$config->{LOG}} "$_->[0] ($_->[1])\n";
406            unshift @reps, $_->[0];
407            unshift @sreps, $_->[1] 
408        }
409    }
410    (\@reps,\@sreps)
411}
412
413sub makeWithGroups{
414    my ($class, $lists, $acds) = @_;
415    my $config = $class->{config};
416    my $metagroups = orderGroups($config,getGroups($config,$lists),$lists,$acds);
417
418    foreach (keys %{$lists}){
419        print {$config->{LOG}} "2 LIST $_ => $lists->{$_}\n"
420    }
421
422    my @discsFiles;
423    my (@cdsize,%size,%graft);
424    for(my $i; $i < @{$config->{disc}}; $i++) { $cdsize[$i] = $config->{disc}[$i]{size} }
425    foreach (@{$metagroups}){
426        my $groups = $_->[0];
427        print {$config->{LOG}} "makeWithGroups: Group listing $_ (@{$_->[1]} -- $groups)\n"
428    }
429    foreach my $g (@{$metagroups}){
430        my $cds = $g->[1];
431        my $groups = $g->[0];
432        print {$class->{config}->{LOG}} "Group: $g (@{$g->[1]} -- $groups)\n";
433        # FIXME ordering metagroups can lead to empty groups with the -l option
434        $groups or next;
435
436        my @buildlist;
437        my @rpmlist;
438        my (@log,@groupok,@mkisos);
439        $class->{disc}->makeDiscs(0,$lists,$cds,\%size,\@mkisos,\@discsFiles,\%graft);
440
441        for (my $i; $i < @$groups; $i++){
442            print {$config->{LOG}} "Get already built discs lists\n";
443            $groups->[$i]{done} = {};
444            $class->{disc}->getBuiltDiscs($lists, $groups->[$i], \@discsFiles);
445            $config->{verbose} and print {$config->{LOG}} "GROUP $i\n";
446            my ($reps,$sreps) = getGroupReps($config,$groups->[$i]);
447            @$reps or next;
448            $config->{verbose} and print {$config->{LOG}} "genDeps\n";
449            $groups->[$i]{params} = genDeps("$config->{tmp}/$config->{name}/$groups->[$i]{depsrep}",$reps,$config->{deps},$config->{verbose},$config->{tmp}) or print {$config->{LOG}} "ERROR: genDeps failed\n" and return 0;
450
451            #print {$config->{LOG}} "PARAMS 1\nKEYS 1 ",join "\n KEYS 1 ", keys %{$groups->[$i]{params}{info}},"\n";
452           
453            $config->{verbose} and print {$config->{LOG}} "getRPMsKey\n";       
454            $groups->[$i]{rpmkey} = getRPMsKeys(0,"$config->{tmp}/$config->{name}/$groups->[$i]{depsrep}/hdlist.cz");
455            #print {$config->{LOG}} "PARAMS 1\nRPMKEYS 1 ",join "\n RPMKEYS 1 ", keys %{$groups->[$i]{rpmkey}{rpm}},"\n";
456            $config->{verbose} and print {$config->{LOG}} "getSize", keys %{$groups->[$i]{list}},"\n";
457            my $redeps = getSize($groups->[$i],$config,$config->{verbose}) or print {$config->{LOG}} "ERROR: getSize failed\n" and return 0;
458            if ($redeps == 2){ 
459                print {$config->{LOG}} "Rebuilding depslist\n" and $groups->[$i]{params} = genDeps("$config->{tmp}/$config->{name}/$groups->[$i]{depsrep}",$reps,1,$config->{verbose},$config->{tmp});
460                #print {$config->{LOG}} "PARAMS 2\nKEYS 2 ",join "\n KEYS 2 ", keys %{$groups->[$i]{params}{info}},"\n";
461                $groups->[$i]{rpmkey} = getRPMsKeys(0,"$config->{tmp}/$config->{name}/$groups->[$i]{depsrep}/hdlist.cz");
462                #print {$config->{LOG}} "PARAMS 2\nRPMKEYS 2 ",join "\n RPMKEYS 2 ", keys %{$groups->[$i]{rpmkey}{rpm}},"\n";
463                getSize($groups->[$i],$config,$config->{verbose}) or print {$config->{LOG}} "ERROR: getSize failed\n" and return 0;
464            }   
465
466            $class->{disc}->guessHdlistSize($groups->[$i],\%size,\@cdsize,$lists,\@discsFiles);
467
468            $groups->[$i]{revdeps} = $class->{list}->reverseDepslist($groups->[$i]);
469
470            ($groups->[$i]{filelist},my $norpmsrate) = $class->{list}->getList($groups->[$i],\@discsFiles);
471
472            if ($groups->[$i]{rpmsratepath}){ 
473                my $outputdir = "$config->{tmp}/build/$config->{name}/$groups->[$i]{installDisc}/Mandrake/base/";
474                -d $outputdir or mkpath $outputdir;
475                my $output = "$outputdir/rpmsrate";
476                $config->{verbose} and print {$config->{LOG}} "cleanrpmsrate $groups->[$i]{rpmsratepath} -> $output\n";
477                $groups->[$i]{rpmsrate} = cleanrpmsrate($groups->[$i]{rpmsratepath},$output,$norpmsrate,@$reps) or print {$config->{LOG}} "ERROR: cleanrpmsrate failed\n";
478                $groups->[$i]{options}{rpmsrate} = $output;
479            }
480
481            print {$config->{LOG}} "buildList group $i\n";
482            $rpmlist[$i] = $class->{list}->buildList($groups->[$i]) or return 0;
483
484            $class->{list}->scoreList($groups->[$i]) or return 0;
485            $class->{list}->autodeps($groups->[$i],$rpmlist[$i]);
486
487            foreach my $l (keys %{$rpmlist[$i]}) { 
488                my @force;
489                my @needed;
490                my @superforce;
491                my @limit;
492                my @b;
493                foreach (keys %{$rpmlist[$i]{$l}}){
494                    if (!$_) {
495                        print {$config->{LOG}} "ERROR: empty rpmlist key ($rpmlist[$i]{$l}{$_}) KEYS ", keys %{$rpmlist[$i]{$l}{$_}}," \n";
496                        next
497                    }
498                    if (!$config->{nodeps} && !$groups->[$i]{options}{nodeps} && /basesystem/) { 
499                        push @superforce, [$_, $rpmlist[$i]{$l}{$_}, $groups->[$i]{scorelist}{$_}]
500                    }elsif ($rpmlist[$i]{$l}{$_}{force}) { 
501                        push @force, [$_, $rpmlist[$i]{$l}{$_}, $groups->[$i]{scorelist}{$_}]
502                    }elsif ($rpmlist[$i]{$l}{$_}{needed}) { 
503                        push @needed, [$_, $rpmlist[$i]{$l}{$_}, $groups->[$i]{scorelist}{$_}]
504                    }elsif ($rpmlist[$i]{$l}{$_}{limit}){
505                        push @limit, [$_, $rpmlist[$i]{$l}{$_}, $groups->[$i]{scorelist}{$_}]
506                    }else { push @b, [$_, $rpmlist[$i]{$l}{$_}, $groups->[$i]{scorelist}{$_}]}
507                    # used to check which packages has beed rejected
508                    push @{$groups->[$i]{buildlist}}, $_
509                }
510                $buildlist[$i]{$l} = [sort { $a->[2] <=> $b->[2] } @b];
511                unshift @{$buildlist [$i]{$l}}, sort { $a->[2] <=> $b->[2] } @limit;
512                push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @needed;
513                push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @force;
514                push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @superforce
515            }
516        }
517
518        # FIXME it must have a cleaner manner to keep buildlist and do not have
519        # to copy it.
520        my @cb;
521        for(my $i; $i < @buildlist; $i++){ 
522            foreach my $l (keys %{$buildlist[$i]}){ foreach (@{$buildlist[$i]{$l}}){ $config->{verbose} and print {$config->{LOG}} "MakeWithGroups: copying buildlist group $i list $l package $_->[0] score $_->[2] options ", join ' ', keys %{$_->[1]},"\n";push @{$cb[$i]{$l}}, $_}}}
523
524        my ($diff,$rejected) = $class->{list}->buildDiscs($groups,\@cb,\@rpmlist,\@log,\@groupok,\%size,\@cdsize,$lists,$cds);
525        my $logi;
526        $diff or return 0;
527        my $cd = $class->{list}->processDiff($groups,$diff,\@log,\@discsFiles);
528        my $ok;
529        $class->{disc}->makeDiscs(1,$lists,$cds,\%size,\@mkisos,\@discsFiles,\%graft,$cd) or return 0;
530        my $ok = $class->{disc}->checkSize(0,\%size,\@cdsize,$rejected);
531        my $n;
532        $ok = 1;
533        while (!$ok){
534            $n++;
535            $ok = 1;
536            my @cb;
537            for(my $i; $i < @buildlist; $i++){ 
538                foreach my $l (keys %{$buildlist[$i]}){ foreach (@{$buildlist[$i]{$l}}){push @{$cb[$i]{$l}}, $_}}}
539                ($diff,$rejected) = $class->{list}->buildDiscs($groups,\@cb,\@rpmlist,\@log,\@groupok,\%size,\@cdsize,$lists,$cds) or return 0;
540                my $cd = $class->{list}->processDiff($groups,$diff,\@log,\@discsFiles);
541                $class->{disc}->makeDiscs(2,$lists,$cds,\%size,\@mkisos,\@discsFiles,\%graft,$cd) or return 0;
542                $ok = $class->{disc}->checkSize($n,\%size,\@cdsize,$rejected);
543                !$ok and print {$config->{LOG}} "ERROR: one or more disc are too big or too small, rebuilding lists\n";
544                $n > 2 and print {$config->{LOG}} "ERROR: could not manage to build discs of correct size, exiting\n" and last
545        }
546        for (my $i; $i < @$groups; $i++){
547            foreach my $list (keys %{$groups->[$i]{list}}){
548                foreach my $type (keys %{$groups->[$i]{list}{$list}}){
549                    foreach (@{$groups->[$i]{list}{$list}{$type}}){
550                        $config->{list}[$list]{disc}{$_->[0]}{$_->[1]}{done} = 1
551                    }
552                }
553            }   
554        }
555    }
556    printDiscsFile($config,\@discsFiles,$config->{print},$metagroups);
557    $config->{printscript} and printBatchFile($config,\@discsFiles,$config->{printscript});
558    1
559}
560
5611
562
563#
564# Changelog
565#
566# 2002 02 21
567#
568# add maxlistmaxrep value to group
569#
570# 2002 03 03
571#
572# change size to an hash that contains disc size and rep size
573#
574# 2002 03 09
575#
576# make group{discrep} and hash not to have loop in disc dependencies when there are multiple repository on one CD
577#
578# 2002 03 14
579#
580# BIG change of group source handling
581#
582# 2002 03 15
583#
584# use new source handling
585#
586# 2002 03 23
587#
588# change getAlone to be able to build generic CDs without installation
Note: See TracBrowser for help on using the repository browser.