daybreak 0.1.3 → 0.2.0

data/lib/daybreak/writer.rb

@@ -1,127 +0,0 @@
-module Daybreak
-  # Writer's handle the actually fiddly task of committing data to disk.
-  # They have a Worker instance that writes in a select loop.
-  class Writer
-    # Open up the file, ready it for binary and nonblocking writing.
-    def initialize(file)
-      @file = file
-      open!
-      @worker = Worker.new(@fd)
-    end
-
-    # Send a record to the workers queue.
-    def write(record)
-      @worker.enqueue record
-    end
-
-    # Finish writing
-    def finish!
-      @worker.finish!
-    end
-
-    # Flush pending commits, and restart the worker.
-    def flush!
-      @worker.flush!
-    end
-
-    # Finish writing and close the file descriptor.
-    def close!
-      finish!
-      @fd.close
-    end
-
-    # Truncate the file.
-    def truncate!
-      finish!
-      @fd.truncate(0)
-      @fd.pos = 0
-    end
-
-    private
-
-    def open!
-      @fd = File.open @file, 'ab'
-
-      if defined?(Fcntl::O_NONBLOCK)
-        f = @fd.fcntl(Fcntl::F_GETFL, 0)
-        @fd.fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK | f)
-      end
-    end
-
-    # Workers handle the actual fiddly bits of asynchronous io and
-    # and handle background writes.
-    class Worker
-      def initialize(fd)
-        @queue  = Queue.new
-        @fd     = fd
-        @thread = Thread.new { work }
-        at_exit { finish! }
-      end
-
-      # Queue up a write to be committed later.
-      def enqueue(record)
-        @queue << record
-      end
-
-      # Loop and block if we don't have work to do or if
-      # the file isn't ready for another write just yet.
-      def work
-        buf, finished = '', false
-        until finished && buf.empty?
-          record = @queue.pop
-          if record
-            buf << Record.serialize(record)
-          else
-            finished = true
-          end
-          read, write = IO.select [], [@fd]
-          if write and fd = write.first
-            lock(fd) { buf = try_write fd, buf }
-          end
-        end
-        @fd.flush
-      end
-
-      # Try and write the buffer to the file via non blocking file writes.
-      # If the write fails try again.
-      def try_write(fd, buf)
-        if defined?(Fcntl::O_NONBLOCK)
-          s = fd.write_nonblock(buf)
-        else
-          s = fd.write(buf)
-        end
-        if s < buf.length
-          buf = buf[s..-1] # didn't finish
-        else
-          buf = ""
-        end
-        buf
-      rescue Errno::EAGAIN
-        buf
-      end
-
-      # Lock a file with the type <tt>lock</tt>
-      def lock(fd)
-        fd.flock File::LOCK_EX
-        begin
-          yield
-        ensure
-          fd.flock File::LOCK_UN
-        end
-      end
-
-      # finish! and start up another worker thread.
-      def flush!
-        finish!
-        @thread = Thread.new { work }
-        true
-      end
-
-      # Push a nil through the queue and block until the write loop is finished.
-      def finish!
-        @queue.push nil
-        @thread.join
-      end
-    end
-  end
-end

data/test/bench.rb

@@ -1,28 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper.rb'
-
-describe "benchmarks" do
-  before do
-    @db = Daybreak::DB.new DB_PATH
-    1000.times {|i| @db[i] = i }
-    @db.flush!
-  end
-
-  bench_performance_constant "keys with sync" do |n|
-    n.times {|i| @db.set(i, 'i' * i, true) }
-  end
-
-  bench_performance_constant "inserting keys" do |n|
-    n.times {|i| @db[i] = 'i' * i }
-  end
-
-  bench_performance_constant "reading keys" do |n|
-    n.times {|i| assert_equal i % 1000, @db[i % 1000] }
-  end
-
-  after do
-    @db.empty!
-    @db.close!
-    File.unlink(DB_PATH)
-  end
-end
-

data/test/compare.rb

@@ -1,47 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper.rb'
-require 'pstore'
-
-describe "compare with pstore" do
-  before do
-    @pstore = PStore.new(File.join(HERE, "test.pstore"))
-  end
-
-  bench_performance_constant "pstore bulk performance" do |n|
-    @pstore.transaction do
-      n.times do |i|
-        @pstore[i] = 'i' * i
-      end
-    end
-  end
-
-  after do
-    File.unlink File.join(HERE, "test.pstore")
-  end
-end
-
-require 'dbm'
-
-describe "compare with dbm" do
-  before do
-    @dbm = DBM.open(File.join(HERE, "test-dbm"), 666, DBM::WRCREAT)
-    1000.times {|i| @dbm[i.to_s] = i }
-  end
-
-  bench_performance_constant "DBM write performance" do |n|
-    n.times do |i|
-      @dbm[i.to_s] = 'i' * i
-    end
-  end
-
-  bench_performance_constant "DBM read performance" do |n|
-    n.times do |i|
-      assert_equal (i % 1000).to_s, @dbm[(i % 1000).to_s]
-    end
-  end
-
-  after do
-    @dbm.close
-
-    File.unlink File.join(HERE, "test-dbm.db")
-  end
-end