easy_sync 0.0.5 → 2.0.0

data/lib/easy_sync/config.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module EasySync
+  # Loads ~/.easy_sync/config.yml, writing a commented sample on first run.
+  # The file is flat: its keys are the settings below.
+  class Config
+    HOME_DIR = File.join(Dir.home, '.easy_sync')
+    DEFAULT_FILENAME = 'config.yml'
+
+    DEFAULTS = {
+      # Each top-level folder of a share is placed on its own (kept on the
+      # same drive as the rest of the share while it fits); loose top-level
+      # files form one more unit. See docs/fine-placement.md.
+      sources: [{ path: '/Volumes/photos' }, { path: '/Volumes/tv' }, { path: '/Volumes/movies' }],
+      mount_root: '/Volumes',
+      reserve: '2gb',       # headroom placement always leaves on a drive: APFS metadata, the .easy_sync copies, rsync temp files
+      keep_awake: true,     # hold off idle sleep (caffeinate) for the length of a sync, on macOS
+      keep_logs: 20,        # run logs kept under log_dir
+      purge: true,          # remove files from the backup once they have been gone from the NAS long enough
+      grace_days: 7,        # ...at least this many days
+      grace_runs: 2,        # ...and confirmed missing on at least this many separate runs
+      scrub_stale_days: 30, # a drive is overdue for `scrub` once it's been this long since it was last fully checked
+      scrub_jobs: 4,        # `scrub --all`/named targets scrub this many drives at once by default
+      # The tripwire (docs/tripwire.md): stop a sync that would overwrite or
+      # lose far more existing files on the drives than the library ever
+      # changes normally. Report-only until tripwire_enforce is true.
+      tripwire_enforce: false,
+      tripwire_run_files: 500,    # whole run: stop everything at this many changed files (0 turns it off)
+      tripwire_folder_files: 50,  # one folder: at least this many changed files...
+      tripwire_folder_ratio: 0.25, # ...and at least this share of its files on the drive
+      # Names skipped when choosing folders to place AND passed to every rsync as
+      # --exclude, so they are never copied at any depth (Synology recycle bins and
+      # thumbnail dirs, Synology Drive's .sync, macOS metadata, SMB leftovers).
+      exclude_folders: ['#recycle', '@eaDir', '.DS_Store', '.sync', '.TemporaryItems', '.Trashes',
+                        '.smbdelete*', '.com.apple.timemachine.supported*', '.Spotlight-V100', '.fseventsd'],
+      rsync_args: []
+    }.freeze
+
+    PATH_KEYS = %i[manifest_path dashboard_path lock_path log_dir mount_root].freeze
+
+    # Comments written next to each key when the file is (re)written.
+    KEY_COMMENTS = {
+      sources: 'NAS shares, as mounted on this Mac. Manage with: easy_sync add-source / remove-source / sources',
+      mount_root: 'where the backup drives appear',
+      manifest_path: nil, dashboard_path: nil,
+      lock_path: 'refuses a second concurrent sync',
+      log_dir: 'one log per sync run', keep_logs: nil,
+      reserve: 'headroom placement always leaves on a drive',
+      keep_awake: 'caffeinate for the length of a sync',
+      purge: 'delete from the drives only after...',
+      grace_days: '...this many days missing on the NAS',
+      grace_runs: '...confirmed on this many separate runs',
+      scrub_stale_days: 'a drive is overdue for `scrub` after this many days unchecked',
+      scrub_jobs: '`scrub --all`/named targets scrub this many drives at once by default',
+      tripwire_enforce: 'false: the tripwire only reports what would have stopped a sync',
+      tripwire_run_files: 'stop a sync that would change this many existing files (0: off)',
+      tripwire_folder_files: 'hold back a folder with at least this many changed files...',
+      tripwire_folder_ratio: '...that are at least this share of its files',
+      exclude_folders: 'never placed, and excluded from every rsync at any depth',
+      rsync_args: 'extra arguments appended to every rsync'
+    }.freeze
+
+    SAMPLE = <<~YAML
+      # easy_sync configuration. Add your NAS shares with:
+      #   easy_sync add-source /Volumes/<share>
+      :sources: []
+      :mount_root: "/Volumes"                 # where the backup drives appear
+      :manifest_path: "~/.easy_sync/manifest.sqlite3"
+      :dashboard_path: "~/.easy_sync/dashboard.html"
+      :lock_path: "~/.easy_sync/jbod.lock"    # refuses a second concurrent sync
+      :log_dir: "~/.easy_sync/logs"           # one log per sync run
+      :keep_logs: 20
+      :reserve: "2gb"                         # headroom placement always leaves on a drive
+      :keep_awake: true                       # caffeinate for the length of a sync
+      :purge: true                            # delete from the drives only after...
+      :grace_days: 7                          # ...this many days missing on the NAS
+      :grace_runs: 2                          # ...confirmed on this many separate runs
+      :scrub_stale_days: 30                   # a drive is overdue for `scrub` after this many days unchecked
+      :scrub_jobs: 4                          # `scrub --all`/named targets scrub this many drives at once by default
+      :tripwire_enforce: false                # false: the tripwire only reports what would have stopped a sync
+      :tripwire_run_files: 500                # stop a sync that would change this many existing files (0: off)
+      :tripwire_folder_files: 50              # hold back a folder with at least this many changed files...
+      :tripwire_folder_ratio: 0.25            # ...that are at least this share of its files
+      :exclude_folders: ["#recycle", "@eaDir", ".DS_Store", ".sync", ".TemporaryItems", ".Trashes",
+                         ".smbdelete*", ".com.apple.timemachine.supported*", ".Spotlight-V100", ".fseventsd"]
+      :rsync_args: []                         # extra arguments appended to every rsync
+    YAML
+
+    def self.default_path
+      File.join(HOME_DIR, DEFAULT_FILENAME)
+    end
+
+    # DEFAULTS with the home-relative paths resolved now rather than at load
+    # time, so HOME_DIR is honoured wherever it points (tests redirect it).
+    def self.defaults
+      DEFAULTS.merge(manifest_path: File.join(HOME_DIR, 'manifest.sqlite3'),
+                     dashboard_path: File.join(HOME_DIR, 'dashboard.html'),
+                     lock_path: File.join(HOME_DIR, 'jbod.lock'),
+                     log_dir: File.join(HOME_DIR, 'logs'))
+    end
+
+    # Loads the config at +path+, writing the sample first if it is missing.
+    # Returns [config, status] where status is :generated or nil.
+    def self.load(path = default_path)
+      status = nil
+      unless File.exist?(path)
+        write_sample(path)
+        status = :generated
+      end
+      data = YAML.safe_load_file(path, permitted_classes: [Symbol], symbolize_names: true) || {}
+      [new(data, path: path), status]
+    end
+
+    def self.write_sample(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, SAMPLE)
+    end
+
+    # Renders +data+ as commented YAML: sources first, then the known keys in
+    # order, then anything else. Comments come from KEY_COMMENTS.
+    def self.dump(data)
+      out = +"# easy_sync configuration. Managed by `easy_sync add-source` and friends;\n# editing by hand is fine too.\n"
+      order = [:sources] + DEFAULTS.keys.reject { |k| k == :sources } + (data.keys - DEFAULTS.keys - [:sources])
+      order.uniq.each do |key|
+        next unless data.key?(key)
+
+        value = data[key]
+        comment = KEY_COMMENTS[key]
+        if key == :sources
+          sources = Array(value)
+          out << "#{(sources.empty? ? ':sources: []' : ':sources:').ljust(40)}# #{comment}\n"
+          sources.each do |src|
+            out << "- :path: #{(src.is_a?(Hash) ? src[:path] : src).to_s.inspect}\n"
+          end
+        elsif (value.is_a?(Array) || value.is_a?(Hash)) && !value.empty?
+          # Collections always go in block form under the key; a one-element
+          # array rendered inline is not valid YAML.
+          out << "#{":#{key}:".ljust(40)}#{comment ? "# #{comment}" : ''}".rstrip << "\n"
+          YAML.dump(value).sub(/\A---\s?/, '').lines.each { |l| out << "  #{l.chomp}\n" unless l.strip.empty? }
+        else
+          rendered = value.is_a?(Array) || value.is_a?(Hash) ? (value.is_a?(Array) ? '[]' : '{}') \
+                                                            : YAML.dump(value).sub(/\A---\s?/, '').lines.map(&:chomp).reject { |l| l == '...' }.join
+          line = ":#{key}: #{rendered}"
+          out << (comment ? "#{line.ljust(40)}# #{comment}\n" : "#{line}\n")
+        end
+      end
+      out
+    end
+
+    # Writes the current data back to +path+ (or the path it was loaded from).
+    def save(to = path)
+      raise Error, 'no config path to save to' unless to
+
+      FileUtils.mkdir_p(File.dirname(to))
+      File.write(to, self.class.dump(data))
+      to
+    end
+
+    # -- sources, as the CLI edits them --------------------------------
+
+    def source_entries
+      Array(data[:sources]).map { |e| { path: (e.is_a?(Hash) ? e[:path] : e).to_s } }
+    end
+
+    def add_source(path)
+      raise Error, "#{path} is already a source" if source_entries.any? { |e| e[:path] == path }
+
+      data[:sources] = source_entries + [{ path: path }]
+    end
+
+    def remove_source(path)
+      before = source_entries
+      data[:sources] = before.reject { |e| e[:path] == path }
+      raise Error, "#{path} is not a source" if data[:sources].size == before.size
+    end
+
+    attr_reader :data, :path
+
+    def initialize(data, path: nil)
+      @data = data
+      @path = path
+    end
+
+    def [](key) = settings[key]
+
+    # Merged settings with `~` expanded in every path, so a config copied
+    # from the README ("~/.easy_sync/...") never creates a literal "~" directory.
+    def settings
+      merged = self.class.defaults.merge(data)
+      PATH_KEYS.each { |k| merged[k] = File.expand_path(merged[k]) if merged[k].is_a?(String) }
+      merged[:sources] = Array(merged[:sources]).map do |e|
+        { path: File.expand_path((e.is_a?(Hash) ? e[:path] : e).to_s) }
+      end
+      merged[:config_path] = path   # so a copy of the config can travel with the drives
+      merged[:reserve_bytes] = Jbod::Placement.parse_size(merged[:reserve])
+      merged
+    end
+  end
+end

data/lib/easy_sync/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EasySync
+  class Error < StandardError; end
+end

data/lib/easy_sync/jbod/backblaze.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module EasySync
+  module Jbod
+    # Reads Backblaze Personal's own local state files, read-only, to say
+    # whether each drive's contents have reached Backblaze: the same numbers
+    # its menu-bar icon shows. Backblaze backs up *from the drives*, so a
+    # drive powered off before its upload finishes leaves that data offsite
+    # only on the NAS until the next time it's connected.
+    #
+    # Files used (all under DATA_DIR, world-readable):
+    # - bzvolumes.xml: each volume Backblaze knows, by GUID, with its mount
+    #   point (hex-encoded, with a trailing slash).
+    # - bzreports/bzstat_remainingbackup.xml: files and bytes still to upload,
+    #   per volume GUID.
+    # - bzfilelists/<GUID>_*filelist.dat: rewritten each time Backblaze scans
+    #   that volume, so its mtime is when it last looked for new files.
+    # - bzreports/bzstat_lastbackupcompleted.xml: when a backup pass last
+    #   finished.
+    # The XML is one self-closing tag per line, so attributes are read with a
+    # regex rather than taking on an XML parser dependency.
+    class Backblaze
+      DATA_DIR = '/Library/Backblaze.bzpkg/bzdata'
+
+      Volume = Struct.new(:guid, :mount_point, :remaining_files, :remaining_bytes, :scanned_at, keyword_init: true)
+
+      # +state+ is :uploading (files left), :waiting (nothing left, but
+      # Backblaze hasn't scanned the drive since easy_sync last copied data to
+      # it, so the zero is stale), :done, or :unknown (Backblaze doesn't know
+      # this volume).
+      DriveState = Struct.new(:state, :files, :bytes, :scanned_at, keyword_init: true) do
+        def done? = state == :done
+
+        def label
+          case state
+          when :done then 'up to date'
+          when :uploading
+            "uploading, #{files.to_s.gsub(/(\d)(?=(\d{3})+\z)/, '\1,')} file#{'s' if files != 1} " \
+              "(#{Placement.format_bytes(bytes)}) left"
+          when :waiting then 'not scanned since the last sync'
+          else 'not in Backblaze'
+          end
+        end
+      end
+
+      # serial => DriveState for +drives+ (Drive structs). A drive not
+      # mounted now is looked up at its usual mount point, which is where
+      # Backblaze last saw it.
+      def drive_states(drives, mounted:, mount_root:, last_copied_at:)
+        drives.to_h do |d|
+          mount = mounted[d.serial_number]&.mount_point || File.join(mount_root, d.friendly_name)
+          [d.serial_number, drive_state(mount, last_copied_at[d.serial_number])]
+        end
+      end
+
+      attr_reader :last_completed_at
+
+      # nil when Backblaze isn't installed or its state can't be read: callers
+      # then show nothing at all about it.
+      def self.read(dir = DATA_DIR)
+        return nil unless File.file?(File.join(dir, 'bzvolumes.xml'))
+
+        new(dir)
+      rescue SystemCallError
+        nil
+      end
+
+      def initialize(dir)
+        @dir = dir
+        remaining = tags('bzreports/bzstat_remainingbackup.xml', 'bzvolume').to_h { |a| [a['bzVolumeGuid'], a] }
+        @volumes = tags('bzvolumes.xml', 'bzvolume').to_h do |a|
+          guid = a['bzVolumeGuid']
+          left = remaining[guid] || {}
+          mount = [a['mountPointPathHex'].to_s].pack('H*').chomp('/')
+          [mount, Volume.new(guid: guid, mount_point: mount, remaining_files: left['pervol_remaining_files_numfiles'].to_i,
+                             remaining_bytes: left['pervol_remaining_files_numbytes'].to_i, scanned_at: scanned_at(guid))]
+        end
+        millis = tags('bzreports/bzstat_lastbackupcompleted.xml', 'lastbackupcompleted').first&.fetch('gmt_millis', nil)
+        @last_completed_at = millis && Time.at(millis.to_i / 1000.0).utc
+      end
+
+      def volume(mount_point) = @volumes[mount_point.to_s.chomp('/')]
+
+      # +last_copied_at+ is when easy_sync last copied data onto the drive
+      # (ISO 8601, or nil if never).
+      def drive_state(mount_point, last_copied_at)
+        vol = volume(mount_point) or return DriveState.new(state: :unknown)
+
+        state = if vol.remaining_files.positive? then :uploading
+                elsif vol.scanned_at.nil? || (last_copied_at && vol.scanned_at < Time.parse(last_copied_at)) then :waiting
+                else :done
+                end
+        DriveState.new(state: state, files: vol.remaining_files, bytes: vol.remaining_bytes, scanned_at: vol.scanned_at)
+      end
+
+      private
+
+      def tags(relative, name)
+        path = File.join(@dir, relative)
+        return [] unless File.file?(path)
+
+        File.read(path).scan(/<#{name}\s([^>]*?)\/?>/).map { |(attrs)| attrs.scan(/(\w+)="([^"]*)"/).to_h }
+      end
+
+      def scanned_at(guid)
+        list = Dir.glob(File.join(@dir, 'bzfilelists', "#{guid}_*filelist.dat")).first
+        list && File.mtime(list).utc
+      end
+    end
+  end
+end

data/lib/easy_sync/jbod/benchmarker.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module EasySync
+  module Jbod
+    # `easy_sync benchmark`: measures one mounted drive's sequential write and
+    # read speed by writing a test file into its .easy_sync folder, reading it
+    # back, and deleting it. A falling rate on one drive is an early failure
+    # sign SMART won't necessarily show, so every result is kept (the last
+    # Manifest::BENCHMARKS_KEPT per drive) and compared against the drive's own
+    # earlier runs. Method and baseline numbers: docs/performance.md.
+    #
+    # The only thing it ever writes on the drive is TEST_FILE, inside
+    # DRIVE_DIR (which rsync, scrub and clean never look at). It is removed
+    # again whatever happens, and a leftover from a killed run is removed
+    # before the next one starts.
+    class Benchmarker
+      TEST_FILE = 'benchmark.tmp'
+      NOCACHE_CMD = 48 # F_NOCACHE, macOS only; best effort elsewhere
+      CHUNK_SIZE = 8 * 1024 * 1024
+      # Written round-robin. Generated before the clock starts, so the timing
+      # is the drive's, not Random's (~2.7 GB/s here, enough to cost ~7% of a
+      # 200 MB/s write if done inline). Spinning drives don't compress or
+      # dedupe, so repeating 64 MB of random data is as good as fresh data.
+      POOL_CHUNKS = 8
+      # A drive's own earlier runs vary by about ±7% (docs/performance.md), so
+      # only a drop well past that, against the median of at least
+      # MIN_HISTORY earlier runs, is called out.
+      SLOWER_THRESHOLD = 0.85
+      MIN_HISTORY = 3
+
+      Result = Struct.new(:drive, :bytes, :write_seconds, :read_seconds, :used_bytes, :error, keyword_init: true) do
+        def ok? = error.nil?
+        def write_mb_s = mb_per_s(write_seconds)
+        def read_mb_s = mb_per_s(read_seconds)
+
+        private
+
+        def mb_per_s(seconds) = seconds.to_f.positive? ? (bytes.to_f / seconds) / (1024 * 1024) : 0.0
+      end
+
+      # How one run compares with the same drive's earlier ones. +earlier+
+      # is how many earlier runs the medians come from; the medians are nil
+      # when there are none.
+      Comparison = Struct.new(:earlier, :write_median, :read_median, keyword_init: true) do
+        def write_change(mb_s) = change(mb_s, write_median)
+        def read_change(mb_s) = change(mb_s, read_median)
+
+        def enough? = earlier >= MIN_HISTORY
+
+        # :write and/or :read, for whichever fell below SLOWER_THRESHOLD of its median.
+        def slower(write_mb_s, read_mb_s)
+          return [] unless enough?
+
+          { write: [write_mb_s, write_median], read: [read_mb_s, read_median] }
+            .select { |_, (now, median)| now < median * SLOWER_THRESHOLD }.keys
+        end
+
+        private
+
+        def change(mb_s, median) = median&.positive? ? (mb_s / median) - 1 : nil
+      end
+
+      def self.compare(earlier_runs)
+        median = lambda do |values|
+          sorted = values.sort
+          mid = sorted.size / 2
+          sorted.size.odd? ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2.0
+        end
+        return Comparison.new(earlier: 0) if earlier_runs.empty?
+
+        Comparison.new(earlier: earlier_runs.size, write_median: median.call(earlier_runs.map(&:write_mb_s)),
+                       read_median: median.call(earlier_runs.map(&:read_mb_s)))
+      end
+
+      def initialize(timer: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+        @timer = timer
+      end
+
+      # +mounted_drive+ is a MountedDrive struct. Returns a Result; a failure
+      # (drive unplugged mid-run, disk full, I/O error) is reported in its
+      # +error+ rather than raised, so one bad drive doesn't stop the others.
+      def run(mounted_drive, size:)
+        path = File.join(mounted_drive.mount_point, DRIVE_DIR, TEST_FILE)
+        result = Result.new(drive: mounted_drive.friendly_name, bytes: size, used_bytes: mounted_drive.used_bytes)
+        remove(path)
+        pool = Array.new(POOL_CHUNKS) { Random.bytes(CHUNK_SIZE) }
+        result.write_seconds = timed { write_test_file(path, size, pool) }
+        result.read_seconds = timed { read_test_file(path) }
+        result
+      rescue SystemCallError, IOError => e
+        result.error = File.file?(File.join(mounted_drive.mount_point, MARKER_FILE)) ? e.message : 'unmounted mid-run'
+        result
+      ensure
+        remove(path)
+      end
+
+      private
+
+      def timed
+        started = @timer.call
+        yield
+        @timer.call - started
+      end
+
+      # The closing fsync is inside the timing: without it this measures how
+      # fast macOS accepts writes into RAM, not how fast the drive stores them.
+      def write_test_file(path, size, pool)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'wb') do |io|
+          nocache(io)
+          written = 0
+          i = 0
+          while written < size
+            chunk = pool[i % pool.size]
+            chunk = chunk.byteslice(0, size - written) if size - written < chunk.bytesize
+            written += io.write(chunk)
+            i += 1
+          end
+          io.fsync
+        end
+      end
+
+      # F_NOCACHE alone still serves pages already in the cache; evicting
+      # first makes the read come off the platter (see PageCache).
+      def read_test_file(path)
+        buffer = String.new(capacity: CHUNK_SIZE)
+        File.open(path, 'rb') do |io|
+          nocache(io)
+          PageCache.evict(io)
+          nil while io.read(CHUNK_SIZE, buffer)
+        end
+      end
+
+      def nocache(io)
+        io.fcntl(NOCACHE_CMD, 1)
+      rescue SystemCallError, NotImplementedError
+        nil # best effort: not every filesystem/platform supports F_NOCACHE
+      end
+
+      def remove(path)
+        File.delete(path) if File.exist?(path)
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/easy_sync/jbod/cleaner.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module EasySync
+  module Jbod
+    # `easy_sync clean`: removes from the drives, right away, anything whose
+    # name matches exclude_folders. Such entries only exist because they were
+    # copied before the exclusion did (or before the exclusion was added), so
+    # there is no reason to wait out the deletion grace period for them. Walks
+    # only the destinations of placed folders, so a drive's own .easy_sync and
+    # anything not managed here is never touched.
+    class Cleaner
+      Result = Struct.new(:removed, :bytes, :would_remove, keyword_init: true) do
+        def initialize(**)
+          super
+          self.removed ||= []
+          self.would_remove ||= []
+          self.bytes ||= 0
+        end
+      end
+
+      def initialize(manifest, excludes:, out: $stdout)
+        @manifest = manifest
+        @excludes = Array(excludes)
+        @out = out
+      end
+
+      # +mounted+ are MountedDrive structs. Returns a Result.
+      def run(mounted, dry_run: false)
+        result = Result.new
+        mounted.each do |drive|
+          @manifest.folders_on(drive.serial_number).each do |folder|
+            base = File.join(drive.mount_point, folder.folder_path)
+            next unless Dir.exist?(base)
+
+            matches_under(base, descend: !folder.root?).each do |path|
+              rel = path.delete_prefix("#{base}/")
+              size = size_of(path)
+              if dry_run
+                @out.puts "  would remove #{folder.folder_path}/#{rel} (#{Placement.format_bytes(size)}) from #{drive.friendly_name}"
+                result.would_remove << [folder.folder_path, rel]
+              else
+                kind = File.directory?(path) ? 'dir' : 'file'
+                FileUtils.rm_rf(path)
+                @out.puts "  removed #{folder.folder_path}/#{rel} (#{Placement.format_bytes(size)}) from #{drive.friendly_name}"
+                result.removed << [folder.folder_path, rel]
+                result.bytes += size
+                @manifest.record_cleaned(folder_path: folder.folder_path, relative_path: rel, kind: kind,
+                                         drive_serial: drive.serial_number)
+              end
+            end
+          end
+        end
+        # Junk that was already gone from the drive (removed by hand, say) may
+        # still have pending rows; those need no grace period either.
+        @manifest.forget_pending_matching(@excludes) unless dry_run
+        result
+      end
+
+      private
+
+      # Deepest matches are not needed: removing a matching directory takes
+      # its contents with it, so stop descending at the first match. A
+      # root-files unit (descend: false) owns only its top level.
+      def matches_under(dir, descend: true)
+        found = []
+        Dir.each_child(dir) do |name|
+          path = File.join(dir, name)
+          if excluded?(name)
+            found << path
+          elsif descend && File.directory?(path) && !File.symlink?(path)
+            found.concat(matches_under(path))
+          end
+        end
+        found.sort
+      rescue SystemCallError
+        found
+      end
+
+      def excluded?(name)
+        @excludes.any? { |pat| File.fnmatch?(pat, name, File::FNM_DOTMATCH) }
+      end
+
+      def size_of(path)
+        return File.size(path) unless File.directory?(path)
+
+        Dir.glob(File.join(path, '**', '*'), File::FNM_DOTMATCH).sum { |f| File.file?(f) ? File.size(f) : 0 }
+      end
+
+    end
+  end
+end