rb-inotify 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+/.yardoc
+/doc

data/.yardopts

@@ -0,0 +1,4 @@
+--readme          README.md
+--markup          markdown
+--markup-provider maruku
+--no-private

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Nathan Weizenbaum
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# rb-inotify
+
+This is a simple wrapper over the [inotify](http://en.wikipedia.org/wiki/Inotify) Linux kernel subsystem
+for monitoring changes to files and directories.
+It uses the [FFI](http://wiki.github.com/ffi/ffi) gem to avoid having to compile a C extension.
+
+## Basic Usage
+
+The API is similar to the inotify C API, but with a more Rubyish feel.
+First, create a notifier:
+
+    notifier = INotify::Notifier.new
+
+Then, tell it to watch the paths you're interested in
+for the events you care about:
+
+    notifier.watch("path/to/foo.txt", :modify) {puts "foo.txt was modified!"}
+    notifier.watch("path/to/bar", :moved_to, :create) do |event|
+      puts "#{event.name} is now in path/to/bar!"
+    end
+
+Inotify can watch directories or individual files.
+It can pay attention to all sorts of events;
+for a full list, see [the inotify man page](http://www.tin.org/bin/man.cgi?section=7&topic=inotify).
+
+Finally, you get at the events themselves:
+
+    notifier.run
+
+This will loop infinitely, calling the appropriate callbacks when the files are changed.
+If you don't want infinite looping,
+you can also block until there are available events,
+process them all at once,
+and then continue on your merry way:
+
+    notifier.process
+
+## Advanced Usage
+
+Sometimes it's necessary to have finer control over the underlying IO operations
+than is provided by the simple callback API.
+The trick to this is that the notifier is a fully-functional IO object,
+with a file descriptor and everything.
+This means, for example, that it can be passed to `IO#select`:
+
+     # Wait 10 seconds for an event then give up
+     if IO.select([notifier], [], [], 10)
+       notifier.process
+     end
+
+It can even be used with EventMachine:
+
+     require 'eventmachine'
+
+     EM.run do
+       EM.watch notifier do
+         notifier.process
+       end
+     end

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rb-inotify"
+    gem.summary = "A Ruby wrapper for Linux's inotify, using FFI"
+    gem.description = gem.summary
+    gem.email = "nex342@gmail.com"
+    gem.homepage = "http://github.com/nex3/rb-notify"
+    gem.authors = ["Nathan Weizenbaum"]
+    gem.add_development_dependency "yard"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rb-inotify.rb

@@ -0,0 +1,12 @@
+require 'rb-inotify/native'
+require 'rb-inotify/native/flags'
+require 'rb-inotify/notifier'
+require 'rb-inotify/watcher'
+require 'rb-inotify/event'
+
+# The root module of the library, which is laid out as so:
+#
+# * {Notifier} -- The main class, where the notifications are set up
+# * {Watcher} -- A watcher for a single file or directory
+# * {Event} -- An filesystem event notification
+module INotify; end

data/lib/rb-inotify/event.rb

@@ -0,0 +1,107 @@
+module INotify
+  # An event caused by a change on the filesystem.
+  # Each {Watcher} can fire many events,
+  # which are passed to that watcher's callback.
+  class Event
+    # An integer specifying that this event is related to some other event,
+    # which will have the same cookie.
+    #
+    # Currently, this is only used for files that are moved within the same directory.
+    # Both the `:moved_from` and the `:moved_to` events will have the same cookie.
+    #
+    # @return [Fixnum]
+    attr_reader :cookie
+
+    # The name of the file that the event occurred on.
+    # This is only set for events that occur on files in directories;
+    # otherwise, it's `""`.
+    #
+    # @return [String]
+    attr_reader :name
+
+    # The {Notifier} that fired this event.
+    #
+    # @return [Notifier]
+    attr_reader :notifier
+
+    # The {Watcher#id id} of the {Watcher} that fired this event.
+    #
+    # @private
+    # @return [Fixnum]
+    attr_reader :watcher_id
+
+    # Returns the {Watcher} that fired this event.
+    #
+    # @return [Watcher]
+    def watcher
+      @watcher ||= @notifier.watchers[@watcher_id]
+    end
+
+    # Returns the flags that describe this event.
+    # This is generally similar to the input to {Notifier#watch},
+    # except that it won't contain options flags nor `:all_events`,
+    # and it may contain one or more of the following flags:
+    #
+    # `:unmount`
+    # : The filesystem containing the watched file or directory was unmounted.
+    #
+    # `:ignored`
+    # : The \{#watcher watcher} was closed, or the watched file or directory was deleted.
+    #
+    # `:isdir`
+    # : The subject of this event is a directory.
+    #
+    # @return [Array<Symbol>]
+    def flags
+      @flags ||= Native::Flags.from_mask(@native[:mask])
+    end
+
+    # Constructs an {Event} object from a string of binary data,
+    # and destructively modifies the string to get rid of the initial segment
+    # used to construct the Event.
+    #
+    # @private
+    # @param data [String] The string to be modified
+    # @param notifier [Notifier] The {Notifier} that fired the event
+    # @return [Event, nil] The event, or `nil` if the string is empty
+    def self.consume(data, notifier)
+      return nil if data.empty?
+      ev = new(data, notifier)
+      data.replace data[ev.size..-1]
+      ev
+    end
+
+    # Creates an event from a string of binary data.
+    # Differs from {Event.consume} in that it doesn't modify the string.
+    #
+    # @private
+    # @param data [String] The data string
+    # @param notifier [Notifier] The {Notifier} that fired the event
+    def initialize(data, notifier)
+      ptr = FFI::MemoryPointer.from_string(data)
+      @native = Native::Event.new(ptr)
+      @cookie = @native[:cookie]
+      @name = data[@native.size, @native[:len]].gsub(/\0+$/, '')
+      @notifier = notifier
+      @watcher_id = @native[:wd]
+
+      raise Exception.new("inotify event queue has overflowed.") if @native[:mask] & Native::Flags::IN_Q_OVERFLOW != 0
+    end
+
+    # Calls the callback of the watcher that fired this event,
+    # passing in the event itself.
+    #
+    # @private
+    def callback!
+      watcher.callback!(self)
+    end
+
+    # Returns the size of this event object in bytes,
+    # including the \{#name} string.
+    #
+    # @return [Fixnum]
+    def size
+      @native.size + @native[:len]
+    end
+  end
+end

data/lib/rb-inotify/native.rb

@@ -0,0 +1,27 @@
+require 'ffi'
+
+module INotify
+  # This module contains the low-level foreign-function interface code
+  # for dealing with the inotify C APIs.
+  # It's an implementation detail, and not meant for users to deal with.
+  #
+  # @private
+  module Native
+    extend FFI::Library
+
+    # The C struct describing an inotify event.
+    #
+    # @private
+    class Event < FFI::Struct
+      layout(
+        :wd, :int,
+        :mask, :uint32,
+        :cookie, :uint32,
+        :len, :uint32)
+    end
+
+    attach_function :inotify_init, [], :int
+    attach_function :inotify_add_watch, [:int, :string, :int], :int
+    attach_function :inotify_rm_watch, [:int, :int], :int
+  end
+end

data/lib/rb-inotify/native/flags.rb

@@ -0,0 +1,89 @@
+module INotify
+  module Native
+    # A module containing all the inotify flags
+    # to be passed to {Notifier#watch}.
+    #
+    # @private
+    module Flags
+      # File was accessed.
+      IN_ACCESS = 0x00000001
+      # Metadata changed.
+      IN_ATTRIB = 0x00000004
+      # Writtable file was closed.
+      IN_CLOSE_WRITE = 0x00000008
+      # File was modified.
+      IN_MODIFY = 0x00000002
+      # Unwrittable file closed.
+      IN_CLOSE_NOWRITE = 0x00000010
+      # File was opened.
+      IN_OPEN = 0x00000020
+      # File was moved from X.
+      IN_MOVED_FROM = 0x00000040
+      # File was moved to Y.
+      IN_MOVED_TO = 0x00000080
+      # Subfile was created.
+      IN_CREATE = 0x00000100
+      # Subfile was deleted.
+      IN_DELETE = 0x00000200
+      # Self was deleted.
+      IN_DELETE_SELF = 0x00000400
+      # Self was moved.
+      IN_MOVE_SELF = 0x00000800
+
+      ## Helper events.
+
+      # Close.
+      IN_CLOSE = (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
+      # Moves.
+      IN_MOVE = (IN_MOVED_FROM | IN_MOVED_TO)
+      # All events which a program can wait on.
+      IN_ALL_EVENTS = (IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE |
+        IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM | IN_MOVED_TO | IN_CREATE |
+        IN_DELETE | IN_DELETE_SELF | IN_MOVE_SELF)
+
+
+      ## Special flags.
+
+      # Only watch the path if it is a directory.
+      IN_ONLYDIR = 0x01000000
+      # Do not follow a sym link.
+      IN_DONT_FOLLOW = 0x02000000
+      # Add to the mask of an already existing watch.
+      IN_MASK_ADD = 0x20000000
+      # Only send event once.
+      IN_ONESHOT = 0x80000000
+
+
+      ## Events sent by the kernel.
+
+      # Backing fs was unmounted.
+      IN_UNMOUNT = 0x00002000
+      # Event queued overflowed.
+      IN_Q_OVERFLOW = 0x00004000
+      # File was ignored.
+      IN_IGNORED = 0x00008000
+      # Event occurred against dir.
+      IN_ISDIR = 0x40000000
+
+      # Converts a list of flags to the bitmask that the C API expects.
+      #
+      # @param flags [Array<Symbol>]
+      # @return Fixnum
+      def self.to_mask(flags)
+        flags.map {|flag| const_get("IN_#{flag.to_s.upcase}")}.
+          inject(0) {|mask, flag| mask | flag}
+      end
+
+      # Converts a bitmask from the C API into a list of flags.
+      #
+      # @return mask [Fixnum]
+      # @return [Array<Symbol>]
+      def self.from_mask(mask)
+        constants.select do |c|
+          next false unless c =~ /^IN_/
+          const_get(c) & mask != 0
+        end.map {|c| c.sub("IN_", "").downcase.to_sym} - [:all_events]
+      end
+    end
+  end
+end

data/lib/rb-inotify/notifier.rb

@@ -0,0 +1,195 @@
+module INotify
+  # Notifier wraps a single instance of inotify.
+  # It's possible to have more than one instance,
+  # but usually unnecessary.
+  #
+  # @example
+  #   # Create the notifier
+  #   notifier = INotify::Notifier.new
+  #
+  #   # Run this callback whenever the file path/to/foo.txt is read
+  #   notifier.watch("path/to/foo.txt", :access) do
+  #     puts "Foo.txt was accessed!"
+  #   end
+  #
+  #   # Watch for any file in the directory being deleted
+  #   # or moved out of the directory.
+  #   notifier.watch("path/to/directory", :delete, :moved_from) do |event|
+  #     # The #name field of the event object contains the name of the affected file
+  #     puts "#{event.name} is no longer in the directory!"
+  #   end
+  #
+  #   # Nothing happens until you run the notifier!
+  #   notifier.run
+  #
+  # Notifier is a subclass of IO with a fully-functional file descriptor,
+  # so it can be passed to functions like `#select`.
+  class Notifier < IO
+    # A hash from {Watcher} ids to the instances themselves.
+    #
+    # @private
+    # @return [{Fixnum => Watcher}]
+    attr_reader :watchers
+
+    # The underlying file descriptor for this notifier.
+    # This is a valid OS file descriptor, and can be used as such.
+    #
+    # @return [Fixnum]
+    attr_reader :fd
+
+    # Creates a new {Notifier}.
+    #
+    # @return [Notifier]
+    # @raise [SystemCallError] if inotify failed to initialize for some reason
+    def initialize
+      @fd = Native.inotify_init
+      @watchers = {}
+      return super(@fd) unless @fd < 0
+
+      raise SystemCallError.new(
+        "Failed to initialize inotify" +
+        case FFI.errno
+        when Errno::EMFILE::Errno; ": the user limit on the total number of inotify instances has been reached."
+        when Errno::ENFILE::Errno; ": the system limit on the total number of file descriptors has been reached."
+        when Errno::ENOMEM::Errno; ": insufficient kernel memory is available."
+        else; ""
+        end,
+        FFI.errno)
+    end
+
+    # Watches a file or directory for changes,
+    # calling the callback when there are.
+    # This is only activated once \{#process} or \{#run} is called.
+    #
+    # ## Flags
+    #
+    # `:access`
+    # : A file is accessed (that is, read).
+    #
+    # `:attrib`
+    # : A file's metadata is changed (e.g. permissions, timestamps, etc).
+    #
+    # `:close_write`
+    # : A file that was opened for writing is closed.
+    #
+    # `:close_nowrite`
+    # : A file that was not opened for writing is closed.
+    #
+    # `:modify`
+    # : A file is modified.
+    #
+    # `:open`
+    # : A file is opened.
+    #
+    # ### Directory-Specific Flags
+    #
+    # These flags only apply when a directory is being watched.
+    #
+    # `:moved_from`
+    # : A file is moved out of the watched directory.
+    #
+    # `:moved_to`
+    # : A file is moved into the watched directory.
+    #
+    # `:create`
+    # : A file is created in the watched directory.
+    #
+    # `:delete`
+    # : A file is deleted in the watched directory.
+    #
+    # `:delete_self`
+    # : The watched file or directory itself is deleted.
+    #
+    # `:move_self`
+    # : The watched file or directory itself is moved.
+    #
+    # ### Helper Flags
+    #
+    # These flags are just combinations of the flags above.
+    #
+    # `:close`
+    # : Either `:close_write` or `:close_nowrite` is activated.
+    #
+    # `:move`
+    # : Either `:moved_from` or `:moved_to` is activated.
+    #
+    # `:all_events`
+    # : Any event above is activated.
+    #
+    # ### Options Flags
+    #
+    # These flags don't actually specify events.
+    # Instead, they specify options for the watcher.
+    #
+    # `:onlydir`
+    # : Only watch the path if it's a directory.
+    #
+    # `:dont_follow`
+    # : Don't follow symlinks.
+    #
+    # `:mask_add`
+    # : Add these flags to the pre-existing flags for this path.
+    #
+    # `:oneshot`
+    # : Only send the event once, then shut down the watcher.
+    #
+    # @param path [String] The path to the file or directory
+    # @param flags [Array<Symbol>] Which events to watch for
+    # @yield [event] A block that will be called
+    #   whenever one of the specified events occur
+    # @yieldparam event [Event] The Event object containing information
+    #   about the event that occured
+    # @return [Watcher] A Watcher set up to watch this path for these events
+    # @raise [SystemCallError] if the file or directory can't be watched,
+    #   e.g. if the file isn't found, read access is denied,
+    #   or the flags don't contain any events
+    def watch(path, *flags, &callback)
+      Watcher.new(self, path, *flags, &callback)
+    end
+
+    # Starts the notifier watching for filesystem events.
+    # Blocks forever and never returns.
+    #
+    # @see #process
+    def run
+      loop {process}
+    end
+
+    # Blocks until there are one or more filesystem events
+    # that this notifier has watchers registered for.
+    # Once there are events, the appropriate callbacks are called
+    # and this function returns.
+    #
+    # @see #run
+    def process
+      read_events.each {|event| event.callback!}
+    end
+
+    # Blocks until there are one or more filesystem events
+    # that this notifier has watchers registered for.
+    # Once there are events, returns their {Event} objects.
+    #
+    # @private
+    def read_events
+      size = 64 * Native::Event.size
+      tries = 1
+
+      begin
+        data = readpartial(size)
+      rescue SystemCallError => er
+        # EINVAL means that there's more data to be read
+        # than will fit in the buffer size
+        raise er unless er.errno == EINVAL || tries == 5
+        size *= 2
+        tries += 1
+        retry
+      end
+
+      events = []
+      while ev = Event.consume(data, self)
+        events << ev
+      end
+      events
+    end
+  end
+end

data/lib/rb-inotify/watcher.rb

@@ -0,0 +1,83 @@
+module INotify
+  # Watchers monitor a single path for changes,
+  # specified by {INotify::Notifier#watch event flags}.
+  # A watcher is usually created via \{Notifier#watch}.
+  #
+  # One {Notifier} may have many {Watcher}s.
+  # The Notifier actually takes care of the checking for events,
+  # via \{Notifier#run #run} or \{Notifier#process #process}.
+  # The main purpose of having Watcher objects
+  # is to be able to disable them using \{#close}.
+  class Watcher
+    # The {Notifier} that this Watcher belongs to.
+    #
+    # @return [Notifier]
+    attr_reader :notifier
+
+    # The path that this Watcher is watching.
+    #
+    # @return [String]
+    attr_reader :path
+
+    # The {INotify::Notifier#watch flags}
+    # specifying the events that this Watcher is watching for,
+    # and potentially some options as well.
+    #
+    # @return [Array<Symbol>]
+    attr_reader :flags
+
+    # The id for this Watcher.
+    # Used to retrieve this Watcher from {Notifier#watchers}.
+    #
+    # @private
+    # @return [Fixnum]
+    attr_reader :id
+
+    # Calls this Watcher's callback with the given {Event}.
+    #
+    # @private
+    # @param event [Event]
+    def callback!(event)
+      @callback[event]
+    end
+
+    # Disables this Watcher, so that it doesn't fire any more events.
+    #
+    # @raise [SystemCallError] if the watch fails to be disabled for some reason
+    def close
+      return if Native.inotify_rm_watch(@notifier.fd, @id) == 0
+      raise SystemCallError.new("Failed to stop watching #{path.inspect}", FFI.errno)
+    end
+
+    # Creates a new {Watcher}.
+    #
+    # @private
+    # @see Notifier#watch
+    def initialize(notifier, path, *flags, &callback)
+      @notifier = notifier
+      @callback = callback || proc {}
+      @path = path
+      @flags = flags.freeze
+      @id = Native.inotify_add_watch(@notifier.fd, path,
+        Native::Flags.to_mask(flags))
+
+      unless @id < 0
+        @notifier.watchers[@id] = self
+        return
+      end
+
+      raise SystemCallError.new(
+        "Failed to watch #{path.inspect}" +
+        case FFI.errno
+        when Errno::EACCES::Errno; ": read access to the given file is not permitted."
+        when Errno::EBADF::Errno; ": the given file descriptor is not valid."
+        when Errno::EFAULT::Errno; ": path points outside of the process's accessible address space."
+        when Errno::EINVAL::Errno; ": the given event mask contains no legal events; or fd is not an inotify file descriptor."
+        when Errno::ENOMEM::Errno; ": insufficient kernel memory was available."
+        when Errno::ENOSPC::Errno; ": The user limit on the total number of inotify watches was reached or the kernel failed to allocate a needed resource."
+        else; ""
+        end,
+        FFI.errno)
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: rb-inotify
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Nathan Weizenbaum
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-29 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A Ruby wrapper for Linux's inotify, using FFI
+email: nex342@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .gitignore
+- .yardopts
+- MIT-LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/rb-inotify.rb
+- lib/rb-inotify/event.rb
+- lib/rb-inotify/native.rb
+- lib/rb-inotify/native/flags.rb
+- lib/rb-inotify/notifier.rb
+- lib/rb-inotify/watcher.rb
+has_rdoc: true
+homepage: http://github.com/nex3/rb-notify
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Ruby wrapper for Linux's inotify, using FFI
+test_files: []
+