nearline 0.0.4 → 0.0.5

data/lib/nearline.rb

@@ -15,5 +15,8 @@ require 'nearline/archived_file'
 require 'nearline/log'
 require 'nearline/manifest'
 
+# Non-AR model
+require 'nearline/file_sequencer'
+
 # Static methods on Nearline
 require 'nearline/module_methods'

data/lib/nearline/archived_file.rb

@@ -4,106 +4,43 @@ module Nearline
     # Represents file metadata and possible related FileContent
     # for a single file on a single system
     class ArchivedFile < ActiveRecord::Base
+      require 'digest/sha1'
       require 'fileutils'
       
       belongs_to :file_content
       belongs_to :system
       has_and_belongs_to_many :manifests
       
-            
-      def self.create_for(file_path, manifest)        
-        file_information = FileInformation.new(file_path, manifest)
-
-        # The path doesn't actually exist and fails a File.stat
+           
+      def self.create_for(file_information)
+        # The path doesn't actually exist and fails a File.lstat
         return nil if file_information.path_hash.nil?
-
-        # If we find an exising entry, use it
-        hash = manifest.system.archived_file_lookup_hash
-        hit = hash[file_information.path_hash]
-
-        unless hit.nil?
-          af = ArchivedFile.find(hit)
-          manifest.archived_files << af
-          return af
-        end
         
         # We need to create a record for either a directory or file
         archived_file = ArchivedFile.new(
           file_information.archived_file_parameters
         )
-        
+
         # Find a new directory
         if (file_information.is_directory)
           archived_file.save!
-          manifest.archived_files << archived_file
+          file_information.manifest.archived_files << archived_file
           return archived_file
         end
         
-        # Find a new file that needs persisted
+        # Find a new file that needs persisted        
         archived_file.file_content.file_size = 
           [file_information.stat.size].pack('Q').unpack('L').first # HACK for Windows
-        archived_file = archived_file.persist(manifest)
-        archived_file.save! unless archived_file.nil?
-        manifest.archived_files << archived_file
+        archived_file = archived_file.persist(file_information.manifest)
+        unless archived_file.nil? || archived_file.frozen?
+          archived_file.save!
+          file_information.manifest.archived_files << archived_file
+        end
         archived_file
         
         # TODO: Symbolic links, block devices, ...?
       end
-      
-      class FileInformation
-        attr_reader :path_hash, :stat, :is_directory, :archived_file_parameters
-        def initialize(file_path, manifest)
-          @manifest = manifest
-          @file_path = file_path
-          @stat = read_stat
-          @is_directory = File.directory?(file_path)
-          @path_hash = generate_path_hash
-          @archived_file_parameters = build_parameters
-        end
-
-        def read_stat
-          stat = nil
-          begin
-            stat = File.stat(@file_path)
-          rescue
-            @manifest.add_log("File not found on stat: #{@file_path}")
-          end
-          stat
-        end
-
-        def generate_path_hash
-          return nil if @stat.nil?          
-          target = [@manifest.system.name, 
-            @file_path,
-            @stat.uid,
-            @stat.gid,
-            @stat.mtime.to_i,
-            @stat.mode].join(':')
-          Digest::SHA1.hexdigest(target)
-        end
-        
-        def file_content_entry_for_files_only
-          return FileContent.new unless @is_directory
-          return nil
-        end
-
-        def build_parameters
-          return nil if @stat.nil?
-          {
-            :system => @manifest.system,
-            :path => @file_path,
-            :path_hash => @path_hash,
-            :file_content => file_content_entry_for_files_only,
-            :uid => @stat.uid,
-            :gid => @stat.gid,
-            :mtime => @stat.mtime.to_i,
-            :mode => @stat.mode,
-            :is_directory => @is_directory    
-          }
-        end
-
-      end
-      
+            
       def restore(*args)
         @options = args.extract_options!
         if (self.is_directory)
@@ -158,20 +95,20 @@ module Nearline
       # won't know that until we complete the process and have to
       # clean up our mess.
       def persist(manifest)
-        whole_file_hash = Digest::SHA1.new
-        file_size = 0
+        seq = nil
         begin
-          file_size = read_file_counting_bytes(whole_file_hash)
+          seq = read_file
         rescue
-          manifest.add_log "Got error '#{$!}' on path: #{self.path}"
+          error = "Got error '#{$!}' on path: #{self.path}"
+          manifest.add_log error
           self.orphan_check
           return nil
         end
-        
-        size_check(file_size, manifest)
+               
+        size_check(seq.file_size, manifest)
         
         # Do we have a unique sequence?
-        key = whole_file_hash.hexdigest
+        key = seq.fingerprint
         return self if unique_sequence_processed?(key, manifest)
                 
         # Handle the case where the sequence is not unique...
@@ -180,19 +117,14 @@ module Nearline
         self
       end
       
-      def read_file_counting_bytes(whole_file_hash)
-        sequencer = FileSequencer.new(self.file_content)
-        file_size = 0
-        buffer = ""
+      def read_file
         File.open(self.path, "rb") do |io|
-          while (!io.eof) do
-            io.read(Block::MAX_SIZE, buffer)
-            file_size += buffer.size
-            whole_file_hash.update(buffer)
-            sequencer.preserve_content(buffer)
+          seq = FileSequencer.new(io, self.file_content)
+          while (!io.eof)
+            seq.persist_segment
           end
+          return seq
         end
-        return file_size
       end
             
       def size_check(file_size, manifest)
@@ -222,10 +154,15 @@ module Nearline
         false
       end
       
+      # In the special case of an identical sequence existing,
+      # we can safely delete all related sequences and then destroy
+      # the file content object without the (far slower) orphan checking
+      # process
       def clean_up_duplicate_content
-        self.file_content.orphan_check
+        Sequence.delete_all "file_content_id = #{self.file_content.id}"
+        self.file_content.destroy
       end
-      
+
       def replace_content(key)
         self.file_content = FileContent.find_by_fingerprint(key)
         self.save!                

data/lib/nearline/block.rb

@@ -12,12 +12,21 @@ module Nearline
     
       has_many :sequences
       
-      MAX_SIZE = (64 * 1024)-1
+      # Maximum block size in bytes
+      @@max_block_size = (64 * 1024)-1
+      cattr_accessor :max_block_size
+      
+      # Level of block compression attempted
+      # 0 = skip compression entirely
+      @@block_compression_level = 5
+      cattr_accessor :block_compression_level
       
       def attempt_compression
-        return if (self.is_compressed)
-        # TODO: Have a bump-the-compression option, here?
-        candidate_content = Zlib::Deflate.deflate(self.bulk_content)
+        return if (self.is_compressed || @@block_compression_level == 0)
+        candidate_content = Zlib::Deflate.deflate(
+          self.bulk_content,
+          @@block_compression_level
+        )
         if candidate_content.length < self.bulk_content.length
           self.is_compressed = true
           self.bulk_content = candidate_content
@@ -37,31 +46,7 @@ module Nearline
         end
         @content = self.bulk_content
       end
-      
-      def self.id_for_content(x)
-        block = Block.new(:bulk_content => x)
-        block.calculate_fingerprint
-        hit = Block.connection.select_one(
-          "select id from blocks where fingerprint='#{block.fingerprint}'"
-        )
-        unless hit.nil?
-          return hit['id']
-        end
-        block.attempt_compression
-        block.save!
-        block.id
-      end
-
-      def self.for_content(x)
-        block = Models::Block.new(:bulk_content => x)
-        block.calculate_fingerprint
-        found = find_by_fingerprint(block.fingerprint)
-        return found if !found.nil?
-        block.attempt_compression
-        block.save!
-        block
-      end
-      
+            
       def orphan_check
         if self.sequences.size == 0
           self.destroy

data/lib/nearline/file_content.rb

@@ -4,7 +4,7 @@ module Nearline
     # Has the responsibility of identifying, restoring and
     # verifying content
     class FileContent < ActiveRecord::Base
-      has_many :sequences
+      has_many :sequences, :order => "sequence"
       has_many :archived_files
       
       def orphan_check
@@ -23,22 +23,25 @@ module Nearline
         return hit.nil?
       end
       
-      def restore_to(io)
+      private
+      
+      def each_sequence
         sequences.each do |seq|
           block = Block.find(seq.block_id)
-          io.write(block.content)
+          yield block
         end
       end
+      
+      public
+      
+      def restore_to(io)
+        each_sequence { |block| io.write(block.content) }
+      end
     
       def verified?
-        if (!self.verified_at.nil?)
-          return true
-        end
+        return true if (!self.verified_at.nil?)
         whole_file_hash = Digest::SHA1.new
-        sequences.each do |seq|
-          block = Block.find(seq.block_id)
-          whole_file_hash.update(block.content)
-        end
+        each_sequence { |block| whole_file_hash.update(block.content) }
         if fingerprint == whole_file_hash.hexdigest
           self.verified_at = Time.now
           self.save!
@@ -47,7 +50,6 @@ module Nearline
         false
       end
       
-      
     end
     
     # Has the responsibility of preserving
@@ -61,26 +63,5 @@ module Nearline
       end
     end
     
-    class FileSequencer
-      def initialize(file_content)
-        @inc = 0
-        @file_content = file_content
-        @file_content.save!
-      end
-      
-      def preserve_content(content)
-        @inc += 1
-        block_id = Block.id_for_content(content)
-        sequence = Sequence.new(
-          :sequence => @inc,
-          :file_content_id => @file_content.id,
-          :block_id => block_id
-        )
-        sequence.save!
-        sequence        
-      end
-            
-    end
-      
   end
 end

data/lib/nearline/file_sequencer.rb

@@ -0,0 +1,130 @@
+module Nearline
+  module Models
+
+    # Used for mass block entry and sequencing
+    class FileSequencer      
+      attr_reader :file_size
+    
+      # Number of blocks to serialize in a batch
+      @@max_blocks = 500;
+      cattr_accessor :max_blocks
+      
+      def initialize(io, file_content)
+        @io = io
+        @file_content = file_content
+        if (@file_content.id.nil?)
+          @file_content.save!
+        end
+        @s = []
+        @b = []
+        @file_size = 0
+        @offset = 0
+        @whole_file_hash = Digest::SHA1.new
+      end
+      
+      def fingerprint
+        @whole_file_hash.hexdigest
+      end
+      
+      def persist_segment
+        pull_blocks
+        sequence_known_blocks      
+        attempt_compression_of_remaining_blocks
+        insert_new_blocks
+        sequence_known_blocks
+        insert_sequences
+        clear_for_next_persist
+      end
+      
+      private
+      
+      def clear_for_next_persist
+        @s = []
+        @b = []
+        @offset += @@max_blocks
+      end
+    
+      def sequence_known_blocks
+        f = found_fingerprint_map
+        add_sequence_entries_clearing_blocks(f)
+      end
+      
+      def found_fingerprint_map
+        f = {}
+        fp_raw = []
+        @b.each {|a| fp_raw << a.fingerprint unless a.nil?}
+        return f if fp_raw.size == 0
+        fingerprints = fp_raw.collect {|fp| "'#{fp}'"}.join(', ')
+        query = "select distinct id, fingerprint from blocks "+
+          "where fingerprint in (#{fingerprints})"
+        r = Nearline::Models::Block.connection.select_all(query)
+        r.each { |e| f[e["fingerprint"]] = e["id"] }
+        f
+      end
+      
+      def add_sequence_entries_clearing_blocks(f)
+        @b.size.times do |i|
+          block = @b[i]
+          unless block.nil?
+            if f[block.fingerprint]
+              @s.push(Sequence.new(
+                  :sequence => i + @offset + 1,
+                  :block_id => f[block.fingerprint],
+                  :file_content_id => @file_content.id
+                ))
+              @b[i] = nil
+            end
+          end
+        end
+      end
+      
+      def insert_sequences
+        @s.each do |s|
+          s.save!
+        end
+      end
+      
+      def attempt_compression_of_remaining_blocks
+        f = {}
+        @b.each do |block|
+          unless block.nil? or f[block.fingerprint]
+            block.attempt_compression
+            f[block.fingerprint] = true
+          end
+        end
+      end
+
+      def insert_new_blocks
+        f = {}
+        @b.each do |b|
+          unless b.nil? || f[b.fingerprint]
+            b.save!
+            f[b.fingerprint] = true
+          end
+        end
+      end
+      
+      def pull_blocks
+        count = 0
+        while (!@io.eof && count < @@max_blocks)
+          count += 1
+          
+          # Move to Block
+          buffer = @io.read(Block.max_block_size)
+          
+          @file_size += buffer.size
+          
+          # Move to Block
+          blk = Block.new(:bulk_content => buffer)
+          @whole_file_hash.update(buffer)
+          
+          # Move to Block
+          blk.calculate_fingerprint
+          @b << blk          
+        end
+      end
+          
+    end
+    
+  end
+end

data/lib/nearline/manifest.rb

@@ -5,10 +5,7 @@ module Nearline
     class FileFinder
       require 'find'
       def self.recurse(paths, exclusions)
-        regex_exclusions = []
-        for exclusion in exclusions
-          regex_exclusions << /#{exclusion}/
-        end
+        regex_exclusions = exclusion_regexes(exclusions)
         paths.each do |path|
           Find.find(path) do |f|
             regex_exclusions.each do |ex|
@@ -18,6 +15,72 @@ module Nearline
           end
         end
       end
+      
+      def self.exclusion_regexes(exclusions)
+        regex_exclusions = []
+        for exclusion in exclusions
+          regex_exclusions << /#{exclusion}/
+        end
+        regex_exclusions
+      end
+    end
+    
+    # Handles file paths and metadata for a file in a manifest
+    class FileInformation
+      attr_reader :path_hash, :stat, :is_directory,
+        :archived_file_parameters, :manifest, :file_path
+      
+      def initialize(file_path, manifest)
+        @manifest = manifest
+        @file_path = file_path
+        @stat = read_stat
+        @is_directory = File.directory?(file_path)
+        @path_hash = generate_path_hash
+        @archived_file_parameters = build_parameters
+      end
+
+      def read_stat
+        stat = nil
+        begin
+          # TODO: change to lstat when we handle links
+          stat = File.stat(@file_path)
+        rescue
+          @manifest.add_log("File not found on stat: #{@file_path}")
+        end
+        stat
+      end
+
+      def generate_path_hash
+        return nil if @stat.nil?          
+        target = [@manifest.system.name, 
+          @file_path,
+          @stat.uid,
+          @stat.gid,
+          @stat.mtime.to_i,
+          @stat.mode].join(':')
+        Digest::SHA1.hexdigest(target)
+      end
+        
+      def file_content_entry_for_files_only
+        return FileContent.new unless @is_directory
+        return nil
+      end
+
+      def build_parameters
+        return nil if @stat.nil?
+        {
+          :system => @manifest.system,
+          :path => @file_path,
+          :path_hash => @path_hash,
+          :file_content => file_content_entry_for_files_only,
+          :uid => @stat.uid,
+          :gid => @stat.gid,
+          :mtime => @stat.mtime.to_i,
+          :mode => @stat.mode,
+          :is_directory => @is_directory    
+        }
+      end
+
     end
     
     # A Manifest represents the corpus of ArchivedFiles and
@@ -32,7 +95,11 @@ module Nearline
       attr_accessor :backup_paths
       # Just needed when you create a manifest
       attr_accessor :backup_exclusions
-            
+      
+      # Maximum number of files to stat and process in a batch
+      @@max_files_cached = 10000
+      cattr_accessor :max_files_cached
+      
       def self.new_for_name(system_name)
         system = System.for_name(system_name)
         system.manifests << m = Nearline::Models::Manifest.new
@@ -43,10 +110,44 @@ module Nearline
       def self.backup(system, backup_paths, backup_exclusions)
         manifest = self.new(:system => system)
         manifest.save!
+        manifest.backup(backup_paths, backup_exclusions)
+      end
+      
+      def backup(backup_paths, backup_exclusions)
+        FileFinder.recurse(backup_paths, backup_exclusions) do |file_path|
+          handle_file_path(file_path)
+        end
+        finish_remaining_file_infos
         
-        FileFinder.recurse(backup_paths, backup_exclusions) do |file_name|
-          $stdout.write file_name + " "
-          af = ArchivedFile.create_for(file_name, manifest)
+        self.completed_at = Time.now
+        self.save!
+        self        
+      end
+      
+      def handle_file_path(file_path)
+        @file_infos = @file_infos || []
+        @file_infos << FileInformation.new(file_path, self)
+        
+        if @file_infos.size > @@max_files_cached
+          process_file_infos
+        end
+      end
+      
+      def finish_remaining_file_infos
+        process_file_infos
+      end
+      
+      def process_file_infos
+        return if @file_infos.size == 0
+
+        lookup = existing_archived_file_lookup        
+        @file_infos.each do |file_info|
+          $stdout.write file_info.file_path + " "
+          if (af = lookup[file_info.path_hash])
+            self.archived_files << af
+          else
+            af = ArchivedFile.create_for(file_info)            
+          end
           if (!af.nil?)
             $stdout.write "#{Time.at(af.mtime).asctime}"
             if (!af.file_content.nil?)
@@ -55,12 +156,18 @@ module Nearline
             $stdout.write("\n")
           end
         end
-
-        manifest.completed_at = Time.now
-        manifest.save!
-        manifest
+        @file_infos = []
       end
       
+      def existing_archived_file_lookup
+        return {} if @file_infos.size == 0
+        path_hashes = @file_infos.collect {|e| "'#{e.path_hash}'"}.join(", ")
+        conditions = "path_hash in (#{path_hashes})"
+        hits = ArchivedFile.find(:all, :conditions => conditions)
+        existing_files = {}
+        hits.each { |e| existing_files[e.path_hash] = e }
+        existing_files
+      end
       
       # Find all Manifest entries (across all Systems) which have never finished.
       # 
@@ -73,17 +180,24 @@ module Nearline
       
       def self.restore_all_missing(system, latest_date_time = Time.now)
         manifest = system.latest_manifest_as_of(latest_date_time)
-        manifest.restore_all_missing
+        manifest.iterate_all_missing do |af|
+          af.restore
+        end 
       end
       
-      # Restore all missing files from this manifest back to the filesystem
-      def restore_all_missing
+      def self.what_would_restore(system, latest_date_time = Time.now)
+        manifest = system.latest_manifest_as_of(latest_date_time)        
+        manifest.iterate_all_missing {}
+      end
+      
+      # Iterate all missing files from this manifest, yielding each
+      def iterate_all_missing
         files_restored = []
         self.archived_files.each do |af|
           begin
             File.stat(af.path)
           rescue
-            af.restore
+            yield af
             files_restored << af.path
           end
         end
@@ -97,14 +211,83 @@ module Nearline
       end
       
       def before_destroy
-        archived_files.each do |af|
+        destroy_archived_files_with_content
+        destroy_archived_files_without_content
+        destroy_archived_files_manifests
+        destroy_logs
+        self.destroy_without_habtm_shim_for_archived_files
+      end
+      
+      private
+      
+      def  archived_file_content_query(op)
+        <<-END_SQL
+select distinct fc.id
+ from archived_files af,
+ archived_files_manifests afm, file_contents fc
+ where
+ afm.manifest_id #{op} #{self.id} and
+ afm.archived_file_id = af.id and
+ af.file_content_id = fc.id      
+        END_SQL
+      end
+      
+      def destroy_archived_files_with_content
+
+        fc_in = self.connection.select_all(archived_file_content_query("=")).collect{|e| e["id"]}
+        fc_out = self.connection.select_all(archived_file_content_query("!=")).collect{|e| e["id"]}
+        fc_to_destroy = (fc_in - fc_out).join ", "
+
+        if (fc_to_destroy.size > 0)
+          af_to_destroy = self.connection.select_all(<<-END_QUERY
+select af.id from archived_files af, archived_files_manifests afm
+where afm.manifest_id=#{self.id} and afm.archived_file_id = af.id and 
+af.file_content_id in (#{fc_to_destroy})
+            END_QUERY
+          ).collect{|e| e["id"]}
+        else
+          af_to_destroy = []
+        end
+                
+        Nearline::Models::ArchivedFile.find(af_to_destroy).each do |af|
+          af.orphan_check
+        end 
+      end
+      
+      def archived_files_query(op)
+        <<-END_QUERY
+select distinct af.id
+ from archived_files af,
+ archived_files_manifests afm
+ where af.file_content_id is null and
+ af.id = afm.archived_file_id and
+ afm.manifest_id #{op} #{self.id}                  
+        END_QUERY
+      end
+      
+      def destroy_archived_files_without_content
+        af_in = self.connection.select_all(archived_files_query("=")).collect{|e| e["id"]}        
+        af_out = self.connection.select_all(archived_files_query("!=")).collect{|e| e["id"]}
+
+        af_to_destroy = Nearline::Models::ArchivedFile.find(af_in - af_out)
+        af_to_destroy.each do |af|
           af.orphan_check
         end
+      end
+    
+
+      def destroy_archived_files_manifests
+        self.connection.delete("delete from archived_files_manifests where manifest_id=#{self.id}")
+      end
+      
+      def destroy_logs
         logs.each do |log|
           log.destroy
-        end
+        end        
       end
       
+      public
+      
       def total_size
         size = 0
         archived_files.each do |af|

data/lib/nearline/module_methods.rb

@@ -1,8 +1,10 @@
 module Nearline  
   module_function
 
-  # VERSION of the software
-  VERSION = "0.0.4"
+  # Version of the software
+  VERSION = "0.0.5"
+  # Last version that changed the database structure
+  DB_VERSION = "0.0.4"
   
   # Array of every Nearline Model using an ActiveRecord connection
   AR_MODELS = Nearline::Models.constants.map do |m|
@@ -21,6 +23,8 @@ module Nearline
   # Stomps on any ActiveRecord::Base.establish_connection you might
   # have already established.
   # 
+  # ***NOTE: MYSQL is the only recommended database at this time.***
+  # 
   # === Examples
   # Nearline.connect!({:adapter => 'sqlite3', :database => 'data/sqlite.db'})
   # 
@@ -49,6 +53,9 @@ module Nearline
   # 
   # Accepts a Hash to establish the connection or
   # a String referring to an entry in config/database.yml.
+  # 
+  # ***NOTE: MYSQL is the only recommended database at this time.***
+  # 
   # === Examples
   # Nearline.connect({:adapter => 'sqlite3', :database => 'data/sqlite.db'})
   # 
@@ -90,9 +97,7 @@ module Nearline
   # Nearline.backup('my_laptop', ['/home/me', '/var/svn']
   #
   def backup(system_name, backup_paths,backup_exclusions= [])
-    unless version_check?
-      raise SchemaVersionException.for_version(schema_version)
-    end    
+    raise_failing_version_check
     Nearline::Models::System.backup(
       system_name,
       Utilities.string_to_array(backup_paths),
@@ -120,13 +125,17 @@ module Nearline
   # 
   # Returns an Array of paths restored
   def restore(system_name, latest_date_time = Time.now)
-    unless version_check?
-      raise SchemaVersionException.for_version(schema_version)
-    end    
+    raise_failing_version_check
     Nearline::Models::System.restore_all_missing(system_name, latest_date_time)
   end
   
-  
+  # Returns an array of paths that would be restored given the provided
+  # parameters
+  def what_would_restore(system_name, latest_date_time = Time.now)
+    raise_failing_version_check
+    Nearline::Models::System.what_would_restore(system_name, latest_date_time)
+  end
+    
   # Returns the nearline version of the database
   def schema_version
     begin
@@ -138,15 +147,23 @@ module Nearline
     end    
   end
   
+  def raise_failing_version_check
+    unless version_check?
+      raise SchemaVersionException.for_version(schema_version)
+    end        
+  end
+  
   # Returns true only if the Nearline version matches the schema
   def version_check?
-    Nearline::VERSION == schema_version()
+    Nearline::DB_VERSION == schema_version()
   end
   
   class SchemaVersionException < Exception
     def self.for_version(v)
-      SchemaVersionException.new("Schema #{v} is not the same "+
-          "version as nearline #{Nearline::VERSION}!")
+      SchemaVersionException.new(<<-END_ERROR)
+Schema #{v} is not the same version as nearline database 
+version #{Nearline::DB_VERSION} used in Nearline #{Nearline::VERSION}!        
+      END_ERROR
     end
   end
   

data/lib/nearline/schema.rb

@@ -18,7 +18,7 @@ module Nearline
     end
     
     def empty_schema
-      Nearline::Models::Manifest.destroy_all
+      Nearline::Models::System.destroy_all
     end
     
     def generate_schema
@@ -99,7 +99,7 @@ module Nearline
           t.column :version, :string
         end
         
-        execute "insert into nearline_version (version) values ('#{Nearline::VERSION}')"        
+        execute "insert into nearline_version (version) values ('#{Nearline::DB_VERSION}')"        
       end
     end
 

data/lib/nearline/system.rb

@@ -52,15 +52,15 @@ module Nearline
         Manifest.restore_all_missing(self, latest_date_time)
       end
       
-      def archived_file_lookup_hash
-        return @lookup_hash if !@lookup_hash.nil?
-        @lookup_hash = {}
-        for af in self.archived_files
-          @lookup_hash[af.path_hash] = af.id
-        end
-        @lookup_hash
+      def self.what_would_restore(system_name, latest_date_time)
+        system = self.for_name(system_name)
+        system.what_would_restore(latest_date_time)
       end
       
+      def what_would_restore(latest_date_time = Time.now)
+        Manifest.what_would_restore(self, latest_date_time)
+      end
+            
       def before_destroy
         for manifest in self.manifests
           manifest.destroy

data/tasks/gemspec.rake

@@ -9,6 +9,7 @@ SPEC = Gem::Specification.new do |s|
   s.version = Nearline::VERSION
   s.author = "Robert J. Osborne"
   s.email = "rjo1970@gmail.com"
+  s.homepage = "http://rubyforge.org/projects/nearline"
   s.summary = "Nearline is a near-line backup and recovery solution"
   s.description = %{
     Nearline is a library to make managing near-line file repositories
@@ -18,7 +19,6 @@ SPEC = Gem::Specification.new do |s|
   s.files = FileList["{tests,lib,doc,tasks}/**/*"].exclude("rdoc").to_a
   s.add_dependency("activerecord", '>= 2.0.2')
   s.require_path = "lib"
-  s.autorequire = "nearline"
   s.test_file = "test/nearline_test.rb"
   s.has_rdoc = true
 end

metadata

@@ -1,67 +1,75 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: nearline
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
-date: 2008-04-18 00:00:00 -04:00
-summary: Nearline is a near-line backup and recovery solution
-require_paths: 
-- lib
-email: rjo1970@gmail.com
-homepage: 
-rubyforge_project: nearline
-description: Nearline is a library to make managing near-line file repositories simple and elegant in pure Ruby.
-autorequire: nearline
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.0.5
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Robert J. Osborne
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-22 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: 
+description: Nearline is a library to make managing near-line file repositories simple and elegant in pure Ruby.
+email: rjo1970@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
 files: 
 - lib/nearline
-- lib/nearline/archived_file.rb
+- lib/nearline/schema.rb
+- lib/nearline/system.rb
+- lib/nearline/module_methods.rb
+- lib/nearline/file_sequencer.rb
 - lib/nearline/block.rb
-- lib/nearline/file_content.rb
 - lib/nearline/log.rb
+- lib/nearline/archived_file.rb
+- lib/nearline/file_content.rb
 - lib/nearline/manifest.rb
-- lib/nearline/module_methods.rb
-- lib/nearline/schema.rb
-- lib/nearline/system.rb
 - lib/nearline.rb
-- tasks/clean.rake
 - tasks/gemspec.rake
-- tasks/rcov.rake
+- tasks/clean.rake
 - tasks/test.rake
-test_files: 
-- test/nearline_test.rb
+- tasks/rcov.rake
+has_rdoc: true
+homepage: http://rubyforge.org/projects/nearline
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activerecord
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.0.2
-    version: 
+rubyforge_project: nearline
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: Nearline is a near-line backup and recovery solution
+test_files: 
+- test/nearline_test.rb