Contents of /builds_bin/update_repos

#!/usr/bin/perl

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

sub compare($$);

my $releases = 2;

my $rpm_flags =  RPM2->vsf_nodsa;
my $repodir = '/releases/7';
my $stagedir = '/builds';
my @repos = qw( 
                /releases/7/smeos/i386/CentOS/RPMS
                /releases/7/smeupdates/i386/RPMS
                /releases/7/smeupdates-testing/i386/RPMS
                /releases/7/smeextras/i386/RPMS
                /releases/7/smeaddons/i386/RPMS
                /releases/7/smetest/i386/RPMS
                /releases/7/smedev/i386/RPMS
                /builds/rpms/RPMS/i386
                /builds/rpms/RPMS/i586
                /builds/rpms/RPMS/i686
                /builds/rpms/RPMS/noarch
                /builds/RPMS
                );
my $devrepo = (grep { m{/sme} } reverse @repos)[0];

my @srcrepos = qw( 
                /mirrors/centos/4/fasttrack/SRPMS
                /mirrors/centos/4/updates/SRPMS
                /mirrors/centos/4/os/SRPMS
                /mirrors/centos/4/extras/SRPMS
                /mirrors/rpmforge/dag/source
                /mirrors/atrpms/src/el4-i386/atrpms/stable
                /builds/rpms/SRPMS
                );

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

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

print "\n";
foreach my $repo ( @repos ) {
        if ( $repo =~ m{^(.*/[0-9]+/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{/builds/RPMS} ) {
                        push @{$repohash{$pkg}{$stagedir}}, $header;
                } elsif ( $repo =~ m{/builds/} ) {
                        push @{$repohash{$pkg}{builds}}, $header;
                } elsif ( $repo =~ m{^(.*/[0-9]+/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{/builds/RPMS} ) {
                        next unless $repohash{$pkg}{latest} || $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 ( $repo =~ m{^(.*/[0-9]+/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}++;
                                }
                        }
                }
        }
}

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}{"$repodir/smedev"}} ) {
                                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"}++;
                        }
                }
        }
}

foreach my $pkg ( grep { $repohash{$_}{"$repodir/smedev"} } keys %repohash ) {
        foreach my $rpm ( @{$repohash{$pkg}{"$repodir/smedev"}} ) {
                unless ( grep { $rpm eq $_ } @{$repohash{$pkg}{builds}} ) {
                        push @remove, $rpm->filename;
                        @{$repohash{$pkg}{"$repodir/smedev"}} = grep { $rpm ne $_ } @{$repohash{$pkg}{"$repodir/smedev"}};
                        $changed{"$repodir/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/\.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;
                }
        }

        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{^/builds};

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