shoryuken-later 0.0.3 → 0.0.5

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZmRmMzRlZjhlM2I4YTM3NjhjNDUxOTQxYzYwZTE1ZjZiNGNiMWQwNA==
-  data.tar.gz: !binary |-
-    ZTQwODFkZDI4YmE4NGM2MzZiZjFkM2NmNTViZTk4OWQ3NGI2NzVhYQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NjYxMDExNjQzYjhhNTJmZWE3ZmZmZWMxYjRmN2IwYjU1OTU0Nzg4NTIyOGQx
-    YzM0NzUzNjZjYzAzOTBjNDZiZGEzYTk3ZDU0MjdmM2ZlNmI0OTg5ZWQ4YjM2
-    NWU1Y2U0NDZmMTZkY2QwYjE5MTJlYzJjMmI1MzA5NzVkNGE2YTE=
-  data.tar.gz: !binary |-
-    MzRiYjI0NDUxMGExNzVmMjA3ZDRlNDlkM2E0NzgzZTc1ZGM5YWE2YzY0OGQy
-    Y2Q0N2QwZjEwMzM2YmUxYzMxYjBkYzUxOWQ0ZjFkNjMwOTNhNjM2MzkxMzdi
-    ZWRiOGRlYjk1MTIzM2IzYjU1ZWJkOWJlNWI2OWQxY2JlMWFiNzg=
+SHA1:
+  metadata.gz: 452bf02360d9ab6eb4a73581d937476a0b49c2d1
+  data.tar.gz: 69348f8206e4c630cbc21b62a0dd9aac83051609
+SHA512:
+  metadata.gz: b9392aa905bf2ea5be0211bf485cf157e34d4f8da7fef8a96ec3590d12fdd9b07ebf1ffd9a597871994c227aacd2e1eba9d91dc755f3976cd966bbf3f7f9814c
+  data.tar.gz: f0d5b96a457574ca36a352809f949255fa794ebecf73486e3789e86342e0e357aa6d859c6e56a2ea5416f0f314e097eeef959ca7e44bfd23850d43939ad90b8f

data/README.md

@@ -1,15 +1,26 @@
 # shoryuken-later
 
 A scheduling plugin for [Shoryuken](https://github.com/phstc/shoryuken) that uses [Dynamo DB](https://aws.amazon.com/dynamodb/)
-to delay messages arbitrarily far into the future.
+to schedule messages arbitrarily far into the future.
 
 ## Features
 
-### Supports distributed architectures
+### Integration with Shoryuken::Worker
+
+A new method named `perform_later` is added to `Shoryuken::Worker` allowing messages to be delayed arbitrarily far into the future. If the delay is 15 minutes or less, then the message is enqueued into the specified SQS `:queue` as usual.  Otherwise, the message is inserted into the specified DynamoDB `:schedule_table`.
+
+```ruby
+ require 'shoryuken-later'
 
-An SQS message is *only* queued if a _conditional_ delete of the DDB item is successful. This eliminates any potential race condition, so if more than one `shoryuken-later` process is polling the same schedule table then no redundant SQS messages will be queued.
+ class MyWorker
+   include Shoryuken::Worker
+  
+   shoryuken_options queue: 'default', schedule_table: 'default_schedule'
+ end
 
-NOTE: You shouldn't really _need_ to run more than one process, but if you do it will be safe.
+ # Schedules a message to be processed 30 minutes from now.
+ MyWorker.perform_later(Time.now + 30 * 60, 'Foobar')
+```
 
 ### One or more schedule tables
 
@@ -27,19 +38,21 @@ later:
 You can use the same configuration file for both `Shoryuken` and `Shoryuken::Later`, because the new configuration options are namespaced.
 
 ```yaml
-# These keys are used by both Shoryuken and Shoryuken::Later
+# This key is used by both Shoryuken and Shoryuken::Later
 aws:
   access_key_id:      ...       # or <%= ENV['AWS_ACCESS_KEY_ID'] %>
   secret_access_key:  ...       # or <%= ENV['AWS_SECRET_ACCESS_KEY'] %>
   region:             us-east-1 # or <%= ENV['AWS_REGION'] %>
-logfile: some/path/to/file.log
   
 # This key is only used by Shoryuken::Later
 later:
   delay: 5 * 60   # How frequently to poll the schedule table, in seconds.
-  pidfile: some/path/to/file.pid
   tables:
     - table1
+    
+# These keys are used by both Shoryuken and Shoryuken::Later
+logfile: some/path/to/file.log
+pidfile: some/path/to/file.pid
 
 # These keys are only used by Shoryuken
 concurrency: 3
@@ -47,102 +60,4 @@ delay: 0
 queues:
   - [queue1, 1]
   - [queue2, 2]
-```
-
-## Usage
-
-### Starting the schedule poller
-
-Start the `shoryuken-later` schedule poller with a command like:
-
-```shell
-bundle exec shoryuken-later --config shoryuken.yml
-```
-
-Run it as a daemon inside of your Rails app with a command like: 
-
-```shell
-bundle exec shoryuken-later --config shoryuken.yml --rails --daemon
-```
-
-[Command-line options](https://github.com/joekhoobyar/shoryuken-later/wiki/Command-line-options)
-
-
-### Integration with ActiveJob
-
-A custom ActiveJob adapter can used to support delaying messages arbitrarily far into the future.
-
-```ruby
-# config/application.rb
-config.active_job.queue_adapter = :shoryuken_later
-```
-
-When you use the `:shoryuken_later` queue adapter, jobs to be performed farther than 15 minutes into the future (by setting the `wait` or `wait_until` ActiveJob options), will be inserted into the *default* schedule table.  You can set the default schedule table in an initializer.
-
-```ruby
-# config/initializers/shoryuken_later.rb
-Shoryuken::Later.default_table = "#{Rails.env}_myapp_later"
-```
-
-
-### Integration with Shoryuken::Worker
-
-A new method named `perform_later` is added to `Shoryuken::Worker` allowing messages to be delayed arbitrarily far into the future. If the delay is 15 minutes or less, then the message is enqueued into the specified SQS `:queue` as usual.  Otherwise, the message is inserted into the specified DynamoDB `:schedule_table`.
-
-```ruby
- require 'shoryuken-later'
-
- class MyWorker
-   include Shoryuken::Worker
-  
-   shoryuken_options queue: 'default', schedule_table: 'default_schedule'
- end
-
- # Schedules a message to be processed 30 minutes from now.
- MyWorker.perform_later(Time.now + 30 * 60, 'Foobar')
-```
-
-
-## Requirements
-
-Ruby 1.9 or greater.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'shoryuken-later'
-```
-
-Or to get the latest updates:
-
-```ruby
-gem 'shoryuken-later', github: 'joekhoobyar/shoryuken-later', branch: 'master'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install shoryuken-later
-    
-## Documentation
-
-Learn about using Shoryuken::Later at the [Shoryuken::Later Wiki](https://github.com/joekhoobyar/shoryuken-later/wiki).
-
-Learn about using Shoryuken at the [Shoryuken Wiki](https://github.com/phstc/shoryuken/wiki).
-
-## Credits
-
-[Pablo Cantero](https://github.com/phstc), creator of [Shoryuken](https://github.com/phstc/shoryuken), and [everybody who contributed to it](https://github.com/phstc/shoryuken/graphs/contributors).  I borrowed a lot of code from Shoryuken itself as a shortcut to making this gem.
-
-## Contributing
-
-1. Fork it ( https://github.com/joekhoobyar/shoryuken-later/fork )
-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 a new Pull Request
+```

data/lib/shoryuken/later/active_job_adapter.rb

@@ -1,4 +1,4 @@
-# Practically all of this has been "borrowed" from Shoryuken.
+# Build on top of Shoryuken's ActiveJob adapter.
 
 # @see ActiveJob::QueueAdapter::ShoryukenAdapter
 
@@ -20,20 +20,16 @@ module ActiveJob
     # To use Shoryuken::Later set the queue_adapter config to +:shoryuken_later+.
     #
     #   Rails.application.config.active_job.queue_adapter = :shoryuken_later
-    class ShoryukenLaterAdapter
+    class ShoryukenLaterAdapter < ShoryukenAdapter
+      JobWrapper = ShoryukenAdapter::JobWrapper
+      
       class << self
-        def enqueue(job) #:nodoc:
-          register_worker!(job)
-
-          Shoryuken::Client.send_message(job.queue_name, job.serialize, message_attributes: message_attributes)
-        end
-
         def enqueue_at(job, timestamp) #:nodoc:
           register_worker!(job)
 
           delay = (timestamp - Time.current.to_f).round
           if delay > 15.minutes
-            Shoryuken::Later::Client.put_item(Shoryuken::Later.default_table, perform_at: Time.current.to_i + delay.to_i,
+            Shoryuken::Later::Client.put_item(Shoryuken::Later.default_table, perform_at: delay.to_i,
                                                                               shoryuken_queue: job.queue_name, shoryuken_class: JobWrapper.to_s,
                                                                               shoryuken_args: JSON.dump(body: job.serialize, options: {}))
           else
@@ -41,32 +37,6 @@ module ActiveJob
                                                                           message_attributes: message_attributes)
           end
         end
-
-
-        private
-
-        def register_worker!(job)
-          Shoryuken.register_worker(job.queue_name, JobWrapper)
-        end
-
-        def message_attributes
-          @message_attributes ||= {
-            'shoryuken_class' => {
-              string_value: JobWrapper.to_s,
-              data_type: 'String'
-            }
-          }
-        end
-      end
-
-      class JobWrapper #:nodoc:
-        include Shoryuken::Worker
-
-        shoryuken_options body_parser: :json, auto_delete: true
-
-        def perform(sqs_msg, hash)
-          Base.execute hash
-        end
       end
     end
   end

data/lib/shoryuken/later/cli.rb

@@ -7,7 +7,6 @@ require 'singleton'
 require 'optparse'
 require 'erb'
 require 'shoryuken/later'
-require 'timers'
 
 module Shoryuken
   module Later
@@ -15,10 +14,12 @@ module Shoryuken
       include Shoryuken::Util
       include Singleton
 
+      attr_accessor :launcher
+      
       def run(args)
         self_read, self_write = IO.pipe
 
-        %w[INT TERM USR1 USR2].each do |sig|
+        %w[INT TERM USR1 USR2 TTIN].each do |sig|
           trap sig do
             self_write.puts(sig)
           end
@@ -33,49 +34,38 @@ module Shoryuken
         validate!
         daemonize
         write_pid
-        
-        Shoryuken::Logging.with_context '[later]' do
-          logger.info 'Starting'
-          
-          # Initialize the timers and poller.
-          @timers = Timers.new
-          require 'shoryuken/later/poller'
-          @pollers = Shoryuken::Later.tables.map{|tbl| Poller.new(tbl) }
-            
-          begin
-            # Poll for items on startup, and every :poll_delay
-            poll_tables
-            @timers.every(Shoryuken::Later.poll_delay){ poll_tables }
-            
-            # Loop watching for signals and firing off of timers
-            while @timers
-              interval = @timers.wait_interval
-              readable, writable = IO.select([self_read], nil, nil, interval)
-              if readable
-                handle_signal readable.first.gets.strip
-              else
-                @timers.fire
-              end
-            end
-          rescue Interrupt
-            @timers.cancel
-            exit 0
+        load_celluloid
+
+        require 'shoryuken/later/launcher'
+        @launcher = Shoryuken::Later::Launcher.new
+
+        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(shutdown: true)
+          exit 0
         end
       end
-      
-      protected
-      
-      def poll_tables
-        logger.debug "Polling schedule tables"
-        @pollers.each do |poller|
-          poller.poll
-        end
-        logger.debug "Polling done"
-      end
 
       private
 
+      def load_celluloid
+        raise "Celluloid cannot be required until here, or it will break Shoryuken::Later's daemonization" if defined?(::Celluloid) && Shoryuken::Later.options[:daemon]
+
+        # Celluloid can't be loaded until after we've daemonized
+        # because it spins up threads and creates locks which get
+        # into a very bad state if forked.
+        require 'celluloid/autostart'
+        Celluloid.logger = (Shoryuken::Later.options[:verbose] ? Shoryuken::Later.logger : nil)
+
+        require 'shoryuken/later/manager'
+      end
+
       def load_rails
         # Adapted from: https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/cli.rb
 
@@ -89,7 +79,6 @@ module Shoryuken
           ::Rails::Application.initializer "shoryuken-later.eager_load" do
             ::Rails.application.config.eager_load = true
           end
-          require 'shoryuken/later/active_job_adapter' if defined?(::ActiveJob)
           require File.expand_path("config/environment.rb")
         end
 
@@ -128,7 +117,7 @@ module Shoryuken
       end
 
       def write_pid
-        if path = Shoryuken::Later.options[:later][:pidfile]
+        if path = Shoryuken::Later.options[:pidfile]
           File.open(path, 'w') do |f|
             f.puts Process.pid
           end
@@ -136,7 +125,7 @@ module Shoryuken
       end
 
       def parse_options(argv)
-        opts = {later: {}}
+        opts = {}
 
         @parser = OptionParser.new do |o|
           o.on '-d', '--daemon', 'Daemonize process' do |arg|
@@ -164,7 +153,7 @@ module Shoryuken
           end
 
           o.on '-P', '--pidfile PATH', 'Path to pidfile' do |arg|
-            opts[:later][:pidfile] = arg
+            opts[:pidfile] = arg
           end
 
           o.on '-v', '--verbose', 'Print more verbose output' do |arg|
@@ -192,10 +181,28 @@ module Shoryuken
         case sig
         when 'USR1'
           logger.info "Received USR1, will soft shutdown down"
-          @timers.cancel
-          @timers = nil
+
+          launcher.stop
+
+          exit 0
+        when 'TTIN'
+          Thread.list.each do |thread|
+            logger.info "Thread TID-#{thread.object_id.to_s(36)} #{thread['label']}"
+            if thread.backtrace
+              logger.info thread.backtrace.join("\n")
+            else
+              logger.info "<no backtrace available>"
+            end
+          end
+          
+          idle   = launcher.manager.instance_variable_get(:@idle).size
+          busy   = launcher.manager.instance_variable_get(:@busy).size
+          tables = launcher.manager.instance_variable_get(:@tables)
+
+          logger.info "Idle: #{idle}, Busy: #{busy}, Polled Tables: #{tables.join(', ')}"
         else
           logger.info "Received #{sig}, will shutdown down"
+
           raise Interrupt
         end
       end
@@ -208,10 +215,8 @@ module Shoryuken
 
         config = options[:config_file] ? parse_config(options[:config_file]).deep_symbolize_keys : {}
 
-        Shoryuken::Later.options[:later].merge!(config.delete(:later) || {})
         Shoryuken::Later.options.merge!(config)
 
-        Shoryuken::Later.options[:later].merge!(options.delete(:later) || {})
         Shoryuken::Later.options.merge!(options)
         
         # Tables from command line options take precedence...

data/lib/shoryuken/later/launcher.rb

@@ -0,0 +1,42 @@
+# All of this has been "borrowed" from Shoryuken.
+
+# @see Shoryuken::Launcher
+module Shoryuken
+  module Later
+    class Launcher
+      include Celluloid
+      include Shoryuken::Util
+
+      trap_exit :actor_died
+
+      attr_accessor :manager
+      
+      def initialize
+        @manager = Shoryuken::Later::Manager.new_link
+
+        @done = false
+      end
+
+      def stop(options = {})
+        watchdog('Later::Launcher#stop') do
+          @done = true
+
+          manager.async.stop(shutdown: !!options[:shutdown], timeout: Shoryuken::Later.options[:timeout])
+          manager.wait(:shutdown)
+        end
+      end
+
+      def run
+        watchdog('Later::Launcher#run') do
+          manager.async.start
+        end
+      end
+
+      def actor_died(actor, reason)
+        return if @done
+        logger.warn 'Shoryuken::Later died due to the following error, cannot recover, process exiting'
+        exit 1
+      end
+    end
+  end
+end

data/lib/shoryuken/later/manager.rb

@@ -0,0 +1,138 @@
+# Most of this has been "borrowed" from Shoryuken, but then repurposed for periodic polling.
+
+# @see Shoryuken::Manager
+require 'set'
+require 'shoryuken/later/poller'
+
+module Shoryuken
+  module Later
+    class Manager
+      include Celluloid
+      include Shoryuken::Util
+      
+      def initialize
+        @tables = Shoryuken::Later.tables.dup.uniq
+        
+        @done = false
+        
+        @idle = Set.new([])
+        @busy = Set.new([])
+        @timers = {}
+        
+        @tables.each{|table| Poller.supervise_as :"poller-#{table}", current_actor, table }
+      end
+
+      def start
+        logger.info 'Starting'
+
+        # Start a poller for every table being polled.
+        @tables.each do |table|
+          dispatch table
+          
+          # Save the timer so it can be cancelled at shutdown.
+          @timers[table] = every(Shoryuken::Later.poll_delay) { dispatch table }
+        end
+      end
+
+      def stop(options = {})
+        watchdog('Later::Manager#stop died') do
+          @done = true
+          
+          @timers.each_value{|timer| timer.cancel if timer }
+          @timers.clear
+
+          logger.info { "Shutting down #{@idle.size} idle poller(s)" }
+
+          @idle.each do |name|
+            poller = Actor[name] and poller.alive? and poller.terminate
+          end
+          @idle.clear
+
+          if @busy.empty?
+            return after(0) { signal(:shutdown) }
+          end
+
+          if options[:shutdown]
+            hard_shutdown_in(options[:timeout])
+          else
+            soft_shutdown(options[:timeout])
+          end
+        end
+      end
+
+      def poller_done(table, poller)
+        watchdog('Later::Manager#poller_done died') do
+          logger.debug { "Poller done for '#{table}'" }
+
+          name = :"poller-#{table}"
+          @busy.delete name
+
+          if stopped?
+            poller.terminate if poller.alive?
+          else
+            @idle << name
+          end
+        end
+      end
+
+      def poller_ready(table, poller)
+        watchdog('Later::Manager#poller_ready died') do
+          logger.debug { "Poller for '#{table}' ready" }
+
+          name = :"poller-#{table}"
+          @busy.delete name
+          @idle << name
+        end
+      end
+
+      def stopped?
+        @done
+      end
+
+      private
+      
+      def dispatch(table)
+        name = :"poller-#{table}"
+        
+        # Only start polling if the poller is idle.
+        if ! stopped? && @idle.include?(name)
+          @idle.delete(name)
+          @busy << name
+              
+          Actor[name].async.poll
+        end
+      end
+      
+      def soft_shutdown(delay)
+        logger.info { "Waiting for #{@busy.size} busy pollers" }
+
+        if @busy.size > 0
+          after(delay) { soft_shutdown(delay) }
+        else
+          after(0) { signal(:shutdown) }
+        end
+      end
+
+      def hard_shutdown_in(delay)
+        logger.info { "Waiting for #{@busy.size} busy pollers" }
+        logger.info { "Pausing up to #{delay} seconds to allow pollers to finish..." }
+
+        after(delay) do
+          watchdog("Later::Manager#hard_shutdown_in died") do
+            if @busy.size > 0
+              logger.info { "Hard shutting down #{@busy.size} busy pollers" }
+
+              @busy.each do |busy|
+                if poller = Actor[busy]
+                  t = poller.bare_object.actual_work_thread
+                  t.raise Shutdown if poller.alive?
+                end
+              end
+            end
+            after(0) { signal(:shutdown) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoryuken/later/poller.rb

@@ -3,12 +3,16 @@ require 'json'
 module Shoryuken
   module Later
     class Poller
+      include Celluloid
       include Shoryuken::Util
       
       attr_reader :table_name
       
-      def initialize(table_name)
+      def initialize(manager, table_name)
+        @manager = manager
         @table_name = table_name
+        
+        @manager.async.poller_ready(@table_name, self)
       end
       
       def poll
@@ -21,10 +25,12 @@ module Shoryuken
             while item = next_item
               id = item.attributes['id']
               logger.info "Found message #{id} from '#{@table_name}'"
-              if sent_msg = process_item(item)
-                logger.debug { "Enqueued message #{id} from '#{@table_name}' as #{sent_msg.id}" }
-              else
-                logger.debug { "Skipping already queued message #{id} from '#{@table_name}'" }
+              defer do
+                if sent_msg = process_item(item)
+                  logger.debug { "Enqueued message #{id} from '#{@table_name}' as #{sent_msg.id}" }
+                else
+                  logger.debug { "Skipping already queued message #{id} from '#{@table_name}'" }
+                end
               end
             end
   
@@ -33,6 +39,8 @@ module Shoryuken
             logger.error "Error fetching message: #{ex}"
             logger.error ex.backtrace.first
           end
+            
+          @manager.async.poller_done(@table_name, self)
         end
       end
 

data/lib/shoryuken/later/version.rb

@@ -1,5 +1,5 @@
 module Shoryuken
   module Later
-    VERSION = '0.0.3'
+    VERSION = '0.0.5'
   end
 end

data/shoryuken-later.gemspec

@@ -20,13 +20,13 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
   
-  spec.required_ruby_version = '>= 1.9.2'
+  spec.required_ruby_version = '>= 2.0.0'
   
   spec.add_development_dependency "bundler", '>= 1.3.5'
   spec.add_development_dependency "rake",    '~> 10.0'
   spec.add_development_dependency "rspec",   '~> 3.0', '< 3.1'
 
   spec.add_dependency "aws-sdk-v1"
-  spec.add_dependency "timers", "~> 1.1.0"
-  spec.add_dependency "shoryuken", "= 0.0.4"
+  spec.add_dependency "celluloid", "~> 0.16.0"
+  spec.add_dependency "shoryuken", "~> 0.0.5"
 end

data/spec/shoryuken/later/poller_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 require 'shoryuken/later/poller'
+require 'shoryuken/later/manager'
 
 describe Shoryuken::Later::Poller do
+  let(:manager)   { double Shoryuken::Later::Manager, poller_ready: nil, poller_done: nil }
   let(:ddb_table) { double 'DynamoDb Table' }
   let(:ddb_items) { double 'Table Items' }
   let(:table)     { 'shoryuken_later' }
@@ -15,26 +17,38 @@ describe Shoryuken::Later::Poller do
   end
 
   before do
+    allow(manager).to receive(:async).and_return(manager)
     allow(Shoryuken::Later::Client).to receive(:tables).with(table).and_return(ddb_table)
   end
 
   subject do
-    described_class.new(table)
+    described_class.new(manager, table)
   end
   
+  describe '#initialize' do
+    it 'informs the manager that the poller is ready' do
+      expect(manager).to receive(:poller_ready).once
+      
+      subject.inspect
+      subject.inspect
+    end
+  end
+
   describe '#poll' do
     it 'pulls items from #next_item, and processes with #process_item' do
       items = [ddb_item]
       expect_any_instance_of(described_class).to receive(:next_item).twice { items.pop }
       expect_any_instance_of(described_class).to receive(:process_item).once.with(ddb_item)
+      expect(manager).to receive(:poller_done).once
 
       subject.poll
     end
     
-    it 'does not call #process_item when there are no items' do
+    it 'informs the manager after polling is done' do
       items = []
       expect_any_instance_of(described_class).to receive(:next_item).once { items.pop }
       expect_any_instance_of(described_class).not_to receive(:process_item)
+      expect(manager).to receive(:poller_done).once
 
       subject.poll
     end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'bundler/setup'
 Bundler.setup
 
+require 'celluloid'
 require 'shoryuken-later'
 require 'json'
 
@@ -15,6 +16,7 @@ if File.exists? options_file
 end
 
 Shoryuken.logger.level = Logger::UNKNOWN
+Celluloid.logger.level = Logger::UNKNOWN
 
 # For Ruby 1.9
 module Kernel
@@ -66,7 +68,7 @@ RSpec.configure do |config|
     TestWorker.get_shoryuken_options['queue'] = 'shoryuken_later'
     TestWorker.get_shoryuken_options['schedule_table'] = 'shoryuken_later'
 
-    Shoryuken.workers.clear
+    Shoryuken.worker_registry.clear
     Shoryuken.register_worker('shoryuken_later', TestWorker)
   end
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: shoryuken-later
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Joe Khoobyar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-12 00:00:00.000000000 Z
+date: 2015-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.3.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.3.5
 - !ruby/object:Gem::Dependency
@@ -62,46 +62,46 @@ dependencies:
   name: aws-sdk-v1
   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: timers
+  name: celluloid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 0.16.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 0.16.0
 - !ruby/object:Gem::Dependency
   name: shoryuken
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: 0.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.4
-description: ! "\n    This gem provides a scheduling plugin (using Dynamo DB) for
-  Shoryuken, as well as an ActiveJob adapter\n  "
+        version: 0.0.5
+description: "\n    This gem provides a scheduling plugin (using Dynamo DB) for Shoryuken,
+  as well as an ActiveJob adapter\n  "
 email:
 - joe@khoobyar.name
 executables:
@@ -120,6 +120,8 @@ files:
 - lib/shoryuken/later/active_job_adapter.rb
 - lib/shoryuken/later/cli.rb
 - lib/shoryuken/later/client.rb
+- lib/shoryuken/later/launcher.rb
+- lib/shoryuken/later/manager.rb
 - lib/shoryuken/later/poller.rb
 - lib/shoryuken/later/version.rb
 - lib/shoryuken/later/worker.rb
@@ -138,17 +140,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A scheduling plugin (using Dynamo DB) for Shoryuken
@@ -157,3 +159,4 @@ test_files:
 - spec/shoryuken/later/poller_spec.rb
 - spec/shoryuken/worker_spec.rb
 - spec/spec_helper.rb
+has_rdoc: