perobs 3.0.1 → 3.0.2

data/lib/perobs/Hash.rb

@@ -92,7 +92,7 @@ module PEROBS
 
     # Return a list of all object IDs of all persistend objects that this Hash
     # is referencing.
-    # @return [Array of Fixnum or Bignum] IDs of referenced objects
+    # @return [Array of Integer] IDs of referenced objects
     def _referenced_object_ids
       @data.each_value.select { |v| v && v.respond_to?(:is_poxreference?) }.
         map { |o| o.id }
@@ -100,7 +100,7 @@ module PEROBS
 
     # This method should only be used during store repair operations. It will
     # delete all referenced to the given object ID.
-    # @param id [Fixnum/Bignum] targeted object ID
+    # @param id [Integer] targeted object ID
     def _delete_reference_to_id(id)
       @data.delete_if do |k, v|
         v && v.respond_to?(:is_poxreference?) && v.id == id

data/lib/perobs/Object.rb

@@ -140,7 +140,7 @@ module PEROBS
 
     # Return a list of all object IDs that the attributes of this instance are
     # referencing.
-    # @return [Array of Fixnum or Bignum] IDs of referenced objects
+    # @return [Array of Integer] IDs of referenced objects
     def _referenced_object_ids
       ids = []
       _all_attributes.each do |attr|
@@ -152,7 +152,7 @@ module PEROBS
 
     # This method should only be used during store repair operations. It will
     # delete all references to the given object ID.
-    # @param id [Fixnum/Bignum] targeted object ID
+    # @param id [Integer] targeted object ID
     def _delete_reference_to_id(id)
       _all_attributes.each do |attr|
         ivar = ('@' + attr.to_s).to_sym

data/lib/perobs/ObjectBase.rb

@@ -207,7 +207,7 @@ module PEROBS
     end
 
     # Restore the object state from the storage back-end.
-    # @param level [Fixnum] the transaction nesting level
+    # @param level [Integer] the transaction nesting level
     def _restore(level)
       # Find the most recently stored state of this object. This could be on
       # any previous stash level or in the regular object DB. If the object

data/lib/perobs/SpaceTree.rb

@@ -40,7 +40,7 @@ module PEROBS
   # size which drastically simplifies the backing store operation.
   class SpaceTree
 
-    attr_reader :nodes
+    attr_reader :nodes, :cache
 
     # Manage the free spaces tree in the specified directory
     # @param dir [String] directory path of an existing directory
@@ -51,29 +51,44 @@ module PEROBS
       @nodes = EquiBlobsFile.new(@dir, 'database_spaces',
                                  SpaceTreeNode::NODE_BYTES, 1)
 
-      @node_cache = SpaceTreeNodeCache.new(128)
+      @cache = SpaceTreeNodeCache.new(self, 128)
     end
 
     # Open the SpaceTree file.
     def open
       @nodes.open
-      @node_cache.clear
-      @root = SpaceTreeNode.new(self, nil, @nodes.total_entries == 0 ?
-                                           nil : @nodes.first_entry)
-      @node_cache.insert(@root)
+      @cache.clear
+      node = @nodes.total_entries == 0 ?
+        SpaceTreeNode::create(self) :
+        SpaceTreeNode::load(self, @nodes.first_entry)
+      @root_address = node.node_address
     end
 
     # Close the SpaceTree file.
     def close
+      @cache.flush
       @nodes.close
-      @root = nil
-      @node_cache.clear
+      @root_address = nil
+      @cache.clear
     end
 
+    # Flush all pending writes to the file system.
+    def sync
+      @cache.flush
+      @nodes.sync
+    end
+
+    # Set a new root node for the SpaceTree
+    # @param node [SpaceTreeNode]
     def set_root(node)
-      @root = node
+      @root_address = node.node_address
+      @nodes.first_entry = node.node_address
     end
 
+    # Return the SpaceTreeNode that is the root of the SpaceTree.
+    def root
+      @root_address ? @cache.get(@root_address) : nil
+    end
 
     # Erase the SpaceTree file. This method cannot be called while the file is
     # open.
@@ -88,7 +103,11 @@ module PEROBS
       if size <= 0
         PEROBS.log.fatal "Size (#{size}) must be larger than 0."
       end
-      @root.add_space(address, size)
+      if has_space?(address, size)
+        PEROBS.log.fatal "The space with address #{address} and size #{size} " +
+          "can't be added twice."
+      end
+      root.add_space(address, size)
     end
 
     # Get a space that has at least the requested size.
@@ -99,10 +118,10 @@ module PEROBS
         PEROBS.log.fatal "Size (#{size}) must be larger than 0."
       end
 
-      if (address_size = @root.find_matching_space(size))
+      if (address_size = root.find_matching_space(size))
         # First we try to find an exact match.
         return address_size
-      elsif (address_size = @root.find_equal_or_larger_space(size))
+      elsif (address_size = root.find_equal_or_larger_space(size))
         return address_size
       else
         return nil
@@ -112,38 +131,15 @@ module PEROBS
     # Delete the node at the given address in the SpaceTree file.
     # @param address [Integer] address in file
     def delete_node(address)
-      @node_cache.delete(address)
+      @cache.delete(address)
       @nodes.delete_blob(address)
     end
 
     # Clear all pools and forget any registered spaces.
     def clear
       @nodes.clear
-      @node_cache.clear
-      @root = SpaceTreeNode.new(self)
-      @node_cache.insert(@root)
-    end
-
-    # Create a new SpaceTreeNode.
-    # @param parent [SpaceTreeNode] parent node
-    # @param blob_address [Integer] address of the free space
-    # @param size [Integer] size of the free space
-    def new_node(parent, blob_address, size)
-      node = SpaceTreeNode.new(self, parent, nil, blob_address, size)
-      @node_cache.insert(node)
-    end
-
-    # Return the SpaceTreeNode that matches the given node address. If a blob
-    # address and size are given, a new node is created instead of being read
-    # from the file.
-    # @param node_address [Integer] Address of the node in the SpaceTree file
-    # @return [SpaceTreeNode]
-    def get_node(node_address)
-      if (node = @node_cache.get(node_address))
-        return node
-      end
-
-      @node_cache.insert(SpaceTreeNode.new(self, nil, node_address))
+      @cache.clear
+      @root_address = SpaceTreeNode::create(self).node_address
     end
 
     # Check if there is a space in the free space lists that matches the
@@ -152,7 +148,7 @@ module PEROBS
     # @param [Integer] size Length of the space in bytes
     # @return [Boolean] True if space is found, false otherwise
     def has_space?(address, size)
-      @root.has_space?(address, size)
+      root.has_space?(address, size)
     end
 
     # Check if the index is OK and matches the flat_file data (if given).
@@ -160,19 +156,28 @@ module PEROBS
     # @return True if space list matches, flase otherwise
     def check(flat_file = nil)
       @nodes.check
-      @root.check(flat_file)
+      root.check(flat_file)
+    end
+
+    # Iterate over all entries and yield address and size.
+    def each
+      root.each do |node, mode, stack|
+        if mode == :on_enter
+          yield(node.blob_address, node.size)
+        end
+      end
     end
 
     # Complete internal tree data structure as textual tree.
     # @return [String]
     def to_s
-      @root.to_tree_s
+      root.to_tree_s
     end
 
     # Convert the tree into an Array of [address, size] touples.
     # @return [Array]
     def to_a
-      @root.to_a
+      root.to_a
     end
 
   end

data/lib/perobs/SpaceTreeNode.rb

@@ -51,43 +51,97 @@ module PEROBS
     # Create a new SpaceTreeNode object. If node_address is not nil, the data
     # will be read from the SpaceTree file at the given node_address.
     # @param tree [SpaceTree] Tree that the object should belong to
-    # @param parent [SpaceTreeNode] Parent node in the tree
     # @param node_address [Integer] Address of the node in the file
     # @param blob_address [Integer] Address of the free space blob
     # @param size [Integer] Size of the free space blob
-    def initialize(tree, parent = nil, node_address = nil, blob_address = 0,
-                   size = 0)
+    # @param parent [SpaceTreeNode] Parent node in the tree
+    # @param smaller [SpaceTreeNode] smaller node in the tree
+    # @param equal [SpaceTreeNode] equal node in the tree
+    # @param larger [SpaceTreeNode] larger node in the tree
+    def initialize(tree, node_address, blob_address = 0, size = 0,
+                   parent = nil, smaller = nil, equal = nil, larger = nil)
       @tree = tree
-      if blob_address < 0
+      if node_address <= 0
         PEROBS.log.fatal "Node address (#{node_address}) must be larger than 0"
       end
+      @node_address = node_address
+      if blob_address < 0
+        PEROBS.log.fatal "Blob address (#{node_address}) must be larger than 0"
+      end
       @blob_address = blob_address
       @size = size
-      @smaller = @equal = @larger = nil
-      @node_address = node_address
+      @parent = parent
+      @smaller = smaller
+      @equal = equal
+      @larger = larger
+
+      ObjectSpace.define_finalizer(
+        self, SpaceTreeNode._finalize(@tree, @node_address))
+      @tree.cache.insert_unmodified(self)
+    end
 
-      unless node_address.nil? || node_address.is_a?(Integer)
-        PEROBS.log.fatal "node_address is not Integer: #{node_address.class}"
-      end
+    # This method generates the destructor for the objects of this class. It
+    # is done this way to prevent the Proc object hanging on to a reference to
+    # self which would prevent the object from being collected. This internal
+    # method is not intended for users to call.
+    def SpaceTreeNode._finalize(tree, node_address)
+      proc { tree.cache._collect(node_address) }
+    end
 
-      if node_address
-        # This must be an existing node. Try to read it and fill the instance
-        # variables.
-        if size != 0
-          PEROBS.log.fatal "If node_address is not nil size must be 0"
-        end
-        if blob_address != 0
-          PEROBS.log.fatal "If node_address is not nil blob_address must be 0"
-        end
-        unless read_node
-          PEROBS.log.fatal "SpaceTree node at address #{node_address} " +
-            "does not exist"
-        end
-      else
-        # This is a new node. Make sure the data is written to the file.
-        @node_address = @tree.nodes.free_address
-        self.parent = parent
+    # Create a new SpaceTreeNode. This method should be used for the creation
+    # of new nodes instead of calling the constructor directly.
+    # @param tree [SpaceTree] The tree the node should belong to
+    # @param node_address [Integer] Address of the node in the file
+    # @param blob_address [Integer] Address of the free space blob
+    # @param size [Integer] Size of the free space blob
+    # @param parent [SpaceTreeNode] Parent node in the tree
+    def SpaceTreeNode::create(tree, blob_address = 0, size = 0, parent = nil)
+      node_address = tree.nodes.free_address
+
+      node = SpaceTreeNode.new(tree, node_address, blob_address, size, parent)
+      node.save
+
+      node
+    end
+
+    # Restore a node from the backing store at the given address and tree.
+    # @param tree [SpaceTree] The tree the node belongs to
+    # @param node_address [Integer] The address in the file.
+    def SpaceTreeNode::load(tree, node_address)
+      unless node_address > 0
+        PEROBS.log.fatal "node_address (#{node_address}) must be larger than 0"
+      end
+      unless (bytes = tree.nodes.retrieve_blob(node_address))
+        PEROBS.log.fatal "SpaceTreeNode at address #{node_address} does " +
+          "not exist"
       end
+
+      blob_address, size, parent_node_address,
+        smaller_node_address, equal_node_address,
+        larger_node_address = bytes.unpack(NODE_BYTES_FORMAT)
+
+      parent = parent_node_address != 0 ?
+        SpaceTreeNodeLink.new(tree, parent_node_address) : nil
+      smaller = smaller_node_address != 0 ?
+        SpaceTreeNodeLink.new(tree, smaller_node_address) : nil
+      equal = equal_node_address != 0 ?
+        SpaceTreeNodeLink.new(tree, equal_node_address) : nil
+      larger = larger_node_address != 0 ?
+        SpaceTreeNodeLink.new(tree, larger_node_address) : nil
+
+      node = SpaceTreeNode.new(tree, node_address, blob_address, size,
+                               parent, smaller, equal, larger)
+
+      node
+    end
+
+    def save
+      bytes = [ @blob_address, @size,
+                @parent ? @parent.node_address : 0,
+                @smaller ? @smaller.node_address : 0,
+                @equal ? @equal.node_address : 0,
+                @larger ? @larger.node_address : 0].pack(NODE_BYTES_FORMAT)
+      @tree.nodes.store_blob(@node_address, bytes)
     end
 
     # Add a new node for the given address and size to the tree.
@@ -110,7 +164,7 @@ module PEROBS
             # There is no smaller node yet, so we create a new one as a
             # smaller child of the current node.
             node.set_link('@smaller',
-                          @tree.new_node(node, address, size))
+                          SpaceTreeNode::create(@tree, address, size, node))
             break
           end
         elsif size > node.size
@@ -122,13 +176,13 @@ module PEROBS
             # There is no larger node yet, so we create a new one as a larger
             # child of the current node.
             node.set_link('@larger',
-                          @tree.new_node(node, address, size))
+                          SpaceTreeNode::create(@tree, address, size, node))
             break
           end
         else
           # Same size as current node. Insert new node as equal child at top of
           # equal list.
-          new_node = @tree.new_node(node, address, size)
+          new_node = SpaceTreeNode::create(@tree, address, size, node)
           new_node.set_link('@equal', node.equal)
 
           node.set_link('@equal', new_node)
@@ -147,7 +201,7 @@ module PEROBS
       node = self
       loop do
         if node.blob_address == address
-          return true
+          return size == node.size
         elsif size < node.size && node.smaller
           node = node.smaller
         elsif size > node.size && node.larger
@@ -242,7 +296,7 @@ module PEROBS
         PEROBS.log.fatal "Cannot unlink unknown child node with address " +
           "#{child_node.node_address} from #{to_s}"
       end
-      write_node
+      @tree.cache.insert_modified(self)
     end
 
     # Depth-first iterator for all nodes. The iterator yields the given block
@@ -339,7 +393,7 @@ module PEROBS
           @parent.set_link('@larger', node)
         else
           PEROBS.log.fatal "Cannot relink unknown child node with address " +
-            "#{node.node_address} from #{to_s}"
+            "#{node.node_address} from #{parent.to_s}"
         end
       else
         if node
@@ -382,7 +436,7 @@ module PEROBS
     def set_size_and_address(size, address)
       @size = size
       @blob_address = address
-      write_node
+      @tree.cache.insert_modified(self)
     end
 
     def set_link(name, node_or_address)
@@ -398,12 +452,12 @@ module PEROBS
         # Clear the node link.
         instance_variable_set(name, nil)
       end
-      write_node
+      @tree.cache.insert_modified(self)
     end
 
     def parent=(p)
       @parent = p ? SpaceTreeNodeLink.new(@tree, p) : nil
-      write_node
+      @tree.cache.insert_modified(self)
     end
     # Compare this node to another node.
     # @return [Boolean] true if node address is identical, false otherwise
@@ -633,40 +687,6 @@ module PEROBS
       str
     end
 
-    private
-
-    def write_node
-      bytes = [ @blob_address, @size,
-                @parent ? @parent.node_address : 0,
-                @smaller ? @smaller.node_address : 0,
-                @equal ? @equal.node_address : 0,
-                @larger ? @larger.node_address : 0].pack(NODE_BYTES_FORMAT)
-      @tree.nodes.store_blob(@node_address, bytes)
-    end
-
-    def read_node
-      unless @node_address > 0
-        PEROBS.log.fatal "@node_address must be larger than 0"
-      end
-      return false unless (bytes = @tree.nodes.retrieve_blob(@node_address))
-
-      @blob_address, @size, parent_node_address,
-        smaller_node_address, equal_node_address,
-        larger_node_address = bytes.unpack(NODE_BYTES_FORMAT)
-      # The parent address can also be 0 as the parent can rightly point back
-      # to the root node which always has the address 0.
-      @parent = parent_node_address != 0 ?
-        SpaceTreeNodeLink.new(@tree, parent_node_address) : nil
-      @smaller = smaller_node_address != 0 ?
-        SpaceTreeNodeLink.new(@tree, smaller_node_address) : nil
-      @equal = equal_node_address != 0 ?
-        SpaceTreeNodeLink.new(@tree, equal_node_address) : nil
-      @larger = larger_node_address != 0 ?
-        SpaceTreeNodeLink.new(@tree, larger_node_address) : nil
-
-      true
-    end
-
   end
 
 end