X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Debbugs%2FDBase.pm;h=5df78b01d2b747830f4355ca99a3d8f6a5120f77;hb=1c4ce01f78b112c2247a08f1a0dc9efb5ab3adca;hp=9ed81600a002e53e301d9c984a6b3528a03f162f;hpb=22e115184540ace6468590898d138300b2967070;p=debbugs.git

diff --git a/Debbugs/DBase.pm b/Debbugs/DBase.pm
index 9ed8160..5df78b0 100644
--- a/Debbugs/DBase.pm
+++ b/Debbugs/DBase.pm
@@ -1,3 +1,6 @@
+# TODO: Implement 'stale' checks, so that there is no need to explicitly
+#	write out a record, before closing.
+
 package Debbugs::DBase;  # assumes Some/Module.pm
 
 use strict;
@@ -10,25 +13,32 @@ BEGIN {
 	$VERSION     = 1.00;
 
 	@ISA         = qw(Exporter);
-	@EXPORT      = qw( %Record );
+	@EXPORT      = qw();
 	%EXPORT_TAGS = ( );     # eg: TAG => [ qw!name1 name2! ],
 
 	# your exported package globals go here,
 	# as well as any optionally exported functions
-	@EXPORT_OK   = qw( %Record );
+	@EXPORT_OK   = qw();
 }
 
 use vars      @EXPORT_OK;
 use Fcntl ':flock';
-use Debbugs::Config qw(%Globals);
+use Debbugs::Config;
+use Debbugs::Email;
 use Debbugs::Common;
-use FileHandle;
+use Debbugs::DBase::Log;
+use Debbugs::DBase::Log::Html;
+use Debbugs::DBase::Log::Message;
+use Debbugs::DBase::Log::Mail;
 
-%Record = ();
+use FileHandle;
+use File::Basename qw(&dirname);
+use File::Path;
 
-my $LoadedRecord = 0;
-my $FileLocked = 0;
-my $FileHandle = new FileHandle;
+my $OpenedRecord = 0;
+my $OpenedLog = 0;
+my $FileHandle;
+my $LogfileHandle = new FileHandle;
 
 sub ParseVersion1Record
 {
@@ -36,22 +46,30 @@ sub ParseVersion1Record
     my @fields = ( "originator", "date", "subject", "msgid", "package",
 		"keywords", "done", "forwarded", "mergedwith", "severity" );
     my $i = 0;
+    my $tag;
+    my (%record, %btags);
+
+    print "D2: (DBase) Record Fields:\n" if $Globals{ 'debug' } > 1;
     foreach my $line ( @data )
     {
 	chop( $line );
-	$Record{ $fields[$i] } = $line;
+	$tag = $fields[$i];
+	$record{ $tag } = $line;
+    	print "\t $tag = $line\n" if $Globals{ 'debug' } > 1;
 	$i++;
+	$btags{ "BUG_$tag" } = $line;
     }
+    return ( \%record, \%btags );
 }
 
 sub ParseVersion2Record
 {
     # I envision the next round of records being totally different in
     # meaning.  In order to maintain compatability, version tagging will be
-    # implemented in thenext go around and different versions will be sent
+    # implemented in the next go around and different versions will be sent
     # off to different functions to be parsed and interpreted into a format
     # that the rest of the system will understand.  All data will be saved
-    # in whatever 'new" format ixists.  The difference will be a "Version: x"
+    # in whatever 'new" format exists.  The difference will be a "Version: x"
     # at the top of the file.
 
     print "No version 2 records are understood at this time\n";
@@ -60,47 +78,210 @@ sub ParseVersion2Record
 
 sub ReadRecord
 {
-    my $record = $_[0];
-    if ( $record ne $LoadedRecord )
+    my ($recordnum, $with_log, $new) = (shift, shift, shift);
+    my @data;
+    my $record;
+    my $btags;
+
+    #Open Status File
+    print "V: Reading status $recordnum\n" if $Globals{ 'verbose' };
+    if( $OpenedRecord != $recordnum )
     {
-	my $path = '';
-	my @data;
-	
-	#find proper directory to store in
-        #later, this will be for tree'd data directory the way
-        #expire is now,..
-	$path = "/db/".$record.".status";
-    
-	open( $FileHandle, $Globals{ "work-dir" } . $path ) 
-	    || &fail( "Unable to open record: ".$Globals{ "work-dir" }."$path\n");
-	flock( $FileHandle, LOCK_EX ) || &fail( "Unable to lock record $record\n" );
-	@data = <$FileHandle>;
-	if ( scalar( @data ) =~ /Version: (\d*)/ )
+	if( defined( $FileHandle ) )
 	{
-	    if ( $1 == 2 )
-	    { &ParseVersion2Record( @data ); }
-	    else
-	    { &fail( "Unknown record version: $1\n"); }
+	    print "D1: Closing status $recordnum\n" if $Globals{ 'debug' };
+	    $OpenedRecord = 0;
+	    close $FileHandle;
+	    $FileHandle = undef;
 	}
-	else { &ParseVersion1Record( @data ); }
-	$LoadedRecord = $record;
+	print "D1: Opening status $recordnum\n" if $Globals{ 'debug' };
+	$FileHandle = &OpenFile( ["db", "archive"], $recordnum, ".status", "status", $new );
+	if( !defined( $FileHandle ) ) { return undef; }
     }
+    else { print "D1: Reusing status $recordnum\n" if $Globals{ 'debug' }; }
+
+    #Lock status file
+    print "D1: Locking status $recordnum\n" if $Globals{ 'debug' };
+    flock( $FileHandle, LOCK_EX ) || &fail( "Unable to lock record $recordnum\n" );
 
+    #Read in status file contents
+    print "D1: Loading status $recordnum\n" if $Globals{ 'debug' };
+    seek( $FileHandle, 0, 0 );
+    @data = <$FileHandle>;
+
+    #Parse Status File Contents
+    if ( scalar( @data ) =~ /Version: (\d*)/ )
+    {
+	if ( $1 == 2 )
+	{ &ParseVersion2Record( @data ); }
+	else
+	{ &fail( "Unknown record version: $1\n"); }
+    }
+    else { ($record, $btags) = &ParseVersion1Record( @data ); }
+    if( $with_log )
+    {
+	#DO READ IN LOG RECORD DATA STUFF
+    }
+    return ($record, $btags);
 }
 
 sub WriteRecord
 {
+    my ($recordnum, %record) = @_;
     my @fields = ( "originator", "date", "subject", "msgid", "package",
 		"keywords", "done", "forwarded", "mergedwith", "severity" );
+
+    #Open Status File
+    print "V: Writing status $recordnum\n" if $Globals{ 'verbose' };
+    if( $OpenedRecord != $recordnum )
+    {
+	if( defined( $FileHandle ) )
+	{
+	    print "D1: Closing status $recordnum\n" if $Globals{ 'debug' };
+	    $OpenedRecord = 0;
+	    close $FileHandle;
+	    $FileHandle = undef;
+	}
+	print "D1: Opening status $recordnum\n" if $Globals{ 'debug' };
+	$FileHandle = &OpenFile( ["db", "archive"], $recordnum, ".status", "status", "old" );
+	if( !defined( $FileHandle ) ) { return undef; }
+    }
+    else { print "D1: Reusing status $recordnum\n" if $Globals{ 'debug' }; }
+
+    #Lock status file
+    print "D1: Locking status $recordnum\n" if $Globals{ 'debug' };
+    flock( $FileHandle, LOCK_EX ) || &fail( "Unable to lock record $recordnum\n" );
+
+    #Read in status file contents
+    print "D1: Saving status $recordnum\n" if $Globals{ 'debug' };
     seek( $FileHandle, 0, 0 );
     for( my $i = 0; $i < $#fields; $i++ )
     {
-	if ( defined( $fields[$i] ) )
-	{ print $FileHandle $Record{ $fields[$i] } . "\n"; }
+	if ( defined( $record{ $fields[$i] } ) )
+	{ print $FileHandle $record{ $fields[$i] } . "\n"; }
 	else { print $FileHandle "\n"; }
     }
-    close $FileHandle;
-    $LoadedRecord = 0;
+}
+
+sub GetFileName
+{
+    my ($prePaths, $stub, $postPath, $desc, $new) = (shift, shift, shift, shift, shift);
+    my $path;
+    foreach my $prePath (@$prePaths) {
+	$path = "/" . $prePath . "/" . $stub . $postPath;
+	print "V: Opening $desc $stub\n" if $Globals{ 'verbose' };
+	print "D2: (DBase) trying $path\n" if $Globals{ 'debug' } > 1;
+	if( ! -r $Globals{ "work-dir" } . $path ) {
+	    $path = "/" . $prePath . "/" . &NameToPathHash($stub) . $postPath;
+	    print "D2: (DBase) trying $path\n" if $Globals{ 'debug' } > 1;
+	    if( ! -r $Globals{ "work-dir" } . $path ) {
+		next if( !$new =~ "new" );
+	    }
+	}
+	if( -r $Globals{ "work-dir" } . $path ) {
+	    return $path;
+	}
+	if( ( ! -r $Globals{ "work-dir" } . $path ) && defined($new) && $new =~ "new") {
+	    my $dir = dirname( $path );
+	    if ( ! -d $Globals{ "work-dir" } . $dir ) {
+		mkpath($Globals{ "work-dir" } . $dir);
+	    }
+	    return $path;
+	}
+    }
+    return undef;
+}
+
+sub OpenFile
+{
+    my ($prePaths, $stub, $postPath, $desc, $new) = (shift, shift, shift, shift, shift);
+    my $fileName = GetFileName($prePaths, $stub, $postPath, $desc, $new);
+    my $handle = new FileHandle;
+    open( $handle, $Globals{ "work-dir" } . $fileName ) && return $handle;
+    return undef;
+}
+
+sub OpenLogfile
+{
+    my $record = $_[0];
+    if ( $record ne $OpenedLog )
+    {
+	$LogfileHandle = OpenFile(["db", "archive"], $record, ".log", "log");
+	$OpenedLog = $record;
+    }
+}
+
+sub ReadLogfile
+{
+    my $record = $_[0];
+    if ( $record eq $OpenedLog )
+    {
+	seek( $LogfileHandle, 0, 0 );
+	my $log = new Debbugs::DBase::Log;
+	$log->Load($LogfileHandle);
+    }
+}
+
+sub CloseLogfile
+{
+    print "V: Closing log $OpenedLog\n" if $Globals{ 'verbose' };
+    close $LogfileHandle;
+    $OpenedLog = 0;
+}
+sub GetBugList
+{
+# TODO: This is ugly, but the easiest for me to implement.
+#	If you have a better way, then please send a patch.
+#
+    my $dir = new FileHandle;
+
+    my $prefix;
+    my $paths = shift;
+    my @paths;
+    if ( !defined($paths) ) {
+	@paths = ("db");
+    } else {
+	@paths = @$paths;
+    }
+    my @ret;
+    my $path;
+    foreach $path (@paths) {
+	$prefix = $Globals{ "work-dir" } . "/" . $path . "/";
+	opendir $dir, $prefix;
+	my @files = readdir($dir);
+	closedir $dir;
+	foreach (grep { /\d*\d\d.status/ } @files) {
+	    next if ( ! -s $prefix . "/" . $_ );
+	    s/.status$//;
+	    push @ret, $_;
+#	    print "$_ -> $_\n";
+	}
+	foreach (grep { /^[s0-9]$/ } @files) {
+	    my $_1 = $_;
+	    opendir $dir, $prefix . $_1;
+	    my @files = grep { /^\d$/ } readdir($dir);
+	    closedir $dir;
+	    foreach (@files) {
+		my $_2 = $_;
+		opendir $dir, "$prefix$_1/$_2";
+		my @files = grep { /^\d$/ } readdir($dir);
+		close $dir;
+		foreach (@files) {
+		    my $_3 = $_;
+		    opendir $dir, "$prefix$_1/$_2/$_3";
+		    my @files = grep { /\d*\d\d.status/ } readdir($dir);
+		    close $dir;
+		    foreach (@files) {
+			next if ( ! -s "$prefix$_1/$_2/$_3/$_" );
+			s/.status$//;
+			push @ret, $_;
+#			print "$_ -> $_1/$_2/$_3/$_\n";
+		    }
+		}
+	    }
+	}
+    }
+    return @ret;
 }
 
 1;