Class: INotify::Notifier

Inherits:
Object
  • Object
show all
Defined in:
lib/rb-inotify/notifier.rb

Overview

Notifier wraps a single instance of inotify. It's possible to have more than one instance, but usually unnecessary.

Examples:

# 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

Constant Summary

RECURSIVE_BLACKLIST =

A list of directories that should never be recursively watched.

  • Files in /dev/fd sometimes register as directories, but are not enumerable.
%w[/dev/fd]

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Notifier) initialize

Creates a new INotify::Notifier.

Raises:

  • (SystemCallError)

    if inotify failed to initialize for some reason



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
# File 'lib/rb-inotify/notifier.rb', line 53

def initialize
  @fd = Native.inotify_init
  @watchers = {}
  return 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

Instance Attribute Details

- (Fixnum) fd (readonly)

The underlying file descriptor for this notifier. This is a valid OS file descriptor, and can be used as such (except under JRuby -- see #to_io).

Returns:

  • (Fixnum)


41
42
43
# File 'lib/rb-inotify/notifier.rb', line 41

def fd
  @fd
end

Class Method Details

+ (Boolean) supports_ruby_io?

Returns Whether or not this Ruby implementation supports wrapping the native file descriptor in a Ruby IO wrapper.

Returns:

  • (Boolean)

    Whether or not this Ruby implementation supports wrapping the native file descriptor in a Ruby IO wrapper.



45
46
47
# File 'lib/rb-inotify/notifier.rb', line 45

def self.supports_ruby_io?
  RUBY_PLATFORM !~ /java/
end

Instance Method Details

- (Object) close

Close the notifier.

Raises:

  • (SystemCallError)

    if closing the underlying file descriptor fails.



244
245
246
247
248
249
250
251
252
253
254
255
256
# File 'lib/rb-inotify/notifier.rb', line 244

def close
  if Native.close(@fd) == 0
    @watchers.clear
    return
  end

  raise SystemCallError.new("Failed to properly close inotify socket" +
   case FFI.errno
   when Errno::EBADF::Errno; ": invalid or closed file descriptior"
   when Errno::EIO::Errno; ": an I/O error occured"
   end,
   FFI.errno)
end

- (Object) process

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 Also:



237
238
239
# File 'lib/rb-inotify/notifier.rb', line 237

def process
  read_events.each {|event| event.callback!}
end

- (Object) read_events

Blocks until there are one or more filesystem events that this notifier has watchers registered for. Once there are events, returns their Event objects.

#run or #process are ususally preferable to calling this directly.



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
# File 'lib/rb-inotify/notifier.rb', line 263

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 == Errno::EINVAL::Errno || tries == 5
    size *= 2
    tries += 1
    retry
  end

  events = []
  cookies = {}
  while event = Event.consume(data, self)
    events << event
    next if event.cookie == 0
    cookies[event.cookie] ||= []
    cookies[event.cookie] << event
  end
  cookies.each {|c, evs| evs.each {|ev| ev.related.replace(evs - [ev]).freeze}}
  events
end

- (Object) run

Starts the notifier watching for filesystem events. Blocks until #stop is called.

See Also:



219
220
221
222
# File 'lib/rb-inotify/notifier.rb', line 219

def run
  @stop = false
  process until @stop
end

- (Object) stop

Stop watching for filesystem events. That is, if we're in a #run loop, exit out as soon as we finish handling the events.



227
228
229
# File 'lib/rb-inotify/notifier.rb', line 227

def stop
  @stop = true
end

- (IO) to_io

Returns a Ruby IO object wrapping the underlying file descriptor. Since this file descriptor is fully functional (except under JRuby), this IO object can be used in any way a Ruby-created IO object can. This includes passing it to functions like #select.

Note that this always returns the same IO object. Creating lots of IO objects for the same file descriptor can cause some odd problems.

This is not supported under JRuby. JRuby currently doesn't use native file descriptors for the IO object, so we can't use this file descriptor as a stand-in.

Returns:

  • (IO)

    An IO object wrapping the file descriptor

Raises:

  • (NotImplementedError)

    if this is being called in JRuby



84
85
86
87
88
89
# File 'lib/rb-inotify/notifier.rb', line 84

def to_io
  unless self.class.supports_ruby_io?
    raise NotImplementedError.new("INotify::Notifier#to_io is not supported under JRuby")
  end
  @io ||= IO.new(@fd)
end

- (Watcher) watch(path, *flags) {|event| ... }

Watches a file or directory for changes, calling the callback when there are. This is only activated once #process or #run is called.

Note that by default, this does not recursively watch subdirectories of the watched directory. To do so, use the :recursive flag.

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.
:recursive
Recursively watch any subdirectories that are created. Note that this is a feature of rb-inotify, rather than of inotify itself, which can only watch one level of a directory. This means that the Event#name field will contain only the basename of the modified file. When using :recursive, Event#absolute_name should always be used.

Parameters:

  • path (String)

    The path to the file or directory

  • flags (Array<Symbol>)

    Which events to watch for

Yields:

  • (event)

    A block that will be called whenever one of the specified events occur

Yield Parameters:

  • event (Event)

    The Event object containing information about the event that occured

Returns:

  • (Watcher)

    A Watcher set up to watch this path for these events

Raises:

  • (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



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
# File 'lib/rb-inotify/notifier.rb', line 189

def watch(path, *flags, &callback)
  return Watcher.new(self, path, *flags, &callback) unless flags.include?(:recursive)

  dir = Dir.new(path)

  dir.each do |base|
    d = File.join(path, base)
    binary_d = d.respond_to?(:force_encoding) ? d.dup.force_encoding('BINARY') : d
    next if binary_d =~ /\/\.\.?$/ # Current or parent directory
    watch(d, *flags, &callback) if !RECURSIVE_BLACKLIST.include?(d) && File.directory?(d)
  end

  dir.close

  rec_flags = [:create, :moved_to]
  return watch(path, *((flags - [:recursive]) | rec_flags)) do |event|
    callback.call(event) if flags.include?(:all_events) || !(flags & event.flags).empty?
    next if (rec_flags & event.flags).empty? || !event.flags.include?(:isdir)
    begin
      watch(event.absolute_name, *flags, &callback)
    rescue Errno::ENOENT
      # If the file has been deleted since the glob was run, we don't want to error out.
    end
  end
end