| 6 |
use File::Find; |
use File::Find; |
| 7 |
use File::Basename; |
use File::Basename; |
| 8 |
use Getopt::Std; |
use Getopt::Std; |
|
use Term::ANSIColor; |
|
| 9 |
use Data::Dumper; |
use Data::Dumper; |
| 10 |
|
|
| 11 |
delete $ENV{PATH}; |
delete $ENV{PATH}; |
| 12 |
my $HOME=$ENV{HOME}; |
my $HOME=$ENV{HOME}; |
| 13 |
umask 002; |
umask 002; |
|
|
|
|
my $rpm_flags = RPM2->vsf_nosha1header | RPM2->vsf_nomd5header | RPM2->vsf_nodsaheader | RPM2->vsf_norsaheader; |
|
|
$rpm_flags |= RPM2->vsf_nosha1 | RPM2->vsf_nomd5 | RPM2->vsf_nodsa | RPM2->vsf_norsa; |
|
|
|
|
|
$Term::ANSIColor::AUTORESET = 1; |
|
| 14 |
$| = 1; |
$| = 1; |
| 15 |
|
|
|
my @archs = ( 'i386', 'x86_64' ); |
|
|
|
|
|
my $repos = { 'smeos' => { prio => 17, inc => 1, ver => 1, rel => 1, os => 1 }, |
|
|
'smeupdates' => { prio => 16, inc => 1, ver => 1, rel => 1 }, |
|
|
'smeupdates-testing' => { prio => 15, inc => 1, ver => 1, rel => 1 }, |
|
|
'smeextras' => { prio => 14, inc => 0, ver => 1, rel => 1 }, |
|
|
'smeaddons' => { prio => 13, inc => 0, ver => 1, rel => 1 }, |
|
|
'smecontribs' => { prio => 12, inc => 0, ver => 1, rel => 1 }, |
|
|
'smetest' => { prio => 11, inc => 1, ver => 2, rel => 2, devel => 2 }, |
|
|
'smedev' => { prio => 10, inc => 0, ver => 2, rel => 2, devel => 1 }, |
|
|
'centos' => { prio => 9, inc => 0, ver => 0, rel => 0, base => 1 }, |
|
|
'fedora/epel' => { prio => 8, inc => 0, ver => 0, rel => 0, base => 1 }, |
|
|
'fedora/extras' => { prio => 7, inc => 0, ver => 0, rel => 0, base => 1 }, |
|
|
'rpmforge' => { prio => 6, inc => 0, ver => 0, rel => 0, base => 1 }, |
|
|
'atrpms' => { prio => 5, inc => 0, ver => 0, rel => 0, base => 1 }, |
|
|
'fedora/core' => { prio => 4, inc => 0, ver => 0, rel => 0, base => 1 }, |
|
|
'base' => { prio => 3, inc => 0, ver => 0, rel => 0, base => 1 }, |
|
|
'builds' => { prio => 2, inc => 0, ver => 0, rel => 0, builds => 1 }, |
|
|
'stage' => { prio => 1, inc => 0, ver => 0, rel => 0, stage => 1, os => 1 }, |
|
|
}; |
|
|
|
|
|
my $distrepo = { '7' => { active => 1, |
|
|
centos => 4, |
|
|
fedora => 3, |
|
|
repo => '/releases/7/', |
|
|
os => 'SME/RPMS/', |
|
|
builds => '/builds/smeserver-7-core/', |
|
|
stage => '/stage/7/', |
|
|
}, |
|
|
'8' => { active => 1, |
|
|
centos => 5, |
|
|
fedora => 6, |
|
|
repo => '/releases/testing/8/', |
|
|
os => 'SME/', |
|
|
builds => '/builds/smeserver-8-core/', |
|
|
stage => '/stage/8/', |
|
|
}, |
|
|
}; |
|
|
|
|
|
my @baserepo = ( ( map { "/mirrors/centos/~C/$_/" } ('os','updates','fasttrack','extras') ), |
|
|
( map { "/mirrors/fedora/epel$_/~C/" } ('','/testing') ), |
|
|
'/mirrors/fedora/extras/~F/', |
|
|
'/mirrors/rpmforge/dag/redhat/el~C/en/~A/RPMS.dag/', |
|
|
'/mirrors/rpmforge/dag/source/', |
|
|
( map { "/mirrors/atrpms$_/el~C-~A/atrpms/stable/" } ('','/src') ), |
|
|
( map { "/mirrors/atrpms$_/el~C-~A/atrpms/testing/" } ('','/src') ), |
|
|
( map {"/mirrors/fedora/core$_/~F/" } ('','/updates') ), |
|
|
); |
|
|
|
|
|
my $skippkg = { '7' => { 'centos' => ['horde','imp-h3','ingo-h3','turba-h3','vim'], |
|
|
'fedora/epel' => ['perl-Razor-Agent'], |
|
|
'rpmforge' => ['perl-Test-Inline'], |
|
|
'atrpms' => ['dovecot','yum'], |
|
|
}, |
|
|
'8' => { 'centos' => ['horde','imp-h3','ingo-h3','turba-h3'], |
|
|
'fedora/epel' => ['perl-Razor-Agent','smolt'], |
|
|
'fedora/extras' => ['dstat','gocr','horde','oidentd','perl-Test-Inline','perl-Razor-Agent','smolt'], |
|
|
'rpmforge' => ['perl-Test-Inline'], |
|
|
'atrpms' => [], |
|
|
'fedora/core' => [], |
|
|
}, |
|
|
}; |
|
|
|
|
| 16 |
my %opts; |
my %opts; |
| 17 |
getopts( 'dtvr:', \%opts ); |
getopts( 'ostr:', \%opts ); |
| 18 |
$opts{r} ||= ''; |
$opts{r} ||= ''; |
| 19 |
|
#available options |
| 20 |
|
#-o = verify we have originals of the packages in repos (not really used anymore) |
| 21 |
|
#-s = verify every package has a source package (so we can rebuild if necessary) |
| 22 |
|
#-t = test run (don't do anything just print out what would be done) |
| 23 |
|
#-r {regex} = regex of packages to run the script against |
| 24 |
|
|
| 25 |
|
my $rpm_flags = RPM2->vsf_nodsaheader | RPM2->vsf_norsaheader | RPM2->vsf_nodsa | RPM2->vsf_norsa; |
| 26 |
|
|
| 27 |
|
my $osdir = 'SME'; |
| 28 |
|
my $disttag = 'sme'; |
| 29 |
|
my $repotag = 'sme'; |
| 30 |
|
|
| 31 |
|
my $distrepo = { '8' => { active => 0, |
| 32 |
|
centos => 5, |
| 33 |
|
archs => [ 'i386', 'x86_64' ], |
| 34 |
|
repo => '/build/smeserver/repo/8/', |
| 35 |
|
builds => ['/build/builds/smeserver-8-core/'], |
| 36 |
|
community => '/build/builds/smeserver-8-contribs/', |
| 37 |
|
stage => '/build/smeserver/stage/8/', |
| 38 |
|
sign => 1, |
| 39 |
|
keyname => 'SME Server 7 signing key <bugteam@contribs.org>', |
| 40 |
|
checksum => 'sha', |
| 41 |
|
}, |
| 42 |
|
'9' => { active => 1, |
| 43 |
|
centos => 6, |
| 44 |
|
archs => [ 'i386', 'x86_64' ], |
| 45 |
|
repo => '/build/smeserver/repo/9/', |
| 46 |
|
builds => ['/build/builds/smeserver-9-core/'], |
| 47 |
|
community => '/build/builds/smeserver-9-contribs/', |
| 48 |
|
stage => '/build/smeserver/stage/9/', |
| 49 |
|
sign => 1, |
| 50 |
|
keyname => 'SME Server 7 signing key <bugteam@contribs.org>', |
| 51 |
|
checksum => 'sha256', |
| 52 |
|
}, |
| 53 |
|
'10' => { active => 1, |
| 54 |
|
centos => 7, |
| 55 |
|
archs => [ 'x86_64' ], |
| 56 |
|
repo => '/build/smeserver/repo/testing/10/', |
| 57 |
|
builds => ['/build/builds/smeserver-10-core/'], |
| 58 |
|
community => '/build/builds/smeserver-10-contribs/', |
| 59 |
|
stage => '/build/smeserver/stage/10/', |
| 60 |
|
sign => 1, |
| 61 |
|
keyname => 'Koozali SME Server signing key (10) <bugteam@koozali.org>', |
| 62 |
|
checksum => 'sha256', |
| 63 |
|
}, |
| 64 |
|
}; |
| 65 |
|
|
| 66 |
|
# list here repo and priority |
| 67 |
|
# prio: highest priority will hide lowest priority |
| 68 |
|
# inc: include for iso ? |
| 69 |
|
# ver: |
| 70 |
|
# rel: |
| 71 |
|
# orig: |
| 72 |
|
# base, os, stage: |
| 73 |
|
my $repos = { "${repotag}os" => { prio => 19, inc => 1, ver => 1, rel => 1, os => 1 }, |
| 74 |
|
"${repotag}updates" => { prio => 18, inc => 1, ver => 1, rel => 1 }, |
| 75 |
|
"${repotag}updates-testing" => { prio => 17, inc => 1, ver => 1, rel => 3 }, |
| 76 |
|
"${repotag}extras" => { prio => 16, inc => 0, ver => 1, rel => 1 }, |
| 77 |
|
"${repotag}addons" => { prio => 15, inc => 0, ver => 1, rel => 1 }, |
| 78 |
|
"${repotag}contribs" => { prio => 14, inc => 0, ver => 1, rel => 1 }, |
| 79 |
|
"${repotag}test" => { prio => 13, inc => 0, ver => 2, rel => 3, devel => 2 }, |
| 80 |
|
"${repotag}dev" => { prio => 12, inc => 0, ver => 1, rel => 1, devel => 1 }, |
| 81 |
|
'centos' => { prio => 11, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 82 |
|
'remi' => { prio => 10, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 83 |
|
'remisafe' => { prio => 9, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 84 |
|
'epel' => { prio => 8, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 85 |
|
'rpmforge' => { prio => 7, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 86 |
|
'atrpms' => { prio => 6, inc => 0, ver => 0, rel => 0, orig => 1, base => 1 }, |
| 87 |
|
'builds' => { prio => 4, inc => 0, ver => 0, rel => 0, orig => 1 }, |
| 88 |
|
'community' => { prio => 2, inc => 0, ver => 0, rel => 0, orig => 1 }, |
| 89 |
|
'stage' => { prio => 1, inc => 0, ver => 0, rel => 0, stage => 1, os => 1 }, |
| 90 |
|
}; |
| 91 |
|
|
| 92 |
|
# list here the path on our local mirror to each upstream and our mirrors |
| 93 |
|
# ~A will be expanded to architecture |
| 94 |
|
# ~C will be expanded to Centos main version number, i.e. 7 for SME 10. |
| 95 |
|
my $baserepo = { "~S${repotag}os/~A/" => "${repotag}os", |
| 96 |
|
"~S${repotag}updates/~A/" => "${repotag}updates", |
| 97 |
|
"~S${repotag}updates-testing/~A/" => "${repotag}updates-testing", |
| 98 |
|
"~S${repotag}extras/~A/" => "${repotag}extras", |
| 99 |
|
"~S${repotag}addons/~A/" => "${repotag}addons", |
| 100 |
|
"~S${repotag}contribs/~A/" => "${repotag}contribs", |
| 101 |
|
"~S${repotag}test/~A/" => "${repotag}test", |
| 102 |
|
"~S${repotag}dev/~A/" => "${repotag}dev", |
| 103 |
|
"/build/smeserver/stage/~s/~A/" => 'stage', |
| 104 |
|
'/mirrors/centos/~C/fasttrack/~A/' => 'centos', |
| 105 |
|
'/mirrors/centos/~C/updates/~A/' => 'centos', |
| 106 |
|
'/mirrors/centos/~C/os/~A/' => 'centos', |
| 107 |
|
'/mirrors/centos/~C/extras/~A/' => 'centos', |
| 108 |
|
'/mirrors/centos-vault/~C/fasttrack/~A/' => 'centos', |
| 109 |
|
'/mirrors/centos-vault/~C/updates/~A/' => 'centos', |
| 110 |
|
'/mirrors/centos-vault/~C/os/~A/' => 'centos', |
| 111 |
|
'/mirrors/centos-vault/~C/extras/~A/' => 'centos', |
| 112 |
|
'/mirrors/fedora/epel/~C/~A/' => 'epel', |
| 113 |
|
'/mirrors/fedora/epel/testing/~C/~A/' => 'epel', |
| 114 |
|
'/mirrors/remi/enterprise/~C/remi/~A/' => 'remi', |
| 115 |
|
'/mirrors/remi/SRPMS/' => 'remi', |
| 116 |
|
'/mirrors/remi/enterprise/~C/safe/~A/' => 'remisafe', |
| 117 |
|
# '/mirrors/remi/SRPMS/' => 'remisafe', |
| 118 |
|
'/mirrors/rpmforge/redhat/el~C/en/~A/dag/' => 'rpmforge', |
| 119 |
|
'/mirrors/rpmforge/redhat/el~C/en/~A/extras/' => 'rpmforge', |
| 120 |
|
'/mirrors/rpmforge/source/' => 'rpmforge', |
| 121 |
|
'/mirrors/atrpms/el~C-~A/atrpms/stable/' => 'atrpms', |
| 122 |
|
'/mirrors/atrpms/el~C-~A/atrpms/testing/' => 'atrpms', |
| 123 |
|
'/mirrors/atrpms/src/el~C-~A/atrpms/stable/' => 'atrpms', |
| 124 |
|
'/mirrors/atrpms/src/el~C-~A/atrpms/testing/' => 'atrpms', |
| 125 |
|
}; |
| 126 |
|
|
| 127 |
|
# add here packages to exclude |
| 128 |
|
# for each version, if a repo is listed and rpm are listed they will be ignored fromt his repo |
| 129 |
|
my $skippkg = { '8' => { 'atrpms' => { map { $_ => 1 } ( 'clamav', 'gnupg' ) }, |
| 130 |
|
'centos' => { map { $_ => 1 } ( 'horde', 'imp-h3', 'ingo-h3', 'turba-h3' ) }, |
| 131 |
|
'epel' => { map { $_ => 1 } ( 'clamav', 'cppunit', 'fping', 'html2ps', 'horde', 'libtalloc', 'libtdb', 'oidentd', 'perl-Compress-Bzip2', 'perl-Compress-Raw-Zlib', 'perl-Compress-Raw-Bzip2', 'perl-Crypt-OpenSSL-Bignum', 'perl-Crypt-OpenSSL-Random', 'perl-Crypt-OpenSSL-RSA', 'perl-Razor-Agent', 'smolt' ) }, |
| 132 |
|
'rpmforge' => { map { $_ => 1 } ( 'dovecot', 'libtalloc', 'mod_auth_tkt', 'perl-Test-Inline', 'spamassassin', 'lzo', 'perl-Convert-TNEF', 'perl-Mail-SPF', 'proftpd', 'erlang', 'perl-DateTime-Format-Mail', 'perl-DateTime-Format-W3CDTF', 'perl-Email-Abstract', 'perl-Email-MIME-Attachment-Stripper', 'perl-Email-Reply', 'perl-Font-AFM', 'perl-IPC-Run', 'rkhunter') }, |
| 133 |
|
}, |
| 134 |
|
'9' => { 'atrpms' => { map { $_ => 1 } ( 'clamav', 'perl-Pod-Escapes', 'perl-Pod-Simple','libvorbis' , 'libogg' ) }, |
| 135 |
|
'epel' => { map { $_ => 1 } ( 'oidentd', 'perl-Razor-Agent' ) }, |
| 136 |
|
'rpmforge' => { map { $_ => 1 } ( 'perl-CGI', 'perl-Compress-Raw-Zlib', 'perl-ExtUtils-ParseXS', 'perl-Pod-Escapes', 'perl-Pod-Simple', 'perl-Time-HiRes', 'perl-version', 'spamassassin', 'portreserve', 'perl-libwww-perl' , 'lzo', 'perl-BSD-Resource', 'perl-Convert-ASN1', 'perl-Devel-StackTrace', 'perl-Digest-SHA1', 'perl-MIME-tools', 'perl-MailTools', 'perl-PPI', 'perl-URI', 'perl-XML-NamespaceSupport', 'perl-XML-Parser', 'perl-XML-SAX-Writer', 'perl-YAML-Syck', 'proftpd', 'syslinux') }, |
| 137 |
|
}, |
| 138 |
|
'10' => { |
| 139 |
|
'centos' => { map { $_ => 1 } ( 'samba' ) }, |
| 140 |
|
'epel' => { map { $_ => 1 } ( 'clamav') }, |
| 141 |
|
}, |
| 142 |
|
}; |
| 143 |
|
|
| 144 |
|
# add here include only conditions |
| 145 |
|
# for each version if a repo is listed here, only listed rpm will be considered |
| 146 |
|
my $onlypkg = { '8' => { |
| 147 |
|
'remi' => { }, |
| 148 |
|
'remisafe' => { }, |
| 149 |
|
}, |
| 150 |
|
'9' => { |
| 151 |
|
'remi' => { }, |
| 152 |
|
}, |
| 153 |
|
'10' => { |
| 154 |
|
'remi' => { map { $_ => 1 } ( 'php-pear' )}, |
| 155 |
|
}, |
| 156 |
|
}; |
| 157 |
|
|
| 158 |
|
my ($stage) = sort { $repos->{$a}->{stage} <=> $repos->{$b}->{stage} } grep { $repos->{$_}->{stage} } keys %$repos; |
| 159 |
my ($devel1, $devel2) = sort { $repos->{$a}->{devel} <=> $repos->{$b}->{devel} } grep { $repos->{$_}->{devel} } keys %$repos; |
my ($devel1, $devel2) = sort { $repos->{$a}->{devel} <=> $repos->{$b}->{devel} } grep { $repos->{$_}->{devel} } keys %$repos; |
| 160 |
$devel2 ||= $devel1; |
$devel2 ||= $devel1; |
|
my ($stage) = sort { $repos->{$a}->{stage} <=> $repos->{$b}->{stage} } grep { $repos->{$_}->{stage} } keys %$repos; |
|
| 161 |
|
|
| 162 |
my ($rel, @rpms, %latest, %sources, $archs, $rebuild, $newline); |
my ($rpms, %base, %latest, %sources); |
| 163 |
foreach my $smever ( sort { $a <=> $b } grep { $distrepo->{$_}->{active} } keys %$distrepo ) { |
foreach my $ver ( sort { $a <=> $b } keys %$distrepo ) { |
| 164 |
$rel = $smever; |
next unless $distrepo->{$ver}->{active}; |
| 165 |
|
my %repochg = (); |
| 166 |
|
$rpms = (); |
| 167 |
%latest = (); |
%latest = (); |
| 168 |
%sources = (); |
%sources = (); |
| 169 |
@rpms = (); |
%base = (); |
|
$rebuild = (); |
|
| 170 |
|
|
| 171 |
# Load distro packages |
@{$distrepo->{$ver}->{all_archs}} = ('noarch', @{$distrepo->{$ver}->{'archs'}}); |
| 172 |
find( { wanted => \&loadpkg, no_chdir => 1, follow_fast => 1 }, map { $distrepo->{$smever}->{$_} } ('repo','builds','stage') ); |
if ( grep $_ eq 'i386', @{$distrepo->{$ver}->{'archs'}} ) { |
| 173 |
printline('white', 0, "Distro (SME Server $rel) packages loaded.\n"); |
push @{$distrepo->{$ver}->{all_archs}}, ('i586', 'i686'); |
| 174 |
|
} |
| 175 |
# Load base packages |
|
| 176 |
foreach my $base ( @baserepo ) { |
foreach my $dir ( sort { $repos->{$baserepo->{$b}}->{prio} <=> $repos->{$baserepo->{$a}}->{prio} || $a cmp $b } keys %$baserepo ) { |
| 177 |
my $bdir = $base; |
my $bdir = $dir; |
| 178 |
$bdir =~ s/~C/$distrepo->{$smever}->{centos}/; |
$bdir =~ s/~S/$distrepo->{$ver}->{repo}/; |
| 179 |
$bdir =~ s/~F/$distrepo->{$smever}->{fedora}/; |
$bdir =~ s/~s/$ver/; |
| 180 |
if ( $bdir =~ m{~A} ) { |
$bdir =~ s/~C/$distrepo->{$ver}->{centos}/; |
| 181 |
for my $arch ( @archs ) { |
for my $arch ( @{$distrepo->{$ver}->{'archs'}}, 'SRPMS/' ) { |
| 182 |
my $basearch = $bdir; |
my $adir = $bdir; |
| 183 |
$basearch =~ s/~A/$arch/; |
if ( $arch eq 'SRPMS/' ) { |
| 184 |
find( { wanted => \&loadbase, no_chdir => 1, follow_fast => 1 }, $basearch ) if -r $basearch; |
$adir =~ s/~A.*//; |
| 185 |
} |
if ( -d "${adir}SRPMS" ) { |
| 186 |
} else { |
$adir .= "SRPMS/"; |
| 187 |
find( { wanted => \&loadbase, no_chdir => 1, follow_fast => 1 }, $bdir ) if -r $bdir; |
} elsif ( -d "${adir}Source/SPackages" ) { |
| 188 |
} |
$adir .= "Source/SPackages/"; |
| 189 |
|
} |
| 190 |
|
} else { |
| 191 |
|
$adir =~ s/~A/$arch/; |
| 192 |
|
if ( -d "${adir}RPMS" ) { |
| 193 |
|
$adir .= "RPMS/"; |
| 194 |
|
} elsif ( -d "${adir}Packages" ) { |
| 195 |
|
$adir .= "Packages/"; |
| 196 |
|
} elsif ( -d "${adir}CentOS" ) { |
| 197 |
|
$adir .= "CentOS/"; |
| 198 |
|
} elsif ( -d "${adir}$osdir" ) { |
| 199 |
|
$adir .= "$osdir/"; |
| 200 |
|
} |
| 201 |
|
} |
| 202 |
|
next unless -d $adir; |
| 203 |
|
opendir DIR, $adir or next; |
| 204 |
|
my @txt = grep { /\.rpm$/ && -f "$adir/$_" } readdir DIR; |
| 205 |
|
closedir DIR; |
| 206 |
|
if (scalar(@txt)) { |
| 207 |
|
opendir DIR, $adir or next; |
| 208 |
|
process_rpm("$adir$_", $ver, $baserepo->{$dir}) foreach readdir DIR; |
| 209 |
|
closedir DIR; |
| 210 |
|
} elsif ($baserepo->{$dir} eq 'epel') { |
| 211 |
|
# EPEL 7 uses a structure with subfolders of first letter of package |
| 212 |
|
find( { wanted => sub { process_rpm($_, $ver, $baserepo->{$dir}) if ($_ =~ m/\.rpm$/);}, no_chdir => 1, follow_fast => 1 }, $adir ); |
| 213 |
|
} |
| 214 |
|
last unless $dir =~ m{~A}; |
| 215 |
|
} |
| 216 |
|
} |
| 217 |
|
find( { wanted => sub { process_rpm($_, $ver, 'builds'); }, no_chdir => 1, follow_fast => 1 }, "$_" ) foreach @{$distrepo->{$ver}->{'builds'}}; |
| 218 |
|
find( { wanted => sub { process_rpm($_, $ver, 'community'); }, no_chdir => 1, follow_fast => 1 }, $distrepo->{$ver}->{'community'} ) if $distrepo->{$ver}->{'community'}; |
| 219 |
|
|
| 220 |
|
foreach my $base ( sort keys %$rpms ) { |
| 221 |
|
next unless $rpms->{$base}->{rpms}; |
| 222 |
|
my %track = (); |
| 223 |
|
my %seen = (); |
| 224 |
|
my %counts = (); |
| 225 |
|
my $acnt = (); |
| 226 |
|
my $print = 0; |
| 227 |
|
%latest = (); |
| 228 |
|
|
| 229 |
|
foreach my $pkg ( sort { $b->{rpm} cmp $a->{rpm} } @{$rpms->{$base}->{rpms}} ) { |
| 230 |
|
next if $pkg->{done}; |
| 231 |
|
|
| 232 |
|
my $tmp = $pkg->{svr}; |
| 233 |
|
# srpm transformations to match up binary and source rpms |
| 234 |
|
SRC: { |
| 235 |
|
# Try to find the name the binary wants (no changes) |
| 236 |
|
$rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 237 |
|
|
| 238 |
|
# rpmforge (.el4.rf to .rf, with rf,rfb,rft,rfx endings) |
| 239 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d(\.rf[btx]?)$}{$1} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 240 |
|
# rpmforge (.el4.rfx to .rf, rfb,rft,rfx switched to rf) |
| 241 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d(\.rf)[btx]$}{$1} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 242 |
|
# rpmforge (.el4.rf to .rfx, rf,rfb,rft,rfx switched to rfx) |
| 243 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d(\.rf)[btx]?$}{$1x} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 244 |
|
# rpmforge (.el4.rf to .el5) TODO: remove when no longer needed |
| 245 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d\.rf$}{.el5} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 246 |
|
# rpmforge (.2.el4.rf to .rf, minor modification not pushed to source?) TODO: remove when no longer needed |
| 247 |
|
($tmp = $pkg->{svr}) =~ s{\.2\.el\d(\.rf)$}{$1} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 248 |
|
|
| 249 |
|
# atrpms (remove .at) |
| 250 |
|
($tmp = $pkg->{svr}) =~ s{\.at$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 251 |
|
# atrpms (remove .el4.at) |
| 252 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d\.at$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 253 |
|
# atrpms (remove .el4) |
| 254 |
|
($tmp = $pkg->{svr}) =~ s{\.el\d$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 255 |
|
# atrpms (remove .0.el5, minor modification not pushed to source?) TODO: remove when no longer needed |
| 256 |
|
($tmp = $pkg->{svr}) =~ s{\.0\.el\d$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 257 |
|
|
| 258 |
|
# Transformations that we hopefully won't have to use anymore TODO: remove if no issues |
| 259 |
|
#($tmp = $pkg->{svr}) =~ s{(\.el\d)\.rf$}{$1} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 260 |
|
#($tmp = $pkg->{svr}) =~ s{(\d+)\.\d+(\.rf)$}{$1$2} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 261 |
|
#($tmp = $pkg->{svr}) =~ s{\.el\d\.rf$}{.dag} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 262 |
|
#($tmp = $pkg->{svr}) =~ s{(\d+)\.\d+\.el\d\.rf$}{$1.dag} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 263 |
|
#($tmp = $pkg->{svr}) =~ s{\.el\d_}{_} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 264 |
|
#($tmp = $pkg->{svr}) =~ s{(-\d+)\.\d+\.el\d$}{$1} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 265 |
|
#($tmp = $pkg->{svr}) =~ s{\.centos\d$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 266 |
|
#($tmp = $pkg->{svr}) =~ s{\.at$}{} && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 267 |
|
#($tmp = $pkg->{svr}) =~ s{\.el\d\.$disttag$}{ && $rpms->{$base}->{vers}->{$tmp} && last SRC; |
| 268 |
|
} |
| 269 |
|
if ( $rpms->{$base}->{vers}->{$tmp} ) { |
| 270 |
|
foreach $tmp ( @{$rpms->{$base}->{vers}->{$tmp}} ) { |
| 271 |
|
$tmp->{svr} = $pkg->{svr}; |
| 272 |
|
push @{$rpms->{$base}->{rpms}}, $tmp unless $tmp->{added}; |
| 273 |
|
$tmp->{added}++; |
| 274 |
|
} |
| 275 |
|
} |
| 276 |
|
|
| 277 |
|
my %orig = (); |
| 278 |
|
my %pkgs = (); |
| 279 |
|
my %reposrc = (); |
| 280 |
|
my $srpm = undef; |
| 281 |
|
foreach my $cmp ( sort { $a->{src} <=> $b->{src} || $repos->{$b->{repo}}->{prio} <=> $repos->{$a->{repo}}->{prio} } @{$rpms->{$base}->{rpms}} ) { |
| 282 |
|
next unless $cmp->{svr} eq $pkg->{svr}; |
| 283 |
|
|
| 284 |
|
if ( ! $track{repo} || $repos->{$cmp->{repo}}->{prio} > $repos->{$track{repo}}->{prio} ) { |
| 285 |
|
if ( $cmp->{src} ) { |
| 286 |
|
if ( ! $track{repo} ) { |
| 287 |
|
$cmp->{delete}++; |
| 288 |
|
$cmp->{done}++; |
| 289 |
|
next; |
| 290 |
|
} |
| 291 |
|
} else { |
| 292 |
|
$track{repo} = $cmp->{repo}; |
| 293 |
|
$track{svr} = $cmp->{svr}; |
| 294 |
|
} |
| 295 |
|
} |
| 296 |
|
if ( $cmp->{svr} eq $track{svr} ) { |
| 297 |
|
if ( $seen{$cmp->{nvra}} ) { |
| 298 |
|
if ( $track{repo} ne $cmp->{repo} ) { |
| 299 |
|
if ($repos->{$cmp->{repo}}->{stage} ) { |
| 300 |
|
if ( $seen{$cmp->{nvra}}->{latest} ) { |
| 301 |
|
$seen{$cmp->{nvra}}->{latest}++; |
| 302 |
|
delete $cmp->{delete} if $cmp->{delete}; |
| 303 |
|
} else { |
| 304 |
|
$cmp->{delete}++; |
| 305 |
|
} |
| 306 |
|
} elsif ( $repos->{$cmp->{repo}}->{orig} ) { |
| 307 |
|
$orig{$cmp->{nvra}}++; |
| 308 |
|
unless ( $repos->{$cmp->{repo}}->{base} ) { |
| 309 |
|
my $tag = dirname(dirname($cmp->{rpm}->{filename})); |
| 310 |
|
qx(touch $tag/PUSHED) if ! $opts{t} && -d $tag && ! -f "$tag/PUSHED"; |
| 311 |
|
} |
| 312 |
|
} elsif ( $cmp->{src} ) { |
| 313 |
|
if ( $cmp->{delete} && $cmp->{oldrepo} && $reposrc{$cmp->{oldrepo}}) { |
| 314 |
|
$cmp->{repo} = $cmp->{oldrepo}; |
| 315 |
|
delete $cmp->{delete}; |
| 316 |
|
} |
| 317 |
|
if ( $reposrc{$cmp->{repo}} ) { |
| 318 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp; |
| 319 |
|
$srpm = $cmp if ! $srpm; |
| 320 |
|
} elsif ( $seen{$cmp->{nvra}}->{repo} ne $cmp->{repo} && ! $cmp->{done} ) { |
| 321 |
|
$cmp->{delete}++; |
| 322 |
|
} |
| 323 |
|
} elsif ( $seen{$cmp->{nvra}}->{repo} ne $cmp->{repo} ) { |
| 324 |
|
$cmp->{delete}++; |
| 325 |
|
} |
| 326 |
|
} elsif ( $cmp->{src} ) { |
| 327 |
|
if ( $reposrc{$cmp->{repo}} && $reposrc{$cmp->{repo}}->{srpm} && $reposrc{$cmp->{repo}}->{srpm}->{oldrepo} ne $cmp->{repo} ) { |
| 328 |
|
$acnt->{$cmp->{repo}}->{$cmp->{rpm}->as_nvre}->{src} = [ |
| 329 |
|
grep { $_ ne $reposrc{$cmp->{repo}}->{srpm} } @{$acnt->{$cmp->{repo}}->{$cmp->{rpm}->as_nvre}->{src}} |
| 330 |
|
]; |
| 331 |
|
|
| 332 |
|
if ( @{$reposrc{$cmp->{repo}}->{srpm}->{repos}} == 1 ) { |
| 333 |
|
$reposrc{$cmp->{repo}}->{srpm}->{repo} = $reposrc{$cmp->{repo}}->{srpm}->{oldrepo}; |
| 334 |
|
delete $reposrc{$cmp->{repo}}->{srpm}->{oldrepo}; |
| 335 |
|
delete $reposrc{$cmp->{repo}}->{srpm}->{delete}; |
| 336 |
|
delete $reposrc{$cmp->{repo}}->{srpm}->{repos}; |
| 337 |
|
delete $reposrc{$cmp->{repo}}->{srpm}->{done}; |
| 338 |
|
$seen{$cmp->{nvra}} = $cmp if $seen{$cmp->{nvra}} eq $reposrc{$cmp->{repo}}->{srpm}; |
| 339 |
|
} else { |
| 340 |
|
warn "How did I get here??"; |
| 341 |
|
} |
| 342 |
|
} else { |
| 343 |
|
$seen{$cmp->{nvra}} = $cmp if $seen{$cmp->{nvra}}->{repo} ne $cmp->{repo}; |
| 344 |
|
} |
| 345 |
|
$srpm = $cmp if ! $srpm && $cmp->{src}; |
| 346 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp if $reposrc{$cmp->{repo}}; |
| 347 |
|
} |
| 348 |
|
} elsif ( $repos->{$cmp->{repo}}->{stage} ) { |
| 349 |
|
$cmp->{delete}++; |
| 350 |
|
} elsif ( $cmp->{src} || grep $_ eq $cmp->{rpm}->arch, @{$distrepo->{$ver}->{all_archs}} ) { |
| 351 |
|
$srpm = $cmp if ! $srpm && $cmp->{src}; |
| 352 |
|
my $dest = $repos->{$track{repo}}->{prio} > $repos->{$devel2}->{prio} ? $track{repo} : $devel2; |
| 353 |
|
$dest = pkgdest($cmp, $devel1, $dest, $rpms->{$base}->{rpms}); |
| 354 |
|
$dest = $devel1 if verrel($cmp, $dest, \%counts); |
| 355 |
|
if ( $cmp->{repo} ne $dest ) { |
| 356 |
|
push @{$cmp->{repos}}, $dest; |
| 357 |
|
if ( $repos->{$cmp->{repo}}->{orig} ) { |
| 358 |
|
$orig{$cmp->{nvra}}++; |
| 359 |
|
unless ( $repos->{$cmp->{repo}}->{base} ) { |
| 360 |
|
my $tag = dirname(dirname($cmp->{rpm}->{filename})); |
| 361 |
|
qx(touch $tag/PUSHED) if ! $opts{t} && -d $tag && ! -f "$tag/PUSHED"; |
| 362 |
|
} |
| 363 |
|
} elsif ( $cmp->{src} && $reposrc{$cmp->{repo}} ) { |
| 364 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp; |
| 365 |
|
} else { |
| 366 |
|
$cmp->{delete}++; |
| 367 |
|
} |
| 368 |
|
$cmp->{oldrepo} = $cmp->{repo} unless $cmp->{oldrepo}; |
| 369 |
|
$cmp->{repo} = $dest; |
| 370 |
|
if ( ! $cmp->{src} && $repos->{$dest}->{prio} > $repos->{$track{repo}}->{prio} ) { |
| 371 |
|
$track{repo} = $dest; |
| 372 |
|
$track{svr} = $cmp->{svr}; |
| 373 |
|
} |
| 374 |
|
} |
| 375 |
|
if ( $cmp->{src} && $reposrc{$cmp->{repo}} ) { |
| 376 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp; |
| 377 |
|
} |
| 378 |
|
} |
| 379 |
|
} else { |
| 380 |
|
if ( $track{repo} eq $cmp->{repo} ) { |
| 381 |
|
if ( verrel($cmp, $cmp->{repo}, \%counts) ) { |
| 382 |
|
$cmp->{delete}++ unless $repos->{$cmp->{repo}}->{base}; |
| 383 |
|
} elsif ( $cmp->{src} ) { |
| 384 |
|
$cmp->{delete}++ unless $repos->{$cmp->{repo}}->{base}; |
| 385 |
|
} else { |
| 386 |
|
$track{svr} = $cmp->{svr}; |
| 387 |
|
} |
| 388 |
|
} elsif ( ! $repos->{$cmp->{repo}}->{base} ) { |
| 389 |
|
if ( $repos->{$cmp->{repo}}->{orig} ) { |
| 390 |
|
$srpm = $cmp if ! $srpm && $cmp->{src}; |
| 391 |
|
my $dest = $repos->{$track{repo}}->{prio} > $repos->{$devel2}->{prio} ? $track{repo} : $devel2; |
| 392 |
|
$dest = pkgdest($cmp, $devel1, $dest, $rpms->{$base}->{rpms}); |
| 393 |
|
$dest = $devel1 if verrel($cmp, $dest, \%counts); |
| 394 |
|
unless ( $cmp->{src} && ! $reposrc{$dest} ) { |
| 395 |
|
if ( $repos->{$dest}->{prio} >= $repos->{$track{repo}}->{prio} && ! verrel($cmp, $dest, \%counts) ) { |
| 396 |
|
unless ( $repos->{$cmp->{repo}}->{base} ) { |
| 397 |
|
my $tag = dirname(dirname($cmp->{rpm}->{filename})); |
| 398 |
|
qx(touch $tag/PUSHED) if ! $opts{t} && -d $tag && ! -f "$tag/PUSHED"; |
| 399 |
|
} |
| 400 |
|
push @{$cmp->{repos}}, $dest; |
| 401 |
|
$cmp->{oldrepo} = $cmp->{repo} unless $cmp->{oldrepo}; |
| 402 |
|
$cmp->{repo} = $dest; |
| 403 |
|
$reposrc{$cmp->{repo}}->{srpm} = $cmp if $cmp->{src}; |
| 404 |
|
$orig{$cmp->{nvra}}++; |
| 405 |
|
} |
| 406 |
|
} |
| 407 |
|
} else { |
| 408 |
|
$cmp->{delete}++; |
| 409 |
|
} |
| 410 |
|
} |
| 411 |
|
} |
| 412 |
|
unless ( $repos->{$cmp->{repo}}->{orig} || ( $cmp->{delete} && ! $cmp->{repos} ) ) { |
| 413 |
|
$pkgs{$cmp->{nvra}}++; |
| 414 |
|
$latest{$cmp->{base}} = $cmp->{svr} if $repos->{$cmp->{repo}}->{inc} && ! $latest{$cmp->{base}}; |
| 415 |
|
$reposrc{$cmp->{repo}} = $cmp unless $reposrc{$cmp->{repo}} || $cmp->{src} || $repos->{$cmp->{repo}}->{stage}; |
| 416 |
|
if ( $latest{$cmp->{base}} && $cmp->{svr} eq $latest{$cmp->{base}} && $repos->{$cmp->{repo}}->{inc} ) { |
| 417 |
|
$cmp->{latest}++ if ! $seen{$cmp->{nvra}} || $cmp->{src}; |
| 418 |
|
} |
| 419 |
|
$seen{$cmp->{nvra}} = $cmp unless $seen{$cmp->{nvra}}; |
| 420 |
|
push @{$acnt->{$cmp->{repo}}->{$cmp->{rpm}->as_nvre}->{$cmp->{src} ? 'src' : $cmp->{rpm}->arch}}, $cmp unless $cmp->{done}; |
| 421 |
|
} |
| 422 |
|
$cmp->{done}++; |
| 423 |
|
} |
| 424 |
|
if ( $srpm ) { |
| 425 |
|
foreach my $r ( sort { $repos->{$b}->{prio} <=> $repos->{$a}->{prio} } keys %reposrc ) { |
| 426 |
|
unless ( $reposrc{$r}->{srpm} ) { |
| 427 |
|
unshift @{$srpm->{repos}}, $r; |
| 428 |
|
$srpm->{oldrepo} = $srpm->{repo} unless $srpm->{oldrepo}; |
| 429 |
|
$srpm->{repo} = $r; |
| 430 |
|
$reposrc{$r}->{srpm} = $srpm; |
| 431 |
|
} |
| 432 |
|
} |
| 433 |
|
} elsif ( scalar keys %pkgs && $opts{s} ) { |
| 434 |
|
print "\n * missing source ($disttag$ver, ", $pkg->{repo}, ", ", $pkg->{svr}, ")\n"; |
| 435 |
|
} |
| 436 |
|
print "\n * missing originals ($disttag$ver, ", $pkg->{repo}, ", ", $pkg->{svr}, ")\n" if $opts{o} && scalar keys %orig != scalar keys %pkgs; |
| 437 |
|
} |
| 438 |
|
|
| 439 |
|
foreach my $r ( keys %$acnt ) { |
| 440 |
|
foreach my $p ( keys %{$acnt->{$r}} ) { |
| 441 |
|
foreach my $a ( keys %{$acnt->{$r}->{$p}} ) { |
| 442 |
|
if ( $a eq 'noarch' ) { |
| 443 |
|
my $p2 = ${$acnt->{$r}->{$p}->{$a}}[0]; |
| 444 |
|
if ( ! $p2->{repos} && scalar @{$acnt->{$r}->{$p}->{$a}} != scalar @{$distrepo->{$ver}->{'archs'}} ) { |
| 445 |
|
$p2->{oldrepo} = $p2->{repo}; |
| 446 |
|
push @{$p2->{repos}}, $p2->{repo}; |
| 447 |
|
} |
| 448 |
|
} elsif ( scalar @{$acnt->{$r}->{$p}->{$a}} != 1 ) { |
| 449 |
|
print "\n * many packages ($r, $a, $p)\n" unless $p =~ m{^syslinux-nonlinux-[0-9]}; |
| 450 |
|
} |
| 451 |
|
} |
| 452 |
|
} |
| 453 |
|
} |
| 454 |
|
|
| 455 |
|
foreach my $pkg ( sort { $a->{nvra} cmp $b->{nvra} } @{$rpms->{$base}->{rpms}} ) { |
| 456 |
|
if ( $pkg->{latest} && $pkg->{latest} == 1 ) { |
| 457 |
|
unless ( grep { $_->{nvra} eq $pkg->{nvra} && $_->{repo} eq $stage } @{$rpms->{$base}->{rpms}} ) { |
| 458 |
|
$pkg->{oldrepo} = $pkg->{repo} unless $pkg->{oldrepo}; |
| 459 |
|
$pkg->{repo} = $stage; |
| 460 |
|
push @{$pkg->{repos}}, $stage; |
| 461 |
|
} |
| 462 |
|
} |
| 463 |
|
|
| 464 |
|
if ( ! $print && ($pkg->{delete} || $pkg->{repos} || ( ! $repos->{$pkg->{repo}}->{base} && $pkg->{nosig} && $distrepo->{$ver}->{sign} ) ) ) { |
| 465 |
|
print "\n$base ($disttag$ver)\n", "=" x length("$base ($disttag$ver)"), "\n"; |
| 466 |
|
$print++; |
| 467 |
|
} |
| 468 |
|
|
| 469 |
|
my $src = $pkg->{rpm}->filename; |
| 470 |
|
if ( ! $repos->{$pkg->{repo}}->{base} && $pkg->{nosig} && $distrepo->{$ver}->{sign} ) { |
| 471 |
|
print "sign package (", basename($pkg->{rpm}->filename), ")\n"; |
| 472 |
|
unless ( $opts{t} ) { |
| 473 |
|
qx(cat $HOME/.rpmpass | setsid rpm -D '_gpg_name $distrepo->{$ver}->{keyname}' --addsign $src >& /dev/null); |
| 474 |
|
if ($?) { |
| 475 |
|
print " * failed to sign package\n"; |
| 476 |
|
next; |
| 477 |
|
} |
| 478 |
|
} |
| 479 |
|
} |
| 480 |
|
|
| 481 |
|
if ( $pkg->{repos} ) { |
| 482 |
|
foreach my $repo ( @{$pkg->{repos}} ) { |
| 483 |
|
if ( $pkg->{delete} ) { |
| 484 |
|
print "move from ", $pkg->{oldrepo}, " to $repo (", basename($pkg->{rpm}->filename), ")\n"; |
| 485 |
|
$pkg->{delete} = 0; |
| 486 |
|
$repochg{$pkg->{oldrepo}}++ unless $repos->{$pkg->{oldrepo}}->{base} || $repos->{$pkg->{oldrepo}}->{stage}; |
| 487 |
|
} elsif ( $pkg->{oldrepo} eq $repo ) { |
| 488 |
|
print "distribute noarch in $repo (", basename($pkg->{rpm}->filename), ")\n"; |
| 489 |
|
} else { |
| 490 |
|
print "copy from ", $pkg->{oldrepo}, " to $repo (", basename($pkg->{rpm}->filename), ")\n"; |
| 491 |
|
} |
| 492 |
|
$repochg{$repo}++ unless $repos->{$repo}->{base} || $repos->{$repo}->{stage}; |
| 493 |
|
$pkg->{oldrepo} = $repo unless $pkg->{oldrepo} eq ${$pkg->{repos}}[0]; |
| 494 |
|
|
| 495 |
|
my @d = (); |
| 496 |
|
my $head = $distrepo->{$ver}->{repo} . $repo . '/'; |
| 497 |
|
$head = $distrepo->{$ver}->{stage} if $repos->{$repo}->{stage}; |
| 498 |
|
my $tail = $repos->{$repo}->{os} ? "$osdir/" : 'RPMS/'; |
| 499 |
|
if ( $pkg->{src} ) { |
| 500 |
|
push @d, "${head}SRPMS/" . basename($pkg->{rpm}->filename); |
| 501 |
|
} elsif ( $pkg->{rpm}->arch eq 'noarch' ) { |
| 502 |
|
push @d, map { "${head}$_/$tail" . basename($pkg->{rpm}->filename) } @{$distrepo->{$ver}->{'archs'}}; |
| 503 |
|
} elsif ($ver>=10 && $pkg->{rpm}->arch =~ m{^(i[356]86)$} && $pkg->{arch} =~ m{^(x86_64)$} ) { |
| 504 |
|
#add copy of i686 packages in x86_64 folder for SME>=10 |
| 505 |
|
push @d, map { "${head}$_/$tail" . basename($pkg->{rpm}->filename) } @{$distrepo->{$ver}->{'archs'}}; |
| 506 |
|
} elsif ( $pkg->{rpm}->arch =~ m{^(i[356]86)$} ) { |
| 507 |
|
push @d, "${head}i386/$tail" . basename($pkg->{rpm}->filename); |
| 508 |
|
} else { |
| 509 |
|
push @d, $head . $pkg->{rpm}->arch . "/$tail" . basename($pkg->{rpm}->filename); |
| 510 |
|
} |
| 511 |
|
foreach my $dest ( @d ) { |
| 512 |
|
qx(cp --preserve=timestamps $src $dest) unless $opts{t} || -f "$dest"; |
| 513 |
|
} |
| 514 |
|
|
| 515 |
|
} |
| 516 |
|
qx(rm -f $src) if exists $pkg->{delete} && ! $opts{t}; |
| 517 |
|
} elsif ( $pkg->{delete} ) { |
| 518 |
|
print "delete from ", $pkg->{repo}, " (", $pkg->{arch}, ", ", basename($pkg->{rpm}->filename), ")\n"; |
| 519 |
|
qx(rm -f $src) unless $opts{t}; |
| 520 |
|
$repochg{$pkg->{repo}}++ unless $repos->{$pkg->{repo}}->{base} || $repos->{$pkg->{repo}}->{stage}; |
| 521 |
|
if ( $repos->{$pkg->{repo}}->{orig} && ! $repos->{$pkg->{repo}}->{base} ) { |
| 522 |
|
my $tag = dirname(dirname($pkg->{rpm}->{filename})); |
| 523 |
|
qx(rm -f $tag/PUSHED) if ! $opts{t} && -d $tag && -f "$tag/PUSHED"; |
| 524 |
|
} |
| 525 |
|
} |
| 526 |
|
} |
| 527 |
|
|
| 528 |
|
if ( $rpms->{$base}->{srpms} ) { |
| 529 |
|
foreach my $pkg ( sort { $b->{rpm} cmp $a->{rpm} } @{$rpms->{$base}->{srpms}} ) { |
| 530 |
|
next if $pkg->{done} || $repos->{$pkg->{repo}}->{orig} || $repos->{$pkg->{repo}}->{base}; |
| 531 |
|
$pkg->{delete}++; |
| 532 |
|
my $src = $pkg->{rpm}->filename; |
| 533 |
|
if ( ! $print && ($pkg->{delete} || $pkg->{repos} || ( $pkg->{nosig} && $distrepo->{$ver}->{sign} ) ) ) { |
| 534 |
|
print "\n$base ($disttag$ver)\n", "=" x length("$base ($disttag$ver)"), "\n"; |
| 535 |
|
$print++; |
| 536 |
|
} |
| 537 |
|
print "delete from ", $pkg->{repo}, " (", $pkg->{arch}, ", ", basename($pkg->{rpm}->filename), ")\n"; |
| 538 |
|
qx(rm -f $src) unless $opts{t}; |
| 539 |
|
$repochg{$pkg->{repo}}++ unless $repos->{$pkg->{repo}}->{base} || $repos->{$pkg->{repo}}->{stage}; |
| 540 |
|
} |
| 541 |
|
} |
| 542 |
|
} |
| 543 |
|
|
| 544 |
|
if ( %repochg ) { |
| 545 |
|
print "\nrebuild repo ($disttag$ver)\n", "=" x length("rebuild repo ($disttag$ver)"), "\n"; |
| 546 |
|
} |
| 547 |
|
foreach my $repo ( sort { $repos->{$b}->{prio} <=> $repos->{$a}->{prio} } keys %repochg ) { |
| 548 |
|
next if $repos->{$repo}->{orig} || $repos->{$repo}->{stage}; |
| 549 |
|
foreach my $arch ( @{$distrepo->{$ver}->{'archs'}} ) { |
| 550 |
|
my $dir = $distrepo->{$ver}->{repo} . "$repo/$arch"; |
| 551 |
|
$dir = qx(readlink -f $dir); |
| 552 |
|
if ( $dir ) { |
| 553 |
|
chomp $dir; |
| 554 |
|
} else { |
| 555 |
|
$dir = $distrepo->{$ver}->{repo} . "$repo/$arch"; |
| 556 |
|
} |
| 557 |
|
print "rebuild $repo/$arch\n"; |
| 558 |
|
unless ( $opts{t} ) { |
| 559 |
|
my $checksum = "--checksum $distrepo->{$ver}->{checksum}"; |
| 560 |
|
|
| 561 |
|
my $exclude = ""; |
| 562 |
|
$exclude .= " --exclude ${osdir}/*" if -d "$dir/Packages"; |
| 563 |
|
$exclude .= " --exclude *smeserver-release*.rpm" if $dir =~ m{test/|-testing/}; |
| 564 |
|
|
| 565 |
|
my $groupfile = ""; |
| 566 |
|
$groupfile = "--simple-md-filenames --groupfile repodata/comps.xml" if -f "$dir/repodata/comps.xml"; |
| 567 |
|
|
| 568 |
|
qx(createrepo --update --database --exclude *.src.rpm --exclude *-debuginfo-*.rpm $checksum $exclude $groupfile $dir); |
| 569 |
|
qx(repoview $dir); |
| 570 |
|
|
| 571 |
|
qx(rm -rf $dir/.olddata) if -d "$dir/.olddata"; |
| 572 |
|
qx(rm -rf $dir/.repodata) if -d "$dir/.repodata"; |
| 573 |
|
qx(rm -rf $dir/repodata/index.html) if -f "$dir/repodata/index.html"; |
| 574 |
|
qx(rm -rf $dir/repodata/update-info) if -d "$dir/repodata/update-info"; |
| 575 |
|
qx(rm -rf $dir/repodata/repoview) if -d "$dir/repodata/repoview"; |
| 576 |
|
} |
| 577 |
|
} |
| 578 |
|
} |
| 579 |
|
unless ( $opts{t} ) { |
| 580 |
|
foreach (@{$distrepo->{$ver}->{'builds'}}) |
| 581 |
|
{ |
| 582 |
|
finddepth(sub{rmdir}, "$_") if -d "$_"; |
| 583 |
|
} |
| 584 |
|
finddepth(sub{rmdir}, $distrepo->{$ver}->{'community'}) if -d "$distrepo->{$ver}->{'community'}"; |
| 585 |
} |
} |
|
printline('white', 0, 'Base (Centos: ', $distrepo->{$smever}->{centos}, ', Fedora: ', $distrepo->{$smever}->{fedora}, ") packages loaded.\n"); |
|
|
|
|
|
%latest = (); |
|
|
foreach my $name ( sort keys %{{ map { $_->{base} => 1 } @rpms }} ) { |
|
|
printline('white', 0, "Processing: $name"); |
|
|
my @pkgs = sort pkgsrt grep { $_->{base} eq $name } @rpms; |
|
|
my %seen = (); |
|
|
my $count = (); |
|
|
$archs = (); |
|
|
|
|
|
foreach my $pkg ( @pkgs ) { |
|
|
next if $pkg->{done} || $pkg->{obsolete} || $pkg->{rpm}->is_source_package || ! $repos->{$pkg->{repo}}; |
|
|
printline('bold black', 1, ' - ', $pkg->{rpm}->filename) if $opts{d}; |
|
|
my $orig = 0; |
|
|
|
|
|
# Find names of packages in same or higher repos |
|
|
my %names = names($pkg, @pkgs); |
|
|
|
|
|
# Stage packages should never be most current |
|
|
if ( rprop($pkg, 'stage') ) { |
|
|
tagpkg($pkg, 'obsolete'); |
|
|
next; |
|
|
} |
|
|
|
|
|
# Move packages from base/builds to correct area |
|
|
elsif ( rprop($pkg, 'base') || rprop($pkg, 'builds') ) { |
|
|
printline('dark blue', 1, ' - checking base/builds') if $opts{d}; |
|
|
my $repo = $names{$pkg->{name}} && $names{$pkg->{name}} > 1 ? $devel2 : $devel1; |
|
|
if ( $pkg->{nonbase} ) { |
|
|
foreach my $up ( @pkgs ) { |
|
|
next if rprop($up, 'builds') || rprop($up, 'base'); |
|
|
next if $up->{name} ne $pkg->{name} || ! $up->{obsolete} || $up->{rpm} ge $pkg->{rpm}; |
|
|
$repo = $up->{repo}; |
|
|
last; |
|
|
} |
|
|
} |
|
|
next if rprop($pkg, 'base') && $repo eq $devel1 && $devel1 ne $devel2; |
|
|
movepkg($pkg, $repo); |
|
|
%names = names($pkg, @pkgs); |
|
|
$seen{$pkg->{nvra}}++; |
|
|
$orig++; |
|
|
} |
|
|
|
|
|
# Check version/release counts |
|
|
unless ( $pkg->{nonbase} ) { |
|
|
printline('dark blue', 1, ' - checking version/release counts') if $opts{d}; |
|
|
$count->{$pkg->{repo}}->{$pkg->{version}}->{$pkg->{release}}++; |
|
|
if ( rprop($pkg, 'ver') && scalar keys %{$count->{$pkg->{repo}}} > rprop($pkg, 'ver') ) { |
|
|
movepkg($_, 'delete') foreach grep { $_->{rpm} eq $pkg->{rpm} } @pkgs; |
|
|
next; |
|
|
} |
|
|
if ( rprop($pkg, 'rel') && scalar keys %{$count->{$pkg->{repo}}->{$pkg->{version}}} > rprop($pkg, 'rel') ) { |
|
|
movepkg($_, 'delete') foreach grep { $_->{rpm} eq $pkg->{rpm} } @pkgs; |
|
|
next; |
|
|
} |
|
|
} |
|
|
|
|
|
foreach my $cmp ( grep { $_->{rpm}->is_source_package || ( ! $_->{done} && $_->{rpm} le $pkg->{rpm} && rprop($_, 'prio') <= rprop($pkg, 'prio') ) } @pkgs ) { |
|
|
printline('dark blue', 1, ' - ', $cmp->{rpm}->filename) if $opts{d}; |
|
|
if ( $cmp->{rpm}->is_source_package ) { |
|
|
if ( $cmp->{name} eq $pkg->{base} ) { |
|
|
if ( $cmp->{rpm} eq $pkg->{rpm} ) { |
|
|
if ( $pkg->{repo} eq $cmp->{repo} || ! $pkg->{srpm} || $pkg->{srpm}->{rpm} ne $pkg->{rpm} ) { |
|
|
delete $pkg->{srpm}->{latest} if $pkg->{latest} && $pkg->{srpm} && $pkg->{srpm}->{latest}; |
|
|
$pkg->{srpm} = $cmp; |
|
|
$pkg->{srpm}->{latest}++ if $pkg->{latest}; |
|
|
} |
|
|
if ( $pkg->{latest} && rprop($cmp, 'stage') ) { |
|
|
tagpkg($cmp, 'inuse'); |
|
|
$pkg->{srpm}->{latest}++; |
|
|
} |
|
|
tagpkg($cmp, 'inuse') if $pkg->{repo} eq $cmp->{repo} || rprop($cmp, 'base') || rprop($cmp, 'builds'); |
|
|
} |
|
|
next if $pkg->{srpm} && $pkg->{srpm}->{rpm} eq $pkg->{rpm}; |
|
|
|
|
|
my $src = $pkg->{rpm}->sourcerpm; |
|
|
my $source = basename $cmp->{rpm}->filename; |
|
|
SRC: { |
|
|
$src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{\.el\d\.at(\.src)}{$1} && $src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{\.el\d(\.rf\.src)}{$1} && $src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{(\d+)\.\d+\.el\d(\.rf\.src)}{$1$2} && $src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{\.el\d\.rf(\.src)}{.dag$1} && $src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{(\d+)\.\d+\.el\d\.rf(\.src)}{$1.dag$2} && $src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{\.el\d(\.src)}{$1} && $src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{(-\d+)\.\d+\.el\d(\.src)}{$1$2} && $src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{\.centos\d(\.src)}{$1} && $src eq $source && last SRC; |
|
|
($src = $pkg->{rpm}->sourcerpm) =~ s{\.el\d\.sme(\.src)}{$1} && $src eq $source && last SRC; |
|
|
$src = ''; |
|
|
} |
|
|
if ( $src eq $source && ( ! $pkg->{srpm} || $pkg->{srpm}->{rpm} eq $cmp->{rpm} ) ) { |
|
|
if ( ! $pkg->{srpm} || $pkg->{repo} eq $cmp->{repo} ) { |
|
|
delete $pkg->{srpm}->{latest} if $pkg->{latest} && $pkg->{srpm} && $pkg->{srpm}->{latest}; |
|
|
$pkg->{srpm} = $cmp; |
|
|
$pkg->{srpm}->{latest}++ if $pkg->{latest}; |
|
|
} |
|
|
if ( $pkg->{latest} && rprop($cmp, 'stage') ) { |
|
|
tagpkg($cmp, 'inuse'); |
|
|
$pkg->{srpm}->{latest}++; |
|
|
} |
|
|
tagpkg($cmp, 'inuse') if $pkg->{repo} eq $cmp->{repo} || rprop($cmp, 'base') || rprop($cmp, 'builds'); |
|
|
} |
|
|
} |
|
|
} elsif ( $cmp->{rpm} eq $pkg->{rpm} ) { |
|
|
if ( $names{$cmp->{name}} ) { |
|
|
if ( $pkg->{repo} eq $cmp->{repo} ) { |
|
|
tagpkg($cmp, 'correct', 1); |
|
|
$seen{$cmp->{nvra}}++; |
|
|
} elsif ( $seen{$cmp->{nvra}} && rprop($cmp, 'stage') && $pkg->{latest} ) { |
|
|
$_->{latest}++ foreach grep { $_->{nvra} eq $cmp->{nvra} && $_->{latest} && $_->{done} } @pkgs; |
|
|
tagpkg($cmp, 'correct', 1); |
|
|
} elsif ( $seen{$cmp->{nvra}} ) { |
|
|
$orig++ if rprop($cmp, 'base') || rprop($cmp, 'builds'); |
|
|
movepkg($cmp, 'delete', 1); |
|
|
} else { |
|
|
movepkg($cmp, $pkg->{repo}, 1, 1); |
|
|
$seen{$cmp->{nvra}}++; |
|
|
} |
|
|
} else { |
|
|
tagpkg($cmp, 'nonbase'); |
|
|
} |
|
|
} elsif ( rprop($cmp, 'prio') < rprop($pkg, 'prio') ) { |
|
|
tagpkg($cmp, 'obsolete'); |
|
|
} |
|
|
} |
|
|
printline('dark blue', 1, ' - checking source packages') if $opts{d}; |
|
|
if ( ! $pkg->{srpm} ) { |
|
|
printline('bold yellow on_red', 1, ' - ', $pkg->{rpm}->filename, ' (missing source ', $pkg->{rpm}->sourcerpm, ')'); |
|
|
} elsif ( $pkg->{srpm}->{repo} ne $pkg->{repo} ) { |
|
|
movepkg($pkg->{srpm}, $pkg->{repo}, 0); |
|
|
} |
|
|
unless ( $orig ) { |
|
|
foreach ( grep { $_->{base} eq $pkg->{base} && $_->{repo} eq $pkg->{repo} } @pkgs ) { |
|
|
printline('bold yellow on_red', 1, ' - ', $_->{rpm}->filename, ' (missing original)'); |
|
|
} |
|
|
} |
|
|
} |
|
|
printline('bold black', 1, ' - missing stage packages') if $opts{d}; |
|
|
movepkg($_, $stage, 0) foreach grep { $_->{latest} && $_->{latest} == 1 } @pkgs; |
|
|
|
|
|
printline('bold black', 1, ' - obsolete packages') if $opts{d}; |
|
|
movepkg($_, 'delete') foreach grep { ! rprop($_, 'base') && ! $_->{done} && ( $_->{obsolete} || ( $_->{rpm}->is_source_package && ! $_->{inuse} ) ) } @pkgs; |
|
|
|
|
|
printline('bold black', 1, ' - arch count check') if $opts{d}; |
|
|
foreach my $r ( keys %$archs ) { |
|
|
foreach my $p ( keys %{$archs->{$r}} ) { |
|
|
foreach my $a ( keys %{$archs->{$r}->{$p}} ) { |
|
|
my $p2 = ${$archs->{$r}->{$p}->{$a}}[0]; |
|
|
if ( $a eq 'noarch' ) { |
|
|
movepkg($p2, $p2->{repo}, 0) if ! $p2->{repos} && scalar @{$archs->{$r}->{$p}->{$a}} != scalar @archs; |
|
|
} elsif ( scalar @{$archs->{$r}->{$p}->{$a}} != 1 ) { |
|
|
printline('bold yellow on_red', 1, ' - ', $p2->{rpm}->filename, ' (many arch)'); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
printline('white', 0, "Finished processing.\n"); |
|
|
|
|
|
unless ( $opts{t} || $opts{r} ) { |
|
|
my %repochg = (); |
|
|
# Move / Copy / Delete packages and tag repo for rebuild. |
|
|
foreach my $pkg ( grep { $_->{oldrepo} } @rpms ) { |
|
|
printline('white', 0, 'Copy/move: ', $pkg->{rpm}->filename); |
|
|
my $src = $pkg->{rpm}->filename; |
|
|
|
|
|
qx(cat $HOME/.rpmpass | setsid rpm --addsign $src >& /dev/null) if $pkg->{nosig}; |
|
|
if ( $pkg->{repos} ) { |
|
|
foreach my $dest ( dest($pkg, @{$pkg->{repos}}) ) { |
|
|
qx(cp --preserve=timestamps $src $dest) unless -f "$dest"; |
|
|
} |
|
|
$repochg{$_}++ foreach @{$pkg->{repos}}; |
|
|
} |
|
|
if ( $pkg->{remove} ) { |
|
|
qx(rm -f $src); |
|
|
$repochg{$pkg->{oldrepo}}++; |
|
|
} |
|
|
} |
|
|
finddepth(sub{rmdir}, $distrepo->{$rel}->{builds}); |
|
|
printline('white', 0, "Finished copying/moving.\n"); |
|
|
|
|
|
foreach my $repo ( sort keys %repochg ) { |
|
|
next if ! $repos->{$repo} || $repos->{$repo}->{base} || $repos->{$repo}->{builds} || $repos->{$repo}->{stage}; |
|
|
foreach my $arch ( @archs ) { |
|
|
my $dir = $distrepo->{$rel}->{repo} . "$repo/$arch"; |
|
|
$dir = qx(readlink -f $dir); |
|
|
chomp $dir; |
|
|
printline('white', 0, "Createrepo: $repo/$arch"); |
|
|
qx(createrepo $dir); |
|
|
printline('white', 0, "Repoview: $repo/$arch"); |
|
|
qx(repoview $dir); |
|
|
qx(rm -rf $dir/.olddata) if -d "$dir/.olddata"; |
|
|
qx(rm -rf $dir/.repodata) if -d "$dir/.repodata"; |
|
|
} |
|
|
} |
|
|
printline('white', 0, "Finished rebuilding repos.\n"); |
|
|
} |
|
|
|
|
|
print "\n================================================================================\n\n"; |
|
| 586 |
} |
} |
| 587 |
|
|
| 588 |
sub pkgsrt { |
sub verrel { |
|
return $a->{rpm}->is_source_package <=> $b->{rpm}->is_source_package || $b->{rpm} cmp $a->{rpm} || rprop($b, 'prio') <=> rprop($a, 'prio'); |
|
|
} |
|
|
|
|
|
sub rprop { |
|
|
my ($pkg, $prop) = @_; |
|
|
return $repos->{$pkg->{repo}} ? $repos->{$pkg->{repo}}->{$prop} : 0; |
|
|
} |
|
|
|
|
|
sub names { |
|
| 589 |
my $pkg = shift; |
my $pkg = shift; |
| 590 |
my @rpms = @_; |
my $repo = shift; |
| 591 |
return map { $_->{name} => rprop($_, 'inc') ? 2 : 1 } grep { $_->{base} eq $pkg->{base} && |
my $counts = shift; |
|
rprop($_, 'prio') >= rprop($pkg, 'prio') && |
|
|
! rprop($_, 'base') && |
|
|
! rprop($_, 'builds') && |
|
|
! $_->{rpm}->is_source_package |
|
|
} @rpms; |
|
|
} |
|
|
|
|
|
sub dest { |
|
|
my ($pkg, @repos) = @_; |
|
|
my @d = (); |
|
|
foreach my $repo ( @repos ) { |
|
|
my $base = $distrepo->{$rel}->{repo} . $repo; |
|
|
$base = $distrepo->{$rel}->{stage} if $repos->{$repo}->{stage}; |
|
|
if ( $pkg->{arch} eq 'noarch' ) { |
|
|
push @d, "$base/i386/" . |
|
|
( $repos->{$repo}->{os} ? $distrepo->{$rel}->{os} : 'RPMS/' ) . |
|
|
basename $pkg->{rpm}->filename; |
|
|
push @d, "$base/x86_64/" . |
|
|
( $repos->{$repo}->{os} ? $distrepo->{$rel}->{os} : 'RPMS/' ) . |
|
|
basename $pkg->{rpm}->filename; |
|
|
} elsif ( $pkg->{arch} =~ m{^(i[356]86)$} ) { |
|
|
push @d, "$base/i386/" . |
|
|
( $repos->{$repo}->{os} ? $distrepo->{$rel}->{os} : 'RPMS/' ) . |
|
|
basename $pkg->{rpm}->filename; |
|
|
} elsif ( $pkg->{arch} eq 'x86_64' ) { |
|
|
push @d, "$base/x86_64/" . |
|
|
( $repos->{$repo}->{os} ? $distrepo->{$rel}->{os} : 'RPMS/' ) . |
|
|
basename $pkg->{rpm}->filename; |
|
|
} elsif ( $pkg->{arch} eq 'zsrc' ) { |
|
|
push @d, "$base/SRPMS/" . |
|
|
basename $pkg->{rpm}->filename; |
|
|
} else { |
|
|
printline('bold yellow on_red', 1, ' - ', $pkg->{rpm}->filename, ' (bad arch: ', $pkg->{arch}, ')'); |
|
|
} |
|
|
} |
|
|
return @d; |
|
|
} |
|
|
|
|
|
sub movepkg { |
|
|
my ($pkg, $repo, $done, $remove) = @_; |
|
|
defined $done or $done = 2; |
|
|
defined $remove or $remove = 0; |
|
|
$remove = 0 if rprop($pkg, 'base') || rprop($pkg, 'builds'); |
|
|
$remove = 1 if $repo eq 'delete'; |
|
|
|
|
|
if ( $repo eq 'delete' && ( rprop($pkg, 'base') || ( rprop($pkg, 'builds') && $done == 1 ) ) ) { |
|
|
tagpkg($pkg, 'inuse', 1); |
|
|
} else { |
|
|
printline('bold magenta', 1, " - ($repo) ", $pkg->{rpm}->filename) if $opts{d}; |
|
|
my $color = 'bold white'; |
|
|
$color = 'bold yellow' if rprop($pkg, 'builds'); |
|
|
$color = 'dark green' if $repos->{$repo} && $repos->{$repo}->{devel}; |
|
|
$color = 'dark red' if $repo eq 'delete'; |
|
|
push @{$pkg->{repos}}, $repo unless $repo eq 'delete'; |
|
|
$pkg->{oldrepo} = $pkg->{repo} unless $pkg->{oldrepo}; |
|
|
$pkg->{repo} = $repo; |
|
|
$pkg->{remove}++ if $remove; |
|
|
printline($color, 1, ' - ', $pkg->{rpm}->filename, ' (', $pkg->{oldrepo}, " to $repo)") if $opts{v} || $opts{d}; |
|
|
done($pkg) if $done; |
|
|
} |
|
|
} |
|
| 592 |
|
|
| 593 |
sub tagpkg { |
return 0 if $pkg->{src}; |
| 594 |
my ($pkg, $tag, $done) = @_; |
$counts->{$repo}->{$pkg->{ver}}->{$pkg->{rel}}++; |
| 595 |
defined $done or $done = 0; |
return 1 if $repos->{$repo}->{ver} && scalar keys %{$counts->{$repo}} > $repos->{$repo}->{ver}; |
| 596 |
|
return 1 if $repos->{$repo}->{rel} && scalar keys %{$counts->{$repo}->{$pkg->{ver}}} > $repos->{$repo}->{rel}; |
| 597 |
printline('bold magenta', 1, " - ($tag) ", $pkg->{rpm}->filename) if $opts{d}; |
return 0; |
|
delete $pkg->{obsolete} if $pkg->{obsolete}; |
|
|
$pkg->{$tag}++; |
|
|
done($pkg) if $done; |
|
| 598 |
} |
} |
| 599 |
|
|
| 600 |
sub done { |
sub pkgdest { |
| 601 |
my $pkg = shift; |
my $pkg = shift; |
| 602 |
printline('bold yellow on_red', 1, " - ", $pkg->{rpm}->filename, " (already processed)") if $pkg->{done}; |
my $dest = shift; |
| 603 |
$pkg->{done}++; |
my $hirepo = shift; |
| 604 |
delete $pkg->{obsolete} if $pkg->{obsolete}; |
my $pkgs = shift; |
| 605 |
|
|
| 606 |
if ( $repos->{$pkg->{repo}} && ! rprop($pkg, 'base') && ! rprop($pkg, 'builds') ) { |
foreach my $cmp ( @$pkgs ) { |
| 607 |
# FIXME: Nasty hack for comps package |
next if $cmp->{src} || $repos->{$cmp->{repo}}->{prio} <= $repos->{$dest}->{prio}; |
| 608 |
if ( $pkg->{name} eq 'comps' ) { |
next if $pkg->{name} ne ( $pkg->{src} ? $cmp->{base} : $cmp->{name} ); |
| 609 |
if ( ! $latest{$pkg->{name}.'.'.$pkg->{arch}} || $latest{$pkg->{name}.'.'.$pkg->{arch}}->{rpm} eq $pkg->{rpm} ) { |
if ( $repos->{$cmp->{repo}}->{prio} > $repos->{$hirepo}->{prio} ) { |
| 610 |
if ( rprop($pkg, 'inc') && ! $pkg->{rpm}->is_source_package ) { |
$dest = $hirepo; |
| 611 |
$latest{$pkg->{name}.'.'.$pkg->{arch}} = $pkg if ! $latest{$pkg->{name}.'.'.$pkg->{arch}}; |
last; |
| 612 |
$pkg->{latest}++; |
} else { |
| 613 |
} |
$dest = $cmp->{repo}; |
| 614 |
} |
} |
| 615 |
} elsif ( ! $latest{$pkg->{name}} || $latest{$pkg->{name}}->{rpm} eq $pkg->{rpm} ) { |
} |
| 616 |
if ( rprop($pkg, 'inc') && ! $pkg->{rpm}->is_source_package ) { |
return $dest; |
| 617 |
$latest{$pkg->{name}} = $pkg if ! $latest{$pkg->{name}}; |
} |
| 618 |
$pkg->{latest}++; |
|
| 619 |
} |
sub process_rpm { |
| 620 |
} |
my $rpm = shift; |
| 621 |
unless ( $pkg->{oldrepo} ) { |
my $ver = shift; |
| 622 |
my $goodarch = 0; |
my $repo = shift; |
| 623 |
$goodarch++ if $pkg->{rpm}->filename =~ m{/(i386|x86_64)/.*\.noarch\.rpm$}; |
return unless $rpm =~ m{/([^/]*)-[^-]+-[^-]+\.\w+\.rpm$}; |
| 624 |
$goodarch++ if $pkg->{rpm}->filename =~ m{/i386/.*\.(i[56]86)\.rpm$}; |
my $base = $1; |
| 625 |
$goodarch++ if $pkg->{rpm}->filename =~ m{/(noarch|i[356]86|x86_64)/.*\.\1\.rpm$}; |
return unless ! $opts{r} || $base =~ m[$opts{r}]; |
| 626 |
printline('bold yellow on_red', 1, ' - ', $pkg->{rpm}->filename, ' (wrong arch)') unless $goodarch; |
return unless $latest{$base} || $sources{$base} || ! $repos->{$repo}->{base}; |
|
} |
|
|
push @{$archs->{$pkg->{repo}}->{$pkg->{rpm}->as_nvre}->{$pkg->{rpm}->is_source_package ? 'src' : $pkg->{rpm}->arch}}, $pkg; |
|
|
} |
|
|
} |
|
|
|
|
|
sub printline { |
|
|
my $color = shift; |
|
|
my $nline = shift; |
|
|
my $string = join '', @_; |
|
|
|
|
|
if ( $nline ) { |
|
|
print "\n" unless $newline; |
|
|
$newline++; |
|
|
} else { |
|
|
$newline = 0; |
|
|
print "\r\e[0K"; |
|
|
} |
|
|
print color $color; |
|
|
print $string; |
|
|
print color 'reset'; |
|
|
print "\n" if $nline; |
|
|
} |
|
|
|
|
|
sub loadpkg { |
|
|
printline('white', 0, "Loading: $_") if -d _; |
|
|
return unless m{/([^/]*)-[^-]+-[^-]+\.\w+.rpm} && ( ! $opts{r} || $1 =~ m{$opts{r}} ); |
|
| 627 |
|
|
| 628 |
my $pkg; |
my $pkg; |
| 629 |
eval { $pkg = RPM2->open_package($_, $rpm_flags); }; |
eval { $pkg = RPM2->open_package($rpm, $rpm_flags); }; |
| 630 |
if ($@) { printline('bold yellow on_red', 1, "Corrupt package $_"); return; } |
if ($@) { print " * corrupt package ($rpm)\n"; return; } |
| 631 |
eval { my $sig = $pkg->siggpg }; |
eval { my $sig = $pkg->siggpg }; |
|
my $nosig = ! $@; |
|
|
if ( $nosig && ! -f "$HOME/.rpmpass" ) { |
|
|
printline('bold yellow on_red', 1, ' - ', $pkg->filename, ' (missing signature)'); |
|
|
return; |
|
|
} |
|
|
|
|
|
my ($srcname, $version, $release) = ($pkg->is_source_package ? basename $pkg->filename : $pkg->sourcerpm) =~ m{^([^/]*)-([^-]+)-([^-]+)\.\w+.rpm}; |
|
|
foreach my $repo ( keys %{$skippkg->{$rel}} ) { return if (dirname $pkg->filename) =~ m{/$repo/} && grep { $_ eq $srcname } @{$skippkg->{$rel}->{$repo}}; } |
|
|
my $reponame = 'unknown'; |
|
|
if ( substr($_, 0, length($distrepo->{$rel}->{builds})) eq $distrepo->{$rel}->{builds} ) { |
|
|
$reponame = 'builds'; |
|
|
} elsif ( substr($_, 0, length($distrepo->{$rel}->{stage})) eq $distrepo->{$rel}->{stage} ) { |
|
|
$reponame = 'stage'; |
|
|
} elsif ( (dirname $pkg->filename) =~ m{\d/(sme[^/]+)/} ) { |
|
|
$reponame = $1; |
|
|
} |
|
|
|
|
|
push @rpms, { base => $srcname, |
|
|
name => $pkg->name, |
|
|
repo => $reponame, |
|
|
nvra => $pkg->name.'-'.$pkg->version.'-'.$pkg->release.'.'.( $pkg->is_source_package ? 'src' : $pkg->tag('ARCH') ), |
|
|
arch => $pkg->is_source_package ? 'zsrc' : $pkg->tag('ARCH'), |
|
|
version => $version, |
|
|
release => $release, |
|
|
rpm => $pkg, |
|
|
nosig => $nosig, |
|
|
}; |
|
|
$sources{$srcname}++; |
|
|
$latest{$pkg->name} = $rpms[$#rpms] if ! $pkg->is_source_package && ( ! $latest{$pkg->name} || $pkg gt $latest{$pkg->name}->{rpm} ); |
|
|
} |
|
| 632 |
|
|
| 633 |
sub loadbase { |
my $nosig = 1; |
| 634 |
printline('white', 0, "Loading: $_") if -d _; |
eval { my $sig = $pkg->dsaheader }; $nosig &= ! $@; |
| 635 |
return unless m{/([^/]*)-[^-]+-[^-]+\.\w+.rpm} && ($latest{$1} || $sources{$1}); |
eval { my $sig = $pkg->rsaheader }; $nosig &= ! $@; |
| 636 |
|
eval { my $sig = $pkg->siggpg }; $nosig &= ! $@; |
| 637 |
my $pkg; |
eval { my $sig = $pkg->sigpgp }; $nosig &= ! $@; |
|
eval { $pkg = RPM2->open_package($_, $rpm_flags); }; |
|
|
if ($@) { printline('bold yellow on_red', 1, "Corrupt package $_"); return; } |
|
|
eval { my $sig = $pkg->siggpg }; |
|
|
unless ($@) { printline('bold yellow on_red', 1, ' - ', $pkg->filename, ' (missing signature)'); return; } |
|
| 638 |
|
|
| 639 |
my $cmp = $latest{$pkg->name}; |
my $cmp = $latest{$pkg->name}; |
| 640 |
my ($srcname, $version, $release) = ($pkg->is_source_package ? basename $pkg->filename : $pkg->sourcerpm) =~ m{^([^/]*)-([^-]+)-([^-]+)\.\w+.rpm}; |
if ( $repos->{$repo}->{base} && ! $pkg->is_source_package ) { |
| 641 |
my $pkgrepo = 'base'; |
return unless $cmp; |
| 642 |
foreach my $repo ( keys %{$skippkg->{$rel}} ) { |
return if $repos->{$cmp->{repo}}->{base} && $repos->{$cmp->{repo}}->{prio} > $repos->{$repo}->{prio} && $pkg ge $cmp->{rpm}; |
| 643 |
if ( (dirname $pkg->filename) =~ m{/$repo/} ) { |
} |
| 644 |
return if grep { $_ eq $srcname } @{$skippkg->{$rel}->{$repo}}; |
my ($src, $version, $release) = ($pkg->is_source_package ? $pkg->filename : $pkg->sourcerpm) =~ m{(?:^|/)([^/]*)-([^-]+)-([^-]+)\.\w+\.rpm$}; |
| 645 |
$pkgrepo = $repo; |
return if $skippkg->{$ver}->{$repo} && ( $skippkg->{$ver}->{$repo}->{$src} || $skippkg->{$ver}->{$repo}->{$pkg->name} ); |
| 646 |
return unless $pkg->is_source_package || $cmp; |
return if $onlypkg->{$ver}->{$repo} && !( $onlypkg->{$ver}->{$repo}->{$src} || $onlypkg->{$ver}->{$repo}->{$pkg->name} ); |
| 647 |
return if ! $pkg->is_source_package && $pkg gt $cmp->{rpm} && rprop($cmp, 'base') && rprop($cmp, 'prio') > $repos->{$pkgrepo}->{prio}; |
return if $repos->{$repo}->{base} && $nosig && $baserepo->{$ver}->{sign}; |
| 648 |
last; |
if ( $nosig && ! -f "$HOME/.rpmpass" ) { print " * missing signature (" .$pkg->filename . ")\n"; return; } |
| 649 |
} |
my $arch = 'unknown'; |
| 650 |
|
$arch = 'SRPMS' if $pkg->filename =~ m{[/-](SRPMS?|src|source)/}; |
| 651 |
|
$arch = 'x86_64' if $pkg->filename =~ m{[/-]x86_64/}; |
| 652 |
|
$arch = 'i386' if $pkg->filename =~ m{[/-](i[356]86)/}; |
| 653 |
|
$arch = 'noarch' if $pkg->filename =~ m{[/-]noarch/}; |
| 654 |
|
|
| 655 |
|
my $rpmhash = { base => $src, |
| 656 |
|
name => $pkg->name, |
| 657 |
|
repo => $repo, |
| 658 |
|
nvra => $pkg->name.'-'.$pkg->version.'-'.$pkg->release.'.'.( $pkg->is_source_package ? 'src' : $pkg->tag('ARCH') ), |
| 659 |
|
svr => $src.'-'.$version.'-'.$release, |
| 660 |
|
src => $pkg->is_source_package, |
| 661 |
|
arch => $arch, |
| 662 |
|
ver => $version, |
| 663 |
|
rel => $release, |
| 664 |
|
rpm => $pkg, |
| 665 |
|
nosig => $nosig, |
| 666 |
|
}; |
| 667 |
|
if ( $pkg->is_source_package ) { |
| 668 |
|
push @{$rpms->{$src}->{srpms}}, $rpmhash; |
| 669 |
|
push @{$rpms->{$src}->{vers}->{$rpmhash->{svr}}}, $rpmhash; |
| 670 |
|
} else { |
| 671 |
|
push @{$rpms->{$src}->{rpms}}, $rpmhash; |
| 672 |
} |
} |
| 673 |
|
$sources{$src}++; |
| 674 |
|
|
| 675 |
push @rpms, { base => $srcname, |
return if $pkg->is_source_package || $repos->{$repo}->{stage}; |
| 676 |
name => $pkg->name, |
if ( ! $repos->{$repo}->{base} ) { |
| 677 |
repo => $pkgrepo, |
if ( ! $cmp || $pkg gt $cmp->{rpm} ) { |
| 678 |
nvra => $pkg->name.'-'.$pkg->version.'-'.$pkg->release.'.'.( $pkg->is_source_package ? 'src' : $pkg->tag('ARCH') ), |
$latest{$pkg->name} = $rpmhash; |
| 679 |
arch => $pkg->is_source_package ? 'zsrc' : $pkg->tag('ARCH'), |
} |
| 680 |
version => $version, |
} elsif ( ( $repos->{$repo}->{prio} >= $repos->{$cmp->{repo}}->{prio} || ! $repos->{$cmp->{repo}}->{base} ) && $pkg ge $cmp->{rpm} ) { |
| 681 |
release => $release, |
$latest{$pkg->name} = $rpmhash; |
|
rpm => $pkg, |
|
|
nosig => 0, |
|
|
}; |
|
|
if ( ! $pkg->is_source_package && $pkg ge $cmp->{rpm} && ( $repos->{$pkgrepo}->{prio} >= rprop($cmp, 'prio') || ! rprop($cmp, 'base') ) ) { |
|
|
$latest{$pkg->name} = $rpms[$#rpms]; |
|
| 682 |
} |
} |
| 683 |
} |
} |
|
|
|
Parent Directory
| 
Revision Log
| 
Revision Graph
| 
Patch
