resque 1.23.0 → 2.6.0

data/lib/resque/server_helper.rb

@@ -0,0 +1,185 @@
+require 'rack/utils'
+
+module Resque
+  module ServerHelper
+    include Rack::Utils
+    alias_method :h, :escape_html
+
+    def current_section
+      url_path request.path_info.sub('/','').split('/')[0].downcase
+    end
+
+    def current_page
+      url_path request.path_info.sub('/','')
+    end
+
+    def url_path(*path_parts)
+      [ url_prefix, path_prefix, path_parts ].join("/").squeeze('/')
+    end
+    alias_method :u, :url_path
+
+    def path_prefix
+      request.env['SCRIPT_NAME']
+    end
+
+    def class_if_current(path = '')
+      'class="current"' if current_page[0, path.size] == path
+    end
+
+    def tab(name)
+      dname = name.to_s.downcase
+      path = url_path(dname)
+      "<li #{class_if_current(path)}><a href='#{path.gsub(" ", "_")}'>#{name}</a></li>"
+    end
+
+    def tabs
+      Resque::Server.tabs
+    end
+
+    def url_prefix
+      Resque::Server.url_prefix
+    end
+
+    def redis_get_size(key)
+      case Resque.redis.type(key)
+      when 'none'
+        0
+      when 'hash'
+        Resque.redis.hlen(key)
+      when 'list'
+        Resque.redis.llen(key)
+      when 'set'
+        Resque.redis.scard(key)
+      when 'string'
+        Resque.redis.get(key).length
+      when 'zset'
+        Resque.redis.zcard(key)
+      end
+    end
+
+    def redis_get_value_as_array(key, start=0)
+      case Resque.redis.type(key)
+      when 'none'
+        []
+      when 'hash'
+        Resque.redis.hgetall(key).to_a[start..(start + 20)]
+      when 'list'
+        Resque.redis.lrange(key, start, start + 20)
+      when 'set'
+        Resque.redis.smembers(key)[start..(start + 20)]
+      when 'string'
+        [Resque.redis.get(key)]
+      when 'zset'
+        Resque.redis.zrange(key, start, start + 20)
+      end
+    end
+
+    def show_args(args)
+      Array(args).map do |a|
+        a.to_yaml
+      end.join("\n")
+    rescue
+      args.to_s
+    end
+
+    def worker_hosts
+      @worker_hosts ||= worker_hosts!
+    end
+
+    def worker_hosts!
+      hosts = Hash.new { [] }
+
+      Resque.workers.each do |worker|
+        host, _ = worker.to_s.split(':')
+        hosts[host] += [worker.to_s]
+      end
+
+      hosts
+    end
+
+    def partial?
+      @partial
+    end
+
+    def partial(template, local_vars = {})
+      @partial = true
+      erb(template.to_sym, {:layout => false}, local_vars)
+    ensure
+      @partial = false
+    end
+
+    def poll
+      if defined?(@polling) && @polling
+        text = "Last Updated: #{Time.now.strftime("%H:%M:%S")}"
+      else
+        text = "<a href='#{u(request.path_info)}.poll' rel='poll'>Live Poll!!</a>"
+      end
+      "<p class='poll'>#{text}</p>"
+    end
+
+    ####################
+    #failed.erb helpers#
+    ####################
+
+    def failed_date_format
+      "%Y/%m/%d %T %z"
+    end
+
+    def failed_multiple_queues?
+      return @multiple_failed_queues if defined?(@multiple_failed_queues)
+
+      @multiple_failed_queues = Resque::Failure.queues.size > 1 ||
+        (defined?(Resque::Failure::RedisMultiQueue) && Resque::Failure.backend == Resque::Failure::RedisMultiQueue)
+    end
+
+    def failed_size
+      @failed_size ||= Resque::Failure.count(params[:queue], params[:class])
+    end
+
+    def failed_per_page
+      @failed_per_page = if params[:class]
+        failed_size
+      else
+        20
+      end
+    end
+
+    def failed_start_at
+      params[:start].to_i
+    end
+
+    def failed_end_at
+      if failed_start_at + failed_per_page > failed_size
+        failed_size
+      else
+        failed_start_at  + failed_per_page - 1
+      end
+    end
+
+    def failed_order
+      params[:order] || 'desc'
+    end
+
+    def failed_class_counts(queue = params[:queue])
+      classes = Hash.new(0)
+      Resque::Failure.each(0, Resque::Failure.count(queue), queue) do |_, item|
+        class_name = item['payload']['class'] if item['payload']
+        class_name ||= "nil"
+        classes[class_name] += 1
+      end
+      classes
+    end
+
+    def page_entries_info(start, stop, size, name = nil)
+      if size == 0
+        name ? "No #{name}s" : '<b>0</b>'
+      elsif size == 1
+        'Showing <b>1</b>' + (name ? " #{name}" : '')
+      elsif size > failed_per_page
+        "Showing #{start}-#{stop} of <b>#{size}</b>" + (name ? " #{name}s" : '')
+      else
+        "Showing #{start} to <b>#{size - 1}</b>" + (name ? " #{name}s" : '')
+      end
+    end
+  end
+end

data/lib/resque/stat.rb

@@ -7,11 +7,23 @@ module Resque
   #   Kill a stat: Stat.clear(name)
   module Stat
     extend self
-    extend Helpers
+
+    def redis
+      warn '[Resque] [Deprecation] Resque::Stat #redis method is deprecated (please use #data_strore)'
+      data_store
+    end
+
+    def data_store
+      @data_store ||= Resque.redis
+    end
+
+    def data_store=(data_store)
+      @data_store = data_store
+    end
 
     # Returns the int value of a stat, given a string stat name.
     def get(stat)
-      redis.get("stat:#{stat}").to_i
+      data_store.stat(stat)
     end
 
     # Alias of `get`
@@ -23,8 +35,8 @@ module Resque
     #
     # Can optionally accept a second int parameter. The stat is then
     # incremented by that amount.
-    def incr(stat, by = 1)
-      redis.incrby("stat:#{stat}", by)
+    def incr(stat, by = 1, **opts)
+      data_store.increment_stat(stat, by, **opts)
     end
 
     # Increments a stat by one.
@@ -37,7 +49,7 @@ module Resque
     # Can optionally accept a second int parameter. The stat is then
     # decremented by that amount.
     def decr(stat, by = 1)
-      redis.decrby("stat:#{stat}", by)
+      data_store.decrement_stat(stat,by)
     end
 
     # Decrements a stat by one.
@@ -46,8 +58,8 @@ module Resque
     end
 
     # Removes a stat from Redis, effectively setting it to 0.
-    def clear(stat)
-      redis.del("stat:#{stat}")
+    def clear(stat, **opts)
+      data_store.clear_stat(stat, **opts)
     end
   end
 end

data/lib/resque/tasks.rb

@@ -1,6 +1,7 @@
 # require 'resque/tasks'
 # will give you the resque tasks
 
+
 namespace :resque do
   task :setup
 
@@ -8,31 +9,14 @@ namespace :resque do
   task :work => [ :preload, :setup ] do
     require 'resque'
 
-    queues = (ENV['QUEUES'] || ENV['QUEUE']).to_s.split(',')
-
     begin
-      worker = Resque::Worker.new(*queues)
-      worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
-      worker.very_verbose = ENV['VVERBOSE']
-      worker.term_timeout = ENV['RESQUE_TERM_TIMEOUT'] || 4.0
-      worker.term_child = ENV['TERM_CHILD']
+      worker = Resque::Worker.new
     rescue Resque::NoQueueError
       abort "set QUEUE env var, e.g. $ QUEUE=critical,high rake resque:work"
     end
 
-    if ENV['BACKGROUND']
-      unless Process.respond_to?('daemon')
-          abort "env var BACKGROUND is set, which requires ruby >= 1.9"
-      end
-      Process.daemon(true)
-    end
-
-    if ENV['PIDFILE']
-      File.open(ENV['PIDFILE'], 'w') { |f| f << worker.pid }
-    end
-
+    worker.prepare
     worker.log "Starting worker #{worker}"
-
     worker.work(ENV['INTERVAL'] || 5) # interval, will block
   end
 
@@ -40,6 +24,10 @@ namespace :resque do
   task :workers do
     threads = []
 
+    if ENV['COUNT'].to_i < 1
+      abort "set COUNT env var, e.g. $ COUNT=2 rake resque:workers"
+    end
+
     ENV['COUNT'].to_i.times do
       threads << Thread.new do
         system "rake resque:work"
@@ -52,12 +40,25 @@ namespace :resque do
   # Preload app files if this is Rails
   task :preload => :setup do
     if defined?(Rails) && Rails.respond_to?(:application)
-      # Rails 3
-      Rails.application.eager_load!
-    elsif defined?(Rails::Initializer)
-      # Rails 2.3
-      $rails_rake_task = false
-      Rails::Initializer.run :load_application_classes
+      if Rails.application.config.eager_load
+        ActiveSupport.run_load_hooks(:before_eager_load, Rails.application)
+        Rails.application.config.eager_load_namespaces.each(&:eager_load!)
+      end
+    end
+  end
+
+  namespace :failures do
+    desc "Sort the 'failed' queue for the redis_multi_queue failure backend"
+    task :sort do
+      require 'resque'
+      require 'resque/failure/redis'
+
+      warn "Sorting #{Resque::Failure.count} failures..."
+      Resque::Failure.each(0, Resque::Failure.count) do |_, failure|
+        data = Resque.encode(failure)
+        Resque.redis.rpush(Resque::Failure.failure_queue_name(failure['queue']), data)
+      end
+      warn "done!"
     end
   end
 end

data/lib/resque/thread_signal.rb

@@ -0,0 +1,24 @@
+class Resque::ThreadSignal
+  def initialize
+    @mutex = Mutex.new
+    @signaled = false
+    @received = ConditionVariable.new
+  end
+
+  def signal
+    @mutex.synchronize do
+      @signaled = true
+      @received.signal
+    end
+  end
+
+  def wait_for_signal(timeout)
+    @mutex.synchronize do
+      unless @signaled
+        @received.wait(@mutex, timeout)
+      end
+
+      @signaled
+    end
+  end
+end

data/lib/resque/vendor/utf8_util.rb

@@ -7,7 +7,8 @@ module UTF8Util
   #
   # Returns self as valid UTF-8.
   def self.clean!(str)
-    raise NotImplementedError
+    return str if str.encoding.to_s == "UTF-8"
+    str.force_encoding("binary").encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => REPLACEMENT_CHAR)
   end
 
   # Replace invalid UTF-8 character sequences with a replacement character
@@ -16,11 +17,4 @@ module UTF8Util
   def self.clean(str)
     clean!(str.dup)
   end
-
-end
-
-if RUBY_VERSION <= '1.9'
-  require 'resque/vendor/utf8_util/utf8_util_18'
-else
-  require 'resque/vendor/utf8_util/utf8_util_19'
 end

data/lib/resque/version.rb

@@ -1,3 +1,3 @@
 module Resque
-  Version = VERSION = '1.23.0'
+  VERSION = '2.6.0'
 end