unbound 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 268e920fce264b5a8fb5a60fc0f3b98d2648adde
-  data.tar.gz: fabfee310e6715df1e05e7ba455ae9fc64ae8f47
+  metadata.gz: 3cc064fa99fcaf867d9474ede41d93ad258742e4
+  data.tar.gz: dd0dd181466af047705bb39f94db521141eaa752
 SHA512:
-  metadata.gz: 634924d61b650aeba4ee82632b34d95040da7aec61ac8a0a632fc3c4b48aeb082c0aca829b0baac77d5647880b933bf711f24f87b88eecc740489f3361dec432
-  data.tar.gz: 8029d61671926ea5874d9c2c4060cf788e11eae74e8c4d60228b9613263ee4ede4b39b20f04767a2565cea8141eb5291cf1289c55aaebeca75501dd02709560a
+  metadata.gz: 51c16931c919a0635208f7ec37f4820f5a7b53e9ec7de05d34f8f0c52d0496dd3e2be8684bf7ac3fedf0cb91565d8c9a14076885b789efd91eda13efbb708f81
+  data.tar.gz: b24c0751df53c3e44418db0c85de1b8678c9bd0f0a6180511316ba88adcf39bb17c499a458927661a38b6d5545b8fd9cc0bee76249a37ce59fdbdadbec9e67f1

data/VERSION

@@ -1 +1 @@
-1.0.1
+2.0.0

data/lib/unbound/context.rb

@@ -71,10 +71,17 @@ module Unbound
       raise_if_error!(Unbound::Bindings.ub_cancel(@ub_ctx, async_id))
     end
 
+    # Returns a brand new IO for the file descriptor that can be selected to 
+    # determine if processing needs to be done. 
+    # Warning: DO NOT CLOSE THIS IO OBJECT! Use Context#close, instead. 
+    # @return [FFI::IO] a brand new IO for the context's file descriptor
     def io
-      return ::FFI::IO.for_fd(self.fd)
+      ret = ::FFI::IO.for_fd(self.fd)
+      ret.autoclose = false
+      return ret
     end
 
+    # Returns the number for the file descriptor.
     def fd
       check_closed!
       Unbound::Bindings.ub_fd(@ub_ctx)

data/lib/unbound/query.rb

@@ -65,6 +65,7 @@ module Unbound
     private
     def finish!()
       @state = STATE_FINISHED
+      @async_id = nil
       @callbacks_finish.call(self)
       clear_callbacks!
     end

data/lib/unbound/resolver.rb

@@ -20,16 +20,18 @@ module Unbound
 
       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(query)
       end
     end
 
+    # @param [Unbound::Query] query The query that will be canceled
+    def cancel_query(query)
+      return if query.async_id.nil?
+      @ctx.cancel_async_query(query.async_id)
+      query.cancel!
+    end
+
     # @return [Integer] the number of queries for which we are awaiting reply
     def outstanding_queries
       @queries.count
@@ -63,7 +65,7 @@ module Unbound
     # Cancel all outstanding queries.
     def cancel_all
       @queries.each do |query|
-        query.cancel!
+        cancel_query(query)
       end
       @queries.clear
     end
@@ -98,7 +100,8 @@ module Unbound
       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_cancel(*@callbacks_cancel) unless @callbacks_cancel.empty?
+
       query.on_finish(*@callbacks_finish)
       ptr = @queries.store(query)
       async_id = @ctx.resolve_async(

data/spec/context_spec.rb

@@ -139,6 +139,33 @@ describe Unbound::Context do
     end
   end
 
+  describe "#io" do
+    it "should return an IO object" do
+      expect(@ctx.io).to be_a(::IO)
+    end
+
+    it "should return a new IO object for each call" do
+      expect(@ctx.io).not_to be(@ctx.io)
+    end
+
+    it "should not be set to autoclose" do
+      expect(@ctx.io.autoclose?).to be_false
+    end
+
+    it "should not autoclose when garbage collection occurs" do
+      do_gc = lambda { ObjectSpace.garbage_collect }
+
+      if Object.const_defined?(:JRuby)
+        # Try to get some GC under JRuby
+        do_gc = lambda { java.lang.System.gc() }
+      end
+      ::IO::select([@ctx.io], nil, nil, 0)
+      do_gc.call()
+      expect {
+        ::IO::select([@ctx.io], nil, nil, 0)
+      }.not_to raise_error
+    end
+  end
 
   describe "asynchronous query processing via select/process" do
     before :each do

data/spec/query_spec.rb

@@ -33,6 +33,22 @@ describe Unbound::Query do
       end
     end
 
+    describe "#async_id" do
+      it "should be nil if the query hasn't been started" do
+        expect(@query.async_id).to be_nil
+      end
+      it "should be the proper value if it has been started" do
+        expect(@query.async_id).to be_nil
+        @query.start!(1234)
+        expect(@query.async_id).to eq(1234)
+      end
+      it "should be nil if the query has been finished" do
+        @query.start!(1234)
+        @query.cancel!
+        expect(@query.async_id).to be_nil
+      end
+    end
+
     describe "#start!" do
       it "should set the async_id" do
         expect(@query.async_id).to be_nil
@@ -66,6 +82,11 @@ describe Unbound::Query do
     end
 
     describe "#error!" do
+      before :each do
+        @async_id = 9999
+        @query.start!(@async_id)
+      end
+
       it "should require an error code as an argument" do
         expect {
           @query.error!
@@ -79,9 +100,19 @@ describe Unbound::Query do
         @query.error!(1234)
         expect(@query).to be_finished
       end
+
+      it "should have set async_id to nil" do
+        @query.error!(1234)
+        expect(@query.async_id).to be_nil
+      end
     end
 
     describe "#answer!" do
+      before :each do
+        @async_id = 9999
+        @query.start!(@async_id)
+      end
+
       it "should require a result as an argument" do
         expect {
           @query.answer!
@@ -97,9 +128,20 @@ describe Unbound::Query do
         @query.answer!(result)
         expect(@query).to be_finished
       end
+
+      it "should have set async_id to nil" do
+        result = double("Result")
+        @query.answer!(result)
+        expect(@query.async_id).to be_nil
+      end
     end
 
     describe "#cancel!" do
+      before :each do
+        @async_id = 9999
+        @query.start!(@async_id)
+      end
+
       it "should require that no arguments be specified" do
         expect {
           @query.cancel!(1234)
@@ -113,6 +155,11 @@ describe Unbound::Query do
         @query.cancel!
         expect(@query).to be_finished
       end
+
+      it "should have set async_id to nil" do
+        @query.cancel!
+        expect(@query.async_id).to be_nil
+      end
     end
 
 

data/spec/query_store_spec.rb

@@ -29,6 +29,20 @@ describe Unbound::QueryStore do
       end
       expect(actual_queries).to match_array(expected_queries)
     end
+    it "should not yield deleted queries" do
+      q1 = new_query(1)
+      q2 = new_query(2)
+      q3 = new_query(3)
+      query_store.store(q1)
+      query_store.store(q2)
+      query_store.store(q3)
+      query_store.delete_query(q2)
+      remaining_queries = []
+      query_store.each do |query|
+        remaining_queries << query
+      end
+      expect(remaining_queries).to match_array([q1, q3])
+    end
   end
   describe "#clear" do
     it "should cause the count to drop to 0" do

data/spec/resolver_spec.rb

@@ -9,29 +9,71 @@ describe Unbound::Resolver do
   after :each do
     @resolver.close unless @resolver.closed?
   end
+
+  let(:query) { Unbound::Query.new("localhost", 1, 1) }
   
   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)
+        query.on_cancel(cb.to_proc)
+        @resolver.send_query(query)
         @resolver.cancel_all
       }.to yield_control
     end
   end
 
   describe "#outstanding_queries" do
-    it "should return the number of outstanding queries"  do
+    it "should be zero if there are no 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
+    end
+
+    it "should go up by one for each query added" do
+      q1 = Unbound::Query.new("localhost", 1, 1)
+      q2 = Unbound::Query.new("localhost", 1, 1)
+      q3 = Unbound::Query.new("localhost", 1, 1)
+      q4 = Unbound::Query.new("localhost", 1, 1)
+      expect(@resolver.outstanding_queries).to eq(0)
+      @resolver.send_query(q1)
+      expect(@resolver.outstanding_queries).to eq(1)
+      @resolver.send_query(q2)
+      expect(@resolver.outstanding_queries).to eq(2)
+      @resolver.send_query(q3)
+      expect(@resolver.outstanding_queries).to eq(3)
+      @resolver.send_query(q4)
+      expect(@resolver.outstanding_queries).to eq(4)
+    end
+
+    it "should drop by one for each query canceled" do
+      q1 = Unbound::Query.new("localhost", 1, 1)
+      q2 = Unbound::Query.new("localhost", 1, 1)
+      q3 = Unbound::Query.new("localhost", 1, 1)
+      q4 = Unbound::Query.new("localhost", 1, 1)
+      @resolver.send_query(q1)
+      @resolver.send_query(q2)
+      @resolver.send_query(q3)
+      @resolver.send_query(q4)
+      expect(@resolver.outstanding_queries).to eq(4)
+      @resolver.cancel_query(q1)
+      expect(@resolver.outstanding_queries).to eq(3)
+      @resolver.cancel_query(q2)
+      expect(@resolver.outstanding_queries).to eq(2)
+      @resolver.cancel_query(q3)
+      expect(@resolver.outstanding_queries).to eq(1)
+      @resolver.cancel_query(q4)
       expect(@resolver.outstanding_queries).to eq(0)
     end
+
+    it "should not reduce the count by more than one if the same query is canceled twice" do
+      q1 = Unbound::Query.new("localhost", 1, 1)
+      q2 = Unbound::Query.new("localhost", 1, 1)
+      @resolver.send_query(q1)
+      @resolver.send_query(q2)
+      expect(@resolver.outstanding_queries).to eq(2)
+      @resolver.cancel_query(q1)
+      expect(@resolver.outstanding_queries).to eq(1)
+      @resolver.cancel_query(q1)
+      expect(@resolver.outstanding_queries).to eq(1)
+    end
   end
 
   describe "#outstanding_queries?" do
@@ -40,7 +82,6 @@ describe Unbound::Resolver do
     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
@@ -69,17 +110,20 @@ describe Unbound::Resolver do
   end
 
   describe "#io" do
-    it "should return an IO object" do
-      expect(@resolver.io).to be_a(::IO)
+    it "should pass through to ctx.io" do
+      ctx = double("Context")
+      resolver = Unbound::Resolver.new(ctx)
+      expect(ctx).to receive(:io)
+      resolver.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)
+        query.on_answer(cb.to_proc)
+        @resolver.send_query(query)
         io = @resolver.io
         expect(::IO.select([io], nil, nil, 5)).to_not be_nil
         @resolver.process
@@ -87,17 +131,45 @@ describe Unbound::Resolver do
     end
   end
 
+  describe "#cancel_query" do
+    it "should all context#cancel_async_query" do
+      expect(@context).to receive(:cancel_async_query).and_call_original
+      @resolver.send_query(query)
+      @resolver.cancel_query(query)
+    end
+
+    it "should set query.async_id to nil" do
+      @resolver.send_query(query)
+      expect(query.async_id).not_to be_nil
+      @resolver.cancel_query(query)
+      expect(query.async_id).to be_nil
+    end
+
+    it "should call 'query#cancel!' only once" do
+      @resolver.send_query(query)
+      expect(query).to receive(:cancel!).exactly(1).times.and_call_original
+      @resolver.cancel_query(query)
+      @resolver.close
+    end
+
+    it "shouldn't try to cancel if the query hasn't been sent" do
+      query = double("Query")
+      allow(query).to receive(:async_id).and_return(nil)
+      ctx = double("Context")
+      resolver = Unbound::Resolver.new(ctx)
+      resolver.cancel_query(query)
+    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
+      @resolver.send_query(query)
+      expect {@resolver.send_query(query)}.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)
@@ -107,7 +179,6 @@ describe Unbound::Resolver do
 
   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)
@@ -119,7 +190,6 @@ describe Unbound::Resolver do
 
   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)
@@ -131,24 +201,22 @@ describe Unbound::Resolver do
 
   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!()
+        @resolver.cancel_query(query)
       }.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!()
+        @resolver.cancel_query(query)
       }.to yield_with_args(query)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unbound
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Mike Ryan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-06 00:00:00.000000000 Z
+date: 2014-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi