rb-kqueue 0.0.2 → 0.1.0

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.0

data/lib/rb-kqueue/event.rb

@@ -39,7 +39,7 @@ module KQueue
     #
     # @return [Array<Symbol>]
     def flags
-      @fflags ||= Native::Flags.from_mask("NOTE", @native[:fflags])
+      @fflags ||= Native::Flags.from_mask("NOTE_#{filter.to_s.upcase}", @native[:fflags])
     end
 
     # Returns whether the end-of-file flag has been set for this event.

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

@@ -37,23 +37,32 @@ module KQueue
 
 
       # For `EVFILT_{READ,WRITE}`
-      NOTE_LOWAT = 0x00000001 # Low water mark
+      NOTE_READ_LOWAT = NOTE_WRITE_LOWAT = 0x00000001 # Low water mark
 
       # For `EVFILT_VNODE`
-      NOTE_DELETE = 0x00000001 # Vnode was removed
-      NOTE_WRITE = 0x00000002 # Data contents changed
-      NOTE_EXTEND = 0x00000004 # Size increased
-      NOTE_ATTRIB = 0x00000008 # Attributes changed
-      NOTE_LINK = 0x00000010 # Link count changed
-      NOTE_RENAME = 0x00000020 # Vnode was renamed
-      NOTE_REVOKE = 0x00000040 # Vnode access was revoked
+      NOTE_VNODE_DELETE = 0x00000001 # Vnode was removed
+      NOTE_VNODE_WRITE = 0x00000002 # Data contents changed
+      NOTE_VNODE_EXTEND = 0x00000004 # Size increased
+      NOTE_VNODE_ATTRIB = 0x00000008 # Attributes changed
+      NOTE_VNODE_LINK = 0x00000010 # Link count changed
+      NOTE_VNODE_RENAME = 0x00000020 # Vnode was renamed
+      NOTE_VNODE_REVOKE = 0x00000040 # Vnode access was revoked
 
       # For `EVFILT_PROC`
-      NOTE_EXIT = 0x80000000 # Process exited
-      NOTE_FORK = 0x40000000 # Process forked
-      NOTE_EXEC = 0x20000000 # Process exec'd
-      NOTE_REAP = 0x10000000 # Process reaped
-      NOTE_SIGNAL = 0x08000000 # Received signal
+      NOTE_PROC_EXIT = 0x80000000 # Process exited
+      NOTE_PROC_FORK = 0x40000000 # Process forked
+      NOTE_PROC_EXEC = 0x20000000 # Process exec'd
+      NOTE_PROC_REAP = 0x10000000 # Process reaped
+      NOTE_PROC_SIGNAL = 0x08000000 # Received signal
+      NOTE_PROC_TRACK = 0x00000001 # follow across forks
+      NOTE_PROC_TRACKERR = 0x00000002 # could not track child
+      NOTE_PROC_CHILD = 0x00000004 # am a child process
+
+      # For `EVFILT_TIMER`
+      NOTE_TIMER_SECONDS = 0x00000001 # data is seconds
+      NOTE_TIMER_USECONDS = 0x00000002 # data is microseconds
+      NOTE_TIMER_NSECONDS = 0x00000004 # data is nanoseconds
+      NOTE_TIMER_ABSOLUTE = 0x00000008 # absolute timeout
 
 
       # Converts a list of flags to the bitmask that the C API expects.

data/lib/rb-kqueue/native.rb

@@ -33,5 +33,8 @@ module KQueue
 
     attach_function :kqueue, [], :int
     attach_function :kevent, [:int, :pointer, :int, :pointer, :int, :pointer], :int
+
+    attach_function :open, [:string, :int], :int
+    attach_function :close, [:int], :int
   end
 end

data/lib/rb-kqueue/queue.rb

@@ -55,7 +55,7 @@ module KQueue
 
     # Watches a stream and produces an event when there's data available to read.
     #
-    # This can watch files, pipes, and fifos.
+    # This can watch files, pipes, fifos, and BPF devices.
     # For files, an event is fired whenever the file pointer
     # is not at the end of the file,
     # and the {Event#data} field is set to the offset
@@ -66,6 +66,17 @@ module KQueue
     # The {Event#data} field is set to the number of bytes available.
     # When the last writer disconnects, {Event#eof?} will be set.
     #
+    # For BPF devices (not supported under Darwin/OS X),
+    # an event is fired when the BPF buffer is full,
+    # the BPF timeout has expired,
+    # or when the BPF has "immediate mode" enabled
+    # and there is data to read.
+    # The {Event#data} field is set to the number of bytes available.
+    #
+    # Note that this isn't compatible with JRuby
+    # unless a native-code file descriptor is passed in.
+    # This means the file descriptor must be returned by an FFI-wrapped C function.
+    #
     # @param fd [IO, Fixnum] A Ruby IO stream, or the file descriptor
     #   for a native IO stream.
     # @yield [event] A block that will be run when the specified stream
@@ -75,7 +86,6 @@ module KQueue
     # @return [Watcher] The Watcher for this event.
     # @raise [SystemCallError] If something goes wrong when registering the Watcher.
     def watch_stream_for_read(fd, &callback)
-      fd = fd.fileno if fd.respond_to?(:fileno)
       Watcher::ReadWrite.new(self, fd, :read, callback)
     end
 
@@ -97,6 +107,10 @@ module KQueue
     # It's possible for {Event#eof?} to be set while there's still
     # data pending in the socket buffer.
     #
+    # Note that this isn't compatible with JRuby
+    # unless a native-code file descriptor is passed in.
+    # This means the file descriptor must be returned by an FFI-wrapped C function.
+    #
     # @param fd [Socket, Fixnum] A Ruby Socket, or the file descriptor
     #   for a native Socket.
     # @param low_water [Fixnum] The low-water mark for new data.
@@ -107,7 +121,6 @@ module KQueue
     # @return [Watcher] The Watcher for this event.
     # @raise [SystemCallError] If something goes wrong when registering the Watcher.
     def watch_socket_for_read(fd, low_water = nil, &callback)
-      fd = fd.fileno if fd.respond_to?(:fileno)
       Watcher::SocketReadWrite.new(self, fd, :read, low_water, callback)
     end
 
@@ -119,6 +132,10 @@ module KQueue
     # remaining in the write buffer.
     # When the reader disconnects, {Event#eof?} will be set.
     #
+    # Note that this isn't compatible with JRuby
+    # unless a native-code file descriptor is passed in.
+    # This means the file descriptor must be returned by an FFI-wrapped C function.
+    #
     # @param fd [IO, Fixnum] A Ruby IO stream, or the file descriptor
     #   for a native IO stream.
     # @yield [event] A block that will be run when the specified stream
@@ -128,7 +145,6 @@ module KQueue
     # @return [Watcher] The Watcher for this event.
     # @raise [SystemCallError] If something goes wrong when registering the Watcher.
     def watch_stream_for_write(fd, &callback)
-      fd = fd.fileno if fd.respond_to?(:fileno)
       Watcher::ReadWrite.new(self, fd, :write, callback)
     end
 
@@ -146,6 +162,10 @@ module KQueue
     # It's possible for {Event#eof?} to be set while there's still
     # data pending in the socket buffer.
     #
+    # Note that this isn't compatible with JRuby
+    # unless a native-code file descriptor is passed in.
+    # This means the file descriptor must be returned by an FFI-wrapped C function.
+    #
     # @param fd [Socket, Fixnum] A Ruby Socket, or the file descriptor
     #   for a native Socket.
     # @param low_water [Fixnum] The low-water mark for new data.
@@ -156,7 +176,6 @@ module KQueue
     # @return [Watcher] The Watcher for this event.
     # @raise [SystemCallError] If something goes wrong when registering the Watcher.
     def watch_socket_for_write(fd, low_water = nil, &callback)
-      fd = fd.fileno if fd.respond_to?(:fileno)
       Watcher::SocketReadWrite.new(self, fd, :write, low_water, callback)
     end
 
@@ -228,9 +247,19 @@ module KQueue
     #
     # `:signal`
     # : The process was sent a signal.
+    #   This is only supported under Darwin/OS X.
     #
     # `:reap`
     # : The process was reaped by the parent via `wait(2)` or similar.
+    #   This is only supported under Darwin/OS X.
+    #
+    # `:track`
+    # : Follow the process across `fork(2)` calls.
+    #   {Event#flags} for the parent process will contain `:fork`,
+    #   while {Event#flags} for the child process will contain `:child`.
+    #   If the system was unable to attach an event to the child process,
+    #   {Event#flags} will contain `:trackerr`.
+    #   This is not supported under Darwin/OS X.
     #
     # @param pid [Fixnum] The id of the process.
     # @param flags [Array<Symbol>] Which events to watch for.
@@ -243,6 +272,40 @@ module KQueue
       Watcher::Process.new(self, path, flags, callback)
     end
 
+    # Watches for signals to this process.
+    # This coexists with other signal facilities, and has lower precedence.
+    # Only signals sent to the process, not to a particular thread, will fire events.
+    # Event notification happens before normal signal delivery processing.
+    #
+    # The {Event#data} field contains the number of times the signal has been generated
+    # since the last time the event was fired.
+    #
+    # @param signal [String, Fixnum] The name of number of the signal.
+    # @yield [event] A block that will be run when the signal is received.
+    # @yieldparam event [Event] The Event object containing information
+    #   about the event that occurred.
+    # @return [Watcher] The Watcher for this event.
+    # @raise [SystemCallError] If something goes wrong when registering the Watcher.
+    def watch_for_signal(signal, &callback)
+      Watcher::Signal.new(self, signal, callback)
+    end
+
+    # Sets up a watcher that fires an event
+    # once every specified interval.
+    #
+    # The {Event#data} field contains the number of times the interval has passed
+    # since the last time the event was fired.
+    #
+    # @param time [Number] The interval, in seconds.
+    # @yield [event] A block that will be run when the interval passes.
+    # @yieldparam event [Event] The Event object containing information
+    #   about the event that occurred.
+    # @return [Watcher] The Watcher for this event.
+    # @raise [SystemCallError] If something goes wrong when registering the Watcher.
+    def watch_timer(time, &callback)
+      Watcher::Timer.new(self, time, callback)
+    end
+
     # Starts the queue watching for events.
     # Blocks until \{#stop} is called.
     #

data/lib/rb-kqueue/watcher/file.rb

@@ -13,7 +13,42 @@ module KQueue
       # @private
       def initialize(queue, path, flags, callback)
         @path = path
-        @file = File.open(path) # TODO: not JRuby-compatible
+        @fd = Native.open(path, 0) # 0 means "read only"
+
+        if @fd < 0
+          raise SystemCallError.new(
+            "Failed to open file #{path}" +
+            case FFI.errno
+            when Errno::EACCES::Errno; ": Permission denied."
+            when Errno::EAGAIN::Errno; ": Slave side of a locked pseudo-terminal device."
+            when Errno::EFAULT::Errno; ": Outside the process's allocated address space."
+            when Errno::EINTR::Errno; ": Interrupted."
+            when Errno::ELOOP::Errno; ": Too many symbolic links (possible loop)."
+            when Errno::EMFILE::Errno; ": Too many open files."
+            when Errno::ENAMETOOLONG::Errno; ": Name too long."
+            when Errno::ENFILE::Errno; ": System file table is full."
+            when Errno::ENOENT::Errno; ": File doesn't exist."
+            when Errno::ENOTDIR::Errno; ": A component of the path prefix is not a directory."
+            when Errno::ENXIO::Errno; ": The device associated with this file doesn't exist."
+            when Errno::EOPNOTSUPP::Errno; ": File type not supported."
+            when Errno::EOVERFLOW::Errno; ": File too big."
+            else; ""
+            end,
+            FFI.errno)
+        end
+
+        ObjectSpace.define_finalizer(self, lambda do
+            next unless Native.close(@fd) < 0
+            raise SystemCallError.new(
+              "Failed to close file #{path}" +
+              case FFI.errno
+              when Errno::EBADF::Errno; ": Invalid file descriptor."
+              when Errno::EINTR::Errno; ": Closing interrupted."
+              when Errno::EIO::Errno; ": IO error."
+              else; ""
+              end,
+              FFI.errno)
+          end)
         super(queue, @file.fileno, :vnode, flags, nil, callback)
       end
     end

data/lib/rb-kqueue/watcher/read_write.rb

@@ -9,6 +9,13 @@ module KQueue
     # Note that read and write events for sockets
     # use the {SocketReadWrite} class.
     class ReadWrite < Watcher
+      # The Ruby IO object from which the file descriptor was extracted.
+      # This is only set if an IO object was used to construct this watcher.
+      # Otherwise, it's `nil`.
+      #
+      # @return [IO, nil]
+      attr_reader :io
+
       # The file descriptor for the stream being watched.
       #
       # @return [Fixnum]
@@ -23,6 +30,11 @@ module KQueue
       #
       # @private
       def initialize(queue, fd, type, callback)
+        if fd.is_a?(IO)
+          @io = fd
+          fd = fd.fileno
+        end
+
         @fd = fd
         @type = type
         super(queue, @fd, type, [], nil, callback)

data/lib/rb-kqueue/watcher/signal.rb

@@ -0,0 +1,32 @@
+module KQueue
+  class Watcher
+    # The {Watcher} subclass for events fired when a signal is received.
+    # Signal events are watched via {Queue#watch_for_signal}.
+    class Signal < Watcher
+      # The name of the signal, e.g. "KILL" for SIGKILL.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # The number of the signal, e.g. 9 for SIGKILL.
+      #
+      # @return [Fixnum]
+      attr_reader :number
+
+      # Creates a new signal Watcher.
+      #
+      # @private
+      def initialize(queue, signal, callback)
+        if signal.is_a?(String)
+          @name = signal
+          @number = Signal.list[signal]
+        else
+          @name = Signal.list.find {|_, n| n == signal}.first
+          @number = signal
+        end
+
+        super(queue, @number, :signal, [], nil, callback)
+      end
+    end
+  end
+end

data/lib/rb-kqueue/watcher/socket_read_write.rb

@@ -20,6 +20,11 @@ module KQueue
       #
       # @private
       def initialize(queue, fd, type, low_water, callback)
+        if fd.is_a?(IO)
+          @io = fd
+          fd = fd.fileno
+        end
+
         @fd = fd
         @type = type
 

data/lib/rb-kqueue/watcher/timer.rb

@@ -0,0 +1,30 @@
+module KQueue
+  class Watcher
+    # The {Watcher} subclass for events fired based on a timer.
+    # Timer events are watched via {Queue#watch_timer}.
+    class Timer < Watcher
+      # The interval on which the timer fires an event, in seconds.
+      #
+      # @return [Numeric]
+      attr_reader :time
+
+      # Creates a new timer Watcher.
+      #
+      # @private
+      def initialize(time, callback)
+        time, unit =
+          if time < 10**-3
+            [(time * 10**9).round, :nseconds]
+          elsif time < 1
+            [(time * 10**6).round, :useconds]
+          elsif time < 10**3 && !time.is_a?(Fixnum)
+            [(time * 10**3).round, nil] # milliseconds
+          else
+            [time.round, :seconds]
+          end
+
+        super(queue, time, :timer, Array(unit), nil, callback)
+      end
+    end
+  end
+end

data/lib/rb-kqueue/watcher.rb

@@ -102,7 +102,7 @@ module KQueue
       native[:ident] = @ident
       native[:filter] = Native::Flags.to_flag("EVFILT", @filter)
       native[:flags] = Native::Flags.to_mask("EV", @flags | flags)
-      native[:fflags] = Native::Flags.to_mask("NOTE", @fflags)
+      native[:fflags] = Native::Flags.to_mask("NOTE_#{@filter.to_s.upcase}", @fflags)
       native[:data] = @data if @data
       native
     end

data/lib/rb-kqueue.rb

@@ -13,7 +13,7 @@ require 'rb-kqueue/queue'
 # * {Watcher} -- A watcher for a single sort of event
 # * {Event} -- A notification that an event has occurred
 module KQueue
-  VERSION = [0, 0, 2]
+  VERSION = [0, 1, 0]
 
   # Raise an exception for a native kqueue error.
   #

data/rb-kqueue.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rb-kqueue}
-  s.version = "0.0.2"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nathan Weizenbaum"]
@@ -31,7 +31,9 @@ Gem::Specification.new do |s|
      "lib/rb-kqueue/watcher/file.rb",
      "lib/rb-kqueue/watcher/process.rb",
      "lib/rb-kqueue/watcher/read_write.rb",
+     "lib/rb-kqueue/watcher/signal.rb",
      "lib/rb-kqueue/watcher/socket_read_write.rb",
+     "lib/rb-kqueue/watcher/timer.rb",
      "rb-kqueue.gemspec"
   ]
   s.homepage = %q{http://github.com/nex3/rb-kqueue}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rb-kqueue
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -56,7 +56,9 @@ files:
 - lib/rb-kqueue/watcher/file.rb
 - lib/rb-kqueue/watcher/process.rb
 - lib/rb-kqueue/watcher/read_write.rb
+- lib/rb-kqueue/watcher/signal.rb
 - lib/rb-kqueue/watcher/socket_read_write.rb
+- lib/rb-kqueue/watcher/timer.rb
 - rb-kqueue.gemspec
 has_rdoc: true
 homepage: http://github.com/nex3/rb-kqueue