filewatch 0.0.1

data/lib/inotify/emhandler.rb

@@ -0,0 +1,16 @@
+require "inotify/fd"
+require "inotify/namespace"
+
+class Inotify::EMHandler < EventMachine::Connection
+  def initialize(inotify_fd, callback=nil)
+    @inotify = inotify_fd
+    @callback = callback
+    self.notify_readable = true
+  end
+
+  def notify_readable
+    @inotify.each do |event|
+      @callback.call(event)
+    end
+  end
+end

data/lib/inotify/event.rb

@@ -0,0 +1,81 @@
+require "inotify/namespace"
+require "inotify/fd"
+require "ffi"
+
+class Inotify::Event < FFI::Struct
+  layout :wd, :int,
+         :mask, :uint32,
+         :cookie, :uint32,
+         :len, :uint32
+  # last piece is the name, but don't hold it in the struct
+         #:name, :string,
+
+  attr_accessor :name
+
+  def initialize(pointer)
+    if pointer.is_a?(String)
+      pointer = FFI::MemoryPointer.from_string(pointer)
+    end
+
+    super(pointer)
+  end
+
+  def self.from_stringpipeio(io)
+    # This fails in ruby 1.9.2 because it literally calls read(2) with
+    # 'self.size' as the byte size to read. This causes EINVAL 
+    # from inotify, documented thusly in inotify(7):
+    # 
+    # """ The  behavior  when  the buffer given to read(2) is too small to
+    #     return information about the next event depends on the  kernel
+    #     version:  in  kernels  before  2.6.21, read(2) returns 0; since
+    #     kernel 2.6.21, read(2) fails with the error EINVAL. """
+    #
+    # Working around this will require implementing our own read buffering
+    # unless comeone clues me in on how to make ruby 1.9.2 read larger
+    # blocks and actually do the nice buffered IO we've all come to
+    # know and love.
+
+    begin
+      data = io.read(self.size, true)
+    rescue Errno::EINVAL => e
+      $stderr.puts "Read was too small? Confused."
+      raise e
+    end
+
+    return nil if data == nil
+
+    pointer = FFI::MemoryPointer.from_string(data)
+    event = self.new(pointer)
+
+    event.from_stringpipeio(io)
+    return event
+  end
+
+  def from_stringpipeio(io)
+    begin
+      @name = io.read(self[:len], true)
+    rescue Errno::EINVAL => e
+      $stderr.puts "Read was too small? Confused."
+      raise e
+    end
+    return self if @name == nil
+
+    @name = @name.split("\0", 2).first
+
+    return self
+  end
+
+  def actions
+    Inotify::FD::WATCH_BITS.reject do |key, bitmask| 
+      self[:mask] & bitmask == 0 
+    end.keys
+  end
+
+  def to_s
+    return "#{@name} (#{self.actions.join(", ")})"
+  end
+
+  def partial?
+    return self[:len] > 0 && @name == nil
+  end # def partial?
+end

data/lib/inotify/fd.rb

@@ -0,0 +1,221 @@
+require "rubygems"
+require "ffi"
+require "inotify/event"
+require "inotify/namespace"
+require "inotify/stringpipeio"
+
+class Inotify::FD
+  include Enumerable
+
+  module CInotify
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+
+    attach_function :inotify_init, [], :int
+    attach_function :inotify_init1, [:int], :int
+    attach_function :inotify_add_watch, [:int, :string, :uint32], :int
+
+    # So we can read and poll inotify from jruby.
+    attach_function :read, [:int, :pointer, :size_t], :int
+
+    # Poll is pretty crappy, but it's better than nothing.
+    attach_function :poll, [:pointer, :int, :int], :int
+  end
+
+  INOTIFY_CLOEXEC = 02000000
+  INOTIFY_NONBLOCK = 04000
+
+  WATCH_BITS = {
+    :access => 1 << 0,
+    :modify => 1 << 1,
+    :attrib => 1 << 2,
+    :close_write => 1 << 3,
+    :close_nowrite => 1 << 4,
+    :open => 1 << 5,
+    :moved_from => 1 << 6,
+    :moved_to => 1 << 7,
+    :create => 1 << 8,
+    :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),
+  }
+
+  attr_reader :fd
+
+  public
+  def initialize
+    @watches = {}
+    @buffer = Inotify::StringPipeIO.new
+
+    @fd = CInotify.inotify_init1(INOTIFY_NONBLOCK)
+
+    if java?
+      @io = nil
+    else
+      @io = IO.for_fd(@fd)
+    end
+  end
+
+  public
+  def java?
+    return RUBY_PLATFORM == "java"
+  end
+
+  # Add a watch.
+  # - path is a string file path
+  # - what_to_watch is any of the valid WATCH_BITS keys
+  #
+  # Example:
+  #   watch("/tmp", :craete, :delete)
+  public
+  def watch(path, *what_to_watch)
+    mask = what_to_watch.inject(0) { |m, val| m |= WATCH_BITS[val] }
+    watch_descriptor = CInotify.inotify_add_watch(@fd, path, mask)
+    #puts "watch #{path} => #{watch_descriptor}"
+
+    if watch_descriptor == -1
+      raise "inotify_add_watch(#{@fd}, #{path}, #{mask}) failed. #{$?}"
+    end
+    @watches[watch_descriptor] = {
+      :path => path,
+      :partial => nil
+    }
+  end
+
+  private
+  def normal_read(timeout=nil)
+    loop do
+      begin
+        data = @io.sysread(4096)
+        @buffer.write(data)
+      rescue Errno::EAGAIN
+        # No data left to read, moveon.
+        break
+      end
+    end
+    return nil
+  end # def normal_read
+
+  private
+  def jruby_read(timeout=nil)
+    @jruby_read_buffer = FFI::MemoryPointer.new(:char, 4096)
+
+    # TODO(sissel): Block with select.
+    # Will have to use FFI to call select, too.
+
+    # We ahve to call libc's read(2) because JRuby/Java can't trivially
+    # be told about existing file descriptors.
+    loop do
+      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
+      break if bytes == -1
+
+      @buffer.write(@jruby_read_buffer.get_bytes(0, bytes))
+    end
+    return nil
+  end # def jruby_read
+    
+  # Make any necessary corrections to the event
+  private
+  def prepare(event)
+    watchpath = @watches[event[:wd]][:path]
+    if event.name == nil
+      # Some events don't have the name at all, so add our own.
+      event.name = watchpath
+    else
+      # Event paths are relative to the watch. Prefix to make the full path.
+      event.name = File.join(watchpath, event.name)
+    end
+
+    return event
+  end # def prepare
+
+  # Get one inotify event.
+  #
+  # If timeout is not given, this call blocks.
+  # If a timeout occurs and no event was read, nil is returned.
+  #
+  # Returns nil on timeout or an Inotify::Event on success.
+  public
+  def get(timeout=nil)
+    # This big 'loop' is to support pop { |event| ... } shipping each available event.
+    # It's not very rubyish (we should probably use Enumerable and such.
+    if java?
+      jruby_read(timeout)
+    else
+      normal_read(timeout)
+    end
+
+    # Recover any previous partial event.
+    if @partial
+      event = @partial.from_stringpipeio(@buffer)
+    else
+      event = Inotify::Event.from_stringpipeio(@buffer)
+      return nil if event == nil
+    end
+
+    if event.partial?
+      @partial = event
+      return nil
+    end
+    @partial = nil
+
+    return prepare(event)
+  end # def get
+
+  # For Enumerable support
+  # 
+  # Yields one Inotify::Event per iteration. If there are no more events
+  # at the this time, then this method will end.
+  public
+  def each(&block)
+    loop do
+      event = get
+      break if event == nil
+      yield prepare(event)
+    end # loop
+  end # def each
+
+  # Subscribe to inotify events for this instance.
+  # 
+  # If you are running in EventMachine, this will set up a 
+  # subscription that behaves sanely in EventMachine
+  #
+  # If you are not running in EventMachine, this method
+  # blocks forever, invoking the given block for each event.
+  # Further, if you are not using EventMachine, you should
+  # not pass a handler, only a block, like this:
+  #
+  #   fd.subscribe do |event|
+  #     puts event
+  #   end
+  public
+  def subscribe(handler=nil, &block)
+    if defined?(EventMachine) && EventMachine.reactor_running?
+      require "inotify/emhandler"
+      handler = Inotify::EMHandler if handler == nil
+      EventMachine::watch(@fd, handler, self, block)
+    else
+      loop do
+        if java?
+          # No way to select on FFI-derived file descriptors yet,
+          # when I grab poll(2) via FFI, this sleep will become
+          # a poll or sleep invocation.
+          sleep(1)
+        else
+          IO.select([@io], nil, nil, nil)
+        end
+        each(&block)
+      end
+    end
+  end
+end # class Inotify::FD

data/lib/inotify/namespace.rb

@@ -0,0 +1,2 @@
+module Inotify
+end

data/lib/inotify/stringpipeio.rb

@@ -0,0 +1,33 @@
+require "rubygems"
+require "inotify/namespace"
+
+class Inotify::StringPipeIO
+  def initialize
+    @buffer = ""
+  end # def initialize
+
+  def write(string)
+    @buffer += string
+  end # def write
+
+  def read(bytes=nil, nil_if_not_enough_data=false)
+    return nil if @buffer == nil || @buffer.empty?
+
+    if nil_if_not_enough_data && bytes > @buffer.size
+      return nil
+    end
+
+    bytes = @buffer.size if bytes == nil
+    data = @buffer[0 .. bytes]
+    if bytes <= @buffer.length
+      @buffer = @buffer[bytes .. -1]
+    else
+      @buffer = ""
+    end
+    return data
+  end # def read
+
+  def size
+    return @buffer.size
+  end
+end # class Inotify::StringPipeIO

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: filewatch
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jordan Sissel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-06 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Watch files and directories in ruby
+email: jls@semicomplete.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/inotify/namespace.rb
+- lib/inotify/emhandler.rb
+- lib/inotify/stringpipeio.rb
+- lib/inotify/fd.rb
+- lib/inotify/event.rb
+has_rdoc: true
+homepage: https://github.com/jordansissel/ruby-inotify-ffi
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.0
+signing_key: 
+specification_version: 3
+summary: filewatch - file watching for ruby
+test_files: []
+