sidecloq 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d0f6f9c7d36841096162c3d1ec7775220e58438
+  data.tar.gz: 4d11bcc58feabca4f13c0cf05f6a8d34257e5d29
+SHA512:
+  metadata.gz: 328c80251970cb9899a5106394a5a0c206ce5317fb88be4d4f01092e6521d7f8fcd487535403d6bd917636739be852b0a0051f51ea25ab739dfbebef040ce894
+  data.tar.gz: 3a956934c7415080ca8a68664471cab8e86707eb914b3ae4864f58b2ada039c47e7559c76054982f0e4780f58d87172079e8a4426be107f2d41e579e9c571bbd

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.ruby-version
+/.ruby-gemset

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+sudo: false
+cache: bundler
+services:
+  - redis-server
+rvm:
+  - 2.0.0
+  - 2.1.8
+  - 2.2.4
+  - ruby-head
+  - jruby-9.0.4.0
+  - jruby-head
+  - rbx-2.6
+  - rbx-2.7
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+platforms :mri do
+  gem 'pry'
+  gem 'minitest-utils'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Matt Robinson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# Sidecloq
+
+[![Build Status](https://travis-ci.org/mattyr/sidecloq.svg)](https://travis-ci.org/mattyr/sidecloq)
+
+Another recurring job extension for Sidekiq.
+
+## Why
+
+TODO: design principles, differences, inspiration (sidetiq,
+sidekiq-scheduler, resque-scheduler)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sidecloq'
+```
+
+Configure Sidecloq alongside your Sidekiq config.  If using Rails, and
+your schedule is located at config/sidecloq.yml, you don't have to do
+anything (ie, omit this whole configuration block).
+
+```ruby
+Sidcloq.configure do |config|
+  config[:schedule_file] =
+    File.join(Rails.root, "config/myschedule.yml")
+end
+```
+
+TODO: configuration options
+
+TODO: schedule file format (like resque-scheduler)
+
+## Web Extension
+
+Add Sidecloq::Web after Sidekiq::Web:
+
+```ruby
+require 'sidekiq/web'
+require 'sidecloq/web'
+```
+
+TODO: screenshot/directions
+
+## Contributing
+
+Bug reports and pull requests are welcome.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+TODO: project links

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+task :default => :test
+
+desc "Run the Sidekiq web interface (w/Sidecloq)"
+task :web do
+  require 'sidekiq'
+  require 'sidecloq'
+
+  Sidekiq.configure_client do |config|
+    config.redis = { url: 'redis://localhost:6379/0', size: 1, namespace: 'sidecloq' }
+  end
+
+  require 'sidekiq/web'
+  require 'sidecloq/web'
+
+  Rack::Server.start(
+    app: Sidekiq::Web
+  )
+end

data/lib/sidecloq/locker.rb

@@ -0,0 +1,57 @@
+module Sidecloq
+  # Locker obtains or waits for an exclusive lock on a key in redis
+  class Locker
+    include Utils
+
+    DEFAULT_LOCK_KEY = "sidecloq_leader_lock"
+
+    def initialize(options={})
+      # we keep a connection from the pool by default
+      @redis = options[:redis] || Sidekiq.redis_pool.checkout
+      @key = options[:lock_key] || DEFAULT_LOCK_KEY
+      @ttl = options[:ttl] || 60
+      @check_interval = options[:check_interval] || 15
+      @lock_manager = Redlock::Client.new([@redis])
+      @obtained_lock = Concurrent::Event.new
+    end
+
+    # blocks until lock is obtained, then yields
+    def with_lock
+      start
+      @obtained_lock.wait
+      yield
+      stop
+    end
+
+    def stop(timeout = nil)
+      if @check_task
+        logger.debug("Stopping locker check task")
+        @check_task.shutdown
+        @check_task.wait_for_termination(timeout)
+        logger.debug("Stopped locker check task")
+      end
+    end
+
+    def has_lock?
+      @obtained_lock.set?
+    end
+
+    private unless $TESTING
+
+    def start
+      logger.debug("Starting locker check task")
+      @check_task = Concurrent::TimerTask.new(execution_interval: @check_interval, run_now: true) do
+        get_or_refresh_lock
+      end
+      @check_task.execute
+    end
+
+    def get_or_refresh_lock
+      # redlock is in ms, not seconds
+      @lock = @lock_manager.lock(@key, @ttl * 1000, extend: @lock)
+      @obtained_lock.set if @lock
+      logger.debug("Leader lock #{"not " if !@lock}held")
+      @lock
+    end
+  end
+end

data/lib/sidecloq/runner.rb

@@ -0,0 +1,48 @@
+module Sidecloq
+  # Runner encapsulates a locker and a scheduler, running scheduler when
+  # "elected" leader
+  class Runner
+    include Utils
+
+    attr_reader :locker, :scheduler
+
+    def initialize(options = {})
+      @locker = extract_locker(options)
+      @scheduler = extract_scheduler(options)
+    end
+
+    def run
+      @thread = Thread.new do
+        logger.info("Runner starting")
+        @locker.with_lock do
+          # i am the leader
+          logger.info("Obtained leader lock")
+          @scheduler.run
+        end
+        logger.info("Runner ending")
+      end
+    end
+
+    def stop(timeout = nil)
+      logger.debug("Stopping runner")
+      if @locker.has_lock?
+        @scheduler.stop(timeout)
+        @locker.stop(timeout)
+      end
+      @thread.join if @thread
+      logger.debug("Stopped runner")
+    end
+
+    private unless $TESTING
+
+    def extract_locker(options)
+      return options[:locker] if options[:locker]
+      Locker.new(options[:locker_options] || {})
+    end
+
+    def extract_scheduler(options)
+      return options[:scheduler] if options[:scheduler]
+      Scheduler.new(options[:schedule], options[:scheduler_options] || {})
+    end
+  end
+end

data/lib/sidecloq/schedule.rb

@@ -0,0 +1,79 @@
+module Sidecloq
+  # Schedule loads and parses recurring job specs from files, hashes, and redis
+  class Schedule
+    include Utils
+
+    REDIS_KEY = :sidecloq_schedule
+
+    attr_reader :job_specs
+
+    def initialize(specs)
+      @job_specs = specs
+    end
+
+    def self.from_yaml(filename)
+      from_hash(YAML.load_file(filename))
+    end
+
+    def self.from_redis
+      specs = {}
+
+      if redis { |r| r.exists(REDIS_KEY) }
+        specs = {}
+
+        redis { |r| r.hgetall(REDIS_KEY) }.tap do |h|
+          h.each do |name, config|
+            specs[name] = MultiJson.decode(config)
+          end
+        end
+      end
+
+      from_hash(specs)
+    end
+
+    def self.from_hash(hash)
+      if defined?(Rails) && hash.key?(Rails.env)
+        hash = hash[Rails.env]
+      end
+
+      specs = hash.inject({}) do |memo, (name, spec)|
+        memo[name] = spec.dup.tap do |s|
+          s['class'] = name unless spec.key?('class') || spec.key?(:class)
+          s['args'] = s['args'] || s[:args] || []
+        end
+        memo
+      end
+
+      new(specs)
+    end
+
+    def save_yaml(filename)
+      File.open(filename,'w') do |h|
+        h.write @job_specs.to_yaml
+      end
+    end
+
+    def save_redis
+      reset_redis_schedule
+      save_all_to_redis
+    end
+
+    private unless $TESTING
+
+    def reset_redis_schedule
+      redis do |r|
+        r.hkeys(REDIS_KEY).each do |k|
+          r.hdel(REDIS_KEY, k)
+        end
+      end
+    end
+
+    def save_all_to_redis
+      redis do |r|
+        @job_specs.each do |name, spec|
+          r.hset(REDIS_KEY, name, MultiJson.encode(spec))
+        end
+      end
+    end
+  end
+end

data/lib/sidecloq/scheduler.rb

@@ -0,0 +1,85 @@
+module Sidecloq
+  # Scheduler enqeues jobs according to the given schedule
+  class Scheduler
+    include Utils
+
+    def initialize(schedule, options = {})
+      @schedule = schedule
+      @options = options
+    end
+
+    # run queues jobs per their schedules, blocking forever
+    def run
+      logger.info("Loading schedules into redis")
+      sync_with_redis
+      logger.info("Starting scheduler")
+      load_schedule_into_rufus
+      logger.debug("Joining rufus thread")
+      rufus.join
+      logger.debug("Scheduler run ended")
+    end
+
+    def stop(timeout = nil)
+      logger.info("Stopping scheduler (timeout: #{timeout})")
+      if timeout
+        t = Concurrent::ScheduledTask.new(timeout) do
+          rufus.shutdown(:kill) if rufus.up?
+        end
+        Thread.new do
+          rufus.shutdown(:wait)
+          t.cancel
+        end
+      else
+        rufus.shutdown(:wait)
+      end
+      rufus.join
+      logger.info("Stopped scheduler")
+    end
+
+    private unless $TESTING
+
+    def rufus
+      @rufus ||= Rufus::Scheduler.new
+    end
+
+    def sync_with_redis
+      @schedule.save_redis
+    end
+
+    def load_schedule_into_rufus
+      logger.debug("Scheduling jobs")
+      @schedule.job_specs.each do |name, spec|
+        load_into_rufus(name, spec)
+      end
+    end
+
+    def load_into_rufus(name, spec)
+      # rufus will loop indefinitely trying to find the next event time if the
+      # cronline is impossible, like '0 5 31 2 *'
+      if will_never_run(spec['cron'])
+        logger.info("Impossible cronline detected, not scheduling #{name}: #{spec}")
+      else
+        logger.info("Scheduling #{name}: #{spec}")
+        rufus.cron(spec['cron']) do
+          safe_enqueue_job(name, spec)
+        end
+      end
+    end
+
+    def safe_enqueue_job(name, spec)
+      logger.info "enqueueing #{name}"
+
+      # failed enqeueuing should not b0rk stuff
+      begin
+        enqueue_job!(name, spec)
+      rescue => e
+        logger.info "error enqueuing #{name} - #{e.class.name}: #{e.message}"
+      end
+    end
+
+    # can raise exceptions, but shouldn't
+    def enqueue_job!(name, spec)
+      Sidekiq::Client.push(spec)
+    end
+  end
+end

data/lib/sidecloq/utils.rb

@@ -0,0 +1,58 @@
+module Sidecloq
+  module Utils
+    class ContextLogger
+      def initialize(ctx)
+        @context = ctx
+      end
+
+      def method_missing(meth, *args)
+        Sidekiq::Logging.with_context(@context) do
+          Sidekiq.logger.send(meth, args)
+        end
+      end
+    end
+
+    def logger
+      @logger ||= ContextLogger.new('Sidecloq')
+    end
+
+    def redis(&block)
+      self.class.redis(&block)
+    end
+
+    # finds cron lines that are impossible, like '0 5 31 2 *'
+    # note: does not attempt to fully validate the cronline
+    def will_never_run(cronline)
+      # look for non-existent day of month
+      split = cronline.split(/\s+/)
+      if split.length > 3 &&
+          split[2] =~ /\d+/
+          split[3] =~ /\d+/
+
+        month = split[3].to_i
+        day = split[2].to_i
+        # special case for leap-year detection
+        return true if month == 2 && day <= 29
+
+        return !Date.valid_date?(0, month, day)
+
+      else
+        false
+      end
+    end
+
+    module ClassMethods
+      def redis(&block)
+        if block
+          Sidekiq.redis(&block)
+        else
+          Sidekiq.redis_pool.checkout
+        end
+      end
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+  end
+end

data/lib/sidecloq/version.rb

@@ -0,0 +1,3 @@
+module Sidecloq
+  VERSION = "0.1.0"
+end

data/lib/sidecloq/web.rb

@@ -0,0 +1,25 @@
+module Sidecloq
+  module Web
+    VIEW_PATH = File.expand_path('../../../web/views', __FILE__)
+
+    def self.registered(app)
+
+      app.get '/recurring' do
+        @schedule = Schedule.from_redis
+
+        erb File.read(File.join(VIEW_PATH, 'recurring.erb'))
+      end
+
+      app.post '/recurring/:name/enqueue' do |name|
+        if spec = Sidecloq::Schedule.from_redis.job_specs[name]
+          Sidekiq::Client.push(spec)
+        end
+        redirect "#{root_path}recurring"
+      end
+
+    end
+  end
+end
+
+Sidekiq::Web.register(Sidecloq::Web)
+Sidekiq::Web.tabs['Recurring'] = 'recurring'

data/lib/sidecloq.rb

@@ -0,0 +1,75 @@
+require 'sidekiq'
+require 'concurrent'
+require 'redlock'
+require 'multi_json'
+require 'rufus-scheduler'
+
+require 'sidecloq/utils'
+require 'sidecloq/schedule'
+require 'sidecloq/locker'
+require 'sidecloq/scheduler'
+require 'sidecloq/runner'
+require 'sidecloq/version'
+
+module Sidecloq
+  def self.install
+    Sidekiq.configure_server do |config|
+      config.on(:startup) do
+        Sidecloq.startup
+      end
+
+      config.on(:shutdown) do
+        Sidecloq.shutdown
+      end
+    end
+  end
+
+  def self.options
+    @options ||= {}
+  end
+
+  def self.options=(opts)
+    @options = opts
+  end
+
+  def self.configure
+    yield self
+  end
+
+  def self.startup
+    unless options[:scheduler]
+      options[:schedule] ||= extract_schedule
+    end
+    @runner = Runner.new(options)
+    @runner.run
+  end
+
+  def self.shutdown
+    @runner.stop(options[:timeout] || 10) if @runner
+  end
+
+  def self.extract_schedule
+    # do our best to do this automatically
+
+    # schedule handed to us
+    return options[:schedule] if options[:schedule]
+
+    # try for a file
+    options[:schedule_file] ||= "config/sidecloq.yml"
+    if File.exists?(options[:schedule_file])
+      return Schedule.from_yaml(options[:schedule_file])
+    elsif defined?(Rails)
+      # try rails-root-relative
+      full_path = File.join(Rails.root, options[:schedule_file])
+      if File.exists?(full_path)
+        options[:schedule_file] = full_path
+        return Schedule.from_yaml(options[:schedule_file])
+      end
+    end
+
+    # return an empty schedule
+    Schedule.new({})
+  end
+end
+
+Sidecloq.install

data/sidetoq.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sidecloq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sidecloq"
+  spec.version       = Sidecloq::VERSION
+  spec.authors       = ["Matt Robinson"]
+  spec.email         = ["robinson.matty@gmail.com"]
+
+  spec.summary       = %q{Recurring jobs for Sidekiq}
+  spec.description   = spec.summary
+  spec.homepage      = "http://github.com/mattyr/sidecloq"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sidekiq", "~> 4.0.1"
+  spec.add_dependency "redlock", "~> 0.1.2"
+  # mimics some dev dependencies of sidekiq:
+  spec.add_dependency "concurrent-ruby"
+  spec.add_dependency "sinatra", "~> 1.4", ">= 1.4.6"
+  spec.add_dependency "redis-namespace", "~> 1.5", ">= 1.5.2"
+  spec.add_dependency "multi_json", "~> 1.11"
+  spec.add_dependency "rufus-scheduler", "~> 3.1", ">= 3.1.10"
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/web/views/recurring.erb

@@ -0,0 +1,38 @@
+<h3>Recurring Jobs</h3>
+
+<div class="table_container">
+  <table class="table table-hover table-bordered table-striped table-white">
+    <thead>
+      <tr>
+        <th>Name</th>
+        <th>Description</th>
+        <th>Interval</th>
+        <th>Class</th>
+        <th>Queue</th>
+        <th>Arguments</th>
+        <th>Actions</th>
+      </tr>
+    </thead>
+
+    <tbody>
+      <% @schedule.job_specs.each do |name, job_spec| %>
+        <tr>
+          <td><%= name %></td>
+          <td><%= job_spec['description'] %></td>
+          <td><%= job_spec.fetch 'cron', job_spec['every'] %></td>
+          <td><%= job_spec['class'] %></td>
+          <td>
+            <a href="<%= root_path %>queues/<%= job_spec.fetch('queue', 'default') %>"><%= job_spec.fetch('queue', 'default') %></a>
+          </td>
+          <td><%= job_spec['args'] %></td>
+          <td>
+            <form action="<%= root_path %>recurring/<%= CGI.escape(name).gsub('+', '%20') %>/enqueue" method="post">
+              <%= csrf_tag if respond_to?(:csrf_tag) %>
+              <input class='btn btn-xs pull-left' type="submit" name="enque" value="<%= t('Enqueue Now') %>"/>
+            </form>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+</div>

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: sidecloq
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matt Robinson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+- !ruby/object:Gem::Dependency
+  name: redlock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.6
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.10
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Recurring jobs for Sidekiq
+email:
+- robinson.matty@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sidecloq.rb
+- lib/sidecloq/locker.rb
+- lib/sidecloq/runner.rb
+- lib/sidecloq/schedule.rb
+- lib/sidecloq/scheduler.rb
+- lib/sidecloq/utils.rb
+- lib/sidecloq/version.rb
+- lib/sidecloq/web.rb
+- sidetoq.gemspec
+- web/views/recurring.erb
+homepage: http://github.com/mattyr/sidecloq
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Recurring jobs for Sidekiq
+test_files: []