delayed_job_celluloid 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmNjODUyMWU4YjE2ZWE2ZDBjNjk5OTIxM2U0ZTNmNWU2YTcyODczOA==
+  data.tar.gz: !binary |-
+    ZGZjMTFhZmE4ZjhhNTQ5ZjU5YjFiYjM0ZWM0MjA3YTE3N2UzZWU4MQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MjJkYjY2OWFlYmVjZjQ1Zjc0MGI3ODYxYWM5M2UxYmUwNzFkMWQzYWQ0OTlm
+    MjFiYzhhZDU0ZDExNWNjNjY4NGNhMmQ5NGIyNWJiZjA3NmI2YzAwYmQzYzBk
+    YjI0MDZkOGY1YmQ1YzIwMzQ1OGQ1ODhmMGMxODIyMDI0OGUxMGM=
+  data.tar.gz: !binary |-
+    NjAzMDMyNjNlNWQ5Njg1NjA2NzhkMjUxNzRlOTNhMGMwNmI4MzBkYzFlZWRi
+    ZDVhNjg5NmE5ZWM2ZDlkYWEwNGMzZjQxNTQ5NjE5OTRlZGEyOGRmYWJkMWNh
+    MTUxYzRkYjBlMTQ1ZjM1MWRiMmU5Y2JhN2IzMDI3NWMwZjUwZTM=

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+test.sqlite3
+*.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in delayed_job_celluloid.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 tom
+
+MIT License
+
+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.md

@@ -0,0 +1,78 @@
+# DelayedJobCelluloid
+
+Based on awesome gems like Sidekiq and Suckerpunch, DelayedJobCelluloid allows delayed job workers to be run in multiple threads within a single process using the Celluloid actor pattern.  The delayed_job workers by default start a new single-threaded process for each worker.  By running workers in a single multi-threaded process instead, delayed_job_celluloid is more efficient in terms of memory use and speed.
+
+## Installation
+
+Add delayed_job_celluloid to your gem file
+
+	gem 'delayed_job_celluloid
+
+Run bundle install
+
+	bundle install delayed_job_celluloid
+
+To add the startup script to your script directory, run the generator
+
+	rails generate delayed_job_celluloid 	
+
+## Usage
+
+First, make sure you have your preferred delayed job backend installed, for instance delayed_job_activerecord, or delayed_job_mongoid.  See [delayed_job](https://github.com/collectiveidea/delayed_job) for more information.
+
+To start working off of your delayed_job queues simply run the below from your application's root directory
+
+	bundle exec script/delayed_job_celluloid
+
+To specify the number of worker threads to start, pass the -n parameter to the startup script.  For example, the below command would start 5 worker threads.  The default is 2.
+
+	bundle exec script/delayed_job_celluloid -n 5
+	
+One important thing to bear in mind with this is that you should have a database connection pool size that is at least equal to the number of worker threads you are running due to the fact that each thread will need its own connection.  if there are not enough connections available you will get database errors.  You can set this in the database.yml file in your app.
+
+	development:
+  		adapter: postgresql
+  	  	database: dev
+  	  	host: localhost
+  	  	pool: 5
+
+Currently the gem does not support daemonization of the main process because I haven't needed it as I am using it in conjuction with Unicorn on Heroku.  If you are running your app on Heroku, this gem will allow you to run multiple workers in a single Unicorn process.  An example unicorn config is as follows:
+
+	# config/unicorn.rb
+	worker_processes Integer(ENV["WEB_CONCURRENCY"] || 2)
+	timeout 15
+	preload_app true
+
+	before_fork do |server, worker|
+  
+	  #Start the Delayed Job worker inside of a Unicorn process
+	  @delayed_job_celluloid_pid ||= spawn("bundle exec script/delayed_job_celluloid -n 5")
+  
+	  Signal.trap 'TERM' do
+	    puts 'Unicorn master intercepting TERM and sending myself QUIT instead'
+	    Process.kill 'QUIT', Process.pid
+	  end
+
+	  defined?(ActiveRecord::Base) and
+	    ActiveRecord::Base.connection.disconnect!
+	end 
+
+	after_fork do |server, worker|
+  
+	  Signal.trap 'TERM' do
+	    puts 'Unicorn worker intercepting TERM and doing nothing. Wait for master to send QUIT'
+	  end
+
+	  defined?(ActiveRecord::Base) and
+	    ActiveRecord::Base.establish_connection
+	end
+
+If you are interested in adding daemonization to the gem itself, feel free to fork it and submit a pull request.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  #SO MUCH NOISE
+  #test.warning = true
+  test.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :test

data/delayed_job_celluloid.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'delayed_job_celluloid/version'
+
+Gem::Specification.new do |s|
+  s.name          = "delayed_job_celluloid"
+  s.version       = DelayedJobCelluloid::VERSION
+  s.authors       = ["Tom Mooney"]
+  s.email         = ["tmooney3979@gmail.com"]
+  s.description   = %q{run delayed_job workers in multiple threads within a single process}
+  s.summary       = %q{multi-threaded delayed_job workers!}
+  s.homepage      = ""
+  s.license       = "MIT"
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'delayed_job'
+  s.add_dependency 'celluloid'
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "delayed_job_active_record"
+end

data/lib/delayed_job_celluloid/command.rb

@@ -0,0 +1,104 @@
+$stdout.sync = true
+
+require 'optparse'
+require 'celluloid/autostart'
+
+module DelayedJobCelluloid
+  
+  class Shutdown < Interrupt; end
+  
+  class Command
+    
+    attr_accessor :worker_count
+
+    def initialize(args)
+      parse_options(args)
+    end
+  
+    def run
+      self_read, self_write = IO.pipe
+      
+      %w(INT TERM).each do |sig|
+        trap sig do
+          self_write.puts(sig)
+        end
+      end
+      
+      require 'delayed_job_celluloid/launcher'
+      @launcher = Launcher.new(@options, @worker_count)
+      
+      begin
+        @launcher.run
+        
+        while readable_io = IO.select([self_read])
+          signal = readable_io.first[0].gets.strip
+          handle_signal(signal)
+        end
+      rescue Interrupt
+        @launcher.stop
+        exit(0)
+      end
+    end
+    
+    def handle_signal(signal)
+      case signal
+      when 'INT','TERM'
+        raise Interrupt
+      end
+        
+    end
+    
+    def parse_options(args)
+      @options = {
+        :quiet => true,
+        :timeout => 8
+      }
+
+      @worker_count = 2
+
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
+
+        opts.on('-h', '--help', 'Show this message') do
+          puts opts
+          exit 1
+        end
+        opts.on('-e', '--environment=NAME', 'Specifies the environment to run this delayed jobs under (test/development/production).') do |e|
+          STDERR.puts "The -e/--environment option has been deprecated and has no effect. Use RAILS_ENV and see http://github.com/collectiveidea/delayed_job/issues/#issue/7"
+        end
+        opts.on('--min-priority N', 'Minimum priority of jobs to run.') do |n|
+          @options[:min_priority] = n
+        end
+        opts.on('--max-priority N', 'Maximum priority of jobs to run.') do |n|
+          @options[:max_priority] = n
+        end
+        opts.on('-n', '--number_of_workers=workers', "Number of worker threads to start") do |worker_count|
+          @worker_count = worker_count.to_i rescue 1
+        end
+        opts.on('--sleep-delay N', "Amount of time to sleep when no jobs are found") do |n|
+          @options[:sleep_delay] = n.to_i
+        end
+        opts.on('--read-ahead N', "Number of jobs from the queue to consider") do |n|
+          @options[:read_ahead] = n
+        end
+        opts.on('-p', '--prefix NAME', "String to be prefixed to worker process names") do |prefix|
+          @options[:prefix] = prefix
+        end
+        opts.on('--queues=queues', "Specify which queue DJ must look up for jobs") do |queues|
+          @options[:queues] = queues.split(',')
+        end
+        opts.on('--queue=queue', "Specify which queue DJ must look up for jobs") do |queue|
+          @options[:queues] = queue.split(',')
+        end
+        opts.on('--exit-on-complete', "Exit when no more jobs are available to run. This will exit if all jobs are scheduled to run in the future.") do
+          @options[:exit_on_complete] = true
+        end
+        opts.on('-t', '--timeout NUM', "Shutdown timeout") do |prefix|
+          @options[:timeout] = Integer(arg)
+        end
+      end
+      @args = opts.parse!(args)
+    end
+    
+  end
+end

data/lib/delayed_job_celluloid/launcher.rb

@@ -0,0 +1,20 @@
+require_relative 'manager'
+
+module DelayedJobCelluloid
+  class Launcher
+    attr_reader :manager, :options
+    def initialize(options, worker_count)
+      @options = options
+      @manager = Manager.new(options, worker_count)
+    end
+
+    def run
+      manager.async.start
+    end
+
+    def stop
+      manager.async.stop(options[:timeout])
+      manager.wait(:shutdown)
+    end
+  end
+end

data/lib/delayed_job_celluloid/manager.rb

@@ -0,0 +1,113 @@
+require_relative 'worker'
+
+module DelayedJobCelluloid
+  class Manager
+    include Celluloid
+    include Logger
+    
+    trap_exit :worker_died
+    
+    attr_reader :ready
+    attr_reader :busy
+    
+    def initialize(options={}, worker_count)
+      @options = options
+      @worker_count = worker_count || 1
+      @done_callback = nil
+
+      @in_progress = {}
+      @threads = {}
+      @done = false
+      @busy = []
+      @ready = @worker_count.times.map do
+        w = Worker.new_link(options, current_actor)
+        w.proxy_id = w.object_id
+        w
+      end
+    end
+    
+    def start
+      @ready.each_with_index do |worker, index|
+        worker.name = "delayed_job.#{index}"
+        worker.async.start 
+      end
+    end
+
+    def stop(timeout)   
+      @done = true
+            
+      info "Shutting down #{@ready.size} idle workers"
+      @ready.each do |worker|
+        worker.terminate if worker.alive?
+      end
+      @ready.clear
+      
+      return after(0) { signal(:shutdown) } if @busy.empty?
+      hard_shutdown_in timeout
+    end
+    
+    def work(worker)
+      @ready.delete(worker)
+      @busy << worker
+    end
+    
+    def worker_done(worker)
+      @busy.delete(worker)
+      if stopped?
+        worker.terminate if worker.alive?
+        signal(:shutdown) if @busy.empty?
+      else
+        @ready << worker if worker.alive?
+      end
+    end
+    
+    def worker_died(worker, reason)
+      debug "#{worker.inspect} died because of #{reason}" unless reason.nil?
+      @busy.delete(worker)
+      unless stopped?
+        worker = Worker.new_link(@options, current_actor)
+        worker.name = "restarted"
+        @ready << worker
+        worker.async.start
+      else
+        signal(:shutdown) if @busy.empty?
+      end
+    end
+
+    def stopped?
+      @done
+    end
+    
+    def real_thread(proxy_id, thr)
+      @threads[proxy_id] = thr
+    end
+    
+    def hard_shutdown_in(delay)
+      info "Pausing up to #{delay} seconds to allow workers to finish..." 
+
+      after(delay) do
+        # We've reached the timeout and we still have busy workers.
+        # They must die but their messages shall live on.
+        info "Still waiting for #{@busy.size} busy workers"
+
+        # Re-enqueue terminated jobs
+        # NOTE: You may notice that we may push a job back to redis before
+        # the worker thread is terminated. This is ok because Sidekiq's
+        # contract says that jobs are run AT LEAST once. Process termination
+        # is delayed until we're certain the jobs are back in Redis because
+        # it is worse to lose a job than to run it twice.
+        #Sidekiq::Fetcher.strategy.bulk_requeue(@in_progress.values)
+
+        debug "Terminating #{@busy.size} busy worker threads"
+        @busy.each do |worker|
+          if worker.alive? && t = @threads.delete(worker.object_id)
+            t.raise Shutdown
+          end
+        end
+
+        after(0) { signal(:shutdown) }
+      end
+    end
+    
+  end
+end

data/lib/delayed_job_celluloid/version.rb

@@ -0,0 +1,3 @@
+module DelayedJobCelluloid
+  VERSION = "0.1.0"
+end

data/lib/delayed_job_celluloid/worker.rb

@@ -0,0 +1,85 @@
+require 'delayed_job'
+require 'delayed/performable_mailer'
+
+module DelayedJobCelluloid
+  class Worker < Delayed::Worker
+    include Celluloid
+
+    attr_accessor :proxy_id
+
+    def initialize(options={}, manager)
+      @manager = manager
+      super(options)
+    end
+
+    def name
+      return @name unless @name.nil?
+    end
+
+    # Sets the name of the worker.
+    def name=(val)
+      @name = val
+    end
+    
+    def start
+      begin
+        say "Starting job worker"
+        @manager.async.real_thread(proxy_id, Thread.current)
+        self.class.lifecycle.run_callbacks(:execute, self) do
+          loop do
+              self.class.lifecycle.run_callbacks(:loop, self) do
+                @realtime = Benchmark.realtime do
+                  @result = work_off
+                end
+              end
+
+              count = @result.sum
+
+              if count.zero?
+                if self.class.exit_on_complete
+                  say "No more jobs available. Exiting"
+                  break
+                else
+                  sleep(self.class.sleep_delay) unless stop?
+                end
+              else
+                say "#{count} jobs processed at %.4f j/s, %d failed" % [count / @realtime, @result.last]
+              end
+
+              break if stop?
+          end
+        end
+        rescue DelayedJobCelluloid::Shutdown
+      end
+    end
+    
+    def stop
+      say "Exiting..."
+      @exit = true
+    end
+    
+    def work_off(num = 100)
+      success, failure = 0, 0
+      
+      @manager.async.work(current_actor)
+      num.times do
+        case reserve_and_run_one_job
+        when true
+          success += 1
+        when false
+          failure += 1
+        else
+          @manager.async.worker_done(current_actor)
+          break # leave if no work could be done
+        end
+        if stop?
+          @manager.async.worker_done(current_actor)
+          break #leave if we're exiting
+        end
+      end
+
+      return [success, failure]
+    end
+    
+  end
+end

data/lib/delayed_job_celluloid.rb

@@ -0,0 +1,13 @@
+require 'delayed_job_celluloid/command'
+require 'delayed_job_celluloid/launcher'
+require 'delayed_job_celluloid/manager'
+require 'delayed_job_celluloid/worker'
+
+module DelayedJobCelluloid
+  class << self
+    attr_accessor :logger
+  end
+end
+
+DelayedJobCelluloid.logger = Logger.new(STDERR)
+Celluloid.logger = DelayedJobCelluloid.logger  

data/lib/generators/delayed_job_celluloid/delayed_job_celluloid_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators'
+
+class DelayedJobCelluloidGenerator < Rails::Generators::Base
+
+  self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+
+  def create_executable_file
+    template "script", "script/delayed_job_celluloid"
+    chmod "script/delayed_job_celluloid", 0755
+  end
+end

data/lib/generators/delayed_job_celluloid/templates/script

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'environment'))
+require 'delayed_job_celluloid/command'
+DelayedJobCelluloid::Command.new(ARGV).run

data/spec/command_test.rb

@@ -0,0 +1,18 @@
+require_relative 'spec_helper'
+require_relative 'test_job'
+
+class CommandSpec < Minitest::Unit::TestCase
+  describe 'command' do
+    
+    it "starts workers" do  
+      i = 0  
+      while i < 10 do
+        test = TestJob.new
+        test.delay.test_this
+        i += 1
+      end
+      DelayedJobCelluloid::Command.new(ARGV << '-n 2').run
+    end
+    
+  end
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: "spec/db/test.sqlite3"

data/spec/launcher_spec.rb

@@ -0,0 +1,22 @@
+require_relative 'spec_helper'
+require_relative 'test_job'
+
+class LauncherSpec < Minitest::Unit::TestCase
+  describe 'launcher' do
+    
+    it "starts working jobs" do    
+      DelayedJobCelluloid::Worker.exit_on_complete = true
+        
+      i=0
+      while i < 10 do
+        test = TestJob.new
+        test.delay.test_this
+        i += 1
+      end
+      
+      launcher = DelayedJobCelluloid::Launcher.new({}, 2)
+      launcher.run
+    end
+    
+  end
+end

data/spec/manager_spec.rb

@@ -0,0 +1,88 @@
+require_relative 'spec_helper'
+
+class ManagerSpec < Minitest::Unit::TestCase
+  describe 'manager' do
+  
+    it "creates N worker instances" do
+      mgr = DelayedJobCelluloid::Manager.new({}, 3)
+      assert_equal mgr.ready.size, 3
+    end
+  
+    it 'starts specified number of workers upon start' do
+      worker = Minitest::Mock.new
+      start = Minitest::Mock.new
+      3.times {start.expect(:start, nil, [])}
+      3.times {worker.expect(:async, start, [])}
+    
+      mgr = DelayedJobCelluloid::Manager.new({}, 0)
+    
+      i = 0
+      while i < 3 do
+        worker.expect(:name=, nil, ["delayed_job.#{i}"])
+        mgr.ready << worker
+        i += 1
+      end
+  
+      mgr.start
+    
+      assert_equal mgr.ready.size, 3
+      worker.verify
+      start.verify
+    end
+  
+    it 'stops workers on stop' do
+      worker = Minitest::Mock.new
+      3.times {worker.expect(:terminate, nil, [])}
+      3.times {worker.expect(:alive?, true, [])}
+    
+      mgr = DelayedJobCelluloid::Manager.new({}, 0)
+    
+      i = 0
+      while i < 3 do
+        mgr.ready << worker
+        i += 1
+      end
+  
+      mgr.busy << worker
+  
+      mgr.stop(8)
+    
+      assert_equal mgr.ready.size, 0
+      worker.verify
+    end
+    
+    it 'removes workers from busy list and adds them to ready list on completion' do
+      worker = Minitest::Mock.new
+      worker.expect(:alive?, true, [])
+      
+      mgr = DelayedJobCelluloid::Manager.new({}, 0)
+      mgr.busy << worker
+  
+      assert_equal 0, mgr.ready.size
+      assert_equal 1, mgr.busy.size
+      
+      mgr.worker_done(worker)
+    
+      assert_equal 1, mgr.ready.size
+      assert_equal 0, mgr.busy.size
+      worker.verify
+    end
+    
+    it 'removes workers from busy list on worker_died and starts a new worker' do
+      worker = Minitest::Mock.new
+      
+      mgr = DelayedJobCelluloid::Manager.new({}, 0)
+      mgr.busy << worker
+  
+      assert_equal 0, mgr.ready.size
+      assert_equal 1, mgr.busy.size
+      
+      mgr.worker_died(worker, "test")
+    
+      assert_equal 0, mgr.ready.size
+      assert_equal 1, mgr.busy.size
+      worker.verify
+    end
+  
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'delayed_job_celluloid'
+require 'delayed_job'
+require 'delayed_job_active_record'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/pride'
+require 'rails'
+require 'active_record'
+require 'sqlite3'
+require 'logger'
+require 'celluloid/autostart'
+
+ROOT = File.join(File.dirname(__FILE__), '..')
+RAILS_ROOT = ROOT
+$LOAD_PATH << File.join(ROOT, 'lib')
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/db.log")
+ActiveRecord::Base.establish_connection(config['test'])
+DelayedJobCelluloid::Worker.logger = Logger.new(File.dirname(__FILE__) + "/dj.log")
+
+ActiveRecord::Base.connection.create_table :delayed_jobs, :force => true do |table|
+  table.integer :priority, :default => 0 # Allows some jobs to jump to the front of the queue
+  table.integer :attempts, :default => 0 # Provides for retries, but still fail eventually.
+  table.text :handler # YAML-encoded string of the object that will do work
+  table.string :last_error # reason for last failure (See Note below)
+  table.datetime :run_at # When to run. Could be Time.now for immediately, or sometime in the future.
+  table.datetime :locked_at # Set when a client is working on this object
+  table.datetime :failed_at # Set when all retries have failed (actually, by default, the record is deleted instead)
+  table.string :locked_by # Who is working on this object (if locked)
+  table.string :queue
+  table.timestamps
+end

data/spec/test_job.rb

@@ -0,0 +1,7 @@
+class TestJob
+
+  def test_this
+    sleep(1)
+  end
+
+end

data/spec/worker_spec.rb

@@ -0,0 +1,38 @@
+require_relative 'spec_helper'
+require_relative 'test_job'
+
+DelayedJobCelluloid::Worker.backend = :active_record
+
+class WorkerSpec < Minitest::Unit::TestCase
+    
+  describe "Worker" do
+
+    before :all do
+      DelayedJobCelluloid::Worker.exit_on_complete = true
+    end
+
+    it "runs jobs" do
+      
+      manager = Minitest::Mock.new
+      async = Minitest::Mock.new
+      100.times {async.expect(:work, nil, [Celluloid::ActorProxy])}
+      100.times {async.expect(:worker_done, nil, [Celluloid::ActorProxy])}
+      async.expect(:real_thread, async, [nil, Thread])
+      100.times {manager.expect(:async, async, [])}
+      
+    
+      worker = DelayedJobCelluloid::Worker.new({},manager)
+      test = TestJob.new
+      test.delay.test_this
+      
+      assert_equal 1, Delayed::Job.count
+      
+      worker.start
+
+      assert_equal 0, Delayed::Job.count
+      manager.verify
+      async.verify
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: delayed_job_celluloid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Mooney
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: delayed_job
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: delayed_job_active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: run delayed_job workers in multiple threads within a single process
+email:
+- tmooney3979@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- delayed_job_celluloid.gemspec
+- lib/delayed_job_celluloid.rb
+- lib/delayed_job_celluloid/command.rb
+- lib/delayed_job_celluloid/launcher.rb
+- lib/delayed_job_celluloid/manager.rb
+- lib/delayed_job_celluloid/version.rb
+- lib/delayed_job_celluloid/worker.rb
+- lib/generators/delayed_job_celluloid/delayed_job_celluloid_generator.rb
+- lib/generators/delayed_job_celluloid/templates/script
+- spec/command_test.rb
+- spec/database.yml
+- spec/launcher_spec.rb
+- spec/manager_spec.rb
+- spec/spec_helper.rb
+- spec/test_job.rb
+- spec/worker_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: multi-threaded delayed_job workers!
+test_files:
+- spec/command_test.rb
+- spec/database.yml
+- spec/launcher_spec.rb
+- spec/manager_spec.rb
+- spec/spec_helper.rb
+- spec/test_job.rb
+- spec/worker_spec.rb