sidekiq 0.10.0 → 7.2.0

data/bin/sidekiqctl

@@ -1,43 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'fileutils'
-
-stage = ARGV[0]
-pidfile = ARGV[1]
-timeout = ARGV[2].to_i
-timeout = 10 if timeout == 0
-
-def done(msg)
-  puts msg
-  exit(0)
-end
-
-done 'No pidfile given' if !pidfile
-done 'Pidfile does not exist' if !File.exist?(pidfile)
-
-pid = File.read(pidfile).to_i
-done 'Invalid pidfile content' if pid == 0
-
-begin
-  Process.getpgid(pid)
-rescue Errno::ESRCH
-  done "Process doesn't exist"
-end
-
-case stage
-when 'quiet'
-  `kill -USR1 #{pid}`
-when 'stop'
-  `kill -TERM #{pid}`
-  timeout.times do
-    begin
-      Process.getpgid(pid)
-    rescue Errno::ESRCH
-      FileUtils.rm_f pidfile
-      done 'Sidekiq shut down gracefully.'
-    end
-    sleep 1
-  end
-  `kill -9 #{pid}`
-  done 'Sidekiq shut down forcefully.'
-end

data/config.ru

@@ -1,8 +0,0 @@
-require 'sidekiq'
-
-Sidekiq.configure_client do |config|
-  config.redis = { :size => 1 }
-end
-
-require 'sidekiq/web'
-run Sidekiq::Web

data/examples/chef/cookbooks/sidekiq/README.rdoc

@@ -1,11 +0,0 @@
-= DESCRIPTION:
-
-Sidekiq is a Redis-backed Ruby library for creating background jobs, placing those jobs on multiple queues, and processing them later.
-
-= USAGE: 
-
-add require_recipe "sidekiq" to main/recipes/default.rb
-
-= NOTES:
-
-I setup a basic size for the Sidekiq workers based on the instance_type, if you need more or less workers please modify the recipe itself.  

data/examples/chef/cookbooks/sidekiq/recipes/default.rb

@@ -1,55 +0,0 @@
-#
-# Cookbook Name:: sidekiq
-# Recipe:: default
-#
-role = node[:instance_role]
-if role == 'solo' || (role == 'util' && node[:name] =~ /sidekiq/)
-
-  # for now
-  worker_count = 1
-
-  node[:applications].each do |app, data|
-    template "/etc/monit.d/sidekiq_#{app}.monitrc" do 
-      owner 'root' 
-      group 'root' 
-      mode 0644 
-      source "monitrc.conf.erb" 
-      variables({ 
-        :num_workers => worker_count,
-        :app_name => app, 
-        :rails_env => node[:environment][:framework_env] 
-      }) 
-    end
-
-    template "/engineyard/bin/sidekiq" do
-      owner 'root'
-      group 'root' 
-      mode 0755
-      source "sidekiq.erb" 
-    end
-
-    worker_count.times do |count|
-      template "/data/#{app}/shared/config/sidekiq_#{count}.yml" do
-        owner node[:owner_name]
-        group node[:owner_name]
-        mode 0644
-        source "sidekiq.yml.erb"
-        variables({
-          :require => "/data/#{app}/current"
-        })
-      end
-    end
-
-    execute "ensure-sidekiq-is-setup-with-monit" do 
-      command %Q{ 
-        monit reload 
-      } 
-    end
-
-    execute "restart-sidekiq" do 
-      command %Q{ 
-        echo "sleep 20 && monit -g #{app}_sidekiq restart all" | at now 
-      }
-    end
-  end 
-end

data/examples/chef/cookbooks/sidekiq/templates/default/monitrc.conf.erb

@@ -1,8 +0,0 @@
-<% (@num_workers || 1).times do |num| %>
-check process sidekiq_<%= @app_name %>_<%= num %>
-  with pidfile /var/run/engineyard/sidekiq/<%= @app_name %>/sidekiq_<%= num %>.pid
-  start program = "/engineyard/bin/sidekiq <%= @app_name %> start <%= @rails_env  %> sidekiq_<%= num %>.yml" with timeout 90 seconds
-  stop program = "/engineyard/bin/sidekiq <%= @app_name %> stop <%= @rails_env  %> sidekiq_<%= num %>.yml" with timeout 90 seconds
-  if totalmem is greater than 300 MB for 2 cycles then restart # eating up memory?
-  group <%= @app_name %>_sidekiq
-<% end %>

data/examples/chef/cookbooks/sidekiq/templates/default/sidekiq.erb

@@ -1,219 +0,0 @@
-#!/bin/sh
-#
-# This script starts and stops the Sidekiq daemon
-# This script belongs in /engineyard/bin/sidekiq
-#
-
-PATH=/bin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:$PATH
-CURDIR=`pwd`
-
-usage() {
-  echo "Usage: $0 <appname> {start|stop|quit} <environment> <conf_file>"
-  echo -e "\nstop)     is a synonym for quit"
-  echo "quit)     issues -INT to request the worker to stop"
-  echo -e "\nSee http://mperham.github.com/sidekiq/ for more details"
-  exit 1
-}
-
-rm_lockfile(){
-  if [ -e $LOCK_FILE ]; then
-   logger -t "monit-sidekiq[$$]" "removing $LOCK_FILE for `cat $LOCK_FILE`"
-   rm $LOCK_FILE
-  fi
-}
-
-exit_cleanly() {
-  cd $CURDIR
-  logger -t "monit-sidekiq[$$]" "exiting wrapper cleanly with $RESULT"
-  exit $RESULT
-}
-
-unlock_and_exit_cleanly(){
-  rm_lockfile
-  exit_cleanly
-}
-
-set_pid_from_file(){
-  export PID=`cat $PID_FILE`
-}
-
-signal_worker() {
-  RESULT=0
-  if [ -f $PID_FILE ]; then
-    set_pid_from_file
-    logger -t "monit-sidekiq[$$]" "Issuing kill with -$SIG $PID"
-    SLEEP_COUNT=0
-    kill -$SIG $PID 
-  fi
-}
-
-signal_worker_fatally(){
-  signal_worker() 
-  if [ -f $PID_FILE ]; then
-    if [ -n "$ALLOW_TIMEOUT" ]; then
-      while [ -e /proc/$PID ]; do
-        sleep .25
-        let "SLEEP_COUNT+=1"
-        let "REPORT_TIME = $SLEEP_COUNT%4"
-        if(( "$SLEEP_COUNT" > $GRACE_TIME )); then
-          logger -t "monit-sidekiq[$$]" "Sidekiq worker with pid $PID for $WORKER_REF still running, issuing -TERM"
-          kill -15 $PID 2>/dev/null; true
-        elif(( $REPORT_TIME == 0 )); then
-          let "RUNTIME = $SLEEP_COUNT/4"
-          logger -t "monit-sidekiq[$$]" "waiting for $PID to die ( for $RUNTIME seconds now)"
-        fi 
-      done
-    fi
-    sleep 1
-    if [ -d /proc/$PID ];then 
-      for child in $(ps axo pid,ppid | awk "{ if ( \$2 == $PID ) { print \$1 }}");
-      do
-        kill -9 $child 2>/dev/null; true
-        logger -t "monit-sidekiq[$$]" "Murdering Sidekiq workers child with $child for $WORKER_REF"
-        break
-      done    
-      while [ -d /proc/$PID ]; do
-        logger -t "monit-sidekiq[$$]" "Murdering Sidekiq worker with $PID for $WORKER_REF"
-        kill -9 $PID
-        sleep 1
-      done
-    fi
-    logger -t "monit-sidekiq[$$]" "Removing pid file for $PID - $WORKER_REF"
-    [ -e "$PID_FILE" -a ! -d /proc/$PID ] && rm -f $PID_FILE
-  fi
-}
-
-lock(){
-  RESULT=0
-  if [ -e $LOCK_FILE ]; then
-    LAST_LOCK_PID=`cat $LOCK_FILE`
-    if [ -n $LAST_LOCK_PID -a -z "`ps axo pid|grep $LAST_LOCK_PID`" -a -f $LOCK_FILE ];then
-      sleep 1
-      logger -t "monit-sidekiq[$$]" "Removing stale lock file for $WORKER_REF ($LAST_LOCK_PID)"
-      rm $LOCK_FILE 2>&1
-    else
-      logger -t "monit-sidekiq[$$]" "Monit already messing with $WORKER_REF ($LAST_LOCK_PID)"
-      RESULT=1
-      exit_cleanly 
-    fi
-  fi
-  echo $$ > $LOCK_FILE
-}
-
-legacy_fix() {
- #In the transition from 0.18.2 to 0.18.3 of ey monit scripts the way 
- #the pid file is used to find the process to kill has changed. 
- #To avert problems being left behind after an upgrade of this package,
-  if [ -f $PID_FILE ]; then
-    set_pid_from_file
-    if [ -n "`ps axo pid,command|grep $PID|grep 'su -c'`" ];then
-      logger -t "monit-sidekiq[$$]" "Monit Scripts have just been upgraded, killing old style workers"
-      for child in $(ps axo pid,ppid| awk "{ if ( \$2 == $PID ) { print \$1 }}");
-      do
-        kill -TERM $child 2> /dev/null
-        while [ -e /proc/$child ]; do
-          logger -t "monit-sidekiq[$$]" "killing legacy worker: $child"
-          [ -e /proc/$child ] && kill -9 $child 2> /dev/null
-	  sleep 1 
-        done
-      done
-      [ -e /proc/$PID   ] && kill -9 $PID   2> /dev/null
-      rm $PID_FILE
-      unlock_exit_cleanly  
-    fi
-  fi
-}
-
-if [ $# -lt 4 ]; then usage; fi
-
-if [ "`whoami`" != "root" ]; then
-  logger -t `basename $0` -s "Must be run as root" 
-  exit 1
-fi
-
-#Baisc Setup of default values
-APP=$1 ; ACTION=$2; RACK_ENV=$3; CONF_FILE=$4;
-
-APP_DIR="/data/${APP}"
-APP_ROOT="${APP_DIR}/current"
-APP_SHARED="${APP_DIR}/shared"
-APP_CONFIG="${APP_SHARED}/config"
-
-if [ -e "${APP_CONFIG}/${CONF_FILE}" ]; then
-  logger -t "sidekiq_${APP}" -s "Good, found a conf file. Proceeding..."
-else
-  logger -t "sidekiq_${APP}" -s "/data/${APP}/shared/config/${CONF_FILE} not found for app: ${APP}"
-  exit 1
-fi
-
-WORKER_REF=`echo $CONF_FILE | sed s/.conf//`
-LOG_FILE="$APP_ROOT/log/$WORKER_REF.log"
-LOCK_FILE="/tmp/$WORKER_REF.monit-lock"
-PID_FILE="/var/run/engineyard/sidekiq/$APP/$WORKER_REF.pid"
-GEMFILE="$APP_ROOT/Gemfile"
-SIDEKIQ="sidekiq"
-if [ -f $GEMFILE ];then
-  SIDEKIQ="bundle exec $APP_ROOT/ey_bundler_binstubs/sidekiq"
-fi
-
-if [ -d $APP_ROOT ]; then
-  USER=$(stat -L -c"%U" $APP_ROOT)
-  export HOME="/home/$USER" 
-
-  # Fix for SD-3786 - stop sending in VERBOSE= and VVERBOSE= by default
-  if declare -p VERBOSE >/dev/null 2>&1; then export V="VERBOSE=$VERBOSE"; fi
-  if declare -p VVERBOSE >/dev/null 2>&1; then export VV="VVERBOSE=$VVERBOSE"; fi
-
-  # Older versions of sudo need us to call env for the env vars to be set correctly
-  COMMAND="/usr/bin/env $V $VV APP_ROOT=${APP_ROOT} RACK_ENV=${RACK_ENV} RAILS_ENV=${RACK_ENV} $SIDEKIQ -e ${RACK_ENV} -C ${APP_CONFIG}/${CONF_FILE}"
-  
-  if [ ! -d /var/run/engineyard/sidekiq/$APP ]; then
-    mkdir -p /var/run/engineyard/sidekiq/$APP
-  fi
-
-  # handle the second param, don't start if already existing
-
-  logger -t "monit-sidekiq[$$]" "${ACTION}ing Sidekiq worker $WORKER_REF"
-  case "$ACTION" in
-    start)
-      lock
-      cd $APP_ROOT
-      if [ -f $PID_FILE ]; then
-        set_pid_from_file
-        if [ -d /proc/$PID ]; then
-          logger -t "monit-sidekiq[$$]" "Sidekiq worker $WORKER_REF is already running with $PID."
-          RESULT=1
-        else
-          rm -f $PID_FILE
-          logger -t "monit-sidekiq[$$]" "Removing stale pid file ($PID_FILE) for pid $PID"
-        fi
-      fi
-      if [ ! -f $PID_FILE ]; then
-        sudo -u $USER -H $COMMAND  >> $LOG_FILE 2>&1 &
-        RESULT=$?
-        logger -t "monit-sidekiq[$$]" "Started with pid $! and exit $RESULT"
-        echo $! > $PID_FILE
-        sleep .1
-      fi
-      unlock_and_exit_cleanly 
-      ;;
-    stop|quit)
-      legacy_fix
-      lock
-      SIG="INT"
-      [ -z "$GRACE_TIME" ] && GRACE_TIME=60
-      ALLOW_TIMEOUT=1
-      signal_worker
-      [ -e "$LOCK_FILE" ] && rm $LOCK_FILE
-      unlock_and_exit_cleanly  
-      ;;
-    *)
-      usage
-      exit_cleanly      
-      ;;
-  esac
-else
-  echo "/data/$APP/current doesn't exist."
-  usage
-fi
-

data/examples/chef/cookbooks/sidekiq/templates/default/sidekiq.yml.erb

@@ -1,22 +0,0 @@
----
-<% if @verbose %>
-:verbose: <%= @verbose %>
-<% end %>
-<% if @environment %>
-:environment: <%= @environment %>
-<% end %>
-<% if @require %>
-:require: <%= @require %>
-<% end %>
-<% if @pidfile %>
-:pidfile: <%= @pidfile %>
-<% end %>
-<% if @concurrency %>
-:concurrency: <%= @concurrency %>
-<% end %>
-<% if @queues %>
-:queues:
-  <% @queues.each do |name, priority| %>
-  - [<%= name %>, <%= priority %>]
-  <% end %>
-<% end %>

data/examples/config.yml

@@ -1,9 +0,0 @@
-# Sample configuration file for Sidekiq.
-# Options here can still be overridden by cmd line args.
-#   sidekiq -C config.yml
----
-:verbose:      false
-:concurrency:  25
-:queues:
-  - [often, 2]
-  - [seldom, 1]

data/examples/monitrc.conf

@@ -1,6 +0,0 @@
-check process sidekiq_myapp
-  with pidfile /path/to/sidekiq.pid
-  start program = "bundle exec sidekiq -C /path/to/sidekiq_conf.yml -P /path/to/sidekiq.pid" with timeout 90 seconds
-  stop program = "kill -s INT `cat /path/to/sidekiq.pid`" with timeout 90 seconds
-  if totalmem is greater than 200 MB for 2 cycles then restart # eating up memory?
-  group myapp_sidekiq

data/examples/por.rb

@@ -1,27 +0,0 @@
-require 'sidekiq'
-
-# If your client is single-threaded, we just need a single connection in our Redis connection pool
-Sidekiq.configure_client do |config|
-  config.redis = Sidekiq::RedisConnection.create(:namespace => 'x', :size => 1, :url => 'redis://redis.host:1234/14')
-end
-
-# Sidekiq server is multi-threaded so our Redis connection pool size defaults to concurrency (-c)
-Sidekiq.configure_server do |config|
-  config.redis = Sidekiq::RedisConnection.create(:namespace => 'x', :url => 'redis://redis.host:1234/14')
-end
-
-# Start up sidekiq via
-# ./bin/sidekiq -r ./examples/por.rb
-# and then you can open up an IRB session like so:
-# irb -r ./examples/por.rb
-# where you can then say
-# PlainOldRuby.perform_async "like a dog", 3
-#
-class PlainOldRuby
-  include Sidekiq::Worker
-
-  def perform(how_hard="super hard", how_long=1)
-    sleep how_long
-    puts "Workin' #{how_hard}"
-  end
-end

data/examples/scheduling.rb

@@ -1,37 +0,0 @@
-# Sidekiq defers scheduling to other, better suited gems.
-# If you want to run a job regularly, here's an example
-# of using the 'whenever' gem to push jobs to Sidekiq
-# regularly.
-
-class MyWorker
-  include Sidekiq::Worker
-
-  def perform(count)
-    puts "Job ##{count}: Late night, so tired..."
-  end
-
-  def self.late_night_work
-    10.times do |x|
-      perform_async(x)
-    end
-  end
-end
-
-# Kick off a bunch of jobs early in the morning
-every 1.day, :at => '4:30 am' do
-  runner "MyWorker.late_night_work"
-end
-
-
-class HourlyWorker
-  include Sidekiq::Worker
-
-  def perform
-    cleanup_database
-    format_hard_drive
-  end
-end
-
-every :hour do # Many shortcuts available: :hour, :day, :month, :year, :reboot
-  runner "HourlyWorker.perform_async"
-end

data/examples/sinkiq.rb

@@ -1,57 +0,0 @@
-# Make sure you have Sinatra installed, then start sidekiq with
-# ./bin/sidekiq -r ./examples/sinkiq.rb
-# Simply run Sinatra with
-# ruby examples/sinkiq.rb
-# and then browse to http://localhost:4567
-#
-require 'sinatra'
-require 'sidekiq/worker'
-$redis = Sidekiq::RedisConnection.create
-
-class SinatraWorker
-  include Sidekiq::Worker
-
-  def perform(msg="lulz you forgot a msg!")
-    $redis.lpush("sinkiq-example-messages", msg)
-  end
-end
-
-get '/' do
-  @failed = $redis.get('stat:failed')
-  @processed = $redis.get('stat:processed')
-  @messages = $redis.lrange('sinkiq-example-messages', 0, -1)
-  erb :index
-end
-
-post '/msg' do
-  SinatraWorker.perform_async params[:msg]
-  redirect to('/')
-end
-
-__END__
-
-@@ layout
-<html>
-  <head>
-    <title>Sinatra + Sidekiq</title>
-    <body>
-      <%= yield %>
-    </body>
-</html>
-
-@@ index
-  <h1>Sinata + Sidekiq Example</h1>
-  <h2>Failed: <%= @failed %></h2>
-  <h2>Processed: <%= @processed %></h2>
-
-  <form method="post" action="/msg">
-    <input type="text" name="msg">
-    <input type="submit" value="Add Message">
-  </form>
-
-  <a href="/">Refresh page</a>
-
-  <h3>Messages</h3>
-  <% @messages.each do |msg| %>
-    <p><%= msg %></p>
-  <% end %>

data/lib/sidekiq/capistrano.rb

@@ -1,32 +0,0 @@
-Capistrano::Configuration.instance.load do
-  before "deploy", "sidekiq:quiet"
-  after "deploy", "sidekiq:restart"
-
-  _cset(:sidekiq_timeout) { 10 }
-
-  namespace :sidekiq do
-
-    desc "Quiet sidekiq (stop accepting new work)"
-    task :quiet do
-      run "cd #{current_path} && sidekiqctl quiet #{current_path}/tmp/pids/sidekiq.pid"
-    end
-
-    desc "Stop sidekiq"
-    task :stop do
-      run "cd #{current_path} && sidekiqctl stop #{current_path}/tmp/pids/sidekiq.pid #{fetch :sidekiq_timeout}"
-    end
-
-    desc "Start sidekiq"
-    task :start do
-      rails_env = fetch(:rails_env, "production")
-      run "cd #{current_path} && nohup bundle exec sidekiq -e #{rails_env} -C #{current_path}/config/sidekiq.yml -P #{current_path}/tmp/pids/sidekiq.pid >> #{current_path}/log/sidekiq.log 2>&1 &"
-    end
-
-    desc "Restart sidekiq"
-    task :restart do
-      stop
-      start
-    end
-
-  end
-end

data/lib/sidekiq/extensions/action_mailer.rb

@@ -1,26 +0,0 @@
-require 'sidekiq/extensions/generic_proxy'
-
-module Sidekiq
-  module Extensions
-    ##
-    # Adds a 'delay' method to ActionMailer to offload arbitrary email
-    # delivery to Sidekiq.  Example:
-    #
-    #    UserMailer.delay.send_welcome_email(new_user)
-    class DelayedMailer
-      include Sidekiq::Worker
-
-      def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        target.send(method_name, *args).deliver
-      end
-    end
-
-    module ActionMailer
-      def delay
-        Proxy.new(DelayedMailer, self)
-      end
-    end
-
-  end
-end

data/lib/sidekiq/extensions/active_record.rb

@@ -1,27 +0,0 @@
-require 'sidekiq/extensions/generic_proxy'
-
-module Sidekiq
-  module Extensions
-    ##
-    # Adds a 'delay' method to ActiveRecord to offload arbitrary method
-    # execution to Sidekiq.  Examples:
-    #
-    # User.delay.delete_inactive
-    # User.recent_signups.each { |user| user.delay.mark_as_awesome }
-    class DelayedModel
-      include Sidekiq::Worker
-
-      def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        target.send(method_name, *args)
-      end
-    end
-
-    module ActiveRecord
-      def delay
-        Proxy.new(DelayedModel, self)
-      end
-    end
-
-  end
-end

data/lib/sidekiq/extensions/generic_proxy.rb

@@ -1,21 +0,0 @@
-module Sidekiq
-  module Extensions
-    class Proxy < ::BasicObject
-      def initialize(performable, target)
-        @performable = performable
-        @target = target
-      end
-
-      def method_missing(name, *args)
-        # Sidekiq has a limitation in that its message must be JSON.
-        # JSON can't round trip real Ruby objects so we use YAML to
-        # serialize the objects to a String.  The YAML will be converted
-        # to JSON and then deserialized on the other side back into a
-        # Ruby object.
-        obj = [@target, name, args]
-        @performable.perform_async(::YAML.dump(obj))
-      end
-    end
-
-  end
-end

data/lib/sidekiq/middleware/client/unique_jobs.rb

@@ -1,32 +0,0 @@
-require 'multi_json'
-require 'digest'
-
-module Sidekiq
-  module Middleware
-    module Client
-      class UniqueJobs
-        HASH_KEY_EXPIRATION = 30 * 60
-
-        def call(item, queue)
-          payload_hash = Digest::MD5.hexdigest(MultiJson.encode(item))
-          unique = false
-
-          Sidekiq.redis do |conn|
-            conn.watch(payload_hash)
-
-            if conn.get(payload_hash)
-              conn.unwatch
-            else
-              unique = conn.multi do
-                conn.setex(payload_hash, HASH_KEY_EXPIRATION, 1)
-              end
-            end
-          end
-
-          yield if unique
-        end
-
-      end
-    end
-  end
-end

data/lib/sidekiq/middleware/server/active_record.rb

@@ -1,13 +0,0 @@
-module Sidekiq
-  module Middleware
-    module Server
-      class ActiveRecord
-        def call(*args)
-          yield
-        ensure
-          ::ActiveRecord::Base.clear_active_connections! if defined?(::ActiveRecord)
-        end
-      end
-    end
-  end
-end