resque-scheduler 4.2.1 → 4.3.0

data/.vagrant-provision-as-vagrant.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-set -e
-set -x
-
-ln -svf /vagrant/.vagrant-skel/bashrc ~/.bashrc
-ln -svf /vagrant/.vagrant-skel/bash_profile ~/.bash_profile
-
-source ~/.bashrc
-
-set +x
-curl -L https://get.rvm.io | bash -s stable --ruby=2.0.0 --auto-dotfiles
-
-source ~/.rvm/scripts/rvm
-gem install --no-ri --no-rdoc bundler foreman

data/.vagrant-provision.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-
-export DEBIAN_FRONTEND=noninteractive
-
-umask 022
-
-set -e
-set -x
-
-apt-get update -yq
-apt-get install --no-install-suggests -yq python-software-properties
-add-apt-repository -y ppa:chris-lea/redis-server
-apt-get update -yq
-apt-get install --no-install-suggests -yq \
-  build-essential \
-  byobu \
-  curl \
-  git \
-  make \
-  redis-server \
-  screen
-
-su - vagrant -c /vagrant/.vagrant-provision-as-vagrant.sh

data/.vagrant-skel/bash_profile

@@ -1,7 +0,0 @@
-#!bash
-
-[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" # Load RVM into a shell session *as a function*
-
-if [[ "$PS1" ]] ; then
-  cd /vagrant
-fi

data/.vagrant-skel/bashrc

@@ -1,7 +0,0 @@
-#!bash
-
-export LANG='en_US.UTF-8'
-export LANGUAGE='en_US.UTF-8'
-export LC_ALL='en_US.UTF-8'
-
-export PATH=$PATH:$HOME/.rvm/bin # Add RVM to PATH for scripting

data/Vagrantfile

@@ -1,14 +0,0 @@
-# vim:filetype=ruby
-
-Vagrant.configure('2') do |config|
-  config.vm.hostname = 'resque-scheduler'
-  config.vm.box = 'precise64'
-  config.vm.box_url = 'http://cloud-images.ubuntu.com/vagrant/precise/' <<
-                      'current/precise-server-cloudimg-amd64-vagrant-disk1.box'
-
-  config.vm.network :private_network, ip: '33.33.33.10', auto_correct: true
-  config.vm.network :forwarded_port, guest: 5678, host: 15678,
-                                     auto_correct: true
-
-  config.vm.provision :shell, path: '.vagrant-provision.sh'
-end

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
-  Resque.schedule = if File.exist?(schedule_yml)
-                      YAML.load_file(schedule_yml)
-                    else
-                      YAML.load(schedule_yml)
-                    end
-end
-
-schedule_json = ENV['RESQUE_SCHEDULE_JSON']
-if schedule_json
-  Resque.schedule = if File.exist?(schedule_json)
-                      JSON.parse(File.read(schedule_json))
-                    else
-                      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,52 +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.fetch_schedule("send_email_#{user.id}")
-      # if a user has no schedule, add it to the array
-      users_unscheduled << user if schedule.nil?
-    end
-
-    unless users_unscheduled.empty?
-      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/script/migrate_to_timestamps_set.rb

@@ -1,16 +0,0 @@
-# vim:fileencoding=utf-8
-
-require 'redis'
-require 'resque'
-
-if ARGV.size != 1
-  puts 'migrate_to_timestamps_set.rb <redis-host:redis-port>'
-  exit
-end
-
-Resque.redis = ARGV[0]
-redis = Resque.redis
-Array(redis.keys('delayed:*')).each do |key|
-  jobs = redis.lrange(key, 0, -1)
-  jobs.each { |job| redis.sadd("timestamps:#{job}", key) }
-end

data/tasks/resque_scheduler.rake

@@ -1,2 +0,0 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'resque/scheduler/tasks'

data/test/cli_test.rb

@@ -1,231 +0,0 @@
-# vim:fileencoding=utf-8
-require_relative 'test_helper'
-
-context 'Cli' do
-  def mock_runtime_env
-    mock.tap { |m| m.stubs(:setup) }
-  end
-
-  def new_cli(argv = [], env = {})
-    Resque::Scheduler::Cli.new(argv, env).tap do |cli|
-      cli.stubs(:runtime_env).returns(mock_runtime_env)
-    end
-  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 '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 'defaults to nil dynamic' do
-    assert_equal(nil, new_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 quiet from the env' do
-    cli = new_cli([], 'QUIET' => '1')
-    assert_equal('1', cli.send(:options)[:quiet])
-  end
-
-  test 'defaults to un-quieted' do
-    assert_equal(false, !!new_cli.send(:options)[:quiet])
-  end
-
-  test 'accepts quiet via -q' do
-    cli = new_cli(%w(-q))
-    cli.parse_options
-    assert_equal(true, cli.send(:options)[:quiet])
-  end
-
-  test 'accepts quiet via --quiet' do
-    cli = new_cli(%w(--quiet))
-    cli.parse_options
-    assert_equal(true, cli.send(:options)[:quiet])
-  end
-
-  test 'initializes logfile from the env' do
-    cli = new_cli([], 'LOGFILE' => 'example.log')
-    assert_equal('example.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 'defaults to dynamic=false' do
-    assert_equal(false, !!new_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)
-    Resque::Scheduler::Cli.run!([], {})
-  end
-
-  test 'does not create keys for unspecified environment variables' do
-    cli = new_cli([], 'DYNAMIC_SCHEDULE' => 'true')
-    assert_equal({ dynamic: 'true' }, cli.send(:options))
-  end
-end