shoryuken-later 0.0.2 → 0.0.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzBhOTRiYmE3MTc2MWU5NzE4OTg3YjUzNjg4N2I2OGJjYWE1ZWEyNQ==
+    ZmRmMzRlZjhlM2I4YTM3NjhjNDUxOTQxYzYwZTE1ZjZiNGNiMWQwNA==
   data.tar.gz: !binary |-
-    MDUxYzI1OWIyYjBmYTZhYmVmZDNhYzEwZTFhYzhkMjI1YmJlZmVlMw==
+    ZTQwODFkZDI4YmE4NGM2MzZiZjFkM2NmNTViZTk4OWQ3NGI2NzVhYQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZjBiOTEwMGEwMGIxMmI2NDRkOTAyNmIzODU4MzNlNDAzMzZmZDRhNWE5ODM0
-    MDkzZWYxMzY4MDcwMzEwZDdlNmI5ODY1ZjU5NmJmYTc4NTljMTgwMDRjZGY1
-    NWM3NTljMTExNzA1MmY3NjdlMDE2OGJlYzFjMzg1YmYxYTc4OWU=
+    NjYxMDExNjQzYjhhNTJmZWE3ZmZmZWMxYjRmN2IwYjU1OTU0Nzg4NTIyOGQx
+    YzM0NzUzNjZjYzAzOTBjNDZiZGEzYTk3ZDU0MjdmM2ZlNmI0OTg5ZWQ4YjM2
+    NWU1Y2U0NDZmMTZkY2QwYjE5MTJlYzJjMmI1MzA5NzVkNGE2YTE=
   data.tar.gz: !binary |-
-    YmU4ZDFlMjJjYWY4ZThiNzdiNjJlMGFlNzY3Y2EwMGNmY2NlNTc4YTIyYjUy
-    ZmY5ZTIxYWU0NDViYjI2NzhlMDNhOGEwYzMyZDVjM2ZhNTk1NzE4ZGJjZDkx
-    MGQ3ZjA2YTYzZGUwY2I3ZGFhOWM4N2QzODg4YzAyMzlkZmJjZWI=
+    MzRiYjI0NDUxMGExNzVmMjA3ZDRlNDlkM2E0NzgzZTc1ZGM5YWE2YzY0OGQy
+    Y2Q0N2QwZjEwMzM2YmUxYzMxYjBkYzUxOWQ0ZjFkNjMwOTNhNjM2MzkxMzdi
+    ZWRiOGRlYjk1MTIzM2IzYjU1ZWJkOWJlNWI2OWQxY2JlMWFiNzg=

data/README.md

@@ -1,26 +1,15 @@
 # shoryuken-later
 
 A scheduling plugin for [Shoryuken](https://github.com/phstc/shoryuken) that uses [Dynamo DB](https://aws.amazon.com/dynamodb/)
-to schedule messages arbitrarily far into the future.
+to delay messages arbitrarily far into the future.
 
 ## Features
 
-### 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'
+### Supports distributed architectures
 
- class MyWorker
-   include Shoryuken::Worker
-  
-   shoryuken_options queue: 'default', schedule_table: 'default_schedule'
- end
+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.
 
- # Schedules a message to be processed 30 minutes from now.
- MyWorker.perform_later(Time.now + 30 * 60, 'Foobar')
-```
+NOTE: You shouldn't really _need_ to run more than one process, but if you do it will be safe.
 
 ### One or more schedule tables
 
@@ -38,21 +27,19 @@ later:
 You can use the same configuration file for both `Shoryuken` and `Shoryuken::Later`, because the new configuration options are namespaced.
 
 ```yaml
-# This key is used by both Shoryuken and Shoryuken::Later
+# These keys are 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
@@ -60,4 +47,102 @@ 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/cli.rb

@@ -7,6 +7,7 @@ require 'singleton'
 require 'optparse'
 require 'erb'
 require 'shoryuken/later'
+require 'timers'
 
 module Shoryuken
   module Later
@@ -14,12 +15,10 @@ module Shoryuken
       include Shoryuken::Util
       include Singleton
 
-      attr_accessor :launcher
-      
       def run(args)
         self_read, self_write = IO.pipe
 
-        %w[INT TERM USR1 USR2 TTIN].each do |sig|
+        %w[INT TERM USR1 USR2].each do |sig|
           trap sig do
             self_write.puts(sig)
           end
@@ -34,38 +33,49 @@ module Shoryuken
         validate!
         daemonize
         write_pid
-        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)
+        
+        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
           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
 
@@ -79,6 +89,7 @@ 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
 
@@ -117,7 +128,7 @@ module Shoryuken
       end
 
       def write_pid
-        if path = Shoryuken::Later.options[:pidfile]
+        if path = Shoryuken::Later.options[:later][:pidfile]
           File.open(path, 'w') do |f|
             f.puts Process.pid
           end
@@ -125,7 +136,7 @@ module Shoryuken
       end
 
       def parse_options(argv)
-        opts = {}
+        opts = {later: {}}
 
         @parser = OptionParser.new do |o|
           o.on '-d', '--daemon', 'Daemonize process' do |arg|
@@ -153,7 +164,7 @@ module Shoryuken
           end
 
           o.on '-P', '--pidfile PATH', 'Path to pidfile' do |arg|
-            opts[:pidfile] = arg
+            opts[:later][:pidfile] = arg
           end
 
           o.on '-v', '--verbose', 'Print more verbose output' do |arg|
@@ -181,28 +192,10 @@ module Shoryuken
         case sig
         when 'USR1'
           logger.info "Received USR1, will soft shutdown down"
-
-          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(', ')}"
+          @timers.cancel
+          @timers = nil
         else
           logger.info "Received #{sig}, will shutdown down"
-
           raise Interrupt
         end
       end
@@ -215,8 +208,10 @@ 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/poller.rb

@@ -3,16 +3,12 @@ require 'json'
 module Shoryuken
   module Later
     class Poller
-      include Celluloid
       include Shoryuken::Util
       
       attr_reader :table_name
       
-      def initialize(manager, table_name)
-        @manager = manager
+      def initialize(table_name)
         @table_name = table_name
-        
-        @manager.async.poller_ready(@table_name, self)
       end
       
       def poll
@@ -25,12 +21,10 @@ module Shoryuken
             while item = next_item
               id = item.attributes['id']
               logger.info "Found 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
+              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
   
@@ -39,8 +33,6 @@ 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.2'
+    VERSION = '0.0.3'
   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.3'
+  spec.required_ruby_version = '>= 1.9.2'
   
   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 "celluloid", "~> 0.15.2"
-  spec.add_dependency "shoryuken", "~> 0.0.4"
+  spec.add_dependency "timers", "~> 1.1.0"
+  spec.add_dependency "shoryuken", "= 0.0.4"
 end

data/spec/shoryuken/later/poller_spec.rb

@@ -1,9 +1,7 @@
 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' }
@@ -17,38 +15,26 @@ 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(manager, table)
+    described_class.new(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 'informs the manager after polling is done' do
+    it 'does not call #process_item when there are no items' 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,7 +1,6 @@
 require 'bundler/setup'
 Bundler.setup
 
-require 'celluloid'
 require 'shoryuken-later'
 require 'json'
 
@@ -16,7 +15,6 @@ if File.exists? options_file
 end
 
 Shoryuken.logger.level = Logger::UNKNOWN
-Celluloid.logger.level = Logger::UNKNOWN
 
 # For Ruby 1.9
 module Kernel

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shoryuken-later
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Joe Khoobyar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-10 00:00:00.000000000 Z
+date: 2015-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,31 +73,31 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: celluloid
+  name: timers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.15.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.15.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: shoryuken
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.0.4
   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
@@ -120,8 +120,6 @@ 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
@@ -142,7 +140,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='

data/lib/shoryuken/later/launcher.rb

@@ -1,42 +0,0 @@
-# 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

@@ -1,138 +0,0 @@
-# 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