bdb 0.1.0 → 0.2.0

data/lib/bdb/base.rb

@@ -19,8 +19,12 @@ class Bdb::Base
     indexes[field] = opts
   end
   
+  def path
+    config[:path] || Dir.pwd
+  end
+
   def environment
-    @environment ||= Bdb::Environment.new(config[:path], self)
+    @environment ||= Bdb::Environment.new(path, self)
   end
   
   def transaction(nested = true, &block)
@@ -32,9 +36,13 @@ class Bdb::Base
   end
   
   def checkpoint(opts = {})
-    environment.synchronize(opts)
+    environment.checkpoint(opts)
   end
-  
+
+  def master?
+    environment.master?
+  end
+
 private
 
   def get_field(field, value)

data/lib/bdb/database.rb

@@ -10,10 +10,11 @@ class Bdb::Database < Bdb::Base
   def db(index = nil)
     if @db.nil?
       @db = {}
+      open_flags = master? ? Bdb::DB_CREATE : Bdb::DB_RDONLY
       transaction(false) do
         primary_db = environment.env.db
         primary_db.pagesize = config[:page_size] if config[:page_size]
-        primary_db.open(transaction, name, nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+        primary_db.open(transaction, name, nil, Bdb::Db::BTREE, open_flags, 0)
         @db[:primary_key] = primary_db
 
         indexes.each do |field, opts|
@@ -31,13 +32,22 @@ class Bdb::Database < Bdb::Base
           index_db = environment.env.db
           index_db.flags = Bdb::DB_DUPSORT unless opts[:unique]
           index_db.pagesize = config[:page_size] if config[:page_size]
-          index_db.open(transaction, "#{name}_by_#{field}", nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
-          primary_db.associate(transaction, index_db, Bdb::DB_CREATE, index_callback)
+          index_db.open(transaction, "#{name}_by_#{field}", nil, Bdb::Db::BTREE, open_flags, 0)
+          primary_db.associate(transaction, index_db, open_flags, index_callback)
           @db[field] = index_db
         end
       end
     end
     @db[index || :primary_key]
+  rescue Bdb::DbError => e
+    # Retry if the database doesn't exist and we are a replication client.
+    if not master? and e.code == Errno::ENOENT::Errno
+      close
+      sleep 1
+      retry
+    else
+      raise(e)
+    end
   end
 
   def close
@@ -48,6 +58,10 @@ class Bdb::Database < Bdb::Base
     end
   end  
 
+  def close_environment
+    environment.close
+  end
+
   def count(field, key)
     with_cursor(db(field)) do |cursor|
       k, v = cursor.get(Tuple.dump(key), nil, Bdb::DB_SET)
@@ -131,13 +145,18 @@ class Bdb::Database < Bdb::Base
     set.results
   end
 
+  def [](key)
+    get(key).first
+  end
+
   def set(key, value, opts = {})
     synchronize do
       key   = Tuple.dump(key)
       value = Marshal.dump(value)
       flags = opts[:create] ? Bdb::DB_NOOVERWRITE : 0
       db.put(transaction, key, value, flags)
-    end
+      value
+   end
   end
 
   def delete(key)
@@ -154,6 +173,10 @@ class Bdb::Database < Bdb::Base
     end
   end
 
+  def sync
+    db.sync
+  end
+
 private
 
   def get_key(key, opts)

data/lib/bdb/environment.rb

@@ -1,12 +1,25 @@
+require 'thread'
+require 'bdb/replication'
+
 class Bdb::Environment
   @@env = {}
   def self.new(path, database = nil)
+    # Only allow one environment per path.
     path = File.expand_path(path)
     @@env[path] ||= super(path)
     @@env[path].databases << database if database
     @@env[path]
   end
 
+  def initialize(path)
+    @path = path
+  end
+  attr_reader :path
+
+  def self.[](path)
+    new(path)
+  end
+
   def self.config(config = {})
     @config ||= {
       :max_locks    => 5000,
@@ -22,10 +35,10 @@ class Bdb::Environment
     @config.merge!(config)
   end
 
-  def initialize(path)
-    @path = path
+  include Replication
+  def self.replicate(path, opts)
+    self[path].replicate(opts)
   end
-  attr_reader :path
 
   def databases
     @databases ||= []
@@ -40,16 +53,19 @@ class Bdb::Environment
         else
           env_flags = Bdb::DB_CREATE | Bdb::DB_INIT_TXN | Bdb::DB_INIT_LOCK |
                       Bdb::DB_REGISTER | Bdb::DB_RECOVER | Bdb::DB_INIT_MPOOL | Bdb::DB_THREAD
-        end
 
+          env_flags |= Bdb::DB_INIT_REP if replicate?
+        end
         @env.cachesize = config[:cache_size] if config[:cache_size]
         @env.set_timeout(config[:txn_timeout],  Bdb::DB_SET_TXN_TIMEOUT)  if config[:txn_timeout]
         @env.set_timeout(config[:lock_timeout], Bdb::DB_SET_LOCK_TIMEOUT) if config[:lock_timeout]
         @env.set_lk_max_locks(config[:max_locks]) if config[:max_locks]
         @env.set_lk_detect(Bdb::DB_LOCK_RANDOM)
         @env.flags_on = Bdb::DB_TXN_WRITE_NOSYNC | Bdb::DB_TIME_NOTGRANTED
-        @env.open(path, env_flags, 0)
+        init_replication(@env) if replicate?
 
+        @env.open(path, env_flags, 0)
+        start_replication(@env) if replicate?
         @exit_handler ||= at_exit { close }
       end
     end

data/lib/bdb/replication.rb

@@ -0,0 +1,68 @@
+require 'socket'
+module Replication
+  DEFAULT_PORT = 3463
+  NUM_THREADS  = 1
+
+  ACK_POLICY = {
+    :all       => Bdb::DB_REPMGR_ACKS_ALL,
+    :all_peers => Bdb::DB_REPMGR_ACKS_ALL_PEERS,
+    :none      => Bdb::DB_REPMGR_ACKS_NONE,
+    :one       => Bdb::DB_REPMGR_ACKS_ONE,
+    :one_peer  => Bdb::DB_REPMGR_ACKS_ONE_PEER,
+    :quorom    => Bdb::DB_REPMGR_ACKS_QUORUM,
+  }
+
+  def replicate?
+    not @replicate.nil?
+  end
+
+  def master?
+    not replicate? or replicate[:master]
+  end
+
+  def replicate(opts = nil)
+    return @replicate if opts.nil?
+
+    master  = normalize_host(opts.delete(:from))
+    clients = [*opts.delete(:to)].compact.collect {|h| normalize_host(h)}
+    local   = normalize_host(opts.delete(:host) || ENV['BDB_REPLICATION_HOST'], opts.delete(:port))
+    remote  = clients + [master] - [local]
+
+    opts[:master] = (local == master)
+    opts[:local]  = local
+    opts[:remote] = remote
+    opts[:num_threads] ||= NUM_THREADS
+    @replicate = opts
+
+    env
+  end
+
+private
+
+  def init_replication(env)
+    env.set_verbose(Bdb::DB_VERB_REPLICATION, true) if replicate[:verbose]
+    env.rep_priority = replicate[:master] ? 1 : 0
+    env.repmgr_ack_policy = ACK_POLICY[replicate[:ack_policy]] if replicate[:ack_policy]
+    env.repmgr_set_local_site(*replicate[:local])
+    replicate[:remote].each do |s|
+      env.repmgr_add_remote_site(*s)
+    end
+    env.rep_nsites = replicate[:remote].size + 1
+  end
+
+  def start_replication(env)
+    env.repmgr_start(replicate[:num_threads], replicate[:master] ? Bdb::DB_REP_MASTER : Bdb::DB_REP_CLIENT)
+  end
+
+  def normalize_host(*host)
+    host = host.compact.join(':')
+    host, port = host.split(':')
+    host ||= Socket.gethostname
+    port ||= DEFAULT_PORT
+    port = port.to_i
+
+    addr_info = Socket.getaddrinfo(host.strip, port)
+    ip = addr_info.detect {|i| i[0] == 'AF_INET'}[3]
+    [ip, port]
+  end
+end

data/test/database_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/database_test_helper'
+
+TMPDIR = File.dirname(__FILE__) + '/tmp'
+FileUtils.rmtree TMPDIR
+FileUtils.mkdir  TMPDIR
+
+class DatabaseTest < Test::Unit::TestCase
+  include DatabaseTestHelper
+
+  def setup
+    @db = Bdb::Database.new('foo', :path => TMPDIR)
+    @db.truncate!
+  end
+  
+  def teardown
+    @db.close
+  end
+end

data/test/database_test_helper.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module DatabaseTestHelper
+  def db
+    @db
+  end
+
+  def test_set_and_get
+    assert_equal nil, db['foo']
+    assert_equal [],  db.get('foo')
+
+    db.set('foo', [1,2,3])
+    assert_equal [1,2,3], db['foo']
+    assert_equal [[1,2,3]], db.get('foo')
+  end
+
+  def test_set_and_get_with_tuples
+    assert_equal [],  db.get(['foo', 1])
+    assert_equal [],  db.get(['foo', 2])
+
+    db.set(['foo', 1], [1,2,3])
+    assert_equal [[1,2,3]], db.get(['foo', 1])
+
+    db.set(['foo', 2], [3,4,5])
+    assert_equal [[3,4,5]], db.get(['foo', 2])
+
+    assert_equal [[1,2,3], [3,4,5]], db.get('foo', :partial => true)
+  end
+
+  def test_get_with_ranges
+    100.times do |i|
+      db.set([:foo, i], {:id => i, :type => 'foo'})
+    end
+
+    assert_equal (17..34).to_a, db.get([:foo, 17]..[:foo, 34]).collect {|r| r[:id]}
+  end
+end

data/test/deadlock_test.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+DIR = '/tmp/bdb_deadlock_test'
+Bdb::Environment.config :path => DIR, :cache_size => 1 * 1024 * 1024, :page_size => 512
+
+class DeadlockTest < Test::Unit::TestCase
+  def setup
+    FileUtils.rmtree DIR
+    FileUtils.mkdir  DIR
+    Bdb::Environment[DIR].close      
+    @db = Bdb::Database.new('foo')
+  end
+
+  attr_reader :db
+
+  N = 5000 # total number of records
+  R = 10   # number of readers
+  W = 10   # number of writers
+  T = 20   # reads per transaction
+  L = 100  # logging frequency
+
+  def test_detect_deadlock
+    pids = []
+
+    W.times do |n|
+      pids << fork(&writer)
+    end
+
+    sleep(1)
+
+    R.times do
+      pids << fork(&reader)
+    end
+
+    # Make sure that all processes finish with no errors.
+    pids.each do |pid|
+      Process.wait(pid)
+      assert_equal status, $?.exitstatus
+    end
+  end
+
+  C = 10
+  def test_detect_unclosed_resources
+    threads = []
+
+    threads << Thread.new do
+      C.times do
+        sleep(10)
+
+        pid = fork do
+          cursor = db.db.cursor(nil, 0)
+          cursor.get(nil, nil, Bdb::DB_FIRST)
+          exit!(1)
+        end
+        puts "\n====simulating exit with unclosed resources ===="
+        Process.wait(pid)
+        assert_equal 1, $?.exitstatus
+      end
+    end
+
+    threads << Thread.new do
+      C.times do
+        pid = fork(&writer(1000))
+        Process.wait(pid)
+        assert [0,9].include?($?.exitstatus)
+      end
+    end
+
+    sleep(3)
+
+    threads << Thread.new do
+      C.times do
+        pid = fork(&reader(1000))
+        Process.wait(pid)
+        assert [0,9].include?($?.exitstatus)
+      end
+    end
+    
+    threads.each {|t| t.join}
+  end
+
+  def reader(n = N)
+    lambda do
+      T.times do
+        (1...n).to_a.shuffle.each_slice(T) do |ids|
+          db.transaction do
+            ids.each {|id| db.get(id)}
+          end
+          log('r')
+        end
+      end
+      db.close_environment
+    end
+  end
+
+  def writer(n = N)
+    lambda do
+      (1...n).to_a.shuffle.each do |id|
+        db.transaction do
+          begin
+            db.set(id, {:bar => "bar" * 1000 + " ayn #{rand}"})
+          rescue Bdb::DbError => e
+            if e.code == Bdb::DB_KEYEXIST
+              db.delete(id)
+              retry
+            else
+              raise(e)
+            end
+          end
+        end
+        log('w')
+      end
+      db.close_environment
+    end
+  end
+
+  def log(action)
+    @count ||= Hash.new(0)
+    if @count[action] % L == 0
+      print action.to_s
+      $stdout.flush
+    end
+    @count[action] += 1
+  end
+end

data/test/replication_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/database_test_helper'
+
+MASTER_DIR = '/tmp/bdb_rep_test_master'
+CLIENT_DIR = '/tmp/bdb_rep_test_client'
+FileUtils.rmtree MASTER_DIR; FileUtils.mkdir MASTER_DIR; 
+FileUtils.rmtree CLIENT_DIR; FileUtils.mkdir CLIENT_DIR
+
+MASTER = 'localhost:8888'
+CLIENT = 'localhost:8889'
+
+N = 100
+
+class ReplicationTest < Test::Unit::TestCase
+  def setup
+    Bdb::Environment.replicate CLIENT_DIR, :from => MASTER, :to => CLIENT, :host => CLIENT #, :verbose => true
+    
+    @pid = Process.fork do
+      Bdb::Environment.replicate MASTER_DIR, :from => MASTER, :to => CLIENT, :host => MASTER #, :verbose => true
+      db = Bdb::Database.new('foo', :path => MASTER_DIR)
+
+      N.times do |i|
+        db.set(i, i + 1)
+        log "m"
+        sleep 0.1
+      end
+      sleep 10
+    end
+  end
+  
+  def teardown
+    Process.kill(9, @pid)
+  end
+
+  def test_single_process_replication
+    db = Bdb::Database.new('foo', :path => CLIENT_DIR)
+    N.times do |i|
+      sleep 0.2
+      assert_equal i + 1, db[i]
+      log "c"
+    end
+  end
+
+  def log(action)
+    print action
+    $stdout.flush
+  end
+end