Class: INotify::Notifier
- Defined in:
- lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/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.
Constant Summary collapse
- 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
-
#watchers ⇒ {Fixnum => Watcher}
readonly
A hash from Watcher ids to the instances themselves.
Instance Method Summary collapse
-
#close ⇒ Object
Close the notifier.
-
#fd ⇒ Fixnum
The underlying file descriptor for this notifier.
-
#initialize ⇒ Notifier
constructor
Creates a new Notifier.
-
#process ⇒ Object
Blocks until there are one or more filesystem events that this notifier has watchers registered for.
-
#read_events ⇒ Object
Blocks until there are one or more filesystem events that this notifier has watchers registered for.
-
#run ⇒ Object
Starts the notifier watching for filesystem events.
-
#stop ⇒ Object
Stop watching for filesystem events.
-
#to_io ⇒ IO
Returns a Ruby IO object wrapping the underlying file descriptor.
-
#watch(path, *flags) {|event| ... } ⇒ Watcher
Watches a file or directory for changes, calling the callback when there are.
Constructor Details
#initialize ⇒ Notifier
Creates a new INotify::Notifier.
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 51 def initialize @running = Mutex.new @pipe = IO.pipe # JRuby shutdown sometimes runs IO finalizers before all threads finish. if RUBY_ENGINE == 'jruby' @pipe[0].autoclose = false @pipe[1].autoclose = false end @watchers = {} fd = Native.inotify_init unless fd < 0 @handle = IO.new(fd) @handle.autoclose = false if RUBY_ENGINE == 'jruby' return end 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
Instance Method Details
#close ⇒ Object
Close the notifier.
272 273 274 275 276 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 272 def close stop @handle.close @watchers.clear end |
#fd ⇒ Fixnum
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).
43 44 45 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 43 def fd @handle.fileno end |
#process ⇒ Object
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.
262 263 264 265 266 267 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 262 def process read_events.each do |event| event.callback! event.flags.include?(:ignored) && event.notifier.watchers.delete(event.watcher_id) end end |
#read_events ⇒ Object
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 285 def read_events size = Native::Event.size + Native.fpathconf(fd, Native::Flags::PC_NAME_MAX) + 1 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 return [] if data.nil? events = [] = {} while event = Event.consume(data, self) events << event next if event. == 0 [event.] ||= [] [event.] << event end .each {|c, evs| evs.each {|ev| ev..replace(evs - [ev]).freeze}} events end |
#run ⇒ Object
Starts the notifier watching for filesystem events. Blocks until #stop is called.
231 232 233 234 235 236 237 238 239 240 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 231 def run @running.synchronize do Thread.current[:INOTIFY_RUN_THREAD] = true @stop = false process until @stop end ensure Thread.current[:INOTIFY_RUN_THREAD] = false end |
#stop ⇒ Object
Stop watching for filesystem events. That is, if we’re in a #run loop, exit out as soon as we finish handling the events.
245 246 247 248 249 250 251 252 253 254 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 245 def stop @stop = true @pipe.last.write "." unless Thread.current[:INOTIFY_RUN_THREAD] @running.synchronize do # no-op: we just needed to wait until the lock was available end end end |
#to_io ⇒ 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.
95 96 97 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 95 def to_io @handle end |
#watch(path, *flags) {|event| ... } ⇒ Watcher
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.
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/rb-inotify-0.10.1/lib/rb-inotify/notifier.rb', line 197 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 next if RECURSIVE_BLACKLIST.include?(d) next if flags.include?(:dont_follow) && File.symlink?(d) next if !File.directory?(d) watch(d, *flags, &callback) 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 |