/[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!

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

Parent Directory | Revision Log | View Patch Patch

-revision 24 by ulpfr,
Sat Nov 11 17:21:28 2000 UTC
+revision 34 by ulpfr,
Sun Nov 12 14:22:40 2000 UTC
 Line 4
  # Author          : Ulrich Pfeifer
  # Created On      : Thu Aug  8 13:05:10 1996
  # Last Modified By: Ulrich Pfeifer
- # Last Modified On: Fri May 19 14:51:14 2000
+ # Last Modified On: Sun Nov 12 15:21:19 2000
  # Language        : CPerl
- # Update Count    : 133
+ # Update Count    : 135
  # Status          : Unknown, Use with caution!
  #
  # Copyright (c) 1996-1997, Ulrich Pfeifer
 Line 166 
 sub new {
    }
    my $lockmgr = LockFile::Simple->make(-autoclean => 1);
-   # aquire a write lock
+   # 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'";
-Line 386 
 sub open {
+Line 387 
 sub open {
    # Locking
    #
    # We allow multiple readers to coexists.  But write access excludes
-   # all read access vice versa.  In practice read access on tables
+   # 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);
-   # aquire a write lock. We might hold one acquired in create() already
-   $self->{write_lock} ||= $lockmgr->lock($self->{file} . '/write')
-     or die "Can't lock '$self->{file}/write'";
    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
+     # 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 pline file.
+       # 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'";
-Line 419 
 sub open {
+Line 434 
 sub open {
          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'";
-     # We are a reader. So we release the write lock
+     # 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");
+     $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};
    }
-Line 609 
 sub delete {
+Line 635 
 sub delete {
  }
  sub unpack {
-   my $self = shift;
+   my($self, $tuple) = @_;
-   my $tuple = shift;
-   return unless defined $tuple;
+   unless (defined $tuple){
+     # require Carp; # unfortunately gives us "bizarre copy...." :-(((((
+     warn("Debug: somebody called unpack without argument tuple!");
+     return;
+   }
    my $att;
    my @result;
-Line 626 
 sub unpack {
+Line 656 
 sub unpack {
  sub set {
    my ($self, $iattr, $value) = @_;
-   unless ($self->{write_lock}) {
+   unless ($self->{write_lock}){
-     die "Cannot set attribute $iattr without having a write lock. Nothing done";
+     warn "Cannot set iattr[$iattr] without write lock. Nothing done";
+     return;
    }
    for my $att (keys %{$self->{inverted}}) {
      if ($] > 5.003) {         # avoid bug in perl up to 5.003_05
-Line 649 
 sub close {
+Line 680 
 sub close {
    if (exists $self->{'access'}) {
      eval {$self->{'access'}->close}; # dont bother if not opened
    }
-   for (values %{$self->{indexes}}) {
+   if ($WAIT::Index::VERSION) {
-     require WAIT::Index;
+     for (values %{$self->{indexes}}) {
-     $_->close();
+       $_->close();
+     }
    }
-   if (defined $self->{inverted}) {
+   if (defined $self->{inverted} && $WAIT::InvertedIndex::VERSION) {
-     require WAIT::InvertedIndex;
+     # require WAIT::InvertedIndex; Uli: we can avoid closing indexes:
+     # if WAIT::InvertedIndex has not been loaded, they cannot have
+     # been altered so far
      my $att;
      for $att (keys %{$self->{inverted}}) {
        if ($] > 5.003) {         # avoid bug in perl up to 5.003_05

 Legend:



Removed from v.24
 


changed lines


 
Added in v.34
 Legend:



Removed from v.24
 


changed lines


 
Added in v.34
-Removed from v.24
+Added in v.34

	ViewVC Help
Powered by ViewVC 1.1.26