sidetiq-0.6.3/0000755000175000017500000000000012434123324014446 5ustar balasankarcbalasankarcsidetiq-0.6.3/Gemfile0000644000175000017500000000005012434123324015734 0ustar balasankarcbalasankarcsource 'https://rubygems.org' gemspec sidetiq-0.6.3/.gitignore0000644000175000017500000000011512434123324016433 0ustar balasankarcbalasankarclib/*.bundle coverage rdoc doc .yardoc .bundle Gemfile.lock pkg tmp dump.rdb sidetiq-0.6.3/Rakefile0000644000175000017500000000011112434123324016104 0ustar balasankarcbalasankarcDir["tasks/**/*.task"].each { |task| load task } task :default => :test sidetiq-0.6.3/metadata.yml0000644000175000017500000001425712434123324016762 0ustar balasankarcbalasankarc--- !ruby/object:Gem::Specification name: sidetiq version: !ruby/object:Gem::Version version: 0.6.3 platform: ruby authors: - Tobias Svensson autorequire: bindir: bin cert_chain: [] date: 2014-09-24 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: sidekiq requirement: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version version: 3.0.0 type: :runtime prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version version: 3.0.0 - !ruby/object:Gem::Dependency name: celluloid requirement: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version version: 0.14.1 type: :runtime prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version version: 0.14.1 - !ruby/object:Gem::Dependency name: ice_cube requirement: !ruby/object:Gem::Requirement requirements: - - '=' - !ruby/object:Gem::Version version: 0.11.1 type: :runtime prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - '=' - !ruby/object:Gem::Version version: 0.11.1 - !ruby/object:Gem::Dependency name: rake 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' - !ruby/object:Gem::Dependency name: sinatra 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' - !ruby/object:Gem::Dependency name: mocha 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' - !ruby/object:Gem::Dependency name: rack-test 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' - !ruby/object:Gem::Dependency name: minitest requirement: !ruby/object:Gem::Requirement requirements: - - "~>" - !ruby/object:Gem::Version version: 5.0.7 type: :development prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - "~>" - !ruby/object:Gem::Version version: 5.0.7 - !ruby/object:Gem::Dependency name: coveralls 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: - tob@tobiassvensson.co.uk executables: [] extensions: [] extra_rdoc_files: [] files: - ".gitignore" - ".travis.yml" - CHANGELOG.md - Gemfile - LICENSE - README.md - Rakefile - examples/Procfile - examples/config.ru - examples/server.rb - examples/workers/failing.rb - examples/workers/simple.rb - lib/sidetiq.rb - lib/sidetiq/actor.rb - lib/sidetiq/actor/clock.rb - lib/sidetiq/actor/handler.rb - lib/sidetiq/api.rb - lib/sidetiq/clock.rb - lib/sidetiq/config.rb - lib/sidetiq/handler.rb - lib/sidetiq/lock/meta_data.rb - lib/sidetiq/lock/redis.rb - lib/sidetiq/logging.rb - lib/sidetiq/middleware/history.rb - lib/sidetiq/schedulable.rb - lib/sidetiq/schedule.rb - lib/sidetiq/subclass_tracking.rb - lib/sidetiq/supervisor.rb - lib/sidetiq/version.rb - lib/sidetiq/views/_home_nav.erb - lib/sidetiq/views/_worker_nav.erb - lib/sidetiq/views/assets/styles.css - lib/sidetiq/views/history.erb - lib/sidetiq/views/locks.erb - lib/sidetiq/views/schedule.erb - lib/sidetiq/views/sidetiq.erb - lib/sidetiq/web.rb - sidetiq.gemspec - tasks/bundler.task - tasks/minitest.task - test/fixtures/backfill_worker.rb - test/fixtures/last_and_scheduled_ticks_worker.rb - test/fixtures/last_tick_worker.rb - test/fixtures/optional_arguments_worker.rb - test/fixtures/scheduled_worker.rb - test/fixtures/simple_worker.rb - test/fixtures/splat_args_worker.rb - test/helper.rb - test/test_clock.rb - test/test_config.rb - test/test_history.rb - test/test_lock_meta_data.rb - test/test_lock_redis.rb - test/test_schedulable.rb - test/test_schedule.rb - test/test_sidetiq.rb - test/test_subclass_tracking.rb - test/test_version.rb - test/test_web.rb - test/test_worker.rb homepage: http://github.com/tobiassvn/sidetiq licenses: - 3-clause BSD 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.2.2 signing_key: specification_version: 4 summary: Recurring jobs for Sidekiq test_files: - test/fixtures/backfill_worker.rb - test/fixtures/last_and_scheduled_ticks_worker.rb - test/fixtures/last_tick_worker.rb - test/fixtures/optional_arguments_worker.rb - test/fixtures/scheduled_worker.rb - test/fixtures/simple_worker.rb - test/fixtures/splat_args_worker.rb - test/helper.rb - test/test_clock.rb - test/test_config.rb - test/test_history.rb - test/test_lock_meta_data.rb - test/test_lock_redis.rb - test/test_schedulable.rb - test/test_schedule.rb - test/test_sidetiq.rb - test/test_subclass_tracking.rb - test/test_version.rb - test/test_web.rb - test/test_worker.rb sidetiq-0.6.3/lib/0000755000175000017500000000000012434123324015214 5ustar balasankarcbalasankarcsidetiq-0.6.3/lib/sidetiq.rb0000644000175000017500000000234312434123324017205 0ustar balasankarcbalasankarc# stdlib require 'ostruct' require 'singleton' require 'socket' require 'time' # gems require 'ice_cube' require 'sidekiq' require 'celluloid' # internal require 'sidetiq/config' require 'sidetiq/logging' require 'sidetiq/api' require 'sidetiq/subclass_tracking' require 'sidetiq/clock' 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 the Sidetiq::Clock actor. def clock Sidetiq::Supervisor.clock end # Public: Returns a Sidetiq::Handler worker. def handler Sidetiq::Supervisor.handler end end if Sidekiq.server? Sidetiq::Supervisor.run! end sidetiq-0.6.3/lib/sidetiq/0000755000175000017500000000000012434123324016656 5ustar balasankarcbalasankarcsidetiq-0.6.3/lib/sidetiq/version.rb0000644000175000017500000000066312434123324020675 0ustar balasankarcbalasankarcmodule Sidetiq # Public: Sidetiq version namespace. module VERSION # Public: Sidetiq major version number. MAJOR = 0 # Public: Sidetiq minor version number. MINOR = 6 # Public: Sidetiq patch level. PATCH = 3 # Public: Sidetiq version suffix. SUFFIX = nil # Public: String representation of the current Sidetiq version. STRING = [MAJOR, MINOR, PATCH, SUFFIX].compact.join('.') end end sidetiq-0.6.3/lib/sidetiq/config.rb0000644000175000017500000000132312434123324020447 0ustar balasankarcbalasankarcmodule Sidetiq class << self # Public: Sets the configuration used by Sidetiq. attr_writer :config # Public: Configuration wrapper for block configurations. # # Examples # # Sidetiq.configure do |config| # config.resolution = 0.2 # end # # Yields the configuration OpenStruct currently set. # Returns nothing. def configure yield config end # Public: Returns the current configuration used by Sidetiq. def config @config ||= OpenStruct.new end end configure do |config| config.worker_history = 50 config.resolution = 1 config.lock_expire = 1000 config.utc = false config.handler_pool_size = nil end end sidetiq-0.6.3/lib/sidetiq/lock/0000755000175000017500000000000012434123324017606 5ustar balasankarcbalasankarcsidetiq-0.6.3/lib/sidetiq/lock/meta_data.rb0000644000175000017500000000241512434123324022054 0ustar balasankarcbalasankarcmodule Sidetiq module Lock class MetaData OWNER = "#{Socket.gethostname}:#{Process.pid}" attr_accessor :owner, :timestamp, :key class << self include Sidekiq::ExceptionHandler def for_new_lock(key) new(owner: OWNER, timestamp: Sidetiq.clock.gettime.to_f, key: key) end def from_json(json = "") # Avoid TypeError when nil is passed to Sidekiq.load_json. json = "" if json.nil? hash = Sidekiq.load_json(json).symbolize_keys new(hash) rescue StandardError => e if json != "" # Looks like garbage lock metadata, so report it. handle_exception(e, context: "Garbage lock meta data detected: #{json}") end new end end def initialize(hash = {}) @owner = hash[:owner] @timestamp = hash[:timestamp] @key = hash[:key] end def pttl Sidekiq.redis { |r| r.pttl(key) } end def to_json instance_variables.each_with_object({}) do |var, hash| hash[var.to_s.delete("@")] = instance_variable_get(var) end.to_json end def to_s "Sidetiq::Lock on #{key} set at #{timestamp} by #{owner}" end end end end sidetiq-0.6.3/lib/sidetiq/lock/redis.rb0000644000175000017500000000461112434123324021243 0ustar balasankarcbalasankarcmodule Sidetiq module Lock class Redis include Logging attr_reader :key, :timeout def self.all Sidekiq.redis do |redis| redis.keys("sidetiq:*:lock").map do |key| new(key) end end end def initialize(key, timeout = Sidetiq.config.lock_expire) @key = extract_key(key) @timeout = timeout end def synchronize Sidekiq.redis do |redis| acquired = lock if acquired debug "Lock: #{key}" begin yield redis ensure unlock debug "Unlock: #{key}" end end end end def stale? pttl = meta_data.pttl # Consider PTTL of -1 (never set) and larger than the # configured lock_expire as invalid. Locks with timestamps # older than 1 minute are also considered stale. pttl < 0 || pttl >= Sidetiq.config.lock_expire || meta_data.timestamp < (Sidetiq.clock.gettime.to_i - 60) end def meta_data @meta_data ||= Sidekiq.redis do |redis| MetaData.from_json(redis.get(key)) end end def lock Sidekiq.redis do |redis| acquired = false watch(redis, key) do if !redis.exists(key) acquired = !!redis.multi do |multi| meta = MetaData.for_new_lock(key) multi.psetex(key, timeout, meta.to_json) end end end acquired end end def unlock Sidekiq.redis do |redis| watch(redis, key) do if meta_data.owner == Sidetiq::Lock::MetaData::OWNER redis.multi do |multi| multi.del(key) end true else false end end end end def unlock! Sidekiq.redis do |redis| redis.del(key) end end private def extract_key(key) case key when Class "sidetiq:#{key.name}:lock" when String key.match(/sidetiq:(.+):lock/) ? key : "sidetiq:#{key}:lock" end end def watch(redis, *args) redis.watch(*args) begin yield ensure redis.unwatch end end end end end sidetiq-0.6.3/lib/sidetiq/schedulable.rb0000644000175000017500000000420412434123324021456 0ustar balasankarcbalasankarcmodule Sidetiq # Public: Mixin for Sidekiq::Worker classes. # # Examples # # class MyWorker # include Sidekiq::Worker # include Sidetiq::Schedulable # # # Daily at midnight # recurrence { daily } # end module Schedulable extend SubclassTracking module ClassMethods include SubclassTracking attr_writer :schedule # Public: Returns a Float timestamp of the last scheduled run. def last_scheduled_occurrence get_timestamp "last" end # Public: Returns the Sidetiq::Schedule for this worker. def schedule @schedule ||= Sidetiq::Schedule.new end # Public: Returns a Float timestamp of the next scheduled run. def next_scheduled_occurrence get_timestamp "next" end def schedule_description get_schedulable_key("schedule_description") end def recurrence(options = {}, &block) # :nodoc: schedule.instance_eval(&block) schedule.set_options(options) # deleting schedulable keys if schedule changed since last reccurence definition if Sidekiq.server? old_description = get_schedulable_key("schedule_description") if old_description != schedule.to_s get_schedulable_keys.map do |key| Sidekiq.redis_pool.with { |r| r.del(key) } end set_schedulable_key("schedule_description", schedule.to_s) end end end private def get_schedulable_keys %w(next last schedule_description history).map { |key| "sidetiq:#{name}:#{key}" } end def get_schedulable_key(key) Sidekiq.redis_pool.with { |r| r.get("sidetiq:#{name}:#{key}") } end def set_schedulable_key(key, value) Sidekiq.redis_pool.with { |r| r.set("sidetiq:#{name}:#{key}", value) } end def get_timestamp(key) (get_schedulable_key(key) || -1).to_f end end def self.included(klass) # :nodoc: super klass.extend(Sidetiq::Schedulable::ClassMethods) klass.extend(Sidetiq::SubclassTracking) subclasses << klass end end end sidetiq-0.6.3/lib/sidetiq/logging.rb0000644000175000017500000000042212434123324020627 0ustar balasankarcbalasankarcmodule Sidetiq # Public: Sidetiq logging interface. module Logging %w(fatal error warn info debug).each do |level| level = level.to_sym define_method(level) do |msg| Sidetiq.logger.__send__(level, "[Sidetiq] #{msg}") end end end end sidetiq-0.6.3/lib/sidetiq/actor.rb0000644000175000017500000000165212434123324020317 0ustar balasankarcbalasankarcmodule Sidetiq module Actor def self.included(base) base.__send__(:include, Celluloid) base.finalizer :sidetiq_finalizer end def initialize(*args, &block) log_call "initialize" super # Link to Sidekiq::Manager when running in server-mode. In most # cases the supervisor is booted before Sidekiq has launched # fully, so defer this. if Sidekiq.server? after(0.1) { link_to_sidekiq_manager } end end private def sidetiq_finalizer log_call "shutting down ..." end def link_to_sidekiq_manager Sidekiq::CLI.instance.launcher.manager.link(current_actor) rescue NoMethodError debug "Can't link #{self.class.name}. Sidekiq::Manager not running. Retrying in 5 seconds ..." after(5) { link_to_sidekiq_manager } end def log_call(call) info "#{self.class.name} id: #{object_id} #{call}" end end end sidetiq-0.6.3/lib/sidetiq/clock.rb0000644000175000017500000000253012434123324020276 0ustar balasankarcbalasankarcmodule Sidetiq # Public: The Sidetiq clock. class Clock include Logging def self.start! warn "Sidetiq::Clock#start! is deprecated. Calling it is no longer required." end def start! warn "Sidetiq::Clock#start! is deprecated. Calling it is no longer required." end # Internal: Returns a hash of Sidetiq::Schedule instances. attr_reader :schedules def initialize # :nodoc: super end # Public: Get the schedule for `worker`. # # worker - A Sidekiq::Worker class # # Examples # # schedule_for(MyWorker) # # => Sidetiq::Schedule # # Returns a Sidetiq::Schedule instances. def schedule_for(worker) if worker.respond_to?(:schedule) worker.schedule end end # Public: Issue a single clock tick. # # Examples # # tick # # => Hash of Sidetiq::Schedule objects # # Returns a hash of Sidetiq::Schedule instances. def tick(tick = gettime) Sidetiq.workers.each do |worker| Sidetiq.handler.dispatch(worker, tick) end end # Public: Returns the current time used by the clock. # # Examples # # gettime # # => 2013-02-04 12:00:45 +0000 # # Returns a Time instance. def gettime Sidetiq.config.utc ? Time.now.utc : Time.now end end end sidetiq-0.6.3/lib/sidetiq/api.rb0000644000175000017500000000617312434123324017763 0ustar balasankarcbalasankarcmodule Sidetiq # Public: Sidetiq API methods. module API # Public: Returns an Array of workers including # Sidetiq::Schedulable. Excludes classes which don't define # a #perform method. def workers Sidetiq::Schedulable.subclasses(true).select do |klass| klass.method_defined?(:perform) end end # Public: Returns a Hash of Sidetiq::Schedule instances. def schedules workers.map(&:schedule) 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 # # => [#, ...] # # Sidetiq.scheduled(MyWorker) # # => [#, ...] # # Sidetiq.scheduled("MyWorker") # # => [#, ...] # # Sidetiq.scheduled do |job| # # do stuff ... # end # # => [#, ...] # # Sidetiq.scheduled(MyWorker) do |job| # # do stuff ... # end # # => [#, ...] # # Sidetiq.scheduled("MyWorker") do |job| # # do stuff ... # end # # => [#, ...] # # 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 # # => [#, ...] # # Sidetiq.retries(MyWorker) # # => [#, ...] # # Sidetiq.retries("MyWorker") # # => [#, ...] # # Sidetiq.retries do |job| # # do stuff ... # end # # => [#, ...] # # Sidetiq.retries(MyWorker) do |job| # # do stuff ... # end # # => [#, ...] # # Sidetiq.retries("MyWorker") do |job| # # do stuff ... # end # # => [#, ...] # # 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 jobs.each(&block) if block_given? jobs end end end sidetiq-0.6.3/lib/sidetiq/supervisor.rb0000644000175000017500000000237312434123324021431 0ustar balasankarcbalasankarcmodule Sidetiq class Supervisor < Celluloid::SupervisionGroup supervise Sidetiq::Actor::Clock, as: :sidetiq_clock if Sidekiq.server? if handler_pool_size = Sidetiq.config.handler_pool_size pool Sidetiq::Actor::Handler, as: :sidetiq_handler, size: handler_pool_size else # Use Celluloid's CPU-based default. pool Sidetiq::Actor::Handler, as: :sidetiq_handler end end class << self include Logging def clock run! if Celluloid::Actor[:sidetiq_clock].nil? Celluloid::Actor[:sidetiq_clock] end def handler run! if Celluloid::Actor[:sidetiq_handler].nil? Celluloid::Actor[:sidetiq_handler] end def run! motd info "Sidetiq::Supervisor start" super end def run raise "Sidetiq::Supervisor should not be run in foreground." end private def motd info "Sidetiq v#{VERSION::STRING} - Copyright (c) 2012-2013, Tobias Svensson " info "Sidetiq is covered by the 3-clause BSD license." info "See LICENSE and http://opensource.org/licenses/BSD-3-Clause for licensing details." end end end end sidetiq-0.6.3/lib/sidetiq/schedule.rb0000644000175000017500000000344712434123324021007 0ustar balasankarcbalasankarcmodule Sidetiq # Public: Recurrence schedule. class Schedule # :nodoc: attr_reader :last_occurrence # Public: Writer for backfilling option. attr_writer :backfill # Public: Start time offset from epoch used for calculating run # times in the Sidetiq schedules. def self.start_time Sidetiq.config.utc ? Time.utc(2010, 1, 1) : Time.local(2010, 1, 1) end def initialize # :nodoc: @schedule = IceCube::Schedule.new(self.class.start_time) end def method_missing(meth, *args, &block) # :nodoc: if IceCube::Rule.respond_to?(meth) rule = IceCube::Rule.send(meth, *args, &block) @schedule.add_recurrence_rule(rule) rule elsif @schedule.respond_to?(meth) @schedule.send(meth, *args, &block) else super end end # Public: Checks if a job is due to be scheduled. # # Returns true if a job is due, otherwise false. def schedule_next?(time) next_occurrence = @schedule.next_occurrence(time) if @last_scheduled != next_occurrence.to_i @last_scheduled = next_occurrence.to_i return true end false end # Public: Schedule to String. # # Examples # # class MyWorker # include Sidekiq::Worker # include Sidetiq::Schedulable # # recurrence { daily } # # def perform # end # end # # Sidetiq.schedules[MyWorker].to_s # # => "Daily" # # Returns a String representing the schedule. def to_s @schedule.to_s end # Public: Inquirer for backfilling option. def backfill? !!@backfill end # Internal: Set schedule options. def set_options(hash) self.backfill = hash[:backfill] if !hash[:backfill].nil? end end end sidetiq-0.6.3/lib/sidetiq/views/0000755000175000017500000000000012434123324020013 5ustar balasankarcbalasankarcsidetiq-0.6.3/lib/sidetiq/views/_home_nav.erb0000644000175000017500000000065312434123324022444 0ustar balasankarcbalasankarc
Home Locks
sidetiq-0.6.3/lib/sidetiq/views/history.erb0000644000175000017500000000271112434123324022207 0ustar balasankarcbalasankarc

Recurring Job: <%= @worker.name %>

<%= erb File.read(File.join(view_path, '_worker_nav.erb')) %>
<% @history.each do |entry| %> <% entry = Sidekiq.load_json(entry).symbolize_keys %> <% end %>
Status Timestamp Details
<%= entry[:status].capitalize %> <%= Time.parse(entry[:timestamp]).strftime("%m/%d/%Y %I:%M:%S%p") %> <% if entry[:status] == 'failure' %> <%= entry[:exception] %>: <%= entry[:error] %> 
                <%= entry[:backtrace].join("
") %>
<% end %>

Node: <%= entry[:node] %>


sidetiq-0.6.3/lib/sidetiq/views/_worker_nav.erb0000644000175000017500000000130712434123324023022 0ustar balasankarcbalasankarc
Home " class="list-group-item<%= current_path == "sidetiq/#{@worker.name}/schedule" ? ' active' : nil %>"> Job Schedule " class="list-group-item<%= current_path == "sidetiq/#{@worker.name}/history" ? ' active' : nil %>"> Job History
sidetiq-0.6.3/lib/sidetiq/views/locks.erb0000644000175000017500000000310412434123324021616 0ustar balasankarcbalasankarc

Active Locks

<%= erb File.read(File.join(view_path, '_home_nav.erb')) %>
<% if @locks_available %> <% if @locks.length > 0 %> <% @locks.each do |meta| %> <% pttl = meta.pttl %> <% end %>
Key Owner Node Timetamp TTL Actions
<%= meta.key %> <%= meta.owner %> <%= meta.timestamp.to_i %> <%= pttl / 1000 %> s
" method="post">
<% else %>
No locks set.
<% end %> <% else %>
KEYS command is disabled in your redis instance, lock information is not available.
<% end %>
sidetiq-0.6.3/lib/sidetiq/views/schedule.erb0000644000175000017500000000306612434123324022306 0ustar balasankarcbalasankarc

Recurring Job: <%= @worker.name %>

<%= erb File.read(File.join(view_path, '_worker_nav.erb')) %>
<% if (recurrences = @schedule.recurrence_rules).length > 0 %> <% recurrences.each do |rule| %> <% end %>
Recurrences
<%= rule.to_s %>
<% end %>
<% if (exceptions = @schedule.exception_rules).length > 0 %> <% exceptions.each do |rule| %> <% end %>
Exceptions
<%= rule.to_s %>
<% end %>
<% end %>
Next 10 runs <% @schedule.next_occurrences(10, @time).each do |time| %>
<%= relative_time(time) %>

sidetiq-0.6.3/lib/sidetiq/views/assets/0000755000175000017500000000000012434123324021315 5ustar balasankarcbalasankarcsidetiq-0.6.3/lib/sidetiq/views/assets/styles.css0000644000175000017500000000042212434123324023350 0ustar balasankarcbalasankarc .table-sidetiq { width: 100%; margin: 0; table-layout: fixed; } .backtrace { display: none; overflow: auto; width: 100%; background: white; } .backtrace pre { display: inline-block; font-size: 0.8em; border: none; white-space: nowrap; margin: 0; }sidetiq-0.6.3/lib/sidetiq/views/sidetiq.erb0000644000175000017500000000321712434123324022152 0ustar balasankarcbalasankarc

Recurring Jobs

<%= erb File.read(File.join(view_path, '_home_nav.erb')) %>
<% if @workers.length > 0 %> <% @workers.each do |worker| %> <% schedule = worker.schedule %> <% end %>
Worker Queue Next Run Actions
"><%= worker.name %> <%= worker.get_sidekiq_options["queue"] %> <% @next = schedule.next_occurrence(@time) %> <% if @next.nil? %> No schedule <% else %> <%= relative_time(schedule.next_occurrence(@time)) %> <% end %>
" method="post">
<% else %>
No recurring jobs found.
<% end %>
sidetiq-0.6.3/lib/sidetiq/subclass_tracking.rb0000644000175000017500000000055312434123324022707 0ustar balasankarcbalasankarcmodule Sidetiq module SubclassTracking def subclasses(deep = false) @subclasses ||= [] if deep @subclasses.inject([]) do |all, subclass| (all << subclass) + subclass.subclasses(true) end else @subclasses end end def inherited(klass) super subclasses << klass end end end sidetiq-0.6.3/lib/sidetiq/middleware/0000755000175000017500000000000012434123324020773 5ustar balasankarcbalasankarcsidetiq-0.6.3/lib/sidetiq/middleware/history.rb0000644000175000017500000000253112434123324023022 0ustar balasankarcbalasankarcmodule Sidetiq module Middleware class History def call(worker, msg, queue, &block) if worker.kind_of?(Sidetiq::Schedulable) call_with_sidetiq_history(worker, msg, queue, &block) else yield end end private def call_with_sidetiq_history(worker, msg, queue) entry = new_history_entry yield rescue StandardError => e entry[:status] = :failure entry[:exception] = e.class.to_s entry[:error] = e.message entry[:backtrace] = e.backtrace raise e ensure save_entry_for_worker(entry, worker) end def new_history_entry { status: :success, error: "", exception: "", backtrace: "", node: "#{Socket.gethostname}:#{Process.pid}-#{Thread.current.object_id}", timestamp: Time.now.iso8601 } end def save_entry_for_worker(entry, worker) Sidekiq.redis do |redis| list_name = "sidetiq:#{worker.class.name}:history" redis.lpush(list_name, Sidekiq.dump_json(entry)) redis.ltrim(list_name, 0, Sidetiq.config.worker_history - 1) end end end end end Sidekiq.configure_server do |config| config.server_middleware do |chain| chain.add Sidetiq::Middleware::History end end sidetiq-0.6.3/lib/sidetiq/actor/0000755000175000017500000000000012434123324017766 5ustar balasankarcbalasankarcsidetiq-0.6.3/lib/sidetiq/actor/clock.rb0000644000175000017500000000127412434123324021412 0ustar balasankarcbalasankarcmodule Sidetiq module Actor class Clock < Sidetiq::Clock include Sidetiq::Actor include Sidekiq::ExceptionHandler def initialize(*args, &block) super if Sidekiq.server? after(0) do debug "Sidetiq::Clock looping ..." loop! end end end private def loop! after([time { tick }, 0].max) do loop! end rescue StandardError => e handle_exception(e, context: 'Sidetiq::Clock#loop!') raise e end def time start = gettime yield Sidetiq.config.resolution - (gettime.to_f - start.to_f) end end end end sidetiq-0.6.3/lib/sidetiq/actor/handler.rb0000644000175000017500000000016212434123324021727 0ustar balasankarcbalasankarcmodule Sidetiq module Actor class Handler < Sidetiq::Handler include Sidetiq::Actor end end end sidetiq-0.6.3/lib/sidetiq/web.rb0000644000175000017500000000474612434123324017773 0ustar balasankarcbalasankarcrequire 'sidetiq' require 'sidekiq/web' module Sidetiq module Web VIEWS = File.expand_path('views', File.dirname(__FILE__)) def self.registered(app) app.get "/sidetiq" do @workers = Sidetiq.workers.sort_by { |worker| worker.name } @time = Sidetiq.clock.gettime erb File.read(File.join(VIEWS, 'sidetiq.erb')), locals: {view_path: VIEWS} end app.get "/sidetiq/locks" do begin @locks = Sidetiq::Lock::Redis.all.map(&:meta_data) @locks_available = true rescue Redis::CommandError @locks_available = false end erb File.read(File.join(VIEWS, 'locks.erb')), locals: {view_path: VIEWS} end app.get "/sidetiq/:name/schedule" do halt 404 unless (name = params[:name]) @time = Sidetiq.clock.gettime @worker = Sidetiq.workers.detect do |worker| worker.name == name end @schedule = @worker.schedule erb File.read(File.join(VIEWS, 'schedule.erb')), locals: {view_path: VIEWS} end app.get "/sidetiq/:name/history" do halt 404 unless (name = params[:name]) @time = Sidetiq.clock.gettime @worker = Sidetiq.workers.detect do |worker| worker.name == name end @history = Sidekiq.redis do |redis| redis.lrange("sidetiq:#{name}:history", 0, -1) end erb File.read(File.join(VIEWS, 'history.erb')), locals: {view_path: VIEWS} end app.post "/sidetiq/:name/trigger" do halt 404 unless (name = params[:name]) worker = Sidetiq.workers.detect do |worker| worker.name == name end case worker.instance_method(:perform).arity.abs when 0 worker.perform_async when 1 Sidekiq.redis do |redis| last_run = (redis.get("sidetiq:#{worker.name}:last") || -1).to_f worker.perform_async(last_run) end else Sidekiq.redis do |redis| last_run = (redis.get("sidetiq:#{worker.name}:last") || -1).to_f worker.perform_async(last_run, Sidetiq.clock.gettime.to_i) end end 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 Sidekiq::Web.register(Sidetiq::Web) Sidekiq::Web.tabs["Sidetiq"] = "sidetiq" sidetiq-0.6.3/lib/sidetiq/handler.rb0000644000175000017500000000273512434123324020627 0ustar balasankarcbalasankarcrequire 'sidekiq/exception_handler' module Sidetiq class Handler include Logging include Sidekiq::ExceptionHandler def dispatch(worker, tick) schedule = worker.schedule return unless schedule.schedule_next?(tick) Lock::Redis.new(worker).synchronize do |redis| if schedule.backfill? && (last = worker.last_scheduled_occurrence) > 0 last = Sidetiq.config.utc ? Time.at(last).utc : Time.at(last) schedule.occurrences_between(last + 1, tick).each do |past_t| enqueue(worker, past_t, redis) end end enqueue(worker, schedule.next_occurrence(tick), redis) end rescue StandardError => e handle_exception(e, context: "Sidetiq::Handler#dispatch") raise e end private def enqueue(worker, time, redis) key = "sidetiq:#{worker.name}" time_f = time.to_f next_run = (redis.get("#{key}:next") || -1).to_f if next_run < time_f info "Enqueue: #{worker.name} (at: #{time_f}) (last: #{next_run})" redis.mset("#{key}:last", next_run, "#{key}:next", time_f) case worker.instance_method(:perform).arity.abs when 0 worker.perform_at(time) when 1 worker.perform_at(time, next_run) else worker.perform_at(time, next_run, time_f) end end rescue StandardError => e handle_exception(e, context: "Sidetiq::Handler#enqueue") raise e end end end sidetiq-0.6.3/LICENSE0000644000175000017500000000277012434123324015461 0ustar balasankarcbalasankarcCopyright (c) 2012-2013, Tobias Svensson All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Tobias Svensson nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL TOBIAS SVENSSON BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. sidetiq-0.6.3/examples/0000755000175000017500000000000012434123324016264 5ustar balasankarcbalasankarcsidetiq-0.6.3/examples/Procfile0000644000175000017500000000010312434123324017744 0ustar balasankarcbalasankarcsidekiq: bundle exec sidekiq -r ./server.rb web: bundle exec rackupsidetiq-0.6.3/examples/config.ru0000644000175000017500000000035312434123324020102 0ustar balasankarcbalasankarcrequire 'sidekiq' require 'sidetiq' require 'sidekiq/web' require 'sidetiq/web' require './workers/simple.rb' require './workers/failing.rb' Sidekiq.configure_client do |config| config.redis = { :size => 1 } end run Sidekiq::Web sidetiq-0.6.3/examples/workers/0000755000175000017500000000000012434123324017760 5ustar balasankarcbalasankarcsidetiq-0.6.3/examples/workers/simple.rb0000644000175000017500000000020212434123324021570 0ustar balasankarcbalasankarcclass Simple include Sidekiq::Worker include Sidetiq::Schedulable recurrence { secondly } def perform(*args) end end sidetiq-0.6.3/examples/workers/failing.rb0000644000175000017500000000030212434123324021711 0ustar balasankarcbalasankarcclass Failing include Sidekiq::Worker include Sidetiq::Schedulable recurrence { secondly } def perform(*args) if rand(5) == 0 raise "This didn't go well." end end end sidetiq-0.6.3/examples/server.rb0000644000175000017500000000034212434123324020116 0ustar balasankarcbalasankarc# Run with `sidekiq -r /path/to/simple.rb` require 'sidekiq' require 'sidetiq' require_relative 'workers/simple' require_relative 'workers/failing' Sidekiq.logger.level = Logger::DEBUG Sidekiq.options[:poll_interval] = 1 sidetiq-0.6.3/.travis.yml0000644000175000017500000000134112434123324016556 0ustar balasankarcbalasankarclanguage: ruby script: rake test branches: only: - master services: - redis-server rvm: - 2.0.0 - 2.1.1 - jruby-19mode - rbx-19mode - ruby-head - jruby-head jdk: - openjdk6 - openjdk7 - oraclejdk7 matrix: exclude: - rvm: 2.1.1 jdk: openjdk7 - rvm: 2.1.1 jdk: openjdk6 - rvm: 2.0.0 jdk: openjdk7 - rvm: 2.0.0 jdk: openjdk6 - rvm: 1.9.3 jdk: openjdk7 - rvm: 1.9.3 jdk: openjdk6 - rvm: rbx-19mode jdk: openjdk7 - rvm: rbx-19mode jdk: openjdk6 - rvm: ruby-head jdk: openjdk7 - rvm: ruby-head jdk: openjdk6 allow_failures: - rvm: rbx-19mode - rvm: ruby-head - rvm: jruby-head - rvm: jruby-19mode sidetiq-0.6.3/test/0000755000175000017500000000000012434123324015425 5ustar balasankarcbalasankarcsidetiq-0.6.3/test/test_lock_meta_data.rb0000644000175000017500000000402012434123324021734 0ustar balasankarcbalasankarcrequire_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, Sidekiq.load_json(md.to_json).symbolize_keys 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 sidetiq-0.6.3/test/test_web.rb0000644000175000017500000000372112434123324017571 0ustar balasankarcbalasankarcrequire_relative 'helper' class TestWeb < Sidetiq::TestCase include Rack::Test::Methods def app Sidekiq::Web end def host last_request.host end def setup super ScheduledWorker.jobs.clear Sidetiq.stubs(:workers).returns([ScheduledWorker]) end def test_home_tab get '/' assert_equal 200, last_response.status assert_match /Sidekiq/, last_response.body assert_match /Sidetiq/, last_response.body end def test_sidetiq_page get '/sidetiq' assert_equal 200, last_response.status Sidetiq.workers.each do |worker| assert_match /#{worker.name}/, last_response.body assert_match /#{worker.get_sidekiq_options['queue']}/, last_response.body end end 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 = ScheduledWorker.schedule schedule.recurrence_rules.each do |rule| assert_match /#{rule.to_s}/, last_response.body end schedule.exception_rules.each do |rule| assert_match /#{rule.to_s}/, last_response.body end schedule.next_occurrences(10).each do |time| assert_match /#{time.getutc.to_s}/, last_response.body end end def test_trigger post "/sidetiq/ScheduledWorker/trigger" assert_equal 302, last_response.status 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 sidetiq-0.6.3/test/fixtures/0000755000175000017500000000000012434123324017276 5ustar balasankarcbalasankarcsidetiq-0.6.3/test/fixtures/scheduled_worker.rb0000644000175000017500000000041112434123324023150 0ustar balasankarcbalasankarcclass ScheduledWorker include Sidekiq::Worker include Sidetiq::Schedulable recurrence do daily.hour_of_day(1) yearly.month_of_year(2) monthly.day_of_month(3) add_exception_rule yearly.month_of_year(:february) end def perform end end sidetiq-0.6.3/test/fixtures/last_and_scheduled_ticks_worker.rb0000644000175000017500000000025112434123324026214 0ustar balasankarcbalasankarcclass LastAndScheduledTicksWorker include Sidekiq::Worker include Sidetiq::Schedulable recurrence { hourly } def perform(last_tick, scheduled_tick) end end sidetiq-0.6.3/test/fixtures/optional_arguments_worker.rb0000644000175000017500000000023212434123324025123 0ustar balasankarcbalasankarcclass OptionalArgumentWorker include Sidekiq::Worker include Sidetiq::Schedulable recurrence { hourly } def perform(last_tick = nil) end end sidetiq-0.6.3/test/fixtures/simple_worker.rb0000644000175000017500000000017612434123324022511 0ustar balasankarcbalasankarcclass SimpleWorker include Sidekiq::Worker include Sidetiq::Schedulable recurrence { daily } def perform end end sidetiq-0.6.3/test/fixtures/splat_args_worker.rb0000644000175000017500000000021712434123324023353 0ustar balasankarcbalasankarcclass SplatArgsWorker include Sidekiq::Worker include Sidetiq::Schedulable recurrence { hourly } def perform(arg1, *args) end end sidetiq-0.6.3/test/fixtures/backfill_worker.rb0000644000175000017500000000022712434123324022764 0ustar balasankarcbalasankarcclass BackfillWorker include Sidekiq::Worker include Sidetiq::Schedulable recurrence backfill: true do daily end def perform end end sidetiq-0.6.3/test/fixtures/last_tick_worker.rb0000644000175000017500000000021412434123324023166 0ustar balasankarcbalasankarcclass LastTickWorker include Sidekiq::Worker include Sidetiq::Schedulable recurrence { hourly } def perform(last_tick) end end sidetiq-0.6.3/test/test_worker.rb0000644000175000017500000000136712434123324020331 0ustar balasankarcbalasankarcrequire_relative 'helper' class TestWorker < Sidetiq::TestCase class FakeWorker include Sidetiq::Schedulable end def test_timestamps_for_new_worker assert FakeWorker.last_scheduled_occurrence == -1 assert FakeWorker.next_scheduled_occurrence == -1 end def test_timestamps_for_existing_worker last_run = (Time.now - 100).to_f next_run = (Time.now + 100).to_f Sidekiq.redis do |redis| redis.set "sidetiq:TestWorker::FakeWorker:last", last_run redis.set "sidetiq:TestWorker::FakeWorker:next", next_run end assert FakeWorker.last_scheduled_occurrence == last_run assert FakeWorker.next_scheduled_occurrence == next_run end def test_options assert BackfillWorker.schedule.backfill? end end sidetiq-0.6.3/test/test_lock_redis.rb0000644000175000017500000000243112434123324021127 0ustar balasankarcbalasankarcrequire_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 sidetiq-0.6.3/test/helper.rb0000644000175000017500000000313112434123324017227 0ustar balasankarcbalasankarcif RUBY_PLATFORM != "java" require 'coveralls' Coveralls.wear! end require 'sidekiq' require 'sidekiq/testing' require 'minitest' require 'mocha/setup' require 'rack/test' require 'sidetiq' require 'sidetiq/web' module Sidekiq def self.server? true end end 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) Dir[File.join(File.dirname(__FILE__), 'fixtures/**/*.rb')].each do |fixture| require fixture end class Sidekiq::Client # Sidekiq testing helper now overwrites raw_push so we need to use # raw_push_old below to keep tests as is. # https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/testing.rb def push_old(item) normed = normalize_item(item) payload = process_single(item['class'], normed) pushed = false pushed = self.__send__(:raw_push_real, [payload]) if payload pushed ? payload['jid'] : nil end end class Sidetiq::TestCase < MiniTest::Test def setup Sidekiq.redis { |r| r.flushall } end def clock Sidetiq.clock end # Blatantly stolen from Sidekiq's test suite. def add_retry(worker = 'SimpleWorker', jid = 'bob', at = Time.now.to_f) payload = Sidekiq.dump_json('class' => worker, 'args' => [], '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 # Override Celluloid's at_exit hook manually. at_exit { exit Minitest.run(ARGV) || false } sidetiq-0.6.3/test/test_schedulable.rb0000644000175000017500000000326012434123324021265 0ustar balasankarcbalasankarcrequire_relative 'helper' require 'minitest/mock' class TestShedulable < Sidetiq::TestCase class FakeWorker include Sidetiq::Schedulable end def test_recurrence Sidekiq.stub(:server?, true) do Sidekiq.expects(:redis_pool).returns(Sidekiq::RedisConnection.create).at_least(1) FakeWorker.recurrence { hourly } end Sidekiq.stub(:server?, false) do Sidekiq.expects(:redis_pool).times(0) FakeWorker.recurrence { hourly } end end def test_resheduling last_run = (Time.now - 100).to_f next_run = (Time.now + 100).to_f Sidekiq.redis do |redis| redis.set "sidetiq:TestShedulable::FakeWorker:last", last_run redis.set "sidetiq:TestShedulable::FakeWorker:next", next_run end assert FakeWorker.schedule_description == nil FakeWorker.schedule = nil FakeWorker.recurrence { minutely } assert FakeWorker.schedule_description == "Minutely" assert FakeWorker.last_scheduled_occurrence == -1.0 assert FakeWorker.next_scheduled_occurrence == -1.0 Sidekiq.redis do |redis| redis.set "sidetiq:TestShedulable::FakeWorker:last", last_run redis.set "sidetiq:TestShedulable::FakeWorker:next", next_run end FakeWorker.schedule = nil FakeWorker.recurrence { minutely } assert FakeWorker.schedule_description == "Minutely" assert FakeWorker.last_scheduled_occurrence == last_run assert FakeWorker.next_scheduled_occurrence == next_run FakeWorker.schedule = nil FakeWorker.recurrence { hourly } assert FakeWorker.schedule_description == "Hourly" assert FakeWorker.last_scheduled_occurrence == -1.0 assert FakeWorker.next_scheduled_occurrence == -1.0 end end sidetiq-0.6.3/test/test_version.rb0000644000175000017500000000110612434123324020474 0ustar balasankarcbalasankarcrequire_relative 'helper' class TestVersion < Sidetiq::TestCase def test_major assert_instance_of Fixnum, Sidetiq::VERSION::MAJOR end def test_minor assert_instance_of Fixnum, Sidetiq::VERSION::MINOR end def test_patch assert_instance_of Fixnum, Sidetiq::VERSION::PATCH end def test_string assert_equal Sidetiq::VERSION::STRING, [Sidetiq::VERSION::MAJOR, Sidetiq::VERSION::MINOR, Sidetiq::VERSION::PATCH, Sidetiq::VERSION::SUFFIX].compact.join('.') end end sidetiq-0.6.3/test/test_sidetiq.rb0000644000175000017500000000667112434123324020465 0ustar balasankarcbalasankarcrequire_relative 'helper' class TestSidetiq < Sidetiq::TestCase def test_schedules schedules = Sidetiq.schedules assert_includes schedules, ScheduledWorker.schedule assert_includes schedules, BackfillWorker.schedule assert_kind_of Sidetiq::Schedule, ScheduledWorker.schedule assert_kind_of Sidetiq::Schedule, BackfillWorker.schedule end def test_workers workers = Sidetiq.workers assert_includes workers, ScheduledWorker assert_includes workers, BackfillWorker end def test_scheduled client = Sidekiq::Client.new SimpleWorker.perform_at(Time.local(2011, 1, 1, 1)) hash = SimpleWorker.jobs.first client.push_old(hash.merge("at" => hash["enqueued_at"])) scheduled = Sidetiq.scheduled assert_kind_of Array, scheduled assert_kind_of Sidekiq::SortedEntry, scheduled.first assert_equal 1, scheduled.length end def test_scheduled_on_empty_set assert_equal 0, Sidetiq.scheduled.length end def test_scheduled_given_arguments client = Sidekiq::Client.new SimpleWorker.perform_at(Time.local(2011, 1, 1, 1)) hash = SimpleWorker.jobs.first client.push_old(hash.merge("at" => hash["enqueued_at"])) assert_equal 1, Sidetiq.scheduled(SimpleWorker).length assert_equal 0, Sidetiq.scheduled(ScheduledWorker).length assert_equal 1, Sidetiq.scheduled("SimpleWorker").length assert_equal 0, Sidetiq.scheduled("ScheduledWorker").length end def test_scheduled_yields_each_job client = Sidekiq::Client.new SimpleWorker.perform_at(Time.local(2011, 1, 1, 1)) hash = SimpleWorker.jobs.first client.push_old(hash.merge("at" => hash["enqueued_at"])) ScheduledWorker.perform_at(Time.local(2011, 1, 1, 1)) hash = ScheduledWorker.jobs.first client.push_old(hash.merge("at" => hash["enqueued_at"])) jobs = [] Sidetiq.scheduled { |job| jobs << job } assert_equal 2, jobs.length jobs = [] Sidetiq.scheduled(SimpleWorker) { |job| jobs << job } assert_equal 1, jobs.length jobs = [] Sidetiq.scheduled("ScheduledWorker") { |job| jobs << job } assert_equal 1, jobs.length end def test_scheduled_with_invalid_class assert_raises(NameError) do Sidetiq.scheduled("Foobar") end end def test_retries add_retry('SimpleWorker', 'foo') add_retry('ScheduledWorker', 'bar') retries = Sidetiq.retries assert_kind_of Array, retries assert_kind_of Sidekiq::SortedEntry, retries[0] assert_kind_of Sidekiq::SortedEntry, retries[1] assert_equal 2, retries.length end def test_retries_on_empty_set assert_equal 0, Sidetiq.retries.length end def test_retries_given_arguments add_retry('SimpleWorker', 'foo') assert_equal 1, Sidetiq.retries(SimpleWorker).length assert_equal 0, Sidetiq.retries(ScheduledWorker).length assert_equal 1, Sidetiq.retries("SimpleWorker").length assert_equal 0, Sidetiq.retries("ScheduledWorker").length end def test_retries_yields_each_job add_retry('SimpleWorker', 'foo') add_retry('ScheduledWorker', 'foo') jobs = [] Sidetiq.retries { |job| jobs << job } assert_equal 2, jobs.length jobs = [] Sidetiq.retries(SimpleWorker) { |job| jobs << job } assert_equal 1, jobs.length jobs = [] Sidetiq.retries("ScheduledWorker") { |job| jobs << job } assert_equal 1, jobs.length end def test_retries_with_invalid_class assert_raises(NameError) do Sidetiq.retries("Foobar") end end end sidetiq-0.6.3/test/test_history.rb0000644000175000017500000000242712434123324020517 0ustar balasankarcbalasankarcrequire_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 = Sidekiq.load_json(entry[0]).symbolize_keys 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 = Sidekiq.load_json(entry[0]).symbolize_keys 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 sidetiq-0.6.3/test/test_config.rb0000644000175000017500000000052012434123324020253 0ustar balasankarcbalasankarcrequire_relative 'helper' class TestConfig < Sidetiq::TestCase def setup @saved = Sidetiq.config Sidetiq.config = OpenStruct.new end def teardown Sidetiq.config = @saved end def test_configure Sidetiq.configure do |config| config.test = 42 end assert_equal 42, Sidetiq.config.test end end sidetiq-0.6.3/test/test_subclass_tracking.rb0000644000175000017500000000057612434123324022522 0ustar balasankarcbalasankarcrequire_relative 'helper' class TestSubclassTracking < Sidetiq::TestCase class Base end class Foo < Base extend Sidetiq::SubclassTracking end class Bar < Foo end class Baz < Bar end def test_subclasses_non_recursive assert_equal [Bar], Foo.subclasses end def test_subclasses_recursive assert_equal [Bar, Baz], Foo.subclasses(true) end end sidetiq-0.6.3/test/test_clock.rb0000644000175000017500000000605112434123324020106 0ustar balasankarcbalasankarcrequire_relative 'helper' class TestClock < Sidetiq::TestCase def test_gettime_seconds assert_equal clock.gettime.tv_sec, Time.now.tv_sec end def test_gettime_nsec refute_nil clock.gettime.tv_nsec end def test_gettime_utc refute clock.gettime.utc? Sidetiq.config.utc = true assert clock.gettime.utc? Sidetiq.config.utc = false end def test_backfilling BackfillWorker.jobs.clear Sidetiq.stubs(:workers).returns([BackfillWorker]) start = Sidetiq::Schedule.start_time BackfillWorker.stubs(:last_scheduled_occurrence).returns(start.to_f) clock.stubs(:gettime).returns(start) clock.tick BackfillWorker.jobs.clear clock.stubs(:gettime).returns(start + 86400 * 10 + 1) clock.tick assert_equal 10, BackfillWorker.jobs.length end def test_enqueues_jobs_by_schedule Sidetiq.stubs(:workers).returns([SimpleWorker]) SimpleWorker.expects(:perform_at).times(10) 10.times do |i| clock.stubs(:gettime).returns(Time.local(2011, 1, i + 1, 1)) clock.tick end clock.stubs(:gettime).returns(Time.local(2011, 1, 10, 2)) clock.tick clock.tick clock.tick end def test_enqueues_jobs_with_default_last_tick_arg_on_first_run time = Time.local(2011, 1, 1, 1, 30) clock.stubs(:gettime).returns(time, time + 3600) Sidetiq.stubs(:workers).returns([LastTickWorker]) expected_first_tick = time + 1800 expected_second_tick = expected_first_tick + 3600 LastTickWorker.expects(:perform_at).with(expected_first_tick, -1).once LastTickWorker.expects(:perform_at).with(expected_second_tick, expected_first_tick.to_f).once clock.tick clock.tick end def test_enqueues_jobs_with_last_run_timestamp_and_next_run_timestamp time = Time.local(2011, 1, 1, 1, 30) clock.stubs(:gettime).returns(time, time + 3600) Sidetiq.stubs(:workers).returns([LastAndScheduledTicksWorker]) expected_first_tick = time + 1800 expected_second_tick = expected_first_tick + 3600 LastAndScheduledTicksWorker.expects(:perform_at) .with(expected_first_tick, -1, expected_first_tick.to_f).once clock.tick LastAndScheduledTicksWorker.expects(:perform_at) .with(expected_second_tick, expected_first_tick.to_f, expected_second_tick.to_f).once clock.tick end def test_enqueues_jobs_with_last_run_timestamp_if_optional_argument time = Time.local(2011, 1, 1, 1, 30) clock.stubs(:gettime).returns(time, time + 3600) Sidetiq.stubs(:workers).returns([OptionalArgumentWorker]) 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 time = Time.local(2011, 1, 1, 1, 30) clock.stubs(:gettime).returns(time, time + 3600) Sidetiq.stubs(:workers).returns([SplatArgsWorker]) expected_first_tick = time + 1800 SplatArgsWorker.expects(:perform_at) .with(expected_first_tick, -1, expected_first_tick.to_f).once clock.tick end end sidetiq-0.6.3/test/test_schedule.rb0000644000175000017500000000200412434123324020601 0ustar balasankarcbalasankarcrequire_relative 'helper' class TestSchedule < Sidetiq::TestCase def test_method_missing sched = Sidetiq::Schedule.new sched.daily assert_equal "Daily", sched.to_s end def test_schedule_next? sched = Sidetiq::Schedule.new sched.daily assert sched.schedule_next?(Time.now + (24 * 60 * 60)) refute sched.schedule_next?(Time.now + (24 * 60 * 60)) assert sched.schedule_next?(Time.now + (2 * 24 * 60 * 60)) refute sched.schedule_next?(Time.now + (2 * 24 * 60 * 60)) end def test_backfill sched = Sidetiq::Schedule.new refute sched.backfill? sched.backfill = true assert sched.backfill? end def test_set_options sched = Sidetiq::Schedule.new sched.set_options(backfill: true) assert sched.backfill? sched.set_options(backfill: false) refute sched.backfill? end def test_use_utc Sidetiq.config.utc = true assert_equal(Time.utc(2010, 01, 01), Sidetiq::Schedule.new.start_time) ensure Sidetiq.config.utc = false end end sidetiq-0.6.3/tasks/0000755000175000017500000000000012434123324015573 5ustar balasankarcbalasankarcsidetiq-0.6.3/tasks/bundler.task0000644000175000017500000000003412434123324020107 0ustar balasankarcbalasankarcrequire 'bundler/gem_tasks' sidetiq-0.6.3/tasks/minitest.task0000644000175000017500000000013212434123324020307 0ustar balasankarcbalasankarcrequire 'rake/testtask' Rake::TestTask.new do |t| t.pattern = 'test/**/test_*.rb' end sidetiq-0.6.3/README.md0000644000175000017500000000260112434123324015724 0ustar balasankarcbalasankarc![Sidetiq](http://f.cl.ly/items/1W3k0R2V2x3n3S1t1M0B/sidetiq.png) ========= [![Build Status](https://travis-ci.org/tobiassvn/sidetiq.png)](https://travis-ci.org/tobiassvn/sidetiq) [![Dependency Status](https://gemnasium.com/tobiassvn/sidetiq.png)](https://gemnasium.com/tobiassvn/sidetiq) [![Coverage Status](https://coveralls.io/repos/tobiassvn/sidetiq/badge.png)](https://coveralls.io/r/tobiassvn/sidetiq) [![Code Climate](https://codeclimate.com/github/tobiassvn/sidetiq.png)](https://codeclimate.com/github/tobiassvn/sidetiq) Recurring jobs for [Sidekiq](http://mperham.github.com/sidekiq/). Overview -------- Sidetiq provides a simple API for defining recurring workers for Sidekiq. - Concurrency and fault-tolerance using Celluloid actors. - Flexible DSL based on [ice_cube](http://seejohnrun.github.com/ice_cube/). - Distributed, Redis-based locking to synchronize multiple Sidetiq processes. - Web extension with extensive monitoring of recurring jobs. - Sidetiq runs in your Sidekiq processes. No extra resources required. Usage ----- Please see the [Sidetiq wiki](http://github.com/tobiassvn/sidetiq/wiki) for more detailed documentation and usage notes. License ------- Sidetiq is released under the 3-clause BSD. See LICENSE for further details. Author ------ Tobias Svensson, [@tobiassvn](https://twitter.com/tobiassvn), [http://github.com/tobiassvn](http://github.com/tobiassvn) sidetiq-0.6.3/CHANGELOG.md0000644000175000017500000001027012434123324016257 0ustar balasankarcbalasankarc0.6.3 ----- - Don't pass classes without #perform defined to handler - Don't try to connect to redis from Schduleable unless Sidekiq.server? returns true. 0.6.2 ----- - Lock ice cube to 0.11.1 to fix memory leaks [camjackson] - Don't use Redis keys command [Connorhd ] - Use Sidekiq.redis_pool in Schedulable [nkondratyev] 0.6.1 ----- - Fix manual triggering of jobs with #perform arguments. - Require 'sidetiq' in 'sidetiq/web'. 0.6.0 ----- - Explicitly require Sidekiq::ExceptionHandler [gglider] - Fix config.utc [gglider] - Add Ruby 2.1.1 to travix [gglider] - Bump ice_cube dependency to 0.12.0 [toolmantim] - Sort workers index page in web dashboard by name [oestrich] - Reseting cached times when recurrence changes [LongMan] - Move CSS to external files [futhr] 0.5.0 ----- - Relax Sidekiq dependency. [leemhenson] 0.4.3 ----- - Various web UI fixes. [manuelmeurer] 0.4.2 ----- - Fix styling for Bootstrap 3 [manuelmeurer] 0.4.1 ----- - Use Sidekiq's JSON wrappers instead of the json gem directly. - Allow tick used by Clock#tick to be overridden. - Bump Sidekiq dependency to >= 2.15.0 0.4.0 ----- - Fix bug where web dashboard wouldn't render when in presence of a worker without a schedule. - Schedulable#tiq deprecation warning removed. - Schedules are now stored on the workers directly instead of in a pseudo-global, mutable Hash. - Clock now start looping automatically if `Sidekiq.server?` returns true. - Show job history in web extension. - Integrate with Sidekiq's exception handling/reporting in critical parts. - Store more detailed lock metadata. - Remove stray 'thead' from ERB template. - Store scheduled worker history in Redis. - Use a Celluloid pool of scheduling handlers to run calculations in parallel. - Use Celluloid actors instead of plain threads. - Fix to work with workers with one optional argument. [nata79] - Refactor top-level namespace methods into separate modules. - Add Procfile-based example code to boot Sidekiq and the web frontend simultaneuously. - Experimental watcher worker to remove invalid locks. 0.3.7 ----- - Bump Sidekiq dependency to ~> 2.14.0. - Use ERB templates instead of slim. - Don't check if `Sidekiq::Web.tabs` is an Array in Sidetiq::Web. - Fix Ruby parser warnings in web.rb. - Move development dependencies from Gemfile to gemspec. - Use coveralls instead of simplecov. 0.3.6 ----- - Better protection against stale locks and race-conditions. Locking is now done using WATCH/MULTI/EXEC/UNWATCH and additionally includes a host and process specific identifier to prevent accidental unlocks from other Sidekiq processes. - Fix Sidetiq::Schedulable documentation. 0.3.5 ----- - Use Clock#mon_synchronize instead of #synchronize. ActiveSupport's core extensions override Module#synchronize which seems to break MonitorMixin. 0.3.4 ----- - More robust #perform arity handling. 0.3.3 ----- - Deprecate Sidekiq::Schedulable.tiq in favor of .recurrence. Sidekiq::Schedulable.tiq will still work until v0.4.0 but log a deprecation warning. 0.3.2 ----- - Fix tests to work with changes to Sidekiq::Client. #push_old seems to expect 'at' instead of 'enqueued_at' now - Switch from MIT to 3-clause BSD license. - Remove C extension. - Bump Sidekiq dependency to ~> 2.13.0. - Ensure redis locks get unlocked in Clock#synchronize_clockworks. 0.3.1 ----- - Bump ice_cube dependency to ~> 0.11.0. - Bump Sidekiq dependency to ~> 2.12.0. - Fix tests. 0.3.0 ----- - Add `Sidetiq.schedules`. - Add `Sidetiq.workers`. - Add `Sidetiq.scheduled`. - Add `Sidetiq.retries`. - Add `Sidetiq.logger`. This defaults to the Sidekiq logger. - Add support for job backfills. - Clean up tests. - Sidetiq::Schedule no longer inherits from IceCube::Schedule. 0.2.0 ----- - Add class methods to get last and next scheduled occurrence. - Pass last and next (current) occurrence to #perform, if desired. This checks the method arity of #perform. - Bump Sidekiq dependency to 2.8.0 - Fix incorrectly assigned Thread priority. - Adjust clock sleep depending of execution time of the last tick. - Don't log thread object ids. - Issue a warning from the middleware if the clock thread died previously. 0.1.5 ----- - Allow jobs to be scheduled for immediate runs via the web extension. sidetiq-0.6.3/sidetiq.gemspec0000644000175000017500000000234012434123324017454 0ustar balasankarcbalasankarc# -*- encoding: utf-8 -*- lib = File.expand_path(File.join('..', 'lib'), __FILE__) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require 'sidetiq/version' Gem::Specification.new do |gem| gem.name = "sidetiq" gem.version = Sidetiq::VERSION::STRING gem.authors = ["Tobias Svensson"] gem.email = ["tob@tobiassvensson.co.uk"] gem.description = "Recurring jobs for Sidekiq" gem.summary = gem.description gem.homepage = "http://github.com/tobiassvn/sidetiq" gem.license = "3-clause BSD" gem.files = `git ls-files`.split($/) gem.executables = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) } gem.test_files = gem.files.grep(%r{^(test|spec|features)/}) gem.require_paths = ["lib"] gem.extensions = [] gem.add_dependency 'sidekiq', '>= 3.0.0' gem.add_dependency 'celluloid', '>= 0.14.1' gem.add_dependency 'ice_cube', '0.11.1' 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' end end