X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Debbugs%2FCommon.pm;h=b135c42cd6c263cc37e4fd997b41b7ec1be9c13d;hb=0ce9751d4f117f3bfe4d713cd24a4ae820ab625d;hp=cec2c80e4a0e5b945819df9b9aa4251442ec26dc;hpb=5a417cf7dcb5940f947e975b1ed58da40a51254f;p=debbugs.git diff --git a/Debbugs/Common.pm b/Debbugs/Common.pm index cec2c80..b135c42 100644 --- a/Debbugs/Common.pm +++ b/Debbugs/Common.pm @@ -32,6 +32,7 @@ use warnings; use strict; use vars qw($VERSION $DEBUG %EXPORT_TAGS @EXPORT_OK @EXPORT); use Exporter qw(import); +use v5.10; BEGIN{ $VERSION = 1.00; @@ -47,6 +48,7 @@ BEGIN{ qw(package_maintainer), qw(sort_versions), qw(open_compressed_file), + qw(walk_bugs), ], misc => [qw(make_list globify_scalar english_join checkpid), qw(cleanup_eval_fail), @@ -78,6 +80,7 @@ use File::Path qw(mkpath); use File::Basename qw(dirname); use MLDBM qw(DB_File Storable); $MLDBM::DumpMeth='portable'; +use List::AllUtils qw(natatime); use Params::Validate qw(validate_with :types); @@ -280,6 +283,117 @@ sub open_compressed_file { return $fh; } +=head2 walk_bugs + +Walk through directories of bugs, calling a subroutine with a list of bugs +found. + +C sub {print map {qq($_\n)} @_},dirs => [qw(db-h)];> + +=over + +=item callback -- CODEREF of a subroutine to call with a list of bugs + +=item dirs -- ARRAYREF of directories to get bugs from. Like C<[qw(db-h archive)]>. + +=item bugs -- ARRAYREF of bugs to walk through. If both C and C are +provided, both are walked through. + +=item bugs_per_call -- maximum number of bugs to provide to callback + +=item progress_bar -- optional L + +=item bug_file -- bug file to look for (generally C) + +=item logging -- optional filehandle to output logging information + +=back + +=cut + +sub walk_bugs { + state $spec = + {dirs => {type => ARRAYREF, + default => [], + }, + bugs => {type => ARRAYREF, + default => [], + }, + progress_bar => {type => OBJECT|UNDEF, + optional => 1, + }, + bug_file => {type => SCALAR, + default => 'summary', + }, + logging => {type => HANDLE, + optional => 1, + }, + callback => {type => CODEREF, + }, + bugs_per_call => {type => SCALAR, + default => 1, + }, + }; + my %param = validate_with(params => \@_, + spec => $spec + ); + my @dirs = @{$param{dirs}}; + my @initial_bugs = (); + if (@{$param{bugs}}) { + unshift @dirs,''; + @initial_bugs = @{$param{bugs}}; + } + my $tot_dirs = @dirs; + my $done_dirs = 0; + my $avg_subfiles = 0; + my $completed_files = 0; + my $dir; + while ($dir = shift @dirs or defined $dir) { + my @list; + my @subdirs; + if (not length $dir and @initial_bugs) { + push @list,@initial_bugs; + @initial_bugs = (); + } else { + printf {$param{verbose}} "Doing dir %s ...\n", $dir + if defined $param{verbose}; + opendir(my $DIR, "$dir/.") or + die "opendir $dir: $!"; + @subdirs = readdir($DIR) or + die "Unable to readdir $dir: $!"; + closedir($DIR) or + die "Unable to closedir $dir: $!"; + + @list = map { m/^(\d+)\.$param{bug_file}$/?($1):() } @subdirs; + } + $tot_dirs -= @dirs; + push @dirs, map { m/^(\d+)$/ && -d "$dir/$1"?("$dir/$1"):() } @subdirs; + $tot_dirs += @dirs; + if ($param{progress_bar}) { + if ($avg_subfiles == 0) { + $avg_subfiles = @list; + } + $param{progress_bar}-> + target($avg_subfiles*($tot_dirs-$done_dirs)+$completed_files+@list); + $avg_subfiles = ($avg_subfiles * $done_dirs + @list) / ($done_dirs+1); + $done_dirs += 1; + } + + my $it = natatime $param{bugs_per_call},@list; + while (my @bugs = $it->()) { + $param{callback}->(@bugs); + $completed_files += scalar @bugs; + if ($param{progress_bar}) { + $param{progress_bar}->update($completed_files) if $param{progress_bar}; + } + if ($completed_files % 100 == 0 and + defined $param{verbose}) { + print {$param{verbose}} "Up to $completed_files bugs...\n" + } + } + } + $param{progress_bar}->remove() if $param{progress_bar}; +} =head2 getparsedaddrs @@ -383,12 +497,15 @@ maintainers for, defaults to the empty arrayref. maintainers for; automatically returns source package maintainer if the package name starts with 'src:', defaults to the empty arrayref. -=item reverse -- whether to return the source/binary packages a -maintainer maintains instead +=item maintainer -- scalar or arrayref of maintainers to return source packages +for. If given, binary and source cannot be given. =item rehash -- whether to reread the maintainer and source maintainer files; defaults to 0 +=item schema -- Debbugs::DB schema. If set, uses the database for maintainer +information. + =back =cut @@ -410,6 +527,9 @@ sub package_maintainer { reverse => {type => BOOLEAN, default => 0, }, + schema => {type => OBJECT, + optional => 1, + } }, ); my @binary = make_list($param{binary}); @@ -418,6 +538,53 @@ sub package_maintainer { if ((@binary or @source) and @maintainers) { croak "It is nonsensical to pass both maintainers and source or binary"; } + if (@binary) { + @source = grep {/^src:/} @binary; + @binary = grep {!/^src:/} @binary; + } + # remove leading src: from source package names + s/^src:// foreach @source; + if ($param{schema}) { + my $s = $param{schema}; + if (@maintainers) { + my $m_rs = $s->resultset('SrcPkg')-> + search({'correspondent.addr' => [@maintainers]}, + {join => {src_vers => + {maintainer => + 'correspondent'}, + }, + columns => ['pkg'], + group_by => [qw(me.pkg)], + }); + return $m_rs->get_column('pkg')->all(); + } elsif (@binary or @source) { + my $rs = $s->resultset('Maintainer'); + if (@binary) { + $rs = + $rs->search({'bin_pkg.pkg' => [@binary]}, + {join => {src_vers => + {bin_vers => 'bin_pkg'}, + }, + columns => ['name'], + group_by => [qw(me.name)], + } + ); + } + if (@source) { + $rs = + $rs->search({'src_pkg.pkg' => [@source]}, + {join => {src_vers => + 'src_pkg', + }, + columns => ['name'], + group_by => [qw(me.name)], + } + ); + } + return $rs->get_column('name')->all(); + } + return (); + } if ($param{rehash}) { $_source_maintainer = undef; $_source_maintainer_rev = undef; @@ -484,7 +651,7 @@ sub package_maintainer { } my @return; for my $binary (@binary) { - if (not $param{reverse} and $binary =~ /^src:/) { + if ($binary =~ /^src:/) { push @source,$binary; next; } @@ -973,6 +1140,8 @@ before. This appears to be a bug in the underlying modules. =cut +our $_NULL_HANDLE; + sub globify_scalar { my ($scalar) = @_; my $handle; @@ -997,8 +1166,15 @@ sub globify_scalar { else { carp "Given a non-scalar reference, non-glob to globify_scalar; returning /dev/null handle"; } + } + if (not defined $_NULL_HANDLE or + not $_NULL_HANDLE->opened() + ) { + $_NULL_HANDLE = + IO::File->new('/dev/null','>:encoding(UTF-8)') or + die "Unable to open /dev/null for writing: $!"; } - return IO::File->new('/dev/null','>:encoding(UTF-8)'); + return $_NULL_HANDLE; } =head2 cleanup_eval_fail()