resque-scheduler 2.3.1 → 2.4.0

data/lib/resque_scheduler/server/views/delayed.erb

@@ -22,6 +22,7 @@
     <th>Job count</th>
     <th>Class</th>
     <th>Args</th>
+    <th>All schedules</th>
   </tr>
   <% resque.delayed_queue_peek(start, 20).each do |timestamp| %>
     <tr>
@@ -42,6 +43,7 @@
         <% end %>
       </td>
       <td><%= h(job['args'].inspect) if job && delayed_timestamp_size == 1 %></td>
+      <td><a href="<%=u URI("/delayed/jobs/#{job['class']}?args=" + URI.encode(job['args'].to_json)) %>">All schedules</a></td>
     </tr>
   <% end %>
 </table>

data/lib/resque_scheduler/server/views/delayed_schedules.erb

@@ -0,0 +1,20 @@
+<h1>Delayed jobs scheduled for <%= params[:klass] %> (<%= @args %>)</h1>
+
+<table class='jobs'>
+<tr>
+  <th>Timestamp</th>
+</tr>
+
+<% @timestamps.each do |t| %>
+<tr>
+  <td>
+    <%= Time.at(t) %>
+  </td>
+</tr>
+<% end %>
+<% if @timestamps.empty? %>
+  <tr>
+    <td class='no-data'>There are no such jobs scheduled.</td>
+  </tr>
+<% end %>
+</table>

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

@@ -19,24 +19,16 @@
   <% Resque.schedule.keys.sort.each do |name| %>
     <% config = Resque.schedule[name] %>
     <tr>
-      <td>
-        <form action="<%= u "/schedule/requeue" %>" method="post">
+      <td style="padding-top: 12px; padding-bottom: 2px; width: 10px">
+        <form action="<%= u "/schedule/requeue" %>" method="post" style="margin-left: 0">
           <input type="hidden" name="job_name" value="<%= h name %>">
           <input type="submit" value="Queue now">
         </form>
       </td>
       <td><%= h name %></td>
       <td><%= h config['description'] %></td>
-      <td style="white-space:nowrap"><%= if !config['every'].nil?
-                                           h('every: ' + (config['every'].is_a?(Array) ? config['every'].join(", ") : config['every'].to_s ))
-                                         elsif !config['cron'].nil?
-                                           h('cron: ' + config['cron'].to_s)
-                                         else
-                                           'Not currently scheduled'
-                                         end %></td>
-      <td><%= (config['class'].nil? && !config['custom_job_class'].nil?) ?
-              h(config['custom_job_class']) :
-              h(config['class']) %></td>
+      <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>
     </tr>

data/lib/resque_scheduler/tasks.rb

@@ -1,40 +1,28 @@
+# vim:fileencoding=utf-8
+
+require 'English'
 require 'resque/tasks'
-# will give you the resque tasks
+require 'resque_scheduler'
 
 namespace :resque do
   task :setup
 
-  desc "Start Resque Scheduler"
-  task :scheduler => :scheduler_setup do
-    require 'resque'
-    require 'resque_scheduler'
-
-    # Need to set this here for conditional Process.daemon redirect of stderr/stdout to /dev/null
-    Resque::Scheduler.mute = true if ENV['MUTE']
-
-    if ENV['BACKGROUND']
-      unless Process.respond_to?('daemon')
-        abort "env var BACKGROUND is set, which requires ruby >= 1.9"
-      end
-      Process.daemon(true, !Resque::Scheduler.mute)
-      Resque.redis.client.reconnect
-    end
-
-    File.open(ENV['PIDFILE'], 'w') { |f| f << Process.pid.to_s } if ENV['PIDFILE']
+  def scheduler_cli
+    @scheduler_cli ||= ResqueScheduler::Cli.new(
+      %W(#{ENV['RESQUE_SCHEDULER_OPTIONS']})
+    )
+  end
 
-    Resque::Scheduler.dynamic           = true if ENV['DYNAMIC_SCHEDULE']
-    Resque::Scheduler.verbose           = true if ENV['VERBOSE']
-    Resque::Scheduler.logfile           = ENV['LOGFILE'] if ENV['LOGFILE']
-    Resque::Scheduler.poll_sleep_amount = Float(ENV['RESQUE_SCHEDULER_INTERVAL']) if ENV['RESQUE_SCHEDULER_INTERVAL']
-    Resque::Scheduler.run
+  desc 'Start Resque Scheduler'
+  task scheduler: :scheduler_setup do
+    scheduler_cli.setup_env
+    scheduler_cli.run_forever
   end
 
   task :scheduler_setup do
-    if ENV['INITIALIZER_PATH']
-      load ENV['INITIALIZER_PATH'].to_s.strip
-    else
+    scheduler_cli.parse_options
+    unless scheduler_cli.pre_setup
       Rake::Task['resque:setup'].invoke
     end
   end
-
 end

data/lib/resque_scheduler/version.rb

@@ -1,5 +1,5 @@
 # vim:fileencoding=utf-8
 
 module ResqueScheduler
-  VERSION = '2.3.1'
+  VERSION = '2.4.0'
 end

data/resque-scheduler.gemspec

@@ -22,10 +22,12 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rack-test'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'json' if RUBY_VERSION < '1.9'
   spec.add_development_dependency 'rubocop' unless RUBY_VERSION < '1.9'
+  spec.add_development_dependency 'simplecov' unless RUBY_VERSION < '1.9'
 
   spec.add_runtime_dependency 'redis', '>= 3.0.0'
   spec.add_runtime_dependency 'resque', '~> 1.25'

data/test/cli_test.rb

@@ -0,0 +1,286 @@
+require_relative 'test_helper'
+
+context 'Cli' do
+  def new_cli(argv = [], env = {})
+    ResqueScheduler::Cli.new(argv, env)
+  end
+
+  test 'does not require any positional arguments' do
+    assert(!new_cli.nil?)
+  end
+
+  test 'initializes verbose from the env' do
+    cli = new_cli([], { 'VERBOSE' => 'foo' })
+    assert_equal('foo', cli.send(:options)[:verbose])
+  end
+
+  test 'defaults to non-verbose' do
+    assert_equal(false, !!new_cli.send(:options)[:verbose])
+  end
+
+  test 'accepts verbose via -v' do
+    cli = new_cli(%w(-v))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:verbose])
+  end
+
+  test 'accepts verbose via --verbose' do
+    cli = new_cli(%w(--verbose))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:verbose])
+  end
+
+  test 'initializes background from the env' do
+    cli = new_cli([], { 'BACKGROUND' => '1' })
+    assert_equal('1', cli.send(:options)[:background])
+  end
+
+  test 'defaults to background=false' do
+    assert_equal(false, !!new_cli.send(:options)[:background])
+  end
+
+  test 'accepts background via -B' do
+    cli = new_cli(%w(-B))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:background])
+  end
+
+  test 'accepts background via --background' do
+    cli = new_cli(%w(--background))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:background])
+  end
+
+  test 'daemonizes when background is true' do
+    Process.expects(:daemon)
+    cli = new_cli(%w(--background))
+    cli.pre_run
+  end
+
+  test 'reconnects redis when background is true' do
+    Process.stubs(:daemon)
+    mock_redis_client = mock('redis_client')
+    mock_redis = mock('redis')
+    mock_redis.expects(:client).returns(mock_redis_client)
+    mock_redis_client.expects(:reconnect)
+    Resque.expects(:redis).returns(mock_redis)
+    cli = new_cli(%w(--background))
+    cli.pre_run
+  end
+
+  test 'aborts when background is given and Process does not support daemon' do
+    Process.stubs(:daemon)
+    Process.expects(:respond_to?).with('daemon').returns(false)
+    cli = new_cli(%w(--background))
+    cli.expects(:abort)
+    cli.pre_run
+  end
+
+  test 'initializes pidfile from the env' do
+    cli = new_cli([], { 'PIDFILE' => 'bar' })
+    assert_equal('bar', cli.send(:options)[:pidfile])
+  end
+
+  test 'defaults to nil pidfile' do
+    assert_equal(nil, new_cli.send(:options)[:pidfile])
+  end
+
+  test 'accepts pidfile via -P' do
+    cli = new_cli(%w(-P foo))
+    cli.parse_options
+    assert_equal('foo', cli.send(:options)[:pidfile])
+  end
+
+  test 'accepts pidfile via --pidfile' do
+    cli = new_cli(%w(--pidfile foo))
+    cli.parse_options
+    assert_equal('foo', cli.send(:options)[:pidfile])
+  end
+
+  test 'writes pid to pidfile when given' do
+    mock_pidfile = mock('pidfile')
+    mock_pidfile.expects(:puts)
+    File.expects(:open).with('derp.pid', 'w').yields(mock_pidfile)
+    cli = new_cli(%w(--pidfile derp.pid))
+    cli.pre_run
+  end
+
+  test 'initializes dynamic from the env' do
+    cli = new_cli([], { 'DYNAMIC_SCHEDULE' => '1' })
+    assert_equal('flurb', cli.send(:options)[:dynamic])
+  end
+
+  test 'defaults to nil dynamic' do
+    assert_equal(nil, new_cli.send(:options)[:dynamic])
+  end
+
+  test 'accepts dynamic via -D' do
+    cli = new_cli(%w(-D))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:dynamic])
+  end
+
+  test 'accepts dynamic via --dynamic-schedule' do
+    cli = new_cli(%w(--dynamic-schedule))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:dynamic])
+  end
+
+  test 'initializes env from the env' do
+    cli = new_cli([], { 'RAILS_ENV' => 'flurb' })
+    assert_equal('flurb', cli.send(:options)[:env])
+  end
+
+  test 'defaults to nil env' do
+    assert_equal(nil, new_cli.send(:options)[:env])
+  end
+
+  test 'accepts env via -E' do
+    cli = new_cli(%w(-E bork))
+    cli.parse_options
+    assert_equal('bork', cli.send(:options)[:env])
+  end
+
+  test 'accepts env via --environment' do
+    cli = new_cli(%w(--environment hork))
+    cli.parse_options
+    assert_equal('hork', cli.send(:options)[:env])
+  end
+
+  test 'initializes initializer_path from the env' do
+    cli = new_cli([], { 'INITIALIZER_PATH' => 'herp.rb' })
+    assert_equal('herp.rb', cli.send(:options)[:initializer_path])
+  end
+
+  test 'defaults to nil initializer_path' do
+    assert_equal(nil, new_cli.send(:options)[:initializer_path])
+  end
+
+  test 'accepts initializer_path via -I' do
+    cli = new_cli(%w(-I hambone.rb))
+    cli.parse_options
+    assert_equal('hambone.rb', cli.send(:options)[:initializer_path])
+  end
+
+  test 'accepts initializer_path via --initalizer-path' do
+    cli = new_cli(%w(--initializer-path cookies.rb))
+    cli.parse_options
+    assert_equal('cookies.rb', cli.send(:options)[:initializer_path])
+  end
+
+  test 'loads given initilalizer_path' do
+    cli = new_cli(%w(--initializer-path fuzzbert.rb))
+    cli.expects(:load).with('fuzzbert.rb')
+    cli.pre_run
+  end
+
+  test 'initializes mute/quiet from the env' do
+    cli = new_cli([], { 'QUIET' => '1' })
+    assert_equal('1', cli.send(:options)[:mute])
+  end
+
+  test 'defaults to unmuted' do
+    assert_equal(false, !!new_cli.send(:options)[:mute])
+  end
+
+  test 'accepts mute/quiet via -q' do
+    cli = new_cli(%w(-q))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:mute])
+  end
+
+  test 'accepts mute via --quiet' do
+    cli = new_cli(%w(--quiet))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:mute])
+  end
+
+  test 'initializes logfile from the env' do
+    cli = new_cli([], { 'LOGFILE' => 'derp.log' })
+    assert_equal('derp.log', cli.send(:options)[:logfile])
+  end
+
+  test 'defaults to nil logfile' do
+    assert_equal(nil, new_cli.send(:options)[:logfile])
+  end
+
+  test 'accepts logfile via -l' do
+    cli = new_cli(%w(-l hurm.out))
+    cli.parse_options
+    assert_equal('hurm.out', cli.send(:options)[:logfile])
+  end
+
+  test 'accepts logfile via --logfile' do
+    cli = new_cli(%w(--logfile flam.log))
+    cli.parse_options
+    assert_equal('flam.log', cli.send(:options)[:logfile])
+  end
+
+  test 'initializes logformat from the env' do
+    cli = new_cli([], { 'LOGFORMAT' => 'fancy' })
+    assert_equal('fancy', cli.send(:options)[:logformat])
+  end
+
+  test 'defaults to nil logformat' do
+    assert_equal(nil, new_cli.send(:options)[:logformat])
+  end
+
+  test 'accepts logformat via -F' do
+    cli = new_cli(%w(-F silly))
+    cli.parse_options
+    assert_equal('silly', cli.send(:options)[:logformat])
+  end
+
+  test 'accepts logformat via --logformat' do
+    cli = new_cli(%w(--logformat flimsy))
+    cli.parse_options
+    assert_equal('flimsy', cli.send(:options)[:logformat])
+  end
+
+  test 'initializes dynamic from the env' do
+    cli = new_cli([], { 'DYNAMIC_SCHEDULE' => '1' })
+    assert_equal('1', cli.send(:options)[:dynamic])
+  end
+
+  test 'defaults to dynamic=false' do
+    assert_equal(false, !!new_cli.send(:options)[:dynamic])
+  end
+
+  test 'accepts dynamic via -D' do
+    cli = new_cli(%w(-D))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:dynamic])
+  end
+
+  test 'accepts dynamic via --dynamic-schedule' do
+    cli = new_cli(%w(--dynamic-schedule))
+    cli.parse_options
+    assert_equal(true, cli.send(:options)[:dynamic])
+  end
+
+  test 'initializes app_name from the env' do
+    cli = new_cli([], { 'APP_NAME' => 'sprocket' })
+    assert_equal('sprocket', cli.send(:options)[:app_name])
+  end
+
+  test 'defaults to nil app_name' do
+    assert_equal(nil, new_cli.send(:options)[:app_name])
+  end
+
+  test 'accepts app_name via -n' do
+    cli = new_cli(%w(-n hambone))
+    cli.parse_options
+    assert_equal('hambone', cli.send(:options)[:app_name])
+  end
+
+  test 'accepts app_name via --app-name' do
+    cli = new_cli(%w(--app-name flimsy))
+    cli.parse_options
+    assert_equal('flimsy', cli.send(:options)[:app_name])
+  end
+
+  test 'runs Resque::Scheduler' do
+    Resque::Scheduler.expects(:run)
+    ResqueScheduler::Cli.run!([], {})
+  end
+end

data/test/delayed_queue_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require_relative 'test_helper'
 
 context "DelayedQueue" do
 
@@ -313,6 +313,75 @@ context "DelayedQueue" do
     assert_equal(2, Resque.count_all_scheduled_jobs)
   end
 
+  test "remove_delayed_selection removes multiple items matching arguments at same timestamp" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "bar", "llama")
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    Resque.enqueue_at(t, SomeIvarJob, "bar", "monkey")
+    Resque.enqueue_at(t, SomeIvarJob, "bar", "platypus")
+    Resque.enqueue_at(t, SomeIvarJob, "baz")
+    Resque.enqueue_at(t, SomeIvarJob, "bar", "llama")
+    Resque.enqueue_at(t, SomeIvarJob, "bar", "llama")
+
+    assert_equal(5, Resque.remove_delayed_selection {|args| args[0] == 'bar'})
+    assert_equal(2, Resque.count_all_scheduled_jobs)
+  end
+
+  test "remove_delayed_selection removes single item matching arguments" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    Resque.enqueue_at(t + 1, SomeIvarJob, "bar")
+    Resque.enqueue_at(t + 2, SomeIvarJob, "bar")
+    Resque.enqueue_at(t + 3, SomeIvarJob, "baz")
+
+    assert_equal(1, Resque.remove_delayed_selection {|args| args[0] == 'foo'})
+    assert_equal(3, Resque.count_all_scheduled_jobs)
+  end
+
+  test "remove_delayed_selection removes multiple items matching arguments" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    Resque.enqueue_at(t + 1, SomeIvarJob, "bar")
+    Resque.enqueue_at(t + 2, SomeIvarJob, "bar")
+    Resque.enqueue_at(t + 3, SomeIvarJob, "baz")
+
+    assert_equal(2, Resque.remove_delayed_selection {|args| args[0] == 'bar'})
+    assert_equal(2, Resque.count_all_scheduled_jobs)
+  end
+
+  test "remove_delayed_selection removes multiple items matching arguments as hash" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, :foo => "foo")
+    Resque.enqueue_at(t + 1, SomeIvarJob, :foo => "bar")
+    Resque.enqueue_at(t + 2, SomeIvarJob, :foo => "bar")
+    Resque.enqueue_at(t + 3, SomeIvarJob, :foo => "baz")
+
+    assert_equal(2, Resque.remove_delayed_selection {|args| args[0]['foo'] == 'bar'})
+    assert_equal(2, Resque.count_all_scheduled_jobs)
+  end
+
+  test "remove_delayed_selection ignores jobs with no arguments" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob)
+    Resque.enqueue_at(t + 1, SomeIvarJob)
+    Resque.enqueue_at(t + 2, SomeIvarJob)
+    Resque.enqueue_at(t + 3, SomeIvarJob)
+
+    assert_equal(0, Resque.remove_delayed_selection {|args| args[0] == 'bar'})
+    assert_equal(4, Resque.count_all_scheduled_jobs)
+  end
+
+  test "remove_delayed_selection doesn't remove items it shouldn't" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob, "foo")
+    Resque.enqueue_at(t + 1, SomeIvarJob, "bar")
+    Resque.enqueue_at(t + 2, SomeIvarJob, "bar")
+    Resque.enqueue_at(t + 3, SomeIvarJob, "baz")
+
+    assert_equal(0, Resque.remove_delayed_selection {|args| args[0] == 'qux'})
+    assert_equal(4, Resque.count_all_scheduled_jobs)
+  end
+
   test "remove_delayed_job_from_timestamp removes instances of jobs at a given timestamp" do
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob, "foo")