moab-versioning 4.2.1 → 4.4.2

data/lib/moab/storage_object_validator.rb

@@ -1,16 +1,17 @@
-require 'moab'
+# frozen_string_literal: true
+
 require 'set'
 
 module Moab
   # Given a druid path, are the contents actually a well-formed Moab?
   # Shameless green: repetitious code included.
   class StorageObjectValidator
-    METADATA_DIR = "metadata".freeze
-    CONTENT_DIR = "content".freeze
+    METADATA_DIR = "metadata"
+    CONTENT_DIR = "content"
     EXPECTED_DATA_SUB_DIRS = [CONTENT_DIR, METADATA_DIR].freeze
     IMPLICIT_DIRS = ['.', '..'].freeze # unlike Find.find, Dir.entries returns the current/parent dirs
-    DATA_DIR = "data".freeze
-    MANIFESTS_DIR = 'manifests'.freeze
+    DATA_DIR = "data"
+    MANIFESTS_DIR = 'manifests'
     EXPECTED_VERSION_SUB_DIRS = [DATA_DIR, MANIFESTS_DIR].freeze
     MANIFEST_INVENTORY_PATH = File.join(MANIFESTS_DIR, "manifestInventory.xml").freeze
     SIGNATURE_CATALOG_PATH = File.join(MANIFESTS_DIR, "signatureCatalog.xml").freeze
@@ -59,11 +60,11 @@ module Moab
           NO_SIGNATURE_CATALOG => "Version %{addl}: Missing signatureCatalog.xml",
           NO_MANIFEST_INVENTORY => "Version %{addl}: Missing manifestInventory.xml",
           NO_FILES_IN_MANIFEST_DIR => "Version %{addl}: No files present in manifest dir",
-          METADATA_SUB_DIRS_DETECTED => "Version %{addl}: metadata directory should only contain files, not directories",
+          METADATA_SUB_DIRS_DETECTED => "Version %{version}: metadata directory should only contain files, not directories. Found directory: %{dir}",
           VERSIONS_NOT_IN_ORDER => "Should contain only sequential version directories. Current directories: %{addl}",
           NO_FILES_IN_METADATA_DIR => "Version %{addl}: No files present in metadata dir",
           NO_FILES_IN_CONTENT_DIR => "Version %{addl}: No files present in content dir",
-          CONTENT_SUB_DIRS_DETECTED => "Version %{addl}: content directory should only contain files, not directories",
+          CONTENT_SUB_DIRS_DETECTED => "Version %{version}: content directory should only contain files, not directories. Found directory: %{dir}",
           BAD_SUB_DIR_IN_CONTENT_DIR => "Version %{addl}: content directory has forbidden sub-directory name: vnnnn or #{FORBIDDEN_CONTENT_SUB_DIRS}"
         }.freeze
     end
@@ -84,13 +85,14 @@ module Moab
     end
 
     def version_dir_format?(dirname)
-      dirname =~ /^[v]\d{4}$/
+      dirname =~ /^v\d{4}$/
     end
 
     # call only if the version directories are "correctly named" vdddd
     def check_sequential_version_dirs
       version_directories.each_with_index do |dir_name, index|
-        next if dir_name[1..-1].to_i == index + 1 # version numbering starts at 1, array indexing at 0
+        next if dir_name[1..].to_i == index + 1 # version numbering starts at 1, array indexing at 0
+
         return [result_hash(VERSIONS_NOT_IN_ORDER, version_directories)]
       end
       []
@@ -114,6 +116,7 @@ module Moab
       return expected_version_sub_dirs(version_path, version) if count == EXPECTED_VERSION_SUB_DIRS.size
       return found_unexpected(version_sub_dirs, version, EXPECTED_VERSION_SUB_DIRS) if count > EXPECTED_VERSION_SUB_DIRS.size
       return missing_dir(version_sub_dirs, version, EXPECTED_VERSION_SUB_DIRS) if count < EXPECTED_VERSION_SUB_DIRS.size
+
       []
     end
 
@@ -123,15 +126,20 @@ module Moab
       data_sub_dirs = directory_entries(data_dir_path)
       errors.concat check_data_sub_dirs(version, data_sub_dirs)
       errors.concat check_metadata_dir_files_only(version_path) if errors.empty?
-      errors.concat check_optional_content_dir(version_path, allow_content_subdirs) if data_sub_dirs.include?('content') && errors.empty?
+      if data_sub_dirs.include?('content') && errors.empty?
+        errors.concat check_optional_content_dir(version_path, allow_content_subdirs)
+      end
       errors
     end
 
     def check_data_sub_dirs(version, data_sub_dirs)
       return found_unexpected(data_sub_dirs, version, EXPECTED_DATA_SUB_DIRS) if data_sub_dirs.size > EXPECTED_DATA_SUB_DIRS.size
+
       errors = []
       errors.concat missing_dir(data_sub_dirs, version, [METADATA_DIR]) unless data_sub_dirs.include?(METADATA_DIR)
-      errors.concat found_unexpected(data_sub_dirs, version, EXPECTED_DATA_SUB_DIRS) unless data_sub_dirs.to_set.subset?(EXPECTED_DATA_SUB_DIRS.to_set)
+      unless data_sub_dirs.to_set.subset?(EXPECTED_DATA_SUB_DIRS.to_set)
+        errors.concat found_unexpected(data_sub_dirs, version, EXPECTED_DATA_SUB_DIRS)
+      end
       errors
     end
 
@@ -139,7 +147,10 @@ module Moab
       errors = []
       content_dir_path = File.join(version_path, DATA_DIR, CONTENT_DIR)
       errors << result_hash(NO_FILES_IN_CONTENT_DIR, basename(version_path)) if directory_entries(content_dir_path).empty?
-      errors << result_hash(CONTENT_SUB_DIRS_DETECTED, basename(version_path)) if contains_sub_dir?(content_dir_path) && !allow_content_subdirs
+      content_sub_dir = contains_sub_dir?(content_dir_path)
+      if content_sub_dir && !allow_content_subdirs
+        errors << result_hash(CONTENT_SUB_DIRS_DETECTED, version: basename(version_path), dir: content_sub_dir)
+      end
       if allow_content_subdirs && contains_sub_dir?(content_dir_path) && contains_forbidden_content_sub_dir?(content_dir_path)
         errors << result_hash(BAD_SUB_DIR_IN_CONTENT_DIR, basename(version_path))
       end
@@ -158,7 +169,10 @@ module Moab
       errors = []
       metadata_dir_path = File.join(version_path, DATA_DIR, METADATA_DIR)
       errors << result_hash(NO_FILES_IN_METADATA_DIR, basename(version_path)) if directory_entries(metadata_dir_path).empty?
-      errors << result_hash(METADATA_SUB_DIRS_DETECTED, basename(version_path)) if contains_sub_dir?(metadata_dir_path)
+      metadata_sub_dir = contains_sub_dir?(metadata_dir_path)
+      if metadata_sub_dir
+        errors << result_hash(METADATA_SUB_DIRS_DETECTED, version: basename(version_path), dir: metadata_sub_dir)
+      end
       errors
     end
 
@@ -204,16 +218,30 @@ module Moab
       path.split(File::SEPARATOR)[-1]
     end
 
-    def result_hash(response_code, addl = nil)
-      { response_code => error_code_msg(response_code, addl) }
+    # @param [Integer] response_code one of the recognized values in error_code_to_messages
+    # @param [Hash<Symbol => String>, String] msg_args Value(s) folded into the error message
+    # @return [Hash<Integer => String>] single key/value Hash
+    # @example Usage
+    #  sov.result_hash(10, '/some/dir')
+    #  sov.result_hash(10, addl: '/some/dir') # equivalent
+    #  sov.result_hash(8, version: '3', dir: '/other/dir')
+    def result_hash(response_code, msg_args = nil)
+      { response_code => error_code_msg(response_code, msg_args) }
     end
 
     def error_code_msg(response_code, addl = nil)
-      format(self.class.error_code_to_messages[response_code], addl: addl)
+      arg_hash = {}
+      if addl.is_a?(Hash)
+        arg_hash.merge!(addl)
+      else
+        arg_hash[:addl] = addl
+      end
+      self.class.error_code_to_messages[response_code] % arg_hash
     end
 
     def check_required_manifest_files(dir, version)
       return [result_hash(NO_FILES_IN_MANIFEST_DIR, version)] unless contains_file?(File.join(dir, MANIFESTS_DIR))
+
       errors = []
       errors << result_hash(NO_MANIFEST_INVENTORY, version) unless File.exist?(File.join(dir, MANIFEST_INVENTORY_PATH))
       errors << result_hash(NO_SIGNATURE_CATALOG, version) unless File.exist?(File.join(dir, SIGNATURE_CATALOG_PATH))

data/lib/moab/storage_object_version.rb

@@ -1,4 +1,4 @@
-require 'moab'
+# frozen_string_literal: true
 
 module Moab
   # A class to represent a version subdirectory within an object's home directory in preservation storage
@@ -32,20 +32,20 @@ module Moab
     def initialize(storage_object, version_id)
       if version_id.is_a?(Integer)
         @version_id = version_id
-      elsif version_id.is_a?(String) and version_id =~ /^v(\d+)$/
+      elsif version_id.is_a?(String) && version_id =~ /^v(\d+)$/
         @version_id = version_id.sub(/^v/, '').to_i
       else
-        raise "version_id (#{version_id}) is not in a recognized format"
+        raise(MoabRuntimeError, "version_id (#{version_id}) is not in a recognized format")
       end
       @version_name = StorageObject.version_dirname(@version_id)
       @version_pathname = storage_object.object_pathname.join(@version_name)
       @storage_object = storage_object
-      @inventory_cache = Hash.new
+      @inventory_cache = {}
     end
 
     # @return [String] The unique identifier concatenating digital object id with version id
     def composite_key
-      @storage_object.digital_object_id + '-' + StorageObject.version_dirname(@version_id)
+      "#{@storage_object.digital_object_id}-#{StorageObject.version_dirname(@version_id)}"
     end
 
     # @return [Boolean] true if the object version directory exists
@@ -70,6 +70,7 @@ module Moab
     def find_filepath(file_category, file_id)
       this_version_filepath = file_pathname(file_category, file_id)
       return this_version_filepath if this_version_filepath.exist?
+
       if file_category == 'manifest'
         msg = "manifest file #{file_id} not found for #{@storage_object.digital_object_id} - #{@version_id}"
         raise FileNotFoundException, msg
@@ -110,15 +111,16 @@ module Moab
     # @see FileInventory#read_xml_file
     def file_inventory(type)
       if version_id > 0
-        return @inventory_cache[type] if @inventory_cache.has_key?(type)
+        return @inventory_cache[type] if @inventory_cache.key?(type)
+
         @inventory_cache[type] = FileInventory.read_xml_file(@version_pathname.join('manifests'), type)
       else
-        groups = ['content', 'metadata'].collect { |id| FileGroup.new(:group_id => id) }
+        groups = %w[content metadata].collect { |id| FileGroup.new(group_id: id) }
         FileInventory.new(
-          :type => 'version',
-          :digital_object_id => @storage_object.digital_object_id,
-          :version_id => @version_id,
-          :groups => groups
+          type: 'version',
+          digital_object_id: @storage_object.digital_object_id,
+          version_id: @version_id,
+          groups: groups
         )
       end
     end
@@ -129,7 +131,7 @@ module Moab
       if version_id > 0
         SignatureCatalog.read_xml_file(@version_pathname.join('manifests'))
       else
-        SignatureCatalog.new(:digital_object_id => @storage_object.digital_object_id)
+        SignatureCatalog.new(digital_object_id: @storage_object.digital_object_id)
       end
     end
 
@@ -137,7 +139,8 @@ module Moab
     # @param bag_dir [Pathname,String] The location of the bag to be ingested
     # @return [void] Create the version subdirectory and move files into it
     def ingest_bag_data(bag_dir)
-      raise "Version already exists: #{@version_pathname}" if @version_pathname.exist?
+      raise(MoabRuntimeError, "Version already exists: #{@version_pathname}") if @version_pathname.exist?
+
       @version_pathname.join('manifests').mkpath
       bag_dir = Pathname(bag_dir)
       ingest_dir(bag_dir.join('data'), @version_pathname.join('data'))
@@ -151,7 +154,8 @@ module Moab
     # @param use_links [Boolean] If true, use hard links; if false, make copies
     # @return [void] recursively link or copy the source directory contents to the target directory
     def ingest_dir(source_dir, target_dir, use_links = true)
-      raise "cannot copy - target already exists: #{target_dir.expand_path}" if target_dir.exist?
+      raise(MoabRuntimeError, "cannot copy - target already exists: #{target_dir.expand_path}") if target_dir.exist?
+
       target_dir.mkpath
       source_dir.children.each do |child|
         if child.directory?
@@ -198,22 +202,22 @@ module Moab
     # @return [void] examine the version's directory and create/serialize a {FileInventory} containing the manifest files
     def generate_manifest_inventory
       manifest_inventory = FileInventory.new(
-        :type => 'manifests',
-        :digital_object_id => @storage_object.digital_object_id,
-        :version_id => @version_id
+        type: 'manifests',
+        digital_object_id: @storage_object.digital_object_id,
+        version_id: @version_id
       )
       pathname = @version_pathname.join('manifests')
-      manifest_inventory.groups << FileGroup.new(:group_id => 'manifests').group_from_directory(pathname, false)
+      manifest_inventory.groups << FileGroup.new(group_id: 'manifests').group_from_directory(pathname, false)
       manifest_inventory.write_xml_file(pathname)
     end
 
     # @return [VerificationResult] return result of testing correctness of version manifests
-    def verify_version_storage()
-      result = VerificationResult.new(self.composite_key)
-      result.subentities << self.verify_manifest_inventory
-      result.subentities << self.verify_version_inventory
-      result.subentities << self.verify_version_additions
-      result.verified = result.subentities.all? { |entity| entity.verified }
+    def verify_version_storage
+      result = VerificationResult.new(composite_key)
+      result.subentities << verify_manifest_inventory
+      result.subentities << verify_version_inventory
+      result.subentities << verify_version_additions
+      result.verified = result.subentities.all?(&:verified)
       result
     end
 
@@ -221,8 +225,8 @@ module Moab
     def verify_manifest_inventory
       # read/parse manifestInventory.xml
       result = VerificationResult.new("manifest_inventory")
-      manifest_inventory = self.file_inventory('manifests')
-      result.subentities << VerificationResult.verify_value('composite_key', self.composite_key, manifest_inventory.composite_key)
+      manifest_inventory = file_inventory('manifests')
+      result.subentities << VerificationResult.verify_value('composite_key', composite_key, manifest_inventory.composite_key)
       result.subentities << VerificationResult.verify_truth('manifests_group', !manifest_inventory.group_empty?('manifests'))
       # measure the manifest signatures of the files in the directory (excluding manifestInventory.xml)
       directory_inventory = FileInventory.new.inventory_from_directory(@version_pathname.join('manifests'), 'manifests')
@@ -236,7 +240,7 @@ module Moab
       compare_result.verified = (diff.difference_count == 0)
       compare_result.details = diff.differences_detail
       result.subentities << compare_result
-      result.verified = result.subentities.all? { |entity| entity.verified }
+      result.verified = result.subentities.all?(&:verified)
       result
     end
 
@@ -244,10 +248,10 @@ module Moab
     def verify_signature_catalog
       result = VerificationResult.new("signature_catalog")
       signature_catalog = self.signature_catalog
-      result.subentities << VerificationResult.verify_value('signature_key', self.composite_key, signature_catalog.composite_key)
+      result.subentities << VerificationResult.verify_value('signature_key', composite_key, signature_catalog.composite_key)
       found = 0
-      missing = Array.new
-      object_pathname = self.storage_object.object_pathname
+      missing = []
+      object_pathname = storage_object.object_pathname
       signature_catalog.entries.each do |catalog_entry|
         storage_location = object_pathname.join(catalog_entry.storage_path)
         if storage_location.exist?
@@ -264,19 +268,19 @@ module Moab
       }
       file_result.details['missing'] = missing unless missing.empty?
       result.subentities << file_result
-      result.verified = result.subentities.all? { |entity| entity.verified }
+      result.verified = result.subentities.all?(&:verified)
       result
     end
 
     # @return [Boolean] true if files & signatures listed in version inventory can all be found
     def verify_version_inventory
       result = VerificationResult.new("version_inventory")
-      version_inventory = self.file_inventory('version')
-      result.subentities << VerificationResult.verify_value('inventory_key', self.composite_key, version_inventory.composite_key)
+      version_inventory = file_inventory('version')
+      result.subentities << VerificationResult.verify_value('inventory_key', composite_key, version_inventory.composite_key)
       signature_catalog = self.signature_catalog
-      result.subentities << VerificationResult.verify_value('signature_key', self.composite_key, signature_catalog.composite_key)
+      result.subentities << VerificationResult.verify_value('signature_key', composite_key, signature_catalog.composite_key)
       found = 0
-      missing = Array.new
+      missing = []
       version_inventory.groups.each do |group|
         group.files.each do |file|
           file.instances.each do |instance|
@@ -298,24 +302,24 @@ module Moab
       }
       file_result.details['missing'] = missing unless missing.empty?
       result.subentities << file_result
-      result.verified = result.subentities.all? { |entity| entity.verified }
+      result.verified = result.subentities.all?(&:verified)
       result
     end
 
     # @return [Boolean] returns true if files in data folder match files listed in version addtions inventory
     def verify_version_additions
       result = VerificationResult.new("version_additions")
-      version_additions = self.file_inventory('additions')
-      result.subentities << VerificationResult.verify_value('composite_key', self.composite_key, version_additions.composite_key)
+      version_additions = file_inventory('additions')
+      result.subentities << VerificationResult.verify_value('composite_key', composite_key, version_additions.composite_key)
       data_directory = @version_pathname.join('data')
-      directory_inventory = FileInventory.new(:type => 'directory').inventory_from_directory(data_directory)
+      directory_inventory = FileInventory.new(type: 'directory').inventory_from_directory(data_directory)
       diff = FileInventoryDifference.new
       diff.compare(version_additions, directory_inventory)
       compare_result = VerificationResult.new('file_differences')
       compare_result.verified = (diff.difference_count == 0)
       compare_result.details = diff.differences_detail
       result.subentities << compare_result
-      result.verified = result.subentities.all? { |entity| entity.verified }
+      result.verified = result.subentities.all?(&:verified)
       result
     end
 
@@ -323,6 +327,7 @@ module Moab
     # @return [null] Deactivate this object version by moving it to another directory.  (Used by restore operation)
     def deactivate(timestamp)
       return unless @version_pathname.exist?
+
       timestamp_pathname = @version_pathname.parent.join(timestamp.utc.iso8601.gsub(/[-:]/, ''))
       timestamp_pathname.mkpath
       demote_pathame = timestamp_pathname.join(@version_pathname.basename)

data/lib/moab/storage_repository.rb

@@ -1,4 +1,4 @@
-require 'moab'
+# frozen_string_literal: true
 
 module Moab
   # A class to represent the SDR repository store
@@ -20,10 +20,12 @@ module Moab
     # @return [Array<Pathname>] The list of filesystem root paths in which objects are stored
     def storage_roots
       unless defined?(@storage_roots)
-        raise "Moab::Config.storage_roots not found in config file" if Moab::Config.storage_roots.nil?
+        raise(MoabRuntimeError, "Moab::Config.storage_roots not found in config file") if Moab::Config.storage_roots.nil?
+
         @storage_roots = [Moab::Config.storage_roots].flatten.collect { |filesystem| Pathname(filesystem) }
-        raise "Moab::Config.storage_roots empty" if @storage_roots.empty?
-        @storage_roots.each { |root| raise "Storage root #{root} not found on system" unless root.exist? }
+        raise(MoabRuntimeError, "Moab::Config.storage_roots empty") if @storage_roots.empty?
+
+        @storage_roots.each { |root| raise(MoabRuntimeError, "Storage root #{root} not found on system") unless root.exist? }
       end
       @storage_roots
     end
@@ -31,8 +33,9 @@ module Moab
     # @return [String] The trunk segment of the object storage path
     def storage_trunk
       unless defined?(@storage_trunk)
-        raise "Moab::Config.storage_trunk not found in config file" if Moab::Config.storage_trunk.nil?
-        @storage_trunk  = Moab::Config.storage_trunk
+        raise(MoabRuntimeError, "Moab::Config.storage_trunk not found in config file") if Moab::Config.storage_trunk.nil?
+
+        @storage_trunk = Moab::Config.storage_trunk
       end
       @storage_trunk
     end
@@ -52,15 +55,15 @@ module Moab
       unless defined?(@deposit_trunk)
         # do not raise error.  this parameter will be ignored if missing
         # raise "Moab::Config.deposit_trunk not found in config file" if Moab::Config.deposit_trunk.nil?
-        @deposit_trunk  = Moab::Config.deposit_trunk
+        @deposit_trunk = Moab::Config.deposit_trunk
       end
       @deposit_trunk
     end
 
     # @param object_id [String] The identifier of the digital object
-    # @return [Pathname] The branch segment of the object deposit path
+    # @return [String] The branch segment of the object deposit path
+    # @note Override this method in a subclass
     def deposit_branch(object_id)
-       #todo This method should be customized, or overridden in a subclass
       object_id
     end
 
@@ -72,16 +75,18 @@ module Moab
       branch = storage_branch(object_id)
       storage_roots.each do |root|
         root_trunk = root.join(storage_trunk)
-        raise "Storage area not found at #{root_trunk}" unless root_trunk.exist?
+        raise(MoabRuntimeError, "Storage area not found at #{root_trunk}") unless root_trunk.exist?
+
         root_trunk_branch = root_trunk.join(branch)
         return root if root_trunk_branch.exist?
       end
       # Search for the object's directory in the deposit areas
-      if include_deposit and deposit_trunk
+      if include_deposit && deposit_trunk
         branch = deposit_branch(object_id)
         storage_roots.each do |root|
           root_trunk = root.join(deposit_trunk)
-          raise "Deposit area not found at #{root_trunk}" unless root_trunk.exist?
+          raise(MoabRuntimeError, "Deposit area not found at #{root_trunk}") unless root_trunk.exist?
+
           root_trunk_branch = root_trunk.join(branch)
           return root if root_trunk_branch.exist?
         end
@@ -95,10 +100,35 @@ module Moab
     # @return [StorageObject] The representation of a digitial object's  storage directory, which might not exist yet.
     def find_storage_object(object_id, include_deposit = false)
       root = find_storage_root(object_id, include_deposit)
-      storage_pathname = root.join(storage_trunk, storage_branch(object_id))
-      storage_object = StorageObject.new(object_id, storage_pathname)
-      storage_object.storage_root = root
-      storage_object
+      create_storage_object(object_id, root)
+    end
+
+    # @param object_id [String] The identifier of the digital object
+    # @param include_deposit [Boolean] specifies whether to look in deposit areas for objects in process of initial ingest
+    # @return [Array<StorageObject>] Representations of a digitial object's storage directories, or an empty array if none found.
+    def search_storage_objects(object_id, include_deposit = false)
+      storage_objects = []
+      # Search for the object's home directory in the storage areas
+      branch = storage_branch(object_id)
+      storage_roots.each do |root|
+        root_trunk = root.join(storage_trunk)
+        raise(MoabRuntimeError, "Storage area not found at #{root_trunk}") unless root_trunk.exist?
+
+        root_trunk_branch = root_trunk.join(branch)
+        storage_objects << create_storage_object(object_id, root) if root_trunk_branch.exist?
+      end
+      # Search for the object's directory in the deposit areas
+      if include_deposit && deposit_trunk
+        branch = deposit_branch(object_id)
+        storage_roots.each do |root|
+          root_trunk = root.join(deposit_trunk)
+          raise(MoabRuntimeError, "Deposit area not found at #{root_trunk}") unless root_trunk.exist?
+
+          root_trunk_branch = root_trunk.join(branch)
+          storage_objects << create_storage_object(object_id, root) if root_trunk_branch.exist?
+        end
+      end
+      storage_objects
     end
 
     # @param object_id [String] The identifier of the digital object whose size is desired
@@ -119,11 +149,9 @@ module Moab
     def storage_object(object_id, create = false)
       storage_object = find_storage_object(object_id)
       unless storage_object.object_pathname.exist?
-        if create
-          storage_object.object_pathname.mkpath
-        else
-          raise Moab::ObjectNotFoundException, "No storage object found for #{object_id}"
-        end
+        raise ObjectNotFoundException, "No storage object found for #{object_id}" unless create
+
+        storage_object.object_pathname.mkpath
       end
       storage_object
     end
@@ -132,9 +160,16 @@ module Moab
     # @param druid [String] The object identifier
     # @return [void] transfer the object to the preservation repository
     def store_new_object_version(druid, bag_pathname)
-      storage_object = self.storage_object(druid, create = true)
-      new_version = storage_object.ingest_bag(bag_pathname)
-      new_version
+      storage_object(druid, true).ingest_bag(bag_pathname)
+    end
+
+    private
+
+    def create_storage_object(object_id, root)
+      storage_pathname = root.join(storage_trunk, storage_branch(object_id))
+      storage_object = StorageObject.new(object_id, storage_pathname)
+      storage_object.storage_root = root
+      storage_object
     end
   end
 end