sidekiq 2.15.1 → 4.2.10

data/Contributing.md

@@ -1,29 +0,0 @@
-# Contributing
-
-First of all, thank you for even opening this file up!  I hope you find
-it worthwhile to help out with Sidekiq.
-
-## Issues
-
-When opening an issue, please include a **backtrace** with your error.
-
-## Code
-
-If you're interested in helping or contributing to Sidekiq, here's
-some known areas which need improvement:
-
-* The Web UI and sidekiq.org website could always use more polish.  If you have an eye for design and an idea for improvement, please open an issue and let us know.
-* The Sidekiq API has a serious issue: deleting elements and iterating
-  at the same time is broken, see #866, #1060.
-* Make normal testing and inline testing dynamic: #1053
-* Your brilliant idea which I haven't listed!
-
-It's always best to open an issue before investing a lot of time into a
-fix or new functionality.  Functionality must meet my design goals and
-vision for the project to be accepted; I would be happy to discuss how
-your idea can best fit into Sidekiq.
-
-
-## Sponsorship
-
-If you've got more money than time and want to sponsor Sidekiq's continued support, your company can buy [Sidekiq Pro](http://sidekiq.org/pro).  You get great functionality, I continue to fix bugs and enhance Sidekiq for years to come.

data/config.ru

@@ -1,18 +0,0 @@
-require 'sidekiq'
-
-Sidekiq.configure_client do |config|
-  config.redis = { :size => 1 }
-end
-
-#Sidekiq.redis {|conn| conn.flushdb }
-#10.times do |idx|
-  #Sidekiq::Client.push('class' => 'HardWorker', 'args' => ['foo', 0.1, idx])
-#end
-
-#Sidekiq.redis { |conn| conn.zadd('retry', Time.now.utc.to_f + 3000, MultiJson.encode({
-  #'class' => 'HardWorker', 'args' => ['foo', 0.1, Time.now.to_f],
-  #'queue' => 'default', 'error_message' => 'No such method', 'error_class' => 'NoMethodError',
-  #'failed_at' => Time.now.utc, 'retry_count' => 0 })) }
-
-require 'sidekiq/web'
-run Sidekiq::Web

data/lib/sidekiq/actor.rb

@@ -1,7 +0,0 @@
-module Sidekiq
-  module Actor
-    def self.included(klass)
-      klass.send(:include, Celluloid)
-    end
-  end
-end

data/lib/sidekiq/capistrano.rb

@@ -1,54 +0,0 @@
-Capistrano::Configuration.instance.load do
-
-  _cset(:sidekiq_default_hooks) { true }
-  _cset(:sidekiq_cmd) { "#{fetch(:bundle_cmd, "bundle")} exec sidekiq" }
-  _cset(:sidekiqctl_cmd) { "#{fetch(:bundle_cmd, "bundle")} exec sidekiqctl" }
-  _cset(:sidekiq_timeout)   { 10 }
-  _cset(:sidekiq_role)      { :app }
-  _cset(:sidekiq_pid)       { "#{current_path}/tmp/pids/sidekiq.pid" }
-  _cset(:sidekiq_processes) { 1 }
-
-  if fetch(:sidekiq_default_hooks)
-    before "deploy:update_code", "sidekiq:quiet"
-    after "deploy:stop",    "sidekiq:stop"
-    after "deploy:start",   "sidekiq:start"
-    before "deploy:restart", "sidekiq:restart"
-  end
-
-  namespace :sidekiq do
-    def for_each_process(&block)
-      fetch(:sidekiq_processes).times do |idx|
-        yield((idx == 0 ? "#{fetch(:sidekiq_pid)}" : "#{fetch(:sidekiq_pid)}-#{idx}"), idx)
-      end
-    end
-
-    desc "Quiet sidekiq (stop accepting new work)"
-    task :quiet, :roles => lambda { fetch(:sidekiq_role) }, :on_no_matching_servers => :continue do
-      for_each_process do |pid_file, idx|
-        run "if [ -d #{current_path} ] && [ -f #{pid_file} ] && kill -0 `cat #{pid_file}`> /dev/null 2>&1; then cd #{current_path} && #{fetch(:sidekiqctl_cmd)} quiet #{pid_file} ; else echo 'Sidekiq is not running'; fi"
-      end
-    end
-
-    desc "Stop sidekiq"
-    task :stop, :roles => lambda { fetch(:sidekiq_role) }, :on_no_matching_servers => :continue do
-      for_each_process do |pid_file, idx|
-        run "if [ -d #{current_path} ] && [ -f #{pid_file} ] && kill -0 `cat #{pid_file}`> /dev/null 2>&1; then cd #{current_path} && #{fetch(:sidekiqctl_cmd)} stop #{pid_file} #{fetch :sidekiq_timeout} ; else echo 'Sidekiq is not running'; fi"
-      end
-    end
-
-    desc "Start sidekiq"
-    task :start, :roles => lambda { fetch(:sidekiq_role) }, :on_no_matching_servers => :continue do
-      rails_env = fetch(:rails_env, "production")
-      for_each_process do |pid_file, idx|
-        run "cd #{current_path} ; nohup #{fetch(:sidekiq_cmd)} -e #{rails_env} -C #{current_path}/config/sidekiq.yml -i #{idx} -P #{pid_file} >> #{current_path}/log/sidekiq.log 2>&1 &", :pty => false
-      end
-    end
-
-    desc "Restart sidekiq"
-    task :restart, :roles => lambda { fetch(:sidekiq_role) }, :on_no_matching_servers => :continue do
-      stop
-      start
-    end
-
-  end
-end

data/lib/sidekiq/yaml_patch.rb

@@ -1,21 +0,0 @@
-# YAML marshalling of instances can fail in some circumstances,
-# e.g. when the instance has a handle to a Proc.  This monkeypatch limits
-# the YAML serialization to just AR's internal @attributes hash.
-# The paperclip gem litters AR instances with Procs, for instance.
-#
-# Courtesy of @ryanlecompte https://gist.github.com/007b88ae90372d1a3321
-#
-
-if defined?(::ActiveRecord)
-  class ActiveRecord::Base
-    yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
-
-    def self.yaml_new(klass, tag, val)
-      klass.unscoped.find(val['attributes'][klass.primary_key])
-    end
-
-    def to_yaml_properties
-      ['@attributes']
-    end
-  end
-end

data/test/config.yml

@@ -1,11 +0,0 @@
----
-:verbose:      false
-:environment:  xzibit
-:require:      ./test/fake_env.rb
-:pidfile:      /tmp/sidekiq-config-test.pid
-:logfile:      /tmp/sidekiq.log
-:namespace:    sidekiq
-:concurrency:  50
-:queues:
-  - [<%="very_"%>often, 2]
-  - [seldom, 1]

data/test/env_based_config.yml

@@ -1,11 +0,0 @@
----
-:pidfile:      /tmp/sidekiq-config-test.pid
-:concurrency:  50
-staging:
-  :verbose:      false
-  :require:      ./test/fake_env.rb
-  :logfile:      /tmp/sidekiq.log
-  :concurrency:  5
-  :queues:
-    - [<%="very_"%>often, 2]
-    - [seldom, 1]

data/test/helper.rb

@@ -1,42 +0,0 @@
-$TESTING = true
-require 'coveralls'
-Coveralls.wear! do
-  add_filter "/test/"
-end
-
-ENV['RACK_ENV'] = ENV['RAILS_ENV'] = 'test'
-if ENV.has_key?("SIMPLECOV")
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "/test/"
-  end
-end
-
-begin
-  require 'pry'
-rescue LoadError
-end
-
-require 'minitest/autorun'
-require 'minitest/pride'
-
-require 'celluloid/autostart'
-require 'sidekiq'
-require 'sidekiq/util'
-Sidekiq.logger.level = Logger::ERROR
-
-Sidekiq::Test = MiniTest::Unit::TestCase
-
-require 'sidekiq/redis_connection'
-redis_url = ENV['REDIS_URL'] || 'redis://localhost/15'
-REDIS = Sidekiq::RedisConnection.create(:url => redis_url, :namespace => 'testy')
-
-Sidekiq.configure_client do |config|
-  config.redis = { :url => redis_url, :namespace => 'testy' }
-end
-
-Celluloid.class_eval do
-  def self.shutdown
-    $stderr.puts "Celluloid shutdown disabled"
-  end
-end

data/test/test_api.rb

@@ -1,341 +0,0 @@
-require 'helper'
-
-class TestApi < Sidekiq::Test
-  describe "stats" do
-    before do
-      Sidekiq.redis {|c| c.flushdb }
-    end
-
-    describe "processed" do
-      it "is initially zero" do
-        s = Sidekiq::Stats.new
-        assert_equal 0, s.processed
-      end
-
-      it "returns number of processed jobs" do
-        Sidekiq.redis { |conn| conn.set("stat:processed", 5) }
-        s = Sidekiq::Stats.new
-        assert_equal 5, s.processed
-      end
-    end
-
-    describe "failed" do
-      it "is initially zero" do
-        s = Sidekiq::Stats.new
-        assert_equal 0, s.processed
-      end
-
-      it "returns number of failed jobs" do
-        Sidekiq.redis { |conn| conn.set("stat:failed", 5) }
-        s = Sidekiq::Stats.new
-        assert_equal 5, s.failed
-      end
-    end
-
-    describe "reset" do
-      it 'can reset stats' do
-        Sidekiq.redis do |conn|
-          conn.set('stat:processed', 5)
-          conn.set('stat:failed', 10)
-          Sidekiq::Stats.new.reset
-          assert_equal '0', conn.get('stat:processed')
-          assert_equal '0', conn.get('stat:failed')
-        end
-      end
-    end
-
-    describe "queues" do
-      it "is initially empty" do
-        s = Sidekiq::Stats.new
-        assert_equal 0, s.queues.size
-      end
-
-      it "returns a hash of queue and size in order" do
-        Sidekiq.redis do |conn|
-          conn.rpush 'queue:foo', '{}'
-          conn.sadd 'queues', 'foo'
-
-          3.times { conn.rpush 'queue:bar', '{}' }
-          conn.sadd 'queues', 'bar'
-        end
-
-        s = Sidekiq::Stats.new
-        assert_equal ({ "foo" => 1, "bar" => 3 }), s.queues
-        assert_equal "bar", s.queues.first.first
-      end
-    end
-
-    describe "enqueued" do
-      it "is initially empty" do
-        s = Sidekiq::Stats.new
-        assert_equal 0, s.enqueued
-      end
-
-      it "returns total enqueued jobs" do
-        Sidekiq.redis do |conn|
-          conn.rpush 'queue:foo', '{}'
-          conn.sadd 'queues', 'foo'
-
-          3.times { conn.rpush 'queue:bar', '{}' }
-          conn.sadd 'queues', 'bar'
-        end
-
-        s = Sidekiq::Stats.new
-        assert_equal 4, s.enqueued
-      end
-    end
-
-    describe "over time" do
-      describe "processed" do
-        it 'retrieves hash of dates' do
-          Sidekiq.redis do |c|
-            c.incrby("stat:processed:2012-12-24", 4)
-            c.incrby("stat:processed:2012-12-25", 1)
-            c.incrby("stat:processed:2012-12-26", 6)
-            c.incrby("stat:processed:2012-12-27", 2)
-          end
-          Time.stub(:now, Time.parse("2012-12-26 1:00:00 -0500")) do
-            s = Sidekiq::Stats::History.new(2)
-            assert_equal ({ "2012-12-26" => 6, "2012-12-25" => 1 }), s.processed
-
-            s = Sidekiq::Stats::History.new(3)
-            assert_equal ({ "2012-12-26" => 6, "2012-12-25" => 1, "2012-12-24" => 4 }), s.processed
-
-            s = Sidekiq::Stats::History.new(2, Date.parse("2012-12-25"))
-            assert_equal ({ "2012-12-25" => 1, "2012-12-24" => 4 }), s.processed
-          end
-        end
-      end
-
-      describe "failed" do
-        it 'retrieves hash of dates' do
-          Sidekiq.redis do |c|
-            c.incrby("stat:failed:2012-12-24", 4)
-            c.incrby("stat:failed:2012-12-25", 1)
-            c.incrby("stat:failed:2012-12-26", 6)
-            c.incrby("stat:failed:2012-12-27", 2)
-          end
-          Time.stub(:now, Time.parse("2012-12-26 1:00:00 -0500")) do
-            s = Sidekiq::Stats::History.new(2)
-            assert_equal ({ "2012-12-26" => 6, "2012-12-25" => 1 }), s.failed
-
-            s = Sidekiq::Stats::History.new(3)
-            assert_equal ({ "2012-12-26" => 6, "2012-12-25" => 1, "2012-12-24" => 4 }), s.failed
-
-            s = Sidekiq::Stats::History.new(2, Date.parse("2012-12-25"))
-            assert_equal ({ "2012-12-25" => 1, "2012-12-24" => 4 }), s.failed
-          end
-        end
-      end
-    end
-  end
-
-  describe 'with an empty database' do
-    before do
-      Sidekiq.redis {|c| c.flushdb }
-    end
-
-    it 'shows queue as empty' do
-      q = Sidekiq::Queue.new
-      assert_equal 0, q.size
-      assert_equal 0, q.latency
-    end
-
-    class ApiWorker
-      include Sidekiq::Worker
-    end
-
-    it 'can enumerate jobs' do
-      q = Sidekiq::Queue.new
-      Time.stub(:now, Time.new(2012, 12, 26)) do
-        ApiWorker.perform_async(1, 'mike')
-        assert_equal ['TestApi::ApiWorker'], q.map(&:klass)
-
-        job = q.first
-        assert_equal 24, job.jid.size
-        assert_equal [1, 'mike'], job.args
-        assert_equal Time.new(2012, 12, 26), job.enqueued_at
-
-      end
-
-      assert q.latency > 10_000_000
-
-      q = Sidekiq::Queue.new('other')
-      assert_equal 0, q.size
-    end
-
-    it 'can delete jobs' do
-      q = Sidekiq::Queue.new
-      ApiWorker.perform_async(1, 'mike')
-      assert_equal 1, q.size
-      assert_equal [true], q.map(&:delete)
-      assert_equal 0, q.size
-    end
-
-    it "can move scheduled job to queue" do
-      job_id = ApiWorker.perform_in(100, 1, 'jason')
-      job = Sidekiq::ScheduledSet.new.find_job(job_id)
-      q = Sidekiq::Queue.new
-      job.add_to_queue
-      queued_job = q.find_job(job_id)
-      refute_nil queued_job
-      assert_equal queued_job.jid, job_id
-      job = Sidekiq::ScheduledSet.new.find_job(job_id)
-      assert_nil job
-    end
-
-    it 'can find job by id in sorted sets' do
-      job_id = ApiWorker.perform_in(100, 1, 'jason')
-      job = Sidekiq::ScheduledSet.new.find_job(job_id)
-      refute_nil job
-      assert_equal job_id, job.jid
-      assert_in_delta job.latency, 0.0, 0.01
-    end
-
-    it 'can find job by id in queues' do
-      q = Sidekiq::Queue.new
-      job_id = ApiWorker.perform_async(1, 'jason')
-      job = q.find_job(job_id)
-      refute_nil job
-      assert_equal job_id, job.jid
-    end
-
-    it 'can clear a queue' do
-      q = Sidekiq::Queue.new
-      2.times { ApiWorker.perform_async(1, 'mike') }
-      q.clear
-
-      Sidekiq.redis do |conn|
-        refute conn.smembers('queues').include?('foo')
-        refute conn.exists('queues:foo')
-      end
-    end
-
-    it 'can fetch by score' do
-      same_time = Time.now.to_f
-      add_retry('bob1', same_time)
-      add_retry('bob2', same_time)
-      r = Sidekiq::RetrySet.new
-      assert_equal 2, r.fetch(same_time).size
-    end
-
-    it 'can fetch by score and jid' do
-      same_time = Time.now.to_f
-      add_retry('bob1', same_time)
-      add_retry('bob2', same_time)
-      r = Sidekiq::RetrySet.new
-      # jobs = r.fetch(same_time)
-      # puts jobs[1].jid
-      assert_equal 1, r.fetch(same_time, 'bob1').size
-    end
-
-    it 'shows empty retries' do
-      r = Sidekiq::RetrySet.new
-      assert_equal 0, r.size
-    end
-
-    it 'can enumerate retries' do
-      add_retry
-
-      r = Sidekiq::RetrySet.new
-      assert_equal 1, r.size
-      array = r.to_a
-      assert_equal 1, array.size
-
-      retri = array.first
-      assert_equal 'ApiWorker', retri.klass
-      assert_equal 'default', retri.queue
-      assert_equal 'bob', retri.jid
-      assert_in_delta Time.now.to_f, retri.at.to_f, 0.01
-    end
-
-    it 'can delete multiple retries from score' do
-      same_time = Time.now.to_f
-      add_retry('bob1', same_time)
-      add_retry('bob2', same_time)
-      r = Sidekiq::RetrySet.new
-      assert_equal 2, r.size
-      Sidekiq::RetrySet.new.delete(same_time)
-      assert_equal 0, r.size
-    end
-
-    it 'can delete a single retry from score and jid' do
-      same_time = Time.now.to_f
-      add_retry('bob1', same_time)
-      add_retry('bob2', same_time)
-      r = Sidekiq::RetrySet.new
-      assert_equal 2, r.size
-      Sidekiq::RetrySet.new.delete(same_time, 'bob1')
-      assert_equal 1, r.size
-    end
-
-    it 'can retry a retry' do
-      add_retry
-      r = Sidekiq::RetrySet.new
-      assert_equal 1, r.size
-      r.first.retry
-      assert_equal 0, r.size
-      assert_equal 1, Sidekiq::Queue.new('default').size
-      job = Sidekiq::Queue.new('default').first
-      assert_equal 'bob', job.jid
-      assert_equal 1, job['retry_count']
-    end
-
-    it 'can clear retries' do
-      add_retry
-      add_retry('test')
-      r = Sidekiq::RetrySet.new
-      assert_equal 2, r.size
-      r.clear
-      assert_equal 0, r.size
-    end
-
-    it 'can enumerate workers' do
-      w = Sidekiq::Workers.new
-      assert_equal 0, w.size
-      w.each do
-        assert false
-      end
-
-      s = '12345'
-      data = Sidekiq.dump_json({ 'payload' => {}, 'queue' => 'default', 'run_at' => Time.now.to_i })
-      Sidekiq.redis do |c|
-        c.multi do
-          c.sadd('workers', s)
-          c.set("worker:#{s}", data)
-          c.set("worker:#{s}:started", Time.now.to_s)
-        end
-      end
-
-      assert_equal 1, w.size
-      w.each do |x, y, z|
-        assert_equal s, x
-        assert_equal 'default', y['queue']
-        assert_equal Time.now.year, DateTime.parse(z).year
-      end
-    end
-
-    it 'can reschedule jobs' do
-      add_retry('foo1')
-      add_retry('foo2')
-
-      retries = Sidekiq::RetrySet.new
-      assert_equal 2, retries.size
-      refute(retries.map { |r| r.score > (Time.now.to_f + 9) }.any?)
-
-      retries.each do |retri|
-        retri.reschedule(Time.now.to_f + 10) if retri.jid == 'foo2'
-      end
-
-      assert_equal 2, retries.size
-      assert(retries.map { |r| r.score > (Time.now.to_f + 9) }.any?)
-    end
-
-    def add_retry(jid = 'bob', at = Time.now.to_f)
-      payload = Sidekiq.dump_json('class' => 'ApiWorker', 'args' => [1, 'mike'], 'queue' => 'default', 'jid' => jid, 'retry_count' => 2, 'failed_at' => Time.now.utc)
-      Sidekiq.redis do |conn|
-        conn.zadd('retry', at.to_s, payload)
-      end
-    end
-  end
-end