em-beanstalk 0.0.3

data/COPYING

@@ -0,0 +1,21 @@
+Copyright (c) 2009, dan sinclair. All rights reserved.
+ 
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+ 
+THIS SOFTWARE IS PROVIDED BY dan sinclair ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL dan sinclair BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,73 @@
+= EMJack
+An attempt to wrap portions of the Beanstalk protocol with EventMachine. Every command
+will return a deferrable object. That object will succeed or fail depending on the 
+reply returned from Beanstalk.
+
+The current, default, errback is to print the error message received.
+
+One thing to keep in mind. The Beanstalk protocol executes all commands serially.
+So, if you send a reserve command and there are no jobs Beanstalk _won't_ process
+any of the commands that come after the reserve until the reserve completes.
+
+This is a bit of a gotcha when sending a series of reserve, delete, etc and there
+are no available jobs.
+
+= Dependencies
+ - EventMachine
+ - RSpec  (to run the tests)
+ - EM::Spec
+
+= Examples
+  EM.run {
+    jack = EMJack::Connection.new
+  
+    jack.use('mytube') { |tube| puts "Using #{tube}" }
+  
+    jack.reserve do |job|
+      puts job.id
+      process(job)
+      
+      jack.delete(job) { puts "Successfully deleted" }
+    end
+  
+    jack.put("my message", :ttr => 300) { |id| puts "put successful #{id}" }
+  
+    jack.stats { |stats| puts "Server up for #{stats['uptime']} seconds" "}
+    
+    jack.stats(:tube, "mytube") { |stats| puts "Total jobs #{stats['total-jobs']}" }
+    
+    jack.list(:tubes) { |tubes| puts "There are #{tubes.length} tubes defined" }
+  }
+
+
+  EMJack#each_job is useful for scenarios where the client is a job worker 
+  and intended to process jobs continuously as they become available. Once 
+  the queue is empty, the client will block and wait for a new job.
+
+  If multiple workers connect to the queue Beanstalkd will round-robin between
+  the workers.
+    EM.run {
+      jack = EMJack::Connection.new
+
+      jack.each_job do |job|
+        puts "Got job ##{job.id}: #{job}"
+
+        if process(job)
+          jack.delete(job) { puts "*Deleted #{job}*" }
+        else
+          # something went horribly wrong!
+        end
+      end
+
+      def process(job)
+        # Some kind of job processing
+      end
+    }
+
+
+= Contact
+If you've got any questions, comments or bugs, please let me know. You can
+contact me by email at dj2 at everburning dot com.
+
+= Contributors
+Peter Kieltyka (EMJack#each_job)

data/Rakefile

@@ -0,0 +1,48 @@
+libdir = File.expand_path("lib")
+$:.unshift(libdir) unless $:.include?(libdir)
+
+require 'em-jack'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "em-beanstalk"
+    s.description = s.summary = "EventMachine client for Beanstalkd"
+    s.email = "dan@postrank.com"
+    s.homepage = "http://github.com/joshbuddy/em-jack"
+    s.authors = ["Dan"]
+    s.files = FileList["[A-Z]*", "{lib,spec}/**/*"]
+    s.add_dependency 'eventmachine'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec'
+require 'spec/rake/spectask'
+task :spec => 'spec:all'
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec_with_rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+require 'rake/rdoctask'
+desc "Generate documentation"
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'rdoc'
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/lib/em-jack.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'em-jack/job'
+require 'em-jack/errors'
+require 'em-jack/beanstalk_connection'
+require 'em-jack/connection'
+
+module EMJack
+  module VERSION
+    STRING = '0.0.3'
+  end
+end

data/lib/em-jack/beanstalk_connection.rb

@@ -0,0 +1,30 @@
+require 'eventmachine'
+
+module EMJack
+  class BeanstalkConnection < EM::Connection
+    attr_accessor :client
+  
+    def connection_completed
+      @client.connected
+    end
+
+    def receive_data(data)
+      @client.received(data)
+    end
+  
+    def send(command, *args)
+      cmd = command.to_s
+      cmd << " #{args.join(" ")}" unless args.length == 0
+      cmd << "\r\n"
+      send_data(cmd)
+    end
+  
+    def send_with_data(command, data, *args)
+      send_data("#{command.to_s} #{args.join(" ")}\r\n#{data}\r\n")
+    end
+  
+    def unbind
+      @client.disconnected
+    end
+  end
+end

data/lib/em-jack/connection.rb

@@ -0,0 +1,281 @@
+require 'eventmachine'
+require 'yaml'
+
+module EMJack
+  class Connection
+
+    attr_accessor :host, :port
+    attr_reader :default_priority, :default_delay, :default_ttr
+    
+    def initialize(opts = nil)
+      @host = opts && opts[:host] || 'localhost'
+      @port = opts && opts[:port] || 11300
+      @tube = opts && opts[:tube]
+      @retry_count = opts && opts[:retry_count] || 5
+      @default_priority = opts && opts[:default_priority] || 65536
+      @default_delay = opts && opts[:default_delay] || 0
+      @default_ttr = opts && opts[:default_ttr] || 300
+      @default_timeout = opts && opts[:timeout] || 5
+      
+      @used_tube = 'default'
+      @watched_tubes = [@used_tube]
+      
+      @data = ""
+      @retries = 0
+      @in_reserve = false
+      @deferrables = []
+      
+      @conn = EM::connect(host, port, EMJack::BeanstalkConnection) do |conn|
+        conn.client = self
+        conn.comm_inactivity_timeout = 0
+        conn.pending_connect_timeout = @default_timeout
+      end
+      
+      unless @tube.nil?
+        use(@tube)
+        watch(@tube)
+      end
+    end
+    
+    def close
+      @disconnect_manually = true
+      @conn.close_connection
+    end
+    
+    def drain!(&block)
+      stats do |stats|
+        stats['current-jobs-ready'].zero? ?
+          EM.next_tick(&block) :
+          reserve{|job| job.delete{ drain!(&block) }}
+      end
+    end
+    
+    def use(tube, &block)
+      return if @used_tube == tube
+      @used_tube = tube
+      @conn.send(:use, tube)
+      add_deferrable(&block)
+      
+    end
+    
+    def watch(tube, &block)
+      return if @watched_tubes.include?(tube)
+      @watched_tubes.push(tube)
+      @conn.send(:watch, tube)
+      add_deferrable(&block)
+    end
+    
+    def ignore(tube, &block)
+      return if not @watched_tubes.include?(tube)
+      @watched_tubes.delete(tube)
+      @conn.send(:ignore, tube)
+      add_deferrable(&block)
+    end
+
+    def reserve(timeout = nil, &block)
+      if timeout
+        @conn.send(:'reserve-with-timeout', timeout)
+      else
+        @conn.send(:reserve)
+      end
+      add_deferrable(&block)
+    end
+
+    def each_job(timeout = nil, &block)
+      work = Proc.new do
+        r = reserve(timeout)
+        r.callback do |job|
+          block.call(job)
+          EM.next_tick { work.call }
+        end
+      end
+      work.call
+    end
+
+    def stats(type = nil, val = nil, &block)
+      case(type)
+      when nil then @conn.send(:stats)
+      when :tube then @conn.send(:'stats-tube', val)
+      when :job then @conn.send(:'stats-job', job_id(val))
+      else raise EMJack::InvalidCommand.new
+      end
+      add_deferrable(&block)
+    end
+
+    def job_id(val)
+      case val
+      when Job
+        val.id
+      else
+        val
+      end
+    end
+    
+    def list(type = nil, &block)
+      case(type)
+      when nil then @conn.send(:'list-tubes')
+      when :use, :used then @conn.send(:'list-tube-used')
+      when :watch, :watched then @conn.send(:'list-tubes-watched')
+      else raise EMJack::InvalidCommand.new
+      end
+      add_deferrable(&block)
+    end
+
+    def delete(val, &block)
+      return unless val
+      @conn.send(:delete, job_id(val))
+      add_deferrable(&block)
+    end
+    
+    def put(msg, opts = nil, &block)
+      case msg
+      when Job
+        priority = opts && opts[:priority] || msg.priority
+        delay = opts && opts[:delay] || msg.delay
+        ttr = opts && opts[:ttr] || msg.ttr
+        body = msg.body
+      else
+        priority = opts && opts[:priority] || default_priority
+        delay = opts && opts[:delay] || default_delay
+        ttr = opts && opts[:ttr] || default_ttr
+        body = msg.to_s
+      end
+      
+      priority = default_priority if priority < 0
+      priority = 2 ** 32 if priority > (2 ** 32)
+      delay = default_delay if delay < 0
+      ttr = default_ttr if ttr < 0
+      
+      @conn.send_with_data(:put, body, priority, delay, ttr, body.size)
+      add_deferrable(&block)
+    end
+  
+    def release(job, &block)
+      return if job.nil?
+      @conn.send(:release, job.jobid, 0, 0)
+      add_deferrable(&block)
+    end
+
+    def connected
+      @retries = 0
+    end
+
+    def disconnected
+      @deferrables.each {|d| d.fail }
+      unless @disconnect_manually
+        raise EMJack::Disconnected if @retries >= @retry_count
+        @retries += 1
+        EM.add_timer(1) { reconnect }
+      end
+    end
+
+    def reconnect
+      @disconnect_manually = false
+      @conn.reconnect(host, port)
+    end
+
+    def add_deferrable(&block)
+      df = EM::DefaultDeferrable.new
+      df.errback do
+        if @error_callback
+          @error_callback.call
+        else
+          puts "ERROR"
+        end
+      end
+      
+      @deferrables.push(df)
+      df.callback(&block) if block
+      df
+    end
+  
+    def on_error(&block)
+      @error_callback = block
+    end
+  
+    def received(data)
+      @data << data
+
+      until @data.empty?
+        idx = @data.index(/(.*?\r\n)/)
+        break if idx.nil?
+
+        first = $1
+        
+        handled = false
+        %w(OUT_OF_MEMORY INTERNAL_ERROR DRAINING BAD_FORMAT
+           UNKNOWN_COMMAND EXPECTED_CRLF JOB_TOO_BIG DEADLINE_SOON
+           TIMED_OUT NOT_FOUND).each do |cmd|
+          next unless first =~ /^#{cmd}\r\n/i
+          df = @deferrables.shift
+          df.fail(cmd.downcase.to_sym)
+
+          @data = @data[(cmd.length + 2)..-1]
+          handled = true
+          break
+        end
+        next if handled
+
+        case (first)
+        when /^DELETED\r\n/ then
+          df = @deferrables.shift
+          df.succeed
+
+        when /^INSERTED\s+(\d+)\r\n/ then
+          df = @deferrables.shift
+          df.succeed($1.to_i)
+
+        when /^RELEASED\r\n/ then
+          df = @deferrables.shift
+          df.succeed
+
+        when /^BURIED\s+(\d+)\r\n/ then
+          df = @deferrables.shift
+          df.fail(:buried, $1.to_i)
+
+        when /^USING\s+(.*)\r\n/ then
+          df = @deferrables.shift
+          df.succeed($1)
+
+        when /^WATCHING\s+(\d+)\r\n/ then
+          df = @deferrables.shift
+          df.succeed($1.to_i)
+
+        when /^OK\s+(\d+)\r\n/ then
+          bytes = $1.to_i
+
+          body, @data = extract_body(bytes, @data)
+          break if body.nil?
+
+          df = @deferrables.shift
+          df.succeed(YAML.load(body))
+          next
+
+        when /^RESERVED\s+(\d+)\s+(\d+)\r\n/ then
+          id = $1.to_i
+          bytes = $2.to_i
+
+          body, @data = extract_body(bytes, @data)
+          break if body.nil?
+
+          df = @deferrables.shift
+          job = EMJack::Job.new(self, id, body)
+          df.succeed(job)
+          next
+        else
+          break
+        end
+        @data.slice!(0, first.size)
+      end
+    end
+    
+    def extract_body(bytes, data)
+      rem = data[(data.index(/\r\n/) + 2)..-1]
+      return [nil, data] if rem.length < bytes
+      body = rem[0..(bytes - 1)]
+      data = rem[(bytes + 2)..-1]
+      data = "" if data.nil?
+      [body, data]
+    end
+  end  
+end

data/lib/em-jack/errors.rb

@@ -0,0 +1,7 @@
+module EMJack
+  class Disconnected < RuntimeError
+  end
+
+  class InvalidCommand < RuntimeError
+  end
+end

data/lib/em-jack/job.rb

@@ -0,0 +1,30 @@
+module EMJack
+  class Job
+    
+    attr_reader :id, :conn
+    attr_accessor :body, :ttr, :priority, :delay
+    
+    def initialize(conn, id, body)
+      @conn = conn
+      @id = id && Integer(id)
+      @body = body
+      @priority = conn && conn.default_priority
+      @delay = conn && conn.default_delay
+      @ttr = conn && conn.default_ttr
+    end
+    
+    alias_method :jobid, :id
+    
+    def delete(&block)
+      conn.delete(self, &block)
+    end
+    
+    def stats(&block)
+      conn.stats(:job, self, &block)
+    end
+
+    def to_s
+      "#{id} -- #{body.inspect}"
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,374 @@
+require 'spec/spec_helper'
+
+describe EMJack::Connection do
+  before(:each) do
+    @connection_mock = mock(:conn)
+    EM.should_receive(:connect).and_return(@connection_mock)
+  end
+
+  it 'should use a default host of "localhost"' do
+    conn = EMJack::Connection.new
+    conn.host.should == 'localhost'
+  end
+
+  it 'should use a default port of 11300' do
+    conn = EMJack::Connection.new
+    conn.port.should == 11300    
+  end
+
+  it 'should watch and use a provided tube on connect' do
+    @connection_mock.should_receive(:send).once.with(:use, "mytube")
+    @connection_mock.should_receive(:send).once.with(:watch, "mytube")
+    conn = EMJack::Connection.new(:tube => "mytube")
+  end
+
+  it 'should send the "use" command' do
+    @connection_mock.should_receive(:send).once.with(:use, "mytube")
+    conn = EMJack::Connection.new
+    conn.use("mytube")
+  end
+
+  it 'should not send the use command to the currently used tube' do
+    @connection_mock.should_receive(:send).once.with(:use, "mytube")
+    conn = EMJack::Connection.new
+    conn.use("mytube")
+    conn.use("mytube")
+  end
+
+  it 'should send the "watch" command' do
+    @connection_mock.should_receive(:send).once.with(:watch, "mytube")
+    conn = EMJack::Connection.new
+    conn.watch("mytube")
+  end
+
+  it 'should not send the watch command for a tube currently watched' do
+    @connection_mock.should_receive(:send).once.with(:watch, "mytube")
+    conn = EMJack::Connection.new
+    conn.watch("mytube")
+    conn.watch("mytube")
+  end
+
+  it 'should send the "put" command' do
+    msg = "my message"
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, msg, anything, anything, anything, msg.length)
+    conn = EMJack::Connection.new
+    conn.put(msg)
+  end
+
+  it 'should default the delay, priority and ttr settings' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, 65536, 0, 300, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg")
+  end
+
+  it 'should accept a delay setting' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, anything, 42, anything, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg", :delay => 42)
+  end
+
+  it 'should accept a ttr setting' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, anything, anything, 999, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg", :ttr => 999)
+  end
+
+  it 'should accept a priority setting' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, 233, anything, anything, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg", :priority => 233)
+  end
+
+  it 'shoudl accept a priority, delay and ttr setting' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, 99, 42, 2000, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg", :priority => 99, :delay => 42, :ttr => 2000)
+  end
+
+  it 'should force delay to be >= 0' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, anything, 0, anything, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg", :delay => -42)
+  end
+
+  it 'should force ttr to be >= 0' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, anything, anything, 300, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg", :ttr => -42)
+  end
+
+  it 'should force priority to be >= 0' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, 65536, anything, anything, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg", :priority => -42)
+  end
+
+  it 'should force priority to be < 2**32' do
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, anything, (2 ** 32), anything, anything, anything)
+    conn = EMJack::Connection.new
+    conn.put("msg", :priority => (2 ** 32 + 1))
+  end
+
+  it 'should handle a non-string provided as the put message' do
+    msg = 22
+    @connection_mock.should_receive(:send_with_data).once.
+                      with(:put, msg.to_s, anything, anything, anything, msg.to_s.length)
+    conn = EMJack::Connection.new
+    conn.put(msg) 
+  end
+
+  it 'should send the "delete" command' do
+    @connection_mock.should_receive(:send).once.with(:delete, 1)
+    job = EMJack::Job.new(nil, 1, "body")
+    conn = EMJack::Connection.new
+    conn.delete(job)
+  end
+
+  it 'should handle a nil job sent to the "delete" command' do
+    @connection_mock.should_not_receive(:send).with(:delete, nil)
+    conn = EMJack::Connection.new
+    conn.delete(nil)
+  end
+
+  it 'should send the "reserve" command' do
+    @connection_mock.should_receive(:send).with(:reserve)
+    conn = EMJack::Connection.new
+    conn.reserve
+  end
+
+  it 'should raise exception if reconnect fails more then RETRY_COUNT times' do
+    EM.should_receive(:add_timer).exactly(5).times
+
+    conn = EMJack::Connection.new
+    5.times { conn.disconnected }
+    lambda { conn.disconnected }.should raise_error(EMJack::Disconnected)
+  end
+
+  it 'should reset the retry count on connection' do
+    EM.should_receive(:add_timer).at_least(1).times
+
+    conn = EMJack::Connection.new
+    5.times { conn.disconnected }
+    conn.connected
+    lambda { conn.disconnected }.should_not raise_error(EMJack::Disconnected)
+  end
+
+  %w(OUT_OF_MEMORY INTERNAL_ERROR DRAINING BAD_FORMAT
+     UNKNOWN_COMMAND EXPECTED_CRLF JOB_TOO_BIG DEADLINE_SOON
+     TIMED_OUT NOT_FOUND).each do |cmd|
+    it "should handle #{cmd} messages" do
+       conn = EMJack::Connection.new
+
+       df = conn.add_deferrable
+       df.should_receive(:fail).with(cmd.downcase.to_sym)
+
+       conn.received("#{cmd}\r\n")
+     end
+  end
+
+  it 'should handle deleted messages' do
+    conn = EMJack::Connection.new
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed)
+
+    conn.received("DELETED\r\n")
+  end
+
+  it 'should handle inserted messages' do
+    conn = EMJack::Connection.new
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with(40)
+
+    conn.received("INSERTED 40\r\n")
+  end
+
+  it 'should handle buried messages' do
+    conn = EMJack::Connection.new
+
+    df = conn.add_deferrable
+    df.should_receive(:fail).with(:buried, 40)
+
+    conn.received("BURIED 40\r\n")
+  end
+
+  it 'should handle using messages' do
+    conn = EMJack::Connection.new
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with("mytube")
+
+    conn.received("USING mytube\r\n")
+  end
+
+  it 'should handle watching messages' do
+    conn = EMJack::Connection.new
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with(24)
+
+    conn.received("WATCHING 24\r\n")
+  end
+
+  it 'should handle reserved messages' do
+    conn = EMJack::Connection.new
+
+    msg = "This is my message"
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with do |job|
+      job.class.should == EMJack::Job
+      job.jobid.should == 42
+      job.body.should == msg
+    end
+
+    conn.received("RESERVED 42 #{msg.length}\r\n#{msg}\r\n")
+  end
+
+  it 'should handle receiving multiple replies in one packet' do
+    conn = EMJack::Connection.new
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with(24)
+
+    df2 = conn.add_deferrable
+    df2.should_receive(:succeed).with("mytube")
+
+    conn.received("WATCHING 24\r\nUSING mytube\r\n")
+  end
+
+  it 'should handle receiving data in chunks' do
+    conn = EMJack::Connection.new
+    
+    msg1 = "First half of the message\r\n"
+    msg2 = "Last half of the message"
+    
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with do |job|
+      job.body.should == "#{msg1}#{msg2}"
+    end
+
+    conn.received("RESERVED 9 #{(msg1 + msg2).length}\r\n#{msg1}")
+    conn.received("#{msg2}\r\n")
+  end
+  
+  it 'should send the stat command' do
+    @connection_mock.should_receive(:send).once.with(:stats)
+    conn = EMJack::Connection.new
+    conn.stats
+  end
+
+  it 'should handle receiving the OK command' do
+    conn = EMJack::Connection.new
+
+    msg =<<-HERE
+---
+current-jobs-urgent: 42
+current-jobs-ready: 92
+current-jobs-reserved: 18
+current-jobs-delayed: 7
+current-jobs-buried: 0
+pid: 416
+version: dev
+HERE
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with do |stats|
+      stats['current-jobs-urgent'].should == 42
+      stats['current-jobs-ready'].should == 92
+      stats['current-jobs-reserved'].should == 18
+      stats['current-jobs-delayed'].should == 7
+      stats['current-jobs-buried'].should == 0
+      stats['pid'].should == 416
+      stats['version'].should == 'dev'
+    end
+
+    conn.received("OK #{msg.length}\r\n#{msg}\r\n")
+  end
+
+  it 'should support job stats' do
+    job = EMJack::Job.new(nil, 42, "blah")
+
+    @connection_mock.should_receive(:send).once.with(:'stats-job', 42)
+    conn = EMJack::Connection.new
+    conn.stats(:job, job)
+  end
+
+  it 'should support tube stats' do
+    @connection_mock.should_receive(:send).once.with(:'stats-tube', "mytube")
+    conn = EMJack::Connection.new
+    conn.stats(:tube, "mytube")
+  end
+
+  it 'should throw exception on invalid stats command' do
+    @connection_mock.should_not_receive(:send)
+    conn = EMJack::Connection.new
+    lambda { conn.stats(:blah) }.should raise_error(EMJack::InvalidCommand)
+  end
+
+  it 'should support listing tubes' do
+    @connection_mock.should_receive(:send).once.with(:'list-tubes')
+    conn = EMJack::Connection.new
+    conn.list
+  end
+
+  it 'should support listing tube used' do
+    @connection_mock.should_receive(:send).once.with(:'list-tube-used')
+    conn = EMJack::Connection.new
+    conn.list(:used)
+  end
+
+  it 'should support listing tubes watched' do
+    @connection_mock.should_receive(:send).once.with(:'list-tubes-watched')
+    conn = EMJack::Connection.new
+    conn.list(:watched)
+  end
+
+  it 'should throw exception on invalid list command' do
+    @connection_mock.should_not_receive(:send)
+    conn = EMJack::Connection.new
+    lambda { conn.list(:blah) }.should raise_error(EMJack::InvalidCommand)
+  end
+
+  it 'should accept a response broken over multiple packets' do
+    conn = EMJack::Connection.new
+
+    msg1 = "First half of the message\r\n"
+    msg2 = "Last half of the message"
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with do |job|
+      job.body.should == "#{msg1}#{msg2}"
+    end
+
+    conn.received("RESERVED 9 ")
+    conn.received("#{(msg1 + msg2).length}")
+    conn.received("\r\n#{msg1}#{msg2}\r\n")
+  end
+
+  it 'should accept a response broken over multiple packets' do
+    conn = EMJack::Connection.new
+
+    msg1 = "First half of the message\r\n"
+    msg2 = "Last half of the message"
+
+    df = conn.add_deferrable
+    df.should_receive(:succeed).with do |job|
+      job.body.should == "#{msg1}#{msg2}"
+    end
+
+    conn.received("RESERVED 9 #{(msg1 + msg2).length}\r\n#{msg1}#{msg2}")
+    conn.received("\r\n")
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,365 @@
+require 'spec/spec_helper'
+
+describe EMJack::Connection, "integration" do
+  include EM::Spec
+
+  it 'should use a default host of "localhost" and port of 11300' do
+    conn = EMJack::Connection.new
+    conn.host.should == 'localhost'
+    conn.port.should == 11300    
+    done
+  end
+
+  it 'should watch and use a provided tube on connect' do
+    conn = EMJack::Connection.new
+    conn.watch('my-lovely-tube') do 
+      conn.list(:watched) do |watched|
+        watched.should include("my-lovely-tube")
+        done
+      end
+    end
+  end
+
+  it 'should send the "use" command' do
+    conn = EMJack::Connection.new
+    conn.use('my-lovely-tube') do 
+      conn.list(:used) do |used|
+        used.should include("my-lovely-tube")
+        done
+      end
+    end
+  end
+  
+  it "should put a job" do
+    conn = EMJack::Connection.new
+    conn.put('myjob') do
+      conn.reserve do |job|
+        job.body.should == 'myjob'
+        job.delete { done }
+      end
+    end
+  end
+
+  it "should drain the queue" do
+    conn = EMJack::Connection.new
+    conn.put('myjob')
+    conn.put('myjob')
+    conn.put('myjob')
+    conn.put('myjob')
+    conn.put('myjob')
+    conn.drain!{
+      conn.stats do |stats|
+        stats['current-jobs-ready'].should == 0
+        done
+      end
+    }
+  end
+
+  it 'should default the delay, priority and ttr settings' do
+    conn = EMJack::Connection.new
+    conn.put('myjob') do
+      conn.reserve do |job|
+        job.delay.should == conn.default_delay
+        job.ttr.should == conn.default_ttr
+        job.priority.should == conn.default_priority
+        job.delete { done }
+      end
+    end
+  end
+  
+  it 'should accept a delay setting' do
+    conn = EMJack::Connection.new
+    start = Time.new.to_f
+    conn.put('mydelayedjob', :delay => 3) do |id|
+      conn.reserve do |job|
+        (Time.new.to_f - start).should be_close(3, 0.1)
+        job.id.should == id
+        job.delete { done }
+      end
+    end
+  end
+  
+  it 'should accept a ttr setting' do
+    conn = EMJack::Connection.new
+    conn.put('mydelayedjob', :ttr => 1) do |id|
+      
+      conn.reserve do |job|
+        job.id.should == id
+        EM.add_timer(3) do
+          conn2 = EMJack::Connection.new
+          conn2.reserve do |job2|
+            job2.id.should == id
+            job2.delete { done }
+          end
+        end
+      end
+    end
+  end
+  
+  it 'should accept a priority setting' do
+    conn = EMJack::Connection.new
+    conn.put('myhighpriorityjob', :priority => 800) do |low_id|
+      conn.put('myhighpriorityjob', :priority => 300) do |high_id|
+        conn.reserve do |job|
+          job.id.should == high_id
+          job.delete { conn.delete(low_id){done}}
+        end
+      end
+    end
+  end
+  
+  it 'should handle a non-string provided as the put message' do
+    conn = EMJack::Connection.new
+    conn.put(22) do |id|
+      conn.reserve do |job|
+        job.body.should == '22'
+        job.delete {done}
+      end
+    end
+  end
+  #
+  #it 'should send the "delete" command' do
+  #  @connection_mock.should_receive(:send).once.with(:delete, 1)
+  #  job = EMJack::Job.new(nil, 1, "body")
+  #  conn = EMJack::Connection.new
+  #  conn.delete(job)
+  #end
+  #
+  #it 'should handle a nil job sent to the "delete" command' do
+  #  @connection_mock.should_not_receive(:send).with(:delete, nil)
+  #  conn = EMJack::Connection.new
+  #  conn.delete(nil)
+  #end
+  #
+  #it 'should send the "reserve" command' do
+  #  @connection_mock.should_receive(:send).with(:reserve)
+  #  conn = EMJack::Connection.new
+  #  conn.reserve
+  #end
+  #
+  #it 'should raise exception if reconnect fails more then RETRY_COUNT times' do
+  #  EM.should_receive(:add_timer).exactly(5).times
+  #
+  #  conn = EMJack::Connection.new
+  #  5.times { conn.disconnected }
+  #  lambda { conn.disconnected }.should raise_error(EMJack::Disconnected)
+  #end
+  #
+  #it 'should reset the retry count on connection' do
+  #  EM.should_receive(:add_timer).at_least(1).times
+  #
+  #  conn = EMJack::Connection.new
+  #  5.times { conn.disconnected }
+  #  conn.connected
+  #  lambda { conn.disconnected }.should_not raise_error(EMJack::Disconnected)
+  #end
+  #
+  #%w(OUT_OF_MEMORY INTERNAL_ERROR DRAINING BAD_FORMAT
+  #   UNKNOWN_COMMAND EXPECTED_CRLF JOB_TOO_BIG DEADLINE_SOON
+  #   TIMED_OUT NOT_FOUND).each do |cmd|
+  #  it "should handle #{cmd} messages" do
+  #     conn = EMJack::Connection.new
+  #
+  #     df = conn.add_deferrable
+  #     df.should_receive(:fail).with(cmd.downcase.to_sym)
+  #
+  #     conn.received("#{cmd}\r\n")
+  #   end
+  #end
+  #
+  #it 'should handle deleted messages' do
+  #  conn = EMJack::Connection.new
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed)
+  #
+  #  conn.received("DELETED\r\n")
+  #end
+  #
+  #it 'should handle inserted messages' do
+  #  conn = EMJack::Connection.new
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with(40)
+  #
+  #  conn.received("INSERTED 40\r\n")
+  #end
+  #
+  #it 'should handle buried messages' do
+  #  conn = EMJack::Connection.new
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:fail).with(:buried, 40)
+  #
+  #  conn.received("BURIED 40\r\n")
+  #end
+  #
+  #it 'should handle using messages' do
+  #  conn = EMJack::Connection.new
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with("mytube")
+  #
+  #  conn.received("USING mytube\r\n")
+  #end
+  #
+  #it 'should handle watching messages' do
+  #  conn = EMJack::Connection.new
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with(24)
+  #
+  #  conn.received("WATCHING 24\r\n")
+  #end
+  #
+  #it 'should handle reserved messages' do
+  #  conn = EMJack::Connection.new
+  #
+  #  msg = "This is my message"
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with do |job|
+  #    job.class.should == EMJack::Job
+  #    job.id.should == 42
+  #    job.body.should == msg
+  #  end
+  #
+  #  conn.received("RESERVED 42 #{msg.length}\r\n#{msg}\r\n")
+  #end
+  #
+  #it 'should handle receiving multiple replies in one packet' do
+  #  conn = EMJack::Connection.new
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with(24)
+  #
+  #  df2 = conn.add_deferrable
+  #  df2.should_receive(:succeed).with("mytube")
+  #
+  #  conn.received("WATCHING 24\r\nUSING mytube\r\n")
+  #end
+  #
+  #it 'should handle receiving data in chunks' do
+  #  conn = EMJack::Connection.new
+  #  
+  #  msg1 = "First half of the message\r\n"
+  #  msg2 = "Last half of the message"
+  #  
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with do |job|
+  #    job.body.should == "#{msg1}#{msg2}"
+  #  end
+  #
+  #  conn.received("RESERVED 9 #{(msg1 + msg2).length}\r\n#{msg1}")
+  #  conn.received("#{msg2}\r\n")
+  #end
+  #
+  #it 'should send the stat command' do
+  #  @connection_mock.should_receive(:send).once.with(:stats)
+  #  conn = EMJack::Connection.new
+  #  conn.stats
+  #end
+  #
+  #it 'should handle receiving the OK command' do
+  #  conn = EMJack::Connection.new
+  #
+  #  msg =<<-HERE
+#---
+#current-jobs-urgent: 42
+#current-jobs-ready: 92
+#current-jobs-reserved: 18
+#current-jobs-delayed: 7
+#current-jobs-buried: 0
+#pid: 416
+#version: dev
+#HERE
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with do |stats|
+  #    stats['current-jobs-urgent'].should == 42
+  #    stats['current-jobs-ready'].should == 92
+  #    stats['current-jobs-reserved'].should == 18
+  #    stats['current-jobs-delayed'].should == 7
+  #    stats['current-jobs-buried'].should == 0
+  #    stats['pid'].should == 416
+  #    stats['version'].should == 'dev'
+  #  end
+  #
+  #  conn.received("OK #{msg.length}\r\n#{msg}\r\n")
+  #end
+  #
+  #it 'should support job stats' do
+  #  job = EMJack::Job.new(nil, 42, "blah")
+  #
+  #  @connection_mock.should_receive(:send).once.with(:'stats-job', 42)
+  #  conn = EMJack::Connection.new
+  #  conn.stats(:job, job)
+  #end
+  #
+  #it 'should support tube stats' do
+  #  @connection_mock.should_receive(:send).once.with(:'stats-tube', "mytube")
+  #  conn = EMJack::Connection.new
+  #  conn.stats(:tube, "mytube")
+  #end
+  #
+  #it 'should throw exception on invalid stats command' do
+  #  @connection_mock.should_not_receive(:send)
+  #  conn = EMJack::Connection.new
+  #  lambda { conn.stats(:blah) }.should raise_error(EMJack::InvalidCommand)
+  #end
+  #
+  #it 'should support listing tubes' do
+  #  @connection_mock.should_receive(:send).once.with(:'list-tubes')
+  #  conn = EMJack::Connection.new
+  #  conn.list
+  #end
+  #
+  #it 'should support listing tube used' do
+  #  @connection_mock.should_receive(:send).once.with(:'list-tube-used')
+  #  conn = EMJack::Connection.new
+  #  conn.list(:used)
+  #end
+  #
+  #it 'should support listing tubes watched' do
+  #  @connection_mock.should_receive(:send).once.with(:'list-tubes-watched')
+  #  conn = EMJack::Connection.new
+  #  conn.list(:watched)
+  #end
+  #
+  #it 'should throw exception on invalid list command' do
+  #  @connection_mock.should_not_receive(:send)
+  #  conn = EMJack::Connection.new
+  #  lambda { conn.list(:blah) }.should raise_error(EMJack::InvalidCommand)
+  #end
+  #
+  #it 'should accept a response broken over multiple packets' do
+  #  conn = EMJack::Connection.new
+  #
+  #  msg1 = "First half of the message\r\n"
+  #  msg2 = "Last half of the message"
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with do |job|
+  #    job.body.should == "#{msg1}#{msg2}"
+  #  end
+  #
+  #  conn.received("RESERVED 9 ")
+  #  conn.received("#{(msg1 + msg2).length}")
+  #  conn.received("\r\n#{msg1}#{msg2}\r\n")
+  #end
+  #
+  #it 'should accept a response broken over multiple packets' do
+  #  conn = EMJack::Connection.new
+  #
+  #  msg1 = "First half of the message\r\n"
+  #  msg2 = "Last half of the message"
+  #
+  #  df = conn.add_deferrable
+  #  df.should_receive(:succeed).with do |job|
+  #    job.body.should == "#{msg1}#{msg2}"
+  #  end
+  #
+  #  conn.received("RESERVED 9 #{(msg1 + msg2).length}\r\n#{msg1}#{msg2}")
+  #  conn.received("\r\n")
+  #end
+end

data/spec/job_spec.rb

@@ -0,0 +1,39 @@
+require 'spec/spec_helper'
+
+describe EMJack::Job do
+  it 'should convert id to an integer' do
+    j = EMJack::Job.new(nil, "123", "body")
+    j.id.should == 123
+  end
+  
+  it 'should fail if id is not an integer' do
+    proc {
+      j = EMJack::Job.new(nil, "asd", "body")
+    }.should raise_error
+  end
+  
+  it 'should send a delete command to the connection' do
+    conn = mock(:conn)
+    conn.should_receive(:default_priority)
+    conn.should_receive(:default_delay)
+    conn.should_receive(:default_ttr)
+    
+    j = EMJack::Job.new(conn, 1, "body")
+
+    conn.should_receive(:delete).with(j)
+    
+    j.delete
+  end
+
+  it 'should send a stats command to the connection' do
+    conn = mock(:conn)
+    conn.should_receive(:default_priority)
+    conn.should_receive(:default_delay)
+    conn.should_receive(:default_ttr)
+
+    j = EMJack::Job.new(conn, 2, 'body')
+    conn.should_receive(:stats).with(:job, j)
+
+    j.stats
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+libdir = File.expand_path("lib")
+$:.unshift(libdir) unless $:.include?(libdir)
+
+require 'em-jack'
+#require 'rubygems'
+require "em-spec/rspec"
+
+#def with_connection(*args)
+#  EM.run do
+#    yield EMJack::Connection.new(*args)
+#    EM.stop
+#  end
+  
+#end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: em-beanstalk
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Dan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-20 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: EventMachine client for Beanstalkd
+email: dan@postrank.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- COPYING
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/em-jack.rb
+- lib/em-jack/beanstalk_connection.rb
+- lib/em-jack/connection.rb
+- lib/em-jack/errors.rb
+- lib/em-jack/job.rb
+- spec/connection_spec.rb
+- spec/integration_spec.rb
+- spec/job_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/joshbuddy/em-jack
+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: EventMachine client for Beanstalkd
+test_files: 
+- spec/connection_spec.rb
+- spec/integration_spec.rb
+- spec/job_spec.rb
+- spec/spec_helper.rb