/[smeserver]/builds_bin/update_repos
ViewVC logotype

Diff of /builds_bin/update_repos

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph | View Patch Patch

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

Legend:
Removed lines/characters  
Changed lines/characters
  Added lines/characters
admin@koozali.org
 ViewVC Help
Powered by ViewVC 1.2.1 RSS 2.0 feed