nearline 0.0.1 → 0.0.2

data/lib/nearline/archived_file.rb

@@ -1,224 +1,225 @@
-module Nearline
-  module Models
-    
-    # Represents file metadata and possible related FileContent
-    # for a single file on a single system
-    class ArchivedFile < ActiveRecord::Base
-      belongs_to :file_content
-      has_and_belongs_to_many :manifests
-            
-      def self.create_for(system_name, file_path, manifest)
-        
-        file_information = FileInformation.new(system_name, file_path, manifest)
-
-        # The path doesn't actually exist and fails a File.stat
-        return nil if file_information.path_hash.nil?
-
-        # If we find an exising entry, use it
-        hit = self.find_by_path_hash(file_information.path_hash)
-        return hit unless hit.nil?
-        
-        # 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!
-          return archived_file
-        end
-        
-        # 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.persist(manifest)
-        archived_file.save!
-        archived_file
-        
-        # TODO: Symbolic links, block devices, ...?
-      end
-      
-      class FileInformation
-        attr_reader :path_hash, :stat, :is_directory, :archived_file_parameters
-        def initialize(system_name, file_path, manifest)
-          @manifest = manifest
-          @stat = read_stat(file_path)
-          @is_directory = File.directory?(file_path)
-          @path_hash = generate_path_hash(system_name, file_path)
-          @archived_file_parameters = build_parameters(system_name, file_path)
-        end
-
-        def read_stat(file_path)
-          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(system_name, file_path)
-          return nil if @stat.nil?          
-          target = [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.fresh_entry unless @is_directory
-          return nil
-        end
-
-        def build_parameters(system_name, file_path)
-          return nil if @stat.nil?
-          {
-            :system_name => system_name,
-            :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)
-          FileUtils.mkdir_p option_override(:path)
-          restore_metadata
-          return
-        end
-        target_path = File.dirname(option_override(:path))
-        if (!File.exist? target_path)
-          FileUtils.mkdir_p target_path
-        end
-        f = File.open(option_override(:path), "wb")
-        self.file_content.restore_to(f)
-        f.close
-        restore_metadata
-        return
-      end
-      
-      def option_override(key)
-        if (@options.has_key?(key))
-          return @options[key]
-        end
-        return self.send(key.to_s)
-      end
-      
-      def restore_metadata
-        path = option_override(:path)
-        mtime = option_override(:mtime)
-        uid = option_override(:uid)
-        gid = option_override(:gid)
-        mode = option_override(:mode)
-        File.utime(0,Time.at(mtime),path)
-        File.chown(uid, gid, path)
-        File.chmod(mode, path)
-      end
-      
-      def before_destroy
-        self.file_content.orphan_check if !self.file_content.nil?
-      end
-      
-      def orphan_check
-        if self.manifests.size == 1
-          self.destroy
-        end
-      end
-      
-      # Actually persist the file to the repository
-      # It has already been determined that a new ArchivedFile record is
-      # necessary and the file requires persisting
-      # 
-      # But, the content may be identical to something else, and we
-      # 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
-        begin
-          file_size = read_file_counting_bytes(whole_file_hash)
-        rescue
-          manifest.add_log "Got error '#{$!}' on path: #{self.path}"
-          self.orphan_check
-          return nil
-        end
-        
-        size_check(file_size, manifest)
-        
-        # Do we have a unique sequence?
-        key = whole_file_hash.hexdigest
-        return self if unique_sequence_processed?(key, manifest)
-                
-        # Handle the case where the sequence is not unique...
-        clean_up_duplicate_content
-        replace_content(key)
-        self
-      end
-      
-      def read_file_counting_bytes(whole_file_hash)
-        sequencer = FileSequencer.new(self.file_content)
-        file_size = 0
-        buffer = ""
-        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)
-            block = Block.for_content(buffer)              
-            sequencer.preserve_block(block)
-          end
-        end
-        return file_size
-      end
-            
-      def size_check(file_size, manifest)
-        if file_size != self.file_content.file_size
-          manifest.add_log "recorded file length #{file_size} " +
-            "does not match #{self.file_content.file_size} " +
-            "reported by the file system on path: #{self.path}"
-        end        
-      end
-      
-      def verify_content(manifest)
-        unless (self.file_content.verified?)
-          manifest.add_log "failed verification on path: #{self.path}"
-        end        
-      end
-      
-      def unique_sequence_processed?(key,manifest)
-        if self.file_content.unique_fingerprint?(key)
-          self.file_content.fingerprint = key
-          self.file_content.save!
-          verify_content(manifest)
-          return true
-        end
-        false
-      end
-      
-      def clean_up_duplicate_content
-        Sequence.delete_all("file_content_id=#{self.file_content.id}")
-        self.file_content.orphan_check
-      end
-      
-      def replace_content(key)
-        self.file_content = FileContent.find_by_fingerprint(key)
-        self.save!                
-      end
-      
-    end
-
-  end
+module Nearline
+  module Models
+    
+    # Represents file metadata and possible related FileContent
+    # for a single file on a single system
+    class ArchivedFile < ActiveRecord::Base
+      belongs_to :file_content
+      has_and_belongs_to_many :manifests
+            
+      def self.create_for(system_name, file_path, manifest)
+        
+        file_information = FileInformation.new(system_name, file_path, manifest)
+
+        # The path doesn't actually exist and fails a File.stat
+        return nil if file_information.path_hash.nil?
+
+        # If we find an exising entry, use it
+        hit = self.find_by_path_hash(file_information.path_hash)
+        return hit unless hit.nil?
+        
+        # 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!
+          return archived_file
+        end
+        
+        # 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.persist(manifest)
+        archived_file.save!
+        archived_file
+        
+        # TODO: Symbolic links, block devices, ...?
+      end
+      
+      class FileInformation
+        attr_reader :path_hash, :stat, :is_directory, :archived_file_parameters
+        def initialize(system_name, file_path, manifest)
+          @manifest = manifest
+          @stat = read_stat(file_path)
+          @is_directory = File.directory?(file_path)
+          @path_hash = generate_path_hash(system_name, file_path)
+          @archived_file_parameters = build_parameters(system_name, file_path)
+        end
+
+        def read_stat(file_path)
+          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(system_name, file_path)
+          return nil if @stat.nil?          
+          target = [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.fresh_entry unless @is_directory
+          return nil
+        end
+
+        def build_parameters(system_name, file_path)
+          return nil if @stat.nil?
+          {
+            :system_name => system_name,
+            :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)
+          FileUtils.mkdir_p option_override(:path)
+          restore_metadata
+          return
+        end
+        target_path = File.dirname(option_override(:path))
+        if (!File.exist? target_path)
+          FileUtils.mkdir_p target_path
+        end
+        f = File.open(option_override(:path), "wb")
+        self.file_content.restore_to(f)
+        f.close
+        restore_metadata
+        return
+      end
+      
+      def option_override(key)
+        if (@options.has_key?(key))
+          return @options[key]
+        end
+        return self.send(key.to_s)
+      end
+      
+      def restore_metadata
+        path = option_override(:path)
+        mtime = option_override(:mtime)
+        uid = option_override(:uid)
+        gid = option_override(:gid)
+        mode = option_override(:mode)
+        File.utime(0,Time.at(mtime),path)
+        File.chown(uid, gid, path)
+        File.chmod(mode, path)
+      end
+      
+      def before_destroy
+        self.file_content.orphan_check if !self.file_content.nil?
+      end
+      
+      def orphan_check
+        if self.manifests.size == 1
+          self.destroy
+        end
+      end
+      
+      # Actually persist the file to the repository
+      # It has already been determined that a new ArchivedFile record is
+      # necessary and the file requires persisting
+      # 
+      # But, the content may be identical to something else, and we
+      # 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
+        begin
+          file_size = read_file_counting_bytes(whole_file_hash)
+        rescue
+          manifest.add_log "Got error '#{$!}' on path: #{self.path}"
+          self.orphan_check
+          return nil
+        end
+        
+        size_check(file_size, manifest)
+        
+        # Do we have a unique sequence?
+        key = whole_file_hash.hexdigest
+        return self if unique_sequence_processed?(key, manifest)
+                
+        # Handle the case where the sequence is not unique...
+        clean_up_duplicate_content
+        replace_content(key)
+        self
+      end
+      
+      def read_file_counting_bytes(whole_file_hash)
+        sequencer = FileSequencer.new(self.file_content)
+        file_size = 0
+        buffer = ""
+        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)
+            block = Block.for_content(buffer)              
+            sequencer.preserve_block(block)
+          end
+        end
+        return file_size
+      end
+            
+      def size_check(file_size, manifest)
+        if file_size != self.file_content.file_size
+          manifest.add_log "recorded file length #{file_size} " +
+            "does not match #{self.file_content.file_size} " +
+            "reported by the file system on path: #{self.path}"
+        end        
+      end
+      
+      def verify_content(manifest)
+        unless (self.file_content.verified?)
+          manifest.add_log "failed verification on path: #{self.path}"
+        end        
+      end
+      
+      def unique_sequence_processed?(key,manifest)
+        if self.file_content.unique_fingerprint?(key)
+          self.file_content.fingerprint = key
+          self.file_content.save!
+          self.save!
+          verify_content(manifest)
+          return true
+        end
+        false
+      end
+      
+      def clean_up_duplicate_content
+        Sequence.delete_all("file_content_id=#{self.file_content.id}")
+        self.file_content.orphan_check
+      end
+      
+      def replace_content(key)
+        self.file_content = FileContent.find_by_fingerprint(key)
+        self.save!                
+      end
+      
+    end
+
+  end
 end

data/lib/nearline/block.rb

@@ -1,56 +1,61 @@
-require 'active_record'
-
-module Nearline
-  module Models
-
-    # Represents a unit of file content which may be
-    # freely shared across the repository
-    # Its sole responsibility is to preserve and provide
-    # content access
-    class Block < ActiveRecord::Base
-      require "zlib"
-    
-      has_many :sequences
-      
-      MAX_SIZE = (64 * 1024)-1
-      
-      def attempt_compression
-        return if (self.is_compressed)
-        # TODO: Have a bump-the-compression option, here?
-        candidate_content = Zlib::Deflate.deflate(self.bulk_content)
-        if candidate_content.length < self.bulk_content.length
-          self.is_compressed = true
-          self.bulk_content = candidate_content
-        end
-      end
-      
-      def calculate_fingerprint
-        self.fingerprint = Digest::SHA1.hexdigest(content)        
-      end
-    
-      def content
-        if (self.is_compressed)
-          return Zlib::Inflate.inflate(self.bulk_content)
-        end
-        self.bulk_content
-      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
-        end
-      end
-            
-    end
-  end
+require 'active_record'
+
+module Nearline
+  module Models
+
+    # Represents a unit of file content which may be
+    # freely shared across the repository
+    # Its sole responsibility is to preserve and provide
+    # content access
+    class Block < ActiveRecord::Base
+      require "zlib"
+    
+      has_many :sequences
+      
+      MAX_SIZE = (64 * 1024)-1
+      
+      def attempt_compression
+        return if (self.is_compressed)
+        # TODO: Have a bump-the-compression option, here?
+        candidate_content = Zlib::Deflate.deflate(self.bulk_content)
+        if candidate_content.length < self.bulk_content.length
+          self.is_compressed = true
+          self.bulk_content = candidate_content
+        end
+      end
+      
+      def calculate_fingerprint
+        self.fingerprint = Digest::SHA1.hexdigest(content)        
+      end
+    
+      def content
+        if (self.is_compressed)
+          return Zlib::Inflate.inflate(self.bulk_content)
+        end
+        self.bulk_content
+      end
+          
+      def self.for_content(x, old_block = nil)
+        unless old_block.nil?
+          if x == old_block.content
+            return old_block
+          end
+        end
+        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
+        end
+      end
+            
+    end
+  end
 end

data/lib/nearline/file_content.rb

@@ -1,85 +1,87 @@
-module Nearline
-  module Models
-
-    # Has the responsibility of identifying and
-    # verifying content
-    class FileContent < ActiveRecord::Base
-      has_many :sequences
-      has_many :archived_files
-
-      def self.fresh_entry
-        file_content = FileContent.new
-        file_content.save!
-        file_content
-      end
-      
-      def restore_to(io)
-        sequencer = FileSequencer.new(self)
-        sequencer.restore_blocks(io)
-      end
-      
-      def verified?
-        sequencer = FileSequencer.new(self)
-        sequencer.verified?
-      end
-      
-      def orphan_check
-        if (self.archived_files.size == 1)
-          sequences.each do |s|
-            s.destroy
-            s.block.orphan_check
-          end
-          self.destroy
-        end
-      end
-            
-      def unique_fingerprint?(key)
-        hit = FileContent.connection.select_one(
-          "select id from file_contents where fingerprint='#{key}'"
-        )
-        return hit.nil?
-      end
-      
-    end
-    
-    # Has the responsibility of preserving
-    # cardinality of stored blocks
-    class Sequence < ActiveRecord::Base
-      belongs_to :block
-      belongs_to :file_content
-    end
-    
-    class FileSequencer
-      def initialize(file_content)
-        @inc = 0
-        @file_content = file_content
-      end
-      
-      def preserve_block(block)
-        @inc += 1
-        sequence = Sequence.new(
-          :sequence => @inc,
-          :file_content_id => @file_content.id,
-          :block_id => block.id
-        )
-        sequence.save!
-        sequence
-      end
-      
-      def restore_blocks(io)
-        @file_content.sequences.each do |seq|
-          io.write(seq.block.content)
-        end
-      end
-      
-      def verified?
-        whole_file_hash = Digest::SHA1.new
-        @file_content.sequences.each do |seq|
-          whole_file_hash.update(seq.block.content)
-        end
-        @file_content.fingerprint == whole_file_hash.hexdigest
-      end
-    end
-
-  end
-end
+module Nearline
+  module Models
+
+    # Has the responsibility of identifying and
+    # verifying content
+    class FileContent < ActiveRecord::Base
+      has_many :sequences
+      has_many :archived_files
+
+      def self.fresh_entry
+        file_content = FileContent.new
+        file_content.save!
+        file_content
+      end
+      
+      def orphan_check
+        if (self.archived_files.size == 1)
+          sequences.each do |s|
+            s.destroy
+            s.block.orphan_check
+          end
+          self.destroy
+        end
+      end
+            
+      def unique_fingerprint?(key)
+        hit = FileContent.connection.select_one(
+          "select id from file_contents where fingerprint='#{key}'"
+        )
+        return hit.nil?
+      end
+      
+      def restore_to(io)
+        sequences.each do |seq|
+          block = Block.find(seq.block_id)
+          io.write(block.content)
+    end
+      end
+    
+      def verified?
+        if (!self.verified_at.nil?)
+          return true
+        end
+        whole_file_hash = Digest::SHA1.new
+        sequences.each do |seq|
+          block = Block.find(seq.block_id)
+          whole_file_hash.update(block.content)
+        end
+        if fingerprint == whole_file_hash.hexdigest
+          self.verified_at = Time.now
+          self.save!
+          return true
+        end
+        false
+      end
+      
+      
+    end
+    
+    # Has the responsibility of preserving
+    # cardinality of stored blocks
+    class Sequence < ActiveRecord::Base
+      belongs_to :block
+      belongs_to :file_content
+    end
+    
+    class FileSequencer
+      def initialize(file_content)
+        @inc = 0
+        @file_content = file_content
+      end
+      
+      def preserve_block(block)
+        @inc += 1
+        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/schema.rb

@@ -1,90 +1,93 @@
-module Nearline
-  module Models
-
-    module_function
-    
-    def destroy_schema
-      ActiveRecord::Schema.define do
-        drop_table :blocks
-        drop_table :file_contents
-        drop_table :sequences
-        drop_table :archived_files
-        drop_table :manifests
-        drop_table :archived_files_manifests
-        drop_table :logs
-      end
-    end
-    
-    def empty_schema
-      Nearline::Models::Manifest.destroy_all
-    end
-    
-    def generate_schema
-      ActiveRecord::Schema.define do
-
-        create_table :blocks do |t|
-          t.column :fingerprint, :string, :length => 40, :null => false
-          t.column :bulk_content, :binary
-          t.column :is_compressed, :boolean, :default => false
-        end
-        
-        add_index :blocks, [:fingerprint], :unique => true
-
-        create_table :file_contents do |t|
-          t.column :fingerprint, :string, :length => 40
-          t.column :file_size, :integer, :default => 0
-        end
-
-        create_table :sequences do |t|
-          t.column :sequence, :integer, :null => false
-          t.column :block_id, :integer, :null => false
-          t.column :file_content_id, :integer, :null => false
-        end
-        
-        add_index :sequences, [:sequence, :file_content_id], :unique => true,
-          :name => "sequence_jn_index"
-
-        create_table :archived_files do |t|
-          t.column :system_name, :string, :null => false
-          t.column :path, :text, :null => false
-          t.column :path_hash, :string, :null => false, :length => 40
-          t.column :file_content_id, :integer
-          t.column :uid, :integer, :default => -1
-          t.column :gid, :integer, :default => -1
-          t.column :mtime, :integer, :default => 0
-          t.column :mode, :integer, :default => 33206  # "chmod 100666"
-          t.column :is_directory, :boolean
-        end
-        
-        add_index :archived_files, [:path_hash], :unique => true
-                        
-        # Manifests are the reference to a collection of archived files
-        create_table :manifests do |t|
-          t.column :system_name, :string
-          t.column :created_at, :datetime
-          t.column :completed_at, :datetime
-        end
-        
-        # Joins archived files across manifests so file references may be recycled
-        create_table :archived_files_manifests, :id => false do |t|
-          t.column :archived_file_id, :integer
-          t.column :manifest_id, :integer
-        end
-
-        add_index :archived_files_manifests,
-          [:archived_file_id, :manifest_id], {
-          :unique => true,
-          :name => "manifest_jn_index"
-        }
-        
-        # Keeps a record of problems during backup related to a manifest
-        create_table :logs do |t|
-          t.column :manifest_id, :integer, :null => false
-          t.column :message, :text
-          t.column :created_at, :datetime
-        end
-      end
-    end
-
-  end
-end
+module Nearline
+  module Models
+
+    module_function
+    
+    def destroy_schema
+      ActiveRecord::Schema.define do
+        drop_table :blocks
+        drop_table :file_contents
+        drop_table :sequences
+        drop_table :archived_files
+        drop_table :manifests
+        drop_table :archived_files_manifests
+        drop_table :logs
+      end
+    end
+    
+    def empty_schema
+      Nearline::Models::Manifest.destroy_all
+    end
+    
+    def generate_schema
+      ActiveRecord::Schema.define do
+
+        create_table :blocks do |t|
+          t.column :fingerprint, :string, :length => 40, :null => false
+          t.column :bulk_content, :binary
+          t.column :is_compressed, :boolean, :default => false
+        end
+        
+        add_index :blocks, [:fingerprint], :unique => true
+
+        create_table :file_contents do |t|
+          t.column :fingerprint, :string, :length => 40
+          t.column :file_size, :string, :default => 0
+          t.column :verified_at, :datetime
+        end
+
+        create_table :sequences do |t|
+          t.column :sequence, :integer, :null => false
+          t.column :block_id, :integer, :null => false
+          t.column :file_content_id, :integer, :null => false
+        end
+        
+        add_index :sequences, [:sequence, :file_content_id], :unique => true,
+          :name => "sequence_jn_index"
+
+        add_index :sequences, [:block_id]
+
+        create_table :archived_files do |t|
+          t.column :system_name, :string, :null => false
+          t.column :path, :text, :null => false
+          t.column :path_hash, :string, :null => false, :length => 40
+          t.column :file_content_id, :integer
+          t.column :uid, :integer, :default => -1
+          t.column :gid, :integer, :default => -1
+          t.column :mtime, :integer, :default => 0
+          t.column :mode, :integer, :default => 33206  # "chmod 100666"
+          t.column :is_directory, :boolean
+        end
+        
+        add_index :archived_files, [:path_hash], :unique => true
+                        
+        # Manifests are the reference to a collection of archived files
+        create_table :manifests do |t|
+          t.column :system_name, :string
+          t.column :created_at, :datetime
+          t.column :completed_at, :datetime
+        end
+        
+        # Joins archived files across manifests so file references may be recycled
+        create_table :archived_files_manifests, :id => false do |t|
+          t.column :archived_file_id, :integer
+          t.column :manifest_id, :integer
+        end
+
+        add_index :archived_files_manifests,
+          [:archived_file_id, :manifest_id], {
+          :unique => true,
+          :name => "manifest_jn_index"
+        }
+        
+        # Keeps a record of problems during backup related to a manifest
+        create_table :logs do |t|
+          t.column :manifest_id, :integer, :null => false
+          t.column :message, :text
+          t.column :created_at, :datetime
+        end
+      end
+    end
+
+  end
+end

data/tasks/gemspec.rake

@@ -3,7 +3,7 @@ require 'rake/gempackagetask'
 
 SPEC = Gem::Specification.new do |s|
   s.name = "nearline"
-  s.version = "0.0.1"
+  s.version = "0.0.2"
   s.author = "Robert J. Osborne"
   s.email = "rjo1970@gmail.com"
   s.summary = "Nearline is a near-line backup and recovery solution"

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: nearline
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2008-04-03 00:00:00 -04:00
+  version: 0.0.2
+date: 2008-04-05 00:00:00 -04:00
 summary: Nearline is a near-line backup and recovery solution
 require_paths: 
 - lib