lockfile 1.1.0 → 1.3.0

data/samples/a.rb

@@ -1,112 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift '../lib'
-#
-# puts this script in an nfs located directory and run from a couple of nodes at
-# once.  the list should appear ordered from either host - note that times may
-# not be ordered depending on the system clocks
-#
-
-#
-# builtin
-#
-  require 'socket'
-  require 'pstore'
-#
-# do what we can to invalidate any nfs caching
-#
-  def timestamp time = Time.now
-#{{{
-    usec = "#{ time.usec }"
-    usec << ('0' * (6 - usec.size)) if usec.size < 6 
-    time.strftime('%Y-%m-%d %H:%M:%S.') << usec
-#}}}
-  end
-  def hostname
-#{{{
-    @__hostname__ ||= Socket::gethostname
-#}}}
-  end
-  def tmpnam dir = Dir.tmpdir, seed = File.basename($0)
-#{{{
-    pid = Process.pid
-    path = "%s_%s_%s_%s_%d" % 
-      [hostname, seed, pid, timestamp.gsub(/\s+/o,'_'), rand(101010)]
-    File.join(dir, path)
-#}}}
-  end
-  def uncache file 
-#{{{
-    refresh = nil
-    begin
-      is_a_file = File === file
-      path = (is_a_file ? file.path : file.to_s) 
-      stat = (is_a_file ? file.stat : File.stat(file.to_s)) 
-      refresh = tmpnam(File.dirname(path))
-      File.link path, refresh rescue File.symlink path, refresh
-      File.chmod stat.mode, path
-      File.utime stat.atime, stat.mtime, path
-    ensure 
-      begin
-        File.unlink refresh if refresh
-      rescue Errno::ENOENT
-      end
-    end
-#}}}
-  end
-#
-# raa - http://raa.ruby-lang.org/project/lockfile/
-#
-  require 'lockfile'
-  pstore = PStore.new 'test.db'
-  timeout = 60
-  max_age = 8
-  refresh = 2
-  debug = false
-  lockfile = Lockfile.new 'test.lock', 
-                          :timeout => timeout,
-                          :max_age => max_age,
-                          :refresh => refresh,
-                          :debug   => debug
-#
-# flock throws ENOLCK on nfs file systems in newer linux kernels
-# plus we want to show that lockfile alone can do the locking
-#
-  class File
-    def flock(*args,&block);true;end
-  end
-#
-# if locking does not work this loop will blow up (Marshal load error) or appear
-# un-ordered.  actually it will eventually blow up due to nfs caching - but that
-# is not the fault of the lockfile class!  for the most part it is a simply demo
-# of locking.  the file will never become corrupt, it just will be unreadable at
-# times due to kernel caching.
-#
-  loop do
-    lockfile.lock do
-      uncache pstore.path 
-      pstore.transaction do
-      #
-      # get/update list
-      #
-        pstore[:list] = [] unless pstore.root? :list
-        list = pstore[:list]
-        tuple = [list.size, hostname, Time.now.to_f]
-        list << tuple
-      #
-      # show last 16 elements
-      #
-        puts '---'
-        list[-([list.size, 16].min)..-1].each{|tuple| p tuple}
-        puts '---'
-      #
-      # keep it a reasonable size
-      #
-        list.shift while list.size > 1024
-      #
-      # write back updates
-      #
-        pstore[:list] = list
-      end
-    end
-    sleep 1 
-  end

data/samples/nfsstore.rb

@@ -1,203 +0,0 @@
-#
-# How to use:
-#
-# db = NFSStore.new("/tmp/foo")
-# db.transaction do
-#   p db.roots
-#   ary = db["root"] = [1,2,3,4]
-#   ary[0] = [1,1.5]
-# end
-
-# db.transaction do
-#   p db["root"]
-# end
-
-require "ftools"
-require "digest/md5"
-require "socket"
-
-require 'lockfile'
-
-class NFSStore
-  HOSTNAME = Socket::gethostname
-  class Error < StandardError
-  end
-
-  def initialize(file)
-    dir = File::dirname(file)
-    unless File::directory? dir
-      raise NFSStore::Error, format("directory %s does not exist", dir)
-    end
-    if File::exist? file and not File::readable? file
-      raise NFSStore::Error, format("file %s not readable", file)
-    end
-    @transaction = false
-    @filename = file
-    @lockfile = Lockfile.new "#{ @filename }.lock",:max_age=>64,:refresh=>8
-    @abort = false
-  end
-
-  def in_transaction
-    raise NFSStore::Error, "not in transaction" unless @transaction
-  end
-  private :in_transaction
-
-  def [](name)
-    in_transaction
-    @table[name]
-  end
-  def fetch(name, default=NFSStore::Error)
-    unless @table.key? name
-      if default==NFSStore::Error
-	raise NFSStore::Error, format("undefined root name `%s'", name)
-      else
-	default
-      end
-    end
-    self[name]
-  end
-  def []=(name, value)
-    in_transaction
-    @table[name] = value
-  end
-  def delete(name)
-    in_transaction
-    @table.delete name
-  end
-  def roots
-    in_transaction
-    @table.keys
-  end
-  def root?(name)
-    in_transaction
-    @table.key? name
-  end
-  def path
-    @filename
-  end
-  def commit
-    in_transaction
-    @abort = false
-    throw :pstore_abort_transaction
-  end
-  def abort
-    in_transaction
-    @abort = true
-    throw :pstore_abort_transaction
-  end
-
-  # do what we can to invalidate any nfs caching
-  def uncache file 
-    begin
-      stat = file.stat
-      path = file.path
-      refresh = "%s.%s.%s.%s" % [path, HOSTNAME, $$, Time.now.to_i % 1024] 
-      File.link path, refresh
-      file.chmod stat.mode
-      File.utime stat.atime, stat.mtime, path
-    rescue Exception => e 
-      warn e
-    ensure
-      begin
-        File.unlink refresh if File.exist? refresh
-      rescue Exception => e
-        warn e
-      end
-    end
-  end
-
-
-  def transaction(read_only=false)
-    raise NFSStore::Error, "nested transaction" if @transaction
-    file = nil
-    value = nil
-
-@lockfile.lock do
-      begin
-        @transaction = true
-        backup = @filename+"~"
-        begin
-          file = File::open(@filename, read_only ? "rb" : "rb+")
-          orig = true
-        rescue Errno::ENOENT
-          raise if read_only
-          file = File::open(@filename, "wb+")
-        end
-        #file.flock(read_only ? File::LOCK_SH : File::LOCK_EX)
-        uncache file
-        file.rewind
-        if read_only
-          @table = Marshal::load(file)
-        elsif orig and (content = file.read) != ""
-          @table = Marshal::load(content)
-          size = content.size
-          md5 = Digest::MD5.digest(content)
-          content = nil		# unreference huge data
-        else
-          @table = {}
-        end
-        begin
-          catch(:pstore_abort_transaction) do
-            value = yield(self)
-          end
-        rescue Exception
-          @abort = true
-          raise
-        ensure
-          if !read_only and !@abort
-            file.rewind
-            content = Marshal::dump(@table)
-            if !md5 || size != content.size || md5 != Digest::MD5.digest(content)
-              File::copy @filename, backup
-              begin
-                file.write(content)
-                file.truncate(file.pos)
-                content = nil		# unreference huge data
-              rescue
-                File::rename backup, @filename if File::exist?(backup)
-                raise
-              end
-            end
-          end
-          if @abort and !orig
-            File.unlink(@filename)
-          end
-          @abort = false
-        end
-      ensure
-        @table = nil
-        @transaction = false
-        file.close if file
-      end
-end
-      value
-  end
-end
-
-
-
-
-
-
-
-
-
-if __FILE__ == $0
-  db = NFSStore.new("/tmp/foo")
-  db.transaction do
-    p db.roots
-    ary = db["root"] = [1,2,3,4]
-    ary[1] = [1,1.5]
-  end
-
-  1000.times do
-    db.transaction do
-      db["root"][0] += 1
-      p db["root"][0]
-    end
-  end
-
-  db.transaction(true) do
-    p db["root"]
-  end
-end