resque-scheduler 2.2.0 → 4.10.2

data/HISTORY.md

@@ -1,180 +0,0 @@
-## 2.2.0 (2013-10-13)
-
-* Locking rufus-scheduler dependency to `~> 2.0`
-* Updated redis dependency to `>= 3.0.0`
-* Add support for parameterized resque jobs.
-* Allowing prefix for `master_lock_key`.
-* Add `Resque.clean_schedules` method, which is useful when setting up the
-  scheduler for the first time.
-* Bug fixes related to first time schedule retrieval and missing schedules.
-
-## 2.1.0 (2013-09-20)
-
-* Locking to resque < 1.25.0 (for now)
-* Ensuring `Resque.schedule=` sets rather than appends
-* Process daemonization fixes including stdio redirection and redis client
-  reconnection
-* Add `#scheduled_at` which returns an array of timestamps at which the
-  specified job is scheduled
-* Syncing stdout/stderr
-* Add `#enqueue_delayed` for enqueueing specific delayed jobs immediately
-* Show server local time in resque-web
-* Enqueue immediately if job is being enqueued in the past
-* Using a logger instead of `#puts`, configurable via `LOGFILE`, `VERBOSE`, and
-  `MUTE` environmental variables, as well as being settable via
-  `Resque::Scheduler#logger`
-* Fixing scheduler template when arrays are passed to rufus-scheduler
-* Add support for configuring `Resque::Scheduler.poll_sleep_amount` via the
-  `INTERVAL` environmental variable.
-* Fixed shutdown in ruby 2.0.0
-* Removed dependency on `Resque::Helpers`
-
-## 2.0.1 (2013-03-20)
-
-* Adding locking to support master failover
-* Allow custom job classes to be used in `Resque.enqueue_at`
-* More efficient `#remove_delayed` implementation
-* Allowing `#enqueue_at` to call `#scheduled` when `Resque.inline` is `true`
-
-## 2.0.0 (2012-05-04)
-
-* Add support for Resque.inline configuration (carlosantoniodasilva)
-* Fixing possible job loss race condition around deleting delayed queues
-  and enqueuing a job 0 seconds in the future.
-
-### 2.0.0.h (2012-03-19)
-
-* Adding plugin support with hooks (andreas)
-
-### 2.0.0.f (2011-11-03)
-
-* TODO: address race condition with delayed jobs (using redis transactions)
-* Support `ENV['BACKGROUND']` flag for daemonizing (bernerdschaefer)
-* Added support for `before_schedule` and `after_schedule` hooks (yaauie)
-* Added `remove_delayed_job_from_timestamp` to remove delayed jobs from
-  a given timestamp.
-
-### 2.0.0.e (2011-09-16)
-
-* Adding `enqueue_at_with_queue`/`enqueue_in_with_queue` support (niralisse)
-* Adding `Resque::Scheduler.poll_sleep_amount` to allow for configuring
-  the sleep time b/w delayed queue polls.
-* Add a "Clear Delayed Jobs" button to the Delayed Jobs page (john-griffin)
-* Fixed pagination issue on the Delayed tab
-
-### 2.0.0.d (2011-04-04)
-
-* porting bug fixes from v1.9-stable
-
-### 2.0.0.c
-
-* Rake task drop a pid file (sreeix)
-
-### 2.0.0.b
-
-* Bug fixes
-
-### 2.0.0.a
-
-* Dynamic schedule support (brianjlandau, davidyang)
-* Now depends on redis >=1.3
-
-## 1.9.10 (2013-09-19)
-
-* Backported `#enqueue_at_with_queue`
-* Locking to resque < 1.25.0
-* Mocha setup compatibility
-* Ruby 1.8 compatibility in scheduler tab when schedule keys are symbols
-
-## 1.9.9 (2011-03-29)
-
-* Compatibility with resque 1.15.0
-
-## 1.9.8 (???)
-
-* Validates delayed jobs prior to insertion into the delayed queue (bogdan)
-* Rescue exceptions that occur during queuing and log them (dgrijalva)
-
-## 1.9.7 (2010-11-09)
-
-* Support for rufus-scheduler "every" syntax (fallwith)
-* Ability to pass a Time to `handle_delayed_items` for testing/staging (rcarver)
-
-## 1.9.6 (2010-10-08)
-
-* Support for custom job classes (like resque-status) (mattetti)
-
-## 1.9.5 (2010-09-09)
-
-* Updated scheduler rake task to allow for an alternate setup task
-  to avoid loading the entire stack. (chewbranca)
-* Fixed sig issue on win32 (#25)
-
-## 1.9.4 (2010-07-29)
-
-* Adding ability to remove jobs from delayed queue (joshsz)
-* Fixing issue #23 (removing .present? reference)
-
-## 1.9.3 (2010-07-07)
-
-* Bug fix (#19)
-
-## 1.9.2 (2010-06-16)
-
-* Fixing issue with redis gem 2.0.1 and redis server 1.2.6 (dbackeus)
-
-## 1.9.1 (2010-06-04)
-
-* Fixing issue with redis server 1.2.6 and redis gem 2.0.1
-
-## 1.9.0 (2010-06-04)
-
-* Adding redis 2.0 support (bpo)
-
-## 1.8.2 (2010-06-04)
-
-* Adding queue now functionality to delayed timestamps (daviddoan)
-
-## 1.8.1 (2010-05-19)
-
-* Adding rails_env for scheduled jobs to support scoping jobs by
-  RAILS_ENV (gravis).
-* Fixing ruby 1.8.6 compatibility issue.
-* Adding gemspec for bundler support.
-
-## 1.8.0 (2010-04-14)
-
-* Moving version to match corresponding resque version
-* Sorting schedule on Scheduler tab
-* Adding tests for resque-web (gravis)
-
-## 1.0.5 (2010-03-01)
-
-* Fixed support for overriding queue from schedule config.
-* Removed resque-web dependency on loading the job classes for "Queue Now",
-  provided "queue" is specified in the schedule.
-* The queue is now stored with the job and arguments in the delayed queue so
-  there is no longer a need for the scheduler to load job classes to introspect
-  the queue.
-
-## 1.0.4 (2010-02-26)
-
-* Added support for specifying the queue to put the job onto. This allows for
-  you to have one job that can go onto multiple queues and be able to schedule
-  jobs without having to load the job classes.
-
-## 1.0.3 (2010-02-11)
-
-* Added support for scheduled jobs with empty crons. This is helpful to have
-  jobs that you don't want on a schedule, but do want to be able to queue by
-  clicking a button.
-
-## 1.0.2 (2010-02-?)
-
-* Change Delayed Job tab to display job details if only 1 job exists
-  for a given timestamp
-
-## 1.0.1 (2010-01-?)
-
-* Bugfix: delayed jobs close together resulted in a 5 second sleep
-

data/lib/resque/scheduler_locking.rb

@@ -1,90 +0,0 @@
-
-# ### Locking the scheduler process
-#
-# There are two places in resque-scheduler that need to be synchonized
-# in order to be able to run redundant scheduler processes while ensuring jobs don't
-# get queued multiple times when the master process changes.
-#
-# 1) Processing the delayed queues (jobs that are created from enqueue_at/enqueue_in, etc)
-# 2) Processing the scheduled (cron-like) jobs from rufus-scheduler
-#
-# Protecting the delayed queues (#1) is relatively easy.  A simple SETNX in
-# redis would suffice.  However, protecting the scheduled jobs is trickier
-# because the clocks on machines could be slightly off or actual firing times
-# could vary slightly due to load.  If scheduler A's clock is slightly ahead
-# of scheduler B's clock (since they are on different machines), when
-# scheduler A dies, we need to ensure that scheduler B doesn't queue jobs
-# that A already queued before it's death. (This all assumes that it is
-# better to miss a few scheduled jobs than it is to run them multiple times
-# for the same iteration.)
-#
-# To avoid queuing multiple jobs in the case of master fail-over, the master
-# should remain the master as long as it can rather than a simple SETNX which
-# would result in the master roll being passed around frequently.
-#
-# Locking Scheme:
-# Each resque-scheduler process attempts to get the master lock via SETNX.
-# Once obtained, it sets the expiration for 3 minutes (configurable).  The
-# master process continually updates the timeout on the lock key to be 3
-# minutes in the future in it's loop(s) (see `run`) and when jobs come out of
-# rufus-scheduler (see `load_schedule_job`).  That ensures that a minimum of
-# 3 minutes must pass since the last queuing operation before a new master is
-# chosen.  If, for whatever reason, the master fails to update the expiration
-# for 3 minutes, the key expires and the lock is up for grabs.  If
-# miraculously the original master comes back to life, it will realize it is
-# no longer the master and stop processing jobs.
-#
-# The clocks on the scheduler machines can then be up to 3 minutes off from
-# each other without the risk of queueing the same scheduled job twice during
-# a master change.  The catch is, in the event of a master change, no
-# scheduled jobs will be queued during those 3 minutes.  So, there is a trade
-# off: the higher the timeout, the less likely scheduled jobs will be fired
-# twice but greater chances of missing scheduled jobs.  The lower the timeout,
-# less likely jobs will be missed, greater the chances of jobs firing twice.  If
-# you don't care about jobs firing twice or are certain your machines' clocks
-# are well in sync, a lower timeout is preferable.  One thing to keep in mind:
-# this only effects *scheduled* jobs - delayed jobs will never be lost or
-# skipped since eventually a master will come online and it will process
-# everything that is ready (no matter how old it is).  Scheduled jobs work
-# like cron - if you stop cron, no jobs fire while it's stopped and it doesn't
-# fire jobs that were missed when it starts up again.
-
-require 'resque/scheduler/lock'
-
-module Resque
-  module SchedulerLocking
-    def master_lock
-      @master_lock ||= build_master_lock
-    end
-
-    def supports_lua?
-      redis_master_version >= 2.5
-    end
-
-    def is_master?
-      master_lock.acquire! || master_lock.locked?
-    end
-
-    def release_master_lock!
-      master_lock.release!
-    end
-
-  private
-
-    def build_master_lock
-      if supports_lua?
-        Resque::Scheduler::Lock::Resilient.new(master_lock_key)
-      else
-        Resque::Scheduler::Lock::Basic.new(master_lock_key)
-      end
-    end
-
-    def master_lock_key
-      "#{ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] || ''}resque_scheduler_master_lock".to_sym
-    end
-
-    def redis_master_version
-      Resque.redis.info['redis_version'].to_f
-    end
-  end
-end

data/lib/resque_scheduler/logger_builder.rb

@@ -1,51 +0,0 @@
-module ResqueScheduler
-  # Just builds a logger, with specified verbosity and destination.
-  # The simplest example:
-  #
-  #   ResqueScheduler::LoggerBuilder.new.build
-  class LoggerBuilder
-    # Initializes new instance of the builder
-    #
-    # Pass :opts Hash with
-    #   - :mute if logger needs to be silent for all levels. Default - false
-    #   - :verbose if there is a need in debug messages. Default - false
-    #   - :log_dev to output logs into a desired file. Default - STDOUT
-    #
-    # Example:
-    #
-    #   LoggerBuilder.new(:mute => false, :verbose => true, :log_dev => 'log/sheduler.log')
-    def initialize(opts={})
-      @muted   = !!opts[:mute]
-      @verbose = !!opts[:verbose]
-      @log_dev = opts[:log_dev] || STDOUT
-    end
-
-    # Returns an instance of Logger
-    def build
-      logger = Logger.new(@log_dev)
-      logger.level = level
-      logger.datetime_format = "%Y-%m-%d %H:%M:%S"
-      logger.formatter = formatter
-
-      logger
-    end
-
-    private
-
-    def level
-      if @verbose && !@muted
-        Logger::DEBUG
-      elsif !@muted
-        Logger::INFO
-      else
-        Logger::FATAL
-      end
-    end
-
-    def formatter
-      proc do |severity, datetime, progname, msg|
-        "[#{severity}] #{datetime}: #{msg}\n"
-      end
-    end
-  end
-end

data/lib/resque_scheduler/plugin.rb

@@ -1,25 +0,0 @@
-module ResqueScheduler
-  module Plugin
-    extend self
-    def hooks(job, pattern)
-      job.methods.grep(/^#{pattern}/).sort
-    end
-
-    def run_hooks(job, pattern, *args)
-      results = hooks(job, pattern).collect do |hook|
-        job.send(hook, *args)
-      end
-
-      results.all? { |result| result != false }
-    end
-
-    def method_missing(method_name, *args, &block)
-      if method_name.to_s =~ /^run_(.*)_hooks$/
-        job = args.shift
-        run_hooks job, $1, *args
-      else
-        super
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-<h1>Schedule</h1>
-
-<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 %>
-</p>
-
-<table>
-  <tr>
-    <th></th>
-    <th>Name</th>
-    <th>Description</th>
-    <th>Interval</th>
-    <th>Class</th>
-    <th>Queue</th>
-    <th>Arguments</th>
-  </tr>
-  <% Resque.schedule.keys.sort.each do |name| %>
-    <% config = Resque.schedule[name] %>
-    <tr>
-      <td>
-        <form action="<%= u "/schedule/requeue" %>" method="post">
-          <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><%= h config['queue'] || queue_from_class_name(config['class']) %></td>
-      <td><%= h config['args'].inspect %></td>
-    </tr>
-  <% end %>
-</table>

data/lib/resque_scheduler/server.rb

@@ -1,92 +0,0 @@
-require 'resque_scheduler'
-require 'resque/server'
-
-# Extend Resque::Server to add tabs
-module ResqueScheduler
-
-  module Server
-
-    def self.included(base)
-
-      base.class_eval do
-
-        helpers do
-          def format_time(t)
-            t.strftime("%Y-%m-%d %H:%M:%S %z")
-          end
-
-          def queue_from_class_name(class_name)
-            Resque.queue_from_class(Resque.constantize(class_name))
-          end
-        end
-
-        get "/schedule" do
-          Resque.reload_schedule! if Resque::Scheduler.dynamic
-          # Is there a better way to specify alternate template locations with sinatra?
-          erb File.read(File.join(File.dirname(__FILE__), 'server/views/scheduler.erb'))
-        end
-
-        post "/schedule/requeue" do
-          @job_name = params['job_name'] || params[:job_name]
-          config = Resque.schedule[@job_name]
-          @parameters = config['parameters'] || config[:parameters]
-          if @parameters
-            erb File.read(File.join(File.dirname(__FILE__), 'server/views/requeue-params.erb'))
-          else
-            Resque::Scheduler.enqueue_from_config(config)
-            redirect u("/overview")
-          end
-        end
-
-        post "/schedule/requeue_with_params" do
-          job_name = params['job_name'] || params[:job_name]
-          config = Resque.schedule[job_name]
-          # Build args hash from post data (removing the job name)
-          submitted_args = params.reject {|key, value| key == 'job_name' || key == :job_name}
-
-          # Merge constructed args hash with existing args hash for
-          # the job, if it exists
-          config_args = config['args'] || config[:args] || {}
-          config_args = config_args.merge(submitted_args)
-
-          # Insert the args hash into config and queue the resque job
-          config = config.merge({'args' => config_args})
-          Resque::Scheduler.enqueue_from_config(config)
-          redirect u("/overview")
-        end
-
-        get "/delayed" do
-          # Is there a better way to specify alternate template locations with sinatra?
-          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed.erb'))
-        end
-
-        get "/delayed/:timestamp" do
-          # Is there a better way to specify alternate template locations with sinatra?
-          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed_timestamp.erb'))
-        end
-
-        post "/delayed/queue_now" do
-          timestamp = params['timestamp']
-          Resque::Scheduler.enqueue_delayed_items_for_timestamp(timestamp.to_i) if timestamp.to_i > 0
-          redirect u("/overview")
-        end
-
-        post "/delayed/clear" do
-          Resque.reset_delayed_queue
-          redirect u('delayed')
-        end
-
-      end
-
-    end
-
-    Resque::Server.tabs << 'Schedule'
-    Resque::Server.tabs << 'Delayed'
-
-  end
-
-end
-
-Resque::Server.class_eval do
-  include ResqueScheduler::Server
-end

data/lib/resque_scheduler/tasks.rb

@@ -1,40 +0,0 @@
-require 'resque/tasks'
-# will give you the resque tasks
-
-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']
-
-    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 = Integer(ENV['INTERVAL']) if ENV['INTERVAL']
-    Resque::Scheduler.run
-  end
-
-  task :scheduler_setup do
-    if ENV['INITIALIZER_PATH']
-      load ENV['INITIALIZER_PATH'].to_s.strip
-    else
-      Rake::Task['resque:setup'].invoke
-    end
-  end
-
-end

data/lib/resque_scheduler/version.rb

@@ -1,3 +0,0 @@
-module ResqueScheduler
-  VERSION = '2.2.0'
-end