Annotation of /builds_bin/update_repos

#!/usr/bin/perl

use strict;
use warnings;
use RPM2;
use Data::Dumper;

sub compare($$);

my $releases = 2;

my $releasedir = '/releases';
my $smerel = '7';
my $arch = 'i386';
my $centosrel = '4';
my $fedorarel = '3';
my $builds = '/builds/rpms';
my $stagedir = '/builds';

my @repos = (
              "$releasedir/$smerel/smeos/$arch/CentOS/RPMS",
              "$releasedir/$smerel/smeos/$arch/SME/RPMS",
              "$releasedir/$smerel/smeos/$arch/RPMS",
              "$releasedir/$smerel/smeos/$arch/SME",
              "$releasedir/$smerel/smeupdates/$arch/RPMS",
              "$releasedir/$smerel/smeupdates-testing/$arch/RPMS",
              "$releasedir/$smerel/smeextras/$arch/RPMS",
              "$releasedir/$smerel/smeaddons/$arch/RPMS",
              "$releasedir/$smerel/smetest/$arch/RPMS",
              "$releasedir/$smerel/smedev/$arch/RPMS",
              "$builds/RPMS/$arch",
              "$builds/RPMS/i586",
              "$builds/RPMS/i686",
              "$builds/RPMS/noarch",
              "$stagedir/RPMS",
            );

my @srcrepos = (
                 "/mirrors/centos/$centosrel/fasttrack/SRPMS",
                 "/mirrors/centos/$centosrel/updates/SRPMS",
                 "/mirrors/centos/$centosrel/os/SRPMS",
                 "/mirrors/centos/$centosrel/extras/SRPMS",
                 "/mirrors/rpmforge/dag/source",
                 "/mirrors/atrpms/src/el$centosrel-$arch/atrpms/stable",
                 "/mirrors/fedora/epel/$centosrel/SRPMS",
                 "/mirrors/fedora/core/updates/$fedorarel/SRPMS",
                 "/mirrors/fedora/core/$fedorarel/source/SRPMS",
                 "/mirrors/fedora/extras/$fedorarel/SRPMS",
                 "$builds/SRPMS",
              );

my %repohash;
my %srcrepohash;
my %changed;
my %copy;
my @remove;

my $rpm_flags = RPM2->vsf_nodsaheader | RPM2->vsf_nodsa;

%{$srcrepohash{$stagedir}} = map { $_ => 0 } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, "$stagedir/SRPMS" );
closedir SRPMS;

foreach my $repo ( @repos ) {
        if ( $repo =~ m{^($releasedir/$smerel/sme[^/]*)/} ) {
                my $srcrepo = $1;

                %{$srcrepohash{$srcrepo}} = map { $_ => 0 } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, "$srcrepo/SRPMS" );
                closedir SRPMS;
        }

        opendir RPMS, $repo;
        foreach my $rpm ( grep { m{\.rpm} } readdir RPMS ) {
                my $header = RPM2->open_package("$repo/$rpm", $rpm_flags);
                my $pkg = $header->tag("NAME").".".$header->tag("ARCH");
                if ( $repo =~ m{$stagedir/RPMS} ) {
                        push @{$repohash{$pkg}{$stagedir}}, $header;
                } elsif ( $repo =~ m{$builds/RPMS} ) {
                        push @{$repohash{$pkg}{builds}}, $header;
                } elsif ( $repo =~ m{^($releasedir/$smerel/sme[^/]*)/} ) {
                        my $pos = $1;
                        push @{$repohash{$pkg}{$pos}}, $header;
                }
        }
        closedir RPMS;
}

my %sources;
foreach my $repo ( reverse @srcrepos ) {
        my %temp_repo = map { $_ => $repo } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, $repo );
        closedir SRPMS;

        %sources = (%sources, %temp_repo);
}

foreach my $pkg ( keys %repohash ) {
        foreach my $repo ( @repos ) {
                if ( $repo =~ m{$stagedir/RPMS} ) {
                        next unless $repohash{$pkg};
                        if ( $repohash{$pkg}{$stagedir} ) {
                                my ($latest, @rest) = sort { $b cmp $a } @{$repohash{$pkg}{$stagedir}};
                                delete $repohash{$pkg}{$stagedir};
                                push @remove, map { $_->filename } @rest if @rest;
                                if ( $repohash{$pkg}{latest} ) {
                                        if ($repohash{$pkg}{latest} ne $latest ) {
                                                push @remove, $latest->filename;
                                                push @{$copy{"$stagedir/RPMS"}}, $repohash{$pkg}{latest}->filename;
                                                $repohash{$pkg}{$stagedir} = $repohash{$pkg}{latest};
                                        } else {
                                                $repohash{$pkg}{$stagedir} = $latest;
                                        }
                                } else {
                                        push @remove, $latest->filename;
                                }
                        } elsif ( $repohash{$pkg}{latest} ) {
                                push @{$copy{"$stagedir/RPMS"}}, $repohash{$pkg}{latest}->filename;
                                $repohash{$pkg}{$stagedir} = $repohash{$pkg}{latest};
                        }
                } elsif ( $repo =~ m{^($releasedir/$smerel/sme[^/]*)/} ) {
                        my $pos = $1;
                        next unless $repohash{$pkg}{$pos};
                        if ( $pos =~ m{/smedev$} ) {
                                next unless $repohash{$pkg}{latest};
                                my @rest = grep { $_ le $repohash{$pkg}{latest} } @{$repohash{$pkg}{$pos}};
                                if ( @rest ) {
                                        push @remove, map { $_->filename } @rest;
                                        $changed{$pos}++;
                                        @{$repohash{$pkg}{$pos}} = grep { $_ gt $repohash{$pkg}{latest} } @{$repohash{$pkg}{$pos}};
                                        delete $repohash{$pkg}{$pos};
                                }
                        } else {
                                my ($latest, @rest) = sort { $b cmp $a } @{$repohash{$pkg}{$pos}};
                                delete $repohash{$pkg}{$pos};
                                if ( $repohash{$pkg}{latest} && $repohash{$pkg}{latest} ge $latest ) {
                                        push @rest, $latest;
                                } else {
                                        $repohash{$pkg}{latest} = $latest;
                                        $repohash{$pkg}{$pos} = $latest;
                                }
                                if ( @rest ) {
                                        push @remove, map { $_->filename } @rest;
                                        $changed{$pos}++;
                                }
                        }
                }
        }
}

print "\n";
foreach my $pkg ( sort grep { $repohash{$_}{builds} } keys %repohash ) {
        my %versions = ();
        foreach my $ver ( sort { $b cmp $a } @{$repohash{$pkg}{builds}} ) {
                next if $repohash{$pkg}{latest} && $repohash{$pkg}{latest} ge $ver;

                $versions{$ver->tag("VERSION")}++;
                if ( $versions{$ver->tag("VERSION")} > $releases || (scalar keys %versions) > $releases ) {
                        foreach my $rpm ( grep { $ver eq $_ } @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} ) {
                                push @remove, $rpm->filename;
                                @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} = grep { $rpm ne $_ } @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}};
                                $changed{"$releasedir/$smerel/smedev"}++;
                        }
                } else {
                        print "Possible update " . $ver->filename . "\n" if $repohash{$pkg}{latest};
                        if ( ! grep { $ver eq $_ } @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} ) {
                                push @{$copy{"$releasedir/$smerel/smedev/$arch/RPMS"}}, $ver->filename;
                                push @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}}, $ver;
                                $changed{"$releasedir/$smerel/smedev"}++;
                        }
                }
        }
}

foreach my $pkg ( grep { $repohash{$_}{"$releasedir/$smerel/smedev"} } keys %repohash ) {
        foreach my $rpm ( @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} ) {
                unless ( grep { $rpm eq $_ } @{$repohash{$pkg}{builds}} ) {
                        push @remove, $rpm->filename;
                        @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} = grep { $rpm ne $_ } @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}};
                        $changed{"$releasedir/$smerel/smedev"}++;
                }
        }
}

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/\.\d+\.el\d+\.rf\./\.rf\./);
                        push @sources, $src if ($src =~ s/\.el\d\.rf\./\.rf\./);
                        push @sources, $src if ($src =~ s/\.el\d\.at\./\.at\./);
                        push @sources, $src if ($src =~ s/\.fc\d\.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;
                }
        }

        foreach my $rpm ( keys %{$srcrepohash{$repo}} ) {
                unless ( $srcrepohash{$repo}{$rpm} ) {
                        push @remove, "$repo/SRPMS/$rpm";
                        $changed{$repo}++;
                }
        }
}

print "\n";
foreach my $repo ( sort keys %copy ) {
        foreach my $rpm ( sort keys %{{ map { $_ => 1 } @{$copy{$repo}} }} ) {
                print "copying $rpm to $repo/\n";
                system(qw(cp --preserve=timestamps), $rpm, "$repo/");
        }
}

print "\n";
foreach my $rpm ( sort keys %{{ map { $_ => 1 } @remove }} ) {
        print "removing $rpm\n";
        unlink $rpm;
}

print "\n";
foreach my $repo ( sort keys %changed ) {
        next if $repo =~ m{^$stagedir};

        print "rebuilding $repo/$arch...\n";
        system(qw(createrepo), "$repo/$arch");
        system(qw(repoview), "$repo/$arch");
}

1	slords	1.1	#!/usr/bin/perl
2
3			use strict;
4			use warnings;
5			use RPM2;
6			use Data::Dumper;
7
8			sub compare($$);
9
10			my $releases = 2;
11
12	slords	1.2	my $releasedir = '/releases';
13			my $smerel = '7';
14			my $arch = 'i386';
15			my $centosrel = '4';
16			my $fedorarel = '3';
17			my $builds = '/builds/rpms';
18	slords	1.1	my $stagedir = '/builds';
19	slords	1.2
20			my @repos = (
21			"$releasedir/$smerel/smeos/$arch/CentOS/RPMS",
22	slords	1.5	"$releasedir/$smerel/smeos/$arch/SME/RPMS",
23			"$releasedir/$smerel/smeos/$arch/RPMS",
24			"$releasedir/$smerel/smeos/$arch/SME",
25	slords	1.2	"$releasedir/$smerel/smeupdates/$arch/RPMS",
26			"$releasedir/$smerel/smeupdates-testing/$arch/RPMS",
27			"$releasedir/$smerel/smeextras/$arch/RPMS",
28			"$releasedir/$smerel/smeaddons/$arch/RPMS",
29			"$releasedir/$smerel/smetest/$arch/RPMS",
30			"$releasedir/$smerel/smedev/$arch/RPMS",
31			"$builds/RPMS/$arch",
32			"$builds/RPMS/i586",
33			"$builds/RPMS/i686",
34			"$builds/RPMS/noarch",
35			"$stagedir/RPMS",
36			);
37
38			my @srcrepos = (
39			"/mirrors/centos/$centosrel/fasttrack/SRPMS",
40			"/mirrors/centos/$centosrel/updates/SRPMS",
41			"/mirrors/centos/$centosrel/os/SRPMS",
42			"/mirrors/centos/$centosrel/extras/SRPMS",
43			"/mirrors/rpmforge/dag/source",
44			"/mirrors/atrpms/src/el$centosrel-$arch/atrpms/stable",
45	slords	1.4	"/mirrors/fedora/epel/$centosrel/SRPMS",
46	slords	1.2	"/mirrors/fedora/core/updates/$fedorarel/SRPMS",
47			"/mirrors/fedora/core/$fedorarel/source/SRPMS",
48			"/mirrors/fedora/extras/$fedorarel/SRPMS",
49			"$builds/SRPMS",
50			);
51	slords	1.1
52			my %repohash;
53			my %srcrepohash;
54			my %changed;
55			my %copy;
56			my @remove;
57
58	slords	1.2	my $rpm_flags = RPM2->vsf_nodsaheader \| RPM2->vsf_nodsa;
59
60	slords	1.1	%{$srcrepohash{$stagedir}} = map { $_ => 0 } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, "$stagedir/SRPMS" );
61			closedir SRPMS;
62
63			foreach my $repo ( @repos ) {
64	slords	1.2	if ( $repo =~ m{^($releasedir/$smerel/sme[^/]*)/} ) {
65			my $srcrepo = $1;
66	slords	1.1
67	slords	1.2	%{$srcrepohash{$srcrepo}} = map { $_ => 0 } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, "$srcrepo/SRPMS" );
68			closedir SRPMS;
69			}
70
71			opendir RPMS, $repo;
72			foreach my $rpm ( grep { m{\.rpm} } readdir RPMS ) {
73			my $header = RPM2->open_package("$repo/$rpm", $rpm_flags);
74			my $pkg = $header->tag("NAME").".".$header->tag("ARCH");
75			if ( $repo =~ m{$stagedir/RPMS} ) {
76			push @{$repohash{$pkg}{$stagedir}}, $header;
77			} elsif ( $repo =~ m{$builds/RPMS} ) {
78			push @{$repohash{$pkg}{builds}}, $header;
79			} elsif ( $repo =~ m{^($releasedir/$smerel/sme[^/]*)/} ) {
80			my $pos = $1;
81			push @{$repohash{$pkg}{$pos}}, $header;
82			}
83			}
84			closedir RPMS;
85	slords	1.1	}
86
87			my %sources;
88			foreach my $repo ( reverse @srcrepos ) {
89	slords	1.2	my %temp_repo = map { $_ => $repo } grep { /\.rpm$/ } readdir SRPMS if ( opendir SRPMS, $repo );
90			closedir SRPMS;
91	slords	1.1
92	slords	1.2	%sources = (%sources, %temp_repo);
93	slords	1.1	}
94
95			foreach my $pkg ( keys %repohash ) {
96	slords	1.2	foreach my $repo ( @repos ) {
97			if ( $repo =~ m{$stagedir/RPMS} ) {
98			next unless $repohash{$pkg};
99			if ( $repohash{$pkg}{$stagedir} ) {
100			my ($latest, @rest) = sort { $b cmp $a } @{$repohash{$pkg}{$stagedir}};
101			delete $repohash{$pkg}{$stagedir};
102			push @remove, map { $_->filename } @rest if @rest;
103			if ( $repohash{$pkg}{latest} ) {
104			if ($repohash{$pkg}{latest} ne $latest ) {
105			push @remove, $latest->filename;
106			push @{$copy{"$stagedir/RPMS"}}, $repohash{$pkg}{latest}->filename;
107			$repohash{$pkg}{$stagedir} = $repohash{$pkg}{latest};
108			} else {
109			$repohash{$pkg}{$stagedir} = $latest;
110			}
111			} else {
112			push @remove, $latest->filename;
113			}
114			} elsif ( $repohash{$pkg}{latest} ) {
115			push @{$copy{"$stagedir/RPMS"}}, $repohash{$pkg}{latest}->filename;
116			$repohash{$pkg}{$stagedir} = $repohash{$pkg}{latest};
117			}
118			} elsif ( $repo =~ m{^($releasedir/$smerel/sme[^/]*)/} ) {
119			my $pos = $1;
120			next unless $repohash{$pkg}{$pos};
121			if ( $pos =~ m{/smedev$} ) {
122			next unless $repohash{$pkg}{latest};
123			my @rest = grep { $_ le $repohash{$pkg}{latest} } @{$repohash{$pkg}{$pos}};
124			if ( @rest ) {
125			push @remove, map { $_->filename } @rest;
126			$changed{$pos}++;
127			@{$repohash{$pkg}{$pos}} = grep { $_ gt $repohash{$pkg}{latest} } @{$repohash{$pkg}{$pos}};
128			delete $repohash{$pkg}{$pos};
129			}
130			} else {
131			my ($latest, @rest) = sort { $b cmp $a } @{$repohash{$pkg}{$pos}};
132			delete $repohash{$pkg}{$pos};
133			if ( $repohash{$pkg}{latest} && $repohash{$pkg}{latest} ge $latest ) {
134			push @rest, $latest;
135			} else {
136			$repohash{$pkg}{latest} = $latest;
137			$repohash{$pkg}{$pos} = $latest;
138			}
139			if ( @rest ) {
140			push @remove, map { $_->filename } @rest;
141			$changed{$pos}++;
142			}
143			}
144			}
145			}
146	slords	1.1	}
147
148	slords	1.2	print "\n";
149	slords	1.1	foreach my $pkg ( sort grep { $repohash{$_}{builds} } keys %repohash ) {
150	slords	1.2	my %versions = ();
151			foreach my $ver ( sort { $b cmp $a } @{$repohash{$pkg}{builds}} ) {
152			next if $repohash{$pkg}{latest} && $repohash{$pkg}{latest} ge $ver;
153
154			$versions{$ver->tag("VERSION")}++;
155			if ( $versions{$ver->tag("VERSION")} > $releases \|\| (scalar keys %versions) > $releases ) {
156			foreach my $rpm ( grep { $ver eq $_ } @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} ) {
157			push @remove, $rpm->filename;
158			@{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} = grep { $rpm ne $_ } @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}};
159			$changed{"$releasedir/$smerel/smedev"}++;
160			}
161			} else {
162			print "Possible update " . $ver->filename . "\n" if $repohash{$pkg}{latest};
163			if ( ! grep { $ver eq $_ } @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} ) {
164			push @{$copy{"$releasedir/$smerel/smedev/$arch/RPMS"}}, $ver->filename;
165			push @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}}, $ver;
166			$changed{"$releasedir/$smerel/smedev"}++;
167			}
168			}
169			}
170			}
171
172			foreach my $pkg ( grep { $repohash{$_}{"$releasedir/$smerel/smedev"} } keys %repohash ) {
173			foreach my $rpm ( @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} ) {
174			unless ( grep { $rpm eq $_ } @{$repohash{$pkg}{builds}} ) {
175			push @remove, $rpm->filename;
176			@{$repohash{$pkg}{"$releasedir/$smerel/smedev"}} = grep { $rpm ne $_ } @{$repohash{$pkg}{"$releasedir/$smerel/smedev"}};
177			$changed{"$releasedir/$smerel/smedev"}++;
178			}
179			}
180	slords	1.1	}
181
182			print "\n";
183			foreach my $repo ( sort keys %srcrepohash ) {
184	slords	1.2	foreach my $pkg ( sort grep { $repohash{$_}{$repo} } keys %repohash ) {
185			my @rpms = ref($repohash{$pkg}{$repo}) eq "ARRAY" ? @{$repohash{$pkg}{$repo}} : ($repohash{$pkg}{$repo});
186			foreach my $rpm ( sort @rpms ) {
187			my $src = $rpm->tag("SOURCERPM");
188
189			my @sources = ();
190			push @sources, $src;
191			push @sources, $src if ($src =~ s/\.\d+\.el\d+\.rf\./\.rf\./);
192			push @sources, $src if ($src =~ s/\.el\d\.rf\./\.rf\./);
193			push @sources, $src if ($src =~ s/\.el\d\.at\./\.at\./);
194			push @sources, $src if ($src =~ s/\.fc\d\.at\./\.at\./);
195			push @sources, $src if ($src =~ s/\.rf\./\.dag\./);
196
197			my $found = 0;
198			foreach my $source ( @sources ) {
199			if ( $sources{$source} ) {
200			unless ( -f "$repo/SRPMS/$source" ) {
201			push @{$copy{"$repo/SRPMS"}}, "$sources{$source}/$source";
202			$changed{$repo}++;
203			}
204			$srcrepohash{$repo}{$source}++;
205			$found++;
206			last;
207			} elsif ( -f "$repo/SRPMS/$source" ) {
208			print "Found missing source $repo/SRPMS/$source for ".$rpm->as_nvre()."\n";
209			$srcrepohash{$repo}{$source}++;
210			$found++;
211			}
212			}
213			print "Can't find source for ".$rpm->as_nvre()."\n" unless $found;
214			}
215			}
216
217			foreach my $rpm ( keys %{$srcrepohash{$repo}} ) {
218			unless ( $srcrepohash{$repo}{$rpm} ) {
219			push @remove, "$repo/SRPMS/$rpm";
220			$changed{$repo}++;
221			}
222			}
223	slords	1.1	}
224
225			print "\n";
226			foreach my $repo ( sort keys %copy ) {
227	slords	1.2	foreach my $rpm ( sort keys %{{ map { $_ => 1 } @{$copy{$repo}} }} ) {
228			print "copying $rpm to $repo/\n";
229			system(qw(cp --preserve=timestamps), $rpm, "$repo/");
230			}
231	slords	1.1	}
232
233			print "\n";
234			foreach my $rpm ( sort keys %{{ map { $_ => 1 } @remove }} ) {
235	slords	1.2	print "removing $rpm\n";
236			unlink $rpm;
237	slords	1.1	}
238
239			print "\n";
240			foreach my $repo ( sort keys %changed ) {
241	slords	1.2	next if $repo =~ m{^$stagedir};
242	slords	1.1
243	slords	1.3	print "rebuilding $repo/$arch...\n";
244			system(qw(createrepo), "$repo/$arch");
245			system(qw(repoview), "$repo/$arch");
246	slords	1.1	}
247	slords	1.2