sidekiq-scheduler 0.0.0 → 0.1.0

data/README.md

@@ -1,3 +1,113 @@
 # SidekiqScheduler
 
-This project is being under development and uses MIT-LICENSE.
+## Description
+
+sidekiq-scheduler is an extension to [Sidekiq](http://github.com/mperham/sidekiq)
+that adds support for queueing jobs in the future.
+
+At the moment job scheduling is only supported in a delayed fashion. Replacing cron
+is not the intention of this gem. Delayed jobs are Sidekiq jobs that you want to run
+at some point in the future.
+
+The syntax is pretty explanatory:
+
+    MyWorker.perform_in(5.days, 'arg1', 'arg2') # run a job in 5 days
+    # or
+    MyWorker.perform_at(5.days.from_now, 'arg1', 'arg2') # run job at a specific time
+
+## Installation
+
+    # Rails 3.x: add it to your Gemfile
+    gem 'sidekiq-scheduler'
+
+    # Starting the scheduler
+    bundle exec sidekiq-scheduler
+
+The scheduler will perform identically to a normal sidekiq worker with
+an additional scheduler thread being run - in the default configuration
+this will result in 25 worker threads being available on the scheduler
+node but all normal configuration options apply.
+
+NOTE: Since it's currently not possible to hook into the default option
+parsing provided by sidekiq you will need to use a configuration file to
+override the scheduler options. Currently the only option available is
+
+    resolution: <seconds between schedule runs>
+
+The scheduling thread will sleep this many seconds between looking for
+jobs that need moving to the worker queue. The default is 5 seconds
+which should be fast enough for almost all uses.
+
+NOTE: You DO NOT want to run more than one instance of the scheduler.  Doing
+so will result in the same job being queued multiple times.  You only need one
+instance of the scheduler running per application, regardless of number of servers.
+
+NOTE: If the scheduler thread goes down for whatever reason, the delayed items
+that should have fired during the outage will fire once the scheduler is
+started back up again (even if it is on a new machine).
+
+## Delayed jobs
+
+Delayed jobs are one-off jobs that you want to be put into a queue at some point
+in the future. The classic example is sending email:
+
+    MyWorker.perform_in(5.days, current_user.id)
+
+This will store the job for 5 days in the Sidekiq delayed queue at which time
+the scheduler will pull it from the delayed queue and put it in the appropriate 
+work queue for the given job. It will then be processed as soon as a worker is 
+available (just like any other Sidekiq job).
+
+NOTE: The job does not fire **exactly** at the time supplied. Rather, once that
+time is in the past, the job moves from the delayed queue to the actual work
+queue and will be completed as workers are free to process it.
+
+Also supported is `MyWork.perform_at` which takes a timestamp to queue the job.
+
+The delayed queue is stored in redis and is persisted in the same way the
+standard Sidekiq jobs are persisted (redis writing to disk). Delayed jobs differ
+from scheduled jobs in that if your scheduler process is down or workers are
+down when a particular job is supposed to be processed, they will simply "catch up"
+once they are started again.  Jobs are guaranteed to run (provided they make it
+into the delayed queue) after their given queue_at time has passed.
+
+One other thing to note is that insertion into the delayed queue is O(log(n))
+since the jobs are stored in a redis sorted set (zset).  I can't imagine this
+being an issue for someone since redis is stupidly fast even at log(n), but full
+disclosure is always best.
+
+### Removing Delayed jobs
+
+If you have the need to cancel a delayed job, you can do it like this:
+
+    # after you've enqueued a job like:
+    MyWorker.perform_at(5.days.from_now, 'arg1', 'arg2')
+    # remove the job with exactly the same parameters:
+    MyWorker.remove_delayed(<timestamp>, 'arg1', 'arg2')
+
+## Note on Patches / Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Credits
+
+This work is a partial port of [resque-scheduler](https://github.com/bvandenbos/resque-scheduler) by Ben VandenBos.  
+Modified to work with the Sidekiq queueing library by Morton Jonuschat.
+
+## Maintainers
+
+* [Morton Jonuschat](https://github.com/yabawock)
+
+## License
+
+MIT License
+
+## Copyright
+
+Copyright 2012 Morton Jonuschat  
+Some parts copyright 2010 Ben VandenBos  

data/lib/sidekiq-scheduler/cli.rb

@@ -0,0 +1,24 @@
+require 'sidekiq-scheduler/manager'
+require 'sidekiq/cli'
+
+module SidekiqScheduler
+  module CLI
+    def self.included(base)
+      base.class_eval do
+        alias_method :run_manager, :run
+        alias_method :run, :run_scheduler
+      end
+    end
+
+    def run_scheduler
+      scheduler_options = { :scheduler => true, :resolution => 5 }
+      scheduler_options.merge!(options)
+      scheduler = SidekiqScheduler::Manager.new(scheduler_options)
+      scheduler.start!
+      run_manager
+      scheduler.stop!
+    end
+  end
+end
+
+Sidekiq::CLI.send(:include, SidekiqScheduler::CLI)

data/lib/sidekiq-scheduler/client.rb

@@ -0,0 +1,87 @@
+require 'sidekiq-scheduler/worker'
+require 'sidekiq/client'
+
+module SidekiqScheduler
+  module Client
+    # Example usage:
+    # Sidekiq::Client.delayed_push('my_queue', Time.now + 600, 'class' => MyWorker, 'args' => ['foo', 1, :bat => 'bar'])
+    def delayed_push(queue=nil, timestamp, item)
+      raise(ArgumentError, "Message must be a Hash of the form: { 'class' => SomeClass, 'args' => ['bob', 1, :foo => 'bar'] }") unless item.is_a?(Hash)
+      raise(ArgumentError, "Message must include a class and set of arguments: #{item.inspect}") if !item['class'] || !item['args']
+
+      timestamp = timestamp.to_i
+
+      item['queue'] = queue.to_s if queue
+      item['class'] = item['class'].to_s if !item['class'].is_a?(String)
+
+      # Add item to the list for this timestamp
+      Sidekiq.redis.rpush("delayed:#{timestamp}", MultiJson.encode(item))
+
+      # Add timestamp to zset. Score and value are based on the timestamp
+      # as querying will be based on that
+      Sidekiq.redis.zadd('delayed_queue_schedule', timestamp, timestamp)
+    end
+
+    def remove_scheduler_queue(timestamp)
+      key = "delayed:#{timestamp}"
+      if 0 == Sidekiq.redis.llen(key)
+        Sidekiq.redis.del(key)
+        Sidekiq.redis.zrem('delayed_queue_schedule', timestamp)
+      end
+    end
+
+    # Example usage:
+    # Sidekiq::Client.remove_all_delayed(MyWorker, 'foo', 1, :bat => 'bar')
+    #
+    # Returns the number of jobs removed
+    #
+    # This method can be very expensive since it needs to scan
+    # through the delayed queues of all timestamps
+    def remove_all_delayed(klass, *args)
+      remove_all_delayed_from_queue(nil, klass, *args)
+    end
+
+    # Example usage:
+    # Sidekiq::Client.remove_all_delayed('foo', MyWorker, 'foo', 1, :bat => 'bar')
+    #
+    # Returns the number of jobs removed
+    #
+    # This method can be very expensive since it needs to scan
+    # through the delayed queues of all timestamps
+    def remove_all_delayed_from_queue(queue, klass, *args)
+      count = 0
+      item = {'class' => klass.to_s, 'args' => args}
+      item['queue'] = queue.to_s if queue
+      search = MultiJson.encode(item)
+      Array(Sidekiq.redis.keys("delayed:*")).each do |key|
+        count += Sidekiq.redis.lrem(key, 0, search)
+      end
+      count
+    end
+
+    # Example usage:
+    # Sidekiq::Client.remove_delayed(Time.now + 600, MyWorker, 'foo', 1, :bat => 'bar')
+    #
+    # Returns the number of jobs removed
+    def remove_delayed(timestamp, klass, *args)
+      remove_delayed_from_queue(nil, timestamp, klass, *args)
+    end
+
+
+    # Example usage:
+    # Sidekiq::Client.remove_delayed('foo', Time.now + 600, MyWorker, 'foo', 1, :bat => 'bar')
+    #
+    # Returns the number of jobs removed
+    def remove_delayed_from_queue(queue, timestamp, klass, *args)
+      timestamp = timestamp.to_i
+      item = {'class' => klass.to_s, 'args' => args}
+      item['queue'] = queue.to_s if queue
+      search = MultiJson.encode(item)
+      count = Sidekiq.redis.lrem("delayed:#{timestamp}", 0, search)
+      remove_scheduler_queue(timestamp)
+      count
+    end
+  end
+end
+
+  Sidekiq::Client.send(:extend, SidekiqScheduler::Client)

data/lib/sidekiq-scheduler/manager.rb

@@ -0,0 +1,86 @@
+require 'celluloid'
+require 'redis'
+require 'multi_json'
+
+require 'sidekiq/util'
+
+module SidekiqScheduler
+
+  ##
+  # The delayed job router in the system.  This
+  # manages the scheduled jobs pushed messages
+  # from Redis onto the work queues
+  #
+  class Manager
+    include Sidekiq::Util
+    include Celluloid
+
+    def initialize(options={})
+      logger.info "Booting sidekiq scheduler #{SidekiqScheduler::VERSION} with Redis at #{redis.client.location}"
+      logger.debug { options.inspect }
+      @enabled = options[:scheduler]
+      @resolution = options[:resolution] || 5
+    end
+
+    def stop
+      @enabled = false
+    end
+
+    def start
+      schedule(true)
+    end
+
+    def reset
+      clear_scheduled_work
+    end
+
+    private
+
+    def clear_scheduled_work
+      queues = redis.zrange('delayed_queue_schedule', 0, -1).to_a
+      redis.del(*queues.map { |t| "delayed:#{t}" }) unless queues.empty?
+      redis.del('delayed_queue_schedule')
+    end
+
+    def find_scheduled_work(timestamp)
+      loop do
+        break logger.debug("Finished processing queue for timestamp #{timestamp}") unless msg = redis.lpop("delayed:#{timestamp}")
+        item = MultiJson.decode(msg)
+        queue = item.delete('queue')
+        Sidekiq::Client.push(queue, item)
+      end
+      Sidekiq::Client.remove_scheduler_queue(timestamp)
+    end
+
+    def find_next_timestamp
+      timestamp = redis.zrangebyscore('delayed_queue_schedule', '-inf', Time.now.to_i, :limit => [0, 1])
+      if timestamp.is_a?(Array)
+        timestamp = timestamp.first
+      end
+      timestamp.to_i unless timestamp.nil?
+    end
+
+    def schedule(run_loop = false)
+      watchdog("Fatal error in sidekiq, scheduler loop died") do
+        return if stopped?
+
+        # Dispatch loop
+        loop do
+          break logger.debug('no scheduler queues to process') unless timestamp = find_next_timestamp
+          find_scheduled_work(timestamp)
+        end
+
+        # This is the polling loop that ensures we check Redis every
+        # second for work, even if there was nothing to do this time
+        # around.
+        after(@resolution) do
+          schedule(run_loop)
+        end if run_loop
+      end
+    end
+
+    def stopped?
+      !@enabled
+    end
+  end
+end

data/lib/sidekiq-scheduler/version.rb

@@ -1,3 +1,3 @@
 module SidekiqScheduler
-  VERSION = "0.0.0"
+  VERSION = "0.1.0"
 end

data/lib/sidekiq-scheduler/worker.rb

@@ -0,0 +1,18 @@
+require 'sidekiq-scheduler/client'
+require 'sidekiq/worker'
+
+module SidekiqScheduler
+  module Worker
+    module ClassMethods
+      def perform_at(timestamp, *args)
+        Sidekiq::Client.delayed_push(timestamp, 'class' => self.name, 'args' => args)
+      end
+
+      def perform_in(seconds_from_now, *args)
+        Sidekiq::Client.delayed_push(Time.now + seconds_from_now, 'class' => self.name, 'args' => args)
+      end
+    end
+  end
+end
+
+Sidekiq::Worker::ClassMethods.send(:include, SidekiqScheduler::Worker::ClassMethods)

data/lib/sidekiq-scheduler.rb

@@ -1,2 +1,4 @@
-module SidekiqScheduler
-end
+require 'sidekiq-scheduler/cli'
+require 'sidekiq-scheduler/client'
+require 'sidekiq-scheduler/manager'
+require 'sidekiq-scheduler/version'

data/test/cli_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'sidekiq-scheduler/cli'
+require 'tempfile'
+
+class CliTest < MiniTest::Unit::TestCase
+  describe 'with cli' do
+    before do
+      @cli = new_cli
+    end
+
+    describe 'with config file' do
+      before do
+        @cli.parse(['sidekiq', '-C', './test/config.yml'])
+      end
+
+      it 'sets the resolution of the scheduler timer' do
+        assert_equal 30, Sidekiq.options[:resolution]
+      end
+    end
+
+    def new_cli
+      cli = Sidekiq::CLI.new
+      def cli.die(code)
+        @code = code
+      end
+
+      def cli.valid?
+        !@code
+      end
+      cli
+    end
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,118 @@
+require 'test_helper'
+require 'timecop'
+
+class ClientTest < MiniTest::Unit::TestCase
+  describe 'with real redis' do
+    before do
+      Sidekiq.redis = { :url => 'redis://localhost/sidekiq_test' }
+      Sidekiq.redis.flushdb
+    end
+
+    it 'removes scheduled messages and returns count' do
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      assert_equal 1, Sidekiq::Client.remove_all_delayed('Foo', 1, 2)
+    end
+
+    it 'removes scheduled messages for a queue and returns count' do
+      Sidekiq::Client.delayed_push('foo', 1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      assert_equal 1, Sidekiq::Client.remove_all_delayed_from_queue('foo', 'Foo', 1, 2)
+    end
+
+    it 'removes only selected scheduled messages' do
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [3, 4])
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [3, 4])
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [5, 6])
+      assert_equal 0, Sidekiq::Client.remove_all_delayed('Foo')
+    end
+
+    it 'removes messages in different timestamp queues' do
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      Sidekiq::Client.delayed_push(1331284492, 'class' => 'Foo', 'args' => [3, 4])
+      Sidekiq::Client.delayed_push(1331284493, 'class' => 'Foo', 'args' => [3, 4])
+      Sidekiq::Client.delayed_push(1331284493, 'class' => 'Foo', 'args' => [5, 6])
+      assert_equal 2, Sidekiq::Client.remove_all_delayed('Foo', 3, 4)
+    end
+
+    it 'removes messages from specified timestamp' do
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      Sidekiq::Client.delayed_push(1331284492, 'class' => 'Foo', 'args' => [1, 2])
+      assert_equal 1, Sidekiq::Client.remove_delayed(1331284491, 'Foo', 1, 2)
+      assert_equal 1, Sidekiq.redis.llen('delayed:1331284492')
+    end
+
+    it 'removes messages for a queue from specified timestamp' do
+      Sidekiq::Client.delayed_push('foo', 1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      Sidekiq::Client.delayed_push('foo', 1331284492, 'class' => 'Foo', 'args' => [1, 2])
+      assert_equal 1, Sidekiq::Client.remove_delayed_from_queue('foo', 1331284491, 'Foo', 1, 2)
+      assert_equal 1, Sidekiq.redis.llen('delayed:1331284492')
+    end
+
+    it 'removes nothing if no message is found' do
+      assert_equal 0, Sidekiq::Client.remove_delayed(1331284491, 'Foo', 3, 4)
+    end
+
+    it 'removes only messages with matching arguments' do
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [3, 2])
+      assert_equal 0, Sidekiq::Client.remove_delayed(1331284491, 'Foo', 3, 4)
+      assert_equal 2, Sidekiq.redis.llen('delayed:1331284491')
+    end
+
+    it 'removes empty scheduler queues' do
+      Sidekiq::Client.delayed_push(1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      assert_equal 1, Sidekiq::Client.remove_delayed(1331284491, 'Foo', 1, 2)
+      assert !Sidekiq.redis.exists('delayed:1331284491')
+      assert_equal 0, Sidekiq.redis.zcard('delayed_scheduler_queue')
+    end
+  end
+
+  describe 'with mock redis' do
+    before do
+      @redis = MiniTest::Mock.new
+      def @redis.multi; yield; end
+      def @redis.set(*); true; end
+      def @redis.sadd(*); true; end
+      def @redis.srem(*); true; end
+      def @redis.get(*); nil; end
+      def @redis.del(*); nil; end
+      def @redis.incrby(*); nil; end
+      def @redis.setex(*); nil; end
+      def @redis.expire(*); true; end
+      def @redis.with_connection; yield self; end
+      Sidekiq.instance_variable_set(:@redis, @redis)
+    end
+
+    it 'pushes delayed messages to redis' do
+      @redis.expect :rpush, 1, ['delayed:1331284491', String]
+      @redis.expect :zadd, 1, ['delayed_queue_schedule', 1331284491, 1331284491]
+      Sidekiq::Client.delayed_push('foo', 1331284491, 'class' => 'Foo', 'args' => [1, 2])
+      @redis.verify
+    end
+
+    it 'removes empty scheduler queues' do
+      @redis.expect :llen, 0, ['delayed:1331284491']
+      @redis.expect :zrem, 1, ['delayed_queue_schedule', 1331284491]
+      Sidekiq::Client.remove_scheduler_queue(1331284491)
+      @redis.verify
+    end
+
+    it 'handles perform_at' do
+      @redis.expect :rpush, 1, ['delayed:1331284491', String]
+      @redis.expect :zadd, 1, ['delayed_queue_schedule', 1331284491, 1331284491]
+      MyWorker.perform_at(1331284491, 1, 2)
+      @redis.verify
+    end
+
+    it 'handles perform_in' do
+      Timecop.freeze(Time.now) do
+        timestamp = Time.now + 30
+        @redis.expect :rpush, 1, ["delayed:#{timestamp.to_i}", String]
+        @redis.expect :zadd, 1, ['delayed_queue_schedule', timestamp.to_i, timestamp.to_i]
+        MyWorker.perform_in(30, 1, 2)
+        @redis.verify
+      end
+    end
+
+  end
+end

data/test/config.yml

@@ -0,0 +1,10 @@
+---
+:verbose:      false
+:environment:  xzibit
+:require:      ./test/fake_env.rb
+:pidfile:      /tmp/sidekiq-config-test.pid
+:concurrency:  50
+:resolution:   30
+:queues:
+  - [often, 2]
+  - [seldom, 1]

data/test/manager_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require 'sidekiq'
+require 'sidekiq/manager'
+
+class ManagerTest < MiniTest::Unit::TestCase
+  describe 'with redis' do
+    before do
+      Sidekiq.redis = { :url => 'redis://localhost/sidekiq_test' }
+      @scheduler = SidekiqScheduler::Manager.new
+      @redis = Sidekiq.redis
+      @redis.flushdb
+      $processed = 0
+      $mutex = Mutex.new
+    end
+
+    class IntegrationWorker
+      include Sidekiq::Worker
+
+      def perform(a, b)
+        $mutex.synchronize do
+          $processed += 1
+        end
+        a + b
+      end
+    end
+
+    it 'detects an empty schedule run' do
+      assert_nil @scheduler.send(:find_next_timestamp)
+    end
+
+    it 'processes only jobs that are due' do
+      timestamp = Time.now + 600
+      Sidekiq::Client.delayed_push(:foo, timestamp, 'class' => IntegrationWorker, 'args' => [1,2])
+      assert_nil @scheduler.send(:find_next_timestamp)
+    end
+
+    it 'processes queues in the right order' do
+      Sidekiq::Client.delayed_push(:foo, 1331284491, 'class' => IntegrationWorker, 'args' => [1,2])
+      Sidekiq::Client.delayed_push(:foo, 1331284492, 'class' => IntegrationWorker, 'args' => [1,2])
+
+      assert_equal 1331284491, @scheduler.send(:find_next_timestamp)
+    end
+
+    it 'moves jobs from the scheduler queues to the worker queues' do
+      Sidekiq::Client.delayed_push(:foo, 1331284491, 'class' => IntegrationWorker, 'args' => [1,2])
+
+      @scheduler.send(:find_scheduled_work, 1331284491)
+
+      assert_equal 0, @redis.llen("delayed:1331284491")
+      assert_equal 1, @redis.llen("queue:foo")
+    end
+
+    it 'resets the scheduler queue' do
+      Sidekiq::Client.delayed_push(:foo, 1331284491, 'class' => IntegrationWorker, 'args' => [1,2])
+      Sidekiq::Client.delayed_push(:foo, 1331284492, 'class' => IntegrationWorker, 'args' => [1,2])
+      Sidekiq::Client.delayed_push(:foo, 1331284493, 'class' => IntegrationWorker, 'args' => [1,2])
+
+      @scheduler.reset
+
+      assert_equal 0, @redis.zcard('delayed_queue_schedule')
+      assert !@redis.exists('delayed:1331284491')
+      assert !@redis.exists('delayed:1331284492')
+      assert !@redis.exists('delayed:1331284493')
+    end
+  end
+end

data/test/support/my_worker.rb

@@ -0,0 +1,3 @@
+class MyWorker
+  include Sidekiq::Worker
+end

data/test/test_helper.rb

@@ -1,10 +1,11 @@
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
+require 'minitest/unit'
+require 'minitest/pride'
+require 'minitest/autorun'
+require 'sidekiq-scheduler'
 
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
-require "rails/test_help"
-
-Rails.backtrace_cleaner.remove_silencers!
+require 'sidekiq/util'
+Sidekiq::Util.logger.level = Logger::ERROR
 
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-12 00:00:00.000000000 Z
+date: 2012-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
-  requirement: &70202400366100 !ruby/object:Gem::Requirement
+  requirement: &70235778635560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 0.8.0
   type: :runtime
   prerelease: false
-  version_requirements: *70202400366100
+  version_requirements: *70235778635560
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70202400365520 !ruby/object:Gem::Requirement
+  requirement: &70235778634920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70202400365520
+  version_requirements: *70235778634920
 - !ruby/object:Gem::Dependency
   name: timecop
-  requirement: &70202400364720 !ruby/object:Gem::Requirement
+  requirement: &70235778634440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70202400364720
+  version_requirements: *70235778634440
 description: Light weight job scheduling extension for Sidekiq that adds support for
   queueing items in the future.
 email:
@@ -52,13 +52,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/sidekiq-scheduler/cli.rb
+- lib/sidekiq-scheduler/client.rb
+- lib/sidekiq-scheduler/manager.rb
 - lib/sidekiq-scheduler/version.rb
+- lib/sidekiq-scheduler/worker.rb
 - lib/sidekiq-scheduler.rb
 - lib/tasks/sidekiq-scheduler_tasks.rake
 - MIT-LICENSE
 - Rakefile
 - README.md
-- test/sidekiq-scheduler_test.rb
+- test/cli_test.rb
+- test/client_test.rb
+- test/config.yml
+- test/fake_env.rb
+- test/manager_test.rb
+- test/support/my_worker.rb
 - test/test_helper.rb
 homepage: https://github.com/yabawock/sidekiq-scheduler
 licenses: []
@@ -74,7 +83,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -299860287847979622
+      hash: -2626338027335115584
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -83,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -299860287847979622
+      hash: -2626338027335115584
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.17
@@ -91,5 +100,10 @@ signing_key:
 specification_version: 3
 summary: Light weight job scheduling extension for Sidekiq
 test_files:
-- test/sidekiq-scheduler_test.rb
+- test/cli_test.rb
+- test/client_test.rb
+- test/config.yml
+- test/fake_env.rb
+- test/manager_test.rb
+- test/support/my_worker.rb
 - test/test_helper.rb

data/test/sidekiq-scheduler_test.rb

@@ -1,7 +0,0 @@
-require 'test_helper'
-
-class SidekiqSchedulerTest < ActiveSupport::TestCase
-  test "truth" do
-    assert_kind_of Module, SidekiqScheduler
-  end
-end