sidetiq 0.3.7 → 0.4.0.rc1

data/lib/sidetiq/web.rb

@@ -5,38 +5,50 @@ module Sidetiq
     VIEWS = File.expand_path('views', File.dirname(__FILE__))
 
     def self.registered(app)
-      app.helpers do
-        def sidetiq_clock
-          Sidetiq::Clock.instance
-        end
+      app.get "/sidetiq" do
+        @schedules = Sidetiq.schedules
+        @time = Sidetiq.clock.gettime
+        erb File.read(File.join(VIEWS, 'sidetiq.erb'))
+      end
 
-        def sidetiq_schedules
-          sidetiq_clock.schedules
-        end
+      app.get "/sidetiq/locks" do
+        @locks = Sidetiq::Lock::Redis.all.map(&:meta_data)
+
+        erb File.read(File.join(VIEWS, 'locks.erb'))
       end
 
-      app.get "/sidetiq" do
-        @schedules = sidetiq_schedules
-        @time = sidetiq_clock.gettime
-        erb File.read(File.join(VIEWS, 'sidetiq.erb'))
+      app.get "/sidetiq/:name/schedule" do
+        halt 404 unless (name = params[:name])
+
+        @time = Sidetiq.clock.gettime
+
+        @worker, @schedule = Sidetiq.schedules.select do |worker, _|
+          worker.name == name
+        end.flatten
+
+        erb File.read(File.join(VIEWS, 'schedule.erb'))
       end
 
-      app.get "/sidetiq/:name" do
+      app.get "/sidetiq/:name/history" do
         halt 404 unless (name = params[:name])
 
-        @time = sidetiq_clock.gettime
+        @time = Sidetiq.clock.gettime
 
-        @worker, @schedule = sidetiq_schedules.select do |worker, _|
+        @worker, @schedule = Sidetiq.schedules.select do |worker, _|
           worker.name == name
         end.flatten
 
-        erb File.read(File.join(VIEWS, 'sidetiq_details.erb'))
+        @history = Sidekiq.redis do |redis|
+          redis.lrange("sidetiq:#{@worker.name}:history", 0, -1)
+        end
+
+        erb File.read(File.join(VIEWS, 'history.erb'))
       end
 
       app.post "/sidetiq/:name/trigger" do
         halt 404 unless (name = params[:name])
 
-        worker, _ = sidetiq_schedules.select do |w, _|
+        worker, _ = Sidetiq.schedules.select do |w, _|
           w.name == name
         end.flatten
 
@@ -44,6 +56,14 @@ module Sidetiq
 
         redirect "#{root_path}sidetiq"
       end
+
+      app.post "/sidetiq/:name/unlock" do
+        halt 404 unless (name = params[:name])
+
+        Sidetiq::Lock::Redis.new(name).unlock!
+
+        redirect "#{root_path}sidetiq/locks"
+      end
     end
   end
 end

data/lib/sidetiq.rb

@@ -1,5 +1,4 @@
 # stdlib
-require 'monitor'
 require 'ostruct'
 require 'singleton'
 require 'socket'
@@ -7,134 +6,55 @@ require 'socket'
 # gems
 require 'ice_cube'
 require 'sidekiq'
+require 'celluloid'
 
 # internal
 require 'sidetiq/config'
+require 'sidetiq/logging'
+require 'sidetiq/api'
 require 'sidetiq/clock'
-require 'sidetiq/lock'
-require 'sidetiq/middleware'
+require 'sidetiq/handler'
+require 'sidetiq/lock/meta_data'
+require 'sidetiq/lock/redis'
 require 'sidetiq/schedule'
 require 'sidetiq/schedulable'
 require 'sidetiq/version'
 
+# middleware
+require 'sidetiq/middleware/history'
+
+# actor topology
+require 'sidetiq/actor'
+require 'sidetiq/actor/clock'
+require 'sidetiq/actor/handler'
+require 'sidetiq/supervisor'
+
 # The Sidetiq namespace.
 module Sidetiq
+  include Sidetiq::API
+
+  # Expose all instance methods as singleton methods.
+  extend self
+
   class << self
     # Public: Setter for the Sidetiq logger.
     attr_writer :logger
+  end
 
-    # Public: Reader for the Sidetiq logger.
-    #
-    # Defaults to `Sidekiq.logger`.
-    def logger
-      @logger ||= Sidekiq.logger
-    end
-
-    # Public: Returns an Array of workers including Sidetiq::Schedulable.
-    def workers
-      schedules.keys
-    end
-
-    # Public: Returns a Hash of Sidetiq::Schedule instances.
-    def schedules
-      Clock.mon_synchronize do
-        Clock.schedules.dup
-      end
-    end
-
-    # Public: Currently scheduled recurring jobs.
-    #
-    # worker - A Sidekiq::Worker class or String of the class name (optional)
-    # block  - An optional block that can be given to which each
-    #          Sidekiq::SortedEntry instance corresponding to a scheduled job will
-    #          be yielded.
-    #
-    # Examples
-    #
-    #   Sidetiq.scheduled
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.scheduled(MyWorker)
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.scheduled("MyWorker")
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.scheduled do |job|
-    #     # do stuff ...
-    #   end
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.scheduled(MyWorker) do |job|
-    #     # do stuff ...
-    #   end
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.scheduled("MyWorker") do |job|
-    #     # do stuff ...
-    #   end
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    # Yields each Sidekiq::SortedEntry instance.
-    # Returns an Array of Sidekiq::SortedEntry objects.
-    def scheduled(worker = nil, &block)
-      filter_set(Sidekiq::ScheduledSet.new, worker, &block)
-    end
-
-    # Public: Recurring jobs currently scheduled for retries.
-    #
-    # worker - A Sidekiq::Worker class or String of the class name (optional)
-    # block  - An optional block that can be given to which each
-    #          Sidekiq::SortedEntry instance corresponding to a scheduled job will
-    #          be yielded.
-    #
-    # Examples
-    #
-    #   Sidetiq.retries
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.retries(MyWorker)
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.retries("MyWorker")
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.retries do |job|
-    #     # do stuff ...
-    #   end
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.retries(MyWorker) do |job|
-    #     # do stuff ...
-    #   end
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    #   Sidetiq.retries("MyWorker") do |job|
-    #     # do stuff ...
-    #   end
-    #   # => [#<Sidekiq::SortedEntry>, ...]
-    #
-    # Yields each Sidekiq::SortedEntry instance.
-    # Returns an Array of Sidekiq::SortedEntry objects.
-    def retries(worker = nil, &block)
-      filter_set(Sidekiq::RetrySet.new, worker, &block)
-    end
-
-    private
-
-    def filter_set(set, worker, &block)
-      worker = worker.constantize if worker.kind_of?(String)
-
-      jobs = set.select do |job|
-        klass = job.klass.constantize
-        ret = klass.include?(Schedulable)
-        ret = ret && klass == worker if worker
-        ret
-      end
+  # Public: Reader for the Sidetiq logger.
+  #
+  # Defaults to `Sidekiq.logger`.
+  def logger
+    @logger ||= Sidekiq.logger
+  end
 
-      jobs.each(&block) if block_given?
+  # Public: Returns the Sidetiq::Clock actor.
+  def clock
+    Sidetiq::Supervisor.clock
+  end
 
-      jobs
-    end
+  # Public: Returns a Sidetiq::Handler worker.
+  def handler
+    Sidetiq::Supervisor.handler
   end
 end

data/sidetiq.gemspec

@@ -19,13 +19,16 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.extensions    = []
 
-  gem.add_dependency 'sidekiq',  '~> 2.14.0'
-  gem.add_dependency 'ice_cube', '~> 0.11.0'
+  gem.add_dependency 'sidekiq',   '~> 2.14.0'
+  gem.add_dependency 'celluloid', '>= 0.14.1'
+  gem.add_dependency 'ice_cube',  '~> 0.11.0'
+  gem.add_dependency 'json'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'sinatra'
   gem.add_development_dependency 'mocha'
   gem.add_development_dependency 'rack-test'
+  gem.add_development_dependency 'minitest', '~> 5.0.7'
 
   if RUBY_PLATFORM != "java"
     gem.add_development_dependency 'coveralls'

data/tasks/bundler.task

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/tasks/minitest.task

@@ -0,0 +1,6 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/test_*.rb'
+end
+

data/test/fixtures/optional_arguments_worker.rb

@@ -0,0 +1,8 @@
+class OptionalArgumentWorker
+	include Sidekiq::Worker
+  include Sidetiq::Schedulable
+
+  def perform(last_tick = nil)
+  end
+end
+

data/test/helper.rb

@@ -3,15 +3,26 @@ if RUBY_PLATFORM != "java"
   Coveralls.wear!
 end
 
-require 'minitest/autorun'
-require 'mocha/setup'
-require 'rack/test'
-
 require 'sidekiq'
 require 'sidekiq/testing'
 
+require 'minitest'
+require 'mocha/setup'
+require 'rack/test'
+
 require 'sidetiq'
 require 'sidetiq/web'
+require 'sidetiq/lock/watcher'
+
+class Sidetiq::Supervisor
+  def self.clock
+    @clock ||= Sidetiq::Clock.new
+  end
+
+  def self.handler
+    Sidetiq::Handler.new
+  end
+end
 
 # Keep the test output clean.
 Sidetiq.logger = Logger.new(nil)
@@ -34,13 +45,13 @@ class Sidekiq::Client
   end
 end
 
-class Sidetiq::TestCase < MiniTest::Unit::TestCase
+class Sidetiq::TestCase < MiniTest::Test
   def setup
     Sidekiq.redis { |r| r.flushall }
   end
 
   def clock
-    @clock ||= Sidetiq::Clock.instance
+    Sidetiq.clock
   end
 
   # Blatantly stolen from Sidekiq's test suite.
@@ -55,3 +66,7 @@ class Sidetiq::TestCase < MiniTest::Unit::TestCase
   end
 end
 
+# Override Celluloid's at_exit hook manually.
+at_exit {
+  exit Minitest.run(ARGV) || false
+}

data/test/test_clock.rb

@@ -1,30 +1,6 @@
 require_relative 'helper'
 
 class TestClock < Sidetiq::TestCase
-  def test_delegates_to_instance
-    Sidetiq::Clock.instance.expects(:foo).once
-    Sidetiq::Clock.foo
-  end
-
-  def test_start_stop
-    refute clock.ticking?
-    assert_nil clock.thread
-
-    clock.start!
-    Thread.pass
-    sleep 0.01
-
-    assert clock.ticking?
-    assert_kind_of Thread, clock.thread
-
-    clock.stop!
-    Thread.pass
-    sleep 0.01
-
-    refute clock.ticking?
-    refute clock.thread.alive?
-  end
-
   def test_gettime_seconds
     assert_equal clock.gettime.tv_sec, Time.now.tv_sec
   end
@@ -118,6 +94,22 @@ class TestClock < Sidetiq::TestCase
     clock.tick
   end
 
+  def test_enqueues_jobs_with_last_run_timestamp_if_optional_argument
+    schedule = Sidetiq::Schedule.new
+    schedule.hourly
+
+    time = Time.local(2011, 1, 1, 1, 30)
+
+    clock.stubs(:gettime).returns(time, time + 3600)
+    clock.stubs(:schedules).returns(OptionalArgumentWorker => schedule)
+
+    expected_first_tick = time + 1800
+
+    OptionalArgumentWorker.expects(:perform_at)
+      .with(expected_first_tick, -1).once
+    clock.tick
+  end
+
   def test_enqueues_jobs_correctly_for_splat_args_perform_methods
     schedule = Sidetiq::Schedule.new
     schedule.hourly

data/test/test_history.rb

@@ -0,0 +1,60 @@
+require_relative 'helper'
+
+class TestHistory < Sidetiq::TestCase
+  class HistoryWorker
+    include Sidekiq::Worker
+    include Sidetiq::Schedulable
+  end
+
+  def test_success
+    middlewared do; end
+
+    entry = Sidekiq.redis do |redis|
+      redis.lrange('sidetiq:TestHistory::HistoryWorker:history', 0, -1)
+    end
+
+    actual = JSON.parse(entry[0], symbolize_names: true)
+
+    assert_equal 'success', actual[:status]
+
+    assert_empty actual[:error]
+    assert_empty actual[:backtrace]
+    assert_empty actual[:exception]
+
+    refute_empty actual[:node]
+    refute_empty actual[:timestamp]
+  end
+
+  def test_failure
+    begin
+      middlewared do
+        raise StandardError.new("failed")
+      end
+    rescue
+    end
+
+    entry = Sidekiq.redis do |redis|
+      redis.lrange('sidetiq:TestHistory::HistoryWorker:history', 0, -1)
+    end
+
+    actual = JSON.parse(entry[0], symbolize_names: true)
+
+    assert_equal 'failure', actual[:status]
+
+    assert_equal "failed", actual[:error]
+    assert_equal "StandardError", actual[:exception]
+    refute_empty actual[:backtrace]
+
+    refute_empty actual[:node]
+    refute_empty actual[:timestamp]
+  end
+
+  def middlewared
+    middleware = Sidetiq::Middleware::History.new
+
+    middleware.call(HistoryWorker.new, {}, 'default') do
+      yield
+    end
+  end
+end
+

data/test/test_lock_meta_data.rb

@@ -0,0 +1,90 @@
+require_relative 'helper'
+
+class TestLockMetaData < Sidetiq::TestCase
+  def new_without_params
+    md = Sidetiq::Lock::MetaData.new
+
+    assert_nil md.owner
+    assert_nil md.timestamp
+    assert_nil md.key
+  end
+
+  def new_with_empty_hash
+    md = Sidetiq::Lock::MetaData.new({})
+
+    assert_nil md.owner
+    assert_nil md.timestamp
+    assert_nil md.key
+  end
+
+  def test_from_json
+    json = { timestamp: 42, owner: "me", key: "foobar" }.to_json
+    md = Sidetiq::Lock::MetaData.from_json(json)
+
+    assert_equal 42, md.timestamp
+    assert_equal "me", md.owner
+    assert_equal "foobar", md.key
+  end
+
+  def test_from_json_with_empty_string_json
+    md = Sidetiq::Lock::MetaData.from_json(nil)
+
+    assert_nil md.owner
+    assert_nil md.timestamp
+    assert_nil md.key
+  end
+
+  def test_from_json_with_nil_json
+    md = Sidetiq::Lock::MetaData.from_json("")
+
+    assert_nil md.owner
+    assert_nil md.timestamp
+    assert_nil md.key
+  end
+
+  def test_pttl
+    lock = Sidetiq::Lock::Redis.new("foobar", 1000000)
+    md = Sidekiq.redis do |r|
+      lock.lock
+      Sidetiq::Lock::MetaData.from_json(r.get(lock.key))
+    end
+
+    # Allow 10 ms.
+    assert md.pttl <= 1000000
+    assert md.pttl > 999990
+  end
+
+  def test_from_json_with_malformed_json
+    Sidetiq::Lock::MetaData.expects(:handle_exception).once
+
+    md = Sidetiq::Lock::MetaData.from_json('invalid')
+
+    assert_nil md.owner
+    assert_nil md.timestamp
+    assert_nil md.key
+  end
+
+  def test_for_new_lock
+    md = Sidetiq::Lock::MetaData.for_new_lock("baz")
+
+    assert_equal Sidetiq::Lock::MetaData::OWNER, md.owner
+    assert_equal "baz", md.key
+
+    assert md.timestamp > 0
+    assert md.timestamp <= Time.now.to_f
+  end
+
+  def test_to_json
+    hash = { timestamp: 42, owner: "me", key: "foobar" }
+    md = Sidetiq::Lock::MetaData.new(hash)
+
+    assert_equal hash, JSON.parse(md.to_json, symbolize_names: true)
+  end
+
+  def test_to_s
+    md = Sidetiq::Lock::MetaData.new(timestamp: 42, owner: "me", key: "foobar")
+
+    assert_equal "Sidetiq::Lock on foobar set at 42 by me", md.to_s
+  end
+end
+

data/test/test_lock_redis.rb

@@ -0,0 +1,63 @@
+require_relative 'helper'
+
+class TestLockRedis < Sidetiq::TestCase
+  def test_locking
+    lock_name = SecureRandom.hex(8)
+    key = SecureRandom.hex(8)
+
+    Sidekiq.redis do |redis|
+      redis.set(key, 0)
+
+      5.times.map do
+        Thread.start do
+          locked(lock_name) do |r|
+            sleep 0.1
+            r.incr(key)
+          end
+        end
+      end.each(&:join)
+
+      assert_equal "1", redis.get(key)
+    end
+  end
+
+  def test_all
+    Sidekiq.redis do |redis|
+      redis.set("sidetiq:Foobar:lock", 1)
+    end
+
+    locks = Sidetiq::Lock::Redis.all
+
+    assert_equal "sidetiq:Foobar:lock", locks.first.key
+  end
+
+  def test_unlock!
+    Sidekiq.redis do |redis|
+      redis.set("sidetiq:Foobar:lock", 1)
+
+      Sidetiq::Lock::Redis.new("Foobar").unlock!
+
+      assert_nil redis.get("sidetiq:Foobar:lock")
+    end
+  end
+
+  def test_lock_sets_correct_meta_data
+    key = SecureRandom.hex(8)
+    internal_key = "sidetiq:#{key}:lock"
+
+    locked(key) do |redis|
+      json = redis.get(internal_key)
+      md = Sidetiq::Lock::MetaData.from_json(json)
+
+      assert_equal Sidetiq::Lock::MetaData::OWNER, md.owner
+      assert_equal internal_key, md.key
+    end
+  end
+
+  def locked(lock_name)
+    Sidetiq::Lock::Redis.new(lock_name).synchronize do |redis|
+      yield redis
+    end
+  end
+end
+

data/test/test_version.rb

@@ -15,7 +15,8 @@ class TestVersion < Sidetiq::TestCase
 
   def test_string
     assert_equal Sidetiq::VERSION::STRING, [Sidetiq::VERSION::MAJOR,
-      Sidetiq::VERSION::MINOR, Sidetiq::VERSION::PATCH].compact.join('.')
+                                            Sidetiq::VERSION::MINOR, Sidetiq::VERSION::PATCH,
+                                            Sidetiq::VERSION::SUFFIX].compact.join('.')
   end
 end
 

data/test/test_watcher.rb

@@ -0,0 +1,24 @@
+require_relative 'helper'
+
+class TestWatcher < Sidetiq::TestCase
+  def setup
+    Sidetiq.config.lock.watcher.remove_lock = true
+    Sidetiq.config.lock.watcher.notify = true
+
+    @worker = Sidetiq::Lock::Watcher.new
+  end
+
+  def test_perform
+    Sidetiq::Lock::Redis.new("foobar", 1000000).lock
+
+    assert_equal 1, Sidetiq::Lock::Redis.all.length
+
+    @worker.expects(:handle_exception).once
+
+    @worker.perform
+
+    assert_equal 0, Sidetiq::Lock::Redis.all.length
+  end
+end
+
+

data/test/test_web.rb

@@ -33,8 +33,18 @@ class TestWeb < Sidetiq::TestCase
     end
   end
 
-  def test_details_page
-    get "/sidetiq/ScheduledWorker"
+  def test_locks_page
+    get "/sidetiq/locks"
+    assert_equal 200, last_response.status
+  end
+
+  def test_history_page
+    get "/sidetiq/ScheduledWorker/history"
+    assert_equal 200, last_response.status
+  end
+
+  def test_schedule_page
+    get "/sidetiq/ScheduledWorker/schedule"
     assert_equal 200, last_response.status
     schedule = clock.schedules[ScheduledWorker]
 
@@ -57,5 +67,19 @@ class TestWeb < Sidetiq::TestCase
     assert_equal "http://#{host}/sidetiq", last_response.location
     assert_equal 1, ScheduledWorker.jobs.size
   end
+
+  def test_unlock
+    Sidekiq.redis do |redis|
+      redis.set("sidetiq:Foo:lock", 1)
+    end
+
+    post "/sidetiq/Foo/unlock"
+    assert_equal 302, last_response.status
+    assert_equal "http://#{host}/sidetiq/locks", last_response.location
+
+    Sidekiq.redis do |redis|
+      assert_nil redis.get("sidetiq:Foo:lock")
+    end
+  end
 end