kulesa-sidekiq 1.2.2

data/lib/sidekiq/testing.rb

@@ -0,0 +1,44 @@
+module Sidekiq
+  module Worker
+
+    ##
+    # The Sidekiq testing infrastructure overrides perform_async
+    # so that it does not actually touch the network.  Instead it
+    # stores the asynchronous jobs in a per-class array so that
+    # their presence/absence can be asserted by your tests.
+    #
+    # This is similar to ActionMailer's :test delivery_method and its
+    # ActionMailer::Base.deliveries array.
+    #
+    # Example:
+    #
+    #   require 'sidekiq/testing'
+    #
+    #   assert_equal 0, HardWorker.jobs.size
+    #   HardWorker.perform_async(:something)
+    #   assert_equal 1, HardWorker.jobs.size
+    #   assert_equal :something, HardWorker.jobs[0]['args'][0]
+    #
+    #   assert_equal 0, Sidekiq::Extensions::DelayedMailer.jobs.size
+    #   MyMailer.delayed.send_welcome_email('foo@example.com')
+    #   assert_equal 1, Sidekiq::Extensions::DelayedMailer.jobs.size
+    #
+    module ClassMethods
+      alias_method :perform_async_old, :perform_async
+      def perform_async(*args)
+        jobs << { 'class' => self.name, 'args' => args }
+        true
+      end
+
+      def jobs
+        @pushed ||= []
+      end
+
+      def drain
+        while job = jobs.shift do
+          new.perform(*job['args'])
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/testing/inline.rb

@@ -0,0 +1,37 @@
+module Sidekiq
+  module Worker
+
+    ##
+    # The Sidekiq inline infrastructure overrides the perform_async so that it
+    # actually calls perform instead. This allows workers to be run inline in a
+    # testing environment.
+    #
+    # This is similar to `Resque.inline = true` functionality.
+    #
+    # Example:
+    #
+    #   require 'sidekiq/testing/inline'
+    #
+    #   $external_variable = 0
+    #
+    #   class ExternalWorker
+    #     include Sidekiq::Worker
+    #
+    #     def perform
+    #       $external_variable = 1
+    #     end
+    #   end
+    #
+    #   assert_equal 0, $external_variable
+    #   ExternalWorker.perform_async
+    #   assert_equal 1, $external_variable
+    #
+    module ClassMethods
+      alias_method :perform_async_old, :perform_async
+      def perform_async(*args)
+        new.perform(*args)
+        true
+      end
+    end
+  end
+end

data/lib/sidekiq/util.rb

@@ -0,0 +1,40 @@
+module Sidekiq
+  ##
+  # This module is part of Sidekiq core and not intended for extensions.
+  #
+  module Util
+
+    EXPIRY = 60 * 60
+
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+
+    def watchdog(last_words)
+      yield
+    rescue => ex
+      logger.error last_words
+      logger.error ex
+      logger.error ex.backtrace.join("\n")
+    end
+
+    def logger
+      Sidekiq.logger
+    end
+
+    def redis(&block)
+      Sidekiq.redis(&block)
+    end
+
+    def process_id
+      Process.pid
+    end
+  end
+end

data/lib/sidekiq/version.rb

@@ -0,0 +1,3 @@
+module Sidekiq
+  VERSION = "1.2.2"
+end

data/lib/sidekiq/web.rb

@@ -0,0 +1,185 @@
+require 'sinatra/base'
+require 'slim'
+require 'sprockets'
+require 'multi_json'
+
+module Sidekiq
+  class SprocketsMiddleware
+    def initialize(app, options={})
+      @app = app
+      @root = options[:root]
+      path   =  options[:path] || 'assets'
+      @matcher = /^\/#{path}\/*/
+      @environment = ::Sprockets::Environment.new(@root)
+      @environment.append_path 'assets/javascripts'
+      @environment.append_path 'assets/javascripts/vendor'
+      @environment.append_path 'assets/stylesheets'
+      @environment.append_path 'assets/stylesheets/vendor'
+      @environment.append_path 'assets/images'
+    end
+
+    def call(env)
+      # Solve the problem of people requesting /sidekiq when they need to request /sidekiq/ so
+      # that relative links in templates resolve correctly.
+      return [301, { 'Location' => "#{env['SCRIPT_NAME']}/", 'Content-Type' => 'text/html' }, ['redirecting']] if env['SCRIPT_NAME'] == env['REQUEST_PATH']
+
+      return @app.call(env) unless @matcher =~ env["PATH_INFO"]
+      env['PATH_INFO'].sub!(@matcher,'')
+      @environment.call(env)
+    end
+  end
+
+  class Web < Sinatra::Base
+    dir = File.expand_path(File.dirname(__FILE__) + "/../../web")
+    set :views,  "#{dir}/views"
+    set :root, "#{dir}/public"
+    set :slim, :pretty => true
+    use SprocketsMiddleware, :root => dir
+
+    helpers do
+
+      def workers
+        @workers ||= begin
+          Sidekiq.redis do |conn|
+            conn.smembers('workers').map do |w|
+              msg = conn.get("worker:#{w}")
+              msg ? [w, Sidekiq.load_json(msg)] : nil
+            end.compact.sort { |x| x[1] ? -1 : 1 }
+          end
+        end
+      end
+
+      def processed
+        Sidekiq.redis { |conn| conn.get('stat:processed') } || 0
+      end
+
+      def failed
+        Sidekiq.redis { |conn| conn.get('stat:failed') } || 0
+      end
+
+      def retry_count
+        Sidekiq.redis { |conn| conn.zcard('retry') }
+      end
+
+      def retries(count=50)
+        Sidekiq.redis do |conn|
+          results = conn.zrange('retry', 0, count, :withscores => true)
+          results.each_slice(2).map { |msg, score| [Sidekiq.load_json(msg), Float(score)] }
+        end
+      end
+
+      def queues
+        @queues ||= Sidekiq.redis do |conn|
+          conn.smembers('queues').map do |q|
+            [q, conn.llen("queue:#{q}") || 0]
+          end.sort { |x,y| x[1] <=> y[1] }
+        end
+      end
+
+      def retries_with_score(score)
+        Sidekiq.redis do |conn|
+          results = conn.zrangebyscore('retry', score, score)
+          results.map { |msg| Sidekiq.load_json(msg) }
+        end
+      end
+
+      def location
+        Sidekiq.redis { |conn| conn.client.location }
+      end
+
+      def root_path
+        "#{env['SCRIPT_NAME']}/"
+      end
+
+      def current_status
+        return 'idle' if workers.size == 0
+        return 'active'
+      end
+
+      def relative_time(time)
+        %{<time datetime="#{time.getutc.iso8601}">#{time}</time>}
+      end
+
+      def display_args(args, count=100)
+        args.map { |arg| a = arg.inspect; a.size > count ? "#{a[0..count]}..." : a }.join(", ")
+      end
+    end
+
+    get "/" do
+      slim :index
+    end
+
+    get "/queues/:name" do
+      halt 404 unless params[:name]
+      count = (params[:count] || 10).to_i
+      @name = params[:name]
+      @messages = Sidekiq.redis {|conn| conn.lrange("queue:#{@name}", 0, count) }.map { |str| Sidekiq.load_json(str) }
+      slim :queue
+    end
+
+    post "/queues/:name" do
+      Sidekiq.redis do |conn|
+        conn.del("queue:#{params[:name]}")
+        conn.srem("queues", params[:name])
+      end
+      redirect root_path
+    end
+
+    get "/retries/:score" do
+      halt 404 unless params[:score]
+      @score = params[:score].to_f
+      @retries = retries_with_score(@score)
+      redirect "#{root_path}retries" if @retries.empty?
+      slim :retry
+    end
+
+    get '/retries' do
+      @retries = retries
+      slim :retries
+    end
+
+    post '/retries' do
+      halt 404 unless params[:score]
+      params[:score].each do |score|
+        s = score.to_f
+        if params['retry']
+          process_score(s, :retry)
+        elsif params['delete']
+          process_score(s, :delete)
+        end
+      end
+      redirect root_path
+    end
+
+    post "/retries/:score" do
+      halt 404 unless params[:score]
+      score = params[:score].to_f
+      if params['retry']
+        process_score(score, :retry)
+      elsif params['delete']
+        process_score(score, :delete)
+      end
+      redirect root_path
+    end
+
+    def process_score(score, operation)
+      case operation
+      when :retry
+        Sidekiq.redis do |conn|
+          results = conn.zrangebyscore('retry', score, score)
+          conn.zremrangebyscore('retry', score, score)
+          results.map do |message|
+            msg = Sidekiq.load_json(message)
+            conn.rpush("queue:#{msg['queue']}", message)
+          end
+        end
+      when :delete
+        Sidekiq.redis do |conn|
+          conn.zremrangebyscore('retry', score, score)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/sidekiq/worker.rb

@@ -0,0 +1,62 @@
+require 'sidekiq/client'
+
+module Sidekiq
+
+  ##
+  # Include this module in your worker class and you can easily create
+  # asynchronous jobs:
+  #
+  # class HardWorker
+  #   include Sidekiq::Worker
+  #
+  #   def perform(*args)
+  #     # do some work
+  #   end
+  # end
+  #
+  # Then in your Rails app, you can do this:
+  #
+  #   HardWorker.perform_async(1, 2, 3)
+  #
+  # Note that perform_async is a class method, perform is an instance method.
+  module Worker
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def logger
+      Sidekiq.logger
+    end
+
+    module ClassMethods
+      def perform_async(*args)
+        Sidekiq::Client.push('class' => self, 'args' => args)
+      end
+
+      ##
+      # Allows customization for this type of Worker.
+      # Legal options:
+      #
+      #   :unique - enable the UniqueJobs middleware for this Worker, default *true*
+      #   :queue - use a named queue for this Worker, default 'default'
+      #   :retry - enable the RetryJobs middleware for this Worker, default *true*
+      #   :timeout - timeout the perform method after N seconds, default *nil*
+      #   :backtrace - whether to save any error backtrace in the retry payload to display in web UI,
+      #      can be true, false or an integer number of lines to save, default *false*
+      def sidekiq_options(opts={})
+        @sidekiq_options = get_sidekiq_options.merge(stringify_keys(opts || {}))
+      end
+
+      def get_sidekiq_options # :nodoc:
+        defined?(@sidekiq_options) ? @sidekiq_options : { 'unique' => true, 'retry' => true, 'queue' => 'default' }
+      end
+
+      def stringify_keys(hash) # :nodoc:
+        hash.keys.each do |key|
+          hash[key.to_s] = hash.delete(key)
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/sidekiq/yaml_patch.rb

@@ -0,0 +1,21 @@
+# YAML marshalling of instances can fail in some circumstances,
+# e.g. when the instance has a handle to a Proc.  This monkeypatch limits
+# the YAML serialization to just AR's internal @attributes hash.
+# The paperclip gem litters AR instances with Procs, for instance.
+#
+# Courtesy of @ryanlecompte https://gist.github.com/007b88ae90372d1a3321
+#
+
+if defined?(::ActiveRecord)
+  class ActiveRecord::Base
+    yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
+
+    def self.yaml_new(klass, tag, val)
+      klass.unscoped.find(val['attributes'][klass.primary_key])
+    end
+
+    def to_yaml_properties
+      ['@attributes']
+    end
+  end
+end

data/myapp/.gitignore

@@ -0,0 +1,15 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp

data/myapp/Capfile

@@ -0,0 +1,5 @@
+load 'deploy'
+# Uncomment if you are using Rails' asset pipeline
+    # load 'deploy/assets'
+Dir['vendor/gems/*/recipes/*.rb','vendor/plugins/*/recipes/*.rb'].each { |plugin| load(plugin) }
+load 'config/deploy' # remove this line to skip loading any of the default tasks

data/myapp/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+platforms :ruby do
+  gem 'sqlite3'
+end
+
+platforms :jruby do
+  gem 'jruby-openssl'
+  gem 'activerecord-jdbcsqlite3-adapter'
+end
+
+gem 'rails', '3.2.2'
+gem 'sidekiq', :path => '..'
+gem 'capistrano'
+
+# sidekiq-web dependencies
+gem 'slim'
+gem 'sinatra'
+gem 'sprockets'

data/myapp/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Myapp::Application.load_tasks