/[wait]/cvs-head/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 /cvs-head/lib/WAIT/Table.pm

Parent Directory | Revision Log | View Patch Patch

-revision 13 by ulpfr,
Fri Apr 28 15:42:44 2000 UTC
+revision 19 by ulpfr,
Tue May  9 11:29:45 2000 UTC
 Line 4
  # Author          : Ulrich Pfeifer
  # Created On      : Thu Aug  8 13:05:10 1996
  # Last Modified By: Ulrich Pfeifer
- # Last Modified On: Sun May 30 20:42:30 1999
+ # Last Modified On: Mon May  8 20:20:58 2000
  # Language        : CPerl
- # Update Count    : 56
+ # Update Count    : 131
  # Status          : Unknown, Use with caution!
  #
  # Copyright (c) 1996-1997, Ulrich Pfeifer
 Line 34 
 use Carp;
  # use autouse Carp => qw( croak($) );
  use DB_File;
  use Fcntl;
+ use LockFile::Simple ();
  my $USE_RECNO = 0;
-Line 163 
 sub new {
+Line 164 
 sub new {
    } elsif (!mkdir($self->{file}, 0775)) {
      croak "Could not 'mkdir $self->{file}': $!\n";
    }
+   my $lockmgr = LockFile::Simple->make(-autoclean => 1);
+   # aquire a write lock
+   $self->{write_lock} = $lockmgr->lock($self->{file} . '/write')
+     or die "Can't lock '$self->{file}/write'";
    $self->{djk}      = $parm{djk}      if defined $parm{djk};
    $self->{layout}   = $parm{layout} || new WAIT::Parse::Base;
    $self->{access}   = $parm{access} if defined $parm{access};
-Line 188 
 sub new {
+Line 195 
 sub new {
      }
      $self->create_inverted_index(attribute => $att, pipeline  => \@spec, @opt);
    }
    $self;
    # end of backwarn compatibility stuff
  }
-Line 323 
 sub drop {
+Line 331 
 sub drop {
        $_->drop;
      }
      unlink "$file/records";
+     # $self->unlock;
      ! (!-e $file or rmdir $file);
    } else {
      croak ref($self)."::drop called directly";
-Line 373 
 sub open {
+Line 382 
 sub open {
                           $self->{mode}, 0664, $DB_BTREE);
      }
    }
+   # Locking
+   #
+   # We allow multiple readers to coexists.  But write access excludes
+   # all read access 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) {
+     # this is a hack.  We do not check for reopening ...
+     return $self if $self->{write_lock};
+     # If we actually want to write we must check if there are any readers
+     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.
+       # 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";
+       }
+     }
+   } else {
+     # this is a hack.  We do not check for reopening ...
+     return $self if $self->{read_lock};
+     # We are a reader. So we release the write lock
+     my $id = time;
+     while (-f "$lockdir/$id.lock") { # here assume ".lock" format!
+       $id++;
+     }
+     $self->{read_lock} = $lockmgr->lock("$lockdir/$id");
+     $self->{write_lock}->release;
+     delete $self->{write_lock};
+   }
    $self;
  }
-Line 432 
 sub insert {
+Line 492 
 sub insert {
    my $tuple = join($;, map($parm{$_} || '', @{$self->{attr}}));
    my $key;
    my @deleted = keys %{$self->{deleted}};
+   my $gotkey = 0;
    if (@deleted) {
      $key = pop @deleted;
      delete $self->{deleted}->{$key};
+     # Sanity check
+     if ($key && $key>0) {
+       $gotkey=1;
    } else {
+       warn(sprintf("WAIT database inconsistency during insert ".
+                    "key[%s]: Please rebuild index\n",
+                    $key
+                   ));
+     }
+   }
+   unless ($gotkey) {
      $key = $self->{nextk}++;
    }
    if ($USE_RECNO) {
-Line 450 
 sub insert {
+Line 521 
 sub insert {
        if ($key == $self->{nextk}-1) {
          $self->{nextk}--;
        } else {
+         # warn "setting key[$key] deleted during insert";
          $self->{deleted}->{$key}=1;
        }
        my $idx;
-Line 504 
 sub delete_by_key {
+Line 576 
 sub delete_by_key {
    my $self  = shift;
    my $key   = shift;
+   unless ($key) {
+     Carp::cluck "Warning: delete_by_key called without key. Looks like a bug in WAIT?";
+     return;
+   }
    return $self->{deleted}->{$key} if defined $self->{deleted}->{$key};
    my %tuple = $self->fetch($key);
    for (values %{$self->{indexes}}) {
-Line 520 
 sub delete_by_key {
+Line 597 
 sub delete_by_key {
        }
      }
    }
+   # warn "setting key[$key] deleted during delete_by_key";
    ++$self->{deleted}->{$key};
  }
  sub delete {
    my $self  = shift;
    my $tkey = $self->have(@_);
+   # warn "tkey[$tkey]\@_[@_]";
    defined $tkey && $self->delete_by_key($tkey, @_);
  }
  sub unpack {
    my $self = shift;
    my $tuple = shift;
+   return unless defined $tuple;
    my $att;
    my @result;
-Line 544 
 sub unpack {
+Line 623 
 sub unpack {
    @result;
  }
+ sub set {
+   my ($self, $iattr, $value) = @_;
+   return unless $self->{write_lock};
+   for my $att (keys %{$self->{inverted}}) {
+     if ($] > 5.003) {         # avoid bug in perl up to 5.003_05
+       my $idx;
+       for $idx (@{$self->{inverted}->{$att}}) {
+         $idx->set($iattr, $value);
+       }
+     } else {
+       map $_->set($iattr, $value), @{$self->{inverted}->{$att}};
+     }
+   }
+;
+ }
  sub close {
    my $self = shift;
-Line 551 
 sub close {
+Line 648 
 sub close {
      eval {$self->{'access'}->close}; # dont bother if not opened
    }
    for (values %{$self->{indexes}}) {
+     require WAIT::Index;
      $_->close();
    }
    if (defined $self->{inverted}) {
-Line 577 
 sub close {
+Line 675 
 sub close {
      delete $self->{db};
    }
+   $self->unlock;
 ;
  }
+ sub unlock {
+   my $self = shift;
+   # Either we have a read or a write lock (or we close the table already)
+   # unless ($self->{read_lock} || $self->{write_lock}) {
+   #   warn "WAIT::Table::unlock: Table aparently hold's no lock"
+   # }
+   if ($self->{write_lock}) {
+     $self->{write_lock}->release();
+     delete $self->{write_lock};
+   }
+   if ($self->{read_lock}) {
+     $self->{read_lock}->release();
+     delete $self->{read_lock};
+   }
+ }
  sub DESTROY {
    my $self = shift;
    warn "Table handle destroyed without closing it first"
-     if $self->{db} and $self->{mode}&O_RDWR;
+     if $self->{write_lock} || $self->{read_lock};
  }
  sub open_scan {
-Line 642 
 sub intervall {
+Line 760 
 sub intervall {
  }
  sub search {
-   my $self = shift;
+   my $self  = shift;
-   my $attr = shift;
+   my ($query, $attr, $cont, $raw);
-   my $cont = shift;
+   if (ref $_[0]) {
-   my $raw  = shift;
+     $query = shift;
+     $attr = $query->{attr};
+     $cont = $query->{cont};
+     $raw  = $query->{raw};
+   } else {
+     require Carp;
+     Carp::cluck("Using three argument search interface is deprecated, use hashref interface instead");
+     $attr = shift;
+     $cont = shift;
+     $raw  = shift;
+     $query = {
+               attr => $attr,
+               cont => $cont,
+               raw  => $raw,
+              };
+   }
    my %result;
    defined $self->{db} or $self->open; # require layout
-Line 655 
 sub search {
+Line 790 
 sub search {
        my $name = $_->name;
        if (exists $raw->{$name} and @{$raw->{$name}}) {
          my $scale = 1/scalar(@{$raw->{$name}});
-         my %r = $_->search_raw(@{$raw->{$name}});
+         my %r = $_->search_raw($query, @{$raw->{$name}});
          my ($key, $val);
          while (($key, $val) = each %r) {
            if (exists $result{$key}) {
-Line 669 
 sub search {
+Line 804 
 sub search {
    }
    if (defined $cont and $cont ne '') {
      for (@{$self->{inverted}->{$attr}}) {
-       my %r = $_->search($cont);
+       my %r = $_->search($query, $cont);
        my ($key, $val);
        while (($key, $val) = each %r) {
          if (exists $result{$key}) {

 Legend:



Removed from v.13
 


changed lines


 
Added in v.19
 Legend:



Removed from v.13
 


changed lines


 
Added in v.19
-Removed from v.13
+Added in v.19

	ViewVC Help
Powered by ViewVC 1.1.26