X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Debbugs%2FStatus.pm;h=f539781495c297c64a54239823411da2a0c328b1;hb=9947e01ea9e792bf12c77405e06ed69ad8751988;hp=57c63570a33bace203ef8e8fe949429435a0a74d;hpb=ce23d0291a7bc8a1cb781cb10ae075263e3fd442;p=debbugs.git diff --git a/Debbugs/Status.pm b/Debbugs/Status.pm index 57c6357..f539781 100644 --- a/Debbugs/Status.pm +++ b/Debbugs/Status.pm @@ -5,7 +5,7 @@ # # [Other people have contributed to this file; their copyrights should # go here too.] -# Copyright 2007 by Don Armstrong . +# Copyright 2007-9 by Don Armstrong . package Debbugs::Status; @@ -33,20 +33,28 @@ status of a particular bug use warnings; use strict; +use feature 'state'; + use vars qw($VERSION $DEBUG %EXPORT_TAGS @EXPORT_OK @EXPORT); -use base qw(Exporter); +use Exporter qw(import); use Params::Validate qw(validate_with :types); use Debbugs::Common qw(:util :lock :quit :misc); +use Debbugs::UTF8; use Debbugs::Config qw(:config); use Debbugs::MIME qw(decode_rfc1522 encode_rfc1522); -use Debbugs::Packages qw(makesourceversions getversions get_versions binarytosource); +use Debbugs::Packages qw(makesourceversions make_source_versions getversions get_versions binary_to_source); use Debbugs::Versions; use Debbugs::Versions::Dpkg; use POSIX qw(ceil); +use File::Copy qw(copy); +use Encode qw(decode encode is_utf8); -use List::Util qw(min max); +use Storable qw(dclone); +use List::AllUtils qw(min max uniq); +use DateTime::Format::Pg; +use Carp qw(croak); BEGIN{ $VERSION = 1.00; @@ -54,20 +62,23 @@ BEGIN{ @EXPORT = (); %EXPORT_TAGS = (status => [qw(splitpackages get_bug_status buggy bug_archiveable), - qw(isstrongseverity bug_presence), + qw(isstrongseverity bug_presence split_status_fields), + qw(get_bug_statuses), ], read => [qw(readbug read_bug lockreadbug lockreadbugmerge), qw(lock_read_all_merged_bugs), ], write => [qw(writebug makestatus unlockwritebug)], + new => [qw(new_bug)], versions => [qw(addfoundversions addfixedversions), qw(removefoundversions removefixedversions) ], hook => [qw(bughook bughook_archive)], + indexdb => [qw(generate_index_db_line)], fields => [qw(%fields)], ); @EXPORT_OK = (); - Exporter::export_ok_tags(qw(status read write versions hook fields)); + Exporter::export_ok_tags(keys %EXPORT_TAGS); $EXPORT_TAGS{all} = [@EXPORT_OK]; } @@ -103,9 +114,11 @@ our %fields = (originator => 'submitter', blockedby => 'blocked-by', unarchived => 'unarchived', summary => 'summary', + outlook => 'outlook', affects => 'affects', ); + # Fields which need to be RFC1522-decoded in format versions earlier than 3. my @rfc1522_fields = qw(originator subject done forwarded owner); @@ -140,6 +153,10 @@ path to the summary file instead of the bug number and/or location. something modifying it while the bug has been read. You B call C if something not undef is returned from read_bug. +=item locks -- hashref of already obtained locks; incremented as new +locks are needed, and decremented as locks are released on particular +files. + =back One of C or C must be passed. This function will return @@ -151,30 +168,34 @@ sub read_bug{ if (@_ == 1) { unshift @_, 'bug'; } + state $spec = + {bug => {type => SCALAR, + optional => 1, + # something really stupid passes negative bugnumbers + regex => qr/^-?\d+/, + }, + location => {type => SCALAR|UNDEF, + optional => 1, + }, + summary => {type => SCALAR, + optional => 1, + }, + lock => {type => BOOLEAN, + optional => 1, + }, + locks => {type => HASHREF, + optional => 1, + }, + }; my %param = validate_with(params => \@_, - spec => {bug => {type => SCALAR, - optional => 1, - # something really - # stupid passes - # negative bugnumbers - regex => qr/^-?\d+/, - }, - location => {type => SCALAR|UNDEF, - optional => 1, - }, - summary => {type => SCALAR, - optional => 1, - }, - lock => {type => BOOLEAN, - optional => 1, - }, - }, + spec => $spec, ); die "One of bug or summary must be passed to read_bug" if not exists $param{bug} and not exists $param{summary}; my $status; my $log; my $location; + my $report; if (not defined $param{summary}) { my $lref; ($lref,$location) = @param{qw(bug location)}; @@ -184,58 +205,75 @@ sub read_bug{ } $status = getbugcomponent($lref, 'summary', $location); $log = getbugcomponent($lref, 'log' , $location); + $report = getbugcomponent($lref, 'report' , $location); return undef unless defined $status; return undef if not -e $status; } else { $status = $param{summary}; $log = $status; + $report = $status; $log =~ s/\.summary$/.log/; + $report =~ s/\.summary$/.report/; ($location) = $status =~ m/(db-h|db|archive)/; + ($param{bug}) = $status =~ m/(\d+)\.summary$/; } if ($param{lock}) { - filelock("$config{spool_dir}/lock/$param{bug}"); + filelock("$config{spool_dir}/lock/$param{bug}",exists $param{locks}?$param{locks}:()); } my $status_fh = IO::File->new($status, 'r'); if (not defined $status_fh) { warn "Unable to open $status for reading: $!"; if ($param{lock}) { - unfilelock(); + unfilelock(exists $param{locks}?$param{locks}:()); } return undef; } + binmode($status_fh,':encoding(UTF-8)'); my %data; my @lines; - my $version = 2; + my $version; local $_; while (<$status_fh>) { chomp; push @lines, $_; - $version = $1 if /^Format-Version: ([0-9]+)/i; + if (not defined $version and + /^Format-Version: ([0-9]+)/i + ) { + $version = $1; + } } - + $version = 2 if not defined $version; # Version 3 is the latest format version currently supported. if ($version > 3) { warn "Unsupported status version '$version'"; if ($param{lock}) { - unfilelock(); + unfilelock(exists $param{locks}?$param{locks}:()); } return undef; } - my %namemap = reverse %fields; + state $namemap = {reverse %fields}; for my $line (@lines) { if ($line =~ /(\S+?): (.*)/) { my ($name, $value) = (lc $1, $2); - $data{$namemap{$name}} = $value if exists $namemap{$name}; + # this is a bit of a hack; we should never, ever have \r + # or \n in the fields of status. Kill them off here. + # [Eventually, this should be superfluous.] + $value =~ s/[\r\n]//g; + $data{$namemap->{$name}} = $value if exists $namemap->{$name}; } } for my $field (keys %fields) { - $data{$field} = '' unless exists $data{$field}; + $data{$field} = '' unless exists $data{$field}; + } + if ($version < 3) { + for my $field (@rfc1522_fields) { + $data{$field} = decode_rfc1522($data{$field}); + } } - $data{severity} = $config{default_severity} if $data{severity} eq ''; for my $field (qw(found_versions fixed_versions found_date fixed_date)) { $data{$field} = [split ' ', $data{$field}]; @@ -244,26 +282,162 @@ sub read_bug{ # create the found/fixed hashes which indicate when a # particular version was marked found or marked fixed. @{$data{$field}}{@{$data{"${field}_versions"}}} = - (('') x (@{$data{"${field}_date"}} - @{$data{"${field}_versions"}}), + (('') x (@{$data{"${field}_versions"}} - @{$data{"${field}_date"}}), @{$data{"${field}_date"}}); } - if ($version < 3) { - for my $field (@rfc1522_fields) { - $data{$field} = decode_rfc1522($data{$field}); - } - } my $status_modified = (stat($status))[9]; # Add log last modified time - $data{log_modified} = (stat($log))[9]; + $data{log_modified} = (stat($log))[9] // (stat("${log}.gz"))[9]; + my $report_modified = (stat($report))[9] // $data{log_modified}; $data{last_modified} = max($status_modified,$data{log_modified}); + # if the date isn't set (ancient bug), use the smallest of any of the modified + if (not defined $data{date} or not length($data{date})) { + $data{date} = min($report_modified,$status_modified,$data{log_modified}); + } $data{location} = $location; $data{archived} = (defined($location) and ($location eq 'archive'))?1:0; $data{bug_num} = $param{bug}; + # mergedwith occasionally is sorted badly. Fix it to always be sorted by <=> + # and not include this bug + if (defined $data{mergedwith} and + $data{mergedwith}) { + $data{mergedwith} = + join(' ', + grep { $_ != $data{bug_num}} + sort { $a <=> $b } + split / /, $data{mergedwith} + ); + } return \%data; } +=head2 split_status_fields + + my @data = split_status_fields(@data); + +Splits splittable status fields (like package, tags, blocks, +blockedby, etc.) into arrayrefs (use make_list on these). Keeps the +passed @data intact using dclone. + +In scalar context, returns only the first element of @data. + +=cut + +our $ditch_empty = sub{ + my @t = @_; + my $splitter = shift @t; + return grep {length $_} map {split $splitter} @t; +}; + +our $sort_and_unique = sub { + my @v; + my %u; + my $all_numeric = 1; + for my $v (@_) { + if ($all_numeric and $v =~ /\D/) { + $all_numeric = 0; + } + next if exists $u{$v}; + $u{$v} = 1; + push @v, $v; + } + if ($all_numeric) { + return sort {$a <=> $b} @v; + } else { + return sort @v; + } +}; + +my $ditch_space_unique_and_sort = sub {return &{$sort_and_unique}(&{$ditch_empty}(' ',@_))}; +my %split_fields = + (package => \&splitpackages, + affects => \&splitpackages, + # Ideally we won't have to split source, but because some consumers of + # get_bug_status cannot handle arrayref, we will split it here. + source => \&splitpackages, + blocks => $ditch_space_unique_and_sort, + blockedby => $ditch_space_unique_and_sort, + # this isn't strictly correct, but we'll split both of them for + # the time being until we ditch all use of keywords everywhere + # from the code + keywords => $ditch_space_unique_and_sort, + tags => $ditch_space_unique_and_sort, + found_versions => $ditch_space_unique_and_sort, + fixed_versions => $ditch_space_unique_and_sort, + mergedwith => $ditch_space_unique_and_sort, + ); + +sub split_status_fields { + my @data = @{dclone(\@_)}; + for my $data (@data) { + next if not defined $data; + croak "Passed an element which is not a hashref to split_status_field".ref($data) if + not (ref($data) and ref($data) eq 'HASH'); + for my $field (keys %{$data}) { + next unless defined $data->{$field}; + if (exists $split_fields{$field}) { + next if ref($data->{$field}); + my @elements; + if (ref($split_fields{$field}) eq 'CODE') { + @elements = &{$split_fields{$field}}($data->{$field}); + } + elsif (not ref($split_fields{$field}) or + UNIVERSAL::isa($split_fields{$field},'Regex') + ) { + @elements = split $split_fields{$field}, $data->{$field}; + } + $data->{$field} = \@elements; + } + } + } + return wantarray?@data:$data[0]; +} + +=head2 join_status_fields + + my @data = join_status_fields(@data); + +Handles joining the splitable status fields. (Basically, the inverse +of split_status_fields. + +Primarily called from makestatus, but may be useful for other +functions after calling split_status_fields (or for legacy functions +if we transition to split fields by default). + +=cut + +sub join_status_fields { + my %join_fields = + (package => ', ', + affects => ', ', + blocks => ' ', + blockedby => ' ', + tags => ' ', + found_versions => ' ', + fixed_versions => ' ', + found_date => ' ', + fixed_date => ' ', + mergedwith => ' ', + ); + my @data = @{dclone(\@_)}; + for my $data (@data) { + next if not defined $data; + croak "Passed an element which is not a hashref to split_status_field: ". + ref($data) + if ref($data) ne 'HASH'; + for my $field (keys %{$data}) { + next unless defined $data->{$field}; + next unless ref($data->{$field}) eq 'ARRAY'; + next unless exists $join_fields{$field}; + $data->{$field} = join($join_fields{$field},@{$data->{$field}}); + } + } + return wantarray?@data:$data[0]; +} + + =head2 lockreadbug lockreadbug($bug_num,$location) @@ -292,7 +466,6 @@ data. =cut sub lockreadbugmerge { - my ($bug_num,$location) = @_; my $data = lockreadbug(@_); if (not defined $data) { return (0,undef); @@ -325,56 +498,137 @@ even if all of the others were read properly. =cut sub lock_read_all_merged_bugs { - my ($bug_num,$location) = @_; + my %param = validate_with(params => \@_, + spec => {bug => {type => SCALAR, + regex => qr/^\d+$/, + }, + location => {type => SCALAR, + optional => 1, + }, + locks => {type => HASHREF, + optional => 1, + }, + }, + ); my $locks = 0; - my @data = (lockreadbug(@_)); + my @data = read_bug(bug => $param{bug}, + lock => 1, + exists $param{location} ? (location => $param{location}):(), + exists $param{locks} ? (locks => $param{locks}):(), + ); if (not @data or not defined $data[0]) { - return ($locks,undef); + return ($locks,()); } $locks++; if (not length $data[0]->{mergedwith}) { return ($locks,@data); } - unfilelock(); + unfilelock(exists $param{locks}?$param{locks}:()); $locks--; - filelock("$config{spool_dir}/lock/merge"); + filelock("$config{spool_dir}/lock/merge",exists $param{locks}?$param{locks}:()); $locks++; - @data = (lockreadbug(@_)); + @data = read_bug(bug => $param{bug}, + lock => 1, + exists $param{location} ? (location => $param{location}):(), + exists $param{locks} ? (locks => $param{locks}):(), + ); if (not @data or not defined $data[0]) { - unfilelock(); #for merge lock above + unfilelock(exists $param{locks}?$param{locks}:()); #for merge lock above $locks--; - return ($locks,undef); + return ($locks,()); } $locks++; my @bugs = split / /, $data[0]->{mergedwith}; + push @bugs, $param{bug}; for my $bug (@bugs) { my $newdata = undef; - if ($bug ne $bug_num) { - $newdata = lockreadbug($bug,$location); + if ($bug != $param{bug}) { + $newdata = + read_bug(bug => $bug, + lock => 1, + exists $param{location} ? (location => $param{location}):(), + exists $param{locks} ? (locks => $param{locks}):(), + ); if (not defined $newdata) { for (1..$locks) { - unfilelock(); + unfilelock(exists $param{locks}?$param{locks}:()); } $locks = 0; - warn "Unable to read bug: $bug while handling merged bug: $bug_num"; - return ($locks,undef); + warn "Unable to read bug: $bug while handling merged bug: $param{bug}"; + return ($locks,()); } $locks++; push @data,$newdata; - } - # perform a sanity check to make sure that the merged bugs are - # all merged with eachother - my $expectmerge= join(' ',grep {$_ != $bug } sort { $a <=> $b } (@bugs,$bug_num)); - if ($newdata->{mergedwith} ne $expectmerge) { - for (1..$locks) { - unfilelock(); + # perform a sanity check to make sure that the merged bugs + # are all merged with eachother + # We do a cmp sort instead of an <=> sort here, because that's + # what merge does + my $expectmerge= + join(' ',grep {$_ != $bug } + sort { $a <=> $b } + @bugs); + if ($newdata->{mergedwith} ne $expectmerge) { + for (1..$locks) { + unfilelock(exists $param{locks}?$param{locks}:()); + } + die "Bug $param{bug} mergedwith differs from bug $bug: ($newdata->{bug_num}: '$newdata->{mergedwith}') vs. ('$expectmerge') (".join(' ',@bugs).")"; } - die "Bug $bug_num differs from bug $bug: ($newdata->{bug_num}: $newdata->{mergedwith}) vs. ($expectmerge) (".join(' ',@bugs).")"; } } return ($locks,@data); } +=head2 new_bug + + my $new_bug_num = new_bug(copy => $data->{bug_num}); + +Creates a new bug and returns the new bug number upon success. + +Dies upon failures. + +=cut + +sub new_bug { + my %param = + validate_with(params => \@_, + spec => {copy => {type => SCALAR, + regex => qr/^\d+/, + optional => 1, + }, + }, + ); + filelock("nextnumber.lock"); + my $nn_fh = IO::File->new("nextnumber",'r') or + die "Unable to open nextnuber for reading: $!"; + local $\; + my $nn = <$nn_fh>; + ($nn) = $nn =~ m/^(\d+)\n$/ or die "Bad format of nextnumber; is not exactly ".'^\d+\n$'; + close $nn_fh; + overwritefile("nextnumber", + ($nn+1)."\n"); + unfilelock(); + my $nn_hash = get_hashname($nn); + if ($param{copy}) { + my $c_hash = get_hashname($param{copy}); + for my $file (qw(log status summary report)) { + copy("db-h/$c_hash/$param{copy}.$file", + "db-h/$nn_hash/${nn}.$file") + } + } + else { + for my $file (qw(log status summary report)) { + overwritefile("db-h/$nn_hash/${nn}.$file", + ""); + } + } + + # this probably needs to be munged to do something more elegant +# &bughook('new', $clone, $data); + + return($nn); +} + + my @v1fieldorder = qw(originator date subject msgid package keywords done forwarded mergedwith severity); @@ -397,7 +651,7 @@ version. sub makestatus { my ($data,$version) = @_; - $version = 2 unless defined $version; + $version = 3 unless defined $version; my $contents = ''; @@ -408,10 +662,9 @@ sub makestatus { [map {$newdata{$field}{$_}||''} keys %{$newdata{$field}}]; } } + %newdata = %{join_status_fields(\%newdata)}; - for my $field (qw(found_versions fixed_versions found_date fixed_date)) { - $newdata{$field} = join ' ', @{$newdata{$field}||[]}; - } + %newdata = encode_utf8_structure(%newdata); if ($version < 3) { for my $field (@rfc1522_fields) { @@ -419,6 +672,13 @@ sub makestatus { } } + # this is a bit of a hack; we should never, ever have \r or \n in + # the fields of status. Kill them off here. [Eventually, this + # should be superfluous.] + for my $field (keys %newdata) { + $newdata{$field} =~ s/[\r\n]//g if defined $newdata{$field}; + } + if ($version == 1) { for my $field (@v1fieldorder) { if (exists $newdata{$field} and defined $newdata{$field}) { @@ -437,11 +697,11 @@ sub makestatus { # Output field names in proper case, e.g. 'Merged-With'. my $properfield = $fields{$field}; $properfield =~ s/(?:^|(?<=-))([a-z])/\u$1/g; - $contents .= "$properfield: $newdata{$field}\n"; + my $data = $newdata{$field}; + $contents .= "$properfield: $data\n"; } } } - return $contents; } @@ -451,7 +711,7 @@ sub makestatus { Writes the bug status and summary files out. -Skips writting out a status file if minversion is 2 +Skips writing out a status file if minversion is 2 Does not call bughook if disablebughook is true. @@ -461,15 +721,23 @@ sub writebug { my ($ref, $data, $location, $minversion, $disablebughook) = @_; my $change; - my %outputs = (1 => 'status', 2 => 'summary'); + my %outputs = (1 => 'status', 3 => 'summary'); for my $version (keys %outputs) { next if defined $minversion and $version < $minversion; my $status = getbugcomponent($ref, $outputs{$version}, $location); die "can't find location for $ref" unless defined $status; - open(S,"> $status.new") || die "opening $status.new: $!"; - print(S makestatus($data, $version)) || + my $sfh; + if ($version >= 3) { + open $sfh,">","$status.new" or + die "opening $status.new: $!"; + } + else { + open $sfh,">","$status.new" or + die "opening $status.new: $!"; + } + print {$sfh} makestatus($data, $version) or die "writing $status.new: $!"; - close(S) || die "closing $status.new: $!"; + close($sfh) or die "closing $status.new: $!"; if (-e $status) { $change = 'change'; } else { @@ -494,7 +762,7 @@ options mean. sub unlockwritebug { writebug(@_); - &unfilelock; + unfilelock(); } =head1 VERSIONS @@ -505,7 +773,7 @@ The following functions are exported with the :versions tag addfoundversions($status,$package,$version,$isbinary); - +All use of this should be phased out in favor of Debbugs::Control::fixed/found =cut @@ -516,11 +784,16 @@ sub addfoundversions { my $version = shift; my $isbinary = shift; return unless defined $version; - undef $package if $package =~ m[(?:\s|/)]; + undef $package if defined $package and $package =~ m[(?:\s|/)]; my $source = $package; + if (defined $package and $package =~ s/^src://) { + $isbinary = 0; + $source = $package; + } if (defined $package and $isbinary) { - my @srcinfo = binarytosource($package, $version, undef); + my @srcinfo = binary_to_source(binary => $package, + version => $version); if (@srcinfo) { # We know the source package(s). Use a fully-qualified version. addfoundversions($data, $_->[0], $_->[1], '') foreach @srcinfo; @@ -556,7 +829,7 @@ exactly are removed. Otherwise, all versions matching the version number are removed. Currently $package and $isbinary are entirely ignored, but accepted -for backwards compatibilty. +for backwards compatibility. =cut @@ -594,7 +867,8 @@ sub addfixedversions { my $source = $package; if (defined $package and $isbinary) { - my @srcinfo = binarytosource($package, $version, undef); + my @srcinfo = binary_to_source(binary => $package, + version => $version); if (@srcinfo) { # We know the source package(s). Use a fully-qualified version. addfixedversions($data, $_->[0], $_->[1], '') foreach @srcinfo; @@ -655,7 +929,7 @@ Split a package string from the status file into a list of package names. sub splitpackages { my $pkgs = shift; return unless defined $pkgs; - return map lc, split /[ \t?,()]+/, $pkgs; + return grep {length $_} map lc, split /[\s,()?]+/, $pkgs; } @@ -691,20 +965,24 @@ Returns undef on failure. # This will eventually need to be fixed before we start using mod_perl our $version_cache = {}; sub bug_archiveable{ + state $spec = {bug => {type => SCALAR, + regex => qr/^\d+$/, + }, + status => {type => HASHREF, + optional => 1, + }, + days_until => {type => BOOLEAN, + default => 0, + }, + ignore_time => {type => BOOLEAN, + default => 0, + }, + schema => {type => OBJECT, + optional => 1, + }, + }; my %param = validate_with(params => \@_, - spec => {bug => {type => SCALAR, - regex => qr/^\d+$/, - }, - status => {type => HASHREF, - optional => 1, - }, - days_until => {type => BOOLEAN, - default => 0, - }, - ignore_time => {type => BOOLEAN, - default => 0, - }, - }, + spec => $spec, ); # This is what we return if the bug cannot be archived. my $cannot_archive = $param{days_until}?-1:0; @@ -725,7 +1003,7 @@ sub bug_archiveable{ } # Check to make sure that the bug has none of the unremovable tags set if (@{$config{removal_unremovable_tags}}) { - for my $tag (split ' ', ($status->{tags}||'')) { + for my $tag (split ' ', ($status->{keywords}||'')) { if (grep {$tag eq $_} @{$config{removal_unremovable_tags}}) { print STDERR "Cannot archive $param{bug} because it has an unremovable tag '$tag'\n" if $DEBUG; return $cannot_archive; @@ -736,16 +1014,16 @@ sub bug_archiveable{ # If we just are checking if the bug can be archived, we'll not even bother # checking the versioning information if the bug has been -done for less than 28 days. my $log_file = getbugcomponent($param{bug},'log'); - if (not defined $log_file) { + if (not defined $log_file or not -e $log_file) { print STDERR "Cannot archive $param{bug} because the log doesn't exist\n" if $DEBUG; return $cannot_archive; } - my $max_log_age = max(map {$config{remove_age} - -M $_} - $log_file, map {my $log = getbugcomponent($_,'log'); + my @log_files = $log_file, (map {my $log = getbugcomponent($_,'log'); defined $log ? ($log) : (); } - split / /, $status->{mergedwith} - ); + split / /, $status->{mergedwith}); + my $max_log_age = max(map {-e $_?($config{remove_age} - -M _):0} + @log_files); if (not $param{days_until} and not $param{ignore_time} and $max_log_age > 0 ) { @@ -770,7 +1048,7 @@ sub bug_archiveable{ @dist_tags{@{$config{removal_distribution_tags}}} = (1) x @{$config{removal_distribution_tags}}; my %dists; - for my $tag (split ' ', ($status->{tags}||'')) { + for my $tag (split ' ', ($status->{keywords}||'')) { next unless exists $config{distribution_aliases}{$tag}; next unless $dist_tags{$config{distribution_aliases}{$tag}}; $dists{$config{distribution_aliases}{$tag}} = 1; @@ -789,6 +1067,7 @@ sub bug_archiveable{ my @sourceversions = get_versions(package => $status->{package}, dist => [keys %dists], source => 1, + hash_slice(%param,'schema'), ); @source_versions{@sourceversions} = (1) x @sourceversions; # If the bug has not been fixed in the versions actually @@ -799,6 +1078,7 @@ sub bug_archiveable{ fixed => $status->{fixed_versions}, version_cache => $version_cache, package => $status->{package}, + hash_slice(%param,'schema'), )) { print STDERR "Cannot archive $param{bug} because it's found\n" if $DEBUG; return $cannot_archive; @@ -819,6 +1099,7 @@ sub bug_archiveable{ dist => [keys %dists], source => 1, time => 1, + hash_slice(%param,'schema'), ); for my $version (sort {$time_versions{$b} <=> $time_versions{$a}} keys %time_versions) { my $buggy = buggy(bug => $param{bug}, @@ -827,6 +1108,7 @@ sub bug_archiveable{ fixed => $status->{fixed_versions}, version_cache => $version_cache, package => $status->{package}, + hash_slice(%param,'schema'), ); last if $buggy eq 'found'; $min_fixed_time = min($time_versions{$version},$min_fixed_time); @@ -891,113 +1173,257 @@ a source package). Defaults to true. Note: Currently the version information is cached; this needs to be changed before using this function in long lived programs. +=head3 Returns + +Currently returns a hashref of status with the following keys. + +=over + +=item id -- bug number + +=item bug_num -- duplicate of id + +=item keywords -- tags set on the bug, including usertags if bugusertags passed. + +=item tags -- duplicate of keywords + +=item package -- name of package that the bug is assigned to + +=item severity -- severity of the bug + +=item pending -- pending state of the bug; one of following possible +values; values listed later have precedence if multiple conditions are +satisifed: + +=over + +=item pending -- default state + +=item forwarded -- bug has been forwarded + +=item pending-fixed -- bug is tagged pending + +=item fixed -- bug is tagged fixed + +=item absent -- bug does not apply to this distribution/architecture + +=item done -- bug is resolved in this distribution/architecture + +=back + +=item location -- db-h or archive; the location in the filesystem + +=item subject -- title of the bug + +=item last_modified -- epoch that the bug was last modified + +=item date -- epoch that the bug was filed + +=item originator -- bug reporter + +=item log_modified -- epoch that the log file was last modified + +=item msgid -- Message id of the original bug report + +=back + + +Other key/value pairs are returned but are not currently documented here. + =cut sub get_bug_status { if (@_ == 1) { unshift @_, 'bug'; } + state $spec = + {bug => {type => SCALAR, + regex => qr/^\d+$/, + }, + status => {type => HASHREF, + optional => 1, + }, + bug_index => {type => OBJECT, + optional => 1, + }, + version => {type => SCALAR|ARRAYREF, + optional => 1, + }, + dist => {type => SCALAR|ARRAYREF, + optional => 1, + }, + arch => {type => SCALAR|ARRAYREF, + optional => 1, + }, + bugusertags => {type => HASHREF, + optional => 1, + }, + sourceversions => {type => ARRAYREF, + optional => 1, + }, + indicatesource => {type => BOOLEAN, + default => 1, + }, + binary_to_source_cache => {type => HASHREF, + optional => 1, + }, + schema => {type => OBJECT, + optional => 1, + }, + }; my %param = validate_with(params => \@_, - spec => {bug => {type => SCALAR, - regex => qr/^\d+$/, - }, - status => {type => HASHREF, - optional => 1, - }, - bug_index => {type => OBJECT, - optional => 1, - }, - version => {type => SCALAR|ARRAYREF, - optional => 1, - }, - dist => {type => SCALAR|ARRAYREF, - optional => 1, - }, - arch => {type => SCALAR|ARRAYREF, - optional => 1, - }, - bugusertags => {type => HASHREF, - optional => 1, - }, - sourceversions => {type => ARRAYREF, - optional => 1, - }, - indicatesource => {type => BOOLEAN, - default => 1, - }, - }, + spec => $spec, ); my %status; if (defined $param{bug_index} and exists $param{bug_index}{$param{bug}}) { - %status = %{ $param{bug_index}{$param{bug}} }; - $status{pending} = $status{ status }; - $status{id} = $param{bug}; - return \%status; - } - if (defined $param{status}) { - %status = %{$param{status}}; + %status = %{ $param{bug_index}{$param{bug}} }; + $status{pending} = $status{ status }; + $status{id} = $param{bug}; + return \%status; } - else { - my $location = getbuglocation($param{bug}, 'summary'); - return {} if not defined $location or not length $location; - %status = %{ readbug( $param{bug}, $location ) }; + my $statuses = get_bug_statuses(@_); + if (exists $statuses->{$param{bug}}) { + return $statuses->{$param{bug}}; + } else { + return {}; } - $status{id} = $param{bug}; +} - if (defined $param{bugusertags}{$param{bug}}) { - $status{keywords} = "" unless defined $status{keywords}; - $status{keywords} .= " " unless $status{keywords} eq ""; - $status{keywords} .= join(" ", @{$param{bugusertags}{$param{bug}}}); +sub get_bug_statuses { + state $spec = + {bug => {type => SCALAR|ARRAYREF, + }, + status => {type => HASHREF, + optional => 1, + }, + bug_index => {type => OBJECT, + optional => 1, + }, + version => {type => SCALAR|ARRAYREF, + optional => 1, + }, + dist => {type => SCALAR|ARRAYREF, + optional => 1, + }, + arch => {type => SCALAR|ARRAYREF, + optional => 1, + }, + bugusertags => {type => HASHREF, + optional => 1, + }, + sourceversions => {type => ARRAYREF, + optional => 1, + }, + indicatesource => {type => BOOLEAN, + default => 1, + }, + binary_to_source_cache => {type => HASHREF, + optional => 1, + }, + schema => {type => OBJECT, + optional => 1, + }, + }; + my %param = validate_with(params => \@_, + spec => $spec, + ); + my $bin_to_src_cache = {}; + if (defined $param{binary_to_source_cache}) { + $bin_to_src_cache = $param{binary_to_source_cache}; } - $status{tags} = $status{keywords}; - my %tags = map { $_ => 1 } split ' ', $status{tags}; - - $status{package} = '' if not defined $status{package}; - $status{"package"} =~ s/\s*$//; - # if we aren't supposed to indicate the source, we'll return - # unknown here. - $status{source} = 'unknown'; - if ($param{indicatesource}) { - my @packages = split /\s*,\s*/, $status{package}; - my @source; - for my $package (@packages) { - next if $package eq ''; - if ($package =~ /^src\:$/) { - push @source,$1; + my %status; + my %statuses; + if (defined $param{schema}) { + my @bug_statuses = + $param{schema}->resultset('BugStatus')-> + search_rs({id => [make_list($param{bug})]}, + {result_class => 'DBIx::Class::ResultClass::HashRefInflator'})-> + all(); + for my $bug_status (@bug_statuses) { + $statuses{$bug_status->{bug_num}} = + $bug_status; + for my $field (qw(blocks blockedby done), + qw(tags mergedwith affects) + ) { + $bug_status->{$field} //=''; } - else { - push @source, binarytosource($package); + $bug_status->{keywords} = + $bug_status->{tags}; + $bug_status->{location} = $bug_status->{archived}?'archive':'db-h'; + for my $field (qw(found_versions fixed_versions found_date fixed_date)) { + $bug_status->{$field} = [split ' ', $bug_status->{$field} // '']; + } + for my $field (qw(found fixed)) { + # create the found/fixed hashes which indicate when a + # particular version was marked found or marked fixed. + @{$bug_status->{$field}}{@{$bug_status->{"${field}_versions"}}} = + (('') x (@{$bug_status->{"${field}_versions"}} - + @{$bug_status->{"${field}_date"}}), + @{$bug_status->{"${field}_date"}}); } + $bug_status->{id} = $bug_status->{bug_num}; } - if (@source) { - $status{source} = join(', ',@source); + } else { + for my $bug (make_list($param{bug})) { + if (defined $param{bug_index} and + exists $param{bug_index}{$bug}) { + my %status = %{$param{bug_index}{$bug}}; + $status{pending} = $status{status}; + $status{id} = $bug; + $statuses{$bug} = \%status; + } + elsif (defined $param{status} and + $param{status}{bug_num} == $bug + ) { + $statuses{$bug} = {%{$param{status}}}; + } else { + my $location = getbuglocation($bug, 'summary'); + next if not defined $location or not length $location; + my %status = %{ readbug( $bug, $location ) }; + $status{id} = $bug; + $statuses{$bug} = \%status; + } } } + for my $bug (keys %statuses) { + my $status = $statuses{$bug}; - $status{"package"} = 'unknown' if ($status{"package"} eq ''); - $status{"severity"} = 'normal' if (not defined $status{severity} or $status{"severity"} eq ''); - - $status{"pending"} = 'pending'; - $status{"pending"} = 'forwarded' if (length($status{"forwarded"})); - $status{"pending"} = 'pending-fixed' if ($tags{pending}); - $status{"pending"} = 'fixed' if ($tags{fixed}); - - - my $presence = bug_presence(status => \%status, - map{(exists $param{$_})?($_,$param{$_}):()} - qw(bug sourceversions arch dist version found fixed package) - ); - if (defined $presence) { - if ($presence eq 'fixed') { - $status{pending} = 'done'; - } - elsif ($presence eq 'absent') { - $status{pending} = 'absent'; - } + if (defined $param{bugusertags}{$param{bug}}) { + $status->{keywords} = "" unless defined $status->{keywords}; + $status->{keywords} .= " " unless $status->{keywords} eq ""; + $status->{keywords} .= join(" ", @{$param{bugusertags}{$param{bug}}}); + } + $status->{tags} = $status->{keywords}; + my %tags = map { $_ => 1 } split ' ', $status->{tags}; + + $status->{package} = '' if not defined $status->{package}; + $status->{"package"} =~ s/\s*$//; + + $status->{"package"} = 'unknown' if ($status->{"package"} eq ''); + $status->{"severity"} = 'normal' if (not defined $status->{severity} or $status->{"severity"} eq ''); + + $status->{"pending"} = 'pending'; + $status->{"pending"} = 'forwarded' if (length($status->{"forwarded"})); + $status->{"pending"} = 'pending-fixed' if ($tags{pending}); + $status->{"pending"} = 'fixed' if ($tags{fixed}); + + + my $presence = bug_presence(status => $status, + bug => $bug, + map{(exists $param{$_})?($_,$param{$_}):()} + qw(sourceversions arch dist version found fixed package) + ); + if (defined $presence) { + if ($presence eq 'fixed') { + $status->{pending} = 'done'; + } elsif ($presence eq 'absent') { + $status->{pending} = 'absent'; + } + } } - return \%status; + return \%statuses; } =head2 bug_presence @@ -1093,7 +1519,7 @@ sub bug_presence { (1) x @{$config{affects_distribution_tags}}; my $some_distributions_disallowed = 0; my %allowed_distributions; - for my $tag (split ' ', ($status{tags}||'')) { + for my $tag (split ' ', ($status{keywords}||'')) { if (exists $config{distribution_aliases}{$tag} and exists $affects_distribution_tags{$config{distribution_aliases}{$tag}}) { $some_distributions_disallowed = 1; @@ -1104,10 +1530,17 @@ sub bug_presence { $allowed_distributions{$tag} = 1; } } - foreach my $arch (make_list($param{arch})) { - for my $package (split /\s*,\s*/, $status{package}) { - my @versions; - foreach my $dist (make_list($param{dist})) { + my @archs = make_list(exists $param{arch}?$param{arch}:()); + GET_SOURCE_VERSIONS: + foreach my $arch (@archs) { + for my $package (split /\s*,\s*/, $status{package}) { + my @versions = (); + my $source = 0; + if ($package =~ /^src:(.+)$/) { + $source = 1; + $package = $1; + } + foreach my $dist (make_list(exists $param{dist}?$param{dist}:[])) { # if some distributions are disallowed, # and this isn't an allowed # distribution, then we ignore this @@ -1117,16 +1550,29 @@ sub bug_presence { not exists $allowed_distributions{$dist}) { next; } - push @versions, getversions($package, $dist, $arch); + push @versions, get_versions(package => $package, + dist => $dist, + ($source?(arch => 'source'): + (defined $arch?(arch => $arch):())), + ); } next unless @versions; - my @temp = makesourceversions($package, - $arch, - @versions - ); + my @temp = make_source_versions(package => $package, + arch => $arch, + versions => \@versions, + ); @sourceversions{@temp} = (1) x @temp; } } + # this should really be split out into a subroutine, + # but it'd touch so many things currently, that we fake + # it; it's needed to properly handle bugs which are + # erroneously assigned to the binary package, and we'll + # probably have it go away eventually. + if (not keys %sourceversions and (not @archs or defined $archs[0])) { + @archs = (undef); + goto GET_SOURCE_VERSIONS; + } } # TODO: This should probably be handled further out for efficiency and @@ -1199,6 +1645,9 @@ sub max_buggy{ version_cache => {type => HASHREF, default => {}, }, + schema => {type => OBJECT, + optional => 1, + }, }, ); # Resolve bugginess states (we might be looking at multiple @@ -1261,6 +1710,9 @@ sub buggy { }, version => {type => SCALAR, }, + schema => {type => OBJECT, + optional => 1, + }, }, ); my @found = @{$param{found}}; @@ -1295,8 +1747,10 @@ sub buggy { my $version_fh = IO::File->new("$config{version_packages_dir}/$srchash/$source", 'r'); if (not defined $version_fh) { # We only want to warn if it's a package which actually has a maintainer - my $maints = getmaintainers(); - next if not exists $maints->{$source}; + my @maint = package_maintainer(source => $source, + hash_slice(%param,'schema'), + ); + next unless @maint; warn "Bug $param{bug}: unable to open $config{version_packages_dir}/$srchash/$source: $!"; next; } @@ -1319,6 +1773,39 @@ sub isstrongseverity { return grep { $_ eq $severity } @{$config{strong_severities}}; } +=head1 indexdb + +=head2 generate_index_db_line + + my $data = read_bug(bug => $bug, + location => $initialdir); + # generate_index_db_line hasn't been written yet at all. + my $line = generate_index_db_line($data); + +Returns a line for a bug suitable to be written out to index.db. + +=cut + +sub generate_index_db_line { + my ($data,$bug) = @_; + + # just in case someone has given us a split out data + $data = join_status_fields($data); + + my $whendone = "open"; + my $severity = $config{default_severity}; + (my $pkglist = $data->{package}) =~ s/[,\s]+/,/g; + $pkglist =~ s/^,+//; + $pkglist =~ s/,+$//; + $whendone = "forwarded" if defined $data->{forwarded} and length $data->{forwarded}; + $whendone = "done" if defined $data->{done} and length $data->{done}; + $severity = $data->{severity} if length $data->{severity}; + return sprintf "%s %d %d %s [%s] %s %s\n", + $pkglist, $data->{bug_num}//$bug, $data->{date}, $whendone, + $data->{originator}, $severity, $data->{keywords}; +} + + =head1 PRIVATE FUNCTIONS @@ -1335,6 +1822,8 @@ sub update_realtime { my $idx_new = IO::File->new($file.'.new','w') or die "Couldn't open ${file}.new: $!"; + binmode($idx_old,':raw:utf8'); + binmode($idx_new,':raw:encoding(UTF-8)'); my $min_bug = min(keys %bugs); my $line; my @line; @@ -1381,41 +1870,29 @@ sub update_realtime { sub bughook_archive { my @refs = @_; - &filelock("$config{spool_dir}/debbugs.trace.lock"); - &appendfile("debbugs.trace","archive ".join(',',@refs)."\n"); + filelock("$config{spool_dir}/debbugs.trace.lock"); + appendfile("$config{spool_dir}/debbugs.trace","archive ".join(',',@refs)."\n"); my %bugs = update_realtime("$config{spool_dir}/index.db.realtime", map{($_,'REMOVE')} @refs); update_realtime("$config{spool_dir}/index.archive.realtime", %bugs); - &unfilelock; + unfilelock(); } sub bughook { my ( $type, %bugs_temp ) = @_; - &filelock("$config{spool_dir}/debbugs.trace.lock"); + filelock("$config{spool_dir}/debbugs.trace.lock"); my %bugs; for my $bug (keys %bugs_temp) { my $data = $bugs_temp{$bug}; - &appendfile("debbugs.trace","$type $bug\n",makestatus($data, 1)); - - my $whendone = "open"; - my $severity = $config{default_severity}; - (my $pkglist = $data->{package}) =~ s/[,\s]+/,/g; - $pkglist =~ s/^,+//; - $pkglist =~ s/,+$//; - $whendone = "forwarded" if defined $data->{forwarded} and length $data->{forwarded}; - $whendone = "done" if defined $data->{done} and length $data->{done}; - $severity = $data->{severity} if length $data->{severity}; - - my $k = sprintf "%s %d %d %s [%s] %s %s\n", - $pkglist, $bug, $data->{date}, $whendone, - $data->{originator}, $severity, $data->{keywords}; - $bugs{$bug} = $k; + appendfile("$config{spool_dir}/debbugs.trace","$type $bug\n",makestatus($data, 1)); + + $bugs{$bug} = generate_index_db_line($data,$bug); } update_realtime("$config{spool_dir}/index.db.realtime", %bugs); - &unfilelock; + unfilelock(); }