rb-kqueue 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 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,5 @@
+# rb-kqueue
+
+This is a simple wrapper over the [kqueue](http://en.wikipedia.org/wiki/Kqueue)
+BSD event notification interface (supported on FreeBSD, NetBSD, OpenBSD, and Darwin).
+It uses the [FFI](http://wiki.github.com/ffi/ffi) gem to avoid having to compile a C extension.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rb-kqueue"
+    gem.summary = "A Ruby wrapper for BSD's kqueue, using FFI"
+    gem.description = gem.summary
+    gem.email = "nex342@gmail.com"
+    gem.homepage = "http://github.com/nex3/rb-kqueue"
+    gem.authors = ["Nathan Weizenbaum"]
+    gem.add_dependency "ffi", ">= 0.5.0"
+    gem.add_development_dependency "yard", ">= 0.4.0"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+module Jeweler::VersionHelper::PlaintextExtension
+  def write_with_inotify
+    write_without_inotify
+    filename = File.join(File.dirname(__FILE__), "lib/rb-kqueue.rb")
+    text = File.read(filename)
+    File.open(filename, 'w') do |f|
+      f.write text.gsub(/^(  VERSION = ).*/, '\1' + [major, minor, patch].inspect)
+    end
+  end
+  alias_method :write_without_inotify, :write
+  alias_method :write, :write_with_inotify
+end
+
+class Jeweler::Commands::Version::Base
+  def commit_version_with_inotify
+    return unless self.repo
+    self.repo.add(File.join(File.dirname(__FILE__), "lib/rb-kqueue.rb"))
+    commit_version_without_inotify
+  end
+  alias_method :commit_version_without_inotify, :commit_version
+  alias_method :commit_version, :commit_version_with_inotify
+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.0.1

data/lib/rb-kqueue.rb

@@ -0,0 +1,28 @@
+require 'rb-kqueue/native'
+require 'rb-kqueue/native/flags'
+require 'rb-kqueue/watcher'
+require 'rb-kqueue/watcher/vnode'
+require 'rb-kqueue/watcher/read_write'
+require 'rb-kqueue/watcher/process'
+require 'rb-kqueue/event'
+require 'rb-kqueue/queue'
+
+module KQueue
+  VERSION = [0, 0, 1]
+
+  def self.handle_error(errno = FFI.errno)
+    raise SystemCallError.new(
+      "KQueue failed" +
+      case errno
+      when Errno::EFAULT::Errno; ": There was an error reading or writing the kevent structure."
+      when Errno::EBADF::Errno; ": The specified descriptor is invalid."
+      when Errno::EINTR::Errno; ": A signal was delivered before the timeout expired and before any events were placed on the kqueue for return."
+      when Errno::EINVAL::Errno; ": The specified time limit or filter is invalid."
+      when Errno::ENOENT::Errno; ": The event could not be found to be modified or deleted."
+      when Errno::ENOMEM::Errno; ": No memory was available to register the event."
+      when Errno::ESRCH::Errno; ": The specified process to attach to does not exist."
+      else; ""
+      end,
+      errno)
+  end
+end

data/lib/rb-kqueue/event.rb

@@ -0,0 +1,32 @@
+module KQueue
+  class Event
+    attr_reader :data
+    attr_reader :filter
+
+    def watcher
+      @watcher ||= @queue.watchers[[filter, @native[:ident]]]
+    end
+
+    def flags
+      @fflags ||= Native::Flags.from_mask("NOTE", @native[:fflags])
+    end
+
+    def eof?
+      @flags.include?(:eof)
+    end
+
+    def initialize(native, queue)
+      @native = native
+      @queue = queue
+      @data = @native[:data]
+      @filter = KQueue::Native::Flags.from_flag("EVFILT", @native[:filter])
+      @flags = Native::Flags.from_mask("EV", @native[:flags])
+
+      KQueue.handle_error @native[:data] if @flags.inclue?(:error)
+    end
+
+    def callback!
+      watcher.callback! self
+    end
+  end
+end

data/lib/rb-kqueue/native.rb

@@ -0,0 +1,26 @@
+require 'ffi'
+
+module KQueue
+  module Native
+    extend FFI::Library
+
+    class KEvent < FFI::Struct
+      layout(
+        :ident,  :uintptr_t,
+        :filter, :int16,
+        :flags,  :uint16,
+        :fflags, :uint32,
+        :data,   :intptr_t,
+        :udata,  :pointer)
+    end
+
+    class TimeSpec < FFI::Struct
+      layout(
+        :tv_sec, :time_t,
+        :tv_nsec, :long)
+    end
+
+    attach_function :kqueue, [], :int
+    attach_function :kevent, [:int, :pointer, :int, :pointer, :int, :pointer], :int
+  end
+end

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

@@ -0,0 +1,85 @@
+module KQueue
+  module Native
+    module Flags
+      # Filters
+      EVFILT_READ = -1
+      EVFILT_WRITE = -2
+      EVFILT_AIO = -3 # Attached to aio requests
+      EVFILT_VNODE = -4 # Attached to vnodes
+      EVFILT_PROC = -5 # Attached to struct proc
+      EVFILT_SIGNAL = -6 # Attached to struct proc
+      EVFILT_TIMER = -7 # Timers
+      EVFILT_MACHPORT = -8 # Mach portsets
+      EVFILT_FS = -9 # Filesystem events
+      EVFILT_USER = -10 # User events
+      EVFILT_SESSION = -11 # Audit session events
+
+
+      # Actions
+      EV_ADD = 0x0001 # Add event to kq (implies enable)
+      EV_DELETE = 0x0002 # Delete event from kq
+      EV_ENABLE = 0x0004 # Enable event
+      EV_DISABLE = 0x0008 # Disable event (not reported)
+      EV_RECEIPT = 0x0040 # Force EV_ERROR on success, data == 0
+
+      # Flags
+      EV_ONESHOT = 0x0010 # Only report one occurrence
+      EV_CLEAR = 0x0020 # Clear event state after reporting
+      EV_DISPATCH = 0x0080 # Disable event after reporting
+
+      # Returned values
+      EV_EOF = 0x8000 # EOF detected
+      EV_ERROR = 0x4000 # Error, data contains errno
+
+
+      # For EVFILT_{READ,WRITE}
+      NOTE_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_NONE = 0x00000080 # No specific vnode event: to test for EVFILT_READ activation
+
+
+      # Converts a list of flags to the bitmask that the C API expects.
+      #
+      # @param prefix [String] The prefix for the C names of the flags
+      # @param flags [Array<Symbol>]
+      # @return [Fixnum]
+      def self.to_mask(prefix, flags)
+        flags.map {|flag| const_get("#{prefix}_#{flag.to_s.upcase}")}.
+          inject(0) {|mask, flag| mask | flag}
+      end
+
+      # Converts a bitmask from the C API into a list of flags.
+      #
+      # @param prefix [String] The prefix for the C names of the flags
+      # @param mask [Fixnum]
+      # @return [Array<Symbol>]
+      def self.from_mask(prefix, mask)
+        re = /^#{Regexp.quote prefix}_/
+        constants.select do |c|
+          next false unless c =~ re
+          const_get(c) & mask != 0
+        end.map {|c| c.sub("#{prefix}_", "").downcase.to_sym}
+      end
+
+      def self.to_flag(prefix, flag)
+        const_get("#{prefix}_#{flag.to_s.upcase}")
+      end
+
+      def self.from_flag(prefix, flag)
+        re = /^#{Regexp.quote prefix}_/
+        constants.each do |c|
+          next unless c =~ re
+          return c.sub("#{prefix}_", "").downcase.to_sym if const_get(c) == flag
+        end
+      end
+    end
+  end
+end

data/lib/rb-kqueue/queue.rb

@@ -0,0 +1,61 @@
+module KQueue
+  class Queue
+    attr_reader :fd
+    attr_reader :watchers
+
+    def initialize
+      @fd = Native.kqueue
+      @watchers = {}
+    end
+
+    def watch_for_read(fd, &callback)
+      fd = fd.fileno if fd.respond_to?(:fileno)
+      Watcher::ReadWrite.new(self, fd, :read, callback)
+    end
+
+    def watch_for_socket_read(fd, low_water = nil, &callback)
+      fd = fd.fileno if fd.respond_to?(:fileno)
+      Watcher::SocketReadWrite.new(self, fd, :read, low_water, callback)
+    end
+
+    def watch_for_write(fd, &callback)
+      fd = fd.fileno if fd.respond_to?(:fileno)
+      Watcher::ReadWrite.new(self, fd, :write, callback)
+    end
+
+    def watch_for_socket_write(fd, low_water = nil, &callback)
+      fd = fd.fileno if fd.respond_to?(:fileno)
+      Watcher::SocketReadWrite.new(self, fd, :write, low_water, callback)
+    end
+
+    def watch_for_file_change(path, *flags, &callback)
+      Watcher::VNode.new(self, path, flags, callback)
+    end
+
+    def watch_for_process_change(pid, *flags, &callback)
+      Watcher::Process.new(self, path, flags, callback)
+    end
+
+    def run
+      @stop = false
+      process until @stop
+    end
+
+    def stop
+      @stop = true
+    end
+
+    def process
+      read_events.each {|event| event.callback!}
+    end
+
+    def read_events
+      size = 1024
+      eventlist = FFI::MemoryPointer.new(Native::KEvent, size)
+      res = Native.kevent(@fd, nil, 0, eventlist, size, nil)
+
+      KQueue.handle_error if res < 0
+      (0...res).map {|i| KQueue::Event.new(Native::KEvent.new(eventlist[i]), self)}
+    end
+  end
+end

data/lib/rb-kqueue/watcher.rb

@@ -0,0 +1,56 @@
+module KQueue
+  class Watcher
+    attr_reader :queue
+
+    def initialize(queue, ident, filter, fflags, data, callback)
+      @queue = queue
+      @ident = ident
+      @filter = filter
+      @flags = []
+      @fflags = fflags
+      @data = data
+      @callback = callback
+      add!
+    end
+
+    def add!
+      kqueue! :add, :clear # TODO: Don't always enable :clear
+      @queue.watchers[[@filter, @ident]] = self
+    end
+
+    def delete!
+      kqueue! :delete
+      @queue.watchers.delete([@filter, @ident])
+    end
+
+    def enable!
+      kqueue! :enable
+    end
+
+    def disable!
+      kqueue! :disable
+    end
+
+    def callback!(event)
+      @callback.call event
+    end
+
+    private
+
+    def native(flags)
+      native = Native::KEvent.new
+      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[:data] = @data if @data
+      native
+    end
+
+    def kqueue!(*flags)
+      if Native.kevent(@queue.fd, native(flags).pointer, 1, nil, 0, nil) < 0
+        KQueue.handle_error
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module KQueue
+  class Watcher
+    class Process < Watcher
+      attr_reader :pid
+
+      def initialize(queue, pid, flags, callback)
+        @pid = pid
+        super(queue, pid, :proc, flags, nil, callback)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module KQueue
+  class Watcher
+    class ReadWrite < Watcher
+      attr_reader :fd
+      attr_reader :type
+
+      def initialize(queue, fd, type, callback)
+        @fd = fd
+        @type = type
+        super(queue, @fd, type, [], nil, callback)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module KQueue
+  class Watcher
+    class SocketReadWrite < ReadWrite
+      attr_reader :low_water
+
+      def initialize(queue, fd, type, low_water, callback)
+        @fd = fd
+        @type = type
+
+        if low_water
+          fflags = [:lowat]
+          data = low_water
+        else
+          fflags = []
+          data = nil
+        end
+
+        super(queue, @fd, type, fflags, data, callback)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module KQueue
+  class Watcher
+    class VNode < Watcher
+      attr_reader :path
+
+      def initialize(queue, path, flags, callback)
+        @path = path
+        @file = File.open(path) # TODO: not JRuby-compatible
+        super(queue, @file.fileno, :vnode, flags, nil, callback)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: rb-kqueue
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nathan Weizenbaum
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-07 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
+description: A Ruby wrapper for BSD's kqueue, using FFI
+email: nex342@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- MIT-LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/rb-kqueue.rb
+- lib/rb-kqueue/event.rb
+- lib/rb-kqueue/native.rb
+- lib/rb-kqueue/native/flags.rb
+- lib/rb-kqueue/queue.rb
+- lib/rb-kqueue/watcher.rb
+- lib/rb-kqueue/watcher/process.rb
+- lib/rb-kqueue/watcher/read_write.rb
+- lib/rb-kqueue/watcher/socket_read_write.rb
+- lib/rb-kqueue/watcher/vnode.rb
+has_rdoc: true
+homepage: http://github.com/nex3/rb-kqueue
+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 BSD's kqueue, using FFI
+test_files: []
+