rb-kqueue 0.0.3 → 0.1.0

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.1.0

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, 3]
+  VERSION = [0, 1, 0]
 
   # Raise an exception for a native kqueue error.
   #

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/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,13 @@ 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.
@@ -240,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.
@@ -255,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.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/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/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/rb-kqueue.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rb-kqueue}
-  s.version = "0.0.3"
+  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.3
+  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