Class: Fingerprint::Checker

Inherits:
Object
  • Object
show all
Defined in:
lib/fingerprint/checker.rb

Overview

Given two fingerprints (master and copy) ensures that the copy has at least everything contained in master: For every file in the master, a corresponding file must exist in the copy. This means that there may be extraneous files in the copy, but ensures that every file in the master has been replicated accurately.

At this time, this implementation may require a large amount of memory, proportional to the number of files being checked.

Master and copy are IO objects corresponding to the output produced by Fingerprint::Scanner.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(master, copy, **options) ⇒ Checker

Returns a new instance of Checker.



34
35
36
37
38
39
 
# File 'lib/fingerprint/checker.rb', line 34

def initialize(master, copy, **options)
	@master = master
	@copy = copy
	
	@options = options
end

Instance Attribute Details

#copy ⇒ Object (readonly)

Returns the value of attribute copy.



42
43
44
 
# File 'lib/fingerprint/checker.rb', line 42

def copy
  @copy
end

#failures ⇒ Object (readonly)

A list of files which either did not exist in the copy, or had the wrong checksum.



96
97
98
 
# File 'lib/fingerprint/checker.rb', line 96

def failures
  @failures
end

#master ⇒ Object (readonly)

Returns the value of attribute master.



41
42
43
 
# File 'lib/fingerprint/checker.rb', line 41

def master
  @master
end

Class Method Details

.check_files(master, copy, **options, &block) ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/fingerprint/checker.rb', line 98

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.parse(master_file)
			
			copy_recordset = RecordSet.new
			copy_recordset.parse(copy_file)

			verify(master_recordset, copy_recordset, **options, &block)
		end
	end
end

.verify(master, copy, **options, &block) ⇒ Object

Helper function to check two fingerprint files.



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/fingerprint/checker.rb', line 115

def self.verify(master, copy, **options, &block)
	error_count = 0 

	errors = options.delete(:recordset) || RecordSet.new
	if options[:output]
		errors = RecordSetPrinter.new(errors, options[:output])
	end

	checker = Checker.new(master, copy, **options)

	checker.check do |record, result, message|
		error_count += 1

		metadata = {
			'error.code' => result,
			'error.message' => message
		}

		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|
				metadata["changes.#{name}.old"] = record[name]
				metadata["changes.#{name}.new"] = copy[name]
			end

			errors << Record.new(:warning, record.path, metadata)
		else
			errors << Record.new(:warning, record.path, metadata)
		end
	end

	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
	})

	return error_count
end

Instance Method Details

#check(&block) ⇒ Object

Run the checking process.



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/fingerprint/checker.rb', line 45

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)
		if result != :valid
			yield record, result, message
		elsif @options[:extended]
			# Extended check compares other attributes such as user, group, file modes.
			changes = record.diff(copy.paths[record.path])
			
			if changes.size > 0
				yield record, :attribute_changed, "Attribute(s) #{changes.join(', ')} changed"
			end
		end
		
		if @options[:progress]
			$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