nfo-resque-mongo 1.15.0

data/lib/resque/server.rb

@@ -0,0 +1,222 @@
+require 'sinatra/base'
+require 'erb'
+require 'resque'
+require 'resque/version'
+
+module Resque
+  class Server < Sinatra::Base
+    dir = File.dirname(File.expand_path(__FILE__))
+
+    set :views,  "#{dir}/server/views"
+    set :public, "#{dir}/server/public"
+    set :static, true
+
+    helpers do
+      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)
+        [ 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}'>#{name}</a></li>"
+      end
+
+      def tabs
+        Resque::Server.tabs
+      end
+
+      def redis_get_size(key)
+        case Resque.redis.type(key)
+        when 'none'
+          []
+        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 '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 { |a| a.inspect }.join("\n")
+      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 @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
+
+    end
+
+    def show(page, layout = true)
+      begin
+        erb page.to_sym, {:layout => layout}, :resque => Resque
+      rescue Errno::ECONNREFUSED
+        erb :error, {:layout => false}, :error => "Can't connect to Mongo!"
+      end
+    end
+
+    # to make things easier on ourselves
+    get "/?" do
+      redirect url_path(:overview)
+    end
+
+    %w( overview queues working workers key ).each do |page|
+      get "/#{page}" do
+        show page
+      end
+
+      get "/#{page}/:id" do
+        show page
+      end
+    end
+
+    post "/queues/:id/remove" do
+      Resque.remove_queue(params[:id])
+      redirect u('queues')
+    end
+
+    %w( overview workers ).each do |page|
+      get "/#{page}.poll" do
+        content_type "text/html"
+        @polling = true
+        show(page.to_sym, false).gsub(/\s{1,}/, ' ')
+      end
+    end
+
+    get "/failed" do
+      if Resque::Failure.url
+        redirect Resque::Failure.url
+      else
+        show :failed
+      end
+    end
+    
+    post "/failed/clear" do
+      Resque::Failure.clear
+      redirect u('failed')
+    end
+
+    get "/failed/requeue/:index" do
+      Resque::Failure.requeue(params[:index])
+      if request.xhr?
+        return Resque::Failure.all(params[:index])['retried_at']
+      else
+        redirect u('failed')
+      end
+    end
+
+    get "/failed/remove/:index" do
+      Resque::Failure.remove(params[:index])
+      redirect u('failed')
+    end
+
+    get "/stats" do
+      redirect url_path("/stats/resque")
+    end
+
+    get "/stats/:id" do
+      show :stats
+    end
+
+    get "/stats/keys/:key" do
+      show :stats
+    end
+
+    get "/stats.txt" do
+      info = Resque.info
+
+      stats = []
+      stats << "resque.servers=#{info[:servers].inspect}"
+      stats << "resque.pending=#{info[:pending]}"
+      stats << "resque.processed+=#{info[:processed]}"
+      stats << "resque.failed+=#{info[:failed]}"
+      stats << "resque.workers=#{info[:workers]}"
+      stats << "resque.working=#{info[:working]}"
+
+      Resque.queues.each do |queue|
+        stats << "queues.#{queue}=#{Resque.size(queue)}"
+      end
+
+      content_type 'text/html'
+      stats.join "\n"
+    end
+
+    def resque
+      Resque
+    end
+
+    def self.tabs
+      @tabs ||= ["Overview", "Working", "Failed", "Queues", "Workers", "Stats"]
+    end
+  end
+end

data/lib/resque/stat.rb

@@ -0,0 +1,55 @@
+module Resque
+  # The stat subsystem. Used to keep track of integer counts.
+  #
+  #   Get a stat:  Stat[name]
+  #   Incr a stat: Stat.incr(name)
+  #   Decr a stat: Stat.decr(name)
+  #   Kill a stat: Stat.clear(name)
+  module Stat
+    extend self
+    extend Helpers
+
+    # Returns the int value of a stat, given a string stat name.
+    def get(stat)
+      res = mongo_stats.find_one(:stat => stat)
+      return 0 unless res
+      res['value'].to_i
+    end
+
+    # Alias of `get`
+    def [](stat)
+      get(stat)
+    end
+
+    # For a string stat name, increments the stat by one.
+    #
+    # Can optionally accept a second int parameter. The stat is then
+    # incremented by that amount.
+    def incr(stat, by = 1)
+      mongo_stats.update({:stat => stat}, {'$inc' => {:value => by}}, :upsert => true)
+    end
+
+    # Increments a stat by one.
+    def <<(stat)
+      incr stat
+    end
+
+    # For a string stat name, decrements the stat by one.
+    #
+    # Can optionally accept a second int parameter. The stat is then
+    # decremented by that amount.
+    def decr(stat, by = 1)
+      mongo_stats.update({:stat => stat}, {'$inc' => {:value => -by}})
+    end
+
+    # Decrements a stat by one.
+    def >>(stat)
+      decr stat
+    end
+
+    # Removes a stat from Redis, effectively setting it to 0.
+    def clear(stat)
+      mongo_stats.remove(:stat => stat)
+    end
+  end
+end

data/lib/resque/tasks.rb

@@ -0,0 +1,42 @@
+# require 'resque/tasks'
+# will give you the resque tasks
+
+namespace :resque do
+  task :setup
+
+  desc "Start a Resque worker"
+  task :work => :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']
+    rescue Resque::NoQueueError
+      abort "set QUEUE env var, e.g. $ QUEUE=critical,high rake resque:work"
+    end
+
+    if ENV['PIDFILE']
+      File.open(ENV['PIDFILE'], 'w') { |f| f << worker.pid }
+    end
+
+    worker.log "Starting worker #{worker}"
+
+    worker.work(ENV['INTERVAL'] || 5) # interval, will block
+  end
+
+  desc "Start multiple Resque workers. Should only be used in dev mode."
+  task :workers do
+    threads = []
+
+    ENV['COUNT'].to_i.times do
+      threads << Thread.new do
+        system "rake resque:work"
+      end
+    end
+
+    threads.each { |thread| thread.join }
+  end
+end

data/lib/resque/version.rb

@@ -0,0 +1,3 @@
+module Resque
+  Version = VERSION = '1.15.0'
+end

data/lib/resque/worker.rb

@@ -0,0 +1,524 @@
+module Resque
+  # A Resque Worker processes jobs. On platforms that support fork(2),
+  # the worker will fork off a child to process each job. This ensures
+  # a clean slate when beginning the next job and cuts down on gradual
+  # memory growth as well as low level failures.
+  #
+  # It also ensures workers are always listening to signals from you,
+  # their master, and can react accordingly.
+  class Worker
+    include Resque::Helpers
+    extend Resque::Helpers
+
+    # Whether the worker should log basic info to STDOUT
+    attr_accessor :verbose
+
+    # Whether the worker should log lots of info to STDOUT
+    attr_accessor  :very_verbose
+
+    # Boolean indicating whether this worker can or can not fork.
+    # Automatically set if a fork(2) fails.
+    attr_accessor :cant_fork
+
+    attr_writer :to_s
+
+    attr_accessor :job
+    
+    # Returns an array of all worker objects.
+    def self.all
+      mongo_workers.distinct(:worker).map { |w| queues = w.split(','); worker = new(*queues); worker.to_s = w; worker }.compact
+    end
+
+    # Returns an array of all worker objects currently processing
+    # jobs.
+    def self.working
+      select = {'working_on' => { '$exists' => true }}
+      # select['working_on'] = {"$exists" => true}
+      working = mongo_workers.find(select).to_a
+      # working.map! {|w| w['worker'] }
+      working.map do |w|
+        queues = w['worker'].split(',')
+        worker = new(*queues)
+        worker.to_s = w['worker']
+        worker.job = w['working_on'] || {}
+        worker 
+      end
+    end
+
+    # Returns a single worker object. Accepts a string id.
+    def self.find(worker_id)
+      w = mongo_workers.find_one(:worker => worker_id)
+      return nil unless w
+      queues = w['worker'].split(',')
+      worker = new(*queues)
+      worker.job = w['working_on'] || {} ## avoid a new call to mongo just to retrieve what's this worker is doing
+      worker.to_s = worker_id
+      worker
+    end
+
+    # Alias of `find`
+    def self.attach(worker_id)
+      find(worker_id)
+    end
+
+    # # Given a string worker id, return a boolean indicating whether the
+    # # worker exists
+    def self.exists?(worker_id)
+      not mongo_workers.find_one(:worker => worker_id.to_s).nil?
+    end
+
+    # Workers should be initialized with an array of string queue
+    # names. The order is important: a Worker will check the first
+    # queue given for a job. If none is found, it will check the
+    # second queue name given. If a job is found, it will be
+    # processed. Upon completion, the Worker will again check the
+    # first queue given, and so forth. In this way the queue list
+    # passed to a Worker on startup defines the priorities of queues.
+    #
+    # If passed a single "*", this Worker will operate on all queues
+    # in alphabetical order. Queues can be dynamically added or
+    # removed without needing to restart workers using this method.
+    def initialize(*queues)
+      @queues = queues.map { |queue| queue.to_s.strip }
+      validate_queues
+    end
+
+    # A worker must be given a queue, otherwise it won't know what to
+    # do with itself.
+    #
+    # You probably never need to call this.
+    def validate_queues
+      if @queues.nil? || @queues.empty?
+        raise NoQueueError.new("Please give each worker at least one queue.")
+      end
+    end
+
+    # This is the main workhorse method. Called on a Worker instance,
+    # it begins the worker life cycle.
+    #
+    # The following events occur during a worker's life cycle:
+    #
+    # 1. Startup:   Signals are registered, dead workers are pruned,
+    #               and this worker is registered.
+    # 2. Work loop: Jobs are pulled from a queue and processed.
+    # 3. Teardown:  This worker is unregistered.
+    #
+    # Can be passed a float representing the polling frequency.
+    # The default is 5 seconds, but for a semi-active site you may
+    # want to use a smaller value.
+    #
+    # Also accepts a block which will be passed the job as soon as it
+    # has completed processing. Useful for testing.
+    def work(interval = 5.0, &block)
+      interval = Float(interval)
+      $0 = "resque: Starting"
+      job_count = 0
+      startup
+      loop do
+        break if shutdown?
+
+        if not @paused and job = reserve
+          log "got: #{job.inspect}"
+          run_hook :before_fork, job
+          working_on job
+
+          if @child = fork
+            rand # Reseeding
+            procline "Forked #{@child} at #{Time.now.to_s}"
+            Process.wait
+          else
+            procline "Processing #{job.queue} since #{Time.now.to_s} (#{job_count} so far)"
+            perform(job, &block)
+            job_count += 1
+            exit! unless @cant_fork
+          end
+
+          done_working
+          @child = nil
+        else
+          break if interval.zero?
+          log! "Sleeping for #{interval} seconds"
+          procline @paused ? "Paused" : "Waiting for #{@queues.join(',')}"
+          sleep interval
+        end
+      end
+
+    ensure
+      unregister_worker
+    end
+
+    # DEPRECATED. Processes a single job. If none is given, it will
+    # try to produce one. Usually run in the child.
+    def process(j = nil, &block)
+      return unless j ||= reserve
+      working_on j
+      perform(j, &block)
+    ensure
+      done_working
+    end
+
+    # Processes a given job in the child.
+    def perform(job)
+      begin
+        run_hook :after_fork, job
+        job.perform
+      rescue Object => e
+        log "#{job.inspect} failed: #{e.inspect}"
+        begin
+          job.fail(e)
+        rescue Object => e
+          log "Received exception when reporting failure: #{e.inspect}"
+        end
+        failed!
+      else
+        log "done: #{job.inspect}"
+      ensure
+        yield job if block_given?
+      end
+    end
+
+    # Attempts to grab a job off one of the provided queues. Returns
+    # nil if no job can be found.
+    def reserve
+      queues.each do |queue|
+        log! "Checking #{queue}"
+        if j = Resque::Job.reserve(queue)
+          log! "Found job on #{queue}"
+          return j
+        end
+      end
+
+      nil
+    rescue Exception => e
+      log "Error reserving job: #{e.inspect}"
+      log e.backtrace.join("\n")
+      raise e
+    end
+
+    # Returns a list of queues to use when searching for a job.
+    # A splat ("*") means you want every queue (in alpha order) - this
+    # can be useful for dynamically adding new queues.
+    def queues
+      @queues[0] == "*" ? Resque.queues.sort : Resque.queues(@queues).sort
+    end
+
+    # Not every platform supports fork. Here we do our magic to
+    # determine if yours does.
+    def fork
+      @cant_fork = true if $TESTING
+
+      return if @cant_fork
+
+      begin
+        # IronRuby doesn't support `Kernel.fork` yet
+        if Kernel.respond_to?(:fork)
+          Kernel.fork
+        else
+          raise NotImplementedError
+        end
+      rescue NotImplementedError
+        @cant_fork = true
+        nil
+      end
+    end
+
+    # Runs all the methods needed when a worker begins its lifecycle.
+    def startup
+      enable_gc_optimizations
+      register_signal_handlers
+      prune_dead_workers
+      run_hook :before_first_fork
+      register_worker
+
+      # Fix buffering so we can `rake resque:work > resque.log` and
+      # get output from the child in there.
+      $stdout.sync = true
+    end
+
+    # Enables GC Optimizations if you're running REE.
+    # http://www.rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+    def enable_gc_optimizations
+      if GC.respond_to?(:copy_on_write_friendly=)
+        GC.copy_on_write_friendly = true
+      end
+    end
+
+    # Registers the various signal handlers a worker responds to.
+    #
+    # TERM: Shutdown immediately, stop processing jobs.
+    #  INT: Shutdown immediately, stop processing jobs.
+    # QUIT: Shutdown after the current job has finished processing.
+    # USR1: Kill the forked child immediately, continue processing jobs.
+    # USR2: Don't process any new jobs
+    # CONT: Start processing jobs again after a USR2
+    def register_signal_handlers
+      trap('TERM') { shutdown!  }
+      trap('INT')  { shutdown!  }
+
+      begin
+        trap('QUIT') { shutdown   }
+        trap('USR1') { kill_child }
+        trap('USR2') { pause_processing }
+        trap('CONT') { unpause_processing }
+      rescue ArgumentError
+        warn "Signals QUIT, USR1, USR2, and/or CONT not supported."
+      end
+
+      log! "Registered signals"
+    end
+
+    # Schedule this worker for shutdown. Will finish processing the
+    # current job.
+    def shutdown
+      log 'Exiting...'
+      @shutdown = true
+    end
+
+    # Kill the child and shutdown immediately.
+    def shutdown!
+      shutdown
+      kill_child
+    end
+
+    # Should this worker shutdown as soon as current job is finished?
+    def shutdown?
+      @shutdown
+    end
+
+    # Kills the forked child immediately, without remorse. The job it
+    # is processing will not be completed.
+    def kill_child
+      if @child
+        log! "Killing child at #{@child}"
+        if system("ps -o pid,state -p #{@child}")
+          Process.kill("KILL", @child) rescue nil
+        else
+          log! "Child #{@child} not found, restarting."
+          shutdown
+        end
+      end
+    end
+
+    # Stop processing jobs after the current one has completed (if we're
+    # currently running one).
+    def pause_processing
+      log "USR2 received; pausing job processing"
+      @paused = true
+    end
+
+    # Start processing jobs again after a pause
+    def unpause_processing
+      log "CONT received; resuming job processing"
+      @paused = false
+    end
+
+    # Looks for any workers which should be running on this server
+    # and, if they're not, removes them from Redis.
+    #
+    # This is a form of garbage collection. If a server is killed by a
+    # hard shutdown, power failure, or something else beyond our
+    # control, the Resque workers will not die gracefully and therefore
+    # will leave stale state information in Redis.
+    #
+    # By checking the current Redis state against the actual
+    # environment, we can determine if Redis is old and clean it up a bit.
+    def prune_dead_workers
+      all_workers = Worker.all
+      known_workers = worker_pids unless all_workers.empty?
+      all_workers.each do |worker|
+        host, pid, queues = worker.to_s.split(':')
+        next unless host == hostname
+        next if known_workers.include?(pid)
+        log! "Pruning dead worker: #{worker}"
+        worker.unregister_worker
+      end
+    end
+
+    # Registers ourself as a worker. Useful when entering the worker
+    # lifecycle on startup.
+    def register_worker
+      mongo_workers.insert(:worker => self.to_s)
+      started!
+    end
+
+    # Runs a named hook, passing along any arguments.
+    def run_hook(name, *args)
+      return unless hook = Resque.send(name)
+      msg = "Running #{name} hook"
+      msg << " with #{args.inspect}" if args.any?
+      log msg
+
+      args.any? ? hook.call(*args) : hook.call
+    end
+
+    # Unregisters ourself as a worker. Useful when shutting down.
+    def unregister_worker
+      # If we're still processing a job, make sure it gets logged as a
+      # failure.
+      if (hash = processing) && !hash.empty?
+        j = Job.new(hash[:queue], hash[:payload])
+        # Ensure the proper worker is attached to this job, even if
+        # it's not the precise instance that died.
+        j.worker = self
+        j.fail(DirtyExit.new)
+      end
+
+      mongo_workers.remove(:worker => self.to_s)
+
+      Stat.clear("processed:#{self}")
+      Stat.clear("failed:#{self}")
+    end
+
+    def check_payload(payload)
+      case payload.class.to_s
+      when 'Class'
+        payload.to_s
+      when 'Array'
+        payload.map { |e| check_payload(e) }
+      when 'Hash'
+        result = {}
+        payload.each { |k,v| result[k] = check_payload(v) }
+        result
+      else
+        return payload
+      end
+    end
+      
+    # Given a job, tells Redis we're working on it. Useful for seeing
+    # what workers are doing and when.
+    def working_on(j)
+      j.worker = self
+      data = {
+        'queue'   => j.queue,
+        'run_at'  => Time.now.to_s,
+        'payload' => check_payload(j.payload)
+      }
+      @job = data
+      working_on = {'working_on' => data}
+      mongo_workers.update({:worker => self.to_s},  {'$set' => working_on}, :upsert => true )
+    end
+
+    # Called when we are done working - clears our `working_on` state
+    # and tells Redis we processed a job.
+    def done_working
+      @job = {}
+      working_on = {'working_on' => 1}
+      mongo_workers.update({:worker =>  self.to_s}, {'$unset' => working_on})      
+      processed!
+    end
+
+    # How many jobs has this worker processed? Returns an int.
+    def processed
+      Stat["processed:#{self}"]
+    end
+
+    # Tell Redis we've processed a job.
+    def processed!
+      Stat << "processed"
+      Stat << "processed:#{self}"
+    end
+
+    # How many failed jobs has this worker seen? Returns an int.
+    def failed
+      Stat["failed:#{self}"]
+    end
+
+    # Tells Redis we've failed a job.
+    def failed!
+      Stat << "failed"
+      Stat << "failed:#{self}"
+    end
+
+    # What time did this worker start? Returns an instance of `Time`
+    def started
+      worker = mongo_workers.find_one(:worker => self.to_s)
+      return nil if !worker
+      worker['started']
+    end
+
+    # Tell Redis we've started
+    def started!
+      started = {'started' => Time.now }
+      mongo_workers.update({:worker => self.to_s},  {'$set' => started})
+    end
+
+    # Returns a hash explaining the Job we're currently processing, if any.
+    def processing
+      job || {} 
+    end
+    
+    # Boolean - true if working, false if not
+    def working?
+      state == :working
+    end
+
+    # Boolean - true if idle, false if not
+    def idle?
+      state == :idle
+    end
+
+    # Returns a symbol representing the current worker state,
+    # which can be either :working or :idle
+    def state
+      worker = mongo_workers.find_one(:worker => self.to_s)
+      worker ? :working : :idle
+    end
+
+    # Is this worker the same as another worker?
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    def inspect
+      "#<Worker #{to_s}>"
+    end
+
+    # The string representation is the same as the id for this worker
+    # instance. Can be used with `Worker.find`.
+    def to_s
+      @to_s ||= "#{hostname}:#{Process.pid}:#{@queues.join(',')}"
+    end
+    alias_method :worker_id, :to_s
+
+    # chomp'd hostname of this machine
+    def hostname
+      @hostname ||= `hostname`.chomp
+    end
+
+    # Returns Integer PID of running worker
+    def pid
+      @pid ||= to_s.split(":")[1].to_i
+    end
+
+    # Returns an array of string pids of all the other workers on this
+    # machine. Useful when pruning dead workers on startup.
+    def worker_pids
+      `ps -A -o pid,command | grep [r]esque | grep -v "resque-web"`.split("\n").map do |line|
+        line.split(' ')[0]
+      end
+    end
+
+    # Given a string, sets the procline ($0) and logs.
+    # Procline is always in the format of:
+    #   resque-VERSION: STRING
+    def procline(string)
+      $0 = "resque-#{Resque::Version}: #{string}"
+      log! $0
+    end
+
+    # Log a message to STDOUT if we are verbose or very_verbose.
+    def log(message)
+      if verbose
+        puts "*** #{message}"
+      elsif very_verbose
+        time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
+        puts "** [#{time}] #$$: #{message}"
+      end
+    end
+
+    # Logs a very verbose message to STDOUT.
+    def log!(message)
+      log message if very_verbose
+    end
+  end
+end