perobs 2.3.1 → 2.4.0

data/lib/perobs/Store.rb

@@ -28,10 +28,12 @@
 require 'set'
 require 'weakref'
 
+require 'perobs/Log'
 require 'perobs/Handle'
 require 'perobs/Cache'
 require 'perobs/ClassMap'
 require 'perobs/BTreeDB'
+require 'perobs/FlatFileDB'
 require 'perobs/Object'
 require 'perobs/Hash'
 require 'perobs/Array'
@@ -100,9 +102,9 @@ module PEROBS
     # @param options [Hash] various options to affect the operation of the
     #        database. Currently the following options are supported:
     #        :engine     : The class that provides the back-end storage
-    #                      engine. By default BTreeDB is used. A user
+    #                      engine. By default FlatFileDB is used. A user
     #                      can provide it's own storage engine that must
-    #                      conform to the same API exposed by BTreeBlobsDB.
+    #                      conform to the same API exposed by FlatFileDB.
     #        :cache_bits : the number of bits used for cache indexing. The
     #                      cache will hold 2 to the power of bits number of
     #                      objects. We have separate caches for reading and
@@ -126,6 +128,7 @@ module PEROBS
     def initialize(data_base, options = {})
       # Create a backing store handler
       @db = (options[:engine] || BTreeDB).new(data_base, options)
+      @db.open
       # Create a map that can translate classes to numerical IDs and vice
       # versa.
       @class_map = ClassMap.new(@db)
@@ -143,13 +146,60 @@ module PEROBS
 
       # The named (global) objects IDs hashed by their name
       unless (@root_objects = object_by_id(0))
+        PEROBS.log.debug "Initializing the PEROBS store"
         # The root object hash always has the object ID 0.
         @root_objects = _construct_po(Hash, 0)
         # Mark the root_objects object as modified.
         @cache.cache_write(@root_objects)
       end
+      unless @root_objects.is_a?(Hash)
+        PEROBS.log.fatal "Database corrupted: Root objects must be a Hash " +
+          "but is a #{@root_objects.class}"
+      end
+    end
+
+    # Copy the store content into a new Store. The arguments are identical to
+    # Store.new().
+    # @param data_base [String] the name of the database
+    # @param options [Hash] various options to affect the operation of the
+    def copy(dir, options = {})
+      # Make sure all objects are persisted.
+      sync
+
+      # Create a new store with the specified directory and options.
+      new_db = Store.new(dir, options)
+      # Clear the cache.
+      new_db.sync
+      # Copy all objects of the existing store to the new store.
+      i = 0
+      each do |ref_obj|
+        obj = ref_obj._referenced_object
+        obj._transfer(new_db)
+        obj._sync
+        i += 1
+      end
+      PEROBS.log.debug "Copied #{i} objects into new database at #{dir}"
+      # Flush the new store and close it.
+      new_db.exit
+
+      true
+    end
+
+
+    # Close the store and ensure that all in-memory objects are written out to
+    # the storage backend. The Store object is no longer usable after this
+    # method was called.
+    def exit
+      if @cache.in_transaction?
+        PEROBS.log.fatal 'You cannot call exit() during a transaction'
+      end
+      @cache.flush
+      @db.close
+      @db = @class_map = @in_memory_objects = @stats = @cache = @root_objects =
+        nil
     end
 
+
     # You need to call this method to create new PEROBS objects that belong to
     # this Store.
     # @param klass [Class] The class of the object you want to create. This
@@ -159,7 +209,7 @@ module PEROBS
     # @return [POXReference] A reference to the newly created object.
     def new(klass, *args)
       unless klass.is_a?(BasicObject)
-        raise ArgumentError, "#{klass} is not a BasicObject derivative"
+        PEROBS.log.fatal "#{klass} is not a BasicObject derivative"
       end
 
       obj = _construct_po(klass, _new_id, *args)
@@ -204,12 +254,12 @@ module PEROBS
       # We only allow derivatives of PEROBS::Object to be stored in the
       # store.
       unless obj.is_a?(ObjectBase)
-        raise ArgumentError, 'Object must be of class PEROBS::Object but ' +
-                             "is of class #{obj.class}"
+        PEROBS.log.fatal 'Object must be of class PEROBS::Object but ' +
+          "is of class #{obj.class}"
       end
 
       unless obj.store == self
-        raise ArgumentError, 'The object does not belong to this store.'
+        PEROBS.log.fatal 'The object does not belong to this store.'
       end
 
       # Store the name and mark the name list as modified.
@@ -229,11 +279,17 @@ module PEROBS
       POXReference.new(self, id)
     end
 
+    # Return a list with all the names of the root objects.
+    # @return [Array of Symbols]
+    def names
+      @root_objects.keys
+    end
+
     # Flush out all modified objects to disk and shrink the in-memory list if
     # needed.
     def sync
       if @cache.in_transaction?
-        raise RuntimeError, 'You cannot call sync() during a transaction'
+        PEROBS.log.fatal 'You cannot call sync() during a transaction'
       end
       @cache.flush
     end
@@ -245,7 +301,7 @@ module PEROBS
     # @return [Fixnum] The number of collected objects
     def gc
       if @cache.in_transaction?
-        raise RuntimeError, 'You cannot call gc() during a transaction'
+        PEROBS.log.fatal 'You cannot call gc() during a transaction'
       end
       sync
       mark
@@ -299,11 +355,21 @@ module PEROBS
       @db.clear_marks
 
       errors = 0
+      objects = 0
       @root_objects.each do |name, id|
+        objects += 1
         errors += check_object(id, repair)
       end
+      if errors > 0
+        PEROBS.log.warn "#{errors} errors found in #{objects} objects"
+      else
+        PEROBS.log.debug "No errors found"
+      end
       @root_objects.delete_if { |name, id| !@db.check(id, false) }
 
+      # Ensure that any fixes are written into the DB.
+      sync
+
       errors
     end
 
@@ -334,8 +400,8 @@ module PEROBS
       while !stack.empty?
         # Get an object index from the stack.
         unless (obj = object_by_id(id = stack.pop))
-          raise RuntimeError, "Database is corrupted. Object with ID #{id} " +
-                              "not found."
+          PEROBS.log.fatal "Database is corrupted. Object with ID #{id} " +
+            "not found."
         end
         # Mark the object so it will never be pushed to the stack again.
         @db.mark(id)
@@ -352,6 +418,7 @@ module PEROBS
     def rename_classes(rename_map)
       @class_map.rename(rename_map)
     end
+
     # Internal method. Don't use this outside of this library!
     # Generate a new unique ID that is not used by any other object. It uses
     # random numbers between 0 and 2**64 - 1.
@@ -379,12 +446,10 @@ module PEROBS
     end
 
     # Remove the object from the in-memory list. This is an internal method
-    # and should never be called from user code.
+    # and should never be called from user code. It will be called from a
+    # finalizer, so many restrictions apply!
     # @param id [Fixnum or Bignum] Object ID of object to remove from the list
     def _collect(id, ignore_errors = false)
-      unless ignore_errors || @in_memory_objects.include?(id)
-        raise RuntimeError, "Object with id #{id} is currently not in memory"
-      end
       @in_memory_objects.delete(id)
     end
 
@@ -408,6 +473,7 @@ module PEROBS
 
       # The root_objects object is included in the count, but we only want to
       # count user objects here.
+      PEROBS.log.debug "#{marked_objects - 1} objects marked"
       @stats.marked_objects = marked_objects - 1
     end
 
@@ -416,6 +482,7 @@ module PEROBS
     def sweep
       @stats.swept_objects = @db.delete_unmarked_objects.length
       @cache.reset
+      PEROBS.log.debug "#{@stats.swept_objects} objects collected"
       @stats.swept_objects
     end
 
@@ -449,13 +516,12 @@ module PEROBS
         else
           # Remove references to bad objects.
           if ref_obj && repair
-            $stderr.puts "Fixing broken reference to #{id} in\n" +
-                         ref_obj.inspect
+            PEROBS.log.warn "Fixing broken reference to object #{id} in " +
+              "object #{ref_obj._id}:\n" + ref_obj.inspect
             ref_obj._delete_reference_to_id(id)
           else
-            raise RuntimeError,
-              "The following object references a non-existing object #{id}:\n" +
-              ref_obj.inspect
+             PEROBS.log.fatal "The following object references a " +
+               "non-existing object #{id}:\n" + ref_obj.inspect
           end
           errors += 1
         end

data/lib/perobs/TreeDB.rb

@@ -0,0 +1,276 @@
+# encoding: UTF-8
+#
+# = BTreeDB.rb -- Persistent Ruby Object Store
+#
+# Copyright (c) 2015, 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 'perobs/Log'
+require 'perobs/DataBase'
+require 'perobs/BTreeBlob'
+
+module PEROBS
+
+  # This class implements a BTree database using filesystem directories as
+  # nodes and blob files as leafs. The BTree grows with the number of stored
+  # entries. Each leaf node blob can hold a fixed number of entries. If more
+  # entries need to be stored, the blob is replaced by a node with multiple
+  # new leafs that store the entries of the previous node. The leafs are
+  # implemented by the BTreeBlob class.
+  class BTreeDB < DataBase
+
+    attr_reader :max_blob_size
+
+    # Create a new BTreeDB object.
+    # @param db_name [String] name of the DB directory
+    # @param options [Hash] options to customize the behavior. Currently only
+    #        the following options are supported:
+    #        :serializer    : Can be :marshal, :json, :yaml
+    #        :dir_bits      : The number of bits to use for the BTree nodes.
+    #                         The value must be between 4 and 14. The larger
+    #                         the number the more back-end directories are
+    #                         being used. The default is 12 which results in
+    #                         4096 directories per node.
+    #        :max_blob_size : The maximum number of entries in the BTree leaf
+    #                         nodes. The insert/find/delete time grows
+    #                         linearly with the size.
+    def initialize(db_name, options = {})
+      super(options[:serializer] || :json)
+
+      @db_dir = db_name
+      # Create the database directory if it doesn't exist yet.
+      ensure_dir_exists(@db_dir)
+
+      # Read the existing DB config.
+      @config = get_hash('config')
+      check_option('serializer')
+
+      # Check and set @dir_bits, the number of bits used for each tree level.
+      @dir_bits = options[:dir_bits] || 12
+      if @dir_bits < 4 || @dir_bits > 14
+        PEROBS.log.fatal "dir_bits option (#{@dir_bits}) must be between 4 " +
+          "and 12"
+      end
+      check_option('dir_bits')
+
+      @max_blob_size = options[:max_blob_size] || 32
+      if @max_blob_size < 4 || @max_blob_size > 128
+        PEROBS.log.fatal "max_blob_size option (#{@max_blob_size}) must be " +
+          "between 4 and 128"
+      end
+      check_option('max_blob_size')
+
+      put_hash('config', @config)
+
+      # This format string is used to create the directory name.
+      @dir_format_string = "%0#{(@dir_bits / 4) +
+                                (@dir_bits % 4 == 0 ? 0 : 1)}X"
+      # Bit mask to extract the dir_bits LSBs.
+      @dir_mask = 2 ** @dir_bits - 1
+    end
+
+    # Delete the entire database. The database is no longer usable after this
+    # method was called.
+    def delete_database
+      FileUtils.rm_rf(@db_dir)
+    end
+
+    def BTreeDB::delete_db(db_name)
+      FileUtils.rm_rf(db_name)
+    end
+
+    # Return true if the object with given ID exists
+    # @param id [Fixnum or Bignum]
+    def include?(id)
+      !(blob = find_blob(id)).nil? && !blob.find(id).nil?
+    end
+
+    # Store a simple Hash as a JSON encoded file into the DB directory.
+    # @param name [String] Name of the hash. Will be used as file name.
+    # @param hash [Hash] A Hash that maps String objects to strings or
+    # numbers.
+    def put_hash(name, hash)
+      file_name = File.join(@db_dir, name + '.json')
+      begin
+        File.write(file_name, hash.to_json)
+      rescue => e
+        PEROBS.log.fatal "Cannot write hash file '#{file_name}': #{e.message}"
+      end
+    end
+
+    # Load the Hash with the given name.
+    # @param name [String] Name of the hash.
+    # @return [Hash] A Hash that maps String objects to strings or numbers.
+    def get_hash(name)
+      file_name = File.join(@db_dir, name + '.json')
+      return ::Hash.new unless File.exist?(file_name)
+
+      begin
+        json = File.read(file_name)
+      rescue => e
+        PEROBS.log.fatal "Cannot read hash file '#{file_name}': #{e.message}"
+      end
+      JSON.parse(json, :create_additions => true)
+    end
+
+    # Store the given object into the cluster files.
+    # @param obj [Hash] Object as defined by PEROBS::ObjectBase
+    def put_object(obj, id)
+      find_blob(id, true).write_object(id, serialize(obj))
+    end
+
+    # Load the given object from the filesystem.
+    # @param id [Fixnum or Bignum] object ID
+    # @return [Hash] Object as defined by PEROBS::ObjectBase or nil if ID does
+    #         not exist
+    def get_object(id)
+      return nil unless (blob = find_blob(id)) && (obj = blob.read_object(id))
+      deserialize(obj)
+    end
+
+    # This method must be called to initiate the marking process.
+    def clear_marks
+      each_blob { |blob| blob.clear_marks }
+    end
+
+    # Permanently delete all objects that have not been marked. Those are
+    # orphaned and are no longer referenced by any actively used object.
+    # @return [Array] List of IDs that have been removed from the DB.
+    def delete_unmarked_objects
+      deleted_ids = []
+      each_blob { |blob| deleted_ids += blob.delete_unmarked_entries }
+      deleted_ids
+    end
+
+    # Mark an object.
+    # @param id [Fixnum or Bignum] ID of the object to mark
+    def mark(id)
+      (blob = find_blob(id)) && blob.mark(id)
+    end
+
+    # Check if the object is marked.
+    # @param id [Fixnum or Bignum] ID of the object to check
+    # @param ignore_errors [Boolean] If set to true no errors will be raised
+    #        for non-existing objects.
+    def is_marked?(id, ignore_errors = false)
+      (blob = find_blob(id)) && blob.is_marked?(id, ignore_errors)
+    end
+
+    # Basic consistency check.
+    # @param repair [TrueClass/FalseClass] True if found errors should be
+    #        repaired.
+    def check_db(repair = false)
+      each_blob { |blob| blob.check(repair) }
+    end
+
+    # Check if the stored object is syntactically correct.
+    # @param id [Fixnum/Bignum] Object ID
+    # @param repair [TrueClass/FalseClass] True if an repair attempt should be
+    #        made.
+    # @return [TrueClass/FalseClass] True if the object is OK, otherwise
+    #         false.
+    def check(id, repair)
+      begin
+        get_object(id)
+      rescue => e
+        PEROBS.log.error "Cannot read object with ID #{id}: #{e.message}"
+        return false
+      end
+
+      true
+    end
+
+    # Store the given serialized object into the cluster files. This method is
+    # for internal use only!
+    # @param raw [String] Serialized Object as defined by PEROBS::ObjectBase
+    # @param id [Fixnum or Bignum] Object ID
+    def put_raw_object(raw, id)
+      find_blob(id, true).write_object(id, raw)
+    end
+
+    private
+
+    def find_blob(id, create_missing_blob = false, dir_name = @db_dir)
+      dir_bits = id & @dir_mask
+      sub_dir_name = File.join(dir_name, @dir_format_string % dir_bits)
+
+      if Dir.exist?(sub_dir_name)
+        if File.exist?(File.join(sub_dir_name, 'index'))
+          # The directory is a blob directory and not a BTree node dir.
+          return BTreeBlob.new(sub_dir_name, self)
+        end
+      else
+        Dir.glob(File.join(dir_name, '*.index')).each do |fqfn|
+          # Extract the 01-part of the filename
+          lsb_string = File.basename(fqfn)[0..-6]
+          # Convert the lsb_string into a Fixnum
+          lsb = Integer('0b' + lsb_string)
+          # Bit mask to match the LSBs
+          mask = (2 ** lsb_string.length) - 1
+          if (id & mask) == lsb
+            return TreeBlob.new(sub_dir_name, lsb_string, self)
+          end
+        end
+        if create_missing_blob
+          # Create the new blob directory.
+          Dir.mkdir(dir_name)
+          # And initialize the blob DB.
+          return BTreeBlob.new(dir_name, self)
+        else
+          return nil
+        end
+      end
+
+      # Discard the least significant @dir_bits bits and start over again
+      # with the directory that matches the @dir_bits LSBs of the new ID.
+      id = id >> @dir_bits
+    end
+
+    def each_blob(&block)
+      each_blob_r(@db_dir, &block)
+    end
+
+    def each_blob_r(dir, &block)
+      Dir.glob(File.join(dir, '*')) do |dir_name|
+        if is_blob_dir?(dir_name)
+          block.call(BTreeBlob.new(dir_name, self))
+        else
+          each_blob_r(dir_name, &block)
+        end
+      end
+    end
+
+    def is_blob_dir?(dir_name)
+      # A blob directory contains an 'index' and 'data' file. This is in
+      # contrast to BTree node directories that only contain other
+      # directories.
+      index_file = File.join(dir_name, 'index')
+      File.exist?(index_file)
+    end
+
+  end
+
+end
+

data/lib/perobs/version.rb

@@ -1,4 +1,4 @@
 module PEROBS
   # The version number
-  VERSION = "2.3.1"
+  VERSION = "2.4.0"
 end

data/test/Array_spec.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2015 by Chris Schlaeger <chris@taskjuggler.org>
+# Copyright (c) 2015, 2016 by Chris Schlaeger <chris@taskjuggler.org>
 #
 # This file contains tests for Array that are similar to the tests for the
 # Array implementation in MRI. The ideas of these tests were replicated in
@@ -224,6 +224,13 @@ describe PEROBS::Array do
     pcheck { expect(a).to eq([ 1, 2, 3, 4, 5, nil ]) }
   end
 
+  it 'should support inspect' do
+    a1 = cpa([ 1 ])
+    a2 = cpa([ 1, a1 ])
+    expect(a1.inspect).to eq("<PEROBS::Array:#{a1._id}>\n[\n  1\n]\n")
+    expect(a2.inspect).to eq("<PEROBS::Array:#{a2._id}>\n[\n  1,\n  <PEROBS::ObjectBase:#{a1._id}>\n]\n")
+  end
+
   it 'should only provide POXReference objects' do
     a = cpa([ @store.new(PO), @store.new(PO) ])
     expect(a[0].respond_to?(:is_poxreference?)).to be true
@@ -236,7 +243,9 @@ describe PEROBS::Array do
     @store['a'] = a = @store.new(PEROBS::Array)
     o = @store.new(PO)
     a[0] = o.get_self
-    expect { @store.sync }.to raise_error(RuntimeError)
+    PEROBS.log.open(StringIO.new)
+    expect { @store.sync }.to raise_error(PEROBS::FatalError)
+    PEROBS.log.open($stderr)
   end
 
 end

data/test/FixedSizeBlobFile_spec.rb

@@ -0,0 +1,91 @@
+# 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/FixedSizeBlobFile'
+
+describe PEROBS::FixedSizeBlobFile do
+
+  before(:all) do
+    @db_dir = generate_db_name('FixedSizeBlobFile')
+    FileUtils.mkdir_p(@db_dir)
+    @bf = PEROBS::FixedSizeBlobFile.new(@db_dir, 'FixedSizeBlobFile', 4)
+  end
+
+  after(:all) do
+    FileUtils.rm_rf(@db_dir)
+  end
+
+  it 'should create the file' do
+    @bf.open
+  end
+
+  it 'should return free addresses' do
+    expect(@bf.free_address).to eql(0)
+  end
+
+  it 'should store and retrieve a blob' do
+    @bf.store_blob(0,'0000')
+    expect(@bf.retrieve_blob(0)).to eql('0000')
+  end
+
+  it 'should store and retrieve multiple blobs' do
+    @bf.store_blob(0,'XXXX')
+    @bf.store_blob(1,'1111')
+    @bf.store_blob(2,'2222')
+    @bf.store_blob(3,'3333')
+    expect(@bf.retrieve_blob(0)).to eql('XXXX')
+    expect(@bf.retrieve_blob(1)).to eql('1111')
+    expect(@bf.retrieve_blob(2)).to eql('2222')
+    expect(@bf.retrieve_blob(3)).to eql('3333')
+  end
+
+  it 'should return nil for a too large address' do
+    expect(@bf.retrieve_blob(4)).to be_nil
+  end
+
+  it 'should delete an entry' do
+    @bf.delete_blob(2)
+    expect(@bf.retrieve_blob(4)).to be_nil
+  end
+
+  it 'should return 2 as an empty address now' do
+    expect(@bf.free_address).to eql(2)
+  end
+
+  it 'should persist all values over and close/open' do
+    @bf.close
+    @bf.open
+
+    expect(@bf.retrieve_blob(0)).to eql('XXXX')
+    expect(@bf.retrieve_blob(1)).to eql('1111')
+    expect(@bf.retrieve_blob(2)).to be_nil
+    expect(@bf.retrieve_blob(3)).to eql('3333')
+  end
+
+end
+

data/test/FlatFileDB_spec.rb

@@ -0,0 +1,56 @@
+# 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/FlatFileDB'
+
+describe PEROBS::FlatFileDB do
+
+  before(:all) do
+    @db_dir = generate_db_name('FlatFileDB')
+    FileUtils.mkdir_p(@db_dir)
+    @db = PEROBS::FlatFileDB.new(@db_dir)
+    @db.open
+  end
+
+  after(:each) do
+    @db.check_db
+  end
+
+  after(:all) do
+    @db.close
+    FileUtils.rm_rf(@db_dir)
+  end
+
+  it 'should have a version file' do
+    version_file = File.join(@db_dir, 'version')
+    expect(File.exist?(version_file)).to be true
+    expect(File.read(version_file).to_i).to eq(PEROBS::FlatFileDB::VERSION)
+  end
+
+end
+