source: soft/build_system/build_system/mkcd/tags/V3_0_3_1mdk/pm/Mkcd/Group.pm @ 1

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

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

File size: 20.3 KB
Line 
1package Mkcd::Group;
2
3my $VERSION = '1.0.2';
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 log_);
11use Mkcd::Package qw(genDeps 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]
70# brokendeps   => { rpm_depending_on_non_listed_locales => 1 , rpm_which_deps_are_broken => 2 }
71# conflict     => { $group_number => 1 } this group have common disc with generic like function with group $group_number.
72# depsrep      => deps repository name
73# depslistid   => [ depslist id ]
74# discdeps     => { cd => { cds it depends on ] }
75# done         => { rpm => rep number }
76# installDisc  => install disc for this group
77# filelist     => [FILELIST]
78# lang         => { locale1 => 1, locale2 => 1}
79# listmaxrep   => { rpm/srpm => { list => max ordered rep_name number for list list } }
80# listrpm      => { list => [ rpm ] }
81# listsize     => { rpm => { list => total rpm size, ... } }
82# maxrep       => max ordered rep_name number
83# maxsize      => rpm maxsize
84# missingdeps  => { rpm => [ missing dependencies ] }
85# nodeps       => { list => 1}
86# orderedrep   => { rpm/srpm => { "rep_name" => num } }
87# orderedlist  => { rpm/srpm }
88# pkgdeps      => { package_name => [depslist dependencies ] }
89# pkgrate      => { rpm => rpmsrate_increase }
90# globrpm      => [ "path1/rpm1" ... "pathn/rpmq" ]
91# replist      => [ [ cd, repname, num], [], ..., []]
92# revdeps      => [ reversed depslist ]
93# rpmsrate     => { rpmsrate }
94# rpmsratepath => rpmsrate path
95# score        => [ score weight ]
96# scoredlist   => { rpm_name => score }
97# size         => { rpm_name => [filesize, list number, directory], ... }
98# srpmname     => { srpm => srpm-version-release }
99# sourcerpm    => { rpm => sourcerpm }
100# urpm         => URPM::urpm
101#     option added to urpm
102#     rpmkey
103#     sourcerpm
104#     rpm
105
106#
107#  FIXME
108#
109# Weigh should be put in the first loop with list so that generic
110# groups without installation can get scoring. At present the implementation
111# prevent from using the -o option with generic and as a consequence
112# generic groups will be sorted with (1,1,0) (no install means no rpmsrate)
113#
114
115sub getGroups {
116    my ($config,$lists) = @_;
117    my (@list, %cd, %done, %list, %repname);
118    print {$config->{LOG}} "getGroups\n";
119    foreach my $i (keys %{$lists}){
120        log_("getGroups: disc $i\n",$config->{verbose},$config->{LOG});
121        $cd{$i} = 1;
122        ref $config->{disc}[$i]{fastgeneric} or next;
123        my @l = @{$config->{disc}[$i]{fastgeneric}};
124        foreach (@l){
125            log_("getGroups: list $_->[1]{list} repname $_->[1]{repname} options (". keys(%{$_->[1]}) .")\n",$config->{verbose},$config->{LOG});
126            my $idx;
127            # 2002 03 19 source/binary are handled later
128            #if ($_->[1]{source}) {
129            ## 2002 03 14 deprecated
130            ## $_->[1]{score} = $_->[1]{priority} ? $_->[1]{priority} + $config->{discMax} : $config->{disc}[$i]{name};
131            #   push @{$list[$_->[1]{list}][1]}, [$i, $_->[1]{repname}, $_->[1], {}]
132            #} else {
133            #   $idx = push @{$list[$_->[1]{list}]}, [$i, $_->[1]{repname}, $_->[1], {}];
134            #}
135            $idx = push @{$list[$_->[1]{list}]}, [$i, $_->[1]{repname}, $_->[1], {}];
136            push @{$repname{$i}{$_->[1]{repname}}}, [ $_->[1]{list}, $idx - 1 ];
137            log_("getGroups: cd $i repname $_->[1]{repname} list $_->[1]{list}\n",$config->{verbose},$config->{LOG});
138            $list{$_->[1]{list}} = 1
139        }
140    }
141    my @group;
142    my $g;
143    my %donerep;
144    foreach my $i (keys %{$lists}){
145        my $t = $config->{disc}[$i]{function}{data}{installation};
146        log_("getGroups: disc $i ($t)\n",$config->{verbose},$config->{LOG});
147        ref $t and do {
148            print {$config->{LOG}} "getGroups: install disc for group $g => ($i)\n";
149            $group[$g]{installDisc} = $i;
150            $group[$g]{options} = $t->[1];
151            $group[$g]{score} ||= $t->[1]{score} || [1,1,1];
152            ($group[$g]{maxrep}{rpm},$group[$g]{maxlist}{rpm}) = addRepList("rpm",$group[$g],$g,$t->[1]{rpmsdir},$donerep{$g},\%done,\%list,\%cd,\%repname,$i,\@list);
153            ($group[$g]{maxrep}{srpm},$group[$g]{maxlist}{srpm}) = addRepList("srpm",$group[$g],$g,$t->[1]{srpmsdir},$donerep{$g},\%done,\%list,\%cd,\%repname,$i,\@list);
154            $group[$g]{rpmsratepath} ||= $t->[1]{rpmsrate} || "$t->[1]{install}/Mandrake/base/rpmsrate";
155            print {$config->{LOG}} "getGroups: using $group[$g]{rpmsratepath} as rpmsrate file\n";
156            $group[$g]{list} and $group[$g]{depsrep} = join '-', keys %{$group[$g]{list}};
157            print {$config->{LOG}} "getGroups: $group[$g]{depsrep} defined as deps file directory\n";
158            if (ref $t->[1]{lang}) {
159                foreach (@{$t->[1]{lang}}) {$group[$g]{lang}{$_} = 1 }
160            }
161
162            $group[$g]{discdeps}{$i} ||= {};
163            print {$config->{LOG}} "getGroups DEBUG: discdep for group $g => ($group[$g]{discdep})\n";
164            $g++;
165        }
166    }
167    foreach (keys %list){
168        log_("getGroups: searching alone groups list $_\n",$config->{verbose},$config->{LOG});
169        $group[$g]{score} = [1,1,1];
170        $group[$g]{depsrep} = $_;
171        getAlone($list[$_],$group[$g],$g,\%done);
172        $list{$_}++;
173        $g++
174    }
175
176    foreach my $i (keys %{$lists}){
177        $done{$i} and next;
178        log_("getGroups: searching alone disc disc $i does not handled by any group, setting alone group\n",$config->{verbose},$config->{LOG});
179        $group[$g]{discdeps}{$i} ||= {};
180        $g++
181    }
182   
183    for (my $i; $i < @group; $i++){
184        $group[$i]{orderedlist}{rpm} ||= [];
185        foreach (@{$group[$i]{orderedlist}{rpm}}){
186            $group[$i]{list}{$_}{srpm} ||= []
187        }
188        $group[$i]{orderedlist}{srpm} ||= [];
189        print {$config->{LOG}} "getGroups: ordered rpm list for group $i: @{$group[$i]{orderedlist}{rpm}}\n";   
190        print {$config->{LOG}} "getGroups: ordered srpm list for group $i: @{$group[$i]{orderedlist}{srpm}}\n"; 
191    }
192
193    $config->{verbose} and printTable(\@group);
194    \@group
195}
196
197sub getAlone{
198    my ($list,$group,$g,$done) = @_;
199    my $num = 1;
200    $list or return;
201    my $lnsort = 1;
202    foreach my $l (@{$list}){
203        my ($cd,$rep,$opt) = @$l;
204        my $ls = $opt->{list};
205        $done->{$cd}{$rep}{$ls} and next;
206        print {$config->{LOG}} "WARNING getAlone: rep $rep of list $_ does not belong to any installation disc, setting alone group $g\n";
207        my $type = $opt->{source} ? "srpm" : "rpm";
208        log_("getGroups: searching alone groups list $ls cd $cd rep $rep type $type\n",$config->{verbose},$config->{LOG});
209        $group->{list}{$ls}{$type} or push @{$group->{orderedlist}{$type}}, $ls;       
210        $group->{listmatrix}{$type}{$ls}{$ls} = 1;
211        push @{$config->{list}[$ls]{disc}{$cd}{$rep}{master}}, $g;
212        push @{$group->{list}{$ls}{$type}}, $l;
213        if (! $group->{orderedrep}{$type}{"$cd/$rep"}){
214            $group->{orderedrep}{$type}{"$cd/$rep"} = $num;
215            push @{$group->{replist}{$type}}, [ $cd, $rep, $num++, [ $ls ]]
216        }
217        if (!$group->{listsort}{$ls}{$type}) { $group->{listsort}{$ls}{$type} = $lnsort++ };
218        $done->{$cd}{$rep}{$ls}++;
219        print {$config->{LOG}} "getGroups: searching alone groups group $g handle disc $l->[0]\n";
220        $group->{discdeps}{$l->[0]} ||= {};
221    }
222}
223
224sub addRepList{
225    my ($type,$group,$g,$replist,$donerep,$done,$list,$disc,$repname,$i,$listTable) = @_;
226    my $num = 1;
227    my $lnsort = 1;
228    foreach (@$replist){
229        my ($cdlist,$cd,$name) = ($_->[0],$_->[1],$_->[2]);
230        my $opt = $_->[3] || {};
231        log_("getGroups: group $g cd $cd repname $name list $cdlist\n",$config->{verbose},$config->{LOG});
232        $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;
233        $donerep->{$type}{$cd}{$name}{$cdlist} = 1;
234        $disc->{$cd} or print {$config->{LOG}} "ERROR getGroups: disc $cd not in list, ignoring\n" and next;
235        my $ln = $repname->{$cd}{$name};
236        $ln or print {$config->{LOG}} "ERROR getGroups: $name on disc $cd does not exist\n" and next;
237        my $replist_list;
238        if (! $group->{orderedrep}{$type}{"$cd/$name"}){
239            $group->{orderedrep}{$type}{"$cd/$name"} = $num;
240            $replist_list = [];
241            push @{$group->{replist}{$type}}, [ $cd, $name, $num++, $replist_list]
242        }
243        $cd != $i and $group->{discdeps}{$i}{$cd}++;
244        $cd != $i and print {$config->{LOG}} "getGroups: group $g handle disc $i\n";
245        foreach my $l (@$ln){
246            my ($ls,$idx) = @$l;
247            next if $cdlist && $cdlist != $ls;
248            if ($group->{listmaxrep}{$type}{$ls} < $group->{orderedrep}{$type}{"$cd/$name"}) { $group->{listmaxrep}{$type}{$ls} = $group->{orderedrep}{$type}{"$cd/$name"} }
249            $group->{list}{$ls}{$type} or push @{$group->{orderedlist}{$type}}, $ls;   
250            foreach my $lst (@{$group->{orderedlist}{$type}}) { $group->{listmatrix}{$type}{$ls}{$lst} = 1 }
251            if (!$group->{listsort}{$ls}{$type}) { $group->{listsort}{$ls}{$type} = $lnsort++ };
252            push @{$group->{list}{$ls}{$type}}, [$cd, $name, $listTable->[$ls][$idx][2], $opt];
253            push @{$replist_list}, $ls;
254            if ($opt->{fixed}){
255                push @{$config->{list}[$ls]{disc}{$cd}{$name}{master}}, $g             
256            }else{
257                # this group is the master for this rep
258                unshift @{$config->{list}[$ls]{disc}{$cd}{$name}{master}}, $g
259            }
260            $list->{$ls}++;
261            $done->{$cd}{$name}{$ls}++;
262        }       
263    }
264    return ($num,$lnsort)
265}
266
267sub preCheck{
268    # TODO
269    # may not be necessary
270}
271
272sub orderGroups{
273    my ($config,$groups,$lists,$acds) = @_;
274    my @metagroups;
275    my @groupmeta;
276    my $ok;
277    # FIXME This algo can create empty metagroups
278    while (!$ok){
279        print {$config->{LOG}} "orderGroups: ordering metagroups\n";
280        $ok = 1;
281        for (my $i; $i < @$groups; $i++){
282            if ($groups->[$i]{installDisc}){
283                $lists->{$groups->[$i]{installDisc}} == 2 or next
284            }
285            print {$config->{LOG}} "Group $i (install disc $groups->[$i]{installDisc})\n";
286            foreach my $list (keys %{$groups->[$i]{list}}){
287                foreach my $type (keys %{$groups->[$i]{list}{$list}}){
288                    foreach my $rep (@{$groups->[$i]{list}{$list}{$type}}){
289                        my ($cd,$r) = ($rep->[0],$rep->[1]);
290                        $lists->{$cd} == 2 or next;
291                        my $og = $config->{list}[$list]{disc}{$cd}{$r}{master}[0];
292                        print {$config->{LOG}} "Master of disc $cd/$r = ($og)\n";
293                        if ($og != $i && $groupmeta[$i] == $groupmeta[$og]){ $ok = 0;$groupmeta[$i] = $groupmeta[$og] + 1 }
294                    }
295                }
296            }
297        }
298    }
299    for (my $i; $i < @$groups; $i++){
300        if ($groups->[$i]{installDisc}){
301            $lists->{$groups->[$i]{installDisc}} == 2 or next
302        }
303        print {$config->{LOG}} "orderGroups: group $i metagroup $groupmeta[$i]\n";
304        push @{$metagroups[$groupmeta[$i]][0]}, $groups->[$i];
305    }
306    my %donedisc;
307    foreach (@metagroups){
308        my %cd;
309        my %cdg;
310        my $i = 1;
311        foreach (@$acds) { $cd{$_} = $i++ }
312        my $grps = $_->[0];
313        my $loop;
314        my $ok = 0;
315        $_->[1] = [];
316        my %groups_conflict;
317        while (!$ok && !$loop){
318            $ok = 1;
319            foreach my $gn (0 .. @{$grps}){
320                my $g = $grps->[$gn];
321                print {$config->{LOG}} "orderGroups: discs ", keys %{$g->{discdeps}},"\n";
322                foreach my $cd (keys %{$g->{discdeps}}){
323                    $donedisc{$cd} and next;
324                    $groups_conflict{$cd}{$gn} = 1;
325                    $g->{conflict} = $groups_conflict{$cd};
326                    log_("group $gn conflict with group $gn ($g->{conflict}{$gn})",1,$config->{LOG});
327                    print {$config->{LOG}} "orderGroups: disc $cd\n";
328                    $lists->{$cd} >= 1 or next;
329                    $cdg{$cd} = {};
330                    if (ref $g->{discdeps}{$cd}){
331                        foreach (keys %{$g->{discdeps}{$cd}}){
332                            $donedisc{$_} and next;
333                            print {$config->{LOG}} "orderGroups: disc $cd => $_\n";
334                            $cdg{$cd}{$_} and print {$config->{LOG}} "ERROR: orderGroups: loop in discs dependencies, taking manual order\n" and $loop = 1;
335                            $cdg{$cd}{$_} = 1;
336                            $cdg{$_} = {};
337                            if ($cd{$cd} <= $cd{$_}){ 
338                                $cd{$cd} = $cd{$_} + 1;
339                                $ok = 0
340                            }
341                        }
342                    }
343                }
344            }
345        }
346        if ($loop){
347            foreach my $c (@$acds) { $cdg{$c} and $lists->{$c} == 2 and push @{$_->[1]}, $c and $donedisc{$c} = 1} 
348        }else{
349            my @scds = sort { $cd{$a} <=> $cd{$b} } keys %cdg;
350            foreach my $c (@scds) { $lists->{$c} == 2 and push @{$_->[1]}, $c and $donedisc{$c} = 1}   
351        }
352        print {$config->{LOG}} "orderGroup: disc sorting @{$_->[1]}\n"
353    }
354    # add alone discs
355    my @cd;
356    foreach (keys %donedisc){
357        $donedisc{$_} or push @cd, $_ 
358    }
359    @cd and push @metagroups, [0,\@cd];
360    \@metagroups
361}
362
363sub getGroupReps{
364    my ($config,$groups) = @_;
365    my @reps;
366    my @sreps;
367    foreach my $listnumber (keys %{$groups->{list}}){
368        my $ok;
369        foreach (@{$groups->{list}{$listnumber}{rpm}}){
370            !$_->[3]{nodeps} and $ok = 1
371        }
372        if (!$ok) { $groups->{nodeps}{$listnumber} = 1; next }
373        print {$config->{LOG}} "getGroupReps list $listnumber\n";
374        foreach (@{$config->{list}[$listnumber]{packages}}) {
375            print {$config->{LOG}} "@$_\n";
376            unshift @reps, $_->[0];
377            unshift @sreps, $_->[1] 
378        }
379    }
380    (\@reps,\@sreps)
381}
382
383sub makeWithGroups{
384    my ($class, $lists, $acds, %done_deps) = @_;
385    my $config = $class->{config};
386    my $metagroups = orderGroups($config,getGroups($config,$lists),$lists,$acds);
387
388    foreach (keys %{$lists}){
389        print {$config->{LOG}} "2 LIST $_ => $lists->{$_}\n"
390    }
391
392    my @discsFiles;
393    my (@cdsize,%size,%graft);
394    for(my $i; $i < @{$config->{disc}}; $i++) { $cdsize[$i] = $config->{disc}[$i]{size} }
395    foreach (@{$metagroups}){
396        my $groups = $_->[0];
397        print {$config->{LOG}} "makeWithGroups: Group listing $_ (@{$_->[1]} -- $groups)\n"
398    }
399    foreach my $g (@{$metagroups}){
400        my $cds = $g->[1];
401        my $groups = $g->[0];
402        print {$class->{config}->{LOG}} "Group: $g (@{$g->[1]} -- $groups)\n";
403        # FIXME ordering metagroups can lead to empty groups with the -l option
404        $groups or next;
405
406        my (@buildlist, @rpmlist, @needed);
407        my (@log,@groupok,@mkisos);
408        $class->{disc}->makeDiscs(0,$lists,$cds,\%size,\@mkisos,\@discsFiles,\%graft);
409
410        for (my $i; $i < @$groups; $i++){
411            print {$config->{LOG}} "Get already built discs lists\n";
412            $groups->[$i]{done} = {};
413            $class->{disc}->getBuiltDiscs($lists, $groups->[$i], \@discsFiles);
414           
415            log_("GROUP $i\n",$config->{verbose},$config->{LOG});
416            my ($reps,$sreps) = getGroupReps($config,$groups->[$i]);
417            @$reps or next;
418           
419            log_("genDeps\n",$config->{verbose},$config->{LOG});
420            if (! $done_deps{$groups->[$i]{depsrep}}){
421                $done_deps{$groups->[$i]{depsrep}} = 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
422            }
423            $groups->[$i]{urpm} = $done_deps{$groups->[$i]{depsrep}};
424
425            log_("getSize" . keys(%{$groups->[$i]{list}}) . "\n",$config->{verbose},$config->{LOG});
426            my $redeps = getSize($groups->[$i],$config,$config->{verbose}) or print {$config->{LOG}} "ERROR: getSize failed\n" and return 0;
427           
428            $class->{disc}->guessHdlistSize($groups->[$i],\%size,\@cdsize,$lists,\@discsFiles);
429
430            $groups->[$i]{revdeps} = $class->{list}->reverseDepslist($groups->[$i]);
431
432            ($groups->[$i]{filelist},my $norpmsrate) = $class->{list}->getList($groups->[$i],\@discsFiles);
433
434            if ($groups->[$i]{rpmsratepath}){ 
435                my $outputdir = "$config->{tmp}/build/$config->{name}/$groups->[$i]{installDisc}/Mandrake/base/";
436                -d $outputdir or mkpath $outputdir;
437                my $output = "$outputdir/rpmsrate";
438                log_("cleanrpmsrate $groups->[$i]{rpmsratepath} -> $output\n",$config->{verbose},$config->{LOG});
439                $groups->[$i]{rpmsrate} = cleanrpmsrate($groups->[$i]{rpmsratepath},$output,$norpmsrate,@$reps) or print {$config->{LOG}} "ERROR: cleanrpmsrate failed\n";
440                $groups->[$i]{options}{rpmsrate} = $output;
441            }
442
443            print {$config->{LOG}} "buildList group $i\n";
444            $rpmlist[$i] = $class->{list}->buildList($groups->[$i]) or return 0;
445
446            $class->{list}->scoreList($groups->[$i]) or return 0;
447            $class->{list}->autodeps($groups->[$i],$rpmlist[$i]);
448
449            foreach my $l (keys %{$rpmlist[$i]}) { 
450                my (@force, @need, @superforce, @limit, @b);
451                foreach (keys %{$rpmlist[$i]{$l}}){
452                    if (!$_) {
453                        print {$config->{LOG}} "ERROR: empty rpmlist key ($rpmlist[$i]{$l}{$_}) KEYS ", keys %{$rpmlist[$i]{$l}{$_}}," \n";
454                        next
455                    }
456                    my $elt = [ $_, $rpmlist[$i]{$l}{$_}, $groups->[$i]{scorelist}{$_} ];
457                    if (!$config->{nodeps} && !$groups->[$i]{options}{nodeps} && /basesystem/) { 
458                        push @superforce, $elt
459                    }elsif ($rpmlist[$i]{$l}{$_}{force}) { 
460                        push @force, $elt
461                    }elsif ($rpmlist[$i]{$l}{$_}{limit}){
462                        push @limit, $elt
463                    }else { 
464                        push @b, $elt
465                    }
466                    push @{$needed[$i]{$l}{alap}[$rpmlist[$i]{$l}{$_}{needed}]}, $elt,  if $rpmlist[$i]{$l}{$_}{needed};
467                    # used to check which packages has beed rejected
468                    push @{$groups->[$i]{buildlist}}, $_
469                }
470                $buildlist[$i]{$l} = [sort { $a->[2] <=> $b->[2] } @b];
471                unshift @{$buildlist [$i]{$l}}, sort { $a->[2] <=> $b->[2] } @limit;
472                # needed must not be put first.
473                #push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @need;
474                push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @force;
475                push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @superforce
476            }
477        }
478
479        # FIXME it must have a cleaner manner to keep buildlist and do not have
480        # to copy it.
481        my @cb;
482        for(my $i; $i < @buildlist; $i++){ 
483            foreach my $l (keys %{$buildlist[$i]}){ foreach (@{$buildlist[$i]{$l}}){ log_("MakeWithGroups: copying buildlist group $i list $l package $_->[0] score $_->[2] options " . join(' ', keys %{$_->[1]}) . "\n",$config->{verbose},$config->{LOG});push @{$cb[$i]{$l}}, $_}}}
484
485        my ($diff,$rejected) = $class->{list}->buildDiscs($groups,\@cb,\@rpmlist,\@log,\@groupok,\%size,\@cdsize,$lists,$cds,\@needed);
486        my $logi;
487        $diff or return 0;
488        my $cd = $class->{list}->processDiff($groups,$diff,\@log,\@discsFiles);
489        my $ok;
490        $class->{disc}->makeDiscs(1,$lists,$cds,\%size,\@mkisos,\@discsFiles,\%graft,$cd) or return 0;
491        $ok = $class->{disc}->checkSize(0,\%size,\@cdsize,$rejected);
492        my $n;
493        $ok = 1;
494        while (!$ok){
495            $n++;
496            $ok = 1;
497            my @cb;
498            for(my $i; $i < @buildlist; $i++){ 
499                foreach my $l (keys %{$buildlist[$i]}){ foreach (@{$buildlist[$i]{$l}}){push @{$cb[$i]{$l}}, $_}}}
500            ($diff,$rejected) = $class->{list}->buildDiscs($groups,\@cb,\@rpmlist,\@log,\@groupok,\%size,\@cdsize,$lists,$cds,\@needed) or return 0;
501            my $cd = $class->{list}->processDiff($groups,$diff,\@log,\@discsFiles);
502            $class->{disc}->makeDiscs(2,$lists,$cds,\%size,\@mkisos,\@discsFiles,\%graft,$cd) or return 0;
503            $ok = $class->{disc}->checkSize($n,\%size,\@cdsize,$rejected);
504            !$ok and print {$config->{LOG}} "ERROR: one or more disc are too big or too small, rebuilding lists\n";
505            $n > 2 and print {$config->{LOG}} "ERROR: could not manage to build discs of correct size, exiting\n" and last
506        }
507        for (my $i; $i < @$groups; $i++){
508            foreach my $list (keys %{$groups->[$i]{list}}){
509                foreach my $type (keys %{$groups->[$i]{list}{$list}}){
510                    foreach (@{$groups->[$i]{list}{$list}{$type}}){
511                        $config->{list}[$list]{disc}{$_->[0]}{$_->[1]}{done} = 1
512                    }
513                }
514            }   
515        }
516    }
517    printDiscsFile($config,\@discsFiles,$config->{print},$metagroups);
518    $config->{printscript} and printBatchFile($config,\@discsFiles,$config->{printscript});
519    1
520}
521
5221
523
524#
525# Changelog
526#
527# 2002 02 21
528# add maxlistmaxrep value to group
529#
530# 2002 03 03
531# change size to an hash that contains disc size and rep size
532#
533# 2002 03 09
534# make group{discrep} and hash not to have loop in disc dependencies when there are multiple repository on one CD
535#
536# 2002 03 14
537# BIG change of group source handling
538#
539# 2002 03 15
540# use new source handling
541#
542# 2002 03 23
543# change getAlone to be able to build generic CDs without installation
544#
545# 2002 06 16   
546# add conflict in group
Note: See TracBrowser for help on using the repository browser.