resque-scheduler 2.5.1 → 4.10.2

data/.travis.yml

@@ -1,21 +0,0 @@
-language: ruby
-rvm:
-- 1.9.3
-- 2.0.0
-env:
-  global:
-  - RESQUE_SCHEDULER_DISABLE_TEST_REDIS_SERVER=1
-services:
-- redis-server
-notifications:
-  email:
-    recipients: daniel.buch+resque-scheduler@gmail.com
-deploy:
-  provider: rubygems
-  api_key:
-    secure: dM97lL/jTu14mEHD2Ih/vQfZ8cWJWb+DQ8UKZjkD2JfYtvwEAlkPG9RrrDkSHb5qkYxG2VAhjyx/0MZJ0TsVL6wrLMC9gcJb3yomw2Sch2Noj68tEndiSUHnxrB9gKzbhHbjLQXDqYf4Hco9/PHHQp4piFPJhLzNZRehIuTJPcA=
-  gem: resque-scheduler
-  on:
-    tags: true
-    repo: resque/resque-scheduler
-    rvm: 2.0.0

data/HISTORY.md

@@ -1,226 +0,0 @@
-# Resque Scheduler History / ChangeLog / Release Notes
-
-## 2.5.1 (2014-02-09)
-* Make signal handling (really) Ruby 2 compatible
-
-## 2.5.0 (2014-02-09)
-* Use `logger.error` when logging errors from `handle_errors`
-* Added search feature to the Delayed tab in Resque Web
-* Fix confusion with redis version requirements in `README.md`
-
-## 2.4.0 (2014-01-14)
-
-* Including optional env name in procline
-* Fixing an explosion regarding `every` in the views
-* Bumping the copyright year
-* Corrected doc for syntax of class and every keys
-* Adding a standalone executable
-* **POSSIBLE BREAKING CHANGE**: Dropping support for ree
-* Add support for persistence of dynamic schedules
-* Fix unsafe shutdown in Ruby 2
-* Adding `.configure` convenience method for block-style configuration
-* Add `.remove_delayed_selection` method to remove based on result of a block
-* Add support for viewing all schedules for a job in web UI
-* Use resque redis namespace in the master lock key
-* Including optional app name in procline
-* Various test improvements, :bug: fixes, and documentation updates!
-
-## 2.3.1 (2013-11-20)
-
-* Correcting `require_paths` in gemspec
-
-## 2.3.0 (2013-11-07)
-
-* Fix re-introduced `ThreadError` on Ruby 2
-* **BREAKING CHANGE**: Added `RESQUE_SCHEDULER_INTERVAL` in place of `INTERVAL`
-* Use `Float()` instead of `Integer()` to calculate poll sleep amount
-* Upgraded dependence of Resque to support 1.25
-* Add rufus scheduler `every` notice to README
-* Use `Resque.validate` instead of custom `.validate_job!`
-* Specify MIT license in gemspec
-
-## 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.11 (2013-11-20)
-
-* Fixed behavior of `#validate_job!` via `#enqueue_at_with_queue` #286
-* Correcting `require_paths` in gemspec #288
-
-## 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/ROADMAP.md

@@ -1,10 +0,0 @@
-TODO for v3.0.0
-===============
-
-- Clean up all RuboCop offences, breaking the API if necessary
-- Get to at least 95% test coverage
-
-TODO for v3.1.0
-===============
-
-- Compatibility with Resque 2

data/bin/resque-scheduler

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-# vim:fileencoding=utf-8
-
-require 'resque_scheduler'
-ResqueScheduler::Cli.run!

data/examples/Rakefile

@@ -1,2 +0,0 @@
-# vim:fileencoding=utf-8
-require 'resque_scheduler/tasks'

data/examples/config/initializers/resque-web.rb

@@ -1,37 +0,0 @@
-# vim:fileencoding=utf-8
-
-require 'json'
-require 'yaml'
-require 'resque'
-
-redis_env_var = ENV['REDIS_PROVIDER'] || 'REDIS_URL'
-Resque.redis = ENV[redis_env_var] || 'localhost:6379'
-
-require 'resque_scheduler'
-require 'resque_scheduler/server'
-
-schedule_yml = ENV['RESQUE_SCHEDULE_YML']
-if schedule_yml
-  if File.exist?(schedule_yml)
-    Resque.schedule = YAML.load_file(schedule_yml)
-  else
-    Resque.schedule = YAML.load(schedule_yml)
-  end
-end
-
-schedule_json = ENV['RESQUE_SCHEDULE_JSON']
-if schedule_json
-  if File.exist?(schedule_json)
-    Resque.schedule = JSON.parse(File.read(schedule_json))
-  else
-    Resque.schedule = JSON.parse(schedule_json)
-  end
-end
-
-class Putter
-  @queue = 'putting'
-
-  def self.perform(*args)
-    args.each { |arg| puts arg }
-  end
-end

data/examples/dynamic-scheduling/README.md

@@ -1,28 +0,0 @@
-Dynamic Scheduling Example
-==========================
-
-Possible workaround for
-https://github.com/resque/resque-scheduler/issues/269
-
-This folder contains just the relevant files you would have to put into
-a rails application.
-
-The problem we want to fix is that when resque-scheduler is restarted,
-any dynamically added jobs are wiped. To fix it, we will run a
-statically scheduled job that dynamically reschedules any missing
-dynamic schedules.
-
-This workaround uses both a dynamic schedule (every time a user is
-created, a schedule is dynamically added to send him a daily email) and
-a static schedule (a job runs hourly, starting 10 seconds after starting
-resque-scheduler, to check that there is a scheduled job to send an
-email for every user; missing schedules are added).
-
-This way even though a resque-scheduler restart wipes all dynamic
-schedules, they are recreated by the `fix_schedules` job that runs in
-the static schedule.  Even if dynamic schedules were lost for any reason
-(data loss in redis clusters, whatever), they will be recreated hourly.
-
-This workaround requires that enough information is saved in the
-database to recreate all dynamic schedules. In this case we create one
-dynamically scheduled job for every user in the database.

data/examples/dynamic-scheduling/app/jobs/fix_schedules_job.rb

@@ -1,54 +0,0 @@
-# vim:fileencoding=utf-8
-#
-# Background job to fix the schedule for email sending. Any missing
-# schedule will be added to resque-schedule.
-#
-# Recent resque-scheduler versions wipe all dynamic schedules when
-# restarting. This means all dynamic schedules, which are added via the
-# API, are wiped on each application redeployment. A workaround for this
-# sometimes undesirable behavior is to make this job part of a static
-# schedule (see config/initializers/resque.rb and
-# config/static_schedule.yml).  This job will be scheduled to run every
-# hour even after restarting resque-schedule, and will add back the
-# dynamic schedules that were wiped on restart. It also serves as
-# safeguard against schedules getting lost for any reason.
-#
-# For more detail about this unfortunate behavior of resque-scheduler see:
-#
-#   https://github.com/resque/resque-scheduler/issues/269
-#
-# The perform method of this class will be invoked from a Resque worker.
-
-class FixSchedulesJob
-  @queue = :send_emails
-
-  # Fix email sending schedules. Any user which does not have scheduled
-  # sending of emails will be detected, and the missing scheduled job
-  # will be added to resque-schedule.
-  #
-  # This method is intended to be invoked from Resque, which means it is
-  # performed in the background.
-  def self.perform
-    users_unscheduled = []
-
-    User.all.each do |user|
-      # get schedule for the user
-      schedule = Resque.get_schedule("send_email_#{user.id}")
-      # if a user has no schedule, add it to the array
-      if schedule.nil?
-        users_unscheduled << user
-      end
-    end
-
-    if users_unscheduled.length > 0
-      users_unscheduled.each do |user|
-        name = "send_email_#{user.id}"
-        config = {}
-        config[:class] = 'SendEmailJob'
-        config[:args] = user.id
-        config[:every] = '1d'
-        Resque.set_schedule(name, config)
-      end
-    end
-  end
-end

data/examples/dynamic-scheduling/app/jobs/send_email_job.rb

@@ -1,9 +0,0 @@
-# vim:fileencoding=utf-8
-
-class SendEmailJob
-  @queue = :send_emails
-
-  def self.perform(user_id)
-    # ... do whatever you have to do to send an email to the user
-  end
-end

data/examples/dynamic-scheduling/app/models/user.rb

@@ -1,16 +0,0 @@
-# vim:fileencoding=utf-8
-
-class User < ActiveRecord::Base
-  after_create :schedule_send_email
-  
-  private
-  
-  def schedule_send_email
-    name = "send_email_#{id}"
-    config = {}
-    config[:class] = 'SendEmailJob'
-    config[:args] = id
-    config[:every] = '1d'
-    Resque.set_schedule(name, config)
-  end
-end

data/examples/dynamic-scheduling/config/resque.yml

@@ -1,4 +0,0 @@
----
-development: localhost:6379
-test: localhost:6379:1
-production: localhost:6379 # or wherever your redis-server is in production

data/examples/dynamic-scheduling/config/static_schedule.yml

@@ -1,7 +0,0 @@
----
-FixSchedulesJob:
-  description: 'Add any missing email sending schedules'
-  queue: send_emails
-  every:
-    - '1h'
-    - :first_in: '10s'

data/examples/dynamic-scheduling/lib/tasks/resque.rake

@@ -1,48 +0,0 @@
-# vim:fileencoding=utf-8
-
-require 'resque/tasks'
-require 'resque_scheduler/tasks'
-require 'yaml'
-
-namespace :resque do
-  task :setup do
-    require 'resque'
-    require 'resque_scheduler'
-
-    rails_root = ENV['RAILS_ROOT'] || File.expand_path('../../../', __FILE__)
-    rails_env = ENV['RAILS_ENV'] || 'development'
-
-    # In resque-only servers we must require each job class individually,
-    # because we're not running the full Rails app
-    require "#{rails_root}/app/jobs/send_email_job"
-    require "#{rails_root}/app/jobs/fix_schedules_job"
-
-    resque_config = YAML.load_file(
-      File.join(rails_root.to_s, 'config', 'resque.yml')
-    )
-    Resque.redis = resque_config[rails_env]
-
-    # If you want to be able to dynamically change the schedule,
-    # uncomment this line.  A dynamic schedule can be updated via the
-    # Resque::Scheduler.set_schedule (and remove_schedule) methods.
-    # When dynamic is set to true, the scheduler process looks for
-    # schedule changes and applies them on the fly.
-    # Note: This feature is only available in >=2.0.0.
-    Resque::Scheduler.dynamic = true
-
-    # Load static schedule (only in background servers).
-    # The schedule doesn't need to be stored in a YAML, it just needs to
-    # be a hash.  YAML is usually the easiest.
-    Resque.schedule = YAML.load_file(
-      File.join(rails_root.to_s, 'config', 'static_schedule.yml')
-    )
-
-    Resque.before_fork do |job|
-      # Reconnect to the DB before running each job. Otherwise we get errors if
-      # the DB is restarted after starting Resque.
-      # Absolutely necessary on Heroku, otherwise we get a "PG::Error: SSL
-      # SYSCALL error: EOF detected" exception
-      ActiveRecord::Base.establish_connection
-    end
-  end
-end

data/examples/run-resque-web

@@ -1,3 +0,0 @@
-#!/bin/bash
-cd "$(dirname $0)"
-exec resque-web --foreground --no-launch config/initializers/resque-web.rb

data/lib/resque/scheduler_locking.rb

@@ -1,91 +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
-      lock_prefix = ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] || ''
-      lock_prefix += ':' if lock_prefix != ''
-      "#{Resque.redis.namespace}:#{lock_prefix}resque_scheduler_master_lock"
-    end
-
-    def redis_master_version
-      Resque.redis.info['redis_version'].to_f
-    end
-  end
-end