resque-pause 0.0.2

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+coverage/*
+.rvmrc
+.project

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in resque-pause.gemspec
+gemspec
+
+group :test, :development do
+  platforms :mri_18 do
+    gem "ruby-debug"
+  end
+
+  platforms :mri_19 do
+    gem "ruby-debug19", :require => 'ruby-debug' if RUBY_VERSION < "1.9.3"
+  end
+end

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    resque-pause (0.0.2)
+      resque (>= 1.9.10)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.3)
+    diff-lcs (1.1.2)
+    json_pure (1.4.6)
+    linecache (0.46)
+      rbx-require-relative (> 0.0.4)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    rack (1.3.0)
+    rack-test (0.6.0)
+      rack (>= 1.0)
+    rbx-require-relative (0.0.5)
+    redis (2.2.1)
+    redis-namespace (0.8.0)
+      redis (< 3.0.0)
+    resque (1.9.10)
+      json_pure (~> 1.4.0)
+      redis-namespace (~> 0.8.0)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    simplecov (0.4.2)
+      simplecov-html (~> 0.4.4)
+    simplecov-html (0.4.5)
+    sinatra (1.2.6)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    tilt (1.3.2)
+    vegas (0.1.8)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rack-test
+  resque (>= 1.9.10)
+  resque-pause!
+  rspec (>= 2.3.0)
+  ruby-debug
+  ruby-debug19
+  simplecov (>= 0.4.2)

data/README.md

@@ -0,0 +1,77 @@
+Resque Pause
+============
+
+A [Resque][rq] plugin. Requires Resque 1.9.10.
+
+resque-pause adds functionality to pause resque jobs through the web interface.
+
+Using a `pause` allows you to stop the job for a slice of time.
+The job finish the process it are doing and don't get a new task to do,
+until the queue is released.
+You can use this functionality to do some maintenance whithout kill workers, for example.
+
+Usage / Examples
+----------------
+
+### Single Job Instance
+
+    require 'resque-pause'
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::Pause
+      @queue = :network_graph
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+Pause is achieved by storing a pause/queue key in Redis.
+
+Default behaviour...
+
+* When the job instance try to execute and the queue is paused, the job is paused for a slice of time.
+* If the queue still paused after this time the job will abort and will be enqueued again with the same arguments.
+
+
+Resque-Web integration
+----------------------
+
+You have to load ResquePause to enable the Pause tab.
+
+```ruby
+    require 'resque_pause'
+```
+
+Customise & Extend
+==================
+
+### Job pause check interval
+
+The slice of time the job will wait for queue be unpaused before abort the job
+could be changed with attribute @pause_check_interval.
+
+By default the time is 10 seconds.
+
+You can define the attribute in your job class in seconds.
+
+    class UpdateNetworkGraph
+      extend Resque::Plugins::Pause
+      @queue = :network_graph
+      @pause_check_interval = 30
+
+      def self.perform(repo_id)
+        heavy_lifting
+      end
+    end
+
+The above modification will ensure the job will wait for 30 seconds before abort.
+
+
+Install
+=======
+
+    $ gem install resque-pause
+
+[rq]: http://github.com/defunkt/resque
+[resque-pause]: https://github.com/wandenberg/resque-pause

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec)

data/lib/resque-pause.rb

@@ -0,0 +1,3 @@
+require 'resque'
+require File.expand_path(File.join('resque_pause_helper'), File.dirname(__FILE__))
+require File.expand_path(File.join('resque', 'plugins', 'pause'), File.dirname(__FILE__))

data/lib/resque/plugins/pause.rb

@@ -0,0 +1,15 @@
+module Resque
+  module Plugins
+    module Pause
+      include Resque::Helpers
+      PAUSE_CHECK_INTERVAL = 10 #seconds to wait when queue is paused
+
+      def before_perform_pause(*args)
+        if ResquePauseHelper.paused?(@queue)
+          Kernel.sleep(@pause_check_interval || Resque::Plugins::Pause::PAUSE_CHECK_INTERVAL)
+          ResquePauseHelper.check_paused(:queue => @queue, :class => self, :args => args)
+        end
+      end
+    end
+  end
+end

data/lib/resque_pause.rb

@@ -0,0 +1,4 @@
+require 'resque'
+require 'resque/server'
+require File.expand_path(File.join('resque_pause_helper'), File.dirname(__FILE__))
+require File.expand_path(File.join('resque_pause', 'server'), File.dirname(__FILE__))

data/lib/resque_pause/server.rb

@@ -0,0 +1,56 @@
+# Extends Resque Web Based UI.
+# Structure has been borrowed from ResqueScheduler.
+module ResquePause
+  module Server
+    include Resque::Helpers
+
+    def self.erb_path(filename)
+      File.join(File.dirname(__FILE__), 'server', 'views', filename)
+    end
+
+    def self.public_path(filename)
+      File.join(File.dirname(__FILE__), 'server', 'public', filename)
+    end
+
+    def self.included(base)
+
+      base.class_eval do
+
+        helpers do
+          def paused?(queue)
+            ResquePauseHelper.paused?(queue)
+          end
+        end
+
+        mime_type :json, 'application/json'
+
+        get '/pause' do
+          erb File.read(ResquePause::Server.erb_path('pause.erb'))
+        end
+
+        post '/pause' do
+          ResquePauseHelper.pause(params['queue_name']) unless params['queue_name'].empty?
+          content_type :json
+          encode(:queue_name => params['queue_name'], :paused => true)
+        end
+
+        post '/unpause' do
+          ResquePauseHelper.unpause(params['queue_name']) unless params['queue_name'].empty?
+          content_type :json
+          encode(:queue_name => params['queue_name'], :paused => false)
+        end
+
+        get /pause\/public\/([a-z]+\.[a-z]+)/ do
+          send_file ResquePause::Server.public_path(params[:captures].first)
+        end
+      end
+    end
+
+    Resque::Server.tabs << 'Pause'
+  end
+end
+
+Resque.extend ResquePause
+Resque::Server.class_eval do
+  include ResquePause::Server
+end

data/lib/resque_pause/server/public/pause.js

@@ -0,0 +1,18 @@
+jQuery(document).ready(function($) {
+	$('input:checkbox.pause').click( function(){
+		var queue = $(this);
+		var data = {'queue_name': queue.val()};
+		var url = queue.is(':checked') ? '/pause' : '/unpause';
+		$.ajax({
+		  type: 'POST',
+		  url: url,
+		  data: data,
+		  async: false,
+		  cache: false,
+		  success: function() { return true; },
+		  error: function() { return false; },
+		  dataType: 'json'
+		});
+
+	});
+});

data/lib/resque_pause/server/views/pause.erb

@@ -0,0 +1,18 @@
+<script src="<%=u '/pause/public/pause.js' %>" type="text/javascript"></script>
+
+<h1 class='wi'>Queues</h1>
+<p class='intro'>The list below contains all the registered queues with the status if is paused or not. Select a queue from above to pause processing jobs.</p>
+<table class='queues1'>
+  <tr>
+    <th>Name</th>
+    <th>Paused</th>
+    <th>Jobs</th>
+  </tr>
+  <% for queue in resque.queues.sort_by { |q| q.to_s } %>
+  <tr>
+    <td class='queue'><%= queue %></td>
+    <td class='status'><input class="pause" type="checkbox" value="<%= queue%>" <%= "checked" if paused?(queue) %>></input></td>
+    <td class='size'><%= resque.size queue %></td>
+  </tr>
+  <% end %>
+</table>

data/lib/resque_pause_helper.rb

@@ -0,0 +1,30 @@
+module ResquePauseHelper
+  class << self
+    def paused?(queue)
+      !Resque.redis.get("pause:queue:#{queue}").nil?
+    end
+
+    def pause(queue)
+      Resque.redis.set "pause:queue:#{queue}", true
+    end
+
+    def unpause(queue)
+      Resque.redis.del "pause:queue:#{queue}"
+    end
+
+    def enqueue_job(args)
+      Resque.redis.lpush("queue:#{args[:queue]}", Resque.encode(:class => args[:class], :args => args[:args]))
+    end
+
+    def dequeue_job(args)
+      Resque.redis.lpop("queue:#{args[:queue]}")
+    end
+
+    def check_paused(args)
+      if ResquePauseHelper.paused?(args[:queue])
+        enqueue_job(args)
+        raise Resque::Job::DontPerform.new "Queue #{args[:queue]} is paused!"
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,7 @@
+module Resque
+  module Plugins
+    module Pause
+      VERSION = "0.0.2"
+    end
+  end
+end

data/resque-pause.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name        = "resque-pause"
+  s.version     = Resque::Plugins::Pause::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Wandenberg Peixoto"]
+  s.email       = ["wandenberg@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A Resque plugin to add functionality to pause resque jobs through the web interface.}
+  s.description = %q{A Resque plugin to add functionality to pause resque jobs through the web interface.
+
+Using a `pause` allows you to stop the job for a slice of time.
+The job finish the process it are doing and don't get a new task to do,
+until the queue is released.
+You can use this functionality to do some maintenance whithout kill workers, for example.}
+
+  s.rubyforge_project = "resque-pause"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.has_rdoc      = false
+
+  s.add_dependency('resque', '>= 1.9.10')
+
+  s.add_development_dependency('rspec', '>= 2.3.0')
+  s.add_development_dependency('rack-test')
+  s.add_development_dependency('simplecov', '>= 0.4.2')
+
+end

data/spec/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 ./spec/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 ./spec/
+
+# 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/spec/resque-web_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe ResquePause::Server do
+  include Rack::Test::Methods
+  def app
+    @app ||= Resque::Server.new
+  end
+
+  let :queues do
+    Resque.redis.sadd(:queues, "queue1")
+    Resque.redis.sadd(:queues, "queue2")
+    Resque.redis.sadd(:queues, "queue3")
+  end
+
+  before do
+    queues
+  end
+
+  it "should respond to /pause" do
+    get '/pause'
+    last_response.should be_ok
+  end
+
+  it "should list all registered queues" do
+    get '/pause'
+    last_response.body.should include("queue1")
+    last_response.body.should include("queue2")
+    last_response.body.should include("queue3")
+  end
+
+  it "should check paused queues" do
+    ResquePauseHelper.pause("queue2")
+
+    get '/pause'
+    last_response.body.should include(%q{<input class="pause" type="checkbox" value="queue1" ></input>})
+    last_response.body.should include(%q{<input class="pause" type="checkbox" value="queue2" checked></input>})
+    last_response.body.should include(%q{<input class="pause" type="checkbox" value="queue3" ></input>})
+  end
+
+
+  it "should pause a queue" do
+    post "/pause", :queue_name => "queue3"
+
+    ResquePauseHelper.paused?("queue3").should be_true
+  end
+
+  it "should return a json when pause a queue" do
+    post "/pause", :queue_name => "queue3"
+
+    last_response.headers["Content-Type"].should == "application/json"
+    last_response.body.should == { :queue_name => "queue3", :paused => true }.to_json
+  end
+
+  it "should unpause a queue" do
+    ResquePauseHelper.pause("queue2")
+    post "/unpause", :queue_name => "queue2"
+
+    ResquePauseHelper.paused?("queue2").should be_false
+  end
+
+  it "should return a json when unpause a queue" do
+    post "/unpause", :queue_name => "queue2"
+
+    last_response.headers["Content-Type"].should == "application/json"
+    last_response.body.should == { :queue_name => "queue2", :paused => false }.to_json
+  end
+
+  it "should return static files" do
+    get "/pause/public/pause.js"
+    last_response.body.should == File.read(File.expand_path('../lib/resque_pause/server/public/pause.js', File.dirname(__FILE__)))
+  end
+
+end

data/spec/resque/plugins/pause_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+class PauseJob
+  extend Resque::Plugins::Pause
+  @queue = :test
+
+  def self.perform(*args)
+  end
+end
+
+describe Resque::Plugins::Pause do
+  it "should be compliance with Resqu::Plugin document" do
+    expect { Resque::Plugin.lint(Resque::Plugins::Pause) }.to_not raise_error
+  end
+
+  it "should use at least resque version 1.8.0" do
+    major, minor, patch = Resque::Version.split('.')
+    major.to_i.should == 1
+    minor.to_i.should >= 8
+  end
+
+  it "should execute the job when queue is not paused" do
+    Resque.enqueue(PauseJob)
+    PauseJob.should_receive(:perform)
+
+    Resque.reserve('test').perform
+  end
+
+  it "should not execute the job when queue is paused" do
+    ResquePauseHelper.pause('test')
+    Resque.enqueue(PauseJob)
+    PauseJob.should_not_receive(:perform)
+
+    Resque.reserve('test').perform
+  end
+
+  it "should not change queued jobs when queue is paused" do
+    ResquePauseHelper.pause('test')
+    Resque.enqueue(PauseJob, 1)
+    Resque.enqueue(PauseJob, 2)
+    Resque.enqueue(PauseJob, 3)
+    jobs = Resque.redis.lrange('queue:test', 0, 2)
+
+    Resque.reserve('test').perform
+
+    remaining_jobs = Resque.redis.lrange('queue:test', 0, 2)
+    jobs.should == remaining_jobs
+  end
+
+  it "should back to execute the job when queue is unpaused" do
+    Resque.enqueue(PauseJob)
+
+    ResquePauseHelper.pause('test')
+    Resque.reserve('test').perform
+    Resque.size('test').should == 1
+
+    ResquePauseHelper.unpause('test')
+    Resque.reserve('test').perform
+    Resque.size('test').should == 0
+  end
+
+end

data/spec/resque_pause_helper_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+class PauseJob
+  @queue = :test
+
+  def self.perform(*args)
+  end
+end
+
+describe ResquePauseHelper do
+
+  context "when check queue status" do
+    it "should return return false if don't have register on redis" do
+      Resque.redis.del "pause:queue:queue1"
+
+      subject.paused?("queue1").should be_false
+    end
+
+    it "should return return true if have register on redis" do
+      Resque.redis.set "pause:queue:queue1", "AnyValue"
+
+      subject.paused?("queue1").should be_true
+    end
+  end
+
+  context "when pause a queue" do
+    it "should register a unregistred queue" do
+      Resque.redis.del "pause:queue:queue1"
+      subject.pause("queue1")
+
+      subject.paused?("queue1").should be_true
+    end
+
+    it "should register again a registred queue" do
+      Resque.redis.set "pause:queue:queue1", "AnyValue"
+      expect { subject.pause("queue1") }.to_not raise_error
+
+      Resque.redis.get("pause:queue:queue1").should_not be_nil
+      Resque.redis.get("pause:queue:queue1").should be_true
+    end
+  end
+
+  context "when unpause a queue" do
+    it "should unregister a unregistred queue" do
+      Resque.redis.del "pause:queue:queue1"
+      subject.unpause("queue1")
+
+      subject.paused?("queue1").should be_false
+    end
+
+    it "should unregister a registred queue" do
+      Resque.redis.set "pause:queue:queue1", "AnyValue"
+      expect { subject.unpause("queue1") }.to_not raise_error
+
+      Resque.redis.get("pause:queue:queue1").should be_nil
+    end
+  end
+
+  context "when enqueue a job" do
+    it "should enqueue on a empty queue" do
+      Resque.redis.del "queue:queue1"
+
+      subject.enqueue_job(:queue => "queue1", :class => PauseJob, :args => nil)
+
+      Resque.redis.llen("queue:queue1").to_i.should == 1
+    end
+
+    it "should enqueue on beginning of a queue" do
+      Resque.redis.lpush "queue:queue1", {:class => PauseJob, :args => [1, 2]}.to_json
+
+      subject.enqueue_job(:queue => "queue1", :class => PauseJob, :args => [1])
+
+      jobs = Resque.redis.lrange('queue:queue1', 0, 10)
+
+      jobs.count.should == 2
+      jobs[0].should == {:class => PauseJob, :args => [1]}.to_json
+      jobs[1].should == {:class => PauseJob, :args => [1, 2]}.to_json
+    end
+  end
+
+  context "when dequeue a job" do
+    it "should not get error when queue is empty" do
+      Resque.redis.del "queue:queue1"
+
+      expect { subject.dequeue_job(:queue => "queue1") }.to_not raise_error
+
+      subject.dequeue_job(:queue => "queue1").should be_nil
+    end
+
+    it "should get the job on beginning of a queue" do
+      Resque.redis.lpush "queue:queue1", {:class => PauseJob, :args => [1, 2]}.to_json
+      Resque.redis.lpush "queue:queue1", {:class => PauseJob, :args => [1]}.to_json
+
+      job = subject.dequeue_job(:queue => "queue1")
+      job.should == {:class => PauseJob, :args => [1]}.to_json
+    end
+  end
+
+  context "when checking if queue is paused" do
+    it "should check if queue is paused" do
+      subject.should_receive(:paused?).with("queue1")
+
+      subject.check_paused(:queue => "queue1")
+    end
+
+    it "should not raise error when queue is not paused" do
+      subject.should_receive(:paused?).with("queue1").and_return(false)
+
+      expect { subject.check_paused(:queue => "queue1") }.to_not raise_error
+    end
+
+    it "should raise error when queue is paused" do
+      subject.stub!(:enqueue_job)
+      subject.stub!(:paused?).with("queue1").and_return(true)
+
+      expect { subject.check_paused(:queue => "queue1") }.to raise_error(Resque::Job::DontPerform)
+    end
+
+    it "should enqueue the job again when queue is paused" do
+      subject.stub!(:paused?).with("queue1").and_return(true)
+
+      args = {:queue => "queue1", :class => PauseJob, :args => [1, 2]}
+      subject.should_receive(:enqueue_job).with(args)
+
+      subject.check_paused(args) rescue nil
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,65 @@
+require 'rack/test'
+
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  abort ''
+end
+
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+  SimpleCov.coverage_dir 'coverage'
+rescue LoadError
+  # ignore simplecov in ruby < 1.9
+end
+
+begin
+  require 'bundler'
+  Bundler.setup
+  Bundler.require(:default, :development)
+rescue LoadError
+  puts 'Bundler is not installed, you need to gem install it in order to run the specs.'
+  exit 1
+end
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir[File.expand_path('support/**/*.rb', File.dirname(__FILE__))].each { |f| require f }
+
+# Requires lib.
+Dir[File.expand_path('../lib/**/*.rb', File.dirname(__FILE__))].each { |f| require f }
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  config.before(:suite) do
+    puts "Starting redis for testing at localhost:9736..."
+    `redis-server #{File.dirname(File.expand_path(__FILE__))}/redis-test.conf`
+    pid = ''
+    while pid.empty? do
+      pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
+    end
+    Resque.redis = '127.0.0.1:9736'
+  end
+
+  config.before(:each) do
+    Resque.redis.flushall
+    Kernel.stub!(:sleep)
+  end
+
+  config.after(:suite) do
+    pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
+    puts '', "Killing test redis server..."
+    Process.kill("KILL", pid.to_i)
+    `rm -f #{File.dirname(File.expand_path(__FILE__))}/dump.rdb`
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification 
+name: resque-pause
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Wandenberg Peixoto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-27 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: resque
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 9
+        - 10
+        version: 1.9.10
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 2
+        version: 0.4.2
+  type: :development
+  version_requirements: *id004
+description: |-
+  A Resque plugin to add functionality to pause resque jobs through the web interface.
+  
+  Using a `pause` allows you to stop the job for a slice of time.
+  The job finish the process it are doing and don't get a new task to do,
+  until the queue is released.
+  You can use this functionality to do some maintenance whithout kill workers, for example.
+email: 
+- wandenberg@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/resque-pause.rb
+- lib/resque/plugins/pause.rb
+- lib/resque_pause.rb
+- lib/resque_pause/server.rb
+- lib/resque_pause/server/public/pause.js
+- lib/resque_pause/server/views/pause.erb
+- lib/resque_pause_helper.rb
+- lib/version.rb
+- resque-pause.gemspec
+- spec/redis-test.conf
+- spec/resque-web_spec.rb
+- spec/resque/plugins/pause_spec.rb
+- spec/resque_pause_helper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: resque-pause
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Resque plugin to add functionality to pause resque jobs through the web interface.
+test_files: []
+