listen 2.7.5 → 2.7.6

data/lib/listen/adapter/polling.rb

@@ -6,15 +6,9 @@ module Listen
     # file IO than the other implementations.
     #
     class Polling < Base
-      DEFAULT_POLLING_LATENCY = 1.0
-
-      def self.usable?
-        true
-      end
+      OS_REGEXP = // # match any
 
-      def start
-        Thread.new { _poll_directories }
-      end
+      DEFAULT_POLLING_LATENCY = 1.0
 
       private
 
@@ -22,26 +16,16 @@ module Listen
         listener.options[:latency] || DEFAULT_POLLING_LATENCY
       end
 
-      def _poll_directories
-        _napped_loop do
-          listener.directories.each do |path|
-            _notify_change(path, type: 'Dir', recursive: true)
-          end
-        end
-      end
-
-      def _napped_loop
+      def _run
         loop do
-          _nap_time { yield }
+          start = Time.now.to_f
+          _directories.each do |path|
+            _notify_change(:dir, path, recursive: true)
+            nap_time = _latency - (Time.now.to_f - start)
+            sleep(nap_time) if nap_time > 0
+          end
         end
       end
-
-      def _nap_time
-        start = Time.now.to_f
-        yield
-        nap_time = _latency - (Time.now.to_f - start)
-        sleep(nap_time) if nap_time > 0
-      end
     end
   end
 end

data/lib/listen/adapter/tcp.rb

@@ -1,33 +1,46 @@
 require 'celluloid/io'
 
+require 'listen/tcp/message'
+
 module Listen
   module Adapter
     # Adapter to receive file system modifications over TCP
     class TCP < Base
+      OS_REGEXP = // # match any
+
       include Celluloid::IO
 
       finalizer :finalize
 
       attr_reader :buffer, :socket
 
-      def self.usable?
-        true
-      end
-
       # Initializes and starts a Celluloid::IO-powered TCP-recipient
       def start
+        attempts = 3
         @socket = TCPSocket.new(listener.host, listener.port)
         @buffer = ''
-        run
+        async.run
+      rescue Celluloid::Task::TerminatedError
+        _log :debug, "TCP adapter was terminated: #{$!.inspect}"
+      rescue Errno::ECONNREFUSED
+        sleep 1
+        attempts -= 1
+        _log :warn, "TCP.start: #{$!.inspect}"
+        retry if retries > 0
+        _log :error, "TCP.start: #{$!.inspect}:#{$@.join("\n")}"
+        raise
+      rescue
+        _log :error, "TCP.start: #{$!.inspect}:#{$@.join("\n")}"
+        raise
       end
 
       # Cleans up buffer and socket
       def finalize
         @buffer = nil
-        if @socket
-          @socket.close
-          @socket = nil
-        end
+        return unless @socket
+
+        @socket.close
+        @socket = nil
       end
 
       # Number of bytes to receive at a time
@@ -46,15 +59,15 @@ module Listen
         while (message = Listen::TCP::Message.from_buffer(@buffer))
           handle_message(message)
         end
+      rescue
+        _log :error, "TCP.handle_data crashed: #{$!}:#{$@.join("\n")}"
+        raise
       end
 
       # Handles incoming message by notifying of path changes
       def handle_message(message)
-        message.object.each do |change, paths|
-          paths.each do |path|
-            _notify_change(path, change: change.to_sym)
-          end
-        end
+        type, modification, path, _ = message.object
+        _notify_change(type.to_sym, path, change: modification.to_sym)
       end
 
       def self.local_fs?

data/lib/listen/adapter/windows.rb

@@ -3,8 +3,8 @@ module Listen
     # Adapter implementation for Windows `wdm`.
     #
     class Windows < Base
-      # The message to show when wdm gem isn't available
-      #
+      OS_REGEXP = /mswin|mingw|cygwin/i
+
       BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
         Please add the following to your Gemfile to avoid polling for changes:
           require 'rbconfig'
@@ -14,39 +14,83 @@ module Listen
       EOS
 
       def self.usable?
-        if RbConfig::CONFIG['target_os'] =~ /mswin|mingw|cygwin/i
-          require 'wdm'
-          true
-        end
+        return false unless super
+        require 'wdm'
+        true
       rescue LoadError
+        _log :debug, "wdm - load failed: #{$!}:#{$@.join("\n")}"
         Kernel.warn BUNDLER_DECLARE_GEM
         false
       end
 
-      def start
-        worker = _init_worker
-        Thread.new { worker.run! }
+      private
+
+      def _configure
+        _log :debug, 'wdm - starting...'
+        @worker = WDM::Monitor.new
+        _directories.each do |path|
+          @worker.watch_recursively(path.to_s, :files, &_file_callback)
+          @worker.watch_recursively(path.to_s, :directories, &_dir_callback)
+          @worker.watch_recursively(path.to_s, :attributes, :last_write,
+                                    &_attr_callback)
+        end
       end
 
-      private
+      def _run
+        @worker.run!
+      end
 
-      # Initializes a WDM monitor and adds a watcher for
-      # each directory passed to the adapter.
-      #
-      # @return [WDM::Monitor] initialized worker
-      #
-      def _init_worker
-        WDM::Monitor.new.tap do |worker|
-          _directories_path.each do |path|
-            worker.watch_recursively(path, &_worker_callback)
+      def _file_callback
+        lambda do |change|
+          begin
+            path = _path(change.path)
+            _log :debug, "wdm - FILE callback: #{change.inspect}"
+            options = { change: _change(change.type) }
+            _notify_change(:file, path, options)
+          rescue
+            _log :error, "wdm - callback failed: #{$!}:#{$@.join("\n")}"
+            raise
           end
         end
       end
 
-      def _worker_callback
+      def _attr_callback
         lambda do |change|
-          options = { type: 'File', change: _change(change.type) }
-          _notify_change(_path(change.path), options)
+          begin
+            path = _path(change.path)
+            return if path.directory?
+
+            _log :debug, "wdm - ATTR callback: #{change.inspect}"
+            options = { change: _change(change.type) }
+            _notify_change(:file, _path(change.path), options)
+          rescue
+            _log :error, "wdm - callback failed: #{$!}:#{$@.join("\n")}"
+            raise
+          end
+        end
+      end
+
+      def _dir_callback
+        lambda do |change|
+          begin
+            path = _path(change.path)
+            _log :debug, "wdm - DIR callback: #{change.inspect}"
+            if change.type == :removed
+              _notify_change(:dir, path.dirname)
+            elsif change.type == :added
+              _notify_change(:dir, path)
+            else
+              # do nothing - changed directory means either:
+              #   - removed subdirs (handled above)
+              #   - added subdirs (handled above)
+              #   - removed files (handled by _file_callback)
+              #   - added files (handled by _file_callback)
+              # so what's left?
+            end
+          rescue
+            _log :error, "wdm - callback failed: #{$!}:#{$@.join("\n")}"
+            raise
+          end
         end
       end
 
@@ -55,7 +99,7 @@ module Listen
       end
 
       def _change(type)
-        { modified: [:modified],
+        { modified: [:modified, :attrib], # TODO: is attrib really passed?
           added:    [:added, :renamed_new_file],
           removed:  [:removed, :renamed_old_file] }.each do |change, types|
           return change if types.include?(type)

data/lib/listen/change.rb

@@ -11,41 +11,44 @@ module Listen
       @listener = listener
     end
 
-    def change(path, options)
+    def change(type, path, options = {})
       change = options[:change]
       cookie = options[:cookie]
 
-      unless cookie
-        # TODO: remove silencing here (it's done later)
-        return if _silencer.silenced?(path, options[:type])
+      if !cookie && listener.silencer.silenced?(path, type)
+        _log :debug, "(silenced): #{path.inspect}"
+        return
       end
 
+      log_details = options[:silence] && 'recording' || change || 'unknown'
+      _log :debug, "#{log_details}: #{type}:#{path} (#{options.inspect})"
+
       if change
-        _notify_listener(change, path, cookie ? { cookie: cookie } : {})
+        listener.queue(type, change, path, cookie ? { cookie: cookie } : {})
       else
-        send("_#{options[:type].downcase}_change", path, options)
+        return unless (record = listener.sync(:record))
+        record.async.still_building! if options[:build]
+
+        if type == :dir
+          return unless (change_queue = listener.async(:change_pool))
+          Directory.scan(change_queue, record, path, options)
+        else
+          change = File.change(record, path)
+          return if !change || options[:silence]
+          listener.queue(:file, change, path)
+        end
       end
+    rescue Celluloid::Task::TerminatedError
+      _log :debug, "Change#change was terminated: #{$!.inspect}"
+    rescue RuntimeError
+      _log :error, "Change#change crashed #{$!.inspect}:#{$@.join("\n")}"
+      raise
     end
 
     private
 
-    def _file_change(path, options)
-      change = File.new(listener, path).change
-      if change && listener.listen? && !options[:silence]
-        _notify_listener(change, path)
-      end
-    end
-
-    def _dir_change(path, options)
-      Directory.new(listener, path, options).scan
-    end
-
-    def _notify_listener(change, path, options = {})
-      listener.changes << { change => path }.merge(options)
-    end
-
-    def _silencer
-      listener.registry[:silencer]
+    def _log(type, message)
+      Celluloid.logger.send(type, message)
     end
   end
 end

data/lib/listen/directory.rb

@@ -1,78 +1,67 @@
+require 'set'
+
 module Listen
   class Directory
-    attr_accessor :listener, :path, :options
-
-    def initialize(listener, path, options = {})
-      @listener    = listener
-      @path    = path
-      @options = options
-    end
+    def self.scan(queue, sync_record, path, options = {})
+      return unless (record = sync_record.async)
 
-    def scan
-      _update_record
-      _all_entries.each do |entry_path, data|
-        case data[:type]
-        when 'File'
-          _async_change(entry_path, options.merge(type: 'File'))
-        when 'Dir'
-          if _recursive_scan?(entry_path)
-            _async_change(entry_path, options.merge(type: 'Dir'))
-          end
-        end
-      end
-    end
+      previous = sync_record.dir_entries(path)
 
-    private
+      record.set_path(:dir, path)
+      current = Set.new(path.children)
 
-    def _update_record
-      if ::Dir.exist?(path)
-        _record.async.set_path(path,  type: 'Dir')
+      if options[:silence]
+        _log :debug, "Recording: #{path}: #{options.inspect}"\
+          " [#{previous.inspect}] -> (#{current.inspect})"
       else
-        _record.async.unset_path(path)
+        _log :debug, "Scanning: #{path}: #{options.inspect}"\
+          " [#{previous.inspect}] -> (#{current.inspect})"
       end
-    end
-
-    def _all_entries
-      _record_entries.merge(_entries)
-    end
-
-    def _entries
-      return {} unless ::Dir.exist?(path)
 
-      entries = ::Dir.entries(path) - %w(. ..)
-      entries = entries.map { |entry| [entry, type: _entry_type(entry)] }
-      Hash[*entries.flatten]
-    end
-
-    def _entry_type(entry_path)
-      entry_path = path.join(entry_path)
-      if entry_path.file?
-        'File'
-      elsif entry_path.directory?
-        'Dir'
+      current.each do |full_path|
+        if full_path.directory?
+          _change(queue, :dir, full_path, options)
+        else
+          _change(queue, :file, full_path, options)
+        end
       end
-    end
 
-    def _record_entries
-      future = _record.future.dir_entries(path)
-      future.value
-    end
+      previous.reject! { |entry, _| current.include? path + entry }
+      _async_changes(path, queue, previous, options)
 
-    def _record
-      listener.registry[:record]
+    rescue Errno::ENOENT
+      record.unset_path(path)
+      _async_changes(path, queue, previous, options)
+
+    rescue Errno::ENOTDIR
+      # TODO: path not tested
+      record.unset_path(path)
+      _async_changes(path, queue, previous, options)
+      _change(queue, :file, path, options)
+    rescue
+      _log :warn, "scanning DIED: #{$!}:#{$@.join("\n")}"
+      raise
     end
 
-    def _change_pool
-      listener.registry[:change_pool]
+    def self._async_changes(path, queue, previous, options)
+      previous.each do |entry, data|
+        _change(queue, data[:type], path + entry, options)
+      end
     end
 
-    def _recursive_scan?(path)
-      !::Dir.exist?(path) || options[:recursive]
+    def self._change(queue, type, full_path, options)
+      return queue.change(type, full_path, options) if type == :dir
+      opts = options.dup
+      opts.delete(:recursive)
+      if opts.empty?
+        queue.change(type, full_path)
+      else
+        queue.change(type, full_path, opts)
+      end
     end
 
-    def _async_change(entry_path, options)
-      entry_path = path.join(entry_path)
-      _change_pool.async.change(entry_path, options)
+    def self._log(type, message)
+      Celluloid.logger.send(type, message)
     end
   end
 end

data/lib/listen/file.rb

@@ -1,118 +1,83 @@
 module Listen
   class File
-    attr_accessor :listener, :path, :data, :md5
+    def self.change(record, path)
+      lstat = path.lstat
 
-    def initialize(listener, path)
-      @listener = listener
-      @path = path
-      @data = { type: 'File' }
-    end
-
-    def change
-      if _existing_path? && _modified?
-        _set_record_data
-        :modified
-      elsif _new_path?
-        _set_record_data
-        :added
-      elsif _removed_path?
-        _unset_record_data
-        :removed
-      end
-    end
-
-    private
-
-    def _new_path?
-      _exist? && !_record_data?
-    end
-
-    def _existing_path?
-      _exist? && _record_data?
-    end
-
-    def _removed_path?
-      !_exist?
-    end
-
-    def _record_data?
-      !_record_data.empty?
-    end
-
-    def _exist?
-      @exist ||= ::File.exist?(path)
-    end
-
-    def _modified?
-      _mtime > _record_data[:mtime] || _mode_modified? || _content_modified?
-    end
-
-    def _mode_modified?
-      _mode != _record_data[:mode]
-    end
+      data = { mtime: lstat.mtime.to_f, mode: lstat.mode }
 
-    # Only useful on Darwin because of the file mtime second precision.
-    # Only check if in the same seconds (mtime == current time).
-    # MD5 is eager loaded, so the first time it'll always return false.
-    #
-    def _content_modified?
-      return false unless RbConfig::CONFIG['target_os'] =~ /darwin/i
-      return false unless _mtime.to_i == Time.now.to_i
+      record_data = record.file_data(path)
 
-      _set_md5
-      if _record_data[:md5]
-        md5 != _record_data[:md5]
-      else
-        _set_record_data
-        false
+      if record_data.empty?
+        record.async.set_path(:file, path, data)
+        return :added
       end
-    end
 
-    def _set_record_data
-      @data.merge!(_new_data)
-      _record.async.set_path(path, data)
-    end
-
-    def _unset_record_data
-      _record.async.unset_path(path)
-    end
-
-    def _new_data
-      data = { mtime: _mtime, mode: _mode }
-      data[:md5] = md5 if md5
-      data
-    end
-
-    def _record_data
-      @_record_data ||= _record.future.file_data(path).value
-    end
+      if data[:mode] != record_data[:mode]
+        record.async.set_path(:file, path, data)
+        return :modified
+      end
 
-    def _record
-      listener.registry[:record]
-    end
+      if data[:mtime] != record_data[:mtime]
+        record.async.set_path(:file, path, data)
+        return :modified
+      end
 
-    def _mtime
-      @mtime ||= _lstat.mtime.to_f
+      unless /1|true/ =~ ENV['LISTEN_GEM_DISABLE_HASHING']
+        if self.inaccurate_mac_time?(lstat)
+          # Check if change happened within 1 second (maybe it's even
+          # too much, e.g. 0.3-0.5 could be sufficient).
+          #
+          # With rb-fsevent, there's a (configurable) latency between
+          # when file was changed and when the event was triggered.
+          #
+          # If a file is saved at ???14.998, by the time the event is
+          # actually received by Listen, the time could already be e.g.
+          # ???15.7.
+          #
+          # And since Darwin adapter uses directory scanning, the file
+          # mtime may be the same (e.g. file was changed at ???14.001,
+          # then at ???14.998, but the fstat time would be ???14.0 in
+          # both cases).
+          #
+          # If change happend at ???14.999997, the mtime is 14.0, so for
+          # an mtime=???14.0 we assume it could even be almost ???15.0
+          #
+          # So if Time.now.to_f is ???15.999998 and stat reports mtime
+          # at ???14.0, then event was due to that file'd change when:
+          #
+          # ???15.999997 - ???14.999998 < 1.0s
+          #
+          # So the "2" is "1 + 1" (1s to cover rb-fsevent latency +
+          # 1s maximum difference between real mtime and that recorded
+          # in the file system)
+          #
+          if data[:mtime].to_i + 2 > Time.now.to_f
+            begin
+              md5 = Digest::MD5.file(path).digest
+              record.async.set_path(:file, path, data.merge(md5: md5))
+              :modified if record_data[:md5] && md5 != record_data[:md5]
+
+            rescue SystemCallError
+              # ignore failed md5
+            end
+          end
+        end
+      end
+    rescue SystemCallError
+      record.async.unset_path(path)
+      :removed
     rescue
-      0.0
+      Celluloid::Logger.debug "lstat failed for: #{path} (#{$!})"
+      raise
     end
 
-    def _mode
-      @mode ||= _lstat.mode
-    rescue
-      nil
-    end
+    def self.inaccurate_mac_time?(stat)
+      # 'mac' means Modified/Accessed/Created
 
-    def _lstat
-      @lstat ||= ::File.lstat(path)
-    rescue
-      nil
-    end
+      # Since precision depends on mounted FS (e.g. you can have a FAT partiion
+      # mounted on Linux), check for fields with a remainder to detect this
 
-    def _set_md5
-      @md5 = Digest::MD5.file(path).digest
-    rescue
-      nil
+      [stat.mtime, stat.ctime, stat.atime].map(&:usec).all?(&:zero?)
     end
   end
 end