kthxbye 1.0.0

data/lib/kthxbye/web_interface/views/working.haml

@@ -0,0 +1,19 @@
+%h2 Active Workers
+
+- unless Kthxbye.working.empty?
+  %table
+    %th Worker
+    %th Job
+    %th Time Started
+    - Kthxbye.working.each do |worker,job|
+      %tr
+        %td #{worker}
+        %td #{job['job_id']}
+        %td #{job['started']}
+- else
+  %span{:style => "color:red"}
+    Currently no active workers.
+
+%p
+  = toggle_poll
+

data/lib/kthxbye/worker.rb

@@ -0,0 +1,221 @@
+module Kthxbye
+  class Worker
+    include Helper
+    extend Helper
+
+    attr_accessor :sleep_for, :queues, :current_queue, :id
+
+    def initialize(queues, sleep_for=5)
+      setup_queues(queues)
+      @sleep_for = sleep_for
+    end
+
+    def setup_queues(queues) 
+      if queues == "*"
+        @queues = Kthxbye.queues.sort
+      elsif queues.include? ?,
+        @queues = queues.split(",").compact
+      else
+        @queues = *queues
+      end
+    end
+
+    def self.find(worker)
+      if exists? worker
+        qs = worker.split(':')[-1].split(",")
+        new_worker = new(*qs)
+        new_worker.id = worker
+        return new_worker
+      else
+        nil
+      end
+    end
+
+    def self.exists?(id)
+      redis.sismember( :workers, id )
+    end
+
+    # gets the job a given worker is working on
+    # returns a hash with the 'job_id' and the 'started' time
+    def self.working_on(id)
+      decode( redis.get( "worker:#{id}" ) )
+    end
+
+    # major run loop. workhorse of a worker... sort of.
+    # in the end, this loop simply runs the jobs in separate
+    # processes by forking out the process then waiting for it
+    # to return. we only process one 
+    def run(&block)
+      log "Starting Kthxbye::Worker #{self}"
+      startup
+      
+      loop do
+        break if @terminate
+
+        if !@paused and job = grab_job
+          log "Found job #{job}"
+          working(job)
+
+          @child = fork {
+            log "Forking..."
+            result = job.perform
+            yield job if block_given?
+            exit!
+          }
+
+          Process.wait
+          done
+        else
+          break if @sleep_for == 0
+          log "No jobs on #{@queues} - sleeping for #{@sleep_for}"
+          sleep sleep_for.to_i
+        end
+      end 
+    ensure
+      unregister_worker
+    end
+
+    def queues
+      @queues.sort
+    end
+
+    # startup actions
+    def startup
+      register_worker
+      register_signals
+    end
+
+    # adds worker to the workers list
+    def register_worker
+      log "Registered worker #{self}"
+      redis.sadd( :workers, self ) if !exists?
+    end
+
+    # removes the worker from our workers list
+    def unregister_worker
+      log "Unregistered worker #{self}"
+      if working?
+        log "Was active. Reporting and rerunning"
+        Failure.create(current_job, ActiveWorkerKilled.new) 
+        current_job.rerun
+      end
+
+      redis.del "worker:#{self}"
+      redis.srem :workers, self
+    end
+    
+    def current_job
+      return @current_job if @current_job
+      data = decode( redis.get("worker:#{self}") )
+      @current_job = Job.find( data['job_id'], @current_queue )
+    end
+
+    # start working actions
+    def working(job)
+      redis.sadd( :working, self )
+
+      data = encode( {:job_id => job.id, :started => Time.now.to_s} )
+      redis.set("worker:#{self}", data)
+      @current_job = job
+
+      # activates job
+      job.active
+    end
+
+    # must be in working list and have a current job
+    def working? 
+      redis.sismember( :working, self )
+    end
+
+    # job complete actions
+    def done
+      redis.srem( :working, self )
+      redis.del( "worker:#{self}" )
+      log "Completed job #{@current_job}"
+      @current_job = nil
+    end
+
+    #
+    # thanks to http://github.com/defunkt/resque/blob/master/lib/resque/worker.rb for these signals
+    #
+    def register_signals
+      trap('TERM') { shutdown! }
+      trap('INT')  { shutdown! }
+
+      begin
+        trap('QUIT') { shutdown }   
+        trap('USR1') { shutdown }
+        trap('USR2') { log "Paused"; @paused = true }
+        trap('CONT') { log "Unpaused"; @paused = false }
+      rescue ArgumentError
+        warn "Signals QUIT, USR1, USR2, and/or CONT not supported."
+      end 
+
+      log "Registered signals"
+    end 
+
+    def shutdown
+      log "Shutting down worker #{self}"
+      @terminate = true
+    end
+
+    def shutdown!
+      kill_child
+      shutdown
+    end
+
+    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
+
+    def grab_job
+      job = nil
+      @queues.each do |q|
+        @current_queue = q
+        log "Checking \"#{q}\" queue for jobs"
+        job = Kthxbye.salvage(q)
+        break unless job.nil?
+      end
+
+      return job || false
+    end
+
+    def exists?
+      redis.sismember( :workers, self )
+    end
+
+    def hostname
+      @hostname ||= `hostname`.chomp
+    end
+
+    def pid
+      Process.pid
+    end
+
+    def id
+      @id ||= "#{hostname}:#{pid}:#{queues.join(",")}"
+    end
+    alias_method :to_s, :id
+
+    def inspect
+      "#<Worker: #{@id}>"
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'kthxbye'
+
+class Test::Unit::TestCase
+end

data/test/redis-test.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9876
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/test/test_failure.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class TestFailure < Test::Unit::TestCase
+  context "See Kthxbye Failures" do
+    setup do
+      Kthxbye.redis.flushall
+    end
+
+    should "create a failure" do
+      id = Kthxbye.enqueue("test", SimpleJob, 1, 2)
+      assert Kthxbye::Failure.create(Kthxbye::Job.find(id, "test"), Exception.new("Test!"))
+
+      assert_not_nil f = Kthxbye::Failure.all.first
+      assert_equal "Exception", f['type']
+      assert_equal "Test!", f['error']
+      assert_equal id, f['job']
+    end
+
+    should "insert and clear an exception" do 
+      id = Kthxbye.enqueue("test", SimpleJob, 1, 2)
+      Kthxbye::Failure.create(Kthxbye::Job.find(id, "test"), Exception.new("Test!"))
+      
+
+      assert_equal 1, Kthxbye::Failure.all.size
+      assert Kthxbye::Failure.clear_exception(id)
+      assert_equal 0, Kthxbye::Failure.all.size
+    end
+
+    should "retry a job that failed" do
+      id = Kthxbye.enqueue("test", BadJob)
+      worker = Kthxbye::Worker.new("test", 0)
+      worker.run
+
+      assert_equal 1, Kthxbye::Failure.all.size
+      assert_equal 1, Kthxbye::Failure.find(id)['attempts']
+
+      Kthxbye::Job.find(id, "test").rerun
+      assert_equal 1, Kthxbye.size("test")
+      worker.run do
+        assert_equal Kthxbye::Job.find(id, "test"), worker.current_job
+      end
+
+      # note, we only store one error for a job failure. we will increment the failure count
+      assert_equal 1, Kthxbye::Failure.all.size
+      assert_equal 2, Kthxbye::Failure.find(id)['attempts']
+      
+    end
+
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,86 @@
+#
+# setup code used and modified from http://github.com/defunkt/resque/blob/master/test/test_helper.rb
+#
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'kthxbye'
+
+dir = File.dirname(File.expand_path(__FILE__))
+require 'test/unit'
+require 'rubygems'
+
+
+# make sure we can run redis
+#
+
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  puts "** try running `sudo rake install`"
+  abort ''
+end
+
+
+#
+# start our own redis when the tests start,
+# kill it when they end
+#
+
+at_exit do
+  next if $!
+
+  if defined?(MiniTest)
+    exit_code = MiniTest::Unit.new.run(ARGV)
+  else
+    exit_code = Test::Unit::AutoRunner.run
+  end 
+
+  pid = `ps -A -o pid,command | grep [r]edis-test`.split(" ")[0]
+  puts "Killing test redis server..."
+  `rm -f #{dir}/dump.rdb`
+  Process.kill("KILL", pid.to_i)
+  exit exit_code
+end
+
+puts "Starting redis for testing at localhost:9876..."
+`redis-server #{dir}/redis-test.conf`
+
+class SimpleJob
+  def self.perform(p1, p2)
+  end
+end
+
+class SomeQueueJob < SimpleJob
+  @queue = :test
+end
+
+class BadJob
+  def self.perform
+    raise "Bad job!"
+  end
+end
+
+class GoodJob
+  def self.perform(name)
+    "Good job, #{name}"
+  end
+end
+
+class LongJob
+  def self.perform(data)
+    sleep 10 
+    puts "I just slept for 10 seconds with #{data} keeping me company"
+    data.gsub(" ", "_")
+  end
+end
+
+
+class BadJobWithSyntaxError
+  def self.perform
+    raise SyntaxError, "Extra Bad job!"
+  end
+end
+