source: soft/build_system/build_system/mkcd/tags/V3_4_5_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: 29.3 KB
Line 
1package Mkcd::Group;
2
3my $VERSION = '2.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
49use vars qw($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# $group[group number]
67# brokendeps   => {
68#       rpm_depending_on_non_listed_locales => 1 ,
69#       rpm_which_deps_are_broken => 2,
70#       rpm_exluded_from_conf => 3 }
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# disc_impacted=> { cd => 1 }
76# done         => { rpm => rep number }
77# installDisc  => install disc for this group
78# filelist     => [FILELIST]
79# lang         => { locale1 => 1, locale2 => 1}
80# list_conflict=> { list => { type => { grp => { list => { type => 0/1 }}}}}
81# listmaxrep   => { rpm/srpm => { list => max ordered rep_name number for list list } }
82# listrpm      => { list => [ rpm ] }
83# listsize     => { rpm => { list => total rpm size, ... } }
84# maxrep       => max ordered rep_name number
85# maxsize      => rpm maxsize
86# nodeps       => { list => 1}
87# orderedrep   => { rpm/srpm => { "rep_name" => num } }
88# orderedlist  => { rpm/srpm }
89# pkgdeps      => { package_name => [depslist dependencies ] }
90# pkgrate      => { rpm => rpmsrate_increase }
91# globrpm      => [ "path1/rpm1" ... "pathn/rpmq" ]
92# rejected     => { rpm => [ "error", "message" ] }
93# rep          => { type => list => [ { "path" => [pkg list] } } ]
94# rep_pkg      => { type => { "path" => [pkg list] } }
95# replist      => { $type => [ [ cd, repname, num, [ [related list, related curdir] [] ] ], [], ..., []] }
96# revdeps      => [ reversed depslist ]
97# rpmsrate     => { rpmsrate }
98# rpmsratepath => rpmsrate path
99# score        => [ score weight ]
100# scoredlist   => { rpm_name => score }
101# size         => { rpm_name => [filesize, list number, directory], ... }
102# srpmname     => { srpm => srpm-version-release }
103# sourcerpm    => { rpm => sourcerpm }
104# urpm         => URPM::urpm
105#     option added to urpm
106#     rpmkey
107#     sourcerpm
108#     rpm
109
110#
111#  FIXME
112#
113# Weigh should be put in the first loop with list so that generic
114# groups without installation can get scoring. At present the implementation
115# prevent from using the -o option with generic and as a consequence
116# generic groups will be sorted with (1,1,0) (no install means no rpmsrate)
117#
118
119sub getGroups {
120    my ($config, $lists) = @_;
121    my (@list, %cd, %done, %list, %repname);
122    log_("getGroups\n", $config->{verbose}, $config->{LOG}, 1);
123    foreach my $i (keys %{$lists}) {
124        log_("getGroups: disc $i\n", $config->{verbose}, $config->{LOG}, 2);
125        $cd{$i} = 1;
126        ref $config->{disc}[$i]{fastgeneric} or next;
127        foreach my $f (@{$config->{disc}[$i]{fastgeneric}}) {
128            my $repname = $f->[1]{repname};
129            my @k = keys %{$f->[1]};
130            ref $f->[1]{lists} or log_("ERROR getGroups: disc $i lists not defined for rep $repname\n", $config->{verbose}, $config->{LOG},3) and next;
131            log_("getGroups: lists @{$f->[1]{lists}} repname $repname options (@k)\n", $config->{verbose}, $config->{LOG},3);
132            foreach my $g_list (@{$f->[1]{lists}}) {
133                log_("getGroups: list $g_list)\n", $config->{verbose}, $config->{LOG}, 3);
134                my $idx;
135                $idx = push @{$list[$g_list]}, [ $i, ${repname}, $f->[1], {} ];
136                push @{$repname{$i}{$repname}}, [ $g_list, $idx - 1 ];
137                log_("getGroups: cd $i repname $repname list $g_list\n", $config->{verbose}, $config->{LOG},3);
138                $list{$g_list} = 0
139            }
140        }
141    }
142    my @group;
143    my $g = prepare_cloned_discs(\@group, \%done, $config, $lists);
144    my %donerep;
145    foreach my $i (keys %{$lists}) {
146        my $t = $config->{disc}[$i]{function}{data}{installation};
147        log_("getGroups: disc $i ($t)\n", $config->{verbose}, $config->{LOG},2);
148        ref $t and do {
149            log_("getGroups: install disc for group $g => ($i)\n", $config->{verbose}, $config->{LOG},3);
150            $group[$g]{installDisc} = $i;
151            $group[$g]{options} = $t->[1];
152            $group[$g]{score} ||= $t->[1]{score} || [1,1,1];
153            ($group[$g]{maxrep}{rpm}, $group[$g]{maxlist}{rpm}) = addRepList("rpm", $group[$g], $g, $t->[1]{rpmsdir}, $donerep{$g}, \%done, \%list, \%cd, \%repname, $i, \@list);
154            ($group[$g]{maxrep}{srpm}, $group[$g]{maxlist}{srpm}) = addRepList("srpm", $group[$g], $g, $t->[1]{srpmsdir}, $donerep{$g}, \%done, \%list, \%cd, \%repname, $i, \@list);
155            $group[$g]{rpmsratepath} ||= $t->[1]{rpmsrate} || "$t->[1]{install}/Mandrake/base/rpmsrate";
156            log_("getGroups: using $group[$g]{rpmsratepath} as rpmsrate file\n", $config->{verbose}, $config->{LOG},4);
157            $group[$g]{list} and $group[$g]{depsrep} = join '-', keys %{$group[$g]{list}};
158            log_("getGroups: $group[$g]{depsrep} defined as deps file directory\n", $config->{verbose}, $config->{LOG},4);
159            if (ref $t->[1]{lang}) {
160                foreach (@{$t->[1]{lang}}) { $group[$g]{lang}{$_} = 1 }
161            }
162
163            $group[$g]{discdeps}{$i} ||= {};
164            log_("getGroups DEBUG: discdep for group $g => ($group[$g]{discdep})\n", $config->{verbose}, $config->{LOG},5);
165            $g++;
166        }
167    }
168    foreach (keys %list) {
169        $list{$_} and next;
170        log_("getGroups: searching alone groups list $_\n", $config->{verbose}, $config->{LOG},2);
171        $group[$g]{score} = [1,1,1];
172        $group[$g]{depsrep} = $_;
173        getAlone($list[$_], $_, $group[$g], $g, \%done);
174        $list{$_}++;
175        log_("getGroups: adding a group $g for list $_\n", $config->{verbose}, $config->{LOG},2);
176        $g++
177    }
178
179    foreach my $i (keys %{$lists}) {
180        $done{$i} and next;
181        $done{$i} = {};
182        log_("getGroups: searching alone disc disc $i does not handled by any group, setting alone group\n", $config->{verbose}, $config->{LOG},2);
183        $group[$g]{discdeps}{$i} ||= {};
184        log_("getGroups: adding a group $g for disc $i\n", $config->{verbose}, $config->{LOG},2);
185        $g++
186    }
187   
188    for (my $i; $i < @group; $i++) {
189        $group[$i]{orderedlist}{rpm} ||= [];
190        foreach (@{$group[$i]{orderedlist}{rpm}}) {
191            $group[$i]{list}{$_}{srpm} ||= []
192        }
193        $group[$i]{orderedlist}{srpm} ||= [];
194        log_("getGroups: ordered rpm list for group $i: @{$group[$i]{orderedlist}{rpm}}\n", $config->{verbose}, $config->{LOG},2);     
195        log_("getGroups: ordered srpm list for group $i: @{$group[$i]{orderedlist}{srpm}}\n", $config->{verbose}, $config->{LOG},2);   
196    }
197   
198    # $config->{verbose} and printTable(\@group);
199    \@group
200}
201
202sub getAlone {
203    my ($list, $ls, $group, $g, $done) = @_;
204    my $num = 1;
205    $list or return;
206    my $lnsort = 1;
207    my $replist_list;
208    foreach my $l (@{$list}) {
209        my ($cd, $rep, $opt) = @$l;
210        $done->{$cd}{$rep}{$ls} and next;
211        log_("WARNING getAlone: rep $rep of list $_ does not belong to any installation disc, setting alone group $g\n", $config->{verbose}, $config->{LOG}, 1);
212        my $type = $opt->{source} ? "srpm" : "rpm";
213        log_("getGroups: searching alone groups list $ls cd $cd rep $rep type $type\n", $config->{verbose}, $config->{LOG},1);
214        $group->{list}{$ls}{$type} or push @{$group->{orderedlist}{$type}}, $ls;       
215        $group->{listmatrix}{$type}{$ls}{$ls} = 1;
216        $config->{list}[$ls]{disc}{$cd}{$rep}{master} ||= $g;
217        if (! exists $config->{disc}[$cd]{group_master}) {
218            log_("getAlone: setting group $g as master of disc $cd\n", $config->{verbose}, $config->{LOG},2);
219            $config->{disc}[$cd]{group_master} = $g;
220            push @{$group->{master_of_disc}}, $cd
221        }
222        $config->{disc}[$cd]{group_list}{$g}{$ls}{$type} = 1;
223        push @{$group->{list}{$ls}{$type}}, $l;
224        my $cur_num = \$group->{orderedrep}{$type}{"$cd/$rep"};
225        if (! $$cur_num) {
226            $$cur_num = $num;
227            $replist_list = { $ls => $l };
228            $group->{replist}{$type}[$num] = [ $cd, $rep, $num++, $replist_list ];
229            $num++
230        } else {
231            $group->{replist}{$type}[$$cur_num][3]{$ls} = $l
232        }
233        foreach my $v (@{$config->{list}[$ls]{virtual}}) {
234            my ($d_cd, $d_rep) = ($v->{disc}, $v->{repname});
235            log_("getAlone: setting disc_prereq for disc on disc $d_cd for list $ls disc $cd group $g\n", $config->{verbose}, $config->{LOG},2);
236            $group->{disc_prereq}{$d_cd}++
237        }
238        if (!$group->{listsort}{$ls}{$type}) { $group->{listsort}{$ls}{$type} = $lnsort++ };
239        $done->{$cd}{$rep}{$ls}++;
240        log_("getAlone: searching alone groups group $g handle disc $l->[0]\n", $config->{verbose}, $config->{LOG},2);
241        # FIXME discdeps may be deprecated for group as hdlists are built without reading real directories.
242        $group->{discdeps}{$l->[0]} ||= {};
243        $group->{disc_impacted}{$l->[0]} = 1;
244        log_("getAlone: setting nodeps flag for group $g list $ls\n", $config->{verbose}, $config->{LOG},3) if $opt->{nodeps};
245        $group->{nodeps}{$ls} = $opt->{nodeps};
246        $group->{options}{nodeps} = $opt->{nodeps}
247    }
248}
249
250sub addRepList {
251    my ($type,$group,$g,$replist,$donerep,$done,$list,$disc,$repname,$i, $listTable) = @_;
252    my $num = 1;
253    my $lnsort = 1;
254    my $replist_list;
255    foreach (@$replist) {
256        my ($cdlist,$cd, $name) = @$_;
257        my $opt = $_->[3] || {};
258        log_("getGroups: group $g cd $cd repname $name list $cdlist noauto ($opt->{noauto})\n", $config->{verbose}, $config->{LOG},2);
259        $donerep->{$type}{$cd}{$name}{$cdlist} and log_("ERROR getGroups: $cd/$name/$cdlist is defined multiple time for group $g, ignoring\n", $config->{verbose}, $config->{LOG}) and next;
260        $donerep->{$type}{$cd}{$name}{$cdlist} = 1;
261        $disc->{$cd} or log_("ERROR getGroups: disc $cd not in list, ignoring\n", $config->{verbose}, $config->{LOG}) and next;
262        my $ln = $repname->{$cd}{$name};
263        $ln or log_("ERROR getGroups: $name on disc $cd does not exist\n", $config->{verbose}, $config->{LOG}) and next;
264        my $cur_num = \$group->{orderedrep}{$type}{"$cd/$name"};
265        if (! $$cur_num) {
266            $$cur_num = $num;
267            $replist_list = {};
268            $group->{replist}{$type}[$num] = [ $cd, $name, $num, $replist_list ];
269            $num++
270        } else {
271            $replist_list = $group->{replist}{$type}[$$cur_num]
272        }
273        $cd != $i and $group->{discdeps}{$i}{$cd}++;
274        $group->{disc_impacted}{$cd} = 1;
275        $cd != $i and log_("getGroups: group $g handle disc $i\n", $config->{verbose}, $config->{LOG},2);
276        foreach my $l (@$ln) {
277            my ($ls, $idx) = @$l;
278            next if $cdlist && $cdlist != $ls;
279            next if $replist_list->{$ls};
280            my $list_options = $listTable->[$ls][$idx][2];
281            if ($group->{listmaxrep}{$type}{$ls} < $group->{orderedrep}{$type}{"$cd/$name"}) { $group->{listmaxrep}{$type}{$ls} = $group->{orderedrep}{$type}{"$cd/$name"} }
282            $group->{list}{$ls}{$type} or push @{$group->{orderedlist}{$type}}, $ls;   
283            foreach my $lst (@{$group->{orderedlist}{$type}}) { $group->{listmatrix}{$type}{$ls}{$lst} = 1 }
284            foreach my $lst_ent (@$ln) { $group->{listmatrix}{$type}{$ls}{$lst_ent->[0]} = 1 }
285            if (!$group->{listsort}{$ls}{$type}) { $group->{listsort}{$ls}{$type} = $lnsort++ };
286            my $curdir = [$cd, $name, $list_options, $opt];
287            push @{$group->{list}{$ls}{$type}}, $curdir;
288            $replist_list->{$ls} = $curdir;
289            foreach my $v (@{$config->{list}[$ls]{virtual}}) {
290                my ($d_cd, $d_rep) = ($v->{disc}, $v->{repname});
291                log_("addRepList: setting disc_prereq for disc on disc $d_cd for list $ls disc $cd group $g\n", $config->{verbose}, $config->{LOG},2);
292                $group->{disc_prereq}{$d_cd}++
293            }
294            if ($opt->{fixed}) {
295                if (!$config->{list}[$ls]{disc}{$cd}{$name}{master}) {
296                    log_("WARNING addRepList: disc $cd rep $name has no master yet\n", $config->{verbose}, $config->{LOG},2) if !$config->{list}[$ls]{disc}{$cd}{$name}{master};
297                    $config->{list}[$ls]{disc}{$cd}{$name}{master} = $g;
298                }
299            } else {
300                # this group is the master for this rep
301                log_("ERROR addRepList: group $g has already a master, overridding\n", $config->{verbose}, $config->{LOG},2) if $config->{list}[$ls]{disc}{$cd}{$name}{master};
302                $config->{list}[$ls]{disc}{$cd}{$name}{master} = $g;
303                if (! exists $config->{disc}[$cd]{group_master}) {
304                    log_("addRepList: setting group $g as master of disc $cd\n", $config->{verbose}, $config->{LOG},2);
305                    $config->{disc}[$cd]{group_master} = $g;
306                    push @{$group->{master_of_disc}}, $cd
307                }
308            }
309            $config->{disc}[$cd]{group_list}{$g}{$ls}{$type} = 1;
310            $list->{$ls}++;
311            $done->{$cd}{$name}{$ls}++;
312        }
313    }
314    return ($num,$lnsort)
315}
316
317sub preCheck {
318    # TODO
319    # may not be necessary
320}
321
322sub orderGroups {
323    my ($config,$groups,$lists, $acds) = @_;
324    my @metagroups;
325    my @groupmeta;
326    my $ok;
327    my $check_group = sub {
328        my ($i,$og, $cd) = @_;
329        log_("checking group $i\n", $config->{verbose}, $config->{LOG});
330        if (ref $groups->[$i]{master_of_disc}) {
331            if ($groupmeta[$i] == $groupmeta[$og]) {
332                log_("setting group $i different from $og cos of disc $cd\n", $config->{verbose}, $config->{LOG});
333                $groupmeta[$i] = $groupmeta[$og] + 1;
334                return 0;
335            }
336        } elsif ($groupmeta[$i] != $groupmeta[$og] && $og == $config->{disc}[$cd]{group_master}) {
337            log_("setting group $i equal to $og cos of disc $cd\n", $config->{verbose}, $config->{LOG});
338            $groupmeta[$i] = $groupmeta[$og];
339            return 0
340        }
341        1
342    };
343    # FIXME This algo can create empty metagroups
344    while (!$ok) {
345        log_("orderGroups: ordering metagroups\n", $config->{verbose}, $config->{LOG});
346        $ok = 1;
347        my %handled;
348        for (my $i; $i < @$groups; $i++) {
349            if ($groups->[$i]{installDisc}) {
350                $lists->{$groups->[$i]{installDisc}} == 2 or next
351            }
352            log_("Group $i (install disc $groups->[$i]{installDisc})\n", $config->{verbose}, $config->{LOG});
353            foreach my $list (keys %{$groups->[$i]{list}}) {
354                foreach my $type (keys %{$groups->[$i]{list}{$list}}) {
355                    foreach my $rep (@{$groups->[$i]{list}{$list}{$type}}) {
356                        my ($cd, $r) = ($rep->[0], $rep->[1]);
357                        $lists->{$cd} == 2 or next;
358                        my $og = $config->{disc}[$cd]{group_master};
359                        $handled{$cd}{$og} = 1;
360                        $og == $i and next;
361                        log_("Master of disc $cd/$r = ($og)\n", $config->{verbose}, $config->{LOG});
362                        $ok = $check_group->($i,$og,$cd);
363                    }
364                }
365            }
366        }
367        for (my $i; $i < @$groups; $i++) {
368            foreach my $cd (keys %{$groups->[$i]{disc_prereq}}) {
369                log_("ordreGroups: searching for disc_prereq for group $i disc $cd\n", $config->{verbose}, $config->{LOG});
370                foreach (keys %{$handled{$cd}}) {
371                    $_ == $i and next;
372                    log_("ordreGroups: disc $cd handled by group $_\n", $config->{verbose}, $config->{LOG});
373                    $ok = $check_group->($i,$_,$cd);
374                }
375            }
376        }
377    }
378    for (my $i; $i < @$groups; $i++) {
379        if ($groups->[$i]{installDisc}) {
380            $lists->{$groups->[$i]{installDisc}} == 2 or next
381        }
382        log_("orderGroups: group $i metagroup $groupmeta[$i]\n", $config->{verbose}, $config->{LOG});
383        push @{$metagroups[$groupmeta[$i]][0]}, $groups->[$i];
384    }
385    my %donedisc;
386    foreach (@metagroups) {
387        my %cd;
388        my %cdg;
389        my $i = 1;
390        foreach (@$acds) { $cd{$_} = $i++ }
391        my $grps = $_->[0];
392        my $loop;
393        my $ok = 0;
394        $_->[1] = [];
395        my %groups_conflict;
396        while (!$ok && !$loop) {
397            $ok = 1;
398            foreach my $gn (0 .. @{$grps}) {
399                my $g = $grps->[$gn];
400                log_("orderGroups: group $gn discs " . (join ' ', (keys %{$g->{discdeps}})) . "\n", $config->{verbose}, $config->{LOG});
401                foreach my $cd (keys %{$g->{discdeps}}) {
402                    $donedisc{$cd} and next;
403                    $groups_conflict{$cd}{$gn} = 1;
404                    $g->{conflict} = $groups_conflict{$cd};
405                    log_("orderGroups: group $gn conflict with group $gn ($g->{conflict}{$gn})\n", $config->{verbose}, $config->{LOG});
406                    log_("orderGroups: orderGroups: disc $cd\n", $config->{verbose}, $config->{LOG});
407                    $lists->{$cd} >= 1 or next;
408                    $cdg{$cd} = {};
409                    if (ref $g->{discdeps}{$cd}) {
410                        foreach (keys %{$g->{discdeps}{$cd}}) {
411                            $donedisc{$_} and next;
412                            log_("orderGroups: disc $cd => $_\n", $config->{verbose}, $config->{LOG});
413                            $cdg{$cd}{$_} and log_("ERROR: orderGroups: loop in discs dependencies, taking manual order\n", $config->{verbose}, $config->{LOG}) and $loop = 1;
414                            $cdg{$cd}{$_} = 1;
415                            $cdg{$_} = {};
416                            if ($cd{$cd} <= $cd{$_}) { 
417                                $cd{$cd} = $cd{$_} + 1;
418                                $ok = 0
419                            }
420                        }
421                    }
422                }
423            }
424        }
425        if ($loop) {
426            foreach my $c (@$acds) { $cdg{$c} and $lists->{$c} == 2 and push @{$_->[1]}, $c and $donedisc{$c} = 1 } 
427        } else {
428            my @scds = sort { $cd{$a} <=> $cd{$b} } keys %cdg;
429            foreach my $c (@scds) { $lists->{$c} == 2 and push @{$_->[1]}, $c and $donedisc{$c} = 1 }   
430        }
431        log_("orderGroups: disc sorting @{$_->[1]}\n", $config->{verbose}, $config->{LOG});
432
433        for (my $i; $i < @$grps; $i++) {
434            foreach my $ls (keys %{$grps->[$i]{list}}) {
435                foreach my $l (keys %{$grps->[$i]{list}}) {
436                    log_("getGroups: group $i listmatrix list $ls - list $l -> $grps->[$i]{listmatrix}{rpm}{$ls}{$l}\n", $config->{verbose}, $config->{LOG})
437                }
438                foreach my $t (keys %{$grps->[$i]{list}{$ls}}) {
439                    my $rep = $grps->[$i]{list}{$ls}{$t};
440                    for (my $grp; $grp < @$grps; $grp++) {
441                        foreach my $list (keys %{$grps->[$grp]{list}}) {
442                            foreach my $type (keys %{$grps->[$grp]{list}{$list}}) {
443                                my $rep2 = $grps->[$grp]{list}{$list}{$type};
444                                foreach my $a (@$rep) {
445                                    if (grep { $a->[0] == $_->[0] } @$rep2) {
446                                        log_("getGroups: group $i list $ls type $t conflicts with group $grp list $list type $type\n", $config->{verbose}, $config->{LOG});     
447                                        $grps->[$i]{list_conflict}{$ls}{$t}{int $grp}{$list}{$type} = 1;
448                                        last
449                                    }
450                                }
451                            }
452                        }
453                    }
454                }
455            }
456        }
457    }
458    # add alone discs
459    my @cd;
460    foreach (keys %donedisc) {
461        $donedisc{$_} or push @cd, $_ 
462    }
463    @cd and push @metagroups, [0, \@cd];
464    \@metagroups
465}
466
467sub getGroupReps {
468    my ($config, $group, $discsFiles) = @_;
469    my $topdir = "$config->{topdir}/build/$config->{name}";
470    my $check_discsFiles = sub {
471        my ($cd, $rep, $listnumber, $rep_nb) = @_;
472        foreach (keys %{$discsFiles->[$cd]{$rep}{$listnumber}}) {
473            my $type = /src$/ ? 'srpm' : 'rpm';
474            my $d = $discsFiles->[$cd]{$rep}{$listnumber}{$_};
475            push @{$group->{rep}{$listnumber}[$rep_nb]{$type}{$d}}, $_;
476            push @{$group->{rep_pkg}{srpm}{$d}}, $_
477        }
478    };
479    my $check_dir = sub {
480        my ($dir, $listnumber, $rep_nb, $type, $test) = @_;
481        opendir my $RPMS, $dir or log_("WARNING getGroupReps: cannot open $dir\n", $config->{verbose}, $config->{LOG}) and return;
482        foreach (readdir $RPMS) {
483            /($test)\.rpm$/ or next;
484            /(.*)\.rpm$/ or next;
485            push @{$group->{rep}{$listnumber}[$rep_nb]{$type}{$dir}}, $1;
486            push @{$group->{rep_pkg}{$type}{$dir}}, $1
487        }
488        closedir $RPMS
489    };
490    my $testarch = join '|', keys %{$config->{ARCH}};
491    foreach my $listnumber (keys %{$group->{list}}) {
492        my $ok;
493        foreach (@{$group->{list}{$listnumber}{rpm}}) {
494            !$_->[3]{nodeps} and $ok = 1
495        }
496        if (!$ok) { $group->{nodeps}{$listnumber} = 1 }
497        log_("getGroupReps list $listnumber\n", $config->{verbose}, $config->{LOG});
498        my $rep_nb;
499        if (ref $config->{list}[$listnumber]{packages}) {
500            foreach (@{$config->{list}[$listnumber]{packages}}) {
501                log_("getGroupReps: rep num $rep_nb\n", $config->{verbose}, $config->{LOG});
502                foreach my $t ('rpm', 'srpm') {
503                    foreach my $d (@{$_->{$t}}) {
504                        log_("getGroupReps: $d\n", $config->{verbose}, $config->{LOG});
505                        $check_dir->($d, $listnumber, $rep_nb, $t, $t eq 'rpm' ? $testarch : 'src');
506                    }
507                }
508                $rep_nb++
509            }
510        }
511       
512        foreach my $d (@{$config->{list}[$listnumber]{virtual}}) {
513            my $cd = $d->{disc};
514            my $rep = $d->{repname};
515            my $path = $config->{disc}[$cd]{function}{data}{dir}{$rep};
516            my $dir = "$topdir/$cd/$path";
517            log_("getGroupReps: virtual disc $cd path $path (num $rep_nb) in $dir\n", $config->{verbose} , $config->{LOG});
518            if ($discsFiles->[$cd]{$rep}{$listnumber}) {
519                $check_discsFiles->($cd,$rep,$listnumber)
520            } elsif (-d $dir) {
521                $check_dir->($dir,$listnumber,$rep_nb, 'rpm',$testarch);
522            } else {
523                log_("ERROR getGroupReps: could not find virtual disc $cd path $path\n", $config->{verbose} , $config->{LOG});
524                next
525            }
526            $rep_nb++
527        }
528        foreach my $cd (keys %{$config->{list}[$listnumber]{disc}}) {
529            foreach my $rep (keys %{$config->{list}[$listnumber]{disc}{$cd}}) {
530                if ($config->{list}[$listnumber]{disc}{$cd}{$rep}{done}) {
531                    $check_discsFiles->($cd,$rep,$listnumber)
532                }
533                $rep_nb++
534            }
535        }
536    }
537}
538
539# TODO at present clone only do full copy
540sub prepare_cloned_discs {
541    my ($group,$done,$config, $lists) = @_;
542    my $g;
543    foreach my $cd (keys %$lists) {
544        my $loc_conf = $config->{disc}[$cd]{function};
545        if ($loc_conf->{data}{clone}) {
546            log_("prepare_cloned_discs: disc $cd\n", $config->{verbose}, $config->{LOG});
547            # nothing to do, cp -r
548            #if (@{$loc_conf->{list}} == 1 && !$loc_conf->{list}[0][1]{to_del}) {
549            #
550            $loc_conf->{data}{clone}[0][1]{full_copy} = 1;
551            $group->[$g]{disc_impacted}{$cd} = 1;
552            $group->[$g]{discdeps}{$cd} = {};
553            log_("prepare_cloned_discs: setting group $g as master of disc $cd\n", $config->{verbose}, $config->{LOG});
554            $config->{disc}[$cd]{group_master} = int $g;
555            push @{$group->[$g]{master_of_disc}}, $cd;
556           
557            foreach (@{$loc_conf->{data}{clone}}) {
558                $group->[$g]{disc_prereq}{$_->[1]{disc}}++
559            }
560            $done->{$cd} = {};
561            $g++
562            #   next
563            #}
564        }
565    }
566    $g
567}
568
569sub makeWithGroups {
570    my ($class, $lists, $acds) = @_;
571    my $config = $class->{config};
572    my $log = $config->{LOG};
573    my $metagroups = orderGroups($config, getGroups($config,$lists),$lists,$acds);
574
575    my (@discsFiles,@cdsize,%size,%graft,%done_deps, %inode);
576    for (my $i; $i < @{$config->{disc}}; $i++) { 
577        $cdsize[$i] = $config->{disc}[$i]{size}; 
578        $size{optimize_space}{disc}{$i} = $cdsize[$i]
579    }
580    foreach (@{$metagroups}) {
581        log_("makeWithGroups: Group listing $_ (@{$_->[1]} -- $_->[0])\n", $config->{verbose}, $config->{LOG})
582    }
583    foreach my $g (@{$metagroups}) {
584        my $cds = $g->[1];
585        my $groups = $g->[0];
586        print $log "Group: $g (@{$cds} -- $groups)\n";
587        # FIXME ordering metagroups can lead to empty groups with the -l option
588        $groups or next;
589
590        my (@buildlist, @rpmlist, @needed);
591        my (@groupok, @mkisos);
592        $class->{disc}->makeDiscs(0,$lists,$cds, \%size, \@mkisos, \@discsFiles, \%graft, \%inode);
593
594        for (my $i; $i < @$groups; $i++) {
595            log_("Get already built discs lists\n", $config->{verbose}, $config->{LOG});
596            $groups->[$i]{done} = {};
597            $class->{disc}->getBuiltDiscs($lists, $groups->[$i], \@discsFiles);
598           
599            log_("GROUP $i\n", $config->{verbose}, $config->{LOG});
600            getGroupReps($config, $groups->[$i], \@discsFiles);
601           
602            log_("genDeps\n", $config->{verbose}, $config->{LOG});
603            if (! $done_deps{$groups->[$i]{depsrep}} && ref $groups->[$i]{rep_pkg}{rpm}) {
604                $done_deps{$groups->[$i]{depsrep}} = genDeps("$config->{tmp}/$config->{name}/$groups->[$i]{depsrep}", $groups->[$i]{rep_pkg}{rpm}, $config->{deps}, $config->{verbose}, $config->{tmp}) or log_("ERROR: genDeps failed\n", $config->{verbose}, $config->{LOG}) and return 0
605            }
606            $groups->[$i]{urpm} = $done_deps{$groups->[$i]{depsrep}};
607
608            log_("getSize\n", $config->{verbose}, $config->{LOG});
609            my $redeps = getSize($groups->[$i],$config, $config->{verbose}) or log_("ERROR: getSize failed\n", $config->{verbose}, $config->{LOG}) and return 0;
610           
611            $class->{disc}->guessHdlistSize($groups->[$i], \%size, \@cdsize, $lists, \@discsFiles);
612
613            $groups->[$i]{revdeps} = $class->{list}->reverseDepslist($groups->[$i]);
614
615            ($groups->[$i]{filelist}, my $norpmsrate) = $class->{list}->getList($groups->[$i], \@discsFiles);
616
617            if ($groups->[$i]{rpmsratepath}) { 
618                my $outputdir = "$config->{tmp}/build/$config->{name}/$groups->[$i]{installDisc}/Mandrake/base/";
619                -d $outputdir or mkpath $outputdir;
620                my $output = "$outputdir/rpmsrate";
621                log_("cleanrpmsrate $groups->[$i]{rpmsratepath} -> $output\n", $config->{verbose}, $config->{LOG});
622                $groups->[$i]{rpmsrate} = cleanrpmsrate($groups->[$i]{rpmsratepath}, $output, $norpmsrate, $groups->[$i]{rep_pkg}{rpm}) or log_("ERROR: cleanrpmsrate failed\n", $config->{verbose}, $config->{LOG});
623                $groups->[$i]{options}{rpmsrate} = $output;
624            }
625
626            log_("build_list group $i\n", $config->{verbose}, $config->{LOG});
627            $rpmlist[$i] = $class->{list}->build_list($groups->[$i]) or return 0;
628
629            $class->{list}->scoreList($groups->[$i]) or return 0;
630            $class->{list}->autodeps($groups->[$i], $rpmlist[$i]);
631
632            foreach my $l (keys %{$rpmlist[$i]}) { 
633                my (@force, @need, @superforce, @limit, @b);
634                foreach (keys %{$rpmlist[$i]{$l}}) {
635                    if (!$_) {
636                        log_("ERROR: empty rpmlist key ($rpmlist[$i]{$l}{$_}) KEYS ", $config->{verbose}, $config->{LOG}), keys %{$rpmlist[$i]{$l}{$_}}, " \n";
637                        next
638                    }
639                    my $elt = [ $_, $rpmlist[$i]{$l}{$_}, $groups->[$i]{scorelist}{$_} ];
640                    if (!$config->{nodeps} && !$groups->[$i]{options}{nodeps} && !$groups->[$i]{nodeps}{$l} && /basesystem/) { 
641                        $elt->[1]{needed} = 1;
642                        push @superforce, $elt
643                    } elsif ($rpmlist[$i]{$l}{$_}{force}) { 
644                        $elt->[1]{needed} = 1;
645                        push @force, $elt
646                    } elsif ($rpmlist[$i]{$l}{$_}{limit}) {
647                        push @limit, $elt
648                    } else { 
649                        push @b, $elt
650                    }
651                    push @{$needed[$i]{$l}{alap}[$rpmlist[$i]{$l}{$_}{needed}]}, $elt, if $rpmlist[$i]{$l}{$_}{needed};
652                    # used to check which packages has beed rejected
653                    push @{$groups->[$i]{buildlist}}, $_
654                }
655                $buildlist[$i]{$l} = [sort { $a->[2] <=> $b->[2] } @b];
656                unshift @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @limit;
657                # needed must not be put first.
658                #push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @need;
659                push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @force;
660                push @{$buildlist[$i]{$l}}, sort { $a->[2] <=> $b->[2] } @superforce
661            }
662        }
663
664        # FIXME it must have a cleaner manner to keep buildlist and do not have
665        # to copy it.
666        my @cb;
667        for (my $i; $i < @buildlist; $i++) { 
668            foreach my $l (keys %{$buildlist[$i]}) { 
669                foreach (@{$buildlist[$i]{$l}}) { 
670                    log_("MakeWithGroups: copying buildlist group $i list $l package $_->[0] score $_->[2] options " . join(' ', keys %{$_->[1]}) . "\n", $config->{verbose}, $config->{LOG}, 4); 
671                    push @{$cb[$i]{$l}}, $_
672                }
673            }
674        }
675
676        my $diff = {};
677        my $rejected;
678        my $n=1;
679        $rejected = $class->{list}->buildDiscs($groups, \@cb, \@rpmlist, \@groupok, \%size, \@cdsize,$lists,$cds, \@needed,$diff,$n) if @cb;
680        my $logi;
681        my ($cd, $diff) = $class->{list}->processDiff($groups,$diff, \@discsFiles);
682        my $ok;
683        # discsFiles contains all the rpms, cd contains only the diff
684        $class->{disc}->makeDiscs(1,$lists,$cds, \%size, \@mkisos, \@discsFiles, \%graft, \%inode,$cd) or return 0;
685        $ok = $class->{disc}->checkSize($n, \%size, \@cdsize,$cds,$rejected);
686        #log_("makeWithGroups: disc_building_tries $config->{disc_building_tries}\n",1,$config->{LOG});
687        $ok = 1 if $config->{disc_building_tries} < 2;
688        while (!$ok) {
689            $n++;
690            log_("makeWithGroups: trying to adjust disc size, try $n\n", $config->{verbose}, $config->{LOG});
691            $ok = 1;
692            my @cb;
693            for (my $i; $i < @buildlist; $i++) { 
694                foreach my $l (keys %{$buildlist[$i]}) { 
695                    $cb[$i]{$l} = [];
696                    foreach (@{$buildlist[$i]{$l}}) {
697                        push @{$cb[$i]{$l}}, $_ if ($groups->[$i]{rejected}{$_->[0]})
698                    }
699                }
700            }
701            $rejected = $class->{list}->buildDiscs($groups, \@cb, \@rpmlist, \@groupok, \%size, \@cdsize,$lists,$cds, \@needed,$diff,$n) if @cb;
702            my ($cd, $diff) = $class->{list}->processDiff($groups,$diff,\@discsFiles);
703            $class->{disc}->makeDiscs($n,$lists,$cds, \%size, \@mkisos, \@discsFiles, \%graft, \%inode,$cd) or return 0;
704            $ok = $class->{disc}->checkSize($n, \%size, \@cdsize,$cds,$rejected);
705            !$ok and log_("ERROR: one or more disc are too big or too small, trying to correct\n", $config->{verbose}, $config->{LOG});
706            $n >= $config->{disc_building_tries} and log_("ERROR: could not manage to build discs of correct size, exiting\n", $config->{verbose}, $config->{LOG}) and last
707        }
708        # finally really build the ISOs
709        $class->{disc}->makeDiscs(-1,$lists,$cds, \%size, \@mkisos, \@discsFiles, \%graft, \%inode,$cd) or return 0;
710        for (my $i; $i < @$groups; $i++) {
711            foreach my $list (keys %{$groups->[$i]{list}}) {
712                foreach my $type (keys %{$groups->[$i]{list}{$list}}) {
713                    foreach (@{$groups->[$i]{list}{$list}{$type}}) {
714                        $config->{list}[$list]{disc}{$_->[0]}{$_->[1]}{done} = 1
715                    }
716                }
717            }   
718        }
719    }
720    printDiscsFile($config, \@discsFiles, $config->{print},$metagroups);
721    $config->{printscript} and printBatchFile($config, \@discsFiles, $config->{printscript});
722    1
723}
724
7251
726
727#
728# Changelog
729#
730# 2002 02 21
731# add maxlistmaxrep value to group
732#
733# 2002 03 03
734# change size to an hash that contains disc size and rep size
735#
736# 2002 03 09
737# make group{discrep} and hash not to have loop in disc dependencies when there are multiple repository on one CD
738#
739# 2002 03 14
740# BIG change of group source handling
741#
742# 2002 03 15
743# use new source handling
744#
745# 2002 03 23
746# change getAlone to be able to build generic CDs without installation
747#
748# 2002 06 16   
749# add conflict in group
750#
751# 2002 08 30
752# change reps structure, add pkg and pkg_rep in group
Note: See TracBrowser for help on using the repository browser.