bloom_filter 0.6.4 → 0.6.5

data/VERSION

@@ -1 +1 @@
-0.6.4
+0.6.5

data/bloom_filter.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bloom_filter}
-  s.version = "0.6.4"
+  s.version = "0.6.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Arya Asemanfar"]
-  s.date = %q{2010-02-01}
+  s.date = %q{2010-02-04}
   s.default_executable = %q{bloom_filter_server}
   s.description = %q{}
   s.email = %q{misterfunnyarsal@gmail.com}
@@ -34,6 +34,7 @@ Gem::Specification.new do |s|
      "lib/bloom_filter/server.rb",
      "test/bloom_filter_bit_vector_test.rb",
      "test/bloom_filter_client_test.rb",
+     "test/bloom_filter_integration_test.rb",
      "test/bloom_filter_server_test.rb",
      "test/bloom_filter_test.rb",
      "test/test_helper.rb"
@@ -46,6 +47,7 @@ Gem::Specification.new do |s|
   s.test_files = [
     "test/bloom_filter_bit_vector_test.rb",
      "test/bloom_filter_client_test.rb",
+     "test/bloom_filter_integration_test.rb",
      "test/bloom_filter_server_test.rb",
      "test/bloom_filter_test.rb",
      "test/test_helper.rb"

data/lib/bloom_filter/client.rb

@@ -4,6 +4,7 @@ require 'bloom_filter/bit_vector'
 
 class BloomFilter
   class Timeout < StandardError; end
+  class ConnectionError < StandardError; end
     
   class Client    
     PACK_N = "N"
@@ -12,61 +13,59 @@ class BloomFilter
       @host, @port = host, port
       @timeout = options[:timeout]
       @raise_on_timeout = options[:raise_on_timeout] || false
+      @raise_on_error = options[:raise_on_error] || false
       self.connect
     end
   
     def add(el)
-      self.connect
-      el = el.to_s
-      @socket.write("#{[el.size + 1].pack(PACK_N)}#{Protocol::ADD}#{el}")
-      timeout_or_default(false) do
-        @socket.read(@socket.read(4).unpack(PACK_N).first) == Protocol::TRUE
+      with_socket_or_default(false) do
+        el = el.to_s
+        @socket.write("#{[el.size + 1].pack(PACK_N)}#{Protocol::ADD}#{el}")
+        read_response == Protocol::TRUE
       end
     end
     alias_method :<<, :add
   
     def include?(el)
-      self.connect
-      el = el.to_s
-      @socket.write("#{[el.size + 1].pack(PACK_N)}#{Protocol::INCLUDE}#{el}")
-      timeout_or_default(true) do
-        @socket.read(@socket.read(4).unpack(PACK_N).first) == Protocol::TRUE
+      with_socket_or_default(true) do
+        el = el.to_s
+        @socket.write("#{[el.size + 1].pack(PACK_N)}#{Protocol::INCLUDE}#{el}")
+        read_response == Protocol::TRUE
       end
     end
   
     def &(els)
-      self.connect
       if els.size == 1
         el = els.first
         self.include?(el) ? [el] : []
       else
-        elements = els.collect { |el| el.to_s }.join(Protocol::DEFAULT_SEPARATOR)
-        @socket.write("#{[elements.size + 1].pack(PACK_N)}#{Protocol::INCLUDE_MANY}#{elements}")
-        
-        timeout_or_default(els) do
-          response = BitVector.new(els.size, @socket.read(@socket.read(4).unpack(PACK_N).first))
-          result = []
-          els.size.times do |i|
-            result << els[i] if response[i] == 1
-          end
-          result
-        end
+        with_socket_or_default(els) do
+          elements = els.collect { |el| el.to_s }.join(Protocol::DEFAULT_SEPARATOR)
+          @socket.write("#{[elements.size + 1].pack(PACK_N)}#{Protocol::INCLUDE_MANY}#{elements}")
+
+          read_response do |response|
+            response = BitVector.new(els.size, response)
+            result = []
+            els.size.times do |i|
+              result << els[i] if response[i] == 1
+            end
+            result
+          end # read_response
+        end # with_socket_or_default
       end
     end
     
     def dump(path, timeout = nil)
-      self.connect
-      @socket.write("#{[path.size + 1].pack(PACK_N)}#{Protocol::DUMP}#{path}")
-      timeout_or_default(false, timeout) do
-        @socket.read(@socket.read(4).unpack(PACK_N).first) == Protocol::TRUE
+      with_socket_or_default(false) do
+        @socket.write("#{[path.size + 1].pack(PACK_N)}#{Protocol::DUMP}#{path}")
+        read_response(timeout) == Protocol::TRUE
       end
     end
     
     def load(path, timeout = nil)
-      self.connect
-      @socket.write("#{[path.size + 1].pack(PACK_N)}#{Protocol::LOAD}#{path}")
-      timeout_or_default(false, timeout) do
-        @socket.read(@socket.read(4).unpack(PACK_N).first) == Protocol::TRUE
+      with_socket_or_default(false) do
+        @socket.write("#{[path.size + 1].pack(PACK_N)}#{Protocol::LOAD}#{path}")
+        read_response(timeout) == Protocol::TRUE
       end
     end
     
@@ -74,7 +73,7 @@ class BloomFilter
       unless self.connected?
         @socket = begin
           TCPSocket.new(@host, @port)
-        rescue Exception => e
+        rescue Errno::ECONNREFUSED
           nil
         end
       end
@@ -94,15 +93,32 @@ class BloomFilter
     end
     
     private
-    def timeout_or_default(default, timeout = nil, &block)
+    def read_response(timeout = nil, &block)
       ready = IO.select([@socket], nil, nil, timeout || @timeout)
       if ready
-        block.call
-      elsif @raise_on_timeout
-        self.disconnect
+        size = @socket.read(4)
+        raise BloomFilter::ConnectionError if size.nil? || size.length < 4
+        size = size.unpack(PACK_N).first
+        response = @socket.read(size)
+        raise BloomFilter::ConnectionError if response.nil? || response.length < size
+        block ? block.call(response) : response
+      else
         raise BloomFilter::Timeout
+      end
+    end
+    
+    def with_socket_or_default(default, &block)
+      self.connect
+      if self.connected?
+        begin
+          yield
+        rescue BloomFilter::Timeout
+          self.disconnect
+          @raise_on_timeout ? raise : default
+        rescue BloomFilter::ConnectionError, Errno::EPIPE
+          @raise_on_error ? raise : default
+        end
       else
-        self.disconnect
         default
       end
     end

data/test/bloom_filter_client_test.rb

@@ -110,17 +110,27 @@ class BloomFilterClientTest < Test::Unit::TestCase
   should "reconnect if not connected before making a call" do
     socket = mock()
     
-    socket.expects(:closed?).returns(true).once
+    socket.stubs(:closed?).returns(true, true, false)
     TCPSocket.expects(:new).with("localhost", 4111).returns(socket).twice
     IO.stubs(:select).returns(socket)
+    socket.stubs(:write, :read)
+        
     client = BloomFilter::Client.new("localhost", 4111, :timeout => 1, :raise_on_timeout => true)
-
-    socket.expects(:write).with("#{[6].pack("N")}#{BloomFilter::Protocol::ADD}hello")
-    socket.expects(:read).with(4).returns([1].pack("N"))
-    socket.expects(:read).with(1).returns(BloomFilter::Protocol::TRUE)
-
-    
-    IO.expects(:select).with([socket], nil, nil, 1).returns(socket)
     client.add("hello")      
   end
+  
+  should "raise exception if set to on conn failure" do
+    socket = mock()
+    
+    socket.stubs(:closed?).returns(false)
+    TCPSocket.stubs(:new).with("localhost", 4111).returns(socket)
+    IO.stubs(:select).returns(socket)
+    socket.stubs(:write)
+    socket.expects(:read).returns(nil)
+    
+    client = BloomFilter::Client.new("localhost", 4111, :timeout => 1, :raise_on_error => true)
+    assert_raises(BloomFilter::ConnectionError) do
+      client.add("hello")
+    end    
+  end
 end

data/test/bloom_filter_integration_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+require 'bloom_filter/server'
+require 'bloom_filter/client'
+
+class BloomFilterIntegrationTest < Test::Unit::TestCase
+  context "with a server listening on port 4111" do
+    setup do
+      Thread.new do
+        EM.run do
+          EM.start_server("localhost", 4111, BloomFilter.new_server(1000, 0.05))
+        end
+      end
+      @client = BloomFilter::Client.new("localhost", 4111)
+    end
+    
+    should "add an element and return true" do
+      assert @client.add("foo")
+    end
+    
+    should "add an element and return true after checking for inclusion" do
+      @client.add("foo")
+      assert @client.include?("foo")
+    end
+    
+    should "return false if we haven't added anything" do
+      assert !@client.include?("foo")
+    end
+    
+    should "intersect with an array and return only the ones that have been added" do
+      @client.add 1
+      @client.add 2
+      @client.add 3
+      assert_equal [1,2,3], @client & [1,2,3,4,5]
+    end
+        
+    teardown do
+      EM.schedule do
+        EM.stop
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bloom_filter
 version: !ruby/object:Gem::Version 
-  version: 0.6.4
+  version: 0.6.5
 platform: ruby
 authors: 
 - Arya Asemanfar
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-01 00:00:00 -08:00
+date: 2010-02-04 00:00:00 -08:00
 default_executable: bloom_filter_server
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -67,6 +67,7 @@ files:
 - lib/bloom_filter/server.rb
 - test/bloom_filter_bit_vector_test.rb
 - test/bloom_filter_client_test.rb
+- test/bloom_filter_integration_test.rb
 - test/bloom_filter_server_test.rb
 - test/bloom_filter_test.rb
 - test/test_helper.rb
@@ -101,6 +102,7 @@ summary: A simple BloomFilter implementation, usable in-process or as an EventMa
 test_files: 
 - test/bloom_filter_bit_vector_test.rb
 - test/bloom_filter_client_test.rb
+- test/bloom_filter_integration_test.rb
 - test/bloom_filter_server_test.rb
 - test/bloom_filter_test.rb
 - test/test_helper.rb