use warnings;
use strict;
+
use vars qw($VERSION $DEBUG %EXPORT_TAGS @EXPORT_OK @EXPORT);
use base qw(Exporter);
%EXPORT_TAGS = (status => [qw(splitpackages get_bug_status buggy bug_archiveable),
qw(isstrongseverity bug_presence),
],
- read => [qw(readbug read_bug lockreadbug lockreadbugmerge)],
+ read => [qw(readbug read_bug lockreadbug lockreadbugmerge),
+ qw(lock_read_all_merged_bugs),
+ ],
write => [qw(writebug makestatus unlockwritebug)],
versions => [qw(addfoundversions addfixedversions),
qw(removefoundversions removefixedversions)
=item summary -- complete path to the .summary file which will be read
+=item lock -- whether to obtain a lock for the bug to prevent
+something modifying it while the bug has been read. You B<must> call
+C<unfilelock();> if something not undef is returned from read_bug.
+
=back
One of C<bug> or C<summary> must be passed. This function will return
summary => {type => SCALAR,
optional => 1,
},
+ lock => {type => BOOLEAN,
+ optional => 1,
+ },
},
);
die "One of bug or summary must be passed to read_bug"
$log =~ s/\.summary$/.log/;
($location) = $status =~ m/(db-h|db|archive)/;
}
- my $status_fh = new IO::File $status, 'r' or
- warn "Unable to open $status for reading: $!" and return undef;
+ if ($param{lock}) {
+ filelock("$config{spool_dir}/lock/$param{bug}");
+ }
+ my $status_fh = IO::File->new($status, 'r');
+ if (not defined $status_fh) {
+ warn "Unable to open $status for reading: $!";
+ if ($param{lock}) {
+ unfilelock();
+ }
+ return undef;
+ }
my %data;
my @lines;
# Version 3 is the latest format version currently supported.
if ($version > 3) {
warn "Unsupported status version '$version'";
+ if ($param{lock}) {
+ unfilelock();
+ }
return undef;
}
# Add log last modified time
$data{log_modified} = (stat($log))[9];
$data{location} = $location;
+ $data{archived} = $location eq 'archive';
$data{bug_num} = $param{bug};
return \%data;
sub lockreadbug {
my ($lref, $location) = @_;
- &filelock("lock/$lref");
- my $data = read_bug(bug => $lref, location => $location);
- &unfilelock unless defined $data;
- return $data;
+ return read_bug(bug => $lref, location => $location, lock => 1);
}
=head2 lockreadbugmerge
return (1,$data);
}
unfilelock();
- filelock('lock/merge');
+ filelock("$config{spool_dir}/lock/merge");
$data = lockreadbug(@_);
if (not defined $data) {
unfilelock();
return (2,$data);
}
+=head2 lock_read_all_merged_bugs
+
+ my ($locks,@bug_data) = lock_read_all_merged_bugs($bug_num,$location);
+
+Performs a filelock, then reads the bug passed. If the bug is merged,
+locks the merge lock, then reads and locks all of the other merged
+bugs. Returns a list of the number of locks and the bug data for all
+of the merged bugs.
+
+Will also return undef if any of the merged bugs failed to be read,
+even if all of the others were read properly.
+
+=cut
+
+sub lock_read_all_merged_bugs {
+ my ($bug_num,$location) = @_;
+ my @data = (lockreadbug(@_));
+ if (not @data and not defined $data[0]) {
+ return (0,undef);
+ }
+ if (not length $data[0]->{mergedwith}) {
+ return (1,@data);
+ }
+ unfilelock();
+ filelock("$config{spool_dir}/lock/merge");
+ my $locks = 0;
+ @data = (lockreadbug(@_));
+ if (not @data and not defined $data[0]) {
+ unfilelock(); #for merge lock above
+ return (0,undef);
+ }
+ $locks++;
+ my @bugs = split / /, $data[0]->{mergedwith};
+ for my $bug (@bugs) {
+ my $newdata = undef;
+ if ($bug ne $bug_num) {
+ $newdata = lockreadbug($bug,$location);
+ if (not defined $newdata) {
+ for (1..$locks) {
+ unfilelock();
+ }
+ $locks = 0;
+ warn "Unable to read bug: $bug while handling merged bug: $bug_num";
+ return ($locks,undef);
+ }
+ $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));
+ if ($newdata->{mergedwith} ne $expectmerge) {
+ for (1..$locks) {
+ unfilelock();
+ }
+ die "Bug $bug_num differs from bug $bug: ($newdata->{mergedwith}) vs. ($expectmerge) (".join(' ',@bugs).")";
+ }
+ }
+ return (2,@data);
+}
+
my @v1fieldorder = qw(originator date subject msgid package
keywords done forwarded mergedwith severity);
print STDERR "Cannot archive $param{bug} because it is not done\n" if $DEBUG;
return $cannot_archive
}
+ # 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}||'')) {
+ 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;
+ }
+ }
+ }
+
# 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');
last if $buggy eq 'found';
$min_fixed_time = min($time_versions{$version},$min_fixed_time);
}
- $min_archive_days = max($min_archive_days,ceil($config{remove_age} - (time - $min_fixed_time)/(60*60*24)));
+ $min_archive_days = max($min_archive_days,ceil($config{remove_age} - (time - $min_fixed_time)/(60*60*24)))
+ # if there are no versions in the archive at all, then
+ # we can archive if enough days have passed
+ if @sourceversions;
}
# If $param{ignore_time}, then we should ignore time.
if ($param{ignore_time}) {
$status{"pending"} = 'fixed' if ($tags{fixed});
- my $presence = bug_presence(map{(exists $param{$_})?($_,$param{$_}):()}
+ my $presence = bug_presence(status => \%status,
+ map{(exists $param{$_})?($_,$param{$_}):()}
qw(bug sourceversions arch dist version found fixed package)
);
if (defined $presence) {
sub bughook_archive {
my @refs = @_;
- &filelock("debbugs.trace.lock");
+ &filelock("$config{spool_dir}/debbugs.trace.lock");
&appendfile("debbugs.trace","archive ".join(',',@refs)."\n");
my %bugs = update_realtime("$config{spool_dir}/index.db.realtime",
map{($_,'REMOVE')} @refs);
sub bughook {
my ( $type, %bugs_temp ) = @_;
- &filelock("debbugs.trace.lock");
+ &filelock("$config{spool_dir}/debbugs.trace.lock");
my %bugs;
for my $bug (keys %bugs_temp) {