/[wait]/trunk/lib/WAIT/Table.pm
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/lib/WAIT/Table.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 34 by ulpfr, Sun Nov 12 14:22:40 2000 UTC revision 77 by laperla, Mon Apr 8 21:00:08 2002 UTC
# Line 4  Line 4 
4  # Author          : Ulrich Pfeifer  # Author          : Ulrich Pfeifer
5  # Created On      : Thu Aug  8 13:05:10 1996  # Created On      : Thu Aug  8 13:05:10 1996
6  # Last Modified By: Ulrich Pfeifer  # Last Modified By: Ulrich Pfeifer
7  # Last Modified On: Sun Nov 12 15:21:19 2000  # Last Modified On: Wed Jan 23 14:15:15 2002
8  # Language        : CPerl  # Language        : CPerl
9  # Update Count    : 135  # Update Count    : 152
10  # Status          : Unknown, Use with caution!  # Status          : Unknown, Use with caution!
11  #  #
12  # Copyright (c) 1996-1997, Ulrich Pfeifer  # Copyright (c) 1996-1997, Ulrich Pfeifer
# Line 165  sub new { Line 165  sub new {
165      croak "Could not 'mkdir $self->{file}': $!\n";      croak "Could not 'mkdir $self->{file}': $!\n";
166    }    }
167    
   my $lockmgr = LockFile::Simple->make(-autoclean => 1);  
   # Aquire a write lock, since we are creating the table, no readers  
   # could possibly be active.  
   $self->{write_lock} = $lockmgr->lock($self->{file} . '/write')  
     or die "Can't lock '$self->{file}/write'";  
   
168    $self->{djk}      = $parm{djk}      if defined $parm{djk};    $self->{djk}      = $parm{djk}      if defined $parm{djk};
169    $self->{layout}   = $parm{layout} || new WAIT::Parse::Base;    $self->{layout}   = $parm{layout} || new WAIT::Parse::Base;
170    $self->{access}   = $parm{access} if defined $parm{access};    $self->{access}   = $parm{access} if defined $parm{access};
# Line 179  sub new { Line 173  sub new {
173    $self->{indexes}  = {};    $self->{indexes}  = {};
174    
175    bless $self, $type;    bless $self, $type;
176    
177      # Checking for readers is not necessary, but let's go with the
178      # generic method.
179      $self->getlock(O_RDWR|O_CREAT); # dies when failing
180      
181    # Call create_index() and create_index() for compatibility    # Call create_index() and create_index() for compatibility
182    for (@{$self->{keyset}||[]}) {    for (@{$self->{keyset}||[]}) {
183      #carp "Specification of indexes at table create time is deprecated";      #carp "Specification of indexes at table create time is deprecated";
# Line 324  Must be called via C<WAIT::Database::dro Line 323  Must be called via C<WAIT::Database::dro
323    
324  sub drop {  sub drop {
325    my $self = shift;    my $self = shift;
326    
327      unless ($self->{write_lock}){
328        warn "Cannot drop table without write lock. Nothing done";
329        return;
330      }
331      
332    if ((caller)[0] eq 'WAIT::Database') { # database knows about this    if ((caller)[0] eq 'WAIT::Database') { # database knows about this
333      $self->close;               # just make sure      $self->close;               # just make sure
334    
335      my $file = $self->{file};      my $file = $self->{file};
336    
337      for (values %{$self->{indexes}}) {      for (values %{$self->{indexes}}) {
338        $_->drop;        $_->drop;
339      }      }
340      unlink "$file/records";      unlink "$file/records";
341        rmdir "$file/read" or warn "Could not rmdir '$file/read'";
342    
343      # $self->unlock;      # $self->unlock;
344      ! (!-e $file or rmdir $file);      ! (!-e $file or rmdir $file);
345    } else {    } else {
# Line 373  sub open { Line 381  sub open {
381      }      }
382      require WAIT::InvertedIndex;      require WAIT::InvertedIndex;
383    }    }
384    
385      $self->getlock($self->{mode});
386    
387    unless (defined $self->{dbh}) {    unless (defined $self->{dbh}) {
388      if ($USE_RECNO) {      if ($USE_RECNO) {
389        $self->{dbh} = tie(@{$self->{db}}, 'DB_File', $file,        $self->{dbh} = tie(@{$self->{db}}, 'DB_File', $file,
# Line 383  sub open { Line 394  sub open {
394                           $self->{mode}, 0664, $DB_BTREE);                           $self->{mode}, 0664, $DB_BTREE);
395      }      }
396    }    }
397      
398    # Locking    
   #  
   # We allow multiple readers to coexists.  But write access excludes  
   # all read access and vice versa.  In practice read access on tables  
   # open for writing will mostly work ;-)  
   
   my $lockmgr = LockFile::Simple->make(-autoclean => 1);  
   
   my $lockdir = $self->{file} . '/read';  
   unless (-d $lockdir) {  
     mkdir $lockdir, 0755 or die "Could not mkdir $lockdir: $!";  
   }  
   
   if ($self->{mode} & O_RDWR) {  
     # Get a write lock.  Release it again and die if there is any  
     # valid reader.  
       
     # this is a hack.  We do not check for reopening ...  
     return $self if $self->{write_lock};  
   
     if ($self->{read_lock}) {  
       # We are a becoming a writer now. So we release the read lock to  
       # avoid blocking ourselves.  
       $self->{read_lock}->release;  
       delete $self->{read_lock};  
     }  
   
     # Get the preliminary write lock  
     $self->{write_lock} = $lockmgr->lock($self->{file} . '/write')  
       or die "Can't lock '$self->{file}/write'";  
       
     # If we actually want to write we must check if there are any  
     # readers.  The write lock is confirmed if wen cannot find any  
     # valid readers.  
       
     local *DIR;  
     opendir DIR, $lockdir or  
       die "Could not opendir '$lockdir': $!";  
     for my $lockfile (grep { -f "$lockdir/$_" } readdir DIR) {  
       # check if the locks are still valid.  
       # Since we are protected by a write lock, we could use a plain file.  
       # But we want to use the stale testing from LockFile::Simple.  
       if (my $lck = $lockmgr->trylock("$lockdir/$lockfile")) {  
         warn "Removing stale lockfile '$lockdir/$lockfile'";  
         $lck->release;  
       } else {  
         $self->{write_lock}->release;  
         die "Cannot write table '$file' while it's in use";  
       }  
     }  
     closedir DIR;  
   } else {  
     # this is a hack.  We do not check for reopening ...  
     return $self if $self->{read_lock};  
   
     # Get the preliminary write lock to protect the directory  
     # operations.  
       
     $self->{write_lock} ||= $lockmgr->lock($self->{file} . '/write')  
       or die "Can't lock '$self->{file}/write'";  
       
     # find a new read slot  
     my $id = time;  
     while (-f "$lockdir/$id.lock") { # here assume ".lock" format!  
       $id++;  
     }  
   
     $self->{read_lock} = $lockmgr->lock("$lockdir/$id")  
       or die "Can't lock '$lockdir/$id'";  
   
     # We are a reader now. So we release the write lock  
     $self->{write_lock}->release;  
     delete $self->{write_lock};  
   }  
   
399    $self;    $self;
400  }  }
401    
# Line 660  sub set { Line 597  sub set {
597      warn "Cannot set iattr[$iattr] without write lock. Nothing done";      warn "Cannot set iattr[$iattr] without write lock. Nothing done";
598      return;      return;
599    }    }
600    
601      # in the rare case that they haven't written a single record yet, we
602      # make sure, the inverted inherits our $self->{mode}:
603      defined $self->{db} or $self->open;
604    
605    for my $att (keys %{$self->{inverted}}) {    for my $att (keys %{$self->{inverted}}) {
606      if ($] > 5.003) {         # avoid bug in perl up to 5.003_05      if ($] > 5.003) {         # avoid bug in perl up to 5.003_05
607        my $idx;        my $idx;
# Line 717  sub close { Line 659  sub close {
659    1;    1;
660  }  }
661    
662    # Locking
663    #
664    # We allow multiple readers to coexists.  But write access excludes
665    # all read access and vice versa.  In practice read access on tables
666    # open for writing will mostly work ;-)
667    
668    # If a "write" lock is requested, an existing "read" lock will be
669    # released.  If a "read" lock ist requested, an existing "write" lock
670    # will be released.  Requiring a lock already hold has no effect.
671    
672    sub getlock {
673      my ($self, $mode) = @_;
674    
675      # autoclean cleans on DESTROY, stale sends SIGZERO to the owner
676      #
677      my $lockmgr = LockFile::Simple->make(-autoclean => 1, -stale => 1);
678      my $file    = $self->{file} . '/records';
679      my $lockdir = $self->{file} . '/read';
680    
681      unless (-d $lockdir) {
682        mkdir $lockdir, 0755 or die "Could not mkdir $lockdir: $!";
683      }
684      
685      if ($mode & O_RDWR) {         # Get a write lock.  Release it again
686                                    # and die if there is any valid
687                                    # readers.
688        
689        # Have a write lock already
690        return $self if $self->{write_lock};
691    
692        if ($self->{read_lock}) {   # We are a becoming a writer now. So
693                                    # we release the read lock to avoid
694                                    # blocking ourselves.
695          $self->{read_lock}->release;
696          delete $self->{read_lock};
697        }
698    
699        # Get the preliminary write lock
700        $self->{write_lock} = $lockmgr->lock($self->{file} . '/write')
701          or die "Can't lock '$self->{file}/write'";
702        
703        # If we actually want to write we must check if there are any
704        # readers.  The write lock is confirmed if wen cannot find any
705        # valid readers.
706        
707        local *DIR;
708        opendir DIR, $lockdir or
709          die "Could not opendir '$lockdir': $!";
710        for my $lockfile (grep { -f "$lockdir/$_" } readdir DIR) {
711          # Check if the locks are still valid.  Since we are protected by
712          # a write lock, we could use a plain file.  But we want to use
713          # the stale testing from LockFile::Simple.
714          if (my $lck = $lockmgr->trylock("$lockdir/$lockfile")) {
715            warn "Removing stale lockfile '$lockdir/$lockfile'";
716            $lck->release;
717          } else {                  # Found an active reader, rats!
718            $self->{write_lock}->release;
719            die "Cannot write table '$file' while it's in use";
720          }
721        }
722        closedir DIR;
723      } else {
724        # Have a read lock already
725        return $self if $self->{read_lock};
726    
727        # Get the preliminary write lock to protect the directory
728        # operations.
729    
730        my $write_lock = $lockmgr->lock($self->{file} . '/read/write')
731          or die "Can't lock '$self->{file}/read/write'";
732    
733        # Find a new read slot.  Maybe the plain file would be better?
734        my $id = time;
735        while (-f "$lockdir/$id.lock") { # here assume ".lock" format!
736          $id++;
737        }
738    
739        $self->{read_lock} = $lockmgr->lock("$lockdir/$id")
740          or die "Can't lock '$lockdir/$id'";
741    
742        # We are a reader now. So we release the write lock
743        $write_lock->release;
744      }
745      return $self;
746    }
747    
748  sub unlock {  sub unlock {
749    my $self = shift;    my $self = shift;
750    
# Line 738  sub unlock { Line 766  sub unlock {
766  sub DESTROY {  sub DESTROY {
767    my $self = shift;    my $self = shift;
768    
769    warn "Table handle destroyed without closing it first"    if ($self->{write_lock} || $self->{read_lock}) {
770      if $self->{write_lock} || $self->{read_lock};      warn "Table handle destroyed without closing it first";
771        $self->unlock;
772      }
773  }  }
774    
775  sub open_scan {  sub open_scan {
Legend:
Removed from v.34  
changed lines
  Added in v.77
  ViewVC Help
Powered by ViewVC 1.1.26