resque-scheduler 4.1.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1c100ee487f2bbb303e4bd2efae46172ac89322
-  data.tar.gz: eccb0c76e7ed34839c8c585fa6751bc3c114f521
+  metadata.gz: ac7465394b46317c0dcce4eff62880f4bd74a823
+  data.tar.gz: 1e6070308b4cce022aa2045b7980c25ac4fc2418
 SHA512:
-  metadata.gz: 9c8b1b82cf0d16eed3f711cfba27787232b4b282f8e329e98708f3a4a348a43b416acf74879165b3e1671b7a83c2d7a1aad25884ba5de5c64736c1a099a38696
-  data.tar.gz: ccd696fa8683b597401da6e0adbeaf5edf58ded176fd61a63ad8fbec9f6e5e052b0432e79b4c974f57778454553ce8bf4c25a5e024f3e23a44c807dc551ee2af
+  metadata.gz: 1ccd3427d6b1fc19366ae68ccdce9b69fba9502bf6aee13111aa3a5f486fd6334d0158291714de187b54b48000fafa878529a32413214306b86d6d914ccb37ab
+  data.tar.gz: 418d846ccd4be98b42e8ead43e44b361e2e1ae27b2f6e1ff761d3724dd54d318d8b339b3b399ab680f096c2d2492f85eedfe10fd4cc0465a6d2a1c93b1bc18c7

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2016-02-10 07:59:57 -0500 using RuboCop version 0.35.1.
+# on 2016-04-22 13:22:42 -0400 using RuboCop version 0.35.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -13,7 +13,7 @@ Lint/AssignmentInCondition:
     - 'lib/resque/scheduler/delaying_extensions.rb'
     - 'lib/resque/scheduler/env.rb'
 
-# Offense count: 15
+# Offense count: 16
 Metrics/AbcSize:
   Max: 36
 
@@ -21,7 +21,7 @@ Metrics/AbcSize:
 Metrics/CyclomaticComplexity:
   Max: 12
 
-# Offense count: 1
+# Offense count: 2
 # Configuration parameters: AllowURI, URISchemes.
 Metrics/LineLength:
   Max: 87
@@ -34,7 +34,7 @@ Metrics/MethodLength:
 # Offense count: 2
 # Configuration parameters: CountComments.
 Metrics/ModuleLength:
-  Max: 294
+  Max: 314
 
 # Offense count: 1
 Style/CaseEquality:
@@ -54,10 +54,9 @@ Style/FileName:
     - 'lib/resque-scheduler.rb'
     - 'test/resque-web_test.rb'
 
-# Offense count: 6
+# Offense count: 5
 # Configuration parameters: MinBodyLength.
 Style/GuardClause:
   Exclude:
     - 'lib/resque/scheduler.rb'
     - 'lib/resque/scheduler/lock/basic.rb'
-    - 'test/support/redis_instance.rb'

data/AUTHORS.md

@@ -26,6 +26,7 @@ Resque Scheduler authors
 - Giovanni Cappellotto
 - Harry Lascelles
 - Henrik Nyh
+- Hormoz Kheradmand
 - James Le Cuirot
 - Jarkko Mönkkönen
 - John Crepezzi
@@ -56,6 +57,7 @@ Resque Scheduler authors
 - Ryan Carver
 - Sameer Siruguri
 - Scott Francis
+- Sean Stephens
 - Sebastian Kippe
 - Spring MC
 - tbprojects
@@ -66,11 +68,14 @@ Resque Scheduler authors
 - Vladislav Shub
 - V Sreekanth
 - Warren Sangster
+- Yuri Kasperovich
 - andreas
 - bbauer
 - camol
+- d4rk5eed
 - fallwith
 - gravis
 - hpoydar
 - malomalo
 - sawanoboly
+- serek

data/HISTORY.md

@@ -1,5 +1,25 @@
 # Resque Scheduler History / ChangeLog / Release Notes
 
+## 4.2.0 (2016-04-29)
+* Bugfix for a race condition in concurrent restarts
+* Clean up and simplify the scheduling extension
+* Make `Resque::Scheduler.logger` accessible to user
+* Failure hook support for better extensibility
+* Default failure handler now outputs stacktrace
+* Add index column to scheduler tab
+* Update rufus-scheduler
+* Bugfix for displaying schedules appropriate to the `env`
+in scheduler UI
+
+## 4.1.0 (2016-02-10)
+* View helper to cut down on repetition
+* Bugfix to check thread life only if present
+* New `Resque.(find|enqueue)_delayed_selection` methods to complement
+`Resque.remove_delayed_selection`
+* Leave undefined env vars unset in internal options hash
+* Insulate checking `Rails.env`
+* Documentation updates and typo fixes
+
 ## 4.0.0 (2014-12-21)
 * Bump rufus-scheduler dependency to `~> 3.0`
 * Address warning from redis-namespace related to `#unwatch`

data/README.md

@@ -170,7 +170,11 @@ Delayed jobs are one-off jobs that you want to be put into a queue at some point
 in the future.  The classic example is sending email:
 
 ```ruby
-Resque.enqueue_in(5.days, SendFollowUpEmail, :user_id => current_user.id)
+Resque.enqueue_in(
+  5.days,
+  SendFollowUpEmail,
+  user_id: current_user.id
+)
 ```
 
 This will store the job for 5 days in the resque delayed queue at which time
@@ -178,13 +182,22 @@ the scheduler process will pull it from the delayed queue and put it in the
 appropriate work queue for the given job and it will be processed as soon as
 a worker is available (just like any other resque job).
 
-NOTE: The job does not fire **exactly** at the time supplied.  Rather, once that
+**NOTE**: The job does not fire **exactly** at the time supplied.  Rather, once that
 time is in the past, the job moves from the delayed queue to the actual resque
 work queue and will be completed as workers are free to process it.
 
 Also supported is `Resque.enqueue_at` which takes a timestamp to queue the
 job, and `Resque.enqueue_at_with_queue` which takes both a timestamp and a
-queue name.
+queue name:
+
+```ruby
+Resque.enqueue_at_with_queue(
+  'queue_name',
+  5.days.from_now,
+  SendFollowUpEmail,
+  user_id: current_user.id
+)
+```
 
 The delayed queue is stored in redis and is persisted in the same way the
 standard resque jobs are persisted (redis writing to disk). Delayed jobs differ
@@ -299,7 +312,7 @@ resulting in resetting schedule time on every deploy, so it's probably a good id
 frequent jobs (like every 10-30 minutes), otherwise - when you use something like `every 20h` and deploy once-twice per day -
 it will schedule the job for 20 hours from deploy, resulting in a job to never be run.
 
-NOTE: Six parameter cron's are also supported (as they supported by
+**NOTE**: Six parameter cron's are also supported (as they supported by
 rufus-scheduler which powers the resque-scheduler process).  This allows you
 to schedule jobs per second (ie: `"30 * * * * *"` would fire a job every 30
 seconds past the minute).
@@ -320,6 +333,10 @@ must pass the following to `resque-scheduler` initialization (see *Installation*
 Resque::Scheduler.dynamic = true
 ```
 
+**NOTE**: In order to delete dynamic schedules via `resque-web` in the
+"Schedule" tab, you must include the `Rack::MethodOverride` middleware (in
+`config.ru` or equivalent).
+
 Dynamic schedules allow for greater flexibility than static schedules as they can be set,
 unset or changed without having to restart `resque-scheduler`. You can specify, if the schedule
 must survive a resque-scheduler restart or not. This is done by setting the `persist` configuration
@@ -398,6 +415,13 @@ Similar to the `before_enqueue`- and `after_enqueue`-hooks provided in Resque
   removed from the delayed queue, but not yet put on a normal queue. It is
   called before `before_enqueue`-hooks, and on the same job instance as the
   `before_enqueue`-hooks will be invoked on. Return values are ignored.
+* `on_enqueue_failure`: Called with the job args and the exception that was raised
+  while enqueueing a job to resque or external application fails.  Return
+  values are ignored. For example:
+
+  ```ruby
+  Resque::Scheduler.failure_handler = ExceptionHandlerClass
+  ```
 
 #### Support for resque-status (and other custom jobs)
 
@@ -511,7 +535,6 @@ require 'resque/scheduler/server'
 
 That should make the scheduler tabs show up in `resque-web`.
 
-
 #### Changes as of 2.0.0
 
 As of resque-scheduler 2.0.0, it's no longer necessary to have the resque-web

data/lib/resque/scheduler.rb

@@ -5,6 +5,7 @@ require_relative 'scheduler/configuration'
 require_relative 'scheduler/locking'
 require_relative 'scheduler/logger_builder'
 require_relative 'scheduler/signal_handling'
+require_relative 'scheduler/failure_handler'
 
 module Resque
   module Scheduler
@@ -22,9 +23,14 @@ module Resque
     public
 
     class << self
+      attr_writer :logger
+
       # the Rufus::Scheduler jobs that are scheduled
       attr_reader :scheduled_jobs
 
+      # allow user to set an additional failure handler
+      attr_writer :failure_handler
+
       # Schedule all jobs and continually look for delayed jobs (never returns)
       def run
         procline 'Starting'
@@ -137,7 +143,7 @@ module Resque
               if master?
                 log! "queueing #{config['class']} (#{name})"
                 Resque.last_enqueued_at(name, Time.now.to_s)
-                handle_errors { enqueue_from_config(config) }
+                enqueue(config)
               end
             end
             @scheduled_jobs[name] = job
@@ -182,19 +188,24 @@ module Resque
         end
       end
 
+      def enqueue_next_item(timestamp)
+        item = Resque.next_item_for_timestamp(timestamp)
+
+        if item
+          log "queuing #{item['class']} [delayed]"
+          enqueue(item)
+        end
+
+        item
+      end
+
       # Enqueues all delayed jobs for a timestamp
       def enqueue_delayed_items_for_timestamp(timestamp)
         item = nil
         loop do
           handle_shutdown do
             # Continually check that it is still the master
-            if master?
-              item = Resque.next_item_for_timestamp(timestamp)
-              if item
-                log "queuing #{item['class']} [delayed]"
-                handle_errors { enqueue_from_config(item) }
-              end
-            end
+            item = enqueue_next_item(timestamp) if master?
           end
           # continue processing until there are no more ready items in this
           # timestamp
@@ -202,18 +213,18 @@ module Resque
         end
       end
 
+      def enqueue(config)
+        enqueue_from_config(config)
+      rescue => e
+        Resque::Scheduler.failure_handler.on_enqueue_failure(config, e)
+      end
+
       def handle_shutdown
         exit if @shutdown
         yield
         exit if @shutdown
       end
 
-      def handle_errors
-        yield
-      rescue => e
-        log_error "#{e.class.name}: #{e.message}"
-      end
-
       # Enqueues a job based on a config hash
       def enqueue_from_config(job_config)
         args = job_config['args'] || job_config[:args]
@@ -330,24 +341,39 @@ module Resque
 
       def poll_sleep_loop
         @sleeping = true
-        start = Time.now
-        loop do
-          elapsed_sleep = (Time.now - start)
-          remaining_sleep = poll_sleep_amount - elapsed_sleep
-          break if remaining_sleep <= 0
-          begin
-            sleep(remaining_sleep)
-            handle_signals
-          rescue Interrupt
-            if @shutdown
-              Resque.clean_schedules
-              release_master_lock
+        if poll_sleep_amount > 0
+          start = Time.now
+          loop do
+            elapsed_sleep = (Time.now - start)
+            remaining_sleep = poll_sleep_amount - elapsed_sleep
+            @do_break = false
+            if remaining_sleep <= 0
+              @do_break = true
+            else
+              @do_break = handle_signals_with_operation do
+                sleep(remaining_sleep)
+              end
             end
-            break
+            break if @do_break
           end
+        else
+          handle_signals_with_operation
         end
       end
 
+      def handle_signals_with_operation
+        yield if block_given?
+        handle_signals
+        false
+      rescue Interrupt
+        before_shutdown if @shutdown
+        true
+      end
+
+      def before_shutdown
+        release_master_lock
+      end
+
       # Sets the shutdown flag, clean schedules and exits if sleeping
       def shutdown
         return if @shutdown
@@ -375,9 +401,9 @@ module Resque
         $0 = argv0
       end
 
-      private
-
-      attr_writer :logger
+      def failure_handler
+        @failure_handler ||= Resque::Scheduler::FailureHandler
+      end
 
       def logger
         @logger ||= Resque::Scheduler::LoggerBuilder.new(
@@ -388,6 +414,8 @@ module Resque
         ).build
       end
 
+      private
+
       def app_str
         app_name ? "[#{app_name}]" : ''
       end

data/lib/resque/scheduler/delaying_extensions.rb

@@ -210,6 +210,8 @@ module Resque
       # O(N) where N is the number of jobs scheduled to fire at the given
       # timestamp
       def remove_delayed_job_from_timestamp(timestamp, klass, *args)
+        return 0 if Resque.inline?
+
         key = "delayed:#{timestamp.to_i}"
         encoded_job = encode(job_to_hash(klass, args))
 
@@ -264,6 +266,8 @@ module Resque
       end
 
       def remove_delayed_job(encoded_job)
+        return 0 if Resque.inline?
+
         timestamps = redis.smembers("timestamps:#{encoded_job}")
 
         replies = redis.pipelined do

data/lib/resque/scheduler/failure_handler.rb

@@ -0,0 +1,11 @@
+module Resque
+  module Scheduler
+    class FailureHandler
+      def self.on_enqueue_failure(_, e)
+        Resque::Scheduler.log_error(
+          "#{e.class.name}: #{e.message} #{e.backtrace.inspect}"
+        )
+      end
+    end
+  end
+end

data/lib/resque/scheduler/scheduling_extensions.rb

@@ -44,33 +44,11 @@ module Resque
       # param, otherwise params is passed in as the only parameter to
       # perform.
       def schedule=(schedule_hash)
-        # This operation tries to be as atomic as possible.
-        # It needs to read the existing schedules outside the transaction.
-        # Unlikely, but this could still cause a race condition.
-        #
-        # A more robust solution would be to SCRIPT it, but that would change
-        # the required version of Redis.
-
-        # select schedules to remove
-        if redis.exists(:schedules)
-          clean_keys = non_persistent_schedules
-        else
-          clean_keys = []
-        end
-
-        # Start the transaction. If this is not atomic and more than one
-        # process is calling `schedule=` the clean_schedules might overlap a
-        # set_schedule and cause the schedules to become corrupt.
-        redis.multi do
-          clean_schedules(clean_keys)
+        @non_persistent_schedules = nil
+        prepared_schedules = prepare_schedules(schedule_hash)
 
-          schedule_hash = prepare_schedule(schedule_hash)
-
-          # store all schedules in redis, so we can retrieve them back
-          # everywhere.
-          schedule_hash.each do |name, job_spec|
-            set_schedule(name, job_spec)
-          end
+        prepared_schedules.each do |schedule, config|
+          set_schedule(schedule, config, false)
         end
 
         # ensure only return the successfully saved data!
@@ -83,33 +61,14 @@ module Resque
         @schedule || {}
       end
 
-      # reloads the schedule from redis
+      # reloads the schedule from redis and memory
       def reload_schedule!
         @schedule = all_schedules
       end
 
       # gets the schedules as it exists in redis
       def all_schedules
-        return nil unless redis.exists(:schedules)
-
-        redis.hgetall(:schedules).tap do |h|
-          h.each do |name, config|
-            h[name] = decode(config)
-          end
-        end
-      end
-
-      # clean the schedules as it exists in redis, useful for first setup?
-      def clean_schedules(keys = non_persistent_schedules)
-        keys.each do |key|
-          remove_schedule(key)
-        end
-        @schedule = nil
-        true
-      end
-
-      def non_persistent_schedules
-        redis.hkeys(:schedules).select { |k| !schedule_persisted?(k) }
+        non_persistent_schedules.merge(persistent_schedules)
       end
 
       # Create or update a schedule with the provided name and configuration.
@@ -121,35 +80,52 @@ module Resque
       #                                     :every => '15mins',
       #                                     :queue => 'high',
       #                                     :args => '/tmp/poop'})
-      def set_schedule(name, config)
+      #
+      # Preventing a reload is optional and available to batch operations
+      def set_schedule(name, config, reload = true)
         persist = config.delete(:persist) || config.delete('persist')
-        redis.pipelined do
-          redis.hset(:schedules, name, encode(config))
-          redis.sadd(:schedules_changed, name)
-          redis.sadd(:persisted_schedules, name) if persist
+
+        if persist
+          redis.hset(:persistent_schedules, name, encode(config))
+        else
+          non_persistent_schedules[name] = decode(encode(config))
         end
-        config
+
+        redis.sadd(:schedules_changed, name)
+        reload_schedule! if reload
       end
 
       # retrive the schedule configuration for the given name
       def fetch_schedule(name)
-        decode(redis.hget(:schedules, name))
-      end
-
-      def schedule_persisted?(name)
-        redis.sismember(:persisted_schedules, name)
+        schedule[name]
       end
 
       # remove a given schedule by name
       def remove_schedule(name)
-        redis.hdel(:schedules, name)
-        redis.srem(:persisted_schedules, name)
+        non_persistent_schedules.delete(name)
+        redis.hdel(:persistent_schedules, name)
         redis.sadd(:schedules_changed, name)
+
+        reload_schedule!
       end
 
       private
 
-      def prepare_schedule(schedule_hash)
+      # we store our non-persistent schedules in this hash
+      def non_persistent_schedules
+        @non_persistent_schedules ||= {}
+      end
+
+      # reads the persistent schedules from redis
+      def persistent_schedules
+        redis.hgetall(:persistent_schedules).tap do |h|
+          h.each do |name, config|
+            h[name] = decode(config)
+          end
+        end
+      end
+
+      def prepare_schedules(schedule_hash)
         prepared_hash = {}
         schedule_hash.each do |name, job_spec|
           job_spec = job_spec.dup

data/lib/resque/scheduler/server.rb

@@ -8,6 +8,8 @@ require 'json'
 module Resque
   module Scheduler
     module Server
+      TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S %z'
+
       unless defined?(::Resque::Scheduler::Server::VIEW_PATH)
         VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
       end
@@ -105,10 +107,19 @@ module Resque
 
         def delayed_queue_now
           timestamp = params['timestamp'].to_i
+          formatted_time = Time.at(timestamp).strftime(
+            ::Resque::Scheduler::Server::TIMESTAMP_FORMAT
+          )
+
           if timestamp > 0
-            Resque::Scheduler.enqueue_delayed_items_for_timestamp(timestamp)
+            unless Resque::Scheduler.enqueue_next_item(timestamp)
+              @error_message = "Unable to remove item at #{formatted_time}"
+            end
+          else
+            @error_message = "Incorrect timestamp #{formatted_time}"
           end
-          redirect u('/overview')
+
+          erb scheduler_template('delayed')
         end
 
         def delayed_cancel_now
@@ -127,7 +138,11 @@ module Resque
 
       module HelperMethods
         def format_time(t)
-          t.strftime('%Y-%m-%d %H:%M:%S %z')
+          t.strftime(::Resque::Scheduler::Server::TIMESTAMP_FORMAT)
+        end
+
+        def show_job_arguments(args)
+          Array(args).map(&:inspect).join("\n")
         end
 
         def queue_from_class_name(class_name)
@@ -196,12 +211,12 @@ module Resque
         end
 
         def scheduled_in_this_env?(name)
-          return true if Resque.schedule[name]['rails_env'].nil?
+          return true if rails_env(name).nil?
           rails_env(name).split(/[\s,]+/).include?(Resque::Scheduler.env)
         end
 
         def rails_env(name)
-          Resque.schedule[name]['rails_env']
+          Resque.schedule[name]['rails_env'] || Resque.schedule[name]['env']
         end
 
         def scheduler_view(filename, options = {}, locals = {})

data/lib/resque/scheduler/server/views/delayed.erb

@@ -3,6 +3,10 @@
 
 <%= scheduler_view :search_form, layout: false %>
 
+<p style="font-color: red; font-weight: bold;">
+  <%= @error_message %>
+</p>
+
 <p class='intro'>
   This list below contains the timestamps for scheduled delayed jobs.
   Server local time: <%= Time.now %>
@@ -39,7 +43,7 @@
           <a href="<%= u "delayed/#{timestamp}" %>">see details</a>
         <% end %>
       </td>
-      <td><%= h(job['args'].inspect) if job && delayed_timestamp_size == 1 %></td>
+      <td><%= h(show_job_arguments(job['args'])) if job && delayed_timestamp_size == 1 %></td>
       <td>
         <% if job %>
           <a href="<%=u URI("/delayed/jobs/#{job['class']}?args=" + URI.encode(job['args'].to_json)) %>">All schedules</a>

data/lib/resque/scheduler/server/views/delayed_schedules.erb

@@ -1,4 +1,4 @@
-<h1>Delayed jobs scheduled for <%= params[:klass] %> (<%= @args %>)</h1>
+<h1>Delayed jobs scheduled for <%= params[:klass] %> (<%= show_job_arguments(@args) %>)</h1>
 
 <table class='jobs'>
 <tr>

data/lib/resque/scheduler/server/views/delayed_timestamp.erb

@@ -13,7 +13,7 @@
   <% jobs.each do |job| %>
     <tr>
       <td class='class'><%= job['class'] %></td>
-      <td class='args'><%=h job['args'].inspect %></td>
+      <td class='args'><%=h show_job_arguments(job['args']) %></td>
     </tr>
   <% end %>
   <% if jobs.empty? %>

data/lib/resque/scheduler/server/views/scheduler.erb

@@ -3,15 +3,20 @@
 <p class='intro'>
   The list below contains all scheduled jobs.  Click &quot;Queue now&quot; to queue
   a job immediately.
-  Server local time: <%= Time.now %>
-  Current master: <%= Resque.redis.get(Resque::Scheduler.master_lock.key) %>
+  <br/> Server local time: <%= Time.now %>
+  <br/> Server Environment: <%= Resque::Scheduler.env %>
+  <br/> Current master: <%= Resque.redis.get(Resque::Scheduler.master_lock.key) %>
+</p>
+<p class='intro'>
+	The highlighted jobs are skipped for current environment.
 </p>
 <div style="overflow-y: auto; width:100%; padding: 0px 5px;">
 <table>
   <tr>
+    <th>Index</th>
     <% if Resque::Scheduler.dynamic %>
       <th></th>
-    <% end %>
+  <% end %>
     <th></th>
     <th>Name</th>
     <th>Description</th>
@@ -21,9 +26,10 @@
     <th>Arguments</th>
     <th>Last Enqueued</th>
   </tr>
-  <% Resque.schedule.keys.sort.select { |n| scheduled_in_this_env?(n) }.each do |name| %>
+  <% Resque.schedule.keys.sort.each_with_index do |name, index| %>
     <% config = Resque.schedule[name] %>
-    <tr>
+    <tr style="<%= scheduled_in_this_env?(name) ? '' : 'color: #9F6000;background: #FEEFB3;' %>">
+	    <td style="padding-left: 15px;"><%= index+ 1 %>.</td>
       <% if Resque::Scheduler.dynamic %>
         <td style="padding-top: 12px; padding-bottom: 2px; width: 10px">
           <form action="<%= u "/schedule" %>" method="post" style="margin-left: 0">
@@ -44,7 +50,7 @@
       <td style="white-space:nowrap"><%= h schedule_interval(config) %></td>
       <td><%= h schedule_class(config) %></td>
       <td><%= h config['queue'] || queue_from_class_name(config['class']) %></td>
-      <td><%= h config['args'].inspect %></td>
+      <td><%= h show_job_arguments(config['args']) %></td>
       <td><%= h Resque.get_last_enqueued_at(name) || 'Never' %></td>
     </tr>
   <% end %>

data/lib/resque/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Resque
   module Scheduler
-    VERSION = '4.1.0'
+    VERSION = '4.2.0'
   end
 end

data/resque-scheduler.gemspec

@@ -41,5 +41,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'mono_logger', '~> 1.0'
   spec.add_runtime_dependency 'redis', '~> 3.0'
   spec.add_runtime_dependency 'resque', '~> 1.25'
-  spec.add_runtime_dependency 'rufus-scheduler', '~> 3.0'
+  spec.add_runtime_dependency 'rufus-scheduler', '~> 3.2'
 end

data/test/delayed_queue_test.rb

@@ -265,6 +265,15 @@ context 'DelayedQueue' do
     end
   end
 
+  test 'enqueue_next_item picks one job' do
+    t = Time.now + 60
+
+    Resque.enqueue_at(t, SomeIvarJob)
+    Resque.enqueue_at(t, SomeIvarJob)
+    Resque::Scheduler.enqueue_next_item(t)
+    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 3).length)
+  end
+
   test 'enqueue_delayed_items_for_timestamp creates jobs ' \
        'and empties the delayed queue' do
     t = Time.now + 60
@@ -335,6 +344,20 @@ context 'DelayedQueue' do
     assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"))
   end
 
+  test "when Resque.inline = true, remove_delayed doesn't remove the job" \
+       'and returns 0' do
+    begin
+      Resque.inline = true
+
+      timestamp = Time.now + 120
+      Resque.enqueue_at(timestamp, SomeIvarJob, 'foo', 'bar')
+
+      assert_equal(0, Resque.remove_delayed(SomeIvarJob))
+    ensure
+      Resque.inline = false
+    end
+  end
+
   test 'scheduled_at returns an array containing job schedule time' do
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob)
@@ -816,6 +839,20 @@ context 'DelayedQueue' do
     assert_equal 0, Resque.delayed_timestamp_size(t2)
   end
 
+  test 'when Resque.inline = true, remove_delayed_job_from_timestamp' \
+       "doesn't remove any jobs and returns 0" do
+    begin
+      Resque.inline = true
+
+      timestamp = Time.now + 120
+      Resque.enqueue_at(timestamp, SomeIvarJob, 'foo', 'bar')
+
+      assert_equal(0, Resque.delayed_timestamp_size(timestamp))
+    ensure
+      Resque.inline = false
+    end
+  end
+
   test 'remove_delayed_job_from_timestamp removes nothing if there ' \
        'are no matches' do
     t = Time.now + 120

data/test/multi_process_test.rb

@@ -3,35 +3,123 @@ require_relative 'test_helper'
 
 context 'Multi Process' do
   test 'setting schedule= from many process does not corrupt the schedules' do
-    schedules = {}
-    counts  = []
-    threads = []
+    # more info on why we're not using threads:
+    # https://github.com/resque/resque-scheduler/pull/439#discussion_r16788812
+    omit('forking is not supported by jruby but this behaviour' \
+      ' is best tested using forks') if RUBY_ENGINE == 'jruby'
+    schedules_1 = {}
+    schedules_2 = {}
+    schedules = []
+    pids = []
 
     # This number may need to be increased if this test is not failing
-    processes = 20
+    processes = 100
 
-    schedule_count = 200
+    schedule_count = 300
 
     schedule_count.times do |n|
-      schedules["job #{n}"] = { cron: '0 1 0 0 0' }
+      schedules_1["1_job_#{n}"] = { cron: '0 1 0 0 0' }
+      schedules_2["2_job_#{n}"] = { cron: '0 1 0 0 0' }
     end
 
     processes.times do |n|
-      threads << Thread.new do
+      pids << fork_with_marshalled_pipe_and_result do
         sleep n * 0.1
-        Resque.schedule = schedules
-        counts << Resque.schedule.size
+        Resque.schedule = n.even? ? schedules_2 : schedules_1
+        Resque.schedule
       end
     end
 
-    # doing this outside the threads increases the odds of failure
+    schedules += get_results_from_children(pids)
+
+    assert_equal processes, schedules.size,
+                 'missing some schedules, did a process die?'
+    schedules.each_with_index do |schedule, i|
+      assert_equal schedule_count, schedule.size,
+                   "schedule count is incorrect (schedule[#{i}]: #{schedule})"
+    end
+  end
+
+  test 'concurrent shutdowns and startups do not corrupt the schedule' do
+    omit('forking is not supported by jruby but this behaviour' \
+      ' is best tested using forks') if RUBY_ENGINE == 'jruby'
+    counts = []
+    children = []
+
+    processes = 40
+
+    schedules = {}
+    schedule_count = 300
+    schedule_count.times do |n|
+      schedules["job_#{n}"] = { 'cron' => '0 1 0 0 0' }
+    end
+
     Resque.schedule = schedules
-    counts << Resque.schedule.size
 
-    threads.each(&:join)
+    processes.times do |n|
+      children << fork_with_marshalled_pipe_and_result do
+        sleep Random.rand(3) * 0.1
+        if n.even?
+          Resque.schedule = schedules
+          Resque.schedule.size
+        else
+          Resque::Scheduler.before_shutdown
+          nil
+        end
+      end
+    end
+
+    counts += get_results_from_children(children).compact
 
+    assert_equal processes / 2, counts.size,
+                 'missing some counts, did a process die?'
     counts.each_with_index do |c, i|
       assert_equal schedule_count, c, "schedule count is incorrect (c: #{i})"
     end
   end
+
+  private
+
+  def fork_with_marshalled_pipe_and_result
+    pipe_read, pipe_write = IO.pipe
+    pid = fork do
+      pipe_read.close
+      result = begin
+        [yield, nil]
+      rescue StandardError => exc
+        [nil, exc]
+      end
+      pipe_write.syswrite(Marshal.dump(result))
+      # exit true the process to get around fork issues on minitest 5
+      # see https://github.com/seattlerb/minitest/issues/467
+      Process.exit!(true)
+    end
+    pipe_write.close
+
+    [pid, pipe_read]
+  end
+
+  def get_results_from_children(children)
+    results = []
+    children.each do |pid, pipe|
+      wait_for_child_process_to_terminate(pid)
+
+      fail "forked process failed with #{$CHILD_STATUS}" unless $CHILD_STATUS.success?
+      result, exc = Marshal.load(pipe.read)
+      fail exc if exc
+      results << result
+    end
+    results
+  end
+
+  def wait_for_child_process_to_terminate(pid = -1, timeout = 30)
+    Timeout.timeout(timeout) do
+      Process.wait(pid)
+    end
+  rescue Timeout::Error
+    Process.kill('KILL', pid)
+    # collect status so it doesn't stick around as zombie process
+    Process.wait(pid)
+    flunk 'Child process did not terminate in time.'
+  end
 end

data/test/resque-web_test.rb

@@ -51,8 +51,8 @@ context 'on GET to /schedule with scheduled jobs' do
     assert last_response.body.include?('SomeIvarJob')
   end
 
-  test 'excludes jobs for other envs' do
-    assert !last_response.body.include?('SomeFancyJob')
+  test 'include(highlight) jobs for other envs' do
+    assert last_response.body.include?('SomeFancyJob')
   end
 
   test 'includes job used in multiple environments' do
@@ -256,11 +256,10 @@ context 'on POST to /delayed/clear' do
 end
 
 context 'on POST to /delayed/queue_now' do
-  setup { post '/delayed/queue_now' }
+  setup { post '/delayed/queue_now', timestamp: 0 }
 
-  test 'redirects to overview' do
-    assert last_response.status == 302
-    assert last_response.header['Location'].include? '/overview'
+  test 'returns ok status' do
+    assert last_response.status == 200
   end
 end
 

data/test/scheduler_hooks_test.rb

@@ -21,4 +21,35 @@ context 'scheduling jobs with hooks' do
     assert_equal(0, Resque.delayed_timestamp_size(enqueue_time.to_i),
                  'job should not be enqueued')
   end
+
+  test 'default failure hooks are called when enqueueing a job fails' do
+    config = {
+      'cron' => '* * * * *',
+      'class' => 'SomeRealClass',
+      'args' => '/tmp'
+    }
+
+    e = RuntimeError.new('custom error')
+    Resque::Scheduler.expects(:enqueue_from_config).raises(e)
+
+    Resque::Scheduler::FailureHandler.expects(:on_enqueue_failure).with(config, e)
+    Resque::Scheduler.enqueue(config)
+  end
+
+  test 'failure hooks are called when enqueueing a job fails' do
+    with_failure_handler(ExceptionHandlerClass) do
+      config = {
+        'cron' => '* * * * *',
+        'class' => 'SomeRealClass',
+        'args' => '/tmp'
+      }
+
+      e = RuntimeError.new('custom error')
+      Resque::Scheduler.expects(:enqueue_from_config).raises(e)
+
+      ExceptionHandlerClass.expects(:on_enqueue_failure).with(config, e)
+
+      Resque::Scheduler.enqueue(config)
+    end
+  end
 end

data/test/scheduler_setup_test.rb

@@ -14,8 +14,17 @@ context 'Resque::Scheduler' do
 
   test 'set custom logger' do
     custom_logger = MonoLogger.new('/dev/null')
-    Resque::Scheduler.send(:logger=, custom_logger)
-    assert_equal(custom_logger, Resque::Scheduler.send(:logger))
+    Resque::Scheduler.logger = custom_logger
+
+    custom_logger.expects(:error).once
+    Resque::Scheduler.log_error('test')
+  end
+
+  test 'custom logger is accessible' do
+    custom_logger = MonoLogger.new('/dev/null')
+    Resque::Scheduler.logger = custom_logger
+
+    assert_equal custom_logger, Resque::Scheduler.logger
   end
 
   test 'configure block' do

data/test/scheduler_task_test.rb

@@ -37,4 +37,36 @@ context 'Resque::Scheduler' do
     Resque::Scheduler.unstub(:release_master_lock)
     Resque::Scheduler.release_master_lock
   end
+
+  test 'can start successfully' do
+    Resque::Scheduler.poll_sleep_amount = nil
+
+    @pid = Process.pid
+    Thread.new do
+      sleep(0.15)
+      Process.kill(:TERM, @pid)
+    end
+
+    assert_raises SystemExit do
+      Resque::Scheduler.run
+    end
+  end
+
+  test 'sending TERM to scheduler breaks out when poll_sleep_amount = 0' do
+    Resque::Scheduler.poll_sleep_amount = 0
+    Resque::Scheduler.expects(:release_master_lock)
+
+    @pid = Process.pid
+    Thread.new do
+      sleep(0.05)
+      Process.kill(:TERM, @pid)
+    end
+
+    assert_raises SystemExit do
+      Resque::Scheduler.run
+    end
+
+    Resque::Scheduler.unstub(:release_master_lock)
+    Resque::Scheduler.release_master_lock
+  end
 end

data/test/scheduler_test.rb

@@ -31,16 +31,16 @@ context 'Resque::Scheduler' do
     Resque::Scheduler.env = 'production'
     config = {
       'cron' => '* * * * *',
-      'class' => 'SomeRealClass',
+      'class' => 'SomeJobWithResqueHooks',
       'args' => '/tmp'
     }
 
     Resque::Job.expects(:create).with(
-      SomeRealClass.queue, SomeRealClass, '/tmp'
+      SomeJobWithResqueHooks.queue, SomeJobWithResqueHooks, '/tmp'
     )
-    SomeRealClass.expects(:before_delayed_enqueue_example).with('/tmp')
-    SomeRealClass.expects(:before_enqueue_example).with('/tmp')
-    SomeRealClass.expects(:after_enqueue_example).with('/tmp')
+    SomeJobWithResqueHooks.expects(:before_delayed_enqueue_example).with('/tmp')
+    SomeJobWithResqueHooks.expects(:before_enqueue_example).with('/tmp')
+    SomeJobWithResqueHooks.expects(:after_enqueue_example).with('/tmp')
 
     Resque::Scheduler.enqueue_from_config(config)
   end
@@ -59,7 +59,7 @@ context 'Resque::Scheduler' do
     assert_equal(0, Resque::Scheduler.rufus_scheduler.jobs.size)
 
     Resque.schedule = {
-      some_ivar_job: {
+      'some_ivar_job' => {
         'cron' => '* * * * *',
         'class' => 'SomeIvarJob',
         'args' => '/tmp'
@@ -87,15 +87,13 @@ context 'Resque::Scheduler' do
     assert Resque::Scheduler.scheduled_jobs.include?('some_ivar_job')
 
     Resque.redis.del(:schedules)
-    Resque.redis.hset(
-      :schedules,
-      'some_ivar_job2',
-      Resque.encode(
+    Resque.schedule = {
+      'some_ivar_job2' => {
         'cron' => '* * * * *',
         'class' => 'SomeIvarJob',
         'args' => '/tmp/2'
-      )
-    )
+      }
+    }
 
     Resque::Scheduler.reload_schedule!
 
@@ -313,7 +311,7 @@ context 'Resque::Scheduler' do
     }
     assert_equal(
       { 'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/75' },
-      Resque.decode(Resque.redis.hget(:schedules, 'my_ivar_job'))
+      Resque.schedule['my_ivar_job']
     )
   end
 
@@ -346,7 +344,7 @@ context 'Resque::Scheduler' do
     } }
     assert_equal(
       { 'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/75' },
-      Resque.decode(Resque.redis.hget(:schedules, 'SomeIvarJob'))
+      Resque.schedule['SomeIvarJob']
     )
     assert_equal('SomeIvarJob', Resque.schedule['SomeIvarJob']['class'])
   end
@@ -366,21 +364,19 @@ context 'Resque::Scheduler' do
     )
     assert_equal(
       { 'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/22' },
-      Resque.decode(Resque.redis.hget(:schedules, 'some_ivar_job'))
+      Resque.schedule['some_ivar_job']
     )
     assert Resque.redis.sismember(:schedules_changed, 'some_ivar_job')
   end
 
   test 'fetch_schedule returns a schedule' do
-    Resque.redis.hset(
-      :schedules,
-      'some_ivar_job2',
-      Resque.encode(
+    Resque.schedule = {
+      'some_ivar_job2' => {
         'cron' => '* * * * *',
         'class' => 'SomeIvarJob',
         'args' => '/tmp/33'
-      )
-    )
+      }
+    }
     assert_equal(
       { 'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/33' },
       Resque.fetch_schedule('some_ivar_job2')

data/test/test_helper.rb

@@ -49,6 +49,10 @@ unless defined?(Rails)
   end
 end
 
+class ExceptionHandlerClass
+  def self.on_enqueue_failure(_, _); end
+end
+
 class FakeCustomJobClass
   def self.scheduled(_, _, *_); end
 end
@@ -89,6 +93,12 @@ class SomeRealClass
   end
 end
 
+class SomeJobWithResqueHooks < SomeRealClass
+  def before_enqueue_example; end
+
+  def after_enqueue_example; end
+end
+
 class JobWithParams
   def self.perform(*args)
     @args = args
@@ -115,7 +125,7 @@ def nullify_logger
     c.quiet = nil
     c.verbose = nil
     c.logfile = nil
-    c.send(:logger=, nil)
+    c.logger = nil
   end
 
   ENV['LOGFILE'] = nil
@@ -126,4 +136,12 @@ def restore_devnull_logfile
   ENV['LOGFILE'] = '/dev/null'
 end
 
+def with_failure_handler(handler)
+  original_handler = Resque::Scheduler.failure_handler
+  Resque::Scheduler.failure_handler = handler
+  yield
+ensure
+  Resque::Scheduler.failure_handler = original_handler
+end
+
 restore_devnull_logfile

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resque-scheduler
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.2.0
 platform: ruby
 authors:
 - Ben VandenBos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-10 00:00:00.000000000 Z
+date: 2016-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -226,14 +226,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.2'
 description: |2
       Light weight job scheduling on top of Resque.
       Adds methods enqueue_at/enqueue_in to schedule jobs in the future.
@@ -280,6 +280,7 @@ files:
 - lib/resque/scheduler/delaying_extensions.rb
 - lib/resque/scheduler/env.rb
 - lib/resque/scheduler/extension.rb
+- lib/resque/scheduler/failure_handler.rb
 - lib/resque/scheduler/lock.rb
 - lib/resque/scheduler/lock/base.rb
 - lib/resque/scheduler/lock/basic.rb
@@ -336,7 +337,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: Light weight job scheduling on top of Resque
@@ -354,4 +355,3 @@ test_files:
 - test/scheduler_test.rb
 - test/test_helper.rb
 - test/util_test.rb
-has_rdoc: