| 3 |
use strict; |
use strict; |
| 4 |
use warnings; |
use warnings; |
| 5 |
use RPM2; |
use RPM2; |
| 6 |
|
use File::Find; |
| 7 |
|
use File::Basename; |
| 8 |
|
use Getopt::Std; |
| 9 |
use Data::Dumper; |
use Data::Dumper; |
| 10 |
|
|
| 11 |
sub compare($$); |
delete $ENV{PATH}; |
| 12 |
|
my $HOME=$ENV{HOME}; |
| 13 |
my $releases = 2; |
umask 002; |
| 14 |
|
$| = 1; |
| 15 |
my $rpm_flags = RPM2->vsf_nodsa; |
|
| 16 |
my $repodir = '/releases/7'; |
my %opts; |
| 17 |
my $stagedir = '/builds'; |
getopts( 'osqtr:', \%opts ); |
| 18 |
my @repos = qw( |
$opts{r} ||= ''; |
| 19 |
/releases/7/smeos/i386/CentOS/RPMS |
|
| 20 |
/releases/7/smeupdates/i386/RPMS |
my $rpm_flags = RPM2->vsf_nosha1header | RPM2->vsf_nomd5header | RPM2->vsf_nodsaheader | RPM2->vsf_norsaheader; |
| 21 |
/releases/7/smeupdates-testing/i386/RPMS |
$rpm_flags |= RPM2->vsf_nosha1 | RPM2->vsf_nomd5 | RPM2->vsf_nodsa | RPM2->vsf_norsa; |
| 22 |
/releases/7/smeextras/i386/RPMS |
|
| 23 |
/releases/7/smeaddons/i386/RPMS |
my @archs = ( 'i386', 'x86_64' ); |
| 24 |
/releases/7/smetest/i386/RPMS |
|
| 25 |
/releases/7/smedev/i386/RPMS |
my $distrepo = { '7' => { active => 1, |
| 26 |
/builds/rpms/RPMS/i386 |
centos => 4, |
| 27 |
/builds/rpms/RPMS/i586 |
fedora => 3, |
| 28 |
/builds/rpms/RPMS/i686 |
repo => '/releases/7/', |
| 29 |
/builds/rpms/RPMS/noarch |
os => 'RPMS/', |
| 30 |
/builds/RPMS |
builds => '/builds/smeserver-7-core/', |
| 31 |
); |
contribs => '/builds/smeserver-7-contribs/', |
| 32 |
my $devrepo = (grep { m{/sme} } reverse @repos)[0]; |
stage => '/stage/7/', |
| 33 |
|
}, |
| 34 |
my @srcrepos = qw( |
'8' => { active => 1, |
| 35 |
/mirrors/centos/4/fasttrack/SRPMS |
centos => 5, |
| 36 |
/mirrors/centos/4/updates/SRPMS |
fedora => 6, |
| 37 |
/mirrors/centos/4/os/SRPMS |
repo => '/releases/testing/8/', |
| 38 |
/mirrors/centos/4/extras/SRPMS |
os => '', |
| 39 |
/mirrors/rpmforge/dag/source |
builds => '/builds/smeserver-8-core/', |
| 40 |
/mirrors/atrpms/src/el4-i386/atrpms/stable |
contribs => '/builds/smeserver-8-contribs/', |
| 41 |
/builds/rpms/SRPMS |
stage => '/stage/8/', |
| 42 |
); |
}, |
| 43 |
|
}; |
| 44 |
my %repohash; |
|
| 45 |
my %srcrepohash; |
my $repos = { 'smeos' => { prio => 18, inc => 1, ver => 1, rel => 1, os => 1 }, |
| 46 |
my %changed; |
'smeupdates' => { prio => 17, inc => 1, ver => 1, rel => 1 }, |
| 47 |
my %copy; |
'smeupdates-testing' => { prio => 16, inc => 1, ver => 1, rel => 1 }, |
| 48 |
my @remove; |
'smeextras' => { prio => 15, inc => 0, ver => 1, rel => 1 }, |
| 49 |
|
'smeaddons' => { prio => 14, inc => 0, ver => 1, rel => 1 }, |
| 50 |
%{$srcrepohash{$stagedir}} = map { $_ => 0 } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, "$stagedir/SRPMS" ); |
'smecontribs' => { prio => 13, inc => 0, ver => 1, rel => 1 }, |
| 51 |
closedir SRPMS; |
'smetest' => { prio => 12, inc => 0, ver => 2, rel => 2, devel => 2 }, |
| 52 |
|
'smedev' => { prio => 11, inc => 0, ver => 2, rel => 2, devel => 1 }, |
| 53 |
print "\n"; |
'centos' => { prio => 10, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 54 |
foreach my $repo ( @repos ) { |
'epel' => { prio => 9, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 55 |
if ( $repo =~ m{^(.*/[0-9]+/sme[^/]*)/} ) { |
'fedora-extras' => { prio => 8, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 56 |
my $srcrepo = $1; |
'rpmforge' => { prio => 7, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 57 |
|
'atrpms' => { prio => 6, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 58 |
%{$srcrepohash{$srcrepo}} = map { $_ => 0 } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, "$srcrepo/SRPMS" ); |
'fedora' => { prio => 5, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 59 |
closedir SRPMS; |
'builds' => { prio => 4, inc => 0, ver => 0, rel => 0, orig => 1 }, |
| 60 |
} |
'contribs' => { prio => 2, inc => 0, ver => 0, rel => 0, orig => 1 }, |
| 61 |
|
'stage' => { prio => 1, inc => 0, ver => 0, rel => 0, stage => 1, os => 1 }, |
| 62 |
opendir RPMS, $repo; |
}; |
| 63 |
foreach my $rpm ( grep { m{\.rpm} } readdir RPMS ) { |
|
| 64 |
my $header = RPM2->open_package("$repo/$rpm", $rpm_flags); |
my $baserepo = { '~Ssmeos/~A/SME/~O' => 'smeos', |
| 65 |
my $pkg = $header->tag("NAME").".".$header->tag("ARCH"); |
'~Ssmeupdates/~A/RPMS/' => 'smeupdates', |
| 66 |
if ( $repo =~ m{/builds/RPMS} ) { |
'~Ssmeupdates-testing/~A/RPMS/' => 'smeupdates-testing', |
| 67 |
push @{$repohash{$pkg}{$stagedir}}, $header; |
'~Ssmeextras/~A/RPMS/' => 'smeextras', |
| 68 |
} elsif ( $repo =~ m{/builds/} ) { |
'~Ssmeaddons/~A/RPMS/' => 'smeaddons', |
| 69 |
push @{$repohash{$pkg}{builds}}, $header; |
'~Ssmecontribs/~A/RPMS/' => 'smecontribs', |
| 70 |
} elsif ( $repo =~ m{^(.*/[0-9]+/sme[^/]*)/} ) { |
'~Ssmetest/~A/RPMS/' => 'smetest', |
| 71 |
my $pos = $1; |
'~Ssmedev/~A/RPMS/' => 'smedev', |
| 72 |
push @{$repohash{$pkg}{$pos}}, $header; |
'/stage/~s/~A/SME/~O' => 'stage', |
| 73 |
} |
'/mirrors/centos/~C/fasttrack/~A/RPMS/' => 'centos', |
| 74 |
} |
'/mirrors/centos/~C/updates/~A/RPMS/' => 'centos', |
| 75 |
closedir RPMS; |
'/mirrors/centos/~C/os/~A/CentOS/~O' => 'centos', |
| 76 |
|
'/mirrors/centos/~C/extras/~A/RPMS/' => 'centos', |
| 77 |
|
'/mirrors/fedora/epel/~C/~A/' => 'epel', |
| 78 |
|
'/mirrors/fedora/epel/testing/~C/~A/' => 'epel', |
| 79 |
|
'/mirrors/fedora/extras/~F/~A/' => 'fedora-extras', |
| 80 |
|
'/mirrors/rpmforge/dag/redhat/el~C/en/~A/dag/RPMS/' => 'rpmforge', |
| 81 |
|
'/mirrors/rpmforge/dag/source/' => 'rpmforge', |
| 82 |
|
'/mirrors/atrpms/el~C-~A/atrpms/stable/' => 'atrpms', |
| 83 |
|
'/mirrors/atrpms/el~C-~A/atrpms/testing/' => 'atrpms', |
| 84 |
|
'/mirrors/atrpms/src/el~C-~A/atrpms/stable/' => 'atrpms', |
| 85 |
|
'/mirrors/atrpms/src/el~C-~A/atrpms/testing/' => 'atrpms', |
| 86 |
|
'/mirrors/fedora/core/~F/~A/os/Fedora/RPMS/' => 'fedora', |
| 87 |
|
'/mirrors/fedora/core/updates/~F/~A/' => 'fedora', |
| 88 |
|
}; |
| 89 |
|
|
| 90 |
|
if ( $opts{q} ) { |
| 91 |
|
$baserepo->{'/mirrors/centos-qa/CentOS/~C/fasttrack/~A/RPMS/'} = 'centos'; |
| 92 |
|
$baserepo->{'/mirrors/centos-qa/CentOS/~C/updates/~A/RPMS/'} = 'centos'; |
| 93 |
|
$baserepo->{'/mirrors/centos-qa/CentOS/~C/os/~A/CentOS/~O'} = 'centos'; |
| 94 |
|
$baserepo->{'/mirrors/centos-qa/CentOS/~C/extras/~A/RPMS/'} = 'centos'; |
| 95 |
} |
} |
| 96 |
|
|
| 97 |
my %sources; |
my $skippkg = { '7' => { 'centos' => { map { $_ => 1 } ( 'horde', 'imp-h3', 'ingo-h3', 'turba-h3', 'vim' ) }, |
| 98 |
foreach my $repo ( reverse @srcrepos ) { |
'epel' => { map { $_ => 1 } ( 'clamav', 'perl-Razor-Agent' ) }, |
| 99 |
my %temp_repo = map { $_ => $repo } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, $repo ); |
'rpmforge' => { map { $_ => 1 } ( 'perl-Test-Inline' ) }, |
| 100 |
closedir SRPMS; |
'atrpms' => { map { $_ => 1 } ( 'dovecot', 'trac', 'yum' ) }, |
| 101 |
|
}, |
| 102 |
%sources = (%sources, %temp_repo); |
'8' => { 'centos' => { map { $_ => 1 } ( 'horde', 'imp-h3', 'ingo-h3', 'turba-h3' ) }, |
| 103 |
} |
'fedora' => { map { $_ => 1 } ( 'kernel-xen' ) }, |
| 104 |
|
'epel' => { map { $_ => 1 } ( 'clamav', 'perl-Razor-Agent', 'smolt' ) }, |
| 105 |
|
'fedora-extras' => { map { $_ => 1 } ( 'dstat', 'gocr', 'horde', 'oidentd', 'perl-Test-Inline', 'perl-Razor-Agent', 'smolt' ) }, |
| 106 |
|
'rpmforge' => { map { $_ => 1 } ( 'perl-Test-Inline' ) }, |
| 107 |
|
}, |
| 108 |
|
}; |
| 109 |
|
|
| 110 |
|
my ($stage) = sort { $repos->{$a}->{stage} <=> $repos->{$b}->{stage} } grep { $repos->{$_}->{stage} } keys %$repos; |
| 111 |
|
my ($devel1, $devel2) = sort { $repos->{$a}->{devel} <=> $repos->{$b}->{devel} } grep { $repos->{$_}->{devel} } keys %$repos; |
| 112 |
|
$devel2 ||= $devel1; |
| 113 |
|
|
| 114 |
|
my ($rpms, %base, %latest, %sources); |
| 115 |
|
foreach my $smever ( sort { $a <=> $b } keys %$distrepo ) { |
| 116 |
|
next unless $distrepo->{$smever}->{active}; |
| 117 |
|
my %repochg = (); |
| 118 |
|
$rpms = (); |
| 119 |
|
%latest = (); |
| 120 |
|
%sources = (); |
| 121 |
|
%base = (); |
| 122 |
|
|
| 123 |
|
foreach my $dir ( sort { $repos->{$baserepo->{$b}}->{prio} <=> $repos->{$baserepo->{$a}}->{prio} || $a cmp $b } keys %$baserepo ) { |
| 124 |
|
my $bdir = $dir; |
| 125 |
|
$bdir =~ s/~O/$distrepo->{$smever}->{os}/; |
| 126 |
|
$bdir =~ s/~S/$distrepo->{$smever}->{repo}/; |
| 127 |
|
$bdir =~ s/~s/$smever/; |
| 128 |
|
$bdir =~ s/~C/$distrepo->{$smever}->{centos}/; |
| 129 |
|
$bdir =~ s/~F/$distrepo->{$smever}->{fedora}/; |
| 130 |
|
for my $arch ( @archs, 'SRPMS/' ) { |
| 131 |
|
my $adir = $bdir; |
| 132 |
|
if ( $arch eq 'SRPMS/' ) { |
| 133 |
|
$adir =~ s/~A.*/$arch/ if $arch eq 'SRPMS/'; |
| 134 |
|
} else { |
| 135 |
|
$adir =~ s/~A/$arch/; |
| 136 |
|
} |
| 137 |
|
opendir DIR, $adir or next; |
| 138 |
|
next unless -d $adir; |
| 139 |
|
process_rpm("$adir$_", $smever, $baserepo->{$dir}) foreach readdir DIR; |
| 140 |
|
closedir DIR; |
| 141 |
|
last unless $dir =~ m{~A}; |
| 142 |
|
} |
| 143 |
|
} |
| 144 |
|
find( { wanted => sub { process_rpm($_, $smever, 'builds'); }, no_chdir => 1, follow_fast => 1 }, $distrepo->{$smever}->{'builds'} ); |
| 145 |
|
find( { wanted => sub { process_rpm($_, $smever, 'contribs'); }, no_chdir => 1, follow_fast => 1 }, $distrepo->{$smever}->{'contribs'} ); |
| 146 |
|
|
| 147 |
|
foreach my $base ( sort keys %$rpms ) { |
| 148 |
|
next unless $rpms->{$base}->{rpms}; |
| 149 |
|
my %track = (); |
| 150 |
|
my %seen = (); |
| 151 |
|
my %counts = (); |
| 152 |
|
my $acnt = (); |
| 153 |
|
my $print = 0; |
| 154 |
|
%latest = (); |
| 155 |
|
|
| 156 |
|
foreach my $pkg ( sort { $b->{rpm} cmp $a->{rpm} } @{$rpms->{$base}->{rpms}} ) { |
| 157 |
|
next if $pkg->{done}; |
| 158 |
|
|
| 159 |
|
my $tmp = $pkg->{svr}; |
| 160 |
|
SRC: { |
| 161 |
|
$rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 162 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d\.at$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 163 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d\.at$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 164 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d(\.rf)$}{$1} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 165 |
|
($tmp = $pkg->{svr}) =~ s{(\d+)\.\d+\.el\d(\.rf)$}{$1$2} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 166 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d\.rf$}{.dag} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 167 |
|
($tmp = $pkg->{svr}) =~ s{(\d+)\.\d+\.el\d\.rf$}{$1.dag} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 168 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 169 |
|
($tmp = $pkg->{svr}) =~ s{(-\d+)\.\d+\.el\d$}{$1} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 170 |
|
($tmp = $pkg->{svr}) =~ s{\.centos\d$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 171 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d\.sme$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 172 |
|
} |
| 173 |
|
if ( $rpms->{$base}->{vers}->{$tmp} ) { |
| 174 |
|
foreach $tmp ( @{$rpms->{$base}->{vers}->{$tmp}} ) { |
| 175 |
|
$tmp->{svr} = $pkg->{svr}; |
| 176 |
|
push @{$rpms->{$base}->{rpms}}, $tmp unless $tmp->{added}; |
| 177 |
|
$tmp->{added}++; |
| 178 |
|
} |
| 179 |
|
} |
| 180 |
|
|
| 181 |
foreach my $pkg ( keys %repohash ) { |
my %orig = (); |
| 182 |
foreach my $repo ( @repos ) { |
my %pkgs = (); |
| 183 |
if ( $repo =~ m{/builds/RPMS} ) { |
my %reposrc = (); |
| 184 |
next unless $repohash{$pkg}{latest} || $repohash{$pkg}{$stagedir}; |
my $srpm = undef; |
| 185 |
my ($latest, @rest) = sort { $b cmp $a } @{$repohash{$pkg}{$stagedir}}; |
foreach my $cmp ( sort { $a->{src} <=> $b->{src} || $repos->{$b->{repo}}->{prio} <=> $repos->{$a->{repo}}->{prio} } @{$rpms->{$base}->{rpms}} ) { |
| 186 |
delete $repohash{$pkg}{$stagedir}; |
next unless $cmp->{svr} eq $pkg->{svr}; |
| 187 |
push @remove, map { $_->filename } @rest if @rest; |
|
| 188 |
if ( $repohash{$pkg}{latest} ) { |
if ( ! $track{repo} || $repos->{$cmp->{repo}}->{prio} > $repos->{$track{repo}}->{prio} ) { |
| 189 |
if ($repohash{$pkg}{latest} ne $latest ) { |
if ( $cmp->{src} ) { |
| 190 |
push @remove, $latest->filename; |
if ( ! $track{repo} ) { |
| 191 |
push @{$copy{"$stagedir/RPMS"}}, $repohash{$pkg}{latest}->filename; |
$cmp->{delete}++; |
| 192 |
$repohash{$pkg}{$stagedir} = $repohash{$pkg}{latest}; |
$cmp->{done}++; |
| 193 |
|
next; |
| 194 |
|
} |
| 195 |
|
} else { |
| 196 |
|
$track{repo} = $cmp->{repo}; |
| 197 |
|
$track{svr} = $cmp->{svr}; |
| 198 |
|
} |
| 199 |
|
} |
| 200 |
|
if ( $cmp->{svr} eq $track{svr} ) { |
| 201 |
|
if ( $seen{$cmp->{nvra}} ) { |
| 202 |
|
if ( $track{repo} ne $cmp->{repo} ) { |
| 203 |
|
if ($repos->{$cmp->{repo}}->{stage} ) { |
| 204 |
|
if ( $seen{$cmp->{nvra}}->{latest} ) { |
| 205 |
|
$seen{$cmp->{nvra}}->{latest}++; |
| 206 |
} else { |
} else { |
| 207 |
$repohash{$pkg}{$stagedir} = $latest; |
$cmp->{delete}++; |
| 208 |
} |
} |
| 209 |
} else { |
} elsif ( $repos->{$cmp->{repo}}->{orig}) { |
| 210 |
push @remove, $latest->filename; |
$orig{$cmp->{nvra}}++; |
| 211 |
|
} elsif ( $cmp->{src} && $reposrc{$cmp->{repo}} ) { |
| 212 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp; |
| 213 |
|
} elsif ( $seen{$cmp->{nvra}}->{repo} ne $cmp->{repo} ) { |
| 214 |
|
$cmp->{delete}++; |
| 215 |
|
} |
| 216 |
} |
} |
| 217 |
} elsif ( $repo =~ m{^(.*/[0-9]+/sme[^/]*)/} ) { |
} elsif ($repos->{$cmp->{repo}}->{stage} ) { |
| 218 |
my $pos = $1; |
$cmp->{delete}++; |
| 219 |
next unless $repohash{$pkg}{$pos}; |
} else { |
| 220 |
if ( $pos =~ m{/smedev$} ) { |
$srpm = $cmp if ! $srpm && $cmp->{src}; |
| 221 |
next unless $repohash{$pkg}{latest}; |
my $dest = $repos->{$track{repo}}->{prio} > $repos->{$devel2}->{prio} ? $track{repo} : $devel2; |
| 222 |
my @rest = grep { $_ le $repohash{$pkg}{latest} } @{$repohash{$pkg}{$pos}}; |
$dest = pkgdest($cmp, $devel1, $dest, $rpms->{$base}->{rpms}); |
| 223 |
if ( @rest ) { |
$dest = $devel1 if verrel($cmp, $dest, \%counts); |
| 224 |
push @remove, map { $_->filename } @rest; |
if ( $cmp->{repo} ne $dest ) { |
| 225 |
$changed{$pos}++; |
push @{$cmp->{repos}}, $dest; |
| 226 |
@{$repohash{$pkg}{$pos}} = grep { $_ gt $repohash{$pkg}{latest} } @{$repohash{$pkg}{$pos}}; |
if ( $repos->{$cmp->{repo}}->{orig} ) { |
| 227 |
delete $repohash{$pkg}{$pos}; |
$orig{$cmp->{nvra}}++; |
| 228 |
} |
} elsif ( $cmp->{src} && $reposrc{$cmp->{repo}} ) { |
| 229 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp; |
| 230 |
|
} else { |
| 231 |
|
$cmp->{delete}++; |
| 232 |
|
} |
| 233 |
|
$cmp->{oldrepo} = $cmp->{repo} unless $cmp->{oldrepo}; |
| 234 |
|
$cmp->{repo} = $dest; |
| 235 |
|
$track{repo} = $dest unless $dest eq $track{repo}; |
| 236 |
|
} |
| 237 |
|
if ( $cmp->{src} && $reposrc{$cmp->{repo}} ) { |
| 238 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp; |
| 239 |
|
} |
| 240 |
|
} |
| 241 |
|
} else { |
| 242 |
|
if ( $track{repo} eq $cmp->{repo} ) { |
| 243 |
|
if ( verrel($cmp, $cmp->{repo}, \%counts) ) { |
| 244 |
|
$cmp->{delete}++ unless $repos->{$cmp->{repo}}->{base}; |
| 245 |
|
} elsif ( $cmp->{src} ) { |
| 246 |
|
$cmp->{delete}++ unless $repos->{$cmp->{repo}}->{base}; |
| 247 |
} else { |
} else { |
| 248 |
my ($latest, @rest) = sort { $b cmp $a } @{$repohash{$pkg}{$pos}}; |
$track{svr} = $cmp->{svr}; |
| 249 |
delete $repohash{$pkg}{$pos}; |
} |
| 250 |
if ( $repohash{$pkg}{latest} && $repohash{$pkg}{latest} ge $latest ) { |
} elsif ( ! $repos->{$cmp->{repo}}->{base} ) { |
| 251 |
push @rest, $latest; |
if ( $repos->{$cmp->{repo}}->{orig} ) { |
| 252 |
|
$srpm = $cmp if ! $srpm && $cmp->{src}; |
| 253 |
|
my $dest = $repos->{$track{repo}}->{prio} > $repos->{$devel2}->{prio} ? $track{repo} : $devel2; |
| 254 |
|
$dest = pkgdest($cmp, $devel1, $dest, $rpms->{$base}->{rpms}); |
| 255 |
|
$dest = $devel1 if verrel($cmp, $dest, \%counts); |
| 256 |
|
unless ( verrel($cmp, $dest, \%counts) ) { |
| 257 |
|
push @{$cmp->{repos}}, $dest; |
| 258 |
|
if ( $repos->{$cmp->{repo}}->{orig} ) { |
| 259 |
|
$orig{$cmp->{nvra}}++; |
| 260 |
|
} elsif ( $cmp->{src} && $reposrc{$cmp->{repo}} ) { |
| 261 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp; |
| 262 |
} else { |
} else { |
| 263 |
$repohash{$pkg}{latest} = $latest; |
$cmp->{delete}++; |
|
$repohash{$pkg}{$pos} = $latest; |
|
| 264 |
} |
} |
| 265 |
if ( @rest ) { |
$cmp->{oldrepo} = $cmp->{repo} unless $cmp->{oldrepo}; |
| 266 |
push @remove, map { $_->filename } @rest; |
$cmp->{repo} = $dest; |
| 267 |
$changed{$pos}++; |
if ( $cmp->{src} && $reposrc{$cmp->{repo}} ) { |
| 268 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp; |
| 269 |
} |
} |
| 270 |
|
} else { |
| 271 |
|
$cmp->{delete}++; |
| 272 |
|
} |
| 273 |
|
} else { |
| 274 |
|
$cmp->{delete}++; |
| 275 |
} |
} |
| 276 |
|
} |
| 277 |
|
} |
| 278 |
|
unless ( $repos->{$cmp->{repo}}->{orig} || ( $cmp->{delete} && ! $cmp->{repos} ) ) { |
| 279 |
|
$pkgs{$cmp->{nvra}}++; |
| 280 |
|
$latest{$cmp->{base}} = $cmp->{svr} if $repos->{$cmp->{repo}}->{inc} && ! $latest{$cmp->{base}}; |
| 281 |
|
$reposrc{$cmp->{repo}} = $cmp unless $reposrc{$cmp->{repo}} || $cmp->{src} || $repos->{$cmp->{repo}}->{stage}; |
| 282 |
|
unless ( $seen{$cmp->{nvra}} ) { |
| 283 |
|
$seen{$cmp->{nvra}} = $cmp; |
| 284 |
|
$cmp->{latest}++ if $latest{$cmp->{base}} && $cmp->{svr} eq $latest{$cmp->{base}} && $repos->{$cmp->{repo}}->{inc}; |
| 285 |
|
} |
| 286 |
|
push @{$acnt->{$cmp->{repo}}->{$cmp->{rpm}->as_nvre}->{$cmp->{src} ? 'src' : $cmp->{rpm}->arch}}, $cmp; |
| 287 |
} |
} |
| 288 |
|
$cmp->{done}++; |
| 289 |
|
} |
| 290 |
|
if ( $srpm ) { |
| 291 |
|
foreach my $r ( sort { $repos->{$b}->{prio} <=> $repos->{$a}->{prio} } keys %reposrc ) { |
| 292 |
|
unless ( $reposrc{$r}->{srpm} ) { |
| 293 |
|
unshift @{$srpm->{repos}}, $r; |
| 294 |
|
$srpm->{oldrepo} = $srpm->{repo} unless $srpm->{oldrepo}; |
| 295 |
|
$srpm->{repo} = $r; |
| 296 |
|
$reposrc{$r}->{srpm} = $srpm; |
| 297 |
|
} |
| 298 |
|
} |
| 299 |
|
} elsif ( scalar keys %pkgs && $opts{s} ) { |
| 300 |
|
print "\n * missing source (sme$smever, ", $pkg->{repo}, ", ", $pkg->{svr}, ")\n"; |
| 301 |
|
} |
| 302 |
|
print "\n * missing originals (sme$smever, ", $pkg->{repo}, ", ", $pkg->{svr}, ")\n" if $opts{o} && scalar keys %orig != scalar keys %pkgs; |
| 303 |
} |
} |
|
} |
|
| 304 |
|
|
| 305 |
foreach my $pkg ( sort grep { $repohash{$_}{builds} } keys %repohash ) { |
foreach my $r ( keys %$acnt ) { |
| 306 |
my %versions = (); |
foreach my $p ( keys %{$acnt->{$r}} ) { |
| 307 |
foreach my $ver ( sort { $b cmp $a } @{$repohash{$pkg}{builds}} ) { |
foreach my $a ( keys %{$acnt->{$r}->{$p}} ) { |
| 308 |
next if $repohash{$pkg}{latest} && $repohash{$pkg}{latest} ge $ver; |
if ( $a eq 'noarch' ) { |
| 309 |
|
my $p2 = ${$acnt->{$r}->{$p}->{$a}}[0]; |
| 310 |
$versions{$ver->tag("VERSION")}++; |
if ( ! $p2->{repos} && scalar @{$acnt->{$r}->{$p}->{$a}} != scalar @archs ) { |
| 311 |
if ( $versions{$ver->tag("VERSION")} > $releases || (scalar keys %versions) > $releases ) { |
$p2->{oldrepo} = $p2->{repo}; |
| 312 |
foreach my $rpm ( grep { $ver eq $_ } @{$repohash{$pkg}{"$repodir/smedev"}} ) { |
push @{$p2->{repos}}, $p2->{repo}; |
|
push @remove, $rpm->filename; |
|
|
@{$repohash{$pkg}{"$repodir/smedev"}} = grep { $rpm ne $_ } @{$repohash{$pkg}{"$repodir/smedev"}}; |
|
|
$changed{"$repodir/smedev"}++; |
|
|
} |
|
|
} else { |
|
|
print "Possible update " . $ver->filename . "\n" if $repohash{$pkg}{latest}; |
|
|
if ( ! grep { $ver eq $_ } @{$repohash{$pkg}{"$repodir/smedev"}} ) { |
|
|
push @{$copy{$devrepo}}, $ver->filename; |
|
|
push @{$repohash{$pkg}{"$repodir/smedev"}}, $ver; |
|
|
$changed{"$repodir/smedev"}++; |
|
| 313 |
} |
} |
| 314 |
|
} elsif ( scalar @{$acnt->{$r}->{$p}->{$a}} != 1 ) { |
| 315 |
|
print "\n * many packages ($r, $a, $p)\n"; |
| 316 |
|
} |
| 317 |
} |
} |
| 318 |
|
} |
| 319 |
} |
} |
|
} |
|
| 320 |
|
|
| 321 |
foreach my $pkg ( grep { $repohash{$_}{"$repodir/smedev"} } keys %repohash ) { |
foreach my $pkg ( sort { $a->{nvra} cmp $b->{nvra} } @{$rpms->{$base}->{rpms}} ) { |
| 322 |
foreach my $rpm ( @{$repohash{$pkg}{"$repodir/smedev"}} ) { |
if ( $pkg->{latest} && $pkg->{latest} == 1 ) { |
| 323 |
unless ( grep { $rpm eq $_ } @{$repohash{$pkg}{builds}} ) { |
$pkg->{oldrepo} = $pkg->{repo} unless $pkg->{oldrepo}; |
| 324 |
push @remove, $rpm->filename; |
$pkg->{repo} = $stage; |
| 325 |
@{$repohash{$pkg}{"$repodir/smedev"}} = grep { $rpm ne $_ } @{$repohash{$pkg}{"$repodir/smedev"}}; |
push @{$pkg->{repos}}, $stage; |
| 326 |
$changed{"$repodir/smedev"}++; |
} |
| 327 |
|
if ( ! $print && ($pkg->{delete} || $pkg->{repos} || $pkg->{nosig} ) ) { |
| 328 |
|
print "\n$base (sme$smever)\n", "=" x length("$base (sme$smever)"), "\n"; |
| 329 |
|
$print++; |
| 330 |
|
} |
| 331 |
|
|
| 332 |
|
my $src = $pkg->{rpm}->filename; |
| 333 |
|
if ( $pkg->{nosig} ) { |
| 334 |
|
print "sign package (", basename($pkg->{rpm}->filename), ")\n"; |
| 335 |
|
unless ( $opts{t} ) { |
| 336 |
|
qx(cat $HOME/.rpmpass | setsid rpm --addsign $src >& /dev/null); |
| 337 |
|
if ($?) { |
| 338 |
|
print " * failed to sign package\n"; |
| 339 |
|
next; |
| 340 |
|
} |
| 341 |
} |
} |
| 342 |
} |
} |
| 343 |
} |
|
| 344 |
|
if ( $pkg->{repos} ) { |
| 345 |
|
foreach my $repo ( @{$pkg->{repos}} ) { |
| 346 |
|
if ( $pkg->{delete} ) { |
| 347 |
|
print "move from ", $pkg->{oldrepo}, " to $repo (", basename($pkg->{rpm}->filename), ")\n"; |
| 348 |
|
$pkg->{delete} = 0; |
| 349 |
|
$repochg{$pkg->{oldrepo}}++ unless $repos->{$pkg->{oldrepo}}->{base} || $repos->{$pkg->{oldrepo}}->{stage}; |
| 350 |
|
} elsif ( $pkg->{oldrepo} eq $repo ) { |
| 351 |
|
print "distribute noarch in $repo (", basename($pkg->{rpm}->filename), ")\n"; |
| 352 |
|
} else { |
| 353 |
|
print "copy from ", $pkg->{oldrepo}, " to $repo (", basename($pkg->{rpm}->filename), ")\n"; |
| 354 |
|
} |
| 355 |
|
$repochg{$repo}++ unless $repos->{$repo}->{base} || $repos->{$repo}->{stage}; |
| 356 |
|
$pkg->{oldrepo} = $repo unless $pkg->{oldrepo} eq ${$pkg->{repos}}[0]; |
| 357 |
|
|
| 358 |
|
my @d = (); |
| 359 |
|
my $head = $distrepo->{$smever}->{repo} . $repo . '/'; |
| 360 |
|
$head = $distrepo->{$smever}->{stage} if $repos->{$repo}->{stage}; |
| 361 |
|
my $tail = $repos->{$repo}->{os} ? 'SME/' . $distrepo->{$smever}->{os} : 'RPMS/'; |
| 362 |
|
if ( $pkg->{src} ) { |
| 363 |
|
push @d, "${head}SRPMS/" . basename($pkg->{rpm}->filename); |
| 364 |
|
} elsif ( $pkg->{rpm}->arch eq 'noarch' ) { |
| 365 |
|
push @d, map { "${head}$_/$tail" . basename($pkg->{rpm}->filename) } @archs; |
| 366 |
|
} elsif ( $pkg->{rpm}->arch =~ m{^(i[356]86)$} ) { |
| 367 |
|
push @d, "${head}i386/$tail" . basename($pkg->{rpm}->filename); |
| 368 |
|
} else { |
| 369 |
|
push @d, $head . $pkg->{rpm}->arch . "/$tail" . basename($pkg->{rpm}->filename); |
| 370 |
|
} |
| 371 |
|
foreach my $dest ( @d ) { |
| 372 |
|
qx(cp --preserve=timestamps $src $dest) unless $opts{t} || -f "$dest"; |
| 373 |
|
} |
| 374 |
|
|
|
print "\n"; |
|
|
foreach my $repo ( sort keys %srcrepohash ) { |
|
|
foreach my $pkg ( sort grep { $repohash{$_}{$repo} } keys %repohash ) { |
|
|
my @rpms = ref($repohash{$pkg}{$repo}) eq "ARRAY" ? @{$repohash{$pkg}{$repo}} : ($repohash{$pkg}{$repo}); |
|
|
foreach my $rpm ( sort @rpms ) { |
|
|
my $src = $rpm->tag("SOURCERPM"); |
|
|
|
|
|
my @sources = (); |
|
|
push @sources, $src; |
|
|
push @sources, $src if ($src =~ s/\.2\.el4\.rf\./\.rf\./); |
|
|
push @sources, $src if ($src =~ s/\.el4\.rf\./\.rf\./); |
|
|
push @sources, $src if ($src =~ s/\.el4\.at\./\.at\./); |
|
|
push @sources, $src if ($src =~ s/\.rf\./\.dag\./); |
|
|
|
|
|
my $found = 0; |
|
|
foreach my $source ( @sources ) { |
|
|
if ( $sources{$source} ) { |
|
|
unless ( -f "$repo/SRPMS/$source" ) { |
|
|
push @{$copy{"$repo/SRPMS"}}, "$sources{$source}/$source"; |
|
|
$changed{$repo}++; |
|
|
} |
|
|
$srcrepohash{$repo}{$source}++; |
|
|
$found++; |
|
|
last; |
|
|
} elsif ( -f "$repo/SRPMS/$source" ) { |
|
|
print "Found missing source $repo/SRPMS/$source for ".$rpm->as_nvre()."\n"; |
|
|
$srcrepohash{$repo}{$source}++; |
|
|
$found++; |
|
|
} |
|
|
} |
|
|
print "Can't find source for ".$rpm->as_nvre()."\n" unless $found; |
|
| 375 |
} |
} |
| 376 |
|
qx(rm -f $src) if exists $pkg->{delete} && ! $opts{t}; |
| 377 |
|
} elsif ( $pkg->{delete} ) { |
| 378 |
|
print "delete from ", $pkg->{repo}, " (", $pkg->{arch}, ", ", basename($pkg->{rpm}->filename), ")\n"; |
| 379 |
|
qx(rm -f $src) unless $opts{t}; |
| 380 |
|
$repochg{$pkg->{repo}}++ unless $repos->{$pkg->{repo}}->{base} || $repos->{$pkg->{repo}}->{stage}; |
| 381 |
|
} |
| 382 |
} |
} |
| 383 |
|
} |
| 384 |
|
|
| 385 |
foreach my $rpm ( keys %{$srcrepohash{$repo}} ) { |
if ( %repochg ) { |
| 386 |
unless ( $srcrepohash{$repo}{$rpm} ) { |
print "\nrebuild repo (sme$smever)\n", "=" x length("rebuild repo (sme$smever)"), "\n"; |
| 387 |
push @remove, "$repo/SRPMS/$rpm"; |
} |
| 388 |
$changed{$repo}++; |
foreach my $repo ( sort { $repos->{$b}->{prio} <=> $repos->{$a}->{prio} } keys %repochg ) { |
| 389 |
|
next if $repos->{$repo}->{orig} || $repos->{$repo}->{stage}; |
| 390 |
|
foreach my $arch ( @archs ) { |
| 391 |
|
my $dir = $distrepo->{$smever}->{repo} . "$repo/$arch"; |
| 392 |
|
$dir = qx(readlink -f $dir); |
| 393 |
|
chomp $dir; |
| 394 |
|
print "rebuild $repo/$arch\n"; |
| 395 |
|
unless ( $opts{t} ) { |
| 396 |
|
if ( -f "$dir/repodata/comps.xml" ) { |
| 397 |
|
qx(createrepo -g repodata/comps.xml $dir); |
| 398 |
|
} else { |
| 399 |
|
qx(createrepo $dir); |
| 400 |
} |
} |
| 401 |
|
qx(repoview $dir); |
| 402 |
|
qx(rm -rf $dir/.olddata) if -d "$dir/.olddata"; |
| 403 |
|
qx(rm -rf $dir/.repodata) if -d "$dir/.repodata"; |
| 404 |
|
} |
| 405 |
} |
} |
| 406 |
|
} |
| 407 |
|
unless ( $opts{t} ) { |
| 408 |
|
finddepth(sub{rmdir}, $distrepo->{$smever}->{$_}) foreach ('builds','contribs'); |
| 409 |
|
} |
| 410 |
} |
} |
| 411 |
|
|
| 412 |
print "\n"; |
sub verrel { |
| 413 |
foreach my $repo ( sort keys %copy ) { |
my $pkg = shift; |
| 414 |
foreach my $rpm ( sort keys %{{ map { $_ => 1 } @{$copy{$repo}} }} ) { |
my $repo = shift; |
| 415 |
print "copying $rpm to $repo/\n"; |
my $counts = shift; |
| 416 |
system(qw(cp --preserve=timestamps), $rpm, "$repo/"); |
|
| 417 |
} |
return 0 if $pkg->{src}; |
| 418 |
|
$counts->{$repo}->{$pkg->{ver}}->{$pkg->{rel}}++; |
| 419 |
|
return 1 if $repos->{$repo}->{ver} && scalar keys %{$counts->{$repo}} > $repos->{$repo}->{ver}; |
| 420 |
|
return 1 if $repos->{$repo}->{rel} && scalar keys %{$counts->{$repo}->{$pkg->{ver}}} > $repos->{$repo}->{rel}; |
| 421 |
|
return 0; |
| 422 |
} |
} |
| 423 |
|
|
| 424 |
print "\n"; |
sub pkgdest { |
| 425 |
foreach my $rpm ( sort keys %{{ map { $_ => 1 } @remove }} ) { |
my $pkg = shift; |
| 426 |
print "removing $rpm\n"; |
my $dest = shift; |
| 427 |
unlink $rpm; |
my $hirepo = shift; |
| 428 |
|
my $pkgs = shift; |
| 429 |
|
|
| 430 |
|
foreach my $cmp ( @$pkgs ) { |
| 431 |
|
next if $cmp->{src} || $repos->{$cmp->{repo}}->{prio} <= $repos->{$dest}->{prio}; |
| 432 |
|
next if $pkg->{name} ne ( $pkg->{src} ? $cmp->{base} : $cmp->{name} ); |
| 433 |
|
if ( $repos->{$cmp->{repo}}->{prio} > $repos->{$hirepo}->{prio} ) { |
| 434 |
|
$dest = $hirepo; |
| 435 |
|
last; |
| 436 |
|
} else { |
| 437 |
|
$dest = $cmp->{repo}; |
| 438 |
|
} |
| 439 |
|
} |
| 440 |
|
return $dest; |
| 441 |
} |
} |
| 442 |
|
|
| 443 |
print "\n"; |
sub process_rpm { |
| 444 |
foreach my $repo ( sort keys %changed ) { |
my $rpm = shift; |
| 445 |
next if $repo =~ m{^/builds}; |
my $smever = shift; |
| 446 |
|
my $repo = shift; |
| 447 |
print "rebuilding $repo/i386...\n"; |
return unless $rpm =~ m{/([^/]*)-[^-]+-[^-]+\.\w+\.rpm$}; |
| 448 |
system(qw(createrepo), "$repo/i386"); |
my $base = $1; |
| 449 |
system(qw(repoview), "$repo/i386"); |
return unless ! $opts{r} || $base =~ m[$opts{r}]; |
| 450 |
|
return unless $latest{$base} || $sources{$base} || ! $repos->{$repo}->{base}; |
| 451 |
|
|
| 452 |
|
my $pkg; |
| 453 |
|
eval { $pkg = RPM2->open_package($rpm, $rpm_flags); }; |
| 454 |
|
if ($@) { print " * corrupt package ($rpm)\n"; return; } |
| 455 |
|
eval { my $sig = $pkg->siggpg }; |
| 456 |
|
my $nosig = ! $@; |
| 457 |
|
|
| 458 |
|
my $cmp = $latest{$pkg->name}; |
| 459 |
|
if ( $repos->{$repo}->{base} && ! $pkg->is_source_package ) { |
| 460 |
|
return unless $cmp; |
| 461 |
|
return if $repos->{$cmp->{repo}}->{base} && $repos->{$cmp->{repo}}->{prio} > $repos->{$repo}->{prio} && $pkg ge $cmp->{rpm}; |
| 462 |
|
} |
| 463 |
|
my ($src, $version, $release) = ($pkg->is_source_package ? $pkg->filename : $pkg->sourcerpm) =~ m{(?:^|/)([^/]*)-([^-]+)-([^-]+)\.\w+\.rpm$}; |
| 464 |
|
return if $skippkg->{$smever}->{$repo} && $skippkg->{$smever}->{$repo}->{$src}; |
| 465 |
|
return if $repos->{$repo}->{base} && $nosig; |
| 466 |
|
if ( $nosig && ! -f "$HOME/.rpmpass" ) { print " * missing signature (" .$pkg->filename . ")\n"; return; } |
| 467 |
|
my $arch = 'unknown'; |
| 468 |
|
$arch = 'SRPMS' if $pkg->filename =~ m{[/-](SRPMS?|src|source)/}; |
| 469 |
|
$arch = 'x86_64' if $pkg->filename =~ m{[/-]x86_64/}; |
| 470 |
|
$arch = 'i386' if $pkg->filename =~ m{[/-](i[356]86)/}; |
| 471 |
|
$arch = 'noarch' if $pkg->filename =~ m{[/-]noarch/}; |
| 472 |
|
|
| 473 |
|
my $rpmhash = { base => $src, |
| 474 |
|
name => $pkg->name, |
| 475 |
|
repo => $repo, |
| 476 |
|
nvra => $pkg->name.'-'.$pkg->version.'-'.$pkg->release.'.'.( $pkg->is_source_package ? 'src' : $pkg->tag('ARCH') ), |
| 477 |
|
svr => $src.'-'.$version.'-'.$release, |
| 478 |
|
src => $pkg->is_source_package, |
| 479 |
|
arch => $arch, |
| 480 |
|
ver => $version, |
| 481 |
|
rel => $release, |
| 482 |
|
rpm => $pkg, |
| 483 |
|
nosig => $nosig, |
| 484 |
|
}; |
| 485 |
|
if ( $pkg->is_source_package ) { |
| 486 |
|
push @{$rpms->{$src}->{srpms}}, $rpmhash; |
| 487 |
|
push @{$rpms->{$src}->{vers}->{$rpmhash->{svr}}}, $rpmhash; |
| 488 |
|
} else { |
| 489 |
|
push @{$rpms->{$src}->{rpms}}, $rpmhash; |
| 490 |
|
} |
| 491 |
|
$sources{$src}++; |
| 492 |
|
|
| 493 |
|
return if $pkg->is_source_package || $repos->{$repo}->{stage}; |
| 494 |
|
if ( ! $repos->{$repo}->{base} ) { |
| 495 |
|
if ( ! $cmp || $pkg gt $cmp->{rpm} ) { |
| 496 |
|
$latest{$pkg->name} = $rpmhash; |
| 497 |
|
} |
| 498 |
|
} elsif ( ( $repos->{$repo}->{prio} >= $repos->{$cmp->{repo}}->{prio} || ! $repos->{$cmp->{repo}}->{base} ) && $pkg ge $cmp->{rpm} ) { |
| 499 |
|
$latest{$pkg->name} = $rpmhash; |
| 500 |
|
} |
| 501 |
} |
} |
Parent Directory
| 
Revision Log
| 
Revision Graph
| 
Patch
