ayl-beanstalk 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,22 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem 'ayl', ">= 0.1.0"
+gem 'beanstalk-client', ">= 1.1.0"
+gem 'daemons', ">= 1.1.0"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.3.0"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.6.4"
+  gem "rcov", ">= 0"
+  gem 'pry'
+end
+
+group :test do
+  gem 'rails', ">= 3.0.0"
+  gem 'pry'
+end

data/Gemfile.lock

@@ -0,0 +1,125 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.1.2)
+      actionpack (= 3.1.2)
+      mail (~> 2.3.0)
+    actionpack (3.1.2)
+      activemodel (= 3.1.2)
+      activesupport (= 3.1.2)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      i18n (~> 0.6)
+      rack (~> 1.3.5)
+      rack-cache (~> 1.1)
+      rack-mount (~> 0.8.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.0)
+    activemodel (3.1.2)
+      activesupport (= 3.1.2)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.2)
+      activemodel (= 3.1.2)
+      activesupport (= 3.1.2)
+      arel (~> 2.2.1)
+      tzinfo (~> 0.3.29)
+    activeresource (3.1.2)
+      activemodel (= 3.1.2)
+      activesupport (= 3.1.2)
+    activesupport (3.1.2)
+      multi_json (~> 1.0)
+    arel (2.2.1)
+    ayl (0.1.0)
+    beanstalk-client (1.1.1)
+    builder (3.0.0)
+    coderay (0.9.8)
+    daemons (1.1.4)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    git (1.2.5)
+    hike (1.2.1)
+    i18n (0.6.0)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    json (1.6.1)
+    mail (2.3.0)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    method_source (0.6.7)
+      ruby_parser (>= 2.3.1)
+    mime-types (1.17.2)
+    multi_json (1.0.3)
+    polyglot (0.3.3)
+    pry (0.9.7.4)
+      coderay (~> 0.9.8)
+      method_source (~> 0.6.7)
+      ruby_parser (>= 2.3.1)
+      slop (~> 2.1.0)
+    rack (1.3.5)
+    rack-cache (1.1)
+      rack (>= 0.4)
+    rack-mount (0.8.3)
+      rack (>= 1.0.0)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.1.2)
+      actionmailer (= 3.1.2)
+      actionpack (= 3.1.2)
+      activerecord (= 3.1.2)
+      activeresource (= 3.1.2)
+      activesupport (= 3.1.2)
+      bundler (~> 1.0)
+      railties (= 3.1.2)
+    railties (3.1.2)
+      actionpack (= 3.1.2)
+      activesupport (= 3.1.2)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    rdoc (3.11)
+      json (~> 1.4)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    ruby_parser (2.3.1)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.8)
+    slop (2.1.0)
+    sprockets (2.1.1)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.31)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ayl (>= 0.1.0)
+  beanstalk-client (>= 1.1.0)
+  bundler (>= 1.0.0)
+  daemons (>= 1.1.0)
+  jeweler (>= 1.6.4)
+  pry
+  rails (>= 3.0.0)
+  rcov
+  rspec (>= 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 j0hnds@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,20 @@
+= ayl-beanstalk
+
+This gem provides a reference implementation of a beanstalk Engine for the
+{ayl}[https://github.com/j0hnds/ayl] gem.
+
+== Contributing to ayl-beanstalk
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 j0hnds@gmail.com. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ayl-beanstalk"
+  gem.homepage = "http://github.com/j0hnds/ayl-beanstalk"
+  gem.license = "MIT"
+  gem.summary = %Q{Ayl extension to provide beanstalk support.}
+  gem.description = %Q{Ayl extension to provide beanstalk support.}
+  gem.email = "j0hnds@gmail.com"
+  gem.authors = ["j0hnds@gmail.com"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ayl-beanstalk #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/ayl_beanstalk

@@ -0,0 +1,281 @@
+#!/usr/bin/env ruby
+#
+# Use this script to look at the current beanstalk information. For help
+# running this script, enter 'beastalk_info.rb --help' on the command line.
+#
+require 'date'
+require 'optparse'
+require 'beanstalk-client'
+
+SLEEP_COMMAND = {
+  :type => :rails,
+  :code => 'Kernel.sleep(20)' # This message will cause the worker to sleep for 20 seconds
+}
+
+#
+# This class provides the commands for the script. Each public instance method
+# on the class is exposed as a command by the script. So, for example, if the
+# user specifies 'beanstalk_info.rb statistics' on the command-line, the script
+# will invoke the BeanstalkCommander#statistics method.
+#
+# When the user asks the script for help ('beanstalk_info.rb --help'), the help
+# implementation will ask for the public instance methods for the BeanstalkCommander
+# class so that we can present the user with the valid commands
+#
+class BeanstalkCommander
+
+  def initialize(host, port, tube)
+    @host = host
+    @port = port
+    @tube = tube
+  end
+
+  #
+  # Lists the statistics for the specified job number
+  #
+  def job_statistics(job_number)
+    raise "Must specify a job number to get the statistics for" unless job_number
+    format_statistics(pool.open_connections.first.job_stats(job_number))
+  end
+
+  #
+  # Lists the statistics for the current tube on beanstalk
+  #
+  def tube_statistics(*args)
+    puts "Statistics for Tube: #{@tube}"
+    format_statistics(pool.stats_tube(@tube))
+  end
+
+  #
+  # Lists the overall statistics for beanstalk
+  #
+  def statistics(*args)
+    puts "Overall Statistics"
+    puts "------------------"
+    format_statistics(pool.stats)
+  end
+
+  #
+  # Lists the tubes active on beanstalk
+  #
+  def list_tubes(*args)
+    tubes = pool.list_tubes
+    puts "Tubes in use"
+    puts "------------"
+    tubes.each_pair do | host, tubes |
+      puts host
+      tubes.each { | tube | puts " - #{tube}" }
+    end
+  end
+
+  #
+  # Displays the job information for the specified job id without
+  # reserving the job or removing it from the queue.
+  #
+  def peek_job(job_number)
+    raise "Must specify a job number to peek" unless job_number
+    job = pool.peek_job(job_number)
+    format_job(job)
+  end
+
+  #
+  # Deletes the job with the specified job id.
+  #
+  def delete(job_number)
+    raise "Must specify a job number to delete" unless job_number
+    pool.open_connections.first.delete(job_number)
+  end
+
+  #
+  # Displays the most current job on the ready queue
+  #
+  def peek_ready(*args)
+    pool.use(@tube)
+    job = pool.peek_ready
+    format_job(job)
+  end
+
+  #
+  # Kick any buried/delayed jobs in te queue
+  #
+  def kick(*args)
+    pool.use(@tube)
+    pool.open_connections.first.kick 1
+  end
+
+  #
+  # Displays the most current job on the delayed queue
+  #
+  def peek_delayed(*args)
+    pool.use(@tube)
+    job = pool.peek_delayed
+    format_job(job)
+  end
+
+  #
+  # Displays the most current job on the buried queue
+  #
+  def peek_buried(*args)
+    pool.use(@tube)
+    job = pool.peek_buried
+    format_job(job)
+  end
+
+  #
+  # Puts a generic job on the queue (job is specified on the command line)
+  #
+  def put_job(job_body)
+    raise "Must specify a job body to put" unless job_body
+    puts "Putting (#{job_body}) on tube: #{@tube}"
+    pool.use(@tube)
+    pool.put(job_body)
+    puts "Job was put"
+  end
+
+  def put_ayl_job(job_body)
+    raise "Must specify a job body to put" unless job_body
+    puts "Putting (#{job_body}) on tube: #{@tube}"
+    pool.put({:type => :ayl, :code => job_body}.to_yaml)
+    puts "Job was put"
+  end
+
+  def put_sleep_job(*args)
+    puts "Putting job on tube '#{@tube}' that will sleep for 20 seconds."
+    pool.use(@tube)
+    pool.put(SLEEP_COMMAND.to_yaml)
+  end
+
+  #
+  # Reserves the current job on the queue, displays it, and removes it from the
+  # queue. The operation is performed against the current queue.
+  #
+  def eat_job(*args)
+    # Reserve the next job on the queue
+    pool.watch(@tube)
+    job = pool.reserve(10)
+    raise "No job to reserve" unless job
+    puts "Reserved job"
+    format_job(job)
+    job.delete
+    puts "Deleted job"
+  end
+
+  #
+  # General purpose tube cleaning mechanism. This allows you to move all the jobs
+  # from one tube to another within beanstalk.
+  # The tube specified on the command line (-t tube), will be used as the 'from-tube' and
+  # the argument to the move_jobs command is the 'to-tube'. When done, you will be a 
+  # a time-out error (because the 'reserve' command timed out without finding a job).
+  # 
+  # It is fast and awesome.
+  #
+  def move_jobs(to_tube)
+    pool.watch(@tube)
+    pool.use(to_tube)
+    while true
+      job = pool.reserve(0) 
+      if job
+        pool.put(job.body)
+        job.delete
+      else
+        break
+      end
+    end
+  end
+
+  private
+
+  #
+  # Returns the connected beanstalk pool
+  #
+  def pool
+    @pool ||= Beanstalk::Pool.new(["#{@host}:#{@port}"])
+  end
+
+  #
+  # Formats the specified job. Can handle the job returned as a hash and as
+  # a job object.
+  #
+  def format_job(job)
+    if job.nil?
+      puts "No job..."
+    elsif job.is_a?(Hash)
+      job.each_pair do | host, job |
+        format_job(job)
+      end
+    else
+      puts "Job: #{job.id}: #{job.body}"
+    end
+  end
+
+  #
+  # Standardized statistics formatting for both tube and general statistics.
+  #
+  def format_statistics(statistics)
+    statistics.keys.sort.each do | key |
+      puts format("%-25s => %13s", key, statistics[key]) if statistics[key].is_a?(Fixnum)
+      puts format("%-25s => %-13s", key, statistics[key]) if statistics[key].is_a?(String)
+    end
+  end
+end
+
+BEANSTALK_HOST_DEFAULT = 'localhost'
+BEANSTALK_PORT_DEFAULT = 11300
+DEFAULT_APP_TUBE_NAME = "default"
+
+options = {}
+
+# Set up the options supported by the script
+optparse = OptionParser.new do | opts |
+
+  # Set a banner, displayed at the top of the help screen
+  opts.banner = "Usage: #{$0} [options] command"
+
+  options[:host] = BEANSTALK_HOST_DEFAULT
+  opts.on '-h', '--host HOST', "Specify the host running beanstalk. Default (#{BEANSTALK_HOST_DEFAULT})" do | host |
+    options[:host] = host
+  end
+
+  options[:port] = BEANSTALK_PORT_DEFAULT
+  opts.on '-p', '--port PORT', "Specify the beanstalk port number. Default (#{BEANSTALK_PORT_DEFAULT})" do | port |
+    options[:port] = port.to_i
+  end
+
+  options[:tube] = DEFAULT_APP_TUBE_NAME
+  opts.on '-t', '--tube TUBE', "Specify the tube name. Default (#{DEFAULT_APP_TUBE_NAME})" do | tube |
+    options[:tube] = tube
+  end
+
+  opts.on '-h', '--help', 'Display the help message' do
+    puts opts
+    puts
+    puts "Valid Commands: "
+    # The false parameter in the instance_methods call is used to eliminate methods from the
+    # super-classes.
+    BeanstalkCommander.instance_methods(false).each do | command |
+      puts " - #{command}"
+    end
+    puts
+    exit
+  end
+
+end
+
+# Parse out the command line
+optparse.parse!
+
+begin
+  beanstalker = BeanstalkCommander.new(options[:host],
+                                       options[:port], 
+                                       options[:tube])
+
+  raise "Must specify a command to execute." if ARGV.empty?
+  command = ARGV.first
+  raise "Invalid command: #{command}" unless beanstalker.respond_to?(command)
+
+  arguments = ARGV[1..-1]
+  beanstalker.send(command, *arguments)
+rescue Exception => ex
+  puts "Error: #{ex.message}"
+  exit
+end

data/bin/ayl_worker

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'ayl-beanstalk/command_line'
+
+BASE_EXIT_CODE = 64
+NO_APP_PATH_SPECIFIED = BASE_EXIT_CODE + 0
+
+options = Ayl::CommandLine.parse!
+
+if options[:app_path].nil?
+  puts "Must specify an application path"
+  exit(NO_APP_PATH_SPECIFIED)
+end
+
+if options[:rails_app]
+  require 'rails' 
+  ENV['RAILS_ENV'] = options[:env]
+end
+
+require File.join(options[:app_path], options[:app_require])
+
+Ayl::MessageOptions.default_queue_name = options[:tube]
+
+worker = Ayl::Engine.get_active_engine.worker
+worker.eval_binding = binding
+
+worker.process_messages

data/bin/ayl_worker_control

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'daemons'
+require 'ayl-beanstalk/command_line'
+
+sdir = File.dirname(File.absolute_path($0))
+sname = File.basename($0).gsub('_control', '')
+spath = File.join(sdir, sname)
+
+options = Ayl::CommandLine.parse! Ayl::CommandLine.grab_app_arguments
+
+raise "Must specify the path to the PID file" if options[:pid_path].nil?
+raise "PID path does not exist" if !File.exists?(options[:pid_path])
+
+Daemons.run(spath, :log_dir => '/tmp', :log_output => true, :dir_mode => :normal, :dir => options[:pid_path])

data/lib/ayl-beanstalk.rb

@@ -0,0 +1,5 @@
+require 'ayl'
+require 'beanstalk-client'
+require 'ayl-beanstalk/pool'
+require 'ayl-beanstalk/engine'
+require 'ayl-beanstalk/worker'

data/lib/ayl-beanstalk/command_line.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+
+module Ayl
+
+  module CommandLine
+
+    BEANSTALK_TUBE_DEFAULT = 'default'
+    APP_REQUIRE_DEFAULT = 'config/environment'
+    RAILS_ENVIRONMENT_DEFAULT = 'production'
+
+    MARKER = '--'
+
+    def self.grab_app_arguments(argv=ARGV)
+      marker_index = argv.index(MARKER)
+      raise "No argument marker found!" if marker_index.nil?
+      argv[marker_index + 1..-1]
+    end
+
+    def self.parse!(argv=ARGV)
+      {}.tap do | options |
+
+        optparse = OptionParser.new do | opts |
+          
+          # Set a banner, displayed at the top of the help screen.
+          opts.banner = "Usage: #{$0} [options]"
+
+          options[:tube] = BEANSTALK_TUBE_DEFAULT
+          opts.on '-t', '--tube TUBE', "Specify the beanstalk tube to listen to. Default (#{BEANSTALK_TUBE_DEFAULT})." do |tube|
+            options[:tube] = tube
+          end
+
+          options[:env] = RAILS_ENVIRONMENT_DEFAULT
+          opts.on '-e', '--environment ENVIRONMENT', "Specify the Rails environment to use" do |environment|
+            options[:env] = environment
+          end
+
+          options[:app_path] = nil
+          opts.on '-a', '--app-path APP_PATH', "Specify the path to the rails app" do |app_path|
+            options[:app_path] = app_path
+          end
+
+          options[:rails_app] = false
+          opts.on '-r', '--rails', "Indicate that we are starting a rails application" do 
+            options[:rails_app] = true
+          end
+
+          options[:app_require] = APP_REQUIRE_DEFAULT
+          opts.on '-c', '--require APP_REQUIRE', "The file to require when the worker starts up" do | app_require |
+            options[:app_require] = app_require
+          end
+
+          opts.on '-p', '--pid-path PID_PATH', "The path to the pid file" do | pid_path |
+            options[:pid_path] = pid_path
+          end
+
+          opts.on '-h', '--help', 'Display the help message' do
+            puts opts
+            exit(0)
+          end
+        end
+
+        optparse.parse!(argv)
+      end # End of .tap
+
+    end
+
+  end
+
+end

data/lib/ayl-beanstalk/engine.rb

@@ -0,0 +1,50 @@
+module Ayl
+
+  module Beanstalk
+
+    class Engine
+      include Ayl::Logging
+      include Ayl::Beanstalk::Pool
+
+      def initialize(host='localhost', port=11300)
+        logger.info "#{self.class.name}.initialize(#{host.inspect}, #{port})"
+        @host = host
+        @port = port
+      end
+
+      def asynchronous?() true end
+
+      def is_connected?
+        connected = true
+        begin
+          pool
+        rescue ::Beanstalk::NotConnected => ex
+          logger.error "#{self.class.name} not connected error: #{ex}"
+          connected = false
+        end
+        connected
+      end
+
+      def submit(message)
+        log_call(:submit) do
+          begin
+            pool.use(message.options.queue_name)
+            code = message.to_rrepr
+            logger.info "#{self.class.name} submitting '#{code}' to tube '#{message.options.queue_name}'"
+            pool.yput(message.to_hash, message.options.priority, message.options.delay, message.options.time_to_run)
+          rescue Exception => ex
+            logger.error "Error submitting message to beanstalk: #{ex}"
+          end
+        end
+      end
+
+      def worker
+        Ayl::Beanstalk::Worker.new(@host, @port)
+      end
+
+    end
+
+    
+  end
+
+end

data/lib/ayl-beanstalk/pool.rb

@@ -0,0 +1,15 @@
+module Ayl
+
+  module Beanstalk
+
+    module Pool
+
+      def pool
+        @pool ||= ::Beanstalk::Pool.new([ "#{@host}:#{@port}" ])
+      end
+
+    end
+
+  end
+
+end

data/lib/ayl-beanstalk/worker.rb

@@ -0,0 +1,46 @@
+module Ayl
+
+  module Beanstalk
+
+    class Worker < Ayl::Worker
+      include Ayl::Logging
+      include Ayl::Beanstalk::Pool
+
+      def initialize(host='localhost', port=11300)
+        logger.info "#{self.class.name}.initialize(#{host.inspect}, #{port})"
+        @host = host
+        @port = port
+      end
+
+      def process_messages
+        logger.info "#{self.class.name} entering process_messages loop"
+        # trap('TERM') { puts "## Got the term signal"; @stop = true }
+        # trap('INT') { puts "## Got the int signal"; @stop = true }
+        # Set the queue that we will be watching
+        pool.watch(Ayl::MessageOptions.default_queue_name)
+        while true
+          break if @stop
+          job = pool.reserve
+          break if job.nil?
+          begin
+            process_message(Ayl::Message.from_hash(job.ybody))
+            job.delete
+          rescue Ayl::UnrecoverableMessageException => ex
+            logger.error "#{self.class.name} Unrecoverable exception in process_messages: #{ex}"
+            job.delete
+          rescue Exception => ex
+            logger.error "#{self.class.name} Exception in process_messages: #{ex}\n#{ex.backtrace.join("\n")}"
+            if job.age > 60
+              job.delete
+            else
+              job.decay
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/ayl_worker_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'optparse'
+require 'ayl-beanstalk/command_line'
+
+describe "ayl_worker script" do
+
+  before(:each) do
+    ARGV.clear
+    @ayl_script = File.join(File.dirname(File.expand_path(__FILE__)), '../bin/ayl_worker')
+  end
+
+  context "handling command line" do
+
+    it "requires that an application path be specified" do
+      Object.any_instance.stub(:puts)
+      lambda { load(@ayl_script, true) }.should exit_with_code(64)
+    end
+
+    it "should exit with a status code of 0 if help is invoked" do
+      ARGV << '--help'
+      Ayl::CommandLine.stub(:puts)
+      lambda { load(@ayl_script, true) }.should exit_with_code(0)
+    end
+
+    it "should exit when an invalid argument is specified" do
+      ARGV << '--not-real'
+
+      lambda { load(@ayl_script, true) }.should raise_error(OptionParser::InvalidOption)
+    end
+
+    it "should set the correct tube name when specified on the command line" do
+      ARGV.concat [ "-a", "support", "-t", "the-tube" ]
+      
+      Ayl::MessageOptions.should_receive(:default_queue_name=).with('the-tube')
+
+      mock_worker = mock("Worker")
+      mock_worker.should_receive(:process_messages)
+      mock_worker.should_receive(:eval_binding=)
+
+      mock_active_engine = mock("ActiveEngine")
+      mock_active_engine.should_receive(:worker).and_return(mock_worker)
+
+      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_active_engine)
+
+      load(@ayl_script, true)
+    end
+
+    it "should set the default tube name when not specified on the command line" do
+      ARGV.concat [ "-a", "support" ]
+      
+      Ayl::MessageOptions.should_receive(:default_queue_name=).with('default')
+
+      mock_worker = mock("Worker")
+      mock_worker.should_receive(:process_messages)
+      mock_worker.should_receive(:eval_binding=)
+
+      mock_active_engine = mock("ActiveEngine")
+      mock_active_engine.should_receive(:worker).and_return(mock_worker)
+
+      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_active_engine)
+
+      load(@ayl_script, true)
+    end
+
+    it "should default to a rails production environment if not specified" do
+      ARGV.concat [ "-a", "support", "-r" ]
+
+      Ayl::MessageOptions.should_receive(:default_queue_name=).with('default')
+
+      mock_worker = mock("Worker")
+      mock_worker.should_receive(:process_messages)
+      mock_worker.should_receive(:eval_binding=)
+
+      mock_active_engine = mock("ActiveEngine")
+      mock_active_engine.should_receive(:worker).and_return(mock_worker)
+
+      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_active_engine)
+      ENV.should_receive(:[]=).with('RAILS_ENV', 'production')
+
+      load(@ayl_script, true)
+    end
+
+    it "should use the specified rails environment" do
+      ARGV.concat [ "-a", "support", "-r", "-e", "development" ]
+
+      Ayl::MessageOptions.should_receive(:default_queue_name=).with('default')
+
+      mock_worker = mock("Worker")
+      mock_worker.should_receive(:process_messages)
+      mock_worker.should_receive(:eval_binding=)
+
+      mock_active_engine = mock("ActiveEngine")
+      mock_active_engine.should_receive(:worker).and_return(mock_worker)
+
+      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_active_engine)
+      ENV.should_receive(:[]=).with('RAILS_ENV', 'development')
+
+      load(@ayl_script, true)
+    end
+
+  end
+
+end

data/spec/command_line_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'ayl-beanstalk/command_line'
+
+describe Ayl::CommandLine do
+
+  context "when extracting the appropriate arguments from the command line" do
+
+    it "grab only the arguments following the application marker" do
+      raw_argv = %w{ start -- -a path-to-app -r -e development }
+      
+      app_arguments = %w{ -a path-to-app -r -e development }
+
+      Ayl::CommandLine.grab_app_arguments(raw_argv).should == app_arguments
+    end
+
+    it "raise an exception if no application marker exists in the command line arguments" do
+      raw_argv = %w{ start -a path-to-app -r -e development }
+      lambda { Ayl::CommandLine.grab_app_arguments(raw_argv) }.should raise_exception
+    end
+
+  end
+
+  context "when parsing the command line" do
+
+    it "should extract the correct options from the command line when the short options are used" do
+      argv = %w{ -t tube_name -e development -a app_path -r -c config/environment -p pid_path }
+      parsed_options = Ayl::CommandLine.parse!(argv)
+      parsed_options.should == { :tube => 'tube_name', :env => 'development', :app_path => 'app_path', :rails_app => true, :app_require => 'config/environment', :pid_path => 'pid_path' }
+    end
+
+    it "should extract the correct options from the command line when the long options are used" do
+      argv = %w{ --tube tube_name --environment development --app-path app_path --rails --require config/environment --pid-path pid_path }
+      parsed_options = Ayl::CommandLine.parse!(argv)
+      parsed_options.should == { :tube => 'tube_name', :env => 'development', :app_path => 'app_path', :rails_app => true, :app_require => 'config/environment', :pid_path => 'pid_path' }
+    end
+
+    it "should raise an exception if invalid arguments are provided" do
+      argv = %w{ --tuber tube_name --environmen development --apppath app_path --rail --require config/environment --pidpath pid_path }
+      lambda { Ayl::CommandLine.parse!(argv) }.should raise_exception
+    end
+
+  end
+
+end

data/spec/engine_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'beanstalk-client'
+require 'active_record'
+require 'active_record/errors'
+
+describe Ayl::Beanstalk::Engine do
+
+  context "Standard API" do
+
+    before(:each) do
+      Kernel.stub(:puts)
+      @engine = Ayl::Beanstalk::Engine.new
+      @engine.stub_chain(:logger, :info)
+      @engine.stub_chain(:logger, :error)
+    end
+
+    it "should respond true to the asynchronous? message" do
+      @engine.asynchronous?.should be_true
+    end
+
+    it "should return true if it has a valid connection to beanstalk" do
+      mock_pool = mock("Beanstalk::Pool")
+
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+
+      @engine.is_connected?.should be_true
+    end
+
+    it "should return false if it does not have a valid connection to beanstalk" do
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_raise(::Beanstalk::NotConnected)
+
+      @engine.is_connected?.should be_false
+    end
+
+    context "Message Submission" do
+      
+      before(:each) do
+        @msg = Ayl::Message.new(23, :to_s, Ayl::MessageOptions.new, 2)
+      end
+
+      it "should submit the specified message to beanstalk" do
+        mock_pool = mock("Beanstalk::Pool")
+        mock_pool.should_receive(:use).with("default")
+        mock_pool.should_receive(:yput).with( { :type => :ayl, :code => "23.to_s(2)" }, 512, 0, 120)
+
+        ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+
+        @engine.submit(@msg)
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'ayl-beanstalk'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/support/config/environment.rb

@@ -0,0 +1,9 @@
+# This is a fake Rails application environment.
+# DON'T delete
+module Ayl
+
+  module Environment
+
+  end
+
+end

data/spec/support/exit_code_matchers.rb

@@ -0,0 +1,24 @@
+module ExitCodeMatchers
+
+  RSpec::Matchers.define :exit_with_code do | code |
+    actual = nil
+    match do |block|
+      begin
+        block.call
+      rescue SystemExit => ex
+        actual = ex.status
+      end
+      actual and actual == code
+    end
+
+    failure_message_for_should do |block|
+      "expected block to call exit(#{code}) but exit" + (actual.nil? ? " not called" : "(#{actual}) was called")
+    end
+    failure_message_for_should_not do |block|
+      "expected block not to call exit(#{code})"
+    end
+    description do
+      "expect block to call exit(#{code})"
+    end
+  end
+end

data/spec/worker_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'beanstalk-client'
+require 'active_record'
+require 'active_record/errors'
+
+describe Ayl::Beanstalk::Worker do
+
+  context "Message Processing" do
+
+    before(:each) do
+      Kernel.stub(:puts)
+      @worker = Ayl::Beanstalk::Worker.new
+      @worker.stub_chain(:logger, :info)
+      @worker.stub_chain(:logger, :error)
+    end
+    
+    it "should wait for a message to be received from beanstalk and process it" do
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:delete)
+      mock_job.should_receive(:ybody).and_return({ :type => :ayl, :code => "23.to_s(2)" })
+
+      mock_pool = mock("Beanstalk::Pool")
+      mock_pool.should_receive(:watch).with("default")
+      # Returns nil on the second call.
+      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+      
+      mock_message = mock("Ayl::Message")
+      mock_message.should_receive(:evaluate)
+      Ayl::Message.stub(:from_hash).with({ :type => :ayl, :code => "23.to_s(2)" }).and_return(mock_message)
+
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+
+      @worker.process_messages
+      
+    end
+
+    it "should raise an UnrecoverableMessageException when the message body is not a valid hash" do
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:delete)
+      mock_job.should_receive(:ybody).and_return("a string")
+      mock_job.should_not_receive(:age)
+
+      mock_pool = mock("Beanstalk::Pool")
+      mock_pool.should_receive(:watch).with("default")
+      # Returns nil on the second call.
+      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+
+      Ayl::Message.stub(:from_hash).with("a string").and_raise(Ayl::UnrecoverableMessageException)
+
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+
+      @worker.process_messages
+    end
+
+    it "should raise an UnrecoverableJobException when the message body is not a valid job type" do
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:delete)
+      mock_job.should_receive(:ybody).and_return({ :type => :junk, :code => "Dog" })
+      mock_job.should_not_receive(:age)
+
+      mock_pool = mock("Beanstalk::Pool")
+      mock_pool.should_receive(:watch).with("default")
+      # Returns nil on the second call.
+      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+
+      Ayl::Message.stub(:from_hash).with({ :type => :junk, :code => "Dog" }).and_raise(Ayl::UnrecoverableMessageException)
+
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+
+      @worker.process_messages
+    end
+
+    it "should raise an UnrecoverableJobException when there is no code in the message body" do
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:delete)
+      mock_job.should_receive(:ybody).and_return({ :type => :ayl })
+      mock_job.should_not_receive(:age)
+
+      mock_pool = mock("Beanstalk::Pool")
+      mock_pool.should_receive(:watch).with("default")
+      # Returns nil on the second call.
+      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+
+      Ayl::Message.stub(:from_hash).with({ :type => :ayl }).and_raise(Ayl::UnrecoverableMessageException)
+
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+
+      @worker.process_messages
+    end
+
+    it "should decay a job that receives an active-record exception on receipt of message that is less than 60 seconds old" do
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:decay)
+      mock_job.should_receive(:ybody).and_return({ :type => :ayl, :code => "Dog" })
+      mock_job.should_receive(:age).and_return(10)
+
+      mock_pool = mock("Beanstalk::Pool")
+      mock_pool.should_receive(:watch).with("default")
+      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+
+      mock_message = mock("Ayl::Message")
+      mock_message.should_receive(:evaluate).and_raise(ActiveRecord::RecordNotFound)
+      Ayl::Message.stub(:from_hash).with({ :type => :ayl, :code => "Dog" }).and_return(mock_message)
+
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+
+      @worker.process_messages
+    end
+
+    it "should delete a job that receives an active-record exception on receipt of message that is more than 60 seconds old" do
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:delete)
+      mock_job.should_receive(:ybody).and_return({ :type => :ayl, :code => "Dog" })
+      mock_job.should_receive(:age).and_return(65)
+
+      mock_pool = mock("Beanstalk::Pool")
+      mock_pool.should_receive(:watch).with("default")
+      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+
+      mock_message = mock("Ayl::Message")
+      mock_message.should_receive(:evaluate).and_raise(ActiveRecord::RecordNotFound)
+      Ayl::Message.stub(:from_hash).with({ :type => :ayl, :code => "Dog" }).and_return(mock_message)
+
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+
+      @worker.process_messages
+    end
+  end
+
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: ayl-beanstalk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- j0hnds@gmail.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ayl
+  requirement: &87968020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *87968020
+- !ruby/object:Gem::Dependency
+  name: beanstalk-client
+  requirement: &87967750 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *87967750
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &87967500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *87967500
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &87967220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *87967220
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &87966960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *87966960
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &87966690 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *87966690
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &87966350 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *87966350
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &87966010 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *87966010
+description: Ayl extension to provide beanstalk support.
+email: j0hnds@gmail.com
+executables:
+- ayl_beanstalk
+- ayl_worker
+- ayl_worker_control
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/ayl_beanstalk
+- bin/ayl_worker
+- bin/ayl_worker_control
+- lib/ayl-beanstalk.rb
+- lib/ayl-beanstalk/command_line.rb
+- lib/ayl-beanstalk/engine.rb
+- lib/ayl-beanstalk/pool.rb
+- lib/ayl-beanstalk/worker.rb
+- spec/ayl_worker_spec.rb
+- spec/command_line_spec.rb
+- spec/engine_spec.rb
+- spec/spec_helper.rb
+- spec/support/config/environment.rb
+- spec/support/exit_code_matchers.rb
+- spec/worker_spec.rb
+homepage: http://github.com/j0hnds/ayl-beanstalk
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 349899887
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Ayl extension to provide beanstalk support.
+test_files: []