perobs 2.5.0 → 3.0.0

data/test/LockFile_spec.rb

@@ -0,0 +1,133 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2017 by Chris Schlaeger <chris@taskjuggler.org>
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'spec_helper'
+
+require 'perobs/LockFile'
+
+describe PEROBS::LockFile do
+
+  before(:each) do
+    @dir = Dir.mktmpdir('LockFile')
+    @file = File.join(@dir, 'LockFile.lock')
+  end
+
+  after(:each) do
+    FileUtils.rm_rf(@dir)
+  end
+
+  it 'should raise an error if the lock file directory does not exist' do
+    capture_io do
+      expect(PEROBS::LockFile.new('/foo/bar/foobar').lock).to be false
+    end
+    PEROBS.log.open($stderr)
+  end
+
+  it 'should support taking and releasing the lock' do
+    lock = PEROBS::LockFile.new(@file)
+    expect(lock.is_locked?).to be false
+    expect(lock.lock).to be true
+    expect(lock.is_locked?).to be true
+    expect(lock.unlock).to be true
+  end
+
+  it 'should fail the unlock after a forced unlock' do
+    lock = PEROBS::LockFile.new(@file)
+    expect(lock.lock).to be true
+    expect(lock.is_locked?).to be true
+    lock.forced_unlock
+    expect(lock.is_locked?).to be false
+    out = capture_io{ expect(lock.unlock).to be false }
+    expect(out).to include('There is no current lock to release')
+  end
+
+  it 'should fail if the lock is already taken' do
+    lock1 = PEROBS::LockFile.new(@file)
+    expect(lock1.lock).to be true
+    lock2 = PEROBS::LockFile.new(@file)
+    out = capture_io { expect(lock2.lock).to be false }
+    expect(out).to include('due to timeout')
+    expect(lock1.unlock).to be true
+    expect(lock2.lock).to be true
+    expect(lock2.unlock).to be true
+  end
+
+  it 'should wait for the old lockholder' do
+    pid = Process.fork do
+      lock1 = PEROBS::LockFile.new(@file)
+      expect(lock1.lock).to be true
+      sleep 5
+      expect(lock1.unlock).to be true
+    end
+
+    while !File.exist?(@file)
+      sleep 1
+    end
+    lock2 = PEROBS::LockFile.new(@file,
+                                 { :max_retries => 100, :pause_secs => 0.5 })
+    expect(lock2.lock).to be true
+    expect(lock2.unlock).to be true
+    Process.wait(pid)
+  end
+
+  it 'should timeout waiting for the old lockholder' do
+    pid = Process.fork do
+      lock1 = PEROBS::LockFile.new(@file)
+      expect(lock1.lock).to be true
+      sleep 3
+      expect(lock1.unlock).to be true
+    end
+
+    while !File.exist?(@file)
+      sleep 1
+    end
+    lock2 = PEROBS::LockFile.new(@file,
+                                 { :max_retries => 2, :pause_secs => 0.5 })
+    out = capture_io { expect(lock2.lock).to be false }
+    expect(out).to include('due to timeout')
+    Process.wait(pid)
+  end
+
+  it 'should terminate the old lockholder after timeout' do
+    pid = Process.fork do
+      lock1 = PEROBS::LockFile.new(@file)
+      expect(lock1.lock).to be true
+      # This sleep will be killed
+      sleep 1000
+    end
+
+    while !File.exist?(@file)
+      sleep 1
+    end
+
+    lock2 = PEROBS::LockFile.new(@file, { :timeout_secs => 1 })
+    out = capture_io { expect(lock2.lock).to be true }
+    expect(out).to include('Old lock file found for PID')
+    expect(lock2.unlock).to be true
+    Process.wait(pid)
+  end
+
+end
+

data/test/SpaceTree_spec.rb

@@ -0,0 +1,245 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2016 by Chris Schlaeger <chris@taskjuggler.org>
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'fileutils'
+
+require 'spec_helper'
+require 'perobs/SpaceTree'
+
+describe PEROBS::SpaceTree do
+
+  before(:all) do
+    @db_dir = generate_db_name('SpaceTree')
+    FileUtils.mkdir_p(@db_dir)
+    @m = PEROBS::SpaceTree.new(@db_dir)
+  end
+
+  after(:all) do
+    FileUtils.rm_rf(@db_dir)
+  end
+
+  it 'should open the space tree' do
+    @m.open
+    expect(@m.to_a).to eql([])
+  end
+
+  it 'should support adding spaces' do
+    @m.add_space(80, 8)
+    expect(@m.has_space?(80, 8)).to be true
+    expect(@m.to_a).to eql([[80, 8]])
+    expect(@m.check).to be true
+    @m.add_space(40, 4)
+    expect(@m.has_space?(40, 4)).to be true
+    expect(@m.to_a).to eql([[80, 8], [40, 4]])
+    @m.add_space(20, 2)
+    expect(@m.has_space?(20, 2)).to be true
+    expect(@m.to_a).to eql([[80, 8], [40, 4], [20, 2]])
+    @m.add_space(160, 16)
+    expect(@m.has_space?(160, 16)).to be true
+    expect(@m.to_a).to eql([[80, 8], [40, 4], [20, 2], [160, 16]])
+    @m.add_space(320, 32)
+    expect(@m.has_space?(320, 32)).to be true
+    expect(@m.to_a).to eql([[80, 8], [40, 4], [20, 2], [160, 16], [320, 32]])
+    @m.add_space(100, 10)
+    expect(@m.has_space?(100, 10)).to be true
+    expect(@m.to_a).to eql([[80, 8], [40, 4], [20, 2], [160, 16], [100, 10], [320, 32]])
+    @m.add_space(81, 8)
+    expect(@m.has_space?(81, 8)).to be true
+    expect(@m.to_a).to eql([[80, 8], [40, 4], [20, 2], [81, 8], [160, 16], [100, 10], [320, 32]])
+    expect(@m.check).to be true
+  end
+
+  it 'should convert the tree into a human readable string' do
+out = <<EOT
+o-v-1:[80, 8] <2 =7 >4
+  +<-v-2:[40, 4] ^1 <3
+  |  +<---3:[20, 2] ^2
+  +=---7:[81, 8] ^1
+  +>-v-4:[160, 16] ^1 <6 >5
+     +<---6:[100, 10] ^4
+     +>---5:[320, 32] ^4
+EOT
+    expect(@m.to_s).to eql out
+  end
+
+  it 'should keep values over an close/open' do
+    @m.add_space(1, 15)
+    expect(@m.check).to be true
+    @m.close
+    @m.open
+    expect(@m.check).to be true
+    expect(@m.to_a).to eql([[80, 8], [40, 4], [20, 2], [81, 8], [160, 16], [100, 10], [1, 15], [320, 32]])
+  end
+
+  it 'should find the smallest node' do
+    node = @m.instance_variable_get('@root').find_smallest_node
+    expect(node.size).to eql(2)
+  end
+
+  it 'should find the largest node' do
+    node = @m.instance_variable_get('@root').find_largest_node
+    expect(node.size).to eql(32)
+    expect(node.node_address).to eql(5)
+    expect(node.parent.size).to eql(16)
+  end
+
+  it 'should support clearing the data' do
+    @m.clear
+    expect(@m.to_a).to eql([])
+    @m.add_space(1, 1)
+    @m.add_space(2, 2)
+    @m.clear
+    expect(@m.to_a).to eql([])
+  end
+
+  it 'should delete an equal node' do
+    @m.clear
+    add_sizes([ 10, 5, 15, 10 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [3, 10], [2, 15]])
+    expect(@m.get_space(10)).to eql([0, 10])
+
+    @m.clear
+    add_sizes([ 10, 5, 15, 10, 10 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [4, 10], [3, 10], [2, 15]])
+    expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.get_space(10)).to eql([4, 10])
+  end
+
+  it 'should delete a smaller node' do
+    @m.clear
+    add_sizes([ 10, 5, 3, 7 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [2, 3], [3, 7]])
+    expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.to_a).to eql([[1, 5], [2, 3], [3, 7]])
+
+    @m.clear
+    add_sizes([ 10, 5, 3 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [2, 3]])
+    expect(@m.get_space(5)).to eql([1, 5])
+    expect(@m.to_a).to eql([[0, 10], [2, 3]])
+
+    @m.clear
+    add_sizes([ 10, 5 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5]])
+    expect(@m.get_space(5)).to eql([1, 5])
+    expect(@m.to_a).to eql([[0, 10]])
+
+    @m.clear
+    add_sizes([ 10, 5, 3, 7, 5 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [2, 3], [4, 5], [3, 7]])
+    expect(@m.get_space(3)).to eql([2, 3])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [4, 5], [3, 7]])
+  end
+
+  it 'should delete an larger node' do
+    @m.clear
+    add_sizes([ 10, 15, 13, 17 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 15], [2, 13], [3, 17]])
+    expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.to_a).to eql([[1, 15], [2, 13], [3, 17]])
+
+    @m.clear
+    add_sizes([ 10, 15, 13 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 15], [2, 13]])
+    expect(@m.get_space(15)).to eql([1, 15])
+    expect(@m.to_a).to eql([[0, 10], [2, 13]])
+
+    @m.clear
+    add_sizes([ 10, 15 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 15]])
+    expect(@m.get_space(15)).to eql([1, 15])
+    expect(@m.to_a).to eql([[0, 10]])
+
+    @m.clear
+    add_sizes([ 10, 5, 15, 20, 17, 22 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [2, 15], [3, 20], [4, 17], [5, 22]])
+    expect(@m.get_space(15)).to eql([2, 15])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [3, 20], [4, 17], [5, 22]])
+  end
+
+  it 'should move largest of small tree' do
+    @m.clear
+    add_sizes([ 5, 3, 7 ])
+    expect(@m.get_space(5)).to eql([0, 5])
+    expect(@m.check).to be true
+    expect(@m.to_a).to eql([[1, 3], [2, 7]])
+
+    @m.clear
+    add_sizes([ 10, 5, 3, 7, 15, 7 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [2, 3], [3, 7], [5, 7], [4, 15]])
+    expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.check).to be true
+    expect(@m.to_a).to eql([[3, 7], [1, 5], [2, 3], [5, 7], [4, 15]])
+
+    @m.clear
+    add_sizes([ 10, 5, 3, 7, 15, 7, 6 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [2, 3], [3, 7], [6, 6], [5, 7], [4, 15]])
+    expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.to_a).to eql([[3, 7], [1, 5], [2, 3], [6, 6], [5, 7], [4, 15]])
+
+    @m.clear
+    add_sizes([ 10, 5, 3, 15, 13, 17 ])
+    expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.to_a).to eql([[1, 5], [2, 3], [3, 15], [4, 13], [5, 17]])
+  end
+
+  it 'should support a real-world traffic pattern' do
+    address = 0
+    spaces = []
+    0.upto(500) do
+      case rand(3)
+      when 0
+        # Insert new values
+        rand(9).times do
+          size = 20 + rand(5000)
+          @m.add_space(address, size)
+          spaces << [address, size]
+          address += size
+        end
+      when 1
+        # Remove some values
+        rand(7).times do
+          size = 20 + rand(6000)
+          if (space = @m.get_space(size))
+            expect(spaces.include?(space)).to be true
+            spaces.delete(space)
+          end
+        end
+      when 2
+        expect(@m.check).to be true
+        spaces.each do |address, size|
+          expect(@m.has_space?(address, size)).to be true
+        end
+      end
+    end
+  end
+
+  def add_sizes(sizes)
+    sizes.each_with_index do |size, i|
+      @m.add_space(i, size)
+    end
+  end
+
+end

data/test/Store_spec.rb

@@ -505,6 +505,9 @@ describe PEROBS::Store do
           expect(@store[key].name).to eq(ref[key])
         end
       end
+      #ref.each do |k, v|
+      #  expect(@store[k].name).to eq(v), "failure in mode #{i}"
+      #end
     end
 
     ref.each do |k, v|

data/test/spec_helper.rb

@@ -40,3 +40,16 @@ def generate_db_name(caller_file)
   db_name
 end
 
+def capture_io
+  PEROBS.log.open(io = StringIO.new)
+  begin
+    yield
+  ensure
+    PEROBS.log.open($stderr)
+  end
+
+  io.rewind
+  io.read
+end
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perobs
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Chris Schlaeger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-16 00:00:00.000000000 Z
+date: 2017-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,25 +66,31 @@ files:
 - Rakefile
 - lib/perobs.rb
 - lib/perobs/Array.rb
+- lib/perobs/BTree.rb
 - lib/perobs/BTreeBlob.rb
 - lib/perobs/BTreeDB.rb
+- lib/perobs/BTreeNode.rb
+- lib/perobs/BTreeNodeCache.rb
+- lib/perobs/BTreeNodeLink.rb
 - lib/perobs/Cache.rb
 - lib/perobs/ClassMap.rb
 - lib/perobs/DataBase.rb
 - lib/perobs/DynamoDB.rb
-- lib/perobs/FixedSizeBlobFile.rb
+- lib/perobs/EquiBlobsFile.rb
 - lib/perobs/FlatFile.rb
 - lib/perobs/FlatFileBlobHeader.rb
 - lib/perobs/FlatFileDB.rb
-- lib/perobs/FreeSpaceManager.rb
 - lib/perobs/Handle.rb
 - lib/perobs/Hash.rb
-- lib/perobs/IndexTree.rb
-- lib/perobs/IndexTreeNode.rb
+- lib/perobs/LockFile.rb
 - lib/perobs/Log.rb
 - lib/perobs/Object.rb
 - lib/perobs/ObjectBase.rb
 - lib/perobs/RobustFile.rb
+- lib/perobs/SpaceTree.rb
+- lib/perobs/SpaceTreeNode.rb
+- lib/perobs/SpaceTreeNodeCache.rb
+- lib/perobs/SpaceTreeNodeLink.rb
 - lib/perobs/StackFile.rb
 - lib/perobs/Store.rb
 - lib/perobs/TreeDB.rb
@@ -96,13 +102,14 @@ files:
 - tasks/test.rake
 - test/Array_spec.rb
 - test/BTreeDB_spec.rb
+- test/BTree_spec.rb
 - test/ClassMap_spec.rb
-- test/FixedSizeBlobFile_spec.rb
+- test/EquiBlobsFile_spec.rb
 - test/FlatFileDB_spec.rb
-- test/FreeSpaceManager_spec.rb
 - test/Hash_spec.rb
-- test/IndexTree_spec.rb
+- test/LockFile_spec.rb
 - test/Object_spec.rb
+- test/SpaceTree_spec.rb
 - test/StackFile_spec.rb
 - test/Store_spec.rb
 - test/perobs_spec.rb
@@ -127,20 +134,21 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Persistent Ruby Object Store
 test_files:
 - test/Array_spec.rb
 - test/BTreeDB_spec.rb
+- test/BTree_spec.rb
 - test/ClassMap_spec.rb
-- test/FixedSizeBlobFile_spec.rb
+- test/EquiBlobsFile_spec.rb
 - test/FlatFileDB_spec.rb
-- test/FreeSpaceManager_spec.rb
 - test/Hash_spec.rb
-- test/IndexTree_spec.rb
+- test/LockFile_spec.rb
 - test/Object_spec.rb
+- test/SpaceTree_spec.rb
 - test/StackFile_spec.rb
 - test/Store_spec.rb
 - test/perobs_spec.rb

data/lib/perobs/FixedSizeBlobFile.rb

@@ -1,193 +0,0 @@
-# encoding: UTF-8
-#
-# = FixedSizeBlobFile.rb -- Persistent Ruby Object Store
-#
-# Copyright (c) 2016 by Chris Schlaeger <chris@taskjuggler.org>
-#
-# MIT License
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'perobs/Log'
-require 'perobs/StackFile'
-
-module PEROBS
-
-  # This class implements persistent storage space for fixed size data blobs.
-  # The blobs can be stored and retrieved and can be deleted again. The
-  # FixedSizeBlobFile manages the storage of the blobs and free storage
-  # spaces. The files grows and shrinks as needed. A blob is referenced by its
-  # address.
-  class FixedSizeBlobFile
-
-    # Create a new stack file in the given directory with the given file name.
-    # @param dir [String] Directory
-    # @param name [String] File name
-    # @param entry_bytes [Fixnum] Number of bytes each entry must have
-    def initialize(dir, name, entry_bytes)
-      @file_name = File.join(dir, name + '.blobs')
-      @entry_bytes = entry_bytes
-      @free_list = StackFile.new(dir, name + '-freelist', 8)
-      @f = nil
-    end
-
-    # Open the blob file.
-    def open
-      begin
-        if File.exist?(@file_name)
-          @f = File.open(@file_name, 'rb+')
-        else
-          @f = File.open(@file_name, 'wb+')
-        end
-      rescue IOError => e
-        PEROBS.log.fatal "Cannot open blob file #{@file_name}: #{e.message}"
-      end
-      unless @f.flock(File::LOCK_NB | File::LOCK_EX)
-        PEROBS.log.fatal 'Database blob file is locked by another process'
-      end
-      @free_list.open
-    end
-
-    # Close the blob file. This method must be called before the program is
-    # terminated to avoid data loss.
-    def close
-      @free_list.close
-      begin
-        @f.flush
-        @f.flock(File::LOCK_UN)
-        @f.close
-      rescue IOError => e
-        PEROBS.log.fatal "Cannot close blob file #{@file_name}: #{e.message}"
-      end
-    end
-
-    # Flush out all unwritten data.
-    def sync
-      @free_list.sync
-      begin
-        @f.sync
-      rescue IOError => e
-        PEROBS.log.fatal "Cannot sync blob file #{@file_name}: #{e.message}"
-      end
-    end
-
-    # Delete all data.
-    def clear
-      @f.truncate(0)
-      @f.flush
-      @free_list.clear
-    end
-
-    def empty?
-      sync
-      @f.size == 0
-    end
-
-    # Return the address of a free blob storage space. Addresses start at 0
-    # and increase linearly.
-    # @return [Fixnum] address of a free blob space
-    def free_address
-      if (bytes = @free_list.pop)
-        # Return an entry from the free list.
-        return bytes.unpack('Q')[0]
-      else
-        # There is currently no free entry. Return the address at the end of
-        # the file.
-        offset_to_address(@f.size)
-      end
-    end
-
-    # Store the given byte blob at the specified address. If the blob space is
-    # already in use the content will be overwritten.
-    # @param address [Fixnum] Address to store the blob
-    # @param bytes [String] bytes to store
-    def store_blob(address, bytes)
-      if bytes.length != @entry_bytes
-        PEROBS.log.fatal "All stack entries must be #{@entry_bytes} " +
-          "long. This entry is #{bytes.length} bytes long."
-      end
-      begin
-        @f.seek(address_to_offset(address))
-        # The first byte is tha flag byte. It's set to 1 for cells that hold a
-        # blob. 0 for empty cells.
-        @f.write([ 1 ].pack('C'))
-        @f.write(bytes)
-        @f.flush
-      rescue IOError => e
-        PEROBS.log.fatal "Cannot store blob at address #{address}: #{e.message}"
-      end
-    end
-
-    # Retrieve a blob from the given address.
-    # @param address [Fixnum] Address to store the blob
-    # @return [String] blob bytes
-    def retrieve_blob(address)
-      begin
-        if (offset = address_to_offset(address)) >= @f.size
-          return nil
-        end
-
-        @f.seek(address_to_offset(address))
-        if (@f.read(1).unpack('C')[0] != 1)
-          return nil
-        end
-        bytes = @f.read(@entry_bytes)
-      rescue IOError => e
-        PEROBS.log.fatal "Cannot retrieve blob at adress #{address}: " +
-          e.message
-      end
-
-      bytes
-    end
-
-    # Delete the blob at the given address.
-    # @param address [Fixnum] Address of blob to delete
-    def delete_blob(address)
-      begin
-        @f.seek(address_to_offset(address))
-        if (@f.read(1).unpack('C')[0] != 1)
-          PEROBS.log.fatal "There is no blob stored at address #{address}"
-        end
-        @f.seek(address_to_offset(address))
-        @f.write([ 0 ].pack('C'))
-      rescue IOError => e
-        PEROBS.log.fatal "Cannot delete blob at address #{address}: " +
-          e.message
-      end
-      # Add the address to the free list.
-      @free_list.push([ address ].pack('Q'))
-    end
-
-    private
-
-    # Translate a blob address to the actual offset in the file.
-    def address_to_offset(address)
-      address * (1 + @entry_bytes)
-    end
-
-    # Translate the file offset to the address of a blob.
-    def offset_to_address(offset)
-      offset / (1 + @entry_bytes)
-    end
-
-  end
-
-end
-