X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Debbugs%2FCommon.pm;h=279893c135bb98a4fda11d8dbd652cb2ffc64e10;hb=9dd18b2a38fae81a660504da29147937596ba206;hp=ab51dbacf5c86f5ab20ce9da4ff22f96a150f4b5;hpb=891c5cd5a2e1ec1ed95c6d3eff7a0c2595955742;p=debbugs.git diff --git a/Debbugs/Common.pm b/Debbugs/Common.pm index ab51dba..279893c 100644 --- a/Debbugs/Common.pm +++ b/Debbugs/Common.pm @@ -39,7 +39,7 @@ BEGIN{ @EXPORT = (); %EXPORT_TAGS = (util => [qw(getbugcomponent getbuglocation getlocationpath get_hashname), - qw(appendfile buglog getparsedaddrs getmaintainers), + qw(appendfile overwritefile buglog getparsedaddrs getmaintainers), qw(bug_status), qw(getmaintainers_reverse), qw(getpseudodesc), @@ -55,13 +55,14 @@ BEGIN{ lock => [qw(filelock unfilelock lockpid)], ); @EXPORT_OK = (); - Exporter::export_ok_tags(qw(lock quit date util misc)); + Exporter::export_ok_tags(keys %EXPORT_TAGS); $EXPORT_TAGS{all} = [@EXPORT_OK]; } #use Debbugs::Config qw(:globals); use Carp; +$Carp::Verbose = 1; use Debbugs::Config qw(:config); use IO::File; @@ -69,10 +70,11 @@ use IO::Scalar; use Debbugs::MIME qw(decode_rfc1522); use Mail::Address; use Cwd qw(cwd); +use Storable qw(dclone); use Params::Validate qw(validate_with :types); -use Fcntl qw(:flock); +use Fcntl qw(:DEFAULT :flock); our $DEBUG_FH = \*STDERR if not defined $DEBUG_FH; @@ -217,6 +219,28 @@ sub appendfile { close $fh or die "Unable to close $file: $!"; } +=head2 overwritefile + + ovewritefile($file,'data','to','append'); + +Opens file.new, writes data to it, then moves file.new to file. + +=cut + +sub overwritefile { + my ($file,@data) = @_; + my $fh = IO::File->new("${file}.new",'w') or + die "Unable top open ${file}.new for writing: $!"; + print {$fh} @data or die "Unable to write to ${file}.new: $!"; + close $fh or die "Unable to close ${file}.new: $!"; + rename("${file}.new",$file) or + die "Unable to rename ${file}.new to $file: $!"; +} + + + + + =head2 getparsedaddrs my $address = getparsedaddrs($address); @@ -406,6 +430,7 @@ sub __add_to_hash { $type //= 'address'; my $fh = IO::File->new($fn,'r') or die "Unable to open $fn for reading: $!"; + binmode($fh,':encoding(UTF-8)'); while (<$fh>) { chomp; next unless m/^(\S+)\s+(\S.*\S)\s*$/; @@ -509,20 +534,44 @@ These functions are exported with the :lock tag =head2 filelock - filelock + filelock($lockfile); + filelock($lockfile,$locks); FLOCKs the passed file. Use unfilelock to unlock it. +Can be passed an optional $locks hashref, which is used to track which +files are locked (and how many times they have been locked) to allow +for cooperative locking. + =cut our @filelocks; +use Carp qw(cluck); + sub filelock { # NB - NOT COMPATIBLE WITH `with-lock' - my ($lockfile) = @_; + my ($lockfile,$locks) = @_; if ($lockfile !~ m{^/}) { $lockfile = cwd().'/'.$lockfile; } + # This is only here to allow for relocking bugs inside of + # Debbugs::Control. Nothing else should be using it. + if (defined $locks and exists $locks->{locks}{$lockfile} and + $locks->{locks}{$lockfile} >= 1) { + if (exists $locks->{relockable} and + exists $locks->{relockable}{$lockfile}) { + $locks->{locks}{$lockfile}++; + # indicate that the bug for this lockfile needs to be reread + $locks->{relockable}{$lockfile} = 1; + push @{$locks->{lockorder}},$lockfile; + return; + } + else { + use Data::Dumper; + confess "Locking already locked file: $lockfile\n".Data::Dumper->Dump([$lockfile,$locks],[qw(lockfile locks)]); + } + } my ($count,$errors); $count= 10; $errors= ''; for (;;) { @@ -538,13 +587,19 @@ sub filelock { } if ($fh) { push @filelocks, {fh => $fh, file => $lockfile}; + if (defined $locks) { + $locks->{locks}{$lockfile}++; + push @{$locks->{lockorder}},$lockfile; + } last; } if (--$count <=0) { $errors =~ s/\n+$//; - die "failed to get lock on $lockfile -- $errors"; + use Data::Dumper; + croak "failed to get lock on $lockfile -- $errors". + (defined $locks?Data::Dumper->Dump([$locks],[qw(locks)]):''); } - sleep 10; +# sleep 10; } } @@ -559,6 +614,7 @@ END { =head2 unfilelock unfilelock() + unfilelock($locks); Unlocks the file most recently locked. @@ -568,10 +624,24 @@ locked with filelock. =cut sub unfilelock { + my ($locks) = @_; if (@filelocks == 0) { - warn "unfilelock called with no active filelocks!\n"; + carp "unfilelock called with no active filelocks!\n"; return; } + if (defined $locks and ref($locks) ne 'HASH') { + croak "hash not passsed to unfilelock"; + } + if (defined $locks and exists $locks->{lockorder} and + @{$locks->{lockorder}} and + exists $locks->{locks}{$locks->{lockorder}[-1]}) { + my $lockfile = pop @{$locks->{lockorder}}; + $locks->{locks}{$lockfile}--; + if ($locks->{locks}{$lockfile} > 0) { + return + } + delete $locks->{locks}{$lockfile}; + } my %fl = %{pop(@filelocks)}; flock($fl{fh},LOCK_UN) or warn "Unable to unlock lockfile $fl{file}: $!"; @@ -602,7 +672,7 @@ sub lockpid { unlink $pidfile or die "Unable to unlink stale pidfile $pidfile $!"; } - my $pidfh = IO::File->new($pidfile,'w') or + my $pidfh = IO::File->new($pidfile,O_CREAT|O_EXCL|O_WRONLY) or die "Unable to open $pidfile for writing: $!"; print {$pidfh} $$ or die "Unable to write to $pidfile $!"; close $pidfh or die "Unable to close $pidfile $!"; @@ -755,7 +825,8 @@ sub globify_scalar { if (defined ref($scalar)) { if (ref($scalar) eq 'SCALAR' and not UNIVERSAL::isa($scalar,'GLOB')) { - return IO::Scalar->new($scalar); + open $handle, '>:scalar:utf8', $scalar; + return $handle; } else { return $scalar; @@ -768,7 +839,7 @@ sub globify_scalar { carp "Given a non-scalar reference, non-glob to globify_scalar; returning /dev/null handle"; } } - return IO::File->new('/dev/null','w'); + return IO::File->new('/dev/null','>:utf8'); } =head2 cleanup_eval_fail() @@ -801,6 +872,8 @@ sub cleanup_eval_fail { } # ditch the "at foo/bar/baz.pm line 5" $error =~ s/\sat\s\S+\sline\s\d+//; + # ditch croak messages + $error =~ s/^\t+.+\n?//g; # ditch trailing multiple periods in case there was a cascade of # die messages. $error =~ s/\.+$/\./; @@ -824,6 +897,7 @@ sub hash_slice(\%@) { return map {exists $hashref->{$_}?($_,$hashref->{$_}):()} @keys; } + 1; __END__