beaneater 0.3.1 → 1.1.1

data/lib/beaneater/tube/collection.rb

@@ -1,16 +1,36 @@
-module Beaneater
+class Beaneater
   # Represents collection of tube related commands.
-  class Tubes < PoolCommand
+
+  class Tubes
+    include Enumerable
+
+    # @!attribute client
+    #   @return [Beaneater] returns the client instance
+    attr_reader :client
 
     # Creates new tubes instance.
     #
-    # @param [Beaneater::Pool] pool The beaneater pool for this tube.
+    # @param [Beaneater] client The beaneater client instance.
     # @example
-    #  Beaneater::Tubes.new(@pool)
+    #  Beaneater::Tubes.new(@client)
+    #
+    def initialize(client)
+      @client = client
+    end
+
+    def last_used
+      client.connection.tube_used
+    end
+
+    def last_used=(tube_name)
+      client.connection.tube_used = tube_name
+    end
+
+    # Delegates transmit to the connection object.
     #
-    def initialize(pool)
-      @last_used = 'default'
-      super
+    # @see Beaneater::Connection#transmit
+    def transmit(command, **options)
+      client.connection.transmit(command, **options)
     end
 
     # Finds the specified beanstalk tube.
@@ -24,7 +44,7 @@ module Beaneater
     #
     # @api public
     def find(tube_name)
-      Tube.new(self.pool, tube_name)
+      Tube.new(client, tube_name)
     end
     alias_method :[], :find
 
@@ -35,13 +55,14 @@ module Beaneater
     # @yield [job] Reserved beaneater job.
     # @return [Beaneater::Job] Reserved beaneater job.
     # @example
-    #   @conn.tubes.reserve { |job| process(job) }
+    #   @client.tubes.reserve { |job| process(job) }
     #     # => <Beaneater::Job id=5 body="foo">
     #
     # @api public
     def reserve(timeout=nil, &block)
-      res = transmit_to_rand(timeout ? "reserve-with-timeout #{timeout}" : 'reserve')
-      job = Job.new(res)
+      res = transmit(
+        timeout ? "reserve-with-timeout #{timeout}" : 'reserve')
+      job = Job.new(client, res)
       block.call(job) if block_given?
       job
     end
@@ -50,36 +71,54 @@ module Beaneater
     #
     # @return [Array<Beaneater::Tube>] List of all beanstalk tubes.
     # @example
-    #   @pool.tubes.all
+    #   @client.tubes.all
     #     # => [<Beaneater::Tube name="tube2">, <Beaneater::Tube name="tube3">]
     #
     # @api public
     def all
-      transmit_to_all('list-tubes', :merge => true)[:body].map { |tube_name| Tube.new(self.pool, tube_name) }
+      transmit('list-tubes')[:body].map do |tube_name|
+        Tube.new(client, tube_name)
+      end
+    end
+
+    # Calls the given block once for each known beanstalk tube, passing that element as a parameter.
+    #
+    # @return An Enumerator is returned if no block is given.
+    # @example
+    #   @pool.tubes.each {|t| puts t.name}
+    #
+    # @api public
+    def each(&block)
+      all.each(&block)
     end
 
     # List of watched beanstalk tubes.
     #
     # @return [Array<Beaneater::Tube>] List of watched beanstalk tubes.
     # @example
-    #   @pool.tubes.watched
+    #   @client.tubes.watched
     #     # => [<Beaneater::Tube name="tube2">, <Beaneater::Tube name="tube3">]
     #
     # @api public
     def watched
-      transmit_to_all('list-tubes-watched', :merge => true)[:body].map { |tube_name| Tube.new(self.pool, tube_name) }
+      last_watched = transmit('list-tubes-watched')[:body]
+      client.connection.tubes_watched = last_watched.dup
+      last_watched.map do |tube_name|
+        Tube.new(client, tube_name)
+      end
     end
 
     # Currently used beanstalk tube.
     #
     # @return [Beaneater::Tube] Currently used beanstalk tube.
     # @example
-    #   @pool.tubes.used
+    #   @client.tubes.used
     #     # => <Beaneater::Tube name="tube2">
     #
     # @api public
     def used
-      Tube.new(self.pool, transmit_to_rand('list-tube-used')[:id])
+      last_used = transmit('list-tube-used')[:id]
+      Tube.new(client, last_used)
     end
 
     # Add specified beanstalkd tubes as watched.
@@ -87,12 +126,13 @@ module Beaneater
     # @param [*String] names Name of tubes to watch
     # @raise [Beaneater::InvalidTubeName] Tube to watch was invalid.
     # @example
-    #   @pool.tubes.watch('foo', 'bar')
+    #   @client.tubes.watch('foo', 'bar')
     #
     # @api public
     def watch(*names)
       names.each do |t|
-        transmit_to_all "watch #{t}"
+        transmit "watch #{t}"
+        client.connection.add_to_watched(t)
       end
     rescue BadFormatError => ex
       raise InvalidTubeName, "Tube in '#{ex.cmd}' is invalid!"
@@ -103,7 +143,7 @@ module Beaneater
     # @param [*String] names Name of tubes to watch
     # @raise [Beaneater::InvalidTubeName] Tube to watch was invalid.
     # @example
-    #   @pool.tubes.watch!('foo', 'bar')
+    #   @client.tubes.watch!('foo', 'bar')
     #
     # @api public
     def watch!(*names)
@@ -116,12 +156,13 @@ module Beaneater
     #
     # @param [*String] names Name of tubes to ignore
     # @example
-    #   @pool.tubes.ignore('foo', 'bar')
+    #   @client.tubes.ignore('foo', 'bar')
     #
     # @api public
     def ignore(*names)
       names.each do |w|
-        transmit_to_all "ignore #{w}"
+        transmit "ignore #{w}"
+        client.connection.remove_from_watched(w)
       end
     end
 
@@ -132,11 +173,11 @@ module Beaneater
     #  @conn.tubes.use("some-tube")
     #
     def use(tube)
-      return tube if @last_used == tube
-      res = transmit_to_all("use #{tube}")
-      @last_used = tube
+      return tube if last_used == tube
+      transmit("use #{tube}")
+      self.last_used = tube
     rescue BadFormatError
       raise InvalidTubeName, "Tube cannot be named '#{tube}'"
     end
   end # Tubes
-end # Beaneater
+end # Beaneater

data/lib/beaneater/tube/record.rb

@@ -1,22 +1,31 @@
-module Beaneater
+class Beaneater
   # Beanstalk tube which contains jobs which can be inserted, reserved, et al.
-  class Tube < PoolCommand
+  class Tube
 
     # @!attribute name
     #   @return [String] name of the tube
-    attr_reader :name
+    # @!attribute client
+    #   @return [Beaneater] returns the client instance
+    attr_reader :name, :client
 
     # Fetches the specified tube.
     #
-    # @param [Beaneater::Pool] pool The beaneater pool for this tube.
+    # @param [Beaneater] client The beaneater client instance.
     # @param [String] name The name for this tube.
     # @example
-    #  Beaneater::Tube.new(@pool, 'tube-name')
+    #  Beaneater::Tube.new(@client, 'tube-name')
     #
-    def initialize(pool, name)
+    def initialize(client, name)
+      @client = client
       @name = name.to_s
       @mutex = Mutex.new
-      super(pool)
+    end
+
+    # Delegates transmit to the connection object.
+    #
+    # @see Beaneater::Connection#transmit
+    def transmit(command, options={})
+      client.connection.transmit(command, **options)
     end
 
     # Inserts job with specified body onto tube.
@@ -33,10 +42,16 @@ module Beaneater
     # @api public
     def put(body, options={})
       safe_use do
-        options = { :pri => config.default_put_pri, :delay => config.default_put_delay,
-                    :ttr => config.default_put_ttr }.merge(options)
-        cmd_options = "#{options[:pri]} #{options[:delay]} #{options[:ttr]} #{body.bytesize}"
-        transmit_to_rand("put #{cmd_options}\r\n#{body}")
+        serialized_body = config.job_serializer.call(body)
+
+        options = {
+          :pri   => config.default_put_pri,
+          :delay => config.default_put_delay,
+          :ttr   => config.default_put_ttr
+        }.merge(options)
+
+        cmd_options = "#{options[:pri]} #{options[:delay]} #{options[:ttr]} #{serialized_body.bytesize}"
+        transmit("put #{cmd_options}\r\n#{serialized_body}")
       end
     end
 
@@ -50,10 +65,10 @@ module Beaneater
     # @api public
     def peek(state)
       safe_use do
-        res = transmit_until_res "peek-#{state}", :status => "FOUND"
-        Job.new(res)
+        res = transmit("peek-#{state}")
+        Job.new(client, res)
       end
-    rescue Beaneater::NotFoundError => ex
+    rescue Beaneater::NotFoundError
       # Return nil if not found
       nil
     end
@@ -69,8 +84,8 @@ module Beaneater
     #
     # @api public
     def reserve(timeout=nil, &block)
-      pool.tubes.watch!(self.name)
-      pool.tubes.reserve(timeout, &block)
+      client.tubes.watch!(self.name)
+      client.tubes.reserve(timeout, &block)
     end
 
     # Kick specified number of jobs from buried to ready state.
@@ -82,18 +97,18 @@ module Beaneater
     #
     # @api public
     def kick(bounds=1)
-      safe_use { transmit_to_rand("kick #{bounds}") }
+      safe_use { transmit("kick #{bounds}") }
     end
 
     # Returns related stats for this tube.
     #
     # @return [Beaneater::StatStruct] Struct of tube related values
     # @example
-    #  @tube.stats.delayed # => 24
+    #  @tube.stats.current_jobs_delayed # => 24
     #
     # @api public
     def stats
-      res = transmit_to_all("stats-tube #{name}", :merge => true)
+      res = transmit("stats-tube #{name}")
       StatStruct.from_hash(res[:body])
     end
 
@@ -106,7 +121,7 @@ module Beaneater
     #
     # @api public
     def pause(delay)
-      transmit_to_all("pause-tube #{name} #{delay}")
+      transmit("pause-tube #{name} #{delay}")
     end
 
     # Clears all unreserved jobs in all states from the tube
@@ -115,14 +130,18 @@ module Beaneater
     #   @tube.clear
     #
     def clear
-      pool.tubes.watch!(self.name)
+      client.tubes.watch!(self.name)
       %w(delayed buried ready).each do |state|
         while job = self.peek(state.to_sym)
-          job.delete
+          begin
+            job.delete
+          rescue Beaneater::UnexpectedResponse, Beaneater::NotFoundError
+            # swallow any issues
+          end
         end
       end
-      pool.tubes.ignore(name)
-    rescue Beaneater::UnexpectedResponse
+      client.tubes.ignore(name)
+    rescue Beaneater::NotIgnoredError
       # swallow any issues
     end
 
@@ -144,12 +163,12 @@ module Beaneater
     # @param [Proc] block Beanstalk command to transmit.
     # @return [Object] Result of block passed
     # @example
-    #  safe_use { transmit_to_rand("kick 1") }
+    #  safe_use { transmit("kick 1") }
     #    # => "Response to kick command"
     #
     def safe_use(&block)
       @mutex.lock
-      tubes.use(self.name)
+      client.tubes.use(self.name)
       yield
     ensure
       @mutex.unlock
@@ -161,6 +180,5 @@ module Beaneater
     def config
       Beaneater.configuration
     end
-
   end # Tube
 end # Beaneater

data/lib/beaneater/version.rb

@@ -1,4 +1,4 @@
-module Beaneater
+class Beaneater
   # Current version of gem.
-  VERSION = "0.3.1"
+  VERSION = "1.1.1"
 end

data/test/beaneater_test.rb

@@ -2,8 +2,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 describe "beanstalk-client" do
   before do
-    @beanstalk = Beaneater::Pool.new(['127.0.0.1:11300'])
-    # @beanstalk = Beaneater::Pool.new(['127.0.0.1:11300', '127.0.0.1:11301'])
+    @beanstalk = Beaneater.new('127.0.0.1:11300')
     @tubes = ['one', 'two', 'three']
 
     # Put something on each tube so they exist
@@ -23,12 +22,12 @@ describe "beanstalk-client" do
       # A: put one
       a = Thread.new do
         tube_one = @beanstalk.tubes.find('one')
-        sleep 4
+        sleep 0.5
         tube_one.put('one')
       end
 
       b = Thread.new do
-        sleep 1
+        sleep 0.125
         tube_two = @beanstalk.tubes.find('two')
         tube_two.put('two')
       end
@@ -52,13 +51,13 @@ describe "beanstalk-client" do
     before do
       a = Thread.new do
         tube_one = @beanstalk.tubes.find('one')
-        sleep 4
+        sleep 0.5
         tube_one.put('one')
       end
 
       b = Thread.new do
         tube_two = @beanstalk.tubes.find('two')
-        sleep 1
+        sleep 0.125
         tube_two.put('two')
       end
 
@@ -108,9 +107,4 @@ describe "beanstalk-client" do
       assert_nil @beanstalk.jobs.find(@job.id)
     end
   end
-
-  after do
-    cleanup_tubes!(@tubes, @beanstalk)
-  end
-
 end

data/test/connection_test.rb

@@ -18,13 +18,25 @@ describe Beaneater::Connection do
 
     it "should init connection" do
       assert_kind_of TCPSocket, @bc.connection
-      assert_equal '127.0.0.1', @bc.connection.peeraddr[3]
+      if @bc.connection.peeraddr[0] == 'AF_INET'
+        assert_equal '127.0.0.1', @bc.connection.peeraddr[3]
+      else
+        assert_equal 'AF_INET6', @bc.connection.peeraddr[0]
+        assert_equal '::1', @bc.connection.peeraddr[3]
+      end
       assert_equal 11300, @bc.connection.peeraddr[1]
     end
 
     it "should raise on invalid connection" do
       assert_raises(Beaneater::NotConnected) { Beaneater::Connection.new("localhost:8544") }
     end
+
+    it "should support array connection to single connection" do
+      @bc2 = Beaneater::Connection.new([@host])
+      assert_equal 'localhost', @bc.address
+      assert_equal 'localhost', @bc.host
+      assert_equal 11300, @bc.port
+    end
   end # new
 
   describe 'for #transmit' do
@@ -60,6 +72,48 @@ describe Beaneater::Connection do
       res = @bc.transmit "put 0 0 100 256\r\n"+(0..255).to_a.pack("c*")
       assert_equal 'INSERTED', res[:status]
     end
+
+    it "should retry command with success after one connection failure" do
+      TCPSocket.any_instance.expects(:readline).times(2).
+        raises(EOFError.new).then.
+        returns("DELETED 56\nFOO")
+
+      res = @bc.transmit "delete 56\r\n"
+      assert_equal 'DELETED', res[:status]
+    end
+
+    it "should fail after exceeding retries with DrainingError" do
+      TCPSocket.any_instance.expects(:readline).times(3).
+        raises(Beaneater::UnexpectedResponse.from_status("DRAINING", "delete 56"))
+
+      assert_raises(Beaneater::DrainingError) { @bc.transmit "delete 56\r\n" }
+    end
+
+    it "should fail after exceeding reconnect max retries" do
+      # next connection attempts should fail
+      TCPSocket.stubs(:new).times(3).raises(Errno::ECONNREFUSED.new)
+      TCPSocket.any_instance.stubs(:readline).times(1).raises(EOFError.new)
+
+      assert_raises(Beaneater::NotConnected) { @bc.transmit "delete 56\r\n" }
+    end
+
+    it "tubes_watched are restored after reconnect" do
+      client = Beaneater.new('127.0.0.1:11300')
+      client.tubes.watch! "another"
+
+      TCPSocket.prepend Module.new {
+        def readline
+          if !$called
+            $called = true
+            raise EOFError
+          end
+
+          super
+        end
+      }
+
+      assert_equal %w[another], client.tubes.watched.map(&:name)
+    end
   end # transmit
 
   describe 'for #close' do