em-jack 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,80 @@
+= 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)
+
+= Examples
+  EM.run {
+    jack = EMJack::Connection.new
+  
+    r = jack.use('mytube')
+    r.callback { |tube| puts "Using #{tube}" }
+  
+    r = jack.reserve
+    r.callback do |job|
+      puts job.jobid
+      process(job)
+      
+      r2 = jack.delete(job)
+      r2.callback { puts "Successfully deleted" }
+    end
+  
+    r = jack.put("my message", :ttr => 300)
+    r.callback { |jobid| puts "put successful #{jobid}" }
+  
+    r = jack.stats
+    r.callback { |stats| puts "Server up for #{stats['uptime']} seconds" "}
+    
+    r = jack.stats(:tube, "mytube")
+    r.callback { |stats| puts "Total jobs #{stats['total-jobs']}" }
+    
+    r = jack.list(:tubes)
+    r.callback { |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.jobid}: #{job}"
+
+        if process(job)
+          r = jack.delete(job)
+          r.callback { puts "*Deleted #{job}*" }
+        else
+        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/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,231 @@
+require 'eventmachine'
+require 'yaml'
+
+module EMJack
+  class Connection
+    RETRY_COUNT = 5
+ 
+    attr_accessor :host, :port
+    
+    def initialize(opts = {})
+      @host = opts[:host] || 'localhost'
+      @port = opts[:port] || 11300
+      @tube = opts[:tube]
+      
+      @used_tube = 'default'
+      @watched_tubes = ['default']
+      
+      @data = ""
+      @retries = 0
+      @in_reserve = false
+      @deferrables = []
+      
+      @conn = EM::connect(host, port, EMJack::BeanstalkConnection) do |conn|
+        conn.client = self
+      end
+      
+      unless @tube.nil?
+        use(@tube)
+        watch(@tube)
+      end
+    end
+    
+    def use(tube)
+      return if @used_tube == tube
+      @used_tube = tube
+      @conn.send(:use, tube)
+      add_deferrable
+    end
+    
+    def watch(tube)
+      return if @watched_tubes.include?(tube)
+      @watched_tubes.push(tube)
+      @conn.send(:watch, tube)
+      add_deferrable
+    end
+    
+    def ignore(tube)
+      return if not @watched_tubes.include?(tube)
+      @watched_tubes.delete(tube)
+      @conn.send(:ignore, tube)
+      add_deferrable
+    end
+
+    def reserve(timeout = nil)
+      if timeout
+        @conn.send(:'reserve-with-timeout', timeout)
+      else
+        @conn.send(:reserve)
+      end
+      add_deferrable
+    end
+
+    def each_job(&block)
+      work = Proc.new do
+        r = reserve
+        r.callback do |job|
+          block.call(job)
+          EM.next_tick { work.call }
+        end
+      end
+      work.call
+    end
+
+    def stats(type = nil, val = nil)
+      case(type)
+      when nil then @conn.send(:stats)
+      when :tube then @conn.send(:'stats-tube', val)
+      when :job then @conn.send(:'stats-job', val.jobid)
+      else raise EMJack::InvalidCommand.new
+      end
+      add_deferrable
+    end
+
+    def list(type = nil)
+      case(type)
+      when nil then @conn.send(:'list-tubes')
+      when :used then @conn.send(:'list-tube-used')
+      when :watched then @conn.send(:'list-tubes-watched')
+      else raise EMJack::InvalidCommand.new
+      end
+      add_deferrable
+    end
+
+    def delete(job)
+      return if job.nil?
+      @conn.send(:delete, job.jobid)
+      add_deferrable
+    end
+    
+    def release(job)
+      return if job.nil?
+      @conn.send(:release, job.jobid, 0, 0)
+      add_deferrable
+    end
+    
+    def put(msg, opts = {})
+      pri = (opts[:priority] || 65536).to_i
+      if pri< 0
+         pri = 65536
+      elsif pri > (2 ** 32)
+        pri = 2 ** 32
+      end
+      
+      delay = (opts[:delay] || 0).to_i
+      delay = 0 if delay < 0
+      
+      ttr = (opts[:ttr] || 300).to_i
+      ttr = 300 if ttr < 0
+      
+      m = msg.to_s
+      
+      @conn.send_with_data(:put, m, pri, delay, ttr, m.length)
+      add_deferrable
+    end
+  
+    def connected
+      @retries = 0
+    end
+
+    def disconnected
+      # XXX I think I need to run out the deferrables as failed here
+      # since the connection was dropped
+
+      raise EMJack::Disconnected if @retries >= RETRY_COUNT
+      @retries += 1
+      EM.add_timer(1) { @conn.reconnect(@host, @port) }
+    end
+
+    def add_deferrable
+      df = EM::DefaultDeferrable.new
+      df.errback { |err| puts "ERROR: #{err}" }
+      
+      @deferrables.push(df)
+      df
+    end
+  
+    def received(data)
+      @data << data
+
+      until @data.empty?
+        idx = @data.index(/\r\n/)
+        break if idx.nil?
+
+        first = @data[0..(idx + 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 /^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 = @data[(@data.index(/\r\n/) + 2)..-1]
+        @data = "" if @data.nil?
+      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,23 @@
+module EMJack
+  class Job
+    attr_accessor :jobid, :body, :ttr, :conn
+    
+    def initialize(conn, jobid, body)
+      @conn = conn
+      @jobid = jobid.to_i
+      @body = body
+    end
+    
+    def delete
+      @conn.delete(self)
+    end
+    
+    def stats
+      @conn.stats(:job, self)
+    end
+
+    def to_s
+      "#{@jobid} -- #{body.inspect}"
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: em-jack
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- dan sinclair
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-11 00:00:00 -06: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: An evented Beanstalk client.
+email: dj2@everburning.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- COPYING
+- 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
+has_rdoc: true
+homepage: http://github.com/dj2/em-jack/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- EM-Jack Documentation
+- --main
+- README.rdoc
+- --line-numbers
+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: An evented Beanstalk client.
+test_files: []
+