resque-status 0.1.0

data/resque-status.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{resque-status}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Quint"]
+  s.date = %q{2010-01-19}
+  s.description = %q{resque-status is an extension to the resque queue system that provides simple trackable jobs. It provides a Resque::Status class which can set/get the statuses of jobs and a Resque::JobWithStatus class that when subclassed provides easily trackable/killable jobs.}
+  s.email = %q{aaron@quirkey.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "examples/sleep_job.rb",
+     "init.rb",
+     "lib/resque/job_with_status.rb",
+     "lib/resque/server/views/status.erb",
+     "lib/resque/server/views/status_styles.erb",
+     "lib/resque/server/views/statuses.erb",
+     "lib/resque/status.rb",
+     "lib/resque/status_server.rb",
+     "resque-status.gemspec",
+     "test/redis-test.conf",
+     "test/test_helper.rb",
+     "test/test_resque-job_with_status.rb",
+     "test/test_resque-status.rb"
+  ]
+  s.homepage = %q{http://github.com/quirkey/resque-status}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{quirkey}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{resque-status is an extension to the resque queue system that provides simple trackable jobs.}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/test_resque-job_with_status.rb",
+     "test/test_resque-status.rb",
+     "examples/sleep_job.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<uuid>, [">= 2.0.2"])
+      s.add_runtime_dependency(%q<resque>, [">= 1.3.1"])
+      s.add_runtime_dependency(%q<redisk>, [">= 0.2.0"])
+      s.add_development_dependency(%q<shoulda>, [">= 2.10.2"])
+    else
+      s.add_dependency(%q<uuid>, [">= 2.0.2"])
+      s.add_dependency(%q<resque>, [">= 1.3.1"])
+      s.add_dependency(%q<redisk>, [">= 0.2.0"])
+      s.add_dependency(%q<shoulda>, [">= 2.10.2"])
+    end
+  else
+    s.add_dependency(%q<uuid>, [">= 2.0.2"])
+    s.add_dependency(%q<resque>, [">= 1.3.1"])
+    s.add_dependency(%q<redisk>, [">= 0.2.0"])
+    s.add_dependency(%q<shoulda>, [">= 2.10.2"])
+  end
+end
+

data/test/redis-test.conf

@@ -0,0 +1,132 @@
+# 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 9736
+
+# 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
+
+# Use object sharing. Can save a lot of memory if you have many common
+# string in your dataset, but performs lookups against the shared objects
+# pool so it uses more CPU and can be a bit slower. Usually it's a good
+# idea.
+#
+# When object sharing is enabled (shareobjects yes) you can use
+# shareobjectspoolsize to control the size of the pool used in order to try
+# object sharing. A bigger pool size will lead to better sharing capabilities.
+# In general you want this value to be at least the double of the number of
+# very common strings you have in your dataset.
+#
+# WARNING: object sharing is experimental, don't enable this feature
+# in production before of Redis 1.0-stable. Still please try this feature in
+# your development environment so that we can test it better.
+shareobjects no
+shareobjectspoolsize 1024

data/test/test_helper.rb

@@ -0,0 +1,82 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+$TESTING = true
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+require 'mocha'
+
+require 'resque/status'
+require 'resque/job_with_status'
+
+class Test::Unit::TestCase
+end
+
+#
+# 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 -e -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:9736..."
+`redis-server #{dir}/redis-test.conf`
+Resque.redis = 'localhost:9736'
+
+
+#### Fixtures
+
+class WorkingJob < Resque::JobWithStatus
+
+  def perform
+    total = options['num']
+    (1..total).each do |num|
+      at(num, total, "At #{num}")
+    end
+  end
+
+end
+
+class ErrorJob < Resque::JobWithStatus
+
+  def perform
+    raise "I'm a bad little job"
+  end
+
+end
+
+class KillableJob < Resque::JobWithStatus
+
+  def perform
+    Resque.redis.set("#{uuid}:iterations", 0)
+    100.times do |num|
+      Resque.redis.incr("#{uuid}:iterations")
+      at(num, 100, "At #{num} of 100")
+    end
+  end
+
+end

data/test/test_resque-job_with_status.rb

@@ -0,0 +1,180 @@
+require 'test_helper'
+
+class TestResqueJobWithStatus < Test::Unit::TestCase
+  
+  context "Resque::JobWithStatus" do
+    setup do
+      Resque.redis.flush_all
+    end
+    
+    context ".create" do
+      setup do
+        @uuid = WorkingJob.create('num' => 100)
+      end
+      
+      should "add the job to the queue" do
+        assert_equal 1, Resque.size(:statused)
+      end
+      
+      should "set the queued object to the current class" do
+        job = Resque.pop(:statused)
+        assert_equal @uuid, job['args'].first
+        assert_equal "WorkingJob", job['class']
+      end
+      
+      should "add the uuid to the statuses" do
+        assert_contains Resque::Status.status_ids, @uuid
+      end
+      
+      should "return a UUID" do
+        assert_match(/^\w{32}$/, @uuid)
+      end
+      
+    end
+    
+    context ".enqueue" do
+      setup do
+        @uuid = Resque::JobWithStatus.enqueue(WorkingJob, :num => 100)
+        @payload = Resque.pop(:statused)
+      end
+      
+      should "add the job with the specific class to the queue" do
+        assert_equal "WorkingJob", @payload['class']
+      end
+      
+      should "add the arguments to the options hash" do
+        assert_equal @uuid, @payload['args'].first
+      end
+      
+      should "add the uuid to the statuses" do
+        assert_contains Resque::Status.status_ids, @uuid
+      end
+      
+      should "return UUID" do
+        assert_match(/^\w{32}$/, @uuid)
+      end
+      
+    end
+    
+    context ".perform" do
+      setup do
+        @uuid      = WorkingJob.create(:num => 100)
+        @payload   = Resque.pop(:statused)
+        @performed = WorkingJob.perform(*@payload['args'])
+      end
+      
+      should "load load a new instance of the klass" do
+        assert @performed.is_a?(WorkingJob)
+      end
+      
+      should "set the uuid" do
+        assert_equal @uuid, @performed.uuid
+      end
+      
+      should "set the status" do
+        assert @performed.status.is_a?(Resque::Status)
+        assert_equal 'WorkingJob', @performed.status.name
+      end
+      
+      before_should "call perform on the inherited class" do
+        WorkingJob.any_instance.expects(:perform).once
+      end
+      
+    end
+    
+    context "killing a job" do
+      setup do
+        @uuid      = KillableJob.create(:num => 100)
+        @payload   = Resque.pop(:statused)
+        Resque::Status.kill(@uuid)
+        assert_contains Resque::Status.kill_ids, @uuid
+        @performed = KillableJob.perform(*@payload['args'])
+        @status = Resque::Status.get(@uuid)
+      end
+      
+      should "set the status to killed" do
+        assert_equal 'killed', @status.status
+        assert @status.killed?
+        assert !@status.completed?
+      end
+      
+      should "only perform iterations up to kill" do
+        assert_equal 1, Resque.redis.get("#{@uuid}:iterations").to_i
+      end
+      
+      should "not persist the kill key" do
+        assert_does_not_contain Resque::Status.kill_ids, @uuid
+      end
+    end
+    
+    context "with an invoked job" do
+      setup do
+        @job = WorkingJob.new('123', {'num' => 100})
+      end
+            
+      context "#at" do
+        setup do
+          @job.at(50, 100, "At 50%")
+        end
+        
+        should "calculate percent" do
+          assert_equal 50, @job.status.pct_complete
+        end
+        
+        should "set status" do
+          assert_equal 'working', @job.status.status
+        end
+        
+        should "save message" do
+          assert_equal "At 50%", @job.status.message
+        end
+      end
+      
+      context "#failed" do
+        setup do
+          @job.failed("OOOOPS!")
+        end
+        
+        should "set status" do
+          assert_equal 'failed', @job.status.status
+        end
+        
+        should "set message" do
+          assert_equal "OOOOPS!", @job.status.message
+        end
+      end
+      
+      context "#completed" do
+        setup do
+          @job.completed
+        end
+        
+        should "set status" do
+          assert_equal 'completed', @job.status.status
+        end
+        
+        should "set message" do
+          assert_match(/complete/i, @job.status.message)
+        end
+        
+      end
+      
+      context "#safe_perform!" do
+        setup do
+          @job = ErrorJob.new("123")
+          assert_raises(RuntimeError) do
+            @job.safe_perform!
+          end
+        end
+                
+        should "set status as failed" do
+          assert_equal 'failed', @job.status.status
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end