fingerprint 1.3.1 → 3.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8e4286765727a4efa88c5ecf4f84ab5d736606a0adae710c32073da69746465
+  data.tar.gz: be66585855747916dd4294736a68cc04d2ff3e1aa49df83d08ec98b4e21bcfee
+SHA512:
+  metadata.gz: 8772554e075f2b29016fe859c85d0d7082fc66a77f068b02d33ebc084c15efa20a83baa52d48fad3860b18316d2084f515f28933065fd7f0a7f7c9743c27bd39
+  data.tar.gz: 8757e6f7cc91db4a7f80be3485ac61184ed0c8fa9ecaad58f2ba257ff74a2b6d7384888439263d7faafa99d4238712b96ab11ba7e6585d4fe43968a8a6fd7672

data/bin/fingerprint

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-# Copyright (c) 2011 Samuel G. D. Williams. <http://www.oriontransfer.co.nz>
+# Copyright, 2016, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -20,219 +20,10 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'optparse'
-require 'pathname'
-require 'fingerprint'
-require 'lockfile'
-require 'fileutils'
+# This script takes a given path, and renames it with the given format. 
+# It then ensures that there is a symlink called "latest" that points 
+# to the renamed directory.
 
-OPTIONS = {
-	:root => "./",
-	:mode => :scan,
-	:output => $stdout,
-	:verbose => false,
-	:force => false,
-	:name => "index.fingerprint",
-	:extended => false,
-	:checksums => Fingerprint::DEFAULT_CHECKSUMS,
-	:lockfile => true
-}
+require_relative '../lib/fingerprint/command'
 
-ARGV.options do |o|
-	script_name = File.basename($0)
-
-	o.banner = "Usage: #{script_name} [options] [path]"
-	o.define_head "This script is used to create and compare file system fingerprints."
-
-	o.separator ""
-	o.separator "Directory analysis and verification:"
-	
-	o.on("-a", "--analyze [path]", String, "Generage a fingerprint of the given path and save it for later verification.") do |path|
-		OPTIONS[:mode] = :analyze
-		OPTIONS[:root] = path if path
-	end
-	
-	o.on("-v", "--verify [path]", String, "Verify a given path based on a previously saved fingerprint.") do |path|
-		OPTIONS[:mode] = :verify
-		OPTIONS[:root] = path if path
-	end
-	
-	o.on("-n name", String, "Specify the name of the fingerprint file.", "Default: #{OPTIONS[:name]}") do |name|
-		OPTIONS[:name] = name
-	end
-	
-	o.on("-f", "Force any operation to complete despite warnings.") do
-		OPTIONS[:force] = true
-	end
-	
-	o.separator ""
-	o.separator "Low level operations:"
-
-	o.on("-c", "Compare the given fingerprints. Check that the second fingerprint is a superset of the first.") do
-		 OPTIONS[:mode] = :check
-	end
-	
-	o.on("-o [output-path]", String, "Write the fingerprint output to the given file.") do |path|
-		OPTIONS[:output] = File.open(path, "w")
-	end
-	
-	o.on("--verbose", "Verbose output, include additional details in the file transcript.") do
-		OPTIONS[:verbose] = true
-	end
-	
-	o.on("--progress", "Print percentage progress to standard error.") do
-		OPTIONS[:progress] = true
-	end
-	
-	o.on("--no-lockfile", "Don't use a lockfile to validate access to the fingerprint.") do
-		OPTIONS[:lockfile] = false
-	end
-
-	o.separator ""
-	
-	o.on("-x", "Include additional extended information about files and directories.") do
-		OPTIONS[:extended] = true
-	end
-	
-	o.on("-s [checksum1,checksum2]", "Provide a list of the checksum algorithms to use.", "Available: #{Fingerprint::CHECKSUMS.keys.join(', ')}; Default: #{OPTIONS[:checksums].join(', ')}") do |checksums|
-		OPTIONS[:checksums] = checksums.split(/[\s,]+/)
-	end
-	
-	o.separator ""
-	o.separator "Help and Copyright information:"
-
-	o.on_tail("--copy", "Display copyright and warranty information") do
-		$stderr.puts "#{script_name} v#{Fingerprint::VERSION::STRING}. Copyright (c) 2011 Samuel Williams."
-		$stderr.puts "This software is released under the MIT license and comes with ABSOLUTELY NO WARRANTY."
-		$stderr.puts "See http://www.oriontransfer.co.nz/ for more information."
-		exit
-	end
-
-	o.on_tail("-h", "--help", "Show this help message.") do
-		$stderr.puts o
-		exit
-	end
-end.parse!
-
-unless File.directory? OPTIONS[:root]
-	$stderr.puts "Path #{OPTIONS[:root]} doesn't exist!"
-	exit(255)
-end
-
-if OPTIONS[:checksums].size == 0
-	OPTIONS[:checksums] = ['MD5', 'SHA2.256']
-end
-
-# Run some block with the given lock, if requested.
-def with_lock
-	lockfile_path = nil
-	if OPTIONS[:lockfile] == true
-		lockfile_path = Pathname.new(OPTIONS[:root]) + (OPTIONS[:name] + ".lock")
-	elsif OPTION[:lockfile] != false
-		lockfile_path = OPTIONS[:lockfile]
-	end
-	
-	if lockfile_path
-		begin
-			Lockfile.new(lockfile_path, :retries => 0) do
-				yield
-			end
-		rescue Lockfile::MaxTriesLockError
-			$stderr.puts "Could not acquire lock #{lockfile_path}."
-			
-			return false
-		end
-	else
-		yield
-	end
-	
-	return true
-end
-
-case (OPTIONS[:mode])
-	when :analyze
-		result = with_lock do
-			output_file = Pathname.new(OPTIONS[:root]) + OPTIONS[:name]
-		
-			if output_file.exist? && !OPTIONS[:force]
-				$stderr.puts "Output file #{output_file} already exists. Aborting."
-				exit(2)
-			end
-		
-			options = OPTIONS.dup
-			options[:excludes] = [OPTIONS[:name]]
-			
-			finished = false
-			begin
-				File.open(output_file, "w") do |io|
-					options[:output] = io
-			
-					Fingerprint::Scanner.scan_paths([OPTIONS[:root]], options)
-				end
-				finished = true
-			ensure
-				FileUtils.rm(output_file) unless finished
-			end
-		end
-		
-		unless result
-			# Lockfile failure
-			exit(4)
-		end
-	when :verify
-		error_count = 0
-		
-		input_file = Pathname.new(OPTIONS[:root]) + OPTIONS[:name]
-		
-		unless File.exist? input_file
-			$stderr.puts "Can't find index #{input_file}. Aborting."
-			exit(3)
-		end
-		
-		options = OPTIONS.dup
-		
-		master = Fingerprint::Recordset.new
-		
-		File.open(input_file, "r") do |io|
-			master.parse(io)
-		end
-		
-		if master.configuration
-			options.merge!(master.configuration.options)
-		end
-
-		scanner = Fingerprint::Scanner.new([OPTIONS[:root]], options)
-		copy = Fingerprint::SparseRecordset.new(scanner)
-
-		error_count += Fingerprint::Checker::verify(master, copy, options)
-		
-		if error_count == 0
-			$stderr.puts "Data verified, 0 errors found."
-			exit(0)
-		else
-			$stderr.puts "Data inconsistent, #{error_count} errors found!"
-			exit(1)
-		end
-	when :scan
-		roots = ARGV
-		roots << Dir.pwd if roots.size == 0
-		
-		# Check that all supplied paths exist
-		roots.delete_if do |root|
-			if File.exist? root
-				false
-			else
-				$stderr.puts "Path #{root} doesn't exist, skipping!"
-				true
-			end
-		end
-
-		options = OPTIONS.dup
-
-		Fingerprint::Scanner.scan_paths(roots, options)
-	when :check
-		options = OPTIONS.dup
-		
-		error_count = Fingerprint::Checker.check_files(ARGV[0], ARGV[1], options)
-		exit(error_count > 0 ? 1 : 0)
-end
+Fingerprint::Command.call

data/lib/fingerprint.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2011 Samuel G. D. Williams. <http://www.oriontransfer.co.nz>
+# Copyright, 2011, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -18,25 +18,39 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'fingerprint/record'
 require 'fingerprint/version'
 require 'fingerprint/scanner'
 require 'fingerprint/checker'
 
 module Fingerprint
 	# A helper function to check two paths for consistency. Provides callback from +Fingerprint::Checker+.
-	def self.check_paths(master_path, copy_path, &block)
+	def self.check_paths(master_path, copy_path, **options, &block)
 		master = Scanner.new([master_path])
 		copy = Scanner.new([copy_path])
 		
-		master_recordset = Recordset.new
-		copy_recordset = SparseRecordset.new(copy)
+		master_recordset = RecordSet.new
+		copy_recordset = SparseRecordSet.new(copy)
 		
 		master.scan(master_recordset)
 		
-		checker = Checker.new(master_recordset, copy_recordset)
+		checker = Checker.new(master_recordset, copy_recordset, **options)
 		
 		checker.check(&block)
 		
 		return checker
 	end
+	
+	# Returns true if the given paths contain identical files. Useful for expectations, e.g. `expect(Fingerprint).to be_identical(source, destination)`
+	def self.identical?(source, destination, &block)
+		failures = 0
+		
+		check_paths(source, destination) do |record, name, message|
+			failures += 1
+			
+			yield(record) if block_given?
+		end
+		
+		return failures == 0
+	end
 end

data/lib/fingerprint/checker.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2011 Samuel G. D. Williams. <http://www.oriontransfer.co.nz>
+# Copyright, 2011, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -31,7 +31,7 @@ module Fingerprint
 	#
 	# Master and copy are +IO+ objects corresponding to the output produced by +Fingerprint::Scanner+.
 	class Checker
-		def initialize(master, copy, options = {})
+		def initialize(master, copy, **options)
 			@master = master
 			@copy = copy
 			
@@ -42,15 +42,26 @@ module Fingerprint
 		attr :copy
 
 		# Run the checking process.
-		def check (options = {}, &block)
+		def check(&block)
 			# For every file in the src, we check that it exists
 			# in the destination:
-			
 			total_count = @master.records.count
 			processed_size = 0
 			total_size = @master.records.inject(0) { |count, record| count + (record['file.size'] || 0).to_i }
 			
+			if @options[:additions]
+				copy_paths = @copy.paths.dup
+			else
+				copy_paths = {}
+			end
+			
 			@master.records.each_with_index do |record, processed_count|
+				copy_paths.delete(record.path)
+
+				if @options[:progress]
+					$stderr.puts "# Checking: #{record.path}"
+				end
+
 				next if record.mode != :file
 
 				result, message = @copy.compare(record)
@@ -66,53 +77,64 @@ module Fingerprint
 				end
 				
 				if @options[:progress]
-					$stderr.puts "# Progress: File #{processed_count} / #{total_count} = #{sprintf('%0.2f%', processed_count.to_f / total_count.to_f * 100.0)}; Byte #{processed_size} / #{total_size} = #{sprintf('%0.2f%', processed_size.to_f / total_size.to_f * 100.0)}"
+					$stderr.puts "# Progress: File #{processed_count} / #{total_count}; Byte #{processed_size} / #{total_size} = #{sprintf('%0.2f%', processed_size.to_f / total_size.to_f * 100.0)}"
 
 					processed_size += (record['file.size'] || 0).to_i
 				end
 			end
+			
+			if @options[:additions]
+				copy_paths.each do |path, record|
+					next unless record.mode == :file || record.mode == :directory
+					
+					yield record, :addition, "File added"
+				end
+			end
 		end
 		
 		# A list of files which either did not exist in the copy, or had the wrong checksum.
 		attr :failures
 
-		def self.check_files(master, copy, options = {}, &block)
-			# New API that takes two Recordsets...
+		def self.check_files(master, copy, **options, &block)
+			# New API that takes two RecordSets...
 			
 			File.open(master) do |master_file|
 				File.open(copy) do |copy_file|
-					master_recordset = Recordset.new
+					master_recordset = RecordSet.new
 					master_recordset.parse(master_file)
 					
-					copy_recordset = Recordset.new
+					copy_recordset = RecordSet.new
 					copy_recordset.parse(copy_file)
 
-					verify(master_recordset, copy_recordset, options, &block)
+					verify(master_recordset, copy_recordset, **options, &block)
 				end
 			end
 		end
 
 		# Helper function to check two fingerprint files.
-		def self.verify(master, copy, options = {}, &block)
+		def self.verify(master, copy, **options, &block)
 			error_count = 0 
 
-			errors = options.delete(:recordset) || Recordset.new
+			errors = options.delete(:recordset) || RecordSet.new
 			if options[:output]
-				errors = RecordsetPrinter.new(errors, options[:output])
+				errors = RecordSetPrinter.new(errors, options[:output])
 			end
 
-			checker = Checker.new(master, copy, options)
+			checker = Checker.new(master, copy, **options)
 
 			checker.check do |record, result, message|
 				error_count += 1
-				copy = checker.copy.paths[record.path]
 
 				metadata = {
 					'error.code' => result,
 					'error.message' => message
 				}
 
-				if copy
+				if result == :addition
+					metadata.merge!(record.metadata)
+					
+					errors << Record.new(:warning, record.path, metadata)
+				elsif (copy = checker.copy.paths[record.path])
 					changes = record.diff(copy)
 
 					changes.each do |name|
@@ -126,7 +148,13 @@ module Fingerprint
 				end
 			end
 
-			errors << Record.new(:summary, nil, {
+			if error_count
+				summary_message = "#{error_count} error(s) detected."
+			else
+				summary_message = "No errors detected"
+			end
+
+			errors << Record.new(:summary, summary_message, {
 				'error.count' => error_count
 			})
 

data/lib/fingerprint/checksums.rb

@@ -0,0 +1,33 @@
+# Copyright, 2016, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# This script takes a given path, and renames it with the given format. 
+# It then ensures that there is a symlink called "latest" that points 
+# to the renamed directory.
+
+require 'samovar'
+
+module Fingerprint
+	module Checksums
+		def self.call(result)
+			result.split(/\s*,\s*/)
+		end
+	end
+end