filewatch 0.2.4 → 0.2.5

data/lib/filewatch/inotify/event.rb

@@ -10,9 +10,18 @@ class FileWatch::Inotify::Event < FFI::Struct
          :len, :uint32
   # last piece is the name, but don't hold it in the struct
          #:name, :string,
+  
+  # helper accessors
+  def wd; return self[:wd]; end
+  def mask; return self[:mask]; end
+  def cookie; return self[:cookie]; end
+  def len; return self[:len]; end
 
   attr_accessor :name
 
+  # This attribute is only set for file renames
+  attr_accessor :old_name
+
   # Enum of :directory or :file
   attr_accessor :type
 
@@ -75,8 +84,10 @@ class FileWatch::Inotify::Event < FFI::Struct
   end
 
   def actions
+    # TODO(sissel): Skip these? 
     ::FileWatch::Inotify::FD::WATCH_BITS.reject do |key, bitmask| 
-      self[:mask] & bitmask == 0 
+      #p key => [self.mask, bitmask] if  self.mask & bitmask != 0 
+      self.mask & bitmask == 0 
     end.keys
   end
 

data/lib/filewatch/inotify/fd.rb

@@ -44,18 +44,20 @@ class FileWatch::Inotify::FD
     :delete => 1 << 9,
     :delete_self => 1 << 10,
     :move_self => 1 << 11,
+  }
 
     # Shortcuts
-    :close => (1 << 3) | (1 << 4),
-    :move => (1 << 6) | (1 << 7) | (1 << 11),
-    :delete => (1 << 9) | (1 << 10),
-  }
+  WATCH_BITS[:close] = WATCH_BITS[:close_write] | WATCH_BITS[:close_nowrite]
+  WATCH_BITS[:move] = WATCH_BITS[:moved_from] \
+                      | WATCH_BITS[:moved_to] | WATCH_BITS[:move_self]
+  WATCH_BITS[:delete] = WATCH_BITS[:delete] | WATCH_BITS[:delete_self]
 
   attr_reader :fd
 
   public
   def self.can_watch?(filestat)
     # TODO(sissel): implement.
+    return true
   end # def self.can_watch?
 
   # Create a new FileWatch::Inotify::FD instance.
@@ -66,9 +68,14 @@ class FileWatch::Inotify::FD
     @watches = {}
     @buffer = FileWatch::StringPipeIO.new
 
-    #@fd = CInotify.inotify_init1(INOTIFY_NONBLOCK)
+    # Can't use inotify_init1 since older kernels don't have it.
+    # Implement nonblock ourselves.
     @fd = CInotify.inotify_init()
 
+    # Track movement cookies # since 'moved_from' and 'moved_to' are separate
+    # events.
+    @movement = {}
+
     if java?
       @io = nil
       @rc = CInotify.fcntl(@fd, F_SETFL, O_NONBLOCK)
@@ -121,19 +128,23 @@ class FileWatch::Inotify::FD
   #   fd.watch("/var/log/messages", :modify)
   public
   def watch(path, *what_to_watch)
-    mask = what_to_watch.inject(0) { |m, val| m |= WATCH_BITS[val] }
+    mask = what_to_watch.uniq.inject(0) { |m, val| m |= WATCH_BITS[val] }
     watch_descriptor = CInotify.inotify_add_watch(@fd, path, mask)
 
     if watch_descriptor == -1
       raise FileWatch::Exception.new(
         "inotify_add_watch(#{@fd}, #{path}, #{mask}) failed. #{$?}", @fd, path)
     end
+
     @watches[watch_descriptor] = {
       :path => path,
       :partial => nil,
       :is_directory => File.directory?(path),
     }
-  end
+    return watch_descriptor
+  end # def watch
+
+  # TODO(sissel): Implement inotify_rm_watch as 'cancel'
 
   private
   def normal_read(timeout=nil)
@@ -151,6 +162,7 @@ class FileWatch::Inotify::FD
 
   private
   def jruby_read(timeout=nil)
+    # TODO(sissel): instantiate this once to prevent extra memory usage? safe?
     @jruby_read_buffer = FFI::MemoryPointer.new(:char, 4096)
 
     # TODO(sissel): Block with select.
@@ -162,9 +174,13 @@ class FileWatch::Inotify::FD
       bytes = CInotify.read(@fd, @jruby_read_buffer, 4096)
 
       # read(2) returns -1 on error, which we expect to be EAGAIN, but...
-      # TODO(sissel): maybe we should check errno properly...
-      # Then again, errno isn't threadsafe, so we'd have to wrap this
-      # in a critical block? Fun times
+      # TODO(sissel): maybe we should check errno properly...  Then again,
+      # errno is supposedly thread-safe, but I believe that is in reference to
+      # pthreads. Ruby's green threads, fibers, etc, are not likely subject to
+      # the same safeties, so we have to assume errno is effed.
+      # This code is run in jruby only, so maybe we can guarantee that
+      # a thread is a pthread and has errno safety. Which leads us to the next
+      # question - how to access errno from jruby/ffi?
       break if bytes == -1
 
       @buffer.write(@jruby_read_buffer.get_bytes(0, bytes))
@@ -176,16 +192,19 @@ class FileWatch::Inotify::FD
   private
   def prepare(event)
     watch = @watches[event[:wd]]
-    watchpath = watch[:path]
+
     if event.name == nil
-      # Some events don't have the name at all, so add our own.
-      event.name = watchpath
+      # Some events don't have the name at all, so add what we know.
+      # This usually occurs on events for files where inotify expects us to
+      # track the file name anyway.
+      event.name = watch[:path]
       event.type = :file
     else
-      # Event paths are relative to the watch, if a directory. Prefix to make
-      # the full path.
+      # In cases where we have event names, they are always(?) directory events
+      # and contain the name of the file changed.  Event paths are relative to
+      # the watch, if a directory. Prefix to make the full path.
       if watch[:is_directory]
-        event.name = File.join(watchpath, event.name)
+        event.name = File.join(watch[:path], event.name)
         event.type = :directory
       end
     end
@@ -239,6 +258,27 @@ class FileWatch::Inotify::FD
     loop do
       event = get
       break if event == nil
+
+      # inotify claims to guarantee order of events, so we should always see
+      # 'moved_from' events before 'moved_to'
+      if event.actions.include?(:moved_from)
+        @movement[event.cookie] = event.name
+      end
+
+      if event.actions.include?(:moved_to) and @movement.include?(event.cookie)
+        event.old_name = @movement[event.cookie]
+        @movement.delete(event.cookie)
+
+        # If we are watching this file, update the path with the new filename
+        @watches.each do |wd, watch|
+          if watch[:path] == event.old_name
+            watch[:old_path] = watch[:path]
+            watch[:path] = event.name
+          end
+        end # @watches.each
+      end # if event.actions.include? :moved_to
+
+      # We're dong mangling the event. Ship it.
       yield event
     end # loop
   end # def each

data/lib/filewatch/tailglob.rb

@@ -30,7 +30,7 @@ class FileWatch::TailGlob
   #   :exclude => array of globs to ignore.
   public
   def tail(glob, options={}, &block)
-    what_to_watch = [ :create, :modify, :delete ]
+    what_to_watch = [ :create, :modify, :delete_self, :move_self ]
 
     # Setup a callback specific to tihs tail call for handling
     # new files found; so we can attach options to each new file.
@@ -80,7 +80,7 @@ class FileWatch::TailGlob
       end
     end
 
-    close(path) if @files.include?(path)
+    close(path) if following?(path)
     @files[path] = File.new(path, "r")
     
     # TODO(sissel): Support 'since'-like support.
@@ -102,6 +102,7 @@ class FileWatch::TailGlob
     @watch.subscribe do |event|
       path = event.name
 
+      p path => event.actions if $DEBUG
       event.actions.each do |action|
         method = "file_action_#{action}".to_sym
         if respond_to?(method)
@@ -166,10 +167,13 @@ class FileWatch::TailGlob
 
   protected
   def close(path)
-    @files[path].close rescue nil
-    @files.delete(path)
+    if following?(path)
+      p :CLOSE => path if $DEBUG
+      @files[path].close rescue nil
+      @files.delete(path)
+    end
     return nil
-  end
+  end # def close
 
   protected
   def file_action_create(path, event, &block)
@@ -184,24 +188,54 @@ class FileWatch::TailGlob
       #@eof_actions[path] = :reopen
     else
       # If we are not yet watching this file, watch it.
-      follow_file(path, :beginning)
-
-      # Then read all of the data so far since this is a new file.
-      file_action_modify(path, event, &block)
+      # Make sure this file matches a known glob
+      if @globoptions.find { |glob, opts| File.fnmatch?(glob, path) }
+        follow_file(path, :beginning)
+        # Then read all of the data so far since this is a new file.
+        file_action_modify(path, event, &block)
+      end
     end
   end # def file_action_create
 
-  def file_action_delete(path, event, &block)
+  # This method is invoked when a file we are tailing is deleted.
+  protected
+  def file_action_delete_self(path, event, &block)
     close(path)
-    # ignore
+  end # def file_action_delete_self
+
+  # This method is invoked when a file we are tailing is moved.
+  def file_action_move_self(path, event, &block)
+    # File renames are assumed to be rotations, so we close.
+    # if this file is not open, this close has no effect.
+    close(event.old_name)
   end
 
-  def file_action_delete_self(path, event, &block)
-    close(path)
-    # ignore
-    #p :delete_self => path
+  # Directory event; file in this dir was renamed.
+  protected
+  def file_action_moved_to(path, event, &block)
+    # TODO(sissel): ignore, maybe call close for good measure?
   end
 
+  protected
+  def file_action_moved_from(path, event, &block)
+    # ignore
+  end # def file_action_moved_from
+
+  protected
+  def file_action_move(path, event, &block)
+    # ignore
+  end # def file_action_move
+
+  protected
+  def file_action_move(path, event, &block)
+    # ignore
+  end # def file_action_move
+
+  protected
+  def file_action_delete(path, event, &block)
+    # ignore
+  end # def file_action_delete
+
   # Returns true if we are currently following the file at the given path.
   public
   def following?(path)

data/lib/filewatch/watch.rb

@@ -13,7 +13,7 @@ class FileWatch::Watch
 
   public
   def watch(path, *what_to_watch)
-    @inotify.watch(path, *what_to_watch)
+    return @inotify.watch(path, *what_to_watch)
   end # def watch
 
   def subscribe(handler=nil, &block)

data/lib/filewatch/watchglob.rb

@@ -27,7 +27,7 @@ class FileWatch::WatchGlob
       begin
         next if watching.include?(path)
         @logger.info("Watching #{path}")
-        @watch.watch(path, :create, :delete, :modify)
+        @watch.watch(path, :create, :delete, :modify, *what_to_watch)
         watching << path
 
         # Yield each file found by glob to the block.
@@ -51,7 +51,7 @@ class FileWatch::WatchGlob
         Dir.glob(globprefix).each do |path|
           next if watching.include?(path)
           @logger.info("Watching dir: #{path.inspect}")
-          @watch.watch(path, :create)
+          @watch.watch(path, :create, :moved_to, :moved_from)
           @globdirs << path
         end # Dir.glob
       end # if part.include?("*")
@@ -64,7 +64,8 @@ class FileWatch::WatchGlob
     @watch.subscribe do |event|
       # If this event is a directory event and the file matches a watched glob,
       # then it should be a new-file creation event. Watch the file.
-      if event.type == :directory and @globdirs.include?(File.dirname(event.name))
+      if event.type == :directory and event.actions.include?(:create) \
+        and @globdirs.include?(File.dirname(event.name))
         glob, what = @globs.find { |glob, what| File.fnmatch?(glob, event.name) }
         if glob
           @watch.watch(event.name, *what)

data/test/logrotate/logrotate.conf

@@ -0,0 +1,5 @@
+/home/jls/projects/ruby-filewatch/test/logrotate/*.log {
+  rotate 5
+  #compress
+  size 100
+}

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: filewatch
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: 
   segments: 
   - 0
   - 2
-  - 4
-  version: 0.2.4
+  - 5
+  version: 0.2.5
 platform: ruby
 authors: 
 - Jordan Sissel
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-13 00:00:00 -07:00
+date: 2011-04-14 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,6 +55,7 @@ files:
 - lib/filewatch/buftok.rb
 - test/log4j/log4j.properties
 - test/log4j/LogTest.java
+- test/logrotate/logrotate.conf
 - bin/gtail
 has_rdoc: true
 homepage: https://github.com/jordansissel/ruby-filewatch