sidekiq-scheduler 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f61962caca434778af22dffae98cdbb9c154774
-  data.tar.gz: 7ecd8c8fc1b61780593346b11f88f719d900cddf
+  metadata.gz: e699dac84cd996f77b54a71564a2e888a5444c6d
+  data.tar.gz: 597847f71ef33050a54ded0d313204d3604f2742
 SHA512:
-  metadata.gz: 11efa51145977a60adf4238a316a2e906ffe3f7767ea5ac15a30f1b7fd2f0331412db631371e91ca48869609c9fa6142621df190c962e1a74fc6eb95c3d34703
-  data.tar.gz: 1086eb5cdfb1920a3d6f713a793939cccf62c74a8c235aedc598ba6216ec9fc3eb97967f2e962fa6b5c2e7c20b32492a10d48a009558e726e84c0f0cb28915bd
+  metadata.gz: 933d343adcbb79210f95308de2b4612d4c0dd1185ea1b2b1d0fa9ae810b2e4a10031ef0d7b5ef90d95cf9168d742c9a9f4fa5369a87b3157397e9de0cc8b730f
+  data.tar.gz: 6813ae6ab82f3ffc24446734071114ad0ed446d15060bf8789b8ae98f6cfb44941c209bb9a1eb5875e8f6bc90a55a8050629ba15546c4972835f09421d63290a

data/README.md

@@ -6,7 +6,7 @@
 
 <p align="center">
   <a href="https://badge.fury.io/rb/sidekiq-scheduler">
-    <img src="https://badge.fury.io/rb/sidekiq-scheduler.png" alt="Gem Version">
+    <img src="https://badge.fury.io/rb/sidekiq-scheduler.svg" alt="Gem Version">
   </a>
   <a href="https://codeclimate.com/github/moove-it/sidekiq-scheduler">
     <img src="https://codeclimate.com/github/moove-it/sidekiq-scheduler/badges/gpa.svg" alt="Code Climate">
@@ -25,261 +25,213 @@
   </a>
 </p>
 
-sidekiq-scheduler is an extension to [Sidekiq](http://github.com/mperham/sidekiq) that adds support
-for running scheduled jobs, which are like cron jobs, recurring on a regular basis.
+`sidekiq-scheduler` is an extension to [Sidekiq](http://github.com/mperham/sidekiq) that
+pushes jobs in a scheduled way, mimicking cron utility.
 
 ## Installation
 
-Add this to your Gemfile:
-
-``` ruby
-gem 'sidekiq-scheduler', '~> 2.0'
+``` shell
+gem install sidekiq-scheduler
 ```
 
-If you are using Rails you are set.
+## Usage
+
+### Hello World
 
-If you are not using Rails create a file with this content:
 
 ``` ruby
-# config/initializers/scheduler.rb
+# hello-scheduler.rb
 
 require 'sidekiq-scheduler'
 
-Dir[File.join(__dir__, '../../lib/workers/**/*.rb')].each(&method(:require))
+class HelloWorld
+  include Sidekiq::Worker
+
+  def perform
+    puts 'Hello world'
+  end
+end
 ```
 
-and then execute:
+``` yaml
+# config/sidekiq.yml
 
-``` sh
-sidekiq -r ./config/initializers/scheduler.rb
+:schedule:
+  hello_world:
+    every: 1m   # Runs once per minute
+    class: HelloWorld
 ```
 
-Look at [Loading the schedule](https://github.com/moove-it/sidekiq-scheduler/#loading-the-schedule)
-for information on how to load your schedule.
+Run sidekiq:
 
-You can add sidekiq-scheduler configuration options to `sidekiq.yml` config file.
-Available options are:
+``` sh
+sidekiq -r ./hello-scheduler.rb
+```
+
+You'll see the following output:
 
-``` yaml
-:schedule: <the schedule to be run>
-:dynamic: <if true the schedule can be modified in runtime [false by default]>
-:enabled: <enables scheduler if true [true by default]>
-:scheduler:
-  :listened_queues_only: <push jobs whose queue is being listened by sidekiq [false by default]>
 ```
+2016-12-10T11:53:08.561Z 6452 TID-ovouhwvm4 INFO: Loading Schedule
+2016-12-10T11:53:08.561Z 6452 TID-ovouhwvm4 INFO: Scheduling HelloWorld {"cron"=>"0 * * * * *", "class"=>"HelloWorld"}
+2016-12-10T11:53:08.562Z 6452 TID-ovouhwvm4 INFO: Schedules Loaded
 
-## Manage tasks from Unicorn/Rails server
+2016-12-10T11:54:00.212Z 6452 TID-ovoulivew HelloWorld JID-b35f36a562733fcc5e58444d INFO: start
+Hello world
+2016-12-10T11:54:00.213Z 6452 TID-ovoulivew HelloWorld JID-b35f36a562733fcc5e58444d INFO: done: 0.001 sec
 
-If you want start sidekiq-scheduler only from Unicorn/Rails, but not from Sidekiq you can have
-something like this in an initializer:
+2016-12-10T11:55:00.287Z 6452 TID-ovoulist0 HelloWorld JID-b7e2b244c258f3cd153c2494 INFO: start
+Hello world
+2016-12-10T11:55:00.287Z 6452 TID-ovoulist0 HelloWorld JID-b7e2b244c258f3cd153c2494 INFO: done: 0.001 sec
+```
 
-``` ruby
-# config/initializers/sidekiq_scheduler.rb
-require 'sidekiq/scheduler'
+## Configuration options
 
-puts "Sidekiq.server? is #{Sidekiq.server?.inspect}"
-puts "defined?(Rails::Server) is #{defined?(Rails::Server).inspect}"
-puts "defined?(Unicorn) is #{defined?(Unicorn).inspect}"
+Configuration options are placed inside `sidekiq.yml` config file.
 
-if Rails.env == 'production' && (defined?(Rails::Server) || defined?(Unicorn))
-  Sidekiq.configure_server do |config|
+Available options are:
 
-    config.on(:startup) do
-      Sidekiq.schedule = YAML.load_file(File.expand_path('../../scheduler.yml', __FILE__))
-      Sidekiq::Scheduler.reload_schedule!
-    end
-  end
-else
-  Sidekiq::Scheduler.enabled = false
-  puts "Sidekiq::Scheduler.enabled is #{Sidekiq::Scheduler.enabled.inspect}"
-end
+``` yaml
+:dynamic: <if true the schedule can be modified in runtime [false by default]>
+:enabled: <enables scheduler if true [true by default]>
+:scheduler:
+  :listened_queues_only: <push jobs whose queue is being listened by sidekiq [false by default]>
 ```
 
-## Scheduled Jobs (Recurring Jobs)
+## Schedule configuration
 
-Scheduled (or recurring) jobs are logically no different than a standard cron
-job. They are jobs that run based on a fixed schedule which is set at
-startup.
-
-The schedule is a list of Sidekiq worker classes with arguments and a
-schedule frequency (in crontab syntax). The schedule is just a Hash, being most likely
-stored in a YAML like so:
+The schedule is configured through the `:schedule` config entry in the sidekiq config file:
 
 ``` yaml
+:schedule:
   CancelAbandonedOrders:
-    cron: "*/5 * * * *"
+    every: 5m             # runs every 5 minutes, job's class: CancelAbandonedOrders
 
   queue_documents_for_indexing:
-    cron: "0 0 * * *"
-    # you can use rufus-scheduler "every" syntax in place of cron if you prefer
-    # every: 1h
+    every: 1h    # runs every 1 hour
 
-    # By default the job name (Hash key) will be taken as worker class name.
+    # By default the job name will be taken as worker class name.
     # If you want to have a different job name and class name, provide the 'class' option
     class: QueueDocuments
 
-    queue: high
-    args:
-    description: "This job queues all content for indexing in solr"
+    queue: slow
+    args: ['*.pdf']
+    description: "This job queues pdf content for indexing in solr"
 
-  clear_leaderboards_contributors:
-    cron: "30 6 * * 1"
-    class: ClearLeaderboards
-    queue: low
-    args: contributors
-    description: "This job resets the weekly leaderboard for contributions"
+    # Enable / disable a job. All jobs are enabled by default.
+    enabled: true
 ```
 
-You can provide options to `every` or `cron` via an Array:
 
-``` yaml
-  clear_leaderboards_moderator:
-    every: ["30s", first_in: '120s']
-    class: CheckDaemon
-    queue: low
-    description: "This job will check Daemon every 30 seconds after 120 seconds after start"
-```
+## Schedule types
 
+Supported types are `cron`, `every`, `interval`, `at`, `in`.
 
-NOTE: Six parameter cron's are also supported (as they supported by
-rufus-scheduler which powers the sidekiq-scheduler process).  This allows you
-to schedule jobs per second (ie: `30 * * * * *` would fire a job every 30
-seconds past the minute).
+Cron, every, and interval types push jobs into sidekiq in a recurrent manner.
 
-A big shout out to [rufus-scheduler](http://github.com/jmettraux/rufus-scheduler)
-for handling the heavy lifting of the actual scheduling engine.
+`cron` follows the same pattern as cron utility, with seconds resolution.
 
-NOTE: As schedules are persisted in Redis, an empty schedule will purge any schedule previously stored.
-sidekiq-scheduler instances running with `dynamic` flag set to `true` and empty schedule configuration will not push any job.
-Before version 2.0.8, instances matching those conditions read the previously stored schedule and push the jobs to sidekiq as usual.
+``` yaml
+:schedule:
+  HelloWorld:
+    cron: '0 * * * * *' # Runs when second = 0
+```
 
-With version >= `2.0.8` the purge of Redis schedules config can be prevented by setting
-`enabled` flag to `false`:
+`every` triggers following a given frequency:
 
-```yaml
-:enabled: false
+``` yaml
+    every: '45m'    # Runs every 45 minutes
 ```
-### Enabling/Disabling jobs
 
-By default all the jobs are enabled. There is an option at job's configuration to change
-this behavior.
+`interval` is similar to `every`, the difference between them is that `interval` type schedules the
+next execution after the interval has elapsed counting from its last job enqueue.
 
+At, and in types push jobs only once. `at` schedules in a point in time:
 ``` yaml
-clear_leaderboards_moderator:
-  every: "30s"
-  class: CheckDaemon
-  enabled: false
-  description: "This job is disabled by default"
+    at: '3001/01/01'
 ```
 
-However, the flag can be changed through the web interface at the Recurring Jobs tab.
+You can specify any string that `DateTime.parse` and `Chronic` understand. To enable Chronic
+strings, you must add it as a dependency.
 
-NOTE: Changes made thorugh the UI supersede job's configuration, even after a restart.
+`in` triggers after a time duration has elapsed:
 
-### Loading the schedule
+``` yaml
+    in: 1h # pushes a sidekiq job in 1 hour, after start-up
+```
 
-Let's assume your scheduled jobs are defined in a file called `config/scheduler.yml` under your Rails project,
-you could create a Rails initializer called `config/initializers/scheduler.rb` which would load the job definitions:
+You can provide options to `every` or `cron` via an Array:
 
-```ruby
-require 'sidekiq/scheduler'
+``` yaml
+    every: ['30s', first_in: '120s']
+```
 
-Sidekiq.configure_server do |config|
-  config.on(:startup) do
-    Sidekiq.schedule = YAML.load_file(File.expand_path('../../scheduler.yml', __FILE__))
-    Sidekiq::Scheduler.reload_schedule!
-  end
-end
+See https://github.com/jmettraux/rufus-scheduler for more information.
+
+## Load the schedule from a different file
+
+You can place the schedule configuration in a separate file from `config/sidekiq.yml`
+
+``` yaml
+# sidekiq_scheduler.yml
+
+clear_leaderboards_contributors:
+  cron: '0 30 6 * * 1'
+  class: ClearLeaderboards
+  queue: low
+  args: contributors
+  description: 'This job resets the weekly leaderboard for contributions'
 ```
 
-If you are running a non Rails project you should add code to load the workers classes before loading the schedule.
+Please notice that the `schedule` root key is not present in the separate file.
 
-```ruby
+To load the schedule:
+
+``` ruby
+require 'sidekiq'
 require 'sidekiq/scheduler'
-Dir[File.expand_path('../../../lib/workers/*.rb', __FILE__)].each do |file| load file; end
 
 Sidekiq.configure_server do |config|
   config.on(:startup) do
-    Sidekiq.schedule = YAML.load_file(File.expand_path("../../scheduler.yml", __FILE__))
+    Sidekiq.schedule = YAML.load_file(File.expand_path('../../sidekiq_scheduler.yml', __FILE__))
     Sidekiq::Scheduler.reload_schedule!
   end
 end
 ```
 
-You can also put your schedule information inside sidekiq.yml and load it with:
-
-```sh
-sidekiq -C ./config/sidekiq.yml
-```
-
-#### The Spring preloader and Testing your initializer via Rails console
+The above code can be placed in an initializer (in `config/initializers`) that runs every time the app starts up.
 
-If you're pulling in your schedule from a YML file via an initializer as shown, be aware that the Spring application preloader included with Rails will interefere with testing via the Rails console.
-
-**Spring will not reload initializers** unless the initializer is changed.  Therefore, if you're making a change to your YML schedule file and reloading Rails console to see the change, Spring will make it seem like your modified schedule is not being reloaded.
-
-To see your updated schedule, be sure to reload Spring by stopping it prior to booting the Rails console.
-
-Run `spring stop` to stop Spring.
-
-For more information, see [this issue](https://github.com/Moove-it/sidekiq-scheduler/issues/35#issuecomment-48067183) and [Spring's README](https://github.com/rails/spring/blob/master/README.md).
+## Dynamic schedule
 
-### Reloading the schedules
+The schedule can be modified after startup. To add / update a schedule, you have to:
 
-Schedules are stored in Redis. To add / update an schedule, you have to:
-
-```ruby
+``` ruby
 Sidekiq.set_schedule('heartbeat', { 'every' => ['1m'], 'class' => 'HeartbeatWorker' })
 ```
 
-When `:dynamic` flag is set to `true`, schedule changes are loaded every 5 seconds.
+If the schedule did not exist it will be created, if it existed it will be updated.
 
-You can set that flag in the following ways.
-
-- YAML configuration:
+When `:dynamic` flag is set to `true`, schedule changes are loaded every 5 seconds.
 
-```
+``` yaml
+# config/sidekiq.yml
 :dynamic: true
 ```
 
-- Initializer configuration:
-
-```ruby
-Sidekiq.configure_server do |config|
-  # ...
-  Sidekiq::Scheduler.dynamic = true
-end
-```
-
-If `:dynamic` flag is set to `false`, you have to reload the schedule manually in sidekiq
+If `:dynamic` flag is set to `false`, you'll have to reload the schedule manually in sidekiq
 side:
 
-```ruby
+``` ruby
 Sidekiq::Scheduler.reload_schedule!
 ```
 
-If the schedule did not exist it will we created, if it existed it will be updated.
-
-### Testing
-
-In your tests you can check that a schedule change has been set you have to:
-
-```ruby
-require 'sidekiq'
-require 'sidekiq-scheduler'
-require 'sidekiq-scheduler/test'
-
-Sidekiq.set_schedule('some_name', { 'every' => ['1m'], 'class' => 'HardWorker' })
-
-Sidekiq::Scheduler.schedules
-#  => { 'every' => ['1m'], 'class' => 'HardWorker' }
+Invoke `Sidekiq.get_schedule` to obtain the current schedule:
 
-Sidekiq::Scheduler.schedules_changed
-#  => ['every']
+``` ruby
+Sidekiq.get_schedule
+#  => { 'every' => '1m', 'class' => 'HardWorker' }
 ```
 
-
-### Time zones
+## Time zones
 
 Note that if you use the cron syntax, this will be interpreted as in the server time zone
 rather than the `config.time_zone` specified in Rails.
@@ -287,7 +239,7 @@ rather than the `config.time_zone` specified in Rails.
 You can explicitly specify the time zone that rufus-scheduler will use:
 
 ``` yaml
-cron: "30 6 * * 1 Europe/Stockholm"
+    cron: '0 30 6 * * 1 Europe/Stockholm'
 ```
 
 Also note that `config.time_zone` in Rails allows for a shorthand (e.g. "Stockholm")
@@ -298,32 +250,63 @@ from the `config.time_zone` value, make sure it's the right format, e.g. with:
 ActiveSupport::TimeZone.find_tzinfo(Rails.configuration.time_zone).name
 ```
 
-A future version of sidekiq-scheduler may do this for you.
-
-### Sidekiq Web Integration
+## Sidekiq Web Integration
 
-SidekiqScheduler provides an extension to the Sidekiq web interface that adds a Recurring Jobs page.
-
-To use it, set up the Sidekiq web interface according to the Sidekiq documentation and then add the `sidekiq-scheduler/web` require:
+sidekiq-scheduler provides an extension to the Sidekiq web interface that adds a `Recurring Jobs` page.
 
 ``` ruby
+# config.ru
+
 require 'sidekiq/web'
+require 'sidekiq-scheduler'
 require 'sidekiq-scheduler/web'
+
+app = Rack::Builder.new {
+  run Sidekiq::Web
+}.to_app
+
+Rack::Handler::WEBrick.run app
 ```
 
-## Note on Patches / Pull Requests
+## The Spring preloader and Testing your initializer via Rails console
+
+If you're pulling in your schedule from a YML file via an initializer as shown, be aware that the Spring application preloader included with Rails will interefere with testing via the Rails console.
+
+**Spring will not reload initializers** unless the initializer is changed.  Therefore, if you're making a change to your YML schedule file and reloading Rails console to see the change, Spring will make it seem like your modified schedule is not being reloaded.
+
+To see your updated schedule, be sure to reload Spring by stopping it prior to booting the Rails console.
+
+Run `spring stop` to stop Spring.
+
+For more information, see [this issue](https://github.com/Moove-it/sidekiq-scheduler/issues/35#issuecomment-48067183) and [Spring's README](https://github.com/rails/spring/blob/master/README.md).
 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so it won't break it in a future version unintentionally.
-* Commit, do not mess with version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself so it can be ignored when merging)
-* Send a pull request. Bonus points for topic branches.
 
-## Credits
+## Manage tasks from Unicorn/Rails server
+
+If you want start sidekiq-scheduler only from Unicorn/Rails, but not from sidekiq you can have
+something like this in an initializer:
+
+``` ruby
+# config/initializers/sidekiq_scheduler.rb
+require 'sidekiq/scheduler'
 
-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.
+puts "Sidekiq.server? is #{Sidekiq.server?.inspect}"
+puts "defined?(Rails::Server) is #{defined?(Rails::Server).inspect}"
+puts "defined?(Unicorn) is #{defined?(Unicorn).inspect}"
+
+if Rails.env == 'production' && (defined?(Rails::Server) || defined?(Unicorn))
+  Sidekiq.configure_server do |config|
+
+    config.on(:startup) do
+      Sidekiq.schedule = YAML.load_file(File.expand_path('../../scheduler.yml', __FILE__))
+      Sidekiq::Scheduler.reload_schedule!
+    end
+  end
+else
+  Sidekiq::Scheduler.enabled = false
+  puts "Sidekiq::Scheduler.enabled is #{Sidekiq::Scheduler.enabled.inspect}"
+end
+```
 
 ## License
 
@@ -331,6 +314,6 @@ MIT License
 
 ## Copyright
 
-Copyright 2013 - 2016 Moove-IT.
+Copyright 2013 - 2017 Moove-IT.
 Copyright 2012 Morton Jonuschat.
 Some parts copyright 2010 Ben VandenBos.

data/lib/sidekiq-scheduler/rufus_utils.rb

@@ -0,0 +1,29 @@
+require 'hashie'
+
+module SidekiqScheduler
+  class RufusUtils
+
+    # Normalizes schedule options to rufust scheduler options
+    #
+    # @param options [String, [Array]
+    #
+    # @return [Array]
+    #
+    # @example
+    #   normalize_schedule_options('15m') => ['15m', {}]
+    #   normalize_schedule_options(['15m']) => ['15m', {}]
+    #   normalize_schedule_options(['15m', first_in: '5m']) => ['15m', { first_in: '5m' }]
+    def self.normalize_schedule_options(options)
+      schedule, opts = options
+
+      if !opts.is_a?(Hash)
+        opts = {}
+      end
+
+      opts = Hashie.symbolize_keys(opts)
+
+      return schedule, opts
+    end
+  end
+end
+

data/lib/sidekiq-scheduler/version.rb

@@ -1,5 +1,5 @@
 module SidekiqScheduler
 
-  VERSION = '2.1.0'
+  VERSION = '2.1.1'
 
 end

data/lib/sidekiq/scheduler.rb

@@ -2,6 +2,7 @@ require 'rufus/scheduler'
 require 'thwait'
 require 'sidekiq/util'
 require 'sidekiq-scheduler/manager'
+require 'sidekiq-scheduler/rufus_utils'
 require 'json'
 
 module Sidekiq
@@ -79,21 +80,6 @@ module Sidekiq
         end
       end
 
-      # modify interval type value to value with options if options available
-      def optionizate_interval_value(value)
-        args = value
-        if args.is_a?(::Array)
-          return args.first if args.size > 2 || !args.last.is_a?(::Hash)
-          # symbolize keys of hash for options
-          args[1] = args[1].inject({}) do |m, i|
-            key, value = i
-            m[(key.to_sym rescue key) || key] = value
-            m
-          end
-        end
-        args
-      end
-
       # Loads a job schedule into the Rufus::Scheduler and stores it in @@scheduled_jobs
       def load_schedule_job(name, config)
         # If rails_env is set in the config, enforce ENV['RAILS_ENV'] as
@@ -109,9 +95,9 @@ module Sidekiq
 
             if !config_interval_type.nil? && config_interval_type.length > 0
 
-              args = optionizate_interval_value(config_interval_type)
+              schedule, options = SidekiqScheduler::RufusUtils.normalize_schedule_options(config_interval_type)
 
-              rufus_job = new_job(name, interval_type, config, args)
+              rufus_job = new_job(name, interval_type, config, schedule, options)
               @@scheduled_jobs[name] = rufus_job
               update_job_next_time(name, rufus_job.next_time)
 
@@ -224,7 +210,7 @@ module Sidekiq
               unschedule_job(schedule_name)
             end
           end
-          logger.info 'Schedules Loaded'
+          logger.info 'Schedule updated'
         end
       end
 
@@ -369,10 +355,10 @@ module Sidekiq
         end
       end
 
-      def new_job(name, interval_type, config, args)
-        opts = { :job => true, :tags => [name] }
+      def new_job(name, interval_type, config, schedule, options)
+        options = options.merge({ :job => true, :tags => [name] })
 
-        rufus_scheduler.send(interval_type, *args, opts) do |job, time|
+        rufus_scheduler.send(interval_type, schedule, options) do |job, time|
           idempotent_job_enqueue(name, time, sanitize_job_config(config)) if job_enabled?(name)
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-scheduler
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Morton Jonuschat
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-13 00:00:00.000000000 Z
+date: 2017-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -249,6 +249,7 @@ files:
 - lib/sidekiq-scheduler.rb
 - lib/sidekiq-scheduler/job_presenter.rb
 - lib/sidekiq-scheduler/manager.rb
+- lib/sidekiq-scheduler/rufus_utils.rb
 - lib/sidekiq-scheduler/schedule.rb
 - lib/sidekiq-scheduler/version.rb
 - lib/sidekiq-scheduler/web.rb