directory_watcher 1.4.1 → 1.5.1

data/lib/directory_watcher/coolio_scanner.rb

@@ -9,174 +9,108 @@ if DirectoryWatcher::HAVE_COOLIO
 
 # The CoolioScanner uses the Coolio loop to monitor changes to files in the
 # watched directory. This scanner is more efficient than the pure Ruby
-# scanner because it relies on the operating system kernel notifictions
+# scanner because it relies on the operating system kernel notifications
 # instead of a periodic polling and stat of every file in the watched
 # directory (the technique used by the Scanner class).
 #
-class DirectoryWatcher::CoolioScanner < ::DirectoryWatcher::Scanner
-
+# Coolio cannot notify us when a file is added to the watched
+# directory; therefore, added files are only picked up when we apply the
+# glob pattern to the directory. This is done at the configured interval.
+#
+class DirectoryWatcher::CoolioScanner < DirectoryWatcher::EventableScanner
   # call-seq:
-  #    CoolioScanner.new { |events| block }
-  #
-  # Create a Coolio based scanner that will generate file events and pass
-  # those events (as an array) to the given _block_.
+  #    CoolioScanner.new( config )
   #
-  def initialize( &block )
-    super(&block)
-    @watchers = {}
+  def initialize( config )
+    super(config)
   end
 
-  # Start the Coolio scanner loop. If the scanner is already running, this method
-  # will return without taking any action.
+  # Called by EventablScanner#start to start the loop up and attach the periodic
+  # timer that will poll the globs for new files.
   #
-  def start
-    return if running?
-
-    @timer = Timer.new self
-    @thread = Thread.new {
-      coolio_loop = Thread.current._coolio_loop
-      @files.keys.each do |fn|
-        if test ?e, fn
-          _watch_file fn
-          next
-        end
-
-        @files.delete fn
-        @events << ::DirectoryWatcher::Event.new(:removed, fn)
-      end
-
-      @timer.attach(coolio_loop)
-      coolio_loop.run
+  def start_loop_with_attached_scan_timer
+    return if @loop_thread
+    @timer = ScanTimer.new( self )
+    @loop_thread = Thread.new {
+      @timer.attach(event_loop)
+      event_loop.run
     }
   end
 
-  # Stop the Coolio scanner loop. If the scanner is already stopped, this method
-  # will return without taking any action.
+  # Called by EventableScanner#stop to stop the loop as part of the shutdown
+  # process.
   #
-  def stop
-    return unless running?
-
-    @timer.detach
-    @timer = nil
-
-    @watchers.each_value {|w| w.detach}
-    @watchers.clear
-
-    notify
-
-    @thread._coolio_loop.stop rescue nil
-    @thread.kill    # for some reason the rev loop is not returning after stopping
-    @thread = nil
+  def stop_loop
+    if @loop_thread then
+      event_loop.stop rescue nil
+      @loop_thread.kill
+      @loop_thread = nil
+    end
   end
 
-  # :stopdoc:
+  # Return the cool.io loop object.
   #
-  # This callback is invoked by a Watcher instance when some change has
-  # occured on the file. The scanner determines if the file has been
-  # modified or deleted and notifies the directory watcher accordingly.
+  # This is used during the startup, shutdown process and for the Watcher to
+  # attach and detach from the event loop
   #
-  def _on_change( watcher )
-    fn = watcher.path
-    stat = watcher.stat
-
-    if stat
-      if @files[fn] != stat
-        @files[fn] = stat
-        @events << ::DirectoryWatcher::Event.new(:modified, fn)
-      end
+  def event_loop
+    if @loop_thread then
+      @loop_thread._coolio_loop
     else
-      watcher.detach
-      @watchers.delete fn
-      @files.delete fn
-      @events << ::DirectoryWatcher::Event.new(:removed, fn)
+      Thread.current._coolio_loop
     end
-
-    notify
   end
 
-  # This callback is invoked by the Timer instance when it is triggered by
-  # the Coolio loop. This method will check for added files and stable files
-  # and notify the directory watcher accordingly.
-  #
-  def _on_timer
-    _find_added
-    _find_stable
-    notify
-  end
-  # :startdoc:
-
-
-  private
-
-  # From the list of files in the watched directory, find those that we are
-  # not currently watching and add them to the watch list. Generate "added"
-  # events for those newly found files.
+  # :stopdoc:
   #
-  def _find_added
-    cur = list_files
-    prev = @files.keys
-    added = cur - prev
-
-    added.each do |fn|
-      @files[fn] = _watch_file(fn).stat
-      @events << ::DirectoryWatcher::Event.new(:added, fn)
-    end
-  end
-
-  # Iterate over the FileStat instances looking for those with non-nil
-  # stable counts. Decrement these counts and generate "stable" events for
-  # those files whose count reaches zero.
+  # Watch files using the Coolio StatWatcher.
   #
-  def _find_stable
-    @files.each do |fn, stat|
-      next if stat.stable.nil?
-      stat.stable -= 1
-      if stat.stable <= 0
-        @events << ::DirectoryWatcher::Event.new(:stable, fn)
-        stat.stable = nil
-      end
-    end
-  end
-
-  # Create and return a new Watcher instance for the given filename _fn_.
+  # This class is required by EventableScanner to institute file watching.
   #
-  def _watch_file( fn )
-    w = Watcher.new(fn, self)
-    w.attach(@thread ? @thread._coolio_loop : Thread.current._coolio_loop)
-    @watchers[fn] = w
-  end
-
-  # :stopdoc:
+  # The coolio +on_change+ callback is converted to the appropriate +on_removed+
+  # and +on_modified+ callbacks for the EventableScanner.
   #
   class Watcher < Coolio::StatWatcher
-    def initialize( fn, scanner )
-      super(fn, scanner.interval)
-      @scanner = scanner
+    def self.watch(fn, scanner )
+      new(fn, scanner)
     end
 
-    def on_change( *args )
-      @scanner._on_change self
+    def initialize( fn, scanner )
+      # for file watching, we want to make sure this happens at a reasonable
+      # value, so set it to 0 if the scanner.interval is > 5 seconds. This will
+      # make it use the system value, and allow us to test.
+      i = scanner.interval < 5 ? scanner.interval : 0
+      super(fn, i)
+      @scanner = scanner
+      attach(scanner.event_loop)
     end
 
-    def stat
-      return unless test ?e, path
-      stat = File.stat path
-      ::DirectoryWatcher::FileStat.new(stat.mtime, stat.size, @scanner.stable)
+    # Cool.io uses on_change so we convert that to the appropriate
+    # EventableScanner calls.
+    #
+    def on_change( prev_stat, current_stat )
+      logger.debug "on_change called"
+      if File.exist?(path) then
+        @scanner.on_modified(self, ::DirectoryWatcher::FileStat.new(path, current_stat.mtime, current_stat.size))
+      else
+        @scanner.on_removed(self, ::DirectoryWatcher::FileStat.for_removed_path(path))
+      end
     end
   end
 
-  class Timer < Coolio::TimerWatcher
+  # Periodically execute a Scan. Hook this into the EventableScanner#on_scan
+  #
+  class ScanTimer< Coolio::TimerWatcher
     def initialize( scanner )
       super(scanner.interval, true)
       @scanner = scanner
     end
 
     def on_timer( *args )
-      @scanner._on_timer
+      @scanner.on_scan
     end
   end
   # :startdoc:
-
 end  # class DirectoryWatcher::CoolioScanner
 
 end  # if DirectoryWatcher::HAVE_COOLIO

data/lib/directory_watcher/em_scanner.rb

@@ -1,4 +1,3 @@
-
 begin
   require 'eventmachine'
   DirectoryWatcher::HAVE_EM = true
@@ -7,13 +6,19 @@ rescue LoadError
 end
 
 if DirectoryWatcher::HAVE_EM
-[:epoll, :kqueue].each {|poll| break if EventMachine.send(poll)}
 
+# Set up the appropriate polling options
+[:epoll, :kqueue].each do |poll|
+  if EventMachine.send("#{poll}?") then
+    EventMachine.send("#{poll}=", true )
+    break
+  end
+end
 
 # The EmScanner uses the EventMachine reactor loop to monitor changes to
 # files in the watched directory. This scanner is more efficient than the
 # pure Ruby scanner because it relies on the operating system kernel
-# notifictions instead of a periodic polling and stat of every file in the
+# notifications instead of a periodic polling and stat of every file in the
 # watched directory (the technique used by the Scanner class).
 #
 # EventMachine cannot notify us when a file is added to the watched
@@ -27,194 +32,117 @@ if DirectoryWatcher::HAVE_EM
 #
 #  * New files are detected only when the watched directory is polled at the
 #    configured interval.
-# 
-class DirectoryWatcher::EmScanner < ::DirectoryWatcher::Scanner
-
+#
+class DirectoryWatcher::EmScanner < DirectoryWatcher::EventableScanner
   # call-seq:
-  #    EmScanner.new { |events| block }
-  #
-  # Create an EventMachine based scanner that will generate file events and
-  # pass those events (as an array) to the given _block_.
+  #    EmScanner.new( configuration )
   #
-  def initialize( &block )
-    super(&block)
-    @timer = nil
-    @run_loop = lambda {_run_loop}
-    @watchers = {}
+  def initialize( config )
+    super(config)
   end
 
-  # Returns +true+ if the scanner is currently running. Returns +false+ if
-  # this is not the case.
+  # Called by EventablScanner#start to start the loop up and attach the periodic
+  # timer that will poll the globs for new files.
   #
-  def running?
-    !@timer.nil?
-  end
-
-  # Start the EventMachine scanner. If the scanner has already been started
-  # this method will return without taking any action.
-  #
-  # If the EventMachine reactor is not running, it will be started by this
-  # method.
-  #
-  def start
-    return if running?
-
+  def start_loop_with_attached_scan_timer
+    return if @loop_thread
     unless EventMachine.reactor_running?
-      @thread = Thread.new {EventMachine.run}
+      @loop_thread = Thread.new {EventMachine.run}
       Thread.pass until EventMachine.reactor_running?
     end
 
-    @files.keys.each do |fn|
-      if test ?e, fn
-        _watch_file fn
-        next
-      end
-
-      @files.delete fn
-      @events << ::DirectoryWatcher::Event.new(:removed, fn)
-    end
-
-    _run_loop
+    @timer = ScanTimer.new(self)
   end
 
-  # Stop the EventMachine scanner. If the scanner is already stopped this
-  # method will return without taking any action.
+  # Called by EventableScanner#stop to stop the loop as part of the shutdown
+  # process.
   #
-  # The EventMachine reactor will _not_ be stopped by this method. It is up
-  # to the user to stop the reactor using the EventMachine#stop_event_loop
-  # method.
-  #
-  def stop
-    return unless running?
-
-    EventMachine.cancel_timer @timer rescue nil
-    @timer = nil
-
-    @watchers.each_value {|w| w.stop_watching if w.active?}
-    @watchers.clear
-
-    notify
+  def stop_loop
+    if @loop_thread then
+      EventMachine.next_tick do
+        EventMachine.stop_event_loop
+      end
+      @loop_thread.kill
+      @loop_thread = nil
+    end
   end
 
-  # call-seq:
-  #    join( limit = nil )
+  # :stopdoc:
   #
-  # This is a no-op method for the EventMachine file scanner.
+  # This is our tailored implementation of the EventMachine FileWatch class.
+  # It receives notifications of file events and provides a mechanism to
+  # translate the EventMachine events into objects to send to the Scanner that
+  # it is initialized with.
   #
-  def join( limit = nil )
-  end
-
-  # :stopdoc:
+  # The Watcher only responds to modified and deleted events.
   #
-  # This callback is invoked by a Watcher instance when some event has
-  # occured on the file. The scanner determines if the file has been
-  # modified or deleted and notifies the directory watcher accordingly.
+  # This class is required by EventableScanner to institute file watching.
   #
-  def _event!( watcher )
-    fn = watcher.path
-    stat = watcher.stat
-
-    if stat
-      _watch_file fn unless watcher.active?
-      @files[fn] = stat
-      @events << ::DirectoryWatcher::Event.new(:modified, fn)
-    else
-      if watcher.active?
-        watcher.stop_watching
-        @watchers.delete fn
-      end
-      @files.delete fn
-      @events << ::DirectoryWatcher::Event.new(:removed, fn)
+  class Watcher < EventMachine::FileWatch
+    def self.watch( path, scanner )
+      EventMachine.watch_file path, Watcher, scanner
     end
 
-    notify
-  end
-  # :startdoc:
- 
-
-  private
-
-  # EventMachine cannot notify us when new files are added to the watched
-  # directory. The event loop will run at the configured interval and look
-  # for files that have been added or files that have become stable.
-  #
-  def _run_loop
-    start = Time.now.to_f
-
-    _find_added
-    _find_stable
-
-    notify
-
-    nap_time = @interval - (Time.now.to_f - start)
-    nap_time = 0.001 unless nap_time > 0
-    @timer = EventMachine.add_timer nap_time, @run_loop
-  end
+    # Initialize the Watcher using with the given scanner
+    # Post initialization, EventMachine will set @path
+    #
+    def initialize( scanner )
+      @scanner = scanner
+    end
 
-  # From the list of files in the watched directory, find those that we are
-  # not currently watching and add them to the watch list. Generate "added"
-  # events for those newly found files.
-  #
-  def _find_added
-    cur = list_files
-    prev = @files.keys
-    added = cur - prev
+    # EventMachine callback for when a watched file is deleted. We convert this
+    # to a FileStat object for a removed file.
+    #
+    def file_deleted
+      @scanner.on_removed(self, ::DirectoryWatcher::FileStat.for_removed_path(@path))
+    end
+    # Event Machine also sends events on file_moved which we'll just consider a
+    # file deleted and the file added event will be picked up by the next scan
+    alias :file_moved :file_deleted
 
-    added.each do |fn|
-      @files[fn] = _watch_file(fn).stat
-      @events << ::DirectoryWatcher::Event.new(:added, fn)
+    # EventMachine callback for when a watched file is modified. We convert this
+    # to a FileStat object and send it to the collector
+    def file_modified
+      stat = File.stat @path
+      @scanner.on_modified(self, ::DirectoryWatcher::FileStat.new(@path, stat.mtime, stat.size))
     end
-  end
 
-  # Iterate over the FileStat instances looking for those with non-nil
-  # stable counts. Decrement these counts and generate "stable" events for
-  # those files whose count reaches zero.
-  #
-  def _find_stable
-    @files.each do |fn, stat|
-      next if stat.stable.nil?
-      stat.stable -= 1
-      if stat.stable <= 0
-        @events << ::DirectoryWatcher::Event.new(:stable, fn)
-        stat.stable = nil
+    # Detach the watcher from the event loop.
+    #
+    # Required by EventableScanner as part of the shutdown process.
+    #
+    def detach
+      EventMachine.next_tick do
+        stop_watching
       end
     end
   end
 
-  # Create and return a new Watcher instance for the given filename _fn_.
+  # Periodically execute a Scan.
   #
-  def _watch_file( fn )
-    @watchers[fn] = EventMachine.watch_file fn, Watcher, self
-  end
-
-  # :stopdoc:
+  # This object is used by EventableScanner to during shutdown.
   #
-  # This is our tailored implementation of the EventMachine FileWatch class.
-  # It receives notifications of file events and provides a mechanism to
-  # translate the EventMachine events into DirectoryWatcher events.
-  #
-  class Watcher < EventMachine::FileWatch
+  class ScanTimer
     def initialize( scanner )
       @scanner = scanner
-      @active = true
+      @timer = EventMachine::PeriodicTimer.new( @scanner.interval, method(:on_scan) )
     end
 
-    def stat
-      return unless test ?e, @path
-      stat = File.stat @path
-      ::DirectoryWatcher::FileStat.new(stat.mtime, stat.size, @scanner.stable)
+    def on_scan
+      @scanner.on_scan
     end
 
-    def active?() @active; end
-    def event!() @scanner._event!(self); end
-    def unbind() @active = false; end
-    def file_deleted() EventMachine.next_tick {event!}; end
-
-    alias :file_modified :event!
-    alias :file_moved :event!
+    # Detach the watcher from the event loop.
+    #
+    # Required by EventableScanner as part of the shutdown process.
+    #
+    def detach
+      EventMachine.next_tick do
+        @timer.cancel
+      end
+    end
   end
   # :startdoc:
-
 end  # class DirectoryWatcher::EmScanner
 end  # if HAVE_EM