X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Debbugs%2FPackages.pm;h=62d26827ab10e037df67d27e4e2c8e71493c0c75;hb=refs%2Fheads%2Fbugwalker_abstraction;hp=b448db3c42e2731009575251f5a15086768711af;hpb=7cb3272735772e4db4e1fce7010935cb0f6795c9;p=debbugs.git diff --git a/Debbugs/Packages.pm b/Debbugs/Packages.pm index b448db3..62d2682 100644 --- a/Debbugs/Packages.pm +++ b/Debbugs/Packages.pm @@ -25,7 +25,7 @@ BEGIN { @EXPORT = (); %EXPORT_TAGS = (versions => [qw(getversions get_versions make_source_versions)], mapping => [qw(getpkgsrc getpkgcomponent getsrcpkgs), - qw(binarytosource sourcetobinary makesourceversions) + qw(binary_to_source sourcetobinary makesourceversions) ], ); @EXPORT_OK = (); @@ -37,7 +37,7 @@ use Fcntl qw(O_RDONLY); use MLDBM qw(DB_File Storable); use Storable qw(dclone); use Params::Validate qw(validate_with :types); -use Debbugs::Common qw(make_list globify_scalar); +use Debbugs::Common qw(make_list globify_scalar sort_versions); use List::Util qw(min max); @@ -60,9 +60,7 @@ may not make sense in other contexts.) =head1 METHODS -=over 8 - -=item getpkgsrc +=head2 getpkgsrc Returns a reference to a hash of binary package names to their corresponding source package names. @@ -96,7 +94,7 @@ sub getpkgsrc { return $_pkgsrc; } -=item getpkgcomponent +=head2 getpkgcomponent Returns a reference to a hash of binary package names to the component of the archive containing those binary packages (e.g. "main", "contrib", @@ -110,7 +108,7 @@ sub getpkgcomponent { return $_pkgcomponent; } -=item getsrcpkgs +=head2 getsrcpkgs Returns a list of the binary packages produced by a given source package. @@ -123,80 +121,195 @@ sub getsrcpkgs { return @{$_srcpkg->{$src}}; } -=item binarytosource +=head2 binary_to_source + + binary_to_source(package => 'foo', + version => '1.2.3', + arch => 'i386'); + + +Turn a binary package (at optional version in optional architecture) +into a single (or set) of source packages (optionally) with associated +versions. + +By default, in LIST context, returns a LIST of array refs of source +package, source version pairs corresponding to the binary package(s), +arch(s), and verion(s) passed. + +In SCALAR context, only the corresponding source packages are +returned, concatenated with ', ' if necessary. + +If no source can be found, returns undef in scalar context, or the +empty list in list context. -Returns a reference to the source package name and version pair -corresponding to a given binary package name, version, and architecture. +=over + +=item binary -- binary package name(s) as a SCALAR or ARRAYREF + +=item version -- binary package version(s) as a SCALAR or ARRAYREF; +optional, defaults to all versions. + +=item arch -- binary package architecture(s) as a SCALAR or ARRAYREF; +optional, defaults to all architectures. -If undef is passed as the architecture, returns a list of references -to all possible pairs of source package names and versions for all -architectures, with any duplicates removed. +=item source_only -- return only the source name (forced on if in +SCALAR context), defaults to false. -If the binary version is not passed either, returns a list of possible -source package names for all architectures at all versions, with any -duplicates removed. +=item scalar_only -- return a scalar only (forced true if in SCALAR +context, also causes source_only to be true), defaults to false. + +=item cache -- optional HASHREF to be used to cache results of +binary_to_source. + +=back =cut +# the two global variables below are used to tie the source maps; we +# probably should be retying them in long lived processes. our %_binarytosource; -sub binarytosource { - my ($binname, $binver, $binarch) = @_; +our %_sourcetobinary; +sub binary_to_source{ + my %param = validate_with(params => \@_, + spec => {binary => {type => SCALAR|ARRAYREF, + }, + version => {type => SCALAR|ARRAYREF, + optional => 1, + }, + arch => {type => SCALAR|ARRAYREF, + optional => 1, + }, + source_only => {default => 0, + }, + scalar_only => {default => 0, + }, + cache => {type => HASHREF, + default => {}, + }, + }, + ); # TODO: This gets hit a lot, especially from buggyversion() - probably # need an extra cache for speed here. return () unless defined $gBinarySourceMap; - if (not tied %_binarytosource) { - tie %_binarytosource, MLDBM => $gBinarySourceMap, O_RDONLY or - die "Unable to open $gBinarySourceMap for reading"; + if ($param{scalar_only} or not wantarray) { + $param{source_only} = 1; + $param{scalar_only} = 1; } - # avoid autovivification - my $binary = $_binarytosource{$binname}; - return () unless defined $binary; - my %binary = %{$binary}; - if (not defined $binver) { - my %uniq; - for my $ver (keys %binary) { - for my $ar (keys %{$binary{$ver}}) { - my $src = $binary{$ver}{$ar}; - next unless defined $src; - $uniq{$src->[0]} = 1; - } - } - return keys %uniq; + my @source; + my @binaries = grep {defined $_} make_list(exists $param{binary}?$param{binary}:[]); + my @versions = grep {defined $_} make_list(exists $param{version}?$param{version}:[]); + my @archs = grep {defined $_} make_list(exists $param{arch}?$param{arch}:[]); + return () unless @binaries; + my $cache_key = join("\1", + join("\0",@binaries), + join("\0",@versions), + join("\0",@archs), + join("\0",@param{qw(source_only scalar_only)})); + if (exists $param{cache}{$cache_key}) { + return $param{scalar_only} ? $param{cache}{$cache_key}[0]: + @{$param{cache}{$cache_key}}; } - elsif (exists $binary{$binver}) { - if (defined $binarch) { - my $src = $binary{$binver}{$binarch}; - return () unless defined $src; # not on this arch - # Copy the data to avoid tiedness problems. - return dclone($src); - } else { - # Get (srcname, srcver) pairs for all architectures and - # remove any duplicates. This involves some slightly tricky - # multidimensional hashing; sorry. Fortunately there'll - # usually only be one pair returned. - my %uniq; - for my $ar (keys %{$binary{$binver}}) { - my $src = $binary{$binver}{$ar}; - next unless defined $src; - $uniq{$src->[0]}{$src->[1]} = 1; - } - my @uniq; - for my $sn (sort keys %uniq) { - push @uniq, [$sn, $_] for sort keys %{$uniq{$sn}}; - } - return @uniq; - } + for my $binary (@binaries) { + if ($binary =~ m/^src:(.+)$/) { + push @source,[$1,'']; + next; + } + if (not tied %_binarytosource) { + tie %_binarytosource, MLDBM => $config{binary_source_map}, O_RDONLY or + die "Unable to open $config{binary_source_map} for reading"; + } + # avoid autovivification + my $bin = $_binarytosource{$binary}; + next unless defined $bin; + if (not @versions) { + for my $ver (keys %{$bin}) { + for my $ar (keys %{$bin->{$ver}}) { + my $src = $bin->{$ver}{$ar}; + next unless defined $src; + push @source,[$src->[0],$src->[1]]; + } + } + } + else { + my $found_one_version = 0; + for my $version (@versions) { + next unless exists $bin->{$version}; + if (exists $bin->{$version}{all}) { + push @source,dclone($bin->{$version}{all}); + next; + } + my @t_archs; + if (@archs) { + @t_archs = @archs; + } + else { + @t_archs = keys %{$bin->{$version}}; + } + for my $arch (@t_archs) { + push @source,dclone($bin->{$version}{$arch}) if + exists $bin->{$version}{$arch}; + } + } + } + } + + if (not @source and not @versions and not @archs) { + # ok, we haven't found any results at all. If we weren't given + # a specific version and architecture, then we should try + # really hard to figure out the right source + + # if any the packages we've been given are a valid source + # package name, and there's no binary of the same name (we got + # here, so there isn't), return it. + + if (not tied %_sourcetobinary) { + tie %_sourcetobinary, MLDBM => $config{source_binary_map}, O_RDONLY or + die "Unable top open $gSourceBinaryMap for reading"; + } + for my $maybe_sourcepkg (@binaries) { + if (exists $_sourcetobinary{$maybe_sourcepkg}) { + push @source,[$maybe_sourcepkg,$_] for keys %{$_sourcetobinary{$maybe_sourcepkg}}; + } + } + # if @source is still empty here, it's probably a non-existant + # source package, so don't return anything. + } + + my @result; + + if ($param{source_only}) { + my %uniq; + for my $s (@source) { + # we shouldn't need to do this, but do this temporarily to + # stop the warning. + next unless defined $s->[0]; + $uniq{$s->[0]} = 1; + } + @result = sort keys %uniq; + if ($param{scalar_only}) { + @result = join(', ',@result); + } + } + else { + my %uniq; + for my $s (@source) { + $uniq{$s->[0]}{$s->[1]} = 1; + } + for my $sn (sort keys %uniq) { + push @result, [$sn, $_] for sort keys %{$uniq{$sn}}; + } } # No $gBinarySourceMap, or it didn't have an entry for this name and # version. - return (); + $param{cache}{$cache_key} = \@result; + return $param{scalar_only} ? $result[0] : @result; } -=item sourcetobinary +=head2 sourcetobinary Returns a list of references to triplets of binary package names, versions, and architectures corresponding to a given source package name and version. @@ -207,13 +320,12 @@ returned, without the architecture. =cut -our %_sourcetobinary; sub sourcetobinary { my ($srcname, $srcver) = @_; if (not tied %_sourcetobinary) { - tie %_sourcetobinary, MLDBM => $gSourceBinaryMap, O_RDONLY or - die "Unable top open $gSourceBinaryMap for reading"; + tie %_sourcetobinary, MLDBM => $config{source_binary_map}, O_RDONLY or + die "Unable top open $config{source_binary_map} for reading"; } @@ -221,9 +333,8 @@ sub sourcetobinary { # avoid autovivification my $source = $_sourcetobinary{$srcname}; return () unless defined $source; - my %source = %{$source}; - if (exists $source{$srcver}) { - my $bin = $source{$srcver}; + if (exists $source->{$srcver}) { + my $bin = $source->{$srcver}; return () unless defined $bin; return @$bin; } @@ -233,7 +344,7 @@ sub sourcetobinary { return map [$_, $srcver], @srcpkgs; } -=item getversions +=head2 getversions Returns versions of the package in a distribution at a specific architecture @@ -282,6 +393,11 @@ may change in the future, so if you care, please code accordingly.) =item return_archs -- returns a version=>[archs] hash indicating which architectures are at which versions. +=item largest_source_version_only -- if there is more than one source +version in a particular distribution, discards all versions but the +largest in that distribution. Defaults to 1, as this used to be the +way that the Debian archive worked. + =back When called in scalar context, this function will return hashrefs or @@ -315,6 +431,9 @@ sub get_versions{ return_archs => {type => BOOLEAN, default => 0, }, + largest_source_version_only => {type => BOOLEAN, + default => 1, + }, }, ); my $versions; @@ -336,19 +455,29 @@ sub get_versions{ } my %versions; for my $package (make_list($param{package})) { + my $source_only = 0; + if ($package =~ s/^src://) { + $source_only = 1; + } my $version = $versions->{$package}; next unless defined $version; for my $dist (make_list($param{dist})) { for my $arch (exists $param{arch}? make_list($param{arch}): (grep {not $param{no_source_arch} or - $_ ne 'source' - } keys %{$version->{$dist}})) { + $_ ne 'source' + } $source_only?'source':keys %{$version->{$dist}})) { next unless defined $version->{$dist}{$arch}; - for my $ver (ref $version->{$dist}{$arch} ? - keys %{$version->{$dist}{$arch}} : - $version->{$dist}{$arch} - ) { + my @vers = ref $version->{$dist}{$arch} eq 'HASH' ? + keys %{$version->{$dist}{$arch}} : + make_list($version->{$dist}{$arch}); + if ($param{largest_source_version_only} and + $arch eq 'source' and @vers > 1) { + # order the versions, then pick the biggest version number + @vers = sort_versions(@vers); + @vers = $vers[-1]; + } + for my $ver (@vers) { my $f_ver = $ver; if ($param{source}) { ($f_ver) = make_source_versions(package => $package, @@ -373,7 +502,7 @@ sub get_versions{ } -=item makesourceversions +=head2 makesourceversions @{$cgi_var{found}} = makesourceversions($cgi_var{package},undef,@{$cgi_var{found}}); @@ -423,7 +552,7 @@ sub make_source_versions { my %param = validate_with(params => \@_, spec => {package => {type => SCALAR|ARRAYREF, }, - arch => {type => SCALAR|ARRAYREF, + arch => {type => SCALAR|ARRAYREF|UNDEF, default => '' }, versions => {type => SCALAR|ARRAYREF, @@ -446,9 +575,8 @@ sub make_source_versions { my ($warnings) = globify_scalar(exists $param{warnings}?$param{warnings}:undef); my ($debug) = globify_scalar(exists $param{debug} ?$param{debug} :undef); - my @packages = grep {defined $_ and length $_ } make_list($param{package}); - my @archs = grep {defined $_ } make_list ($param{archs}); + my @archs = grep {defined $_ } make_list ($param{arch}); if (not @archs) { push @archs, ''; } @@ -461,19 +589,31 @@ sub make_source_versions { my %sourceversions; for my $version (make_list($param{versions})) { if ($version =~ m{(.+)/([^/]+)$}) { + # Already a source version. + $sourceversions{$version} = 1; + next unless exists $param{warnings}; # check to see if this source version is even possible my @bin_versions = sourcetobinary($1,$2); if (not @bin_versions or @{$bin_versions[0]} != 3) { print {$warnings} "The source $1 and version $2 do not appear to match any binary packages\n"; } - # Already a source version. - $sourceversions{$version} = 1; } else { if (not @packages) { croak "You must provide at least one package if the versions are not fully qualified"; } for my $pkg (@packages) { + if ($pkg =~ /^src:(.+)/) { + $sourceversions{"$1/$version"} = 1; + next unless exists $param{warnings}; + # check to see if this source version is even possible + my @bin_versions = sourcetobinary($1,$version); + if (not @bin_versions or + @{$bin_versions[0]} != 3) { + print {$warnings} "The source '$1' and version '$version' do not appear to match any binary packages\n"; + } + next; + } for my $arch (@archs) { my $cachearch = (defined $arch) ? $arch : ''; my $cachekey = "$pkg/$cachearch/$version"; @@ -483,7 +623,16 @@ sub make_source_versions { } next; } - my @srcinfo = binarytosource($pkg, $version, $arch); + elsif ($param{guess_source} and + exists$param{source_version_cache}{$cachekey.'/guess'}) { + for my $v (@{$param{source_version_cache}{$cachekey.'/guess'}}) { + $sourceversions{$v} = 1; + } + next; + } + my @srcinfo = binary_to_source(binary => $pkg, + version => $version, + length($arch)?(arch => $arch):()); if (not @srcinfo) { # We don't have explicit information about the # binary-to-source mapping for this version @@ -503,10 +652,15 @@ sub make_source_versions { } else { next; } + # store guesses in a slightly different location + $param{source_version_cache}{$cachekey.'/guess'} = [ map { "$_->[0]/$_->[1]" } @srcinfo ]; } } + else { + # only store this if we didn't have to guess it + $param{source_version_cache}{$cachekey} = [ map { "$_->[0]/$_->[1]" } @srcinfo ]; + } $sourceversions{"$_->[0]/$_->[1]"} = 1 foreach @srcinfo; - $param{source_version_cache}{$cachekey} = [ map { "$_->[0]/$_->[1]" } @srcinfo ]; } } } @@ -516,8 +670,4 @@ sub make_source_versions { -=back - -=cut - 1;