moab-versioning 1.3.0

data/lib/moab/signature_catalog_entry.rb

@@ -0,0 +1,61 @@
+require 'moab'
+
+module Moab
+
+  # A file-level entry in a digital object's {SignatureCatalog}.
+  # It has a child {FileSignature} element that identifies the file's contents (the bytestream)
+  # along with data that specfies the SDR storage location that was used to preserve a single file instance.
+  #
+  # ====Data Model
+  # * {SignatureCatalog} = lookup table containing a cumulative collection of all files ever ingested
+  #   * <b>{SignatureCatalogEntry} [1..*] = an row in the lookup table containing storage information about a single file</b>
+  #     * {FileSignature} [1] = file fixity information
+  #
+  # @note Copyright (c) 2012 by The Board of Trustees of the Leland Stanford Junior University.
+  #   All rights reserved.  See {file:LICENSE.rdoc} for details.
+  class SignatureCatalogEntry < Serializable
+
+    include HappyMapper
+
+    # The name of the XML element used to serialize this objects data
+    tag 'entry'
+
+    # (see Serializable#initialize)
+    def initialize(opts={})
+      super(opts)
+    end
+
+    # @attribute
+    # @return [Integer] The ordinal version number
+    attribute :version_id, Integer, :tag => 'originalVersion', :key => true, :on_save => Proc.new {|n| n.to_s}
+
+    # @attribute
+    # @return [String] The name of the file group
+    attribute :group_id, String, :tag => 'groupId', :key => true
+
+    # @attribute
+    # @return [String] The id is the filename path, relative to the file group's base directory
+    attribute :path, String, :key => true, :tag => 'storagePath'
+
+    # @attribute
+    # @return [FileSignature] The fixity data of the file instance
+    element :signature, FileSignature, :tag => 'fileSignature'
+
+    def signature
+      # HappyMapper's parser tries to put an array of signatures in the signature field
+      @signature.is_a?(Array) ? @signature[0] : @signature
+    end
+
+    def signature=(signature)
+      @signature = signature.is_a?(Array) ? signature[0] : signature
+    end
+
+    # @api internal
+    # @return [String] Returns the storage path to a file, relative to the object storage home directory
+    def storage_path
+      File.join(StorageObject.version_dirname(version_id),'data', group_id, path)
+    end
+
+  end
+
+end

data/lib/moab/storage_object.rb

@@ -0,0 +1,220 @@
+require 'moab'
+
+module Moab
+
+  # A class to represent a digital object's repository storage location
+  # and methods for
+  # * packaging a bag for ingest of a new object version to the repository
+  # * ingesting a bag
+  # * disseminating a bag containing a reconstructed object version
+  #
+  # ====Data Model
+  # * {StorageRepository} = represents a digital object repository storage node
+  #   * {StorageServices} = supports application layer access to the repository's objects, data, and metadata
+  #   * <b>{StorageObject} = represents a digital object's repository storage location and ingest/dissemination methods</b>
+  #     * {StorageObjectVersion} [1..*] = represents a version subdirectory within an object's home directory
+  #       * {Bagger} [1] = utility for creating bagit packages for ingest or dissemination
+  #
+  # @note Copyright (c) 2012 by The Board of Trustees of the Leland Stanford Junior University.
+  #   All rights reserved.  See {file:LICENSE.rdoc} for details.
+  class StorageObject
+
+    # @return [String] The digital object ID (druid)
+    attr_accessor :digital_object_id
+
+    # @return [Pathname] The location of the object's storage home directory
+    attr_accessor :object_pathname
+
+    # @param object_id [String] The digital object identifier
+    # @param object_dir [Pathname,String] The location of the object's storage home directory
+    def initialize(object_id, object_dir, mkpath=false)
+      @digital_object_id = object_id
+      @object_pathname = Pathname.new(object_dir)
+      initialize_storage if mkpath
+    end
+
+    # @return [Boolean] true if the object's storage directory exists
+    def exist?
+      @object_pathname.exist?
+    end
+
+    # @api external
+    # @return [void] Create the directory for the digital object home unless it already exists
+    def initialize_storage
+        @object_pathname.mkpath
+    end
+
+    # @api external
+    # @param bag_dir [Pathname,String] The location of the bag to be ingested
+    # @return [void] Ingest a new object version contained in a bag into this objects storage area
+    # @example {include:file:spec/features/storage/ingest_spec.rb}
+    def ingest_bag(bag_dir)
+      bag_dir = Pathname.new(bag_dir)
+      current_version = StorageObjectVersion.new(self,current_version_id)
+      current_inventory = current_version.file_inventory('version')
+      new_version = StorageObjectVersion.new(self,current_version_id + 1)
+      if FileInventory.xml_pathname_exist?(bag_dir,'version')
+        new_inventory = FileInventory.read_xml_file(bag_dir,'version')
+      elsif current_version.version_id == 0
+        new_inventory = versionize_bag(bag_dir,current_version,new_version)
+      end
+      validate_new_inventory(new_inventory)
+      new_version.ingest_bag_data(bag_dir)
+      new_version.update_catalog(current_version.signature_catalog,new_inventory)
+      new_version.generate_differences_report(current_inventory,new_inventory)
+      new_version.generate_manifest_inventory
+      new_version
+    end
+
+    # @api internal
+    # @param bag_dir [Pathname] The location of the bag to be ingested
+    # @param current_version[StorageObjectVersion] The current latest version of the object
+    # @param new_version [StorageObjectVersion] The version to be added
+    # @return [FileInventory] The file inventory of the specified type for this version
+    def versionize_bag(bag_dir,current_version,new_version)
+      new_inventory = FileInventory.new(
+          :type=>'version',
+          :digital_object_id=>@digital_object_id,
+          :version_id=>new_version.version_id,
+          :inventory_datetime => Time.now
+      )
+      new_inventory.inventory_from_bagit_bag(bag_dir)
+      new_inventory.write_xml_file(bag_dir)
+      version_additions = current_version.signature_catalog.version_additions(new_inventory)
+      version_additions.write_xml_file(bag_dir)
+      new_inventory
+    end
+
+    # @api external
+    # @param version_id [Integer] The version identifier of the object version to be disseminated
+    # @param bag_dir [Pathname,String] The location of the bag to be created
+    # @return [void] Reconstruct an object version and package it in a bag for dissemination
+    # @example {include:file:spec/features/storage/reconstruct_spec.rb}
+    def reconstruct_version(version_id, bag_dir)
+      storage_version = StorageObjectVersion.new(self,version_id)
+      version_inventory = storage_version.file_inventory('version')
+      signature_catalog = storage_version.signature_catalog
+      bagger = Bagger.new(version_inventory, signature_catalog, bag_dir)
+      bagger.fill_bag(:reconstructor,@object_pathname)
+    end
+
+    # @param [String] catalog_filepath The object-relative path of the file
+    # @return [Pathname] The absolute storage path of the file, including the object's home directory
+    def storage_filepath(catalog_filepath)
+      storage_filepath = @object_pathname.join(catalog_filepath)
+      raise FileNotFoundException, "#{catalog_filepath} missing from storage location #{storage_filepath}" unless storage_filepath.exist?
+      storage_filepath
+    end
+
+    # @api external
+    # @param version_id [Integer] The version identifier of an object version
+    # @return [String] The directory name of the version, relative to the digital object home directory (e.g v0002)
+    def self.version_dirname(version_id)
+      ("v%04d" % version_id)
+    end
+
+    # @return [Array<Integer>] The list of all version ids for this object
+    def version_id_list
+      list = Array.new
+      @object_pathname.children.each do |dirname|
+        vnum = dirname.basename.to_s
+        if vnum.match /^v(\d+)$/
+          list << vnum[1..-1].to_i
+        end
+      end
+      list.sort
+    end
+
+    # @return [Array<StorageObjectVersion>] The list of all versions in this storage object
+    def version_list
+      version_id_list.collect{|id| self.storage_object_version(id)}
+    end
+    alias :versions :version_list
+
+    # @return [Boolean] true if there are no versions yet in this object
+    def empty?
+      version_id_list.empty?
+    end
+
+    # @api external
+    # @return [Integer] The identifier of the latest version of this object, or 0 if no versions exist
+    def current_version_id
+      return @current_version_id unless @current_version_id.nil?
+      list = self.version_id_list
+      version_id = list.empty? ? 0 : list.last
+      @current_version_id = version_id
+    end
+
+    # @return [StorageObjectVersion] The most recent version in the storage object
+    def current_version
+      self.storage_object_version(current_version_id)
+    end
+
+    # @api internal
+    # @param version_inventory [FileInventory] The inventory of the object version to be ingested
+    # @return [Boolean] Tests whether the new version number is one higher than the current version number
+    def validate_new_inventory(version_inventory)
+      if version_inventory.version_id != (current_version_id + 1)
+        raise "version mismatch - current: #{current_version_id} new: #{version_inventory.version_id}"
+      end
+      true
+    end
+
+    # @api external
+    # @param version_id [Integer] The existing version to return.  If nil, return latest version
+    # @return [StorageObjectVersion] The representation of an existing version's storage area
+    def find_object_version(version_id=nil)
+      current = current_version_id
+      case version_id
+        when nil
+          StorageObjectVersion.new(self,current)
+        when 1..current
+          StorageObjectVersion.new(self,version_id)
+        else
+          raise "Version ID #{version_id} does not exist"
+      end
+    end
+
+    # @api external
+    # @param version_id [Integer] The version to return. OK if version does not exist
+    # @return [StorageObjectVersion] The representation of a specified version.
+    # * Version 0 is a special case used to generate empty manifests
+    # * Current version + 1 is used for creation of a new version
+    def storage_object_version(version_id)
+      if version_id
+        StorageObjectVersion.new(self,version_id)
+      else
+        raise "Version ID not specified"
+      end
+    end
+
+    # @return [VerificationResult] Return result of storage verfication
+    def verify_object_storage
+      result = VerificationResult.new(digital_object_id)
+      self.version_list.each do |version|
+        result.subentities << version.verify_version_storage
+      end
+      result.subentities << current_version.verify_signature_catalog
+      result.verified = result.subentities.all?{|entity| entity.verified}
+      result
+    end
+
+    # @param recovery_path [Pathname, String] The location of the recovered object versions
+    # @return [Boolean] Restore all recovered versions to online storage and verify results
+    def restore_object(recovery_path)
+      timestamp = Time.now
+      recovery_object = StorageObject.new(@digital_object_id, recovery_path, mkpath=false)
+      recovery_object.versions.each do |recovery_version|
+        version_id = recovery_version.version_id
+        storage_version = self.storage_object_version(version_id)
+        # rename/save the original
+        storage_version.deactivate(timestamp)
+        # copy the recovered version into place
+        FileUtils.cp_r(recovery_version.version_pathname.to_s,storage_version.version_pathname.to_s)
+      end
+      self
+    end
+
+  end
+
+end

data/lib/moab/storage_object_version.rb

@@ -0,0 +1,333 @@
+require 'moab'
+
+module Moab
+
+  # A class to represent a version subdirectory within an object's home directory in preservation storage
+  #
+  # ====Data Model
+  # * {StorageRepository} = represents a digital object repository storage node
+  #   * {StorageServices} = supports application layer access to the repository's objects, data, and metadata
+  #   * {StorageObject} = represents a digital object's repository storage location and ingest/dissemination methods
+  #     * <b>{StorageObjectVersion} [1..*] = represents a version subdirectory within an object's home directory</b>
+  #       * {Bagger} [1] = utility for creating bagit packages for ingest or dissemination
+  #
+  # @note Copyright (c) 2012 by The Board of Trustees of the Leland Stanford Junior University.
+  #   All rights reserved.  See {file:LICENSE.rdoc} for details.
+  class StorageObjectVersion
+
+    # @return [Integer] The ordinal version number
+    attr_accessor :version_id
+
+    # @return [String] The "v0001" directory name derived from the version id
+    attr_accessor :version_name
+
+    # @return [Pathname] The location of the version inside the home directory
+    attr_accessor :version_pathname
+
+    # @return [Pathname] The location of the object's home directory
+    attr_accessor :storage_object
+
+    # @return [Hash<FileInventory>] Cached copies of versionInventory, versionAdditions, or manifestInventory
+    attr_accessor :inventory_cache
+
+  # @param storage_object [StorageObject] The object representing the digital object's storage location
+  # @param version_id [Integer,String] The ordinal version number or a string like 'v0003'
+    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.match /^v(\d+)$/
+        @version_id = version_id.sub(/^v/,'').to_i
+      else
+        raise "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
+    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)
+    end
+
+    # @return [Boolean] true if the object version directory exists
+    def exist?
+      @version_pathname.exist?
+    end
+
+  # @param [String] file_category The category of file ('content', 'metadata', or 'manifest'))
+  # @param [String] file_id The name of the file (path relative to base directory)
+  # @return [FileSignature] signature of the specified file
+    def find_signature(file_category, file_id)
+      if file_category =~ /manifest/
+        file_inventory('manifests').file_signature('manifests',file_id)
+      else
+        file_inventory('version').file_signature(file_category, file_id)
+      end
+    end
+
+  # @param [String] file_category The category of file ('content', 'metadata', or 'manifest')
+  # @param [String] file_id The name of the file (path relative to base directory)
+  # @return [Pathname] Pathname object containing the full path for the specified file
+    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?
+      raise FileNotFoundException, "manifest file #{file_id} not found for #{@storage_object.digital_object_id} - #{@version_id}" if file_category == 'manifest'
+      file_signature = file_inventory('version').file_signature(file_category, file_id)
+      catalog_filepath = signature_catalog.catalog_filepath(file_signature)
+      @storage_object.storage_filepath(catalog_filepath)
+    end
+
+  # @param [String] file_category The category of file ('content', 'metadata', or 'manifest')
+  # @param [FileSignature] file_signature The signature of the file
+  # @return [Pathname] Pathname object containing the full path for the specified file
+    def find_filepath_using_signature(file_category, file_signature)
+      catalog_filepath = signature_catalog.catalog_filepath(file_signature)
+      @storage_object.storage_filepath(catalog_filepath)
+    end
+
+  # @param [String] file_category The category of file ('content', 'metadata', or 's')
+  # @param [String] file_id The name of the file (path relative to base directory)
+  # @return [Pathname] Pathname object containing this version's storage path for the specified file
+    def file_pathname(file_category, file_id)
+      file_category_pathname(file_category).join(file_id)
+    end
+
+  # @param [String] file_category The category of file ('content', 'metadata', or 's')
+  # @return [Pathname] Pathname object containing this version's storage home for the specified file category
+    def file_category_pathname(file_category)
+      if file_category =~ /manifest/
+        @version_pathname.join('manifests')
+      else
+        @version_pathname.join('data',file_category)
+      end
+    end
+
+    # @api external
+    # @param type [String] The type of inventory to return (version|additions|manifests)
+    # @return [FileInventory] The file inventory of the specified type for this version
+    # @see FileInventory#read_xml_file
+    def file_inventory(type)
+      if version_id > 0
+        return @inventory_cache[type] if @inventory_cache.has_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)}
+        FileInventory.new(
+            :type=>'version',
+            :digital_object_id => @storage_object.digital_object_id,
+            :version_id => @version_id,
+            :groups => groups
+        )
+      end
+    end
+
+    # @api external
+    # @return [SignatureCatalog] The signature catalog of the digital object as of this version
+    def signature_catalog
+      if version_id > 0
+        SignatureCatalog.read_xml_file(@version_pathname.join('manifests'))
+      else
+        SignatureCatalog.new(:digital_object_id => @storage_object.digital_object_id)
+      end
+    end
+
+    # @api internal
+    # @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.to_s}" if @version_pathname.exist?
+      @version_pathname.join('manifests').mkpath
+      bag_dir=Pathname(bag_dir)
+      ingest_dir(bag_dir.join('data'),@version_pathname.join('data'))
+      ingest_file(bag_dir.join(FileInventory.xml_filename('version')),@version_pathname.join('manifests'))
+      ingest_file(bag_dir.join(FileInventory.xml_filename('additions')),@version_pathname.join('manifests'))
+    end
+
+    # @api internal
+    # @param source_dir [Pathname] The source location of the directory whose contents are to be ingested
+    # @param target_dir [Pathname] The target location of the directory into which files are ingested
+    # @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?
+      target_dir.mkpath
+      source_dir.children.each do |child|
+        if child.directory?
+          ingest_dir(child, target_dir.join(child.basename), use_links)
+        else
+          ingest_file(child, target_dir, use_links)
+        end
+      end
+    end
+
+    # @api internal
+    # @param source_file [Pathname] The source location of the file to be ingested
+    # @param target_dir [Pathname] The location of the directory in which to place the file
+    # @param use_links [Boolean] If true, use hard links; if false, make copies
+    # @return [void] link or copy the specified file from source location to the version directory
+    def ingest_file(source_file, target_dir, use_links=true)
+      if use_links
+        FileUtils.link(source_file.to_s, target_dir.to_s) #, :force => true)
+      else
+        FileUtils.copy(source_file.to_s, target_dir.to_s)
+      end
+    end
+
+    # @api internal
+    # @param signature_catalog [SignatureCatalog] The current version's catalog
+    # @param new_inventory [FileInventory] The new version's inventory
+    # @return [void] Updates the catalog to include newly added files, then saves it to disk
+    # @see SignatureCatalog#update
+    def update_catalog(signature_catalog,new_inventory)
+      signature_catalog.update(new_inventory, @version_pathname.join('data'))
+      signature_catalog.write_xml_file(@version_pathname.join('manifests'))
+    end
+
+    # @api internal
+    # @param old_inventory [FileInventory] The old version's inventory
+    # @param new_inventory [FileInventory] The new version's inventory
+    # @return [void] generate a file inventory differences report and save to disk
+    def generate_differences_report(old_inventory,new_inventory)
+      differences = FileInventoryDifference.new.compare(old_inventory, new_inventory)
+      differences.write_xml_file(@version_pathname.join('manifests'))
+    end
+
+    # @api internal
+    # @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)
+      manifest_inventory.groups << FileGroup.new(:group_id=>'manifests').group_from_directory(@version_pathname.join('manifests'), recursive=false)
+      manifest_inventory.write_xml_file(@version_pathname.join('manifests'))
+    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}
+      result
+    end
+
+    # @return [Boolean] return true if the manifest inventory matches the actual files
+    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)
+      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')
+      directory_inventory.digital_object_id = storage_object.digital_object_id
+      directory_group = directory_inventory.group('manifests')
+      directory_group.remove_file_having_path("manifestInventory.xml")
+      # compare the measured signatures against the values in manifestInventory.xml
+      diff = FileInventoryDifference.new
+      diff.compare(manifest_inventory,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
+    end
+
+    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)
+      found = 0
+      missing = Array.new
+      object_pathname = self.storage_object.object_pathname
+      signature_catalog.entries.each do |catalog_entry|
+        storage_location = object_pathname.join(catalog_entry.storage_path)
+        if storage_location.exist?
+          found += 1
+        else
+          missing << storage_location.to_s
+        end
+      end
+      file_result = VerificationResult.new("storage_location")
+      file_result.verified = (found == signature_catalog.file_count)
+      file_result.details = {
+          'expected' => signature_catalog.file_count,
+          'found' => found
+      }
+      file_result.details['missing'] = missing unless missing.empty?
+      result.subentities << file_result
+      result.verified = result.subentities.all?{|entity| entity.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)
+      signature_catalog =self.signature_catalog
+      result.subentities << VerificationResult.verify_value('signature_key',self.composite_key,signature_catalog.composite_key)
+      found = 0
+      missing = Array.new
+      version_inventory.groups.each do |group|
+        group.files.each do |file|
+          file.instances.each do |instance|
+            relative_path = File.join(group.group_id, instance.path)
+            catalog_entry = signature_catalog.signature_hash[file.signature]
+            if ! catalog_entry.nil?
+              found += 1
+            else
+              missing << relative_path.to_s
+            end
+          end
+        end
+      end
+      file_result = VerificationResult.new("catalog_entry")
+      file_result.verified = (found == version_inventory.file_count)
+      file_result.details = {
+          'expected' => version_inventory.file_count,
+          'found' => found
+      }
+      file_result.details['missing'] = missing unless missing.empty?
+
+      result.subentities << file_result
+      result.verified = result.subentities.all?{|entity| entity.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)
+      data_directory = @version_pathname.join('data')
+      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
+    end
+
+    # @param timestamp [Time] The time at which the deactivation was initiated.  Used to name the inactive directory
+    # @return [null] Deactivate this object version by moving it to another directory.  (Used by restore operation)
+    def deactivate(timestamp)
+      if @version_pathname.exist?
+        timestamp_pathname = @version_pathname.parent.join(timestamp.utc.iso8601.gsub(/[-:]/,''))
+        timestamp_pathname.mkpath
+        demote_pathame = timestamp_pathname.join(@version_pathname.basename)
+        @version_pathname.rename(demote_pathame)
+      end
+    end
+
+  end
+
+end