unbound 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41262867ad30ae0615f3a7669517863964d4b0e5
-  data.tar.gz: 6bde21f3af9105f0e41e3c91dc6db1ebc847fc82
+  metadata.gz: b9e071138d458da3ab632fd55f7208e686e55679
+  data.tar.gz: ffebd0663a8fe538b933c21cb35bd9f876ec64eb
 SHA512:
-  metadata.gz: 450c506ec33c36d41205ab8a0f58d746803ff1a211dac1ebf6c42758a9837a4f1bedb611bdeb992a48b7489bf2f46b2b20e4945444c88bb600bf30507904a8b4
-  data.tar.gz: bdcd31bd6a883049f0b80271daea7d5fc6d37880faf47a808c64440a852997b4e44673b291a158e3150e93fea8f4e499e7fcf69184b3de30d08407bb777d5d82
+  metadata.gz: 3190a931ff0e491a2c772056b486cad1c35b0e54ade6c6b6cf9429dfdd154157921fac796e62b34d0ea6ae699056a968b02776723179224c337bad716de2809d
+  data.tar.gz: c539edfe6095cf3dba1c51411782ee6dcfc5f8c73e611270ebcaaa39e855dd61256c650d1f79ca6f058133c3bdadba7f08d4f75271d0317fbf5643d2d71ed15a

data/README.md

@@ -6,42 +6,7 @@ These bindings allow for asynchronous and synchronous name resolution. You reall
 
 ## Code Example
 
-```
-require 'unbound/context'
-require 'unbound/result'
-
-ctx = Unbound::Context.new
-
-CB = Proc.new do |mydata, err, result_ptr|
-  if (err == 0) 
-    result = Unbound::Result.new(result_ptr)
-    puts "Got response rcode: #{result[:rcode]}, qname: #{result[:qname]}"
-  end
-end
-
-google_id = ctx.resolve_async("www.google.com", 1, 1, CB)
-yahoo_id = ctx.resolve_async("www.yahoo.com", 1, 1, CB)
-github_id = ctx.resolve_async("www.github.com", 1, 1, CB)
-
-io = ctx.io
-
-# Keep looping until we haven't gotten any
-while (::IO.select([io], nil, nil, 5)) 
-  ctx.process()
-end
-
-ctx.close()
-puts "all done!"
-```
-
-outputs:
-```
-Got response rcode: 0, qname: www.google.com
-Got response rcode: 0, qname: www.github.com
-Got response rcode: 0, qname: www.yahoo.com
-all done!
-```
-
+See the examples directory.
 
 ## Motivation
 

data/Rakefile

@@ -20,6 +20,7 @@ Jeweler::Tasks.new do |gem|
   gem.email = "falter@gmail.com"
   gem.authors = ["Mike Ryan"]
   gem.files  = Dir.glob("lib/**/*.rb") + 
+              Dir.glob("examples/*") + 
               Dir.glob("spec/{*.rb}") + 
               Dir.glob("spec/conf/{*.conf}") + 
               %w(LICENSE.txt Gemfile README.md Rakefile VERSION)

data/VERSION

@@ -1 +1 @@
-0.0.2
+1.0.0

data/examples/resolve_async.rb

@@ -0,0 +1,47 @@
+# Example that resolves three hostnames in an aynchronous fashion.
+#
+# Outputs:
+#   Got result for www.google.com!
+#   Got result for github.com!
+#   Got result for www.yahoo.com!
+#   all done!
+# 
+require 'unbound'
+
+ctx = Unbound::Context.new
+resolver = Unbound::Resolver.new(ctx)
+
+at_exit do
+  resolver.close unless resolver.closed?
+end
+
+# Add some callbacks to the resolver
+resolver.on_answer do |q, result|
+  puts "Got result for #{q.name} : rcode: #{result[:rcode]}!"
+end
+resolver.on_cancel do |q|
+  puts "Query canceled: #{q.name}!"
+end
+resolver.on_error do |q, error_code|
+  puts "Query had error: #{q.name} #{error_code}!"
+end
+
+names = ["www.google.com", "www.yahoo.com", "github.com", "notadomain"]
+names.each do |name|
+  query = Unbound::Query.new(name, 1, 1)
+  query.on_answer do |query, result|
+    puts "query-level callback for on_answer: #{name}"
+  end
+  resolver.send_query(query)
+end
+
+io = resolver.io
+
+# Keep looping until we haven't gotten any
+while resolver.outstanding_queries? && (::IO.select([io], nil, nil, 5)) 
+  ctx.process()
+end
+
+resolver.close()
+puts "all done!"
+

data/lib/unbound.rb

@@ -1,3 +1,7 @@
 module Unbound
   require 'unbound/bindings'
+  require 'unbound/result'
+  require 'unbound/query'
+  require 'unbound/context'
+  require 'unbound/resolver'
 end

data/lib/unbound/bindings.rb

@@ -1,15 +1,46 @@
 require 'ffi'
+require 'unbound/result'
 module Unbound
   module Bindings
     extend FFI::Library
 
     LIBNAMES = ['unbound', 'libunbound.so', 'libunbound.so.2']
     if ENV['LIBUNBOUND']
+      # :nocov:
       LIBNAMES.unshift(ENV['LIBUNBOUND'])
+      # :nocov:
     end
 
     ffi_lib LIBNAMES
 
+    enum :error_code,
+      [
+        # /** no error */
+        :noerror , 0,
+        # /** socket operation. Set to -1, so that if an error from _fd() is
+        #  * passed (-1) it gives a socket error. */
+        :socket , -1,
+        # /** alloc failure */
+        :nomem , -2,
+        # /** syntax error */
+        :syntax , -3,
+        # /** DNS service failed */
+        :servfail , -4,
+        # /** fork() failed */
+        :forkfail , -5,
+        # /** cfg change after finalize() */
+        :afterfinal , -6,
+        # /** initialization failed (bad settings) */
+        :initfail , -7,
+        # /** error in pipe communication with async bg worker */
+        :pipe , -8,
+        # /** error reading from file (resolv.conf) */
+        :readfile , -9,
+        # /** error async_id does not exist or result already been delivered */
+        :noid , -10
+    ]
+      
+    
 
     typedef :pointer, :mydata
     typedef :pointer, :ub_ctx_ptr
@@ -22,43 +53,43 @@ module Unbound
     attach_function :ub_ctx_create, [], :ub_ctx_ptr
     attach_function :ub_ctx_delete, [:ub_ctx_ptr], :void
 
-    attach_function :ub_ctx_set_option, [:ub_ctx_ptr, :string, :string], :int
-    attach_function :ub_ctx_get_option, [:ub_ctx_ptr, :string, :pointer], :int
-    attach_function :ub_ctx_config, [:ub_ctx_ptr, :string], :int
+    attach_function :ub_ctx_set_option, [:ub_ctx_ptr, :string, :string], :error_code
+    attach_function :ub_ctx_get_option, [:ub_ctx_ptr, :string, :pointer], :error_code
+    attach_function :ub_ctx_config, [:ub_ctx_ptr, :string], :error_code
 
-    attach_function :ub_ctx_set_fwd, [:ub_ctx_ptr, :string], :int
-    attach_function :ub_ctx_resolvconf, [:ub_ctx_ptr, :string], :int
-    attach_function :ub_ctx_hosts, [:ub_ctx_ptr, :string], :int
+    attach_function :ub_ctx_set_fwd, [:ub_ctx_ptr, :string], :error_code
+    attach_function :ub_ctx_resolvconf, [:ub_ctx_ptr, :string], :error_code
+    attach_function :ub_ctx_hosts, [:ub_ctx_ptr, :string], :error_code
 
-    attach_function :ub_ctx_add_ta, [:ub_ctx_ptr, :string], :int
-    attach_function :ub_ctx_add_ta_file, [:ub_ctx_ptr, :string], :int
+    attach_function :ub_ctx_add_ta, [:ub_ctx_ptr, :string], :error_code
+    attach_function :ub_ctx_add_ta_file, [:ub_ctx_ptr, :string], :error_code
 
-    attach_function :ub_ctx_trustedkeys, [:ub_ctx_ptr, :string], :int
+    attach_function :ub_ctx_trustedkeys, [:ub_ctx_ptr, :string], :error_code
 
-    attach_function :ub_ctx_debugout, [:ub_ctx_ptr, :pointer], :int # TODO: FILE pointer
-    attach_function :ub_ctx_debuglevel, [:ub_ctx_ptr, :int], :int
+    attach_function :ub_ctx_debugout, [:ub_ctx_ptr, :pointer], :error_code # TODO: FILE pointer
+    attach_function :ub_ctx_debuglevel, [:ub_ctx_ptr, :int], :error_code
 
-    attach_function :ub_ctx_async, [:ub_ctx_ptr, :int], :int
+    attach_function :ub_ctx_async, [:ub_ctx_ptr, :int], :error_code
 
-    attach_function :ub_poll, [:ub_ctx_ptr], :int
-    attach_function :ub_wait, [:ub_ctx_ptr], :int, :blocking => true
-    attach_function :ub_fd, [:ub_ctx_ptr], :int
-    attach_function :ub_process, [:ub_ctx_ptr], :int, :blocking => true
+    attach_function :ub_poll, [:ub_ctx_ptr], :error_code
+    attach_function :ub_wait, [:ub_ctx_ptr], :error_code, :blocking => true
+    attach_function :ub_fd, [:ub_ctx_ptr], :error_code
+    attach_function :ub_process, [:ub_ctx_ptr], :error_code, :blocking => true
 
-    attach_function :ub_resolve,       [:ub_ctx_ptr, :string, :int, :int, :ub_result_ptrptr], :int, :blocking => true
-    attach_function :ub_resolve_async, [:ub_ctx_ptr, :string, :int, :int, :mydata, :ub_callback_t, :pointer], :int
-    attach_function :ub_cancel, [:ub_ctx_ptr, :int], :int
+    attach_function :ub_resolve,       [:ub_ctx_ptr, :string, :int, :int, :ub_result_ptrptr], :error_code, :blocking => true
+    attach_function :ub_resolve_async, [:ub_ctx_ptr, :string, :int, :int, :mydata, :ub_callback_t, :pointer], :error_code
+    attach_function :ub_cancel, [:ub_ctx_ptr, :int], :error_code
 
     attach_function :ub_resolve_free, [:ub_result_ptr], :void
-    attach_function :ub_strerror, [:int], :string
+    attach_function :ub_strerror, [:error_code], :string
 
-    attach_function :ub_ctx_print_local_zones, [:ub_ctx_ptr], :int
+    attach_function :ub_ctx_print_local_zones, [:ub_ctx_ptr], :error_code
 
-    attach_function :ub_ctx_zone_add, [:ub_ctx_ptr, :string, :string], :int
-    attach_function :ub_ctx_zone_remove, [:ub_ctx_ptr, :string], :int
+    attach_function :ub_ctx_zone_add, [:ub_ctx_ptr, :string, :string], :error_code
+    attach_function :ub_ctx_zone_remove, [:ub_ctx_ptr, :string], :error_code
 
-    attach_function :ub_ctx_data_add, [:ub_ctx_ptr, :string], :int
-    attach_function :ub_ctx_data_remove, [:ub_ctx_ptr, :string], :int
+    attach_function :ub_ctx_data_add, [:ub_ctx_ptr, :string], :error_code
+    attach_function :ub_ctx_data_remove, [:ub_ctx_ptr, :string], :error_code
 
     ## This wasn't added until unbound 1.4.15
     # attach_function :ub_version, [], :string

data/lib/unbound/callback_array.rb

@@ -0,0 +1,21 @@
+module Unbound
+  class CallbackArray < Array
+    # Registers one or more callbacks
+    # @param [Array<#call>] cbs A splat of procs to register as callbacks
+    # @yield [] cb_block A block to register as a callback
+    # @raise [ArgumentError] if no callbacks are provided
+    def add_callback(*cbs, &cb_block)
+      cbs.push(cb_block) unless cb_block.nil?
+      raise(ArgumentError.new("Missing callback")) if cbs.empty?
+      concat(cbs)
+    end
+
+    # Calls each registered callback with the provided arguments
+    # @param [Array] args A splat of arguments to pass to each callback via #call
+    def call(*args)
+      each do |cb|
+        cb.call(*args)
+      end
+    end
+  end
+end

data/lib/unbound/callbacks_mixin.rb

@@ -0,0 +1,54 @@
+require 'unbound/callback_array'
+module Unbound
+  module CallbacksMixin
+    def init_callbacks
+      @callbacks_start = CallbackArray.new
+      @callbacks_answer = CallbackArray.new
+      @callbacks_error = CallbackArray.new
+      @callbacks_cancel = CallbackArray.new
+      @callbacks_finish = CallbackArray.new
+    end
+    private :init_callbacks
+
+    def clear_callbacks!
+      @callbacks_start.clear
+      @callbacks_answer.clear
+      @callbacks_error.clear
+      @callbacks_cancel.clear
+      @callbacks_finish.clear
+    end
+    private :clear_callbacks!
+
+    # Adds a callback that will be called just after the query is sent
+    # @param [Proc] cb
+    def on_start(*cbs, &cb_block)
+      @callbacks_start.add_callback(*cbs, &cb_block)
+    end
+
+    # Adds a callback that will be called when we receive an answer to the query
+    # @param [Proc] cb
+    def on_answer(*cbs, &cb_block)
+      @callbacks_answer.add_callback(*cbs, &cb_block)
+    end
+
+    # Adds a callback that will be called when an error internal to unbound occurs
+    # @param [Proc] cb
+    def on_error(*cbs, &cb_block)
+      @callbacks_error.add_callback(*cbs, &cb_block)
+    end
+
+    # Adds a callback that will be called if the query times out (dependant on 
+    # the resolver)
+    # @param [Proc] cb
+    def on_cancel(*cbs, &cb_block)
+      @callbacks_cancel.add_callback(*cbs, &cb_block)
+    end
+
+    # Adds a callback will *always* be called when the query is finished 
+    # whether answerfully, in error, or due to cancel.
+    # @param [Proc] cb
+    def on_finish(*cbs, &cb_block)
+      @callbacks_finish.add_callback(*cbs, &cb_block)
+    end
+  end
+end

data/lib/unbound/context.rb

@@ -5,6 +5,15 @@ module Unbound
   class Context
     def initialize
       @ub_ctx = Unbound::Bindings.ub_ctx_create()
+      @raise_on_noid = false
+    end
+
+    def raise_on_noid=(b)
+      @raise_on_noid = (b == true)
+    end
+
+    def raise_on_noid?
+      @raise_on_noid
     end
 
     def check_closed!
@@ -14,10 +23,12 @@ module Unbound
     end
 
     def raise_if_error!(retval)
-      if retval != 0
-        raise APIError.new(retval)
+      return retval if retval == :noerror
+
+      if retval == :noid && @raise_on_noid == false
+        return retval
       end
-      return retval
+      raise APIError.new(retval)
     end
 
     def closed?

data/lib/unbound/exceptions.rb

@@ -23,4 +23,8 @@ module Unbound
   class ContextClosedError < MissingContextError
   end
 
+  # Indicates that an identical query object has already been submitted.
+  class QueryAlreadyStarted < Error
+  end
+
 end

data/lib/unbound/query.rb

@@ -0,0 +1,72 @@
+require 'unbound/exceptions'
+require 'unbound/callbacks_mixin'
+module Unbound
+  # A representation of a query, as used by Unbound::Resolver
+  class Query
+    include CallbacksMixin
+    attr_reader :name, :rrtype, :rrclass, :async_id
+
+    STATE_INIT = 0
+    STATE_STARTED = 1
+    STATE_FINISHED = 100
+
+    # @param [String] name
+    # @param [Integer] rrtype
+    # @param [Integer] rrclass
+    def initialize(name, rrtype, rrclass)
+      @name = name
+      @rrtype = rrtype
+      @rrclass = rrclass
+      @async_id = nil
+
+      @state = STATE_INIT
+      init_callbacks
+    end
+    
+    # @return [Boolean] whether the query has finished or not
+    def finished?
+      @state >= STATE_FINISHED
+    end
+    
+    # @return [Boolean] whether the query has been started or not
+    def started?
+      @state >= STATE_STARTED
+    end
+
+    # Called by the resolver just after it has sent the query, and received an
+    # asynchronous ID.
+    def start!(async_id)
+      @state = STATE_STARTED
+      @async_id = async_id
+      @callbacks_start.call(self)
+      @callbacks_start.clear
+    end
+
+    # Called by the resolver when it has received an answer
+    # @param [Unbound::Result] result The result structure
+    def answer!(result)
+      @callbacks_answer.call(self, result)
+      finish!()
+    end
+
+    # Called by the resolver when it has encountered an internal unbound error
+    # @param [Unbound::Bindings::error_codes] error_code 
+    def error!(error_code)
+      @callbacks_error.call(self, error_code)
+      finish!()
+    end
+
+    # Called by the resolver after a cancel has occurred.
+    def cancel!()
+      @callbacks_cancel.call(self)
+      finish!()
+    end
+
+    private
+    def finish!()
+      @state = STATE_FINISHED
+      @callbacks_finish.call(self)
+      clear_callbacks!
+    end
+  end
+end

data/lib/unbound/resolver.rb

@@ -1,36 +1,115 @@
 require 'unbound/bindings'
 require 'unbound/result'
 require 'unbound/context'
+require 'unbound/callbacks_mixin'
 
 module Unbound
+  # A simple asynchronous resolver
   class Resolver
-    def initialize()
-      @ctx = Unbound::Context.new
-      @ctx.load_config("unbound/etc/unbound.conf")
+    include CallbacksMixin
 
-      cb = Proc.new { |a,b,c| nil }
-      self.query("localhost", 1, 1, cb) 
-      @ctx.wait()
+    # @param [Unbound::Context] ctx The context around which we will wrap this
+    #  resolver.
+    def initialize(ctx)
+      @ctx = ctx
+      @queries = {}
+      @resolve_callback_func = FFI::Function.new(
+        :void, [:pointer, :int, :pointer], 
+        self.method(:resolve_callback))
+
+      init_callbacks
+
+      on_cancel do |query|
+        if query.async_id
+          @ctx.cancel_async_query(query.async_id)
+        end
+      end
+      on_finish do |query|
+        @queries.delete(query.object_id)
+      end
+    end
+
+    # @return [Integer] the number of queries for which we are awaiting reply
+    def outstanding_queries
+      @queries.count
     end
 
+    # @return [Boolean] true if there are any queries for which we are awaiting
+    #  reply
+    def outstanding_queries?
+      @queries.count > 0
+    end
+
+    def resolve_callback(oid_ptr, err, result_ptr)
+      return if oid_ptr.nil?
+      oid = oid_ptr.address
+      query = @queries[oid]
+      return if query.nil?
+
+      if err == 0
+        query.answer!(Unbound::Result.new(result_ptr))
+      else 
+        # :nocov:
+        query.error!(err)
+        # :nocov:
+      end
+    ensure 
+      if err == 0
+        # Always free the result pointer
+        Unbound::Bindings.ub_resolve_free(result_ptr)
+      end
+    end
+    private :resolve_callback
+
+    # Cancel all outstanding queries.
+    def cancel_all
+      @queries.each_value do |query|
+        query.cancel!
+      end
+      @queries.clear
+    end
+
+    def closed?
+      @ctx.closed?
+    end
+
+    # Cancel all queries and close the resolver down.
     def close
+      return if self.closed? == true
+      self.cancel_all
       @ctx.close
     end
 
-    def fd
-      @ctx.fd
+    # @see Unbound::Context#io
+    def io
+      @ctx.io
     end
 
+    # @see Unbound::Context#process
     def process
       @ctx.process
     end
 
-    def cancel(async_id)
-      @ctx.cancel_async_query(async_id)
-    end
-
-    def query(name, rrtype, rrclass, callback, private_data = nil)
-      @ctx.resolve_async(name, rrtype, rrclass, callback, private_data)
+    # @param [Unbound::Query] query
+    def send_query(query)
+      if query.started?
+        raise QueryAlreadyStarted.new
+      end
+      @queries[query.object_id] = query
+      # Add all of our callbacks, if any have been registered.
+      query.on_start(*@callbacks_start) unless @callbacks_start.empty?
+      query.on_answer(*@callbacks_answer) unless @callbacks_answer.empty?
+      query.on_error(*@callbacks_error) unless @callbacks_error.empty?
+      query.on_cancel(*@callbacks_cancel)
+      query.on_finish(*@callbacks_finish)
+      oid_ptr = FFI::Pointer.new query.object_id
+      async_id = @ctx.resolve_async(
+        query.name, 
+        query.rrtype, 
+        query.rrclass, 
+        @resolve_callback_func, 
+        oid_ptr)
+      query.start!(async_id)
     end
   end
 end

data/lib/unbound/result.rb

@@ -50,15 +50,7 @@ module Unbound
     end
   end
 
-  class Result < FFI::ManagedStruct
-    include ResultLayout
-
-    def self.release(ptr)
-      Unbound.ub_resolve_free(ptr)
-    end
-  end
-
-  class ResultCast < FFI::Struct
+  class Result < FFI::Struct
     include ResultLayout
   end
 end

data/spec/callback_array_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Unbound::CallbackArray do
+  before :each do
+    @cba = Unbound::CallbackArray.new
+  end
+
+  describe "#add_callback" do
+    it "should raise an ArgumentError if no callback is provided" do
+      expect { 
+        @cba.add_callback()
+      }.to raise_error(ArgumentError)
+    end
+    it "should accept a callback as an argument" do
+      proc1 = Proc.new {}
+      @cba.add_callback(proc1)
+      expect(@cba).to eq([proc1])
+    end
+    it "should accept a callback as block" do
+      proc1 = Proc.new {}
+      @cba.add_callback(&proc1)
+      expect(@cba).to eq([proc1])
+    end
+    it "should accept multiple callbacks as arguments in order" do
+      proc1 = Proc.new {}
+      proc2 = Proc.new {}
+      proc3 = Proc.new {}
+      proc4 = Proc.new {}
+      proc5 = Proc.new {}
+      @cba.add_callback(proc1, proc2, proc3, proc4, proc5)
+      expect(@cba).to eq([proc1, proc2, proc3, proc4, proc5])
+    end
+    it "should preserve order" do
+      proc1 = Proc.new {}
+      proc2 = Proc.new {}
+      proc3 = Proc.new {}
+      proc4 = Proc.new {}
+      proc5 = Proc.new {}
+      @cba.add_callback(proc1)
+      @cba.add_callback(proc2)
+      @cba.add_callback(proc3)
+      @cba.add_callback(proc4)
+      @cba.add_callback(proc5)
+      expect(@cba).to eq([proc1, proc2, proc3, proc4, proc5])
+    end
+    it "should arguments and blocks at the same time" do
+      proc1 = Proc.new {}
+      proc2 = Proc.new {}
+      proc3 = Proc.new {}
+      proc4 = Proc.new {}
+      proc5 = Proc.new {}
+      @cba.add_callback(proc1, proc2, proc3, proc4, &proc5)
+      expect(@cba).to eq([proc1, proc2, proc3, proc4, proc5])
+    end
+  end
+  describe "#call" do
+    it "should arguments and blocks at the same time" do
+      expect { |cb1|
+        expect { |cb2|
+          expect { |cb3|
+            expect { |cb4|
+              @cba.add_callback(cb1.to_proc, cb2.to_proc, cb3.to_proc, cb4.to_proc)
+              @cba.call(1,2,3)
+            }.to yield_with_args(1,2,3)
+          }.to yield_with_args(1,2,3)
+        }.to yield_with_args(1,2,3)
+      }.to yield_with_args(1,2,3)
+    end
+  end
+end
+

data/spec/context_spec.rb

@@ -1,8 +1,4 @@
 require 'spec_helper'
-require 'unbound/context'
-require 'unbound/exceptions'
-require 'unbound/result'
-require 'pp'
 
 describe Unbound::Context do
   before :each do
@@ -13,6 +9,15 @@ describe Unbound::Context do
     @ctx.close unless @ctx.closed?
   end
 
+  subject { @ctx }
+  its(:raise_on_noid?) { should be_false }
+
+
+  it "should let me indicate that it should raise an error if the error code is :noid" do
+    @ctx.raise_on_noid = true
+    expect(@ctx.raise_on_noid?).to be_true
+  end
+
   describe "#closed?" do
     it "should indicate whether the context is closed or not" do
       expect(@ctx.closed?).to be_false
@@ -74,7 +79,6 @@ describe Unbound::Context do
       expect(1).to be(1)
 
       @cb_result_ptr = nil
-      @cb_result = nil
       @cb_err = nil
       @cb_mydata = nil
 
@@ -82,9 +86,6 @@ describe Unbound::Context do
         @cb_mydata = mydata
         @cb_err = err
         @cb_result_ptr = result_ptr
-        if (@cb_err == 0) 
-          @cb_result = Unbound::Result.new(@cb_result_ptr)
-        end
       end
     end
 
@@ -120,14 +121,21 @@ describe Unbound::Context do
       end
 
       it "should cancel a query" do
-        expect(@ctx.cancel_async_query(@async_id)).to be(0)
+        expect(@ctx.cancel_async_query(@async_id)).to be(:noerror)
       end
       
       it "should raise an APIError when canceling a non-existent query" do
+        @ctx.raise_on_noid = true 
+        expect(@ctx.raise_on_noid?).to be_true
         expect(lambda do 
           @ctx.cancel_async_query(@async_id + 1)
         end).to raise_error(Unbound::APIError)
       end
+
+      it "#raise_on_noid=false should raise an APIError when canceling a non-existent query" do
+        expect(@ctx.raise_on_noid?).to be_false
+        expect(@ctx.cancel_async_query(@async_id + 1)).to eq(:noid)
+      end
     end
   end
 

data/spec/query_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe Unbound::Query do
+  context "a query for google.com IN A" do
+    before :each do
+      @rrtype = 1
+      @rrclass = 1
+      @name = "google.com"
+      @query = Unbound::Query.new(@name, @rrtype, @rrclass)
+    end
+
+    subject {@query}
+    its(:name) { should eq("google.com") }
+    its(:rrtype) { should eq(1) }
+    its(:rrclass) { should eq(1) }
+
+    describe "#finished?" do
+      it "should be false by default" do
+        expect(@query.finished?).to be_false
+      end
+      it "should be true after #cancel! is called" do
+        @query.cancel!
+        expect(@query.finished?).to be_true
+      end
+      it "should be true after #error! is called" do
+        @query.error!(1234)
+        expect(@query.finished?).to be_true
+      end
+      it "should be true after #answer! is called" do
+        result = double("Result")
+        @query.answer!(result)
+        expect(@query.finished?).to be_true
+      end
+    end
+
+    describe "#start!" do
+      it "should set the async_id" do
+        expect(@query.async_id).to be_nil
+        @query.start!(1234)
+        expect(@query.async_id).to eq(1234)
+      end
+
+      specify "the query should be started after calling" do
+        @query.start!(1234)
+        expect(@query).to be_started
+      end
+    end
+
+    describe "#started?" do
+      it "should be false by default" do
+        expect(@query.started?).to be_false
+      end
+      it "should be true after start! is called" do
+        @query.start!(1234)
+        expect(@query.started?).to be_true
+      end
+    end
+
+    describe "#on_start" do
+      it "should be called after start! is called" do
+        expect { |cb|
+          @query.on_start(cb.to_proc)
+          @query.start!(1234)
+        }.to yield_with_args(@query)
+      end
+    end
+
+    describe "#error!" do
+      it "should require an error code as an argument" do
+        expect {
+          @query.error!
+        }.to raise_error(ArgumentError)
+        expect {
+          @query.error!(1234)
+        }.to_not raise_error
+      end
+
+      specify "the query finished after being called" do
+        @query.error!(1234)
+        expect(@query).to be_finished
+      end
+    end
+
+    describe "#answer!" do
+      it "should require a result as an argument" do
+        expect {
+          @query.answer!
+        }.to raise_error(ArgumentError)
+        result = double("Result")
+        expect {
+          @query.answer!(result)
+        }.to_not raise_error
+      end
+
+      specify "the query finished after being called" do
+        result = double("Result")
+        @query.answer!(result)
+        expect(@query).to be_finished
+      end
+    end
+
+    describe "#cancel!" do
+      it "should require that no arguments be specified" do
+        expect {
+          @query.cancel!(1234)
+        }.to raise_error(ArgumentError)
+        expect {
+          @query.cancel!()
+        }.to_not raise_error
+      end
+
+      specify "the query finished after being called" do
+        @query.cancel!
+        expect(@query).to be_finished
+      end
+    end
+
+
+    describe "#on_error" do
+      specify "callbacks should be called upon #error!, but not others" do
+        expect { |answer_cb|
+          expect { |error_cb|
+            expect { |cancel_cb|
+              @query.on_answer(&answer_cb)
+              @query.on_error(&error_cb)
+              @query.on_cancel(&cancel_cb)
+              @query.error!(999)
+            }.to_not yield_control
+          }.to yield_control
+        }.to_not yield_control
+      end
+
+      specify "callbacks should be called with the query object and error code" do
+        expect { |error_cb|
+          @query.on_error(&error_cb)
+          @query.error!(999)
+        }.to yield_with_args(@query, 999)
+      end
+    end
+
+    describe "#on_answer" do
+      specify "callbacks should be called upon #answer!, but not others" do
+        result = double("Result")
+        expect { |answer_cb|
+          expect { |error_cb|
+            expect { |cancel_cb|
+              @query.on_answer(&answer_cb)
+              @query.on_error(&error_cb)
+              @query.on_cancel(&cancel_cb)
+              @query.answer!(result)
+            }.to_not yield_control
+          }.to_not yield_control
+        }.to yield_control
+      end
+
+      specify "callbacks should be called with the query object and result object" do
+        result = double("Result")
+        expect { |answer_cb|
+          @query.on_answer(&answer_cb)
+          @query.answer!(result)
+        }.to yield_with_args(@query, result)
+      end
+    end 
+
+    describe "#on_cancel" do
+      specify "callbacks should be called upon #cancel!, but not others" do
+        expect { |answer_cb|
+          expect { |error_cb|
+            expect { |cancel_cb|
+              @query.on_answer(&answer_cb)
+              @query.on_error(&error_cb)
+              @query.on_cancel(&cancel_cb)
+              @query.cancel!()
+            }.to yield_control
+          }.to_not yield_control
+        }.to_not yield_control
+      end
+
+      specify "callbacks should be called with the query object" do
+        expect { |cancel_cb|
+          @query.on_cancel(&cancel_cb)
+          @query.cancel!()
+        }.to yield_with_args(@query)
+      end
+    end
+
+    describe "#on_finish" do
+      it "should be called after cancel! is called" do
+        expect { |cb|
+          @query.on_finish(cb.to_proc)
+          @query.cancel!()
+        }.to yield_with_args(@query)
+      end
+      it "should be called after answer! is called" do
+        result = double("Result")
+        expect { |cb|
+          @query.on_finish(cb.to_proc)
+          @query.answer!(result)
+        }.to yield_with_args(@query)
+      end
+      it "should be called after error! is called" do
+        expect { |cb|
+          @query.on_finish(cb.to_proc)
+          @query.error!(999)
+        }.to yield_with_args(@query)
+      end
+    end
+  end
+end
+

data/spec/resolver_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe Unbound::Resolver do
+  before :each do
+    @context = Unbound::Context.new
+    @resolver = Unbound::Resolver.new(@context)
+  end
+
+  after :each do
+    @resolver.close unless @resolver.closed?
+  end
+  
+  describe "#cancel_all" do
+    it "should cancel all queries"  do
+      query1 = Unbound::Query.new("localhost", 1, 1)
+      expect { |cb|
+        query1.on_cancel(cb.to_proc)
+        @resolver.send_query(query1)
+        @resolver.cancel_all
+      }.to yield_control
+    end
+  end
+
+  describe "#outstanding_queries" do
+    it "should return the number of outstanding queries"  do
+      expect(@resolver.outstanding_queries).to eq(0)
+      10.times do
+        query = Unbound::Query.new("localhost", 1, 1)
+        @resolver.send_query(query)
+      end
+      expect(@resolver.outstanding_queries).to eq(10)
+      @resolver.cancel_all
+      expect(@resolver.outstanding_queries).to eq(0)
+    end
+  end
+
+  describe "#outstanding_queries?" do
+    it "should be false if there are no outstanding queries"  do
+      expect(@resolver.outstanding_queries?).to be_false
+    end
+
+    it "should be true if there are any outstanding queries"  do
+      query = Unbound::Query.new("localhost", 1, 1)
+      @resolver.send_query(query)
+      expect(@resolver.outstanding_queries?).to be_true
+    end
+  end
+
+  describe "#closed?" do
+    it "should not be closed by default"  do
+      expect(@resolver.closed?).to be_false
+    end
+    it "should be closed after calling #close" do
+      @resolver.close
+      expect(@resolver.closed?).to be_true
+    end
+  end
+
+  describe "#close" do
+    it "should call #cancel_all" do
+      @resolver.should_receive(:cancel_all).and_call_original
+      @resolver.close
+    end
+
+    it "should close the context" do
+      @context.should_receive(:close).and_call_original
+      @resolver.close
+    end
+  end
+
+  describe "#io" do
+    it "should return an IO object" do
+      expect(@resolver.io).to be_a(::IO)
+    end
+  end
+
+  describe "#process" do
+    it "should call our callback" do
+      query1 = Unbound::Query.new("localhost", 1, 1)
+      expect { |cb|
+        query1.on_answer(cb.to_proc)
+        @resolver.send_query(query1)
+        io = @resolver.io
+        expect(::IO.select([io], nil, nil, 5)).to_not be_nil
+        @resolver.process
+      }.to yield_control
+    end
+  end
+
+  describe "#send_query" do
+    it "should raise an exception if the same query object is submitted twice" do
+      query1 = Unbound::Query.new("localhost", 1, 1)
+      @resolver.send_query(query1)
+      expect {@resolver.send_query(query1)}.to raise_error
+    end
+  end
+
+  describe "#on_start" do
+    specify "callbacks should be called when send_query is called" do
+      query = Unbound::Query.new("localhost", 1, 1)
+      expect { |cb|
+        @resolver.on_start(&cb)
+        @resolver.send_query(query)
+      }.to yield_with_args(query)
+    end
+  end
+
+  describe "#on_answer" do
+    specify "callbacks should be called if the query has been answered" do
+      query = Unbound::Query.new("localhost", 1, 1)
+      result = double("Result")
+      expect { |cb|
+        @resolver.on_answer(&cb)
+        @resolver.send_query(query)
+        query.answer!(result)
+      }.to yield_with_args(query, result)
+    end
+  end
+
+  describe "#on_error" do
+    specify "callbacks should be called if the query has an error" do
+      query = Unbound::Query.new("localhost", 1, 1)
+      result = double("Result")
+      expect { |cb|
+        @resolver.on_error(&cb)
+        @resolver.send_query(query)
+        query.error!(1234)
+      }.to yield_with_args(query, 1234)
+    end
+  end
+
+  describe "#on_cancel" do
+    specify "callbacks should be called if the query has been canceled" do
+      query = Unbound::Query.new("localhost", 1, 1)
+      result = double("Result")
+      expect { |cb|
+        @resolver.on_cancel(&cb)
+        @resolver.send_query(query)
+        query.cancel!()
+      }.to yield_with_args(query)
+    end
+  end
+
+  describe "#on_finish" do
+    specify "callbacks should be called if the query is finished for any reason" do
+      query = Unbound::Query.new("localhost", 1, 1)
+      result = double("Result")
+      expect { |cb|
+        @resolver.on_finish(&cb)
+        @resolver.send_query(query)
+        query.cancel!()
+      }.to yield_with_args(query)
+    end
+  end
+end
+

data/spec/result_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Unbound::Result do
+  extend UnboundHelper
+  UDP_RESPONSE = hex2bin("44438180000100060000000003777777057961686f6f03636f6d0000010001c00c0005000100000121000f0666642d667033037767310162c010c02b000500010000012100090664732d667033c032c046000500010000003100150e64732d616e792d6670332d6c666203776131c036c05b000500010000012100120f64732d616e792d6670332d7265616cc06ac07c00010001000000310004628bb718c07c00010001000000310004628bb495")
+
+  describe "#to_resolv" do
+    it "should return nil if there is no data" do
+      result = Unbound::Result.new
+      expect(result.to_resolv).to be_nil
+    end
+    it "should return a resolv object if there is data" do
+      result = Unbound::Result.new
+      packet_ptr = FFI::MemoryPointer.from_string(UDP_RESPONSE)
+      result[:answer_packet] = packet_ptr
+      result[:answer_len] = packet_ptr.size
+      expect(result.to_resolv).to be_a(Resolv::DNS::Message)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -7,9 +7,24 @@ module UnboundHelper
   SPEC_ROOT = Pathname.new(__FILE__).dirname.expand_path
   PROJECT_ROOT =  (SPEC_ROOT + '../').expand_path
   CONF_ROOT = SPEC_ROOT + 'conf'
-  def self.config_file(name)
+
+  def config_file(name)
     (CONF_ROOT + name).to_s
   end
+  module_function :config_file
+
+  def hex2bin(hexstring)
+    ret = "\x00" * (hexstring.length / 2)
+    ret.force_encoding("BINARY")
+    offset = 0
+    while offset < hexstring.length
+      hex_byte = hexstring[offset..(offset+1)]
+      ret.setbyte(offset/2, hex_byte.to_i(16))
+      offset += 2
+    end
+    ret
+  end
+  module_function :hex2bin
 end
 
 require 'simplecov'
@@ -28,4 +43,4 @@ RSpec.configure do |config|
   end
 end
 
-
+require 'unbound'

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: unbound
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Mike Ryan
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-28 00:00:00.000000000 Z
+date: 2014-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: jeweler
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :development
-- !ruby/object:Gem::Dependency
-  name: rake
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
   type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Unbound DNS resolver bindings for Ruby
 email: falter@gmail.com
 executables: []
@@ -65,21 +65,29 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- examples/resolve_async.rb
 - lib/unbound.rb
 - lib/unbound/bindings.rb
+- lib/unbound/callback_array.rb
+- lib/unbound/callbacks_mixin.rb
 - lib/unbound/context.rb
 - lib/unbound/exceptions.rb
+- lib/unbound/query.rb
 - lib/unbound/resolver.rb
 - lib/unbound/result.rb
+- spec/callback_array_spec.rb
 - spec/conf/local_zone.conf
 - spec/conf/test_config.conf
 - spec/context_spec.rb
+- spec/query_spec.rb
+- spec/resolver_spec.rb
+- spec/result_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/justfalter/unbound-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -94,9 +102,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.1.9
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
 specification_version: 4
 summary: Unbound DNS resolver bindings for Ruby
 test_files: []