rubyyabt 0.0.5

data/classes/ProxyHTTP.rb

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+
+require 'net/https'
+require 'uri'
+require 'timeout'
+#noinspection RubyResolve
+require 'thread'
+#noinspection RubyResolve
+require 'classes/proxy_http_cache_hash'
+
+$myDEBUG = false if not $myDEBUG
+$myVERBOSE = false if not $myVERBOSE
+$options = nil unless $options
+
+class ProxyHTTP
+  def initialize()
+	# Defines the subdirs for each type of data
+	@types = {
+			:chunk   => 'chunks',
+			:file    => 'files',
+			:backup  => 'backups',
+			:root    => 'meta',
+			:cache   => 'cache'
+	}
+	@@valid_caches =  [:chunk, :file]
+	$options[:target] += "/" if $options[:target][-1] != "/"
+	# Calculate the user agent for HTTP requests
+	$options[:user_agent] = $options[:program_name] + " " + $options[:version].join(".")
+	@mutex = Mutex.new
+	@url = URI.parse($options[:target])
+	@http = Net::HTTP.new(@url.host, @url.port)
+	@http.use_ssl = true if @url.scheme = 'https'
+	@http.open_timeout = 15
+	@http.read_timeout = 280
+	if $options[:ssl_cert_dir] then
+	  #noinspection RubyResolve
+	  @http.ca_path = $options[:ssl_cert_dir]
+	  #noinspection RubyResolve
+	  @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+	  #noinspection RubyResolve
+	  @http.verify_depth = 5
+	end
+	@cui = Cui.instance
+	@cache = ProxyHTTPCache_Hash.new
+  end
+
+  def caching?()
+	return true
+  end
+
+  def dump_cache()
+	return @cache.dump
+  end
+
+  def load_cache(cache_data)
+	#noinspection RubyResolve
+	begin
+	  @cache = Marshal.load(cache_data)
+	  if not @cache.kind_of?(ProxyHTTPCache_Hash) then
+		@cui.error("Cache is not compatible. Starting with an empty cache.")
+		@cache = ProxyHTTPCache_Hash.new
+	  end
+	rescue Exception # Just start out with an empty cache
+	  @cache = ProxyHTTPCache_Hash.new
+	end
+
+  end
+
+  #noinspection RubyScope
+  def request(http_request, timeout = 300, tries = 20)
+	@cui.error("DEBUG[#{Thread.current.inspect}]: Trying to lock ProxyHTTP request mutex in thread #{Thread.current.inspect}") if $myDEBUG
+	@mutex.synchronize {
+	  @cui.error("DEBUG[#{Thread.current.inspect}]: Got ProxyHTTP request mutex in thread #{Thread.current.inspect}") if $myDEBUG
+	  response = ''
+	  while tries > 0 do
+		@cui.error("DEBUG[#{Thread.current.inspect}]: Got #{tries} tries left for request #{http_request.inspect} #{http_request.path}, timeout #{timeout}") if $myDEBUG
+		begin
+		  Timeout::timeout(timeout) {
+			@cui.error("DEBUG[#{Thread.current.inspect}]: Sending request #{http_request.inspect} for #{http_request.path}....") if $myDEBUG
+			response = @http.request(http_request)
+		  }
+		rescue Timeout::Error
+		  tries -= 1
+		  @cui.error("Timeout during request. #{tries} tries left")
+		  retry if tries > 0
+		  raise
+		rescue Exception => ex
+		  @cui.error("Caught exception #{ex} with message #{ex.message} during request. #{tries} tries left") if $myVERBOSE
+		  tries -= 1
+		  retry if tries > 0
+		  raise
+		end
+		code = response.code.to_i
+		@cui.error("DEBUG[#{Thread.current.inspect}]: Response code: #{code}") if $myDEBUG
+		return response if (code >= 200) and (code < 300)
+		if (code >= 400) and (code < 500) # No retries for these errors...
+		  # Yeehaw! we need an exception for code 401 since humyo sometimes replies with it with correct authorization
+		  tries = 0 if (code != 401)
+		end
+		tries -= 1
+		@cui.error("DEBUG[#{Thread.current.inspect}]: #{tries} tries left for this request. Retrying after sleep if > 0") if $myDEBUG
+		sleep(rand) if tries > 0 # Sleep up to one second before retrying
+	  end
+	  @cui.error("DEBUG[#{Thread.current.inspect}]: Raising exception for failed request: #{response.code} #{response.message}") if $myDEBUG
+	  raise 'HTTP request failed: ' + response.code + ' ' + response.message
+	}
+  end
+
+  #noinspection RubyUnusedLocalVariable
+  def read(target_dir, type, file)
+	subdir_type = type
+	subdir_type = (type.to_s + file[0..2]).to_sym if type == :chunk
+	subdir_type = (type.to_s + file[0..2]).to_sym if type == :file
+	subdir = ''
+	subdir = file[0..2] + '/' if type == :chunk
+	subdir = file[0..2] + '/' if type == :file
+	uri = @url.merge(@types[type] + '/').merge(subdir).merge(file)
+	get = Net::HTTP::Get.new(uri.request_uri)
+	get.initialize_http_header({"User-Agent" => $options[:user_agent]})
+	get.basic_auth($options[:username], $options[:password])
+	@cui.error("DEBUG[#{Thread.current.inspect}]: Reading from #{uri.to_s}") if $myDEBUG
+	begin
+	  response = request(get, $options[:http_timeout])
+	rescue Exception => ex
+	  @cui.error(ex.message + ' at URL: ' + uri.to_s)
+	  raise
+	else
+	  return response.body
+	end
+  end
+
+  #noinspection RubyUnusedLocalVariable
+  def write(target_dir, type, file, data)
+	subdir_type = type
+	subdir_type = (type.to_s + file[0..2]).to_sym if type == :chunk
+	subdir_type = (type.to_s + file[0..2]).to_sym if type == :file
+	subdir = ''
+	subdir = file[0..2] + '/' if type == :chunk
+	subdir = file[0..2] + '/' if type == :file
+	uri = @url.merge(@types[type] + '/').merge(subdir).merge(file)
+	put = Net::HTTP::Put.new(uri.request_uri)
+	put.initialize_http_header({"User-Agent" => $options[:user_agent], "Content-Type" => "application/octet-stream"})
+	put.basic_auth($options[:username], $options[:password])
+	put.body = data
+	@cui.error("DEBUG[#{Thread.current.inspect}]: Writing to #{uri.to_s}") if $myDEBUG
+	begin
+	  response = request(put, 180)
+	rescue RuntimeError => ex
+	  if ex.message == "HTTP request failed: 409 Conflict" then
+		@cui.error("DEBUG[#{Thread.current.inspect}]: Caught a 409 Conflict error") if $myDEBUG
+		if (subdir_type != type) then
+		  begin
+			@cui.error("DEBUG[#{Thread.current.inspect}]: Trying to create the directory #{@url.merge(@types[type] + '/').to_s}") if $myDEBUG
+			mkdir(@url.merge(@types[type] + '/'))
+		  rescue RuntimeError => rt
+			@cui.error("DEBUG[#{Thread.current.inspect}]: Caught exception during mkdir: #{rt.message}") if $myDEBUG
+			raise if rt.message[0..23] != "HTTP request failed: 405"
+		  end
+		end
+		@cui.error("DEBUG[#{Thread.current.inspect}]: Trying to create the directory #{@url.merge(@types[type] + '/').merge(subdir).to_s}") if $myDEBUG
+		mkdir(@url.merge(@types[type] + '/').merge(subdir))
+	  end
+	  retry
+	rescue Exception => ex
+	  @cui.error(ex.message + ' at URL: ' + uri.to_s)
+	  raise
+	else
+	  @cache.add(type, file) if @@valid_caches.include?(type)
+	  @cui.error("DEBUG[#{Thread.current.inspect}]: Added #{file} to cache list for #{subdir_type}") if $myDEBUG
+	  return true
+	end
+  end
+
+  def mkdir(uri)
+	mkcol = Net::HTTP::Mkcol.new(uri.request_uri)
+	mkcol.initialize_http_header({"User-Agent" => $options[:user_agent]})
+	mkcol.basic_auth($options[:username], $options[:password])
+	@cui.error("DEBUG[#{Thread.current.inspect}]: Trying to create directory #{uri.to_s}") if $myDEBUG
+	begin
+	  request(mkcol)
+	rescue Exception => ex
+	  # Check if it's just a 405 that happens when the directory already exists...
+	  return if ex.message[0..23] == "HTTP request failed: 405"
+	  @cui.error(ex.message + ' at URL: ' + uri.to_s)
+	  raise
+	end
+  end
+
+  def exists?(target_dir, type, file)
+	return @cache.search(type, file) if @@valid_caches.include?(type)
+	return false # TODO: Need to do a real check on the server instead...
+  end
+
+  def list(uri)
+	propfind = Net::HTTP::Propfind.new(uri.request_uri)
+	propfind.initialize_http_header({"User-Agent" => $options[:user_agent], "Depth" => "1", "Content-Type" => "application/octet-stream"})
+	propfind.basic_auth($options[:username], $options[:password])
+	propfind.body = '<?xml version="1.0" encoding="utf-8" ?><propfind xmlns="DAV:"><propname/></propfind>'
+	@cui.error("Retrieving file list for #{uri.to_s}...") if $myDEBUG
+	begin
+	  response = request(propfind, 30)
+	rescue RuntimeError => ex
+	  @cui.error("DEBUG[#{Thread.current.inspect}]: Caught exception #{ex} with message #{ex.message} during list") if $myDEBUG
+	  return Array.new if ex.message[0..23] == "HTTP request failed: 404"
+	  @cui.error("Caught exception #{ex.message} for URL #{uri.to_s} with request #{propfind.inspect}") if $myVERBOSE
+	rescue Exception => ex
+	  @cui.error(ex.message + ' at URL: ' + uri.to_s)
+	  raise
+	else
+	  @cui.error("DEBUG[#{Thread.current.inspect}]: Parsing result for list...") if $myDEBUG
+	  regexp = Regexp.new('<D:href>([^<]*)</D:href>', Regexp::IGNORECASE)
+	  list = response.body.scan(regexp)
+	  list.each_index { | i |
+		list[i] = list[i][0]
+		list[i] = list[i][(uri.request_uri.length)..(list[i].length)]
+		list[i] = nil if list[i] == ""
+	  }
+	  list.compact!
+	  list.sort!
+	  @cui.error("Found #{list.count} files") if $myDEBUG
+	  list
+	end
+  end
+end

data/classes/SMGFile.rb

@@ -0,0 +1,292 @@
+#!/usr/bin/env ruby
+
+#noinspection RubyResolve
+require 'classes/Chunk'
+#noinspection RubyResolve
+require 'classes/Source'
+#noinspection RubyResolve
+require 'classes/Target'
+require 'digest/md5'
+#noinspection RubyResolve
+require 'digest/sha2'
+require 'time'
+
+$myDEBUG = false if not $myDEBUG
+$myVERBOSE = false if not $myVERBOSE
+$options = nil unless $options
+
+class SMGFile
+  attr_reader :directory, :name, :type
+
+  def initialize(file = nil, md5 = nil, sha256 = nil)
+    @cui = Cui.instance
+    @source = Source.instance
+    @target = Target.instance
+    @is_complete = false
+    @filename = file
+    @md5 = nil
+    @sha256 = nil
+    @size = 0
+    @mtime = 0
+    @meta_md5 = md5
+    @meta_sha256 = sha256
+    @chunks = Array.new
+  end
+
+  def backup!()
+    # Check the file type
+    case @source.ftype(@filename)
+      when 'file'
+        backup_file()
+      when 'directory'
+        backup_dir()
+      when 'characterSpecial'
+        # backup_dev(@filename) TODO
+      when 'blockSpecial'
+        # backup_dev(@filename) TODO
+      when 'fifo'
+        # backup_fifo(@filename) TODO
+      when 'link'
+        backup_link()
+      when 'socket'
+        # backup_socket(@filename) TODO
+      when 'unknown'
+        @cui.message("[E] Unsupported file type for: #{@filename}")
+    end
+  end
+
+  def backup_file()
+    @cui.current_file_name(@filename)
+    fd = @source.open_read(@filename)
+    stat = fd.lstat
+    ftype = stat.ftype
+    mtime = stat.mtime.utc.rfc2822
+    mode = "%o" % stat.mode
+    uid = stat.uid.to_s
+    gid = stat.gid.to_s
+    expected_size = stat.size
+    @cui.current_file_size(expected_size)
+    size = 0
+    md5hashing = Digest::MD5.new
+    sha256hashing = Digest::SHA2.new(256)
+    @cui.message("DEBUG[#{Thread.current.inspect}: Created hashing objects") if $myDEBUG
+    chunks = ''
+    while !fd.eof?
+      @cui.message("DEBUG[#{Thread.current.inspect}: Checked for EOF") if $myDEBUG
+      chunk = Chunk.new
+      @cui.message("DEBUG[#{Thread.current.inspect}: Created new chunk") if $myDEBUG
+      data = fd.read($options[:chunk_size])
+      @cui.message("DEBUG[#{Thread.current.inspect}: Read data") if $myDEBUG
+      chunk.set_data(data)
+      @cui.message("DEBUG[#{Thread.current.inspect}: Saved data in chunk") if $myDEBUG
+      md5hashing << data
+      @cui.message("DEBUG[#{Thread.current.inspect}: hashed for MD5") if $myDEBUG
+      sha256hashing << data
+      @cui.message("DEBUG[#{Thread.current.inspect}: hashed for sha256") if $myDEBUG
+      size += data.length
+      @cui.message("DEBUG[#{Thread.current.inspect}: Updated read size") if $myDEBUG
+      chunk.backup! # Upload this chunk
+      @cui.message("DEBUG[#{Thread.current.inspect}: backed up chunk") if $myDEBUG
+      chunks += chunk.sha256 + '.' + chunk.md5 + "\n"
+      @cui.finished_size_add(data.length)
+    end
+    fd.close()
+    @cui.message("DEBUG[#{Thread.current.inspect}: Closed FD") if $myDEBUG
+    md5 = md5hashing.hexdigest
+    @cui.message("DEBUG[#{Thread.current.inspect}: Got MD5") if $myDEBUG
+    sha256 = sha256hashing.hexdigest
+    @cui.message("DEBUG[#{Thread.current.inspect}: Got sha256") if $myDEBUG
+    # Build the metadata file
+    @metadata = "[stat]\n"
+    @metadata += "filename = " + @filename + "\n"
+    @metadata += "ftype = " + ftype + "\n"
+    @metadata += "mtime = " + mtime + "\n"
+    @metadata += "mode = " + mode + "\n"
+    @metadata += "uid = " + uid + "\n"
+    @metadata += "gid = " + gid + "\n"
+    @metadata += "size = " + size.to_s + "\n"
+    @metadata += "\n"
+    @metadata += "[checksums]\n"
+    @metadata += "md5 = " + md5 + "\n"
+    @metadata += "sha256 = " + sha256 + "\n"
+    @metadata += "\n"
+    @metadata += "[chunks]\n"
+    @metadata += chunks
+    @cui.message("Size mismatch: expected #{expected_size} but found #{size}!") if expected_size != size
+    @size = size
+    @mtime = mtime
+    @cui.message("DEBUG[#{Thread.current.inspect}: Checking if file already exists on server") if $myDEBUG
+    return true if @target.exists?(:file, "#{meta_sha256}.#{meta_md5}") # if this chunk already exists, no need to upload it
+    @cui.message("Uploading file metadata #{@filename}: #{meta_sha256}.#{meta_md5}...") if $myDEBUG
+    @target.write(:file, "#{meta_sha256}.#{meta_md5}", @metadata)
+    @cui.message("DEBUG[#{Thread.current.inspect}: Uploaded file metadata") if $myDEBUG
+  end
+
+  def backup_dir()
+    @cui.current_file_name(@filename)
+    stat = @source.lstat(@filename)
+    ftype = stat.ftype
+    mtime = stat.mtime.utc.rfc2822
+    mode = "%o" % stat.mode
+    uid = stat.uid.to_s
+    gid = stat.gid.to_s
+    # Build the metadata file
+    @metadata = "[stat]\n"
+    @metadata += "filename = " + @filename + "\n"
+    @metadata += "ftype = " + ftype + "\n"
+    @metadata += "mtime = " + mtime + "\n"
+    @metadata += "mode = " + mode + "\n"
+    @metadata += "uid = " + uid + "\n"
+    @metadata += "gid = " + gid + "\n"
+    @size = 0
+    @mtime = mtime
+    return true if @target.exists?(:file, "#{meta_sha256}.#{meta_md5}") # if this chunk already exists, no need to upload it
+    @cui.message("Uploading directory metadata #{@filename}: #{meta_sha256}.#{meta_md5}...") if $myVERBOSE
+    @target.write(:file, "#{meta_sha256}.#{meta_md5}", @metadata)
+  end
+
+  def backup_link()
+    @cui.message("Backing up link #{@filename}") if $myVERBOSE
+    stat = @source.lstat(@filename)
+    ftype = stat.ftype
+    mtime = stat.mtime.utc.rfc2822
+    mode = "%o" % stat.mode
+    uid = stat.uid.to_s
+    gid = stat.gid.to_s
+    link_target = @source.readlink(@filename)
+    @metadata = "[stat]\n"
+    @metadata += "filename = " + @filename + "\n"
+    @metadata += "ftype = " + ftype + "\n"
+    @metadata += "target = " + link_target + "\n"
+    @metadata += "mode = " + mode + "\n"
+    @metadata += "uid = " + uid + "\n"
+    @metadata += "gid = " + gid + "\n"
+    @size = 0
+    @mtime = mtime
+    return true if @target.exists?(:file, "#{meta_sha256}.#{meta_md5}") # if this chunk already exists, no need to upload it
+    @cui.message("Uploading file metadata #{@filename}: #{meta_sha256}.#{meta_md5}...") if $myVERBOSE
+    @target.write(:file, "#{meta_sha256}.#{meta_md5}", @metadata)
+  end
+
+  def restore!()
+    return false if ! @target.exists?(:file, "#{meta_sha256}.#{meta_md5}") # Cannot restore if metadata not available
+    @metadata = @target.read(:file, "#{meta_sha256}.#{meta_md5}")
+    parse_metadata
+    case @ftype
+      when 'file'
+        restore_file()
+      when 'directory'
+        restore_dir()
+      when 'characterSpecial'
+        # restore_dev(@filename) TODO
+      when 'blockSpecial'
+        # restore_dev(@filename) TODO
+      when 'fifo'
+        # restore_fifo(@filename) TODO
+      when 'link'
+        restore_link()
+      when 'socket'
+        # restore_socket(@filename) TODO
+      when 'unknown'
+        @cui.error("Unsupported file type for: #{@filename}")
+    end
+  end
+
+  def restore_file()
+    fd = @source.open_write(@filename)
+    size = 0
+    md5hashing = Digest::MD5.new
+    sha256hashing = Digest::SHA2.new(256)
+    @chunks.each { | chunk_sum |
+    # Get sha256 and md5 for the chunk, they are verified in the chunk
+      sha256 = chunk_sum[0..63]
+      md5 = chunk_sum[65..96]
+      chunk = Chunk.new
+      chunk.md5 = md5
+      chunk.sha256 = sha256
+      chunk.restore!
+      fd.write(chunk.data)
+      size += chunk.length
+      md5hashing << chunk.data
+      sha256hashing << chunk.data
+    }
+    fd.close()
+    # Recover the file information
+    @source.set_stat(@filename, @mtime, @mode, @uid, @gid)
+    @cui.error("File size mismatch in file #{@filename}: #{sha256}.#{md5}") if size != @size
+    # Now get the hashes for the whole file and compare them
+    md5 = md5hashing.hexdigest
+    sha256 = sha256hashing.hexdigest
+    if (@md5 = md5) and (@sha256 = sha256) then
+      @cui.message("File verified")
+    else
+      @cui.error("Checksum error in file #{@filename}: #{sha256}.#{md5}")
+    end
+  end
+
+  def restore_link()
+    @source.symlink(@filename, @target)
+    # @source.set_stat(@filename, Time.now, @mode, @uid, @gid)
+  end
+
+  def restore_dir()
+    if !(@source.exists?(@filename)) then
+      @source.mkdir(@filename)
+      @source.set_stat(@filename, @mtime, @mode, @uid, @gid)
+    end
+  end
+
+  def parse_metadata
+    chunk_data = /\[chunks\]\n([0-9a-zA-Z]{64}\.[0-9a-zA-Z]{32}\n)+/.match(@metadata)
+    chunk_data = chunk_data.to_s
+    chunk_data = chunk_data.split("\n")
+    chunk_data.delete_at(0)
+    @chunks = chunk_data
+    @metadata.lines { | line |
+      case
+        when line =~ /^[a-z0-9A-Z]+ = /
+          field = /^([a-z0-9A-Z]+) = /.match(line).captures[0]
+          case field
+            when "filename"
+              @filename = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0]
+            when "ftype"
+              @ftype = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0]
+            when "mtime"
+              @mtime = Time.rfc2822(/^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0])
+            when "mode"
+              @mode = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0].oct
+            when "uid"
+              @uid = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0].to_i
+            when "gid"
+              @gid = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0].to_i
+            when "size"
+              @size = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0].to_i
+            when "md5"
+              @md5 = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0]
+            when "sha256"
+              @sha256 = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0]
+            when "target"
+              @target = /^[a-z0-9A-Z]+ = (.*)$/.match(line).captures[0]
+          end
+      end
+    }
+  end
+
+  def meta_md5()
+    return @meta_md5 if @meta_md5
+    @meta_md5 = Digest::MD5.hexdigest(@metadata)
+  end
+
+  def meta_sha256()
+    return @meta_sha256 if @meta_sha256
+    @meta_sha256 = Digest::SHA2.new(256).hexdigest(@metadata)
+  end
+
+  def size()
+    @size
+  end
+
+  def mtime()
+    @mtime
+  end
+end

data/classes/Source.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require 'singleton'
+require 'find'
+
+$options = nil unless $options
+
+class Source
+  include Singleton
+
+  def initialize()
+    @cui = Cui.instance
+    @files = nil
+    raise "Source (#{$options[:source]}) is not a directory" if !(File.directory?($options[:source]))
+    # Remove line endings if necessary
+    $options[:excl_incl].each { | s | s.chomp! }
+  end
+
+  def exists?(path = '')
+    File.exists?($options[:source] + path)
+  end
+
+  def open_read(path)
+    File.new($options[:source] + path, 'rb+')
+  end
+
+  def open_write(path)
+    File.new($options[:source] + path, 'wb+')
+  end
+
+  def mkdir(path)
+    Dir.mkdir($options[:source] + path)
+  end
+
+  def ftype(path)
+    File.ftype($options[:source] + path)
+  end
+
+  def lstat(path)
+    File.lstat($options[:source] + path)
+  end
+
+  def readlink(path)
+    File.readlink($options[:source] + path)
+  end
+
+  def symlink(path, target)
+    File.symlink(target, $options[:source] + path)
+  end
+
+  def set_stat(path, mtime, mode, uid, gid)
+    if File.lstat($options[:source] + path).ftype != 'link' then
+      File.utime(0, mtime, $options[:source] + path)
+      File.chmod(mode, $options[:source] + path)
+      File.chown(uid, gid, $options[:source] + path)
+    end
+  end
+
+  def files(rescan = false)
+    if not rescan then
+      return @files if @files
+    end
+    @files = Array.new
+    options_source_length = $options[:source].length
+    Find.find($options[:source]) { | f |
+      # Remove the leading full path
+      f = f[(options_source_length)..99999]
+      f = '/' if f.empty?
+      include = true # by default include everything
+      # Now loop over the include/exclude globs
+      $options[:excl_incl].each { | ei |
+        what = ei[0..0] # First character, this syntax is required for ruby 1.8
+        glob = ei[1..99999] # More than a hundred thousand characters? bad luck...
+        case what # Check the glob for a match and update include variable
+          when '-'
+            include = false # glob matched but was an exclude
+          when '+'
+            include = true # glob matched and is an include
+        end if File.fnmatch(glob, f)
+      }
+      if include then
+        size = 0
+        size = File.size($options[:source] + f) if File.file?($options[:source] + f)
+        @cui.total_size_add(size)
+        @cui.total_files_inc
+        @files << f
+      else
+        Find.prune # Skip directories or files if they are not to be included
+      end
+    }
+    @files
+  end
+end