resque-concurrent-restriction 0.5.0

data/spec/spec.opts

@@ -0,0 +1,8 @@
+--colour
+--format
+specdoc
+--reverse
+--timeout
+20
+--loadby
+mtime

data/spec/spec_helper.rb

@@ -0,0 +1,153 @@
+require 'rspec'
+require 'ap'
+
+spec_dir = File.dirname(File.expand_path(__FILE__))
+REDIS_CMD = "redis-server #{spec_dir}/redis-test.conf"
+
+puts "Starting redis for testing at localhost:9736..."
+puts `cd #{spec_dir}; #{REDIS_CMD}`
+
+require 'resque'
+Resque.redis = 'localhost:9736'
+require 'resque-concurrent-restriction'
+
+# Schedule the redis server for shutdown when tests are all finished.
+at_exit do
+  pid = File.read("#{spec_dir}/redis.pid").to_i rescue nil
+  system ("kill -9 #{pid}") if pid != 0
+  File.delete("#{spec_dir}/redis.pid") rescue nil
+  File.delete("#{spec_dir}/redis-server.log") rescue nil
+  File.delete("#{spec_dir}/dump.rdb") rescue nil
+end
+
+
+##
+# Helper to perform job classes
+#
+module PerformJob
+
+  def run_resque_job(job_class, *job_args)
+    opts = job_args.last.is_a?(Hash) ? job_args.pop : {}
+    queue = opts[:queue] || Resque.queue_from_class(job_class)
+
+    Resque::Job.create(queue, job_class, *job_args)
+
+    run_resque_queue(queue, opts)
+  end
+
+  def run_resque_queue(queue, opts={})
+    worker = Resque::Worker.new(queue)
+    worker.very_verbose = true if opts[:verbose]
+
+    # do a single job then shutdown
+    def worker.done_working
+      super
+      shutdown
+    end
+
+    if opts[:inline]
+      job = worker.reserve
+      worker.perform(job)
+    else
+      worker.work(0)
+    end
+  end
+
+  def dump_redis
+    result = {}
+    Resque.redis.keys("*").each do |key|
+      type = Resque.redis.type(key)
+      result[key] = case type
+        when 'string' then Resque.redis.get(key)
+        when 'list' then Resque.redis.lrange(key, 0, -1)
+        when 'set' then Resque.redis.smembers(key)
+        else type
+      end
+    end
+    return result
+  end
+
+end
+
+module RunCountHelper
+
+  def around_perform(*args)
+    begin
+      Resque.redis.set("restricted_job_started:#{self}:#{args.to_json}", true)
+      Resque.redis.incr("restricted_job_run_count:#{self}:#{args.to_json}")
+      yield
+    ensure
+      Resque.redis.set("restricted_job_ended:#{self}:#{args.to_json}", true)
+    end
+  end
+
+  def perform(*args)
+    #puts "Running job #{self}:#{args}"
+  end
+
+  def run_count(*args)
+    Resque.redis.get("restricted_job_run_count:#{self}:#{args.to_json}").to_i
+  end
+
+  def total_run_count
+    keys = Resque.redis.keys("restricted_job_run_count:#{self}:*")
+    keys.inject(0) {|sum, k| sum + Resque.redis.get(k).to_i }
+  end
+
+  def started?(*args)
+    return Resque.redis.get("restricted_job_started#{self}:#{args.to_json}") == true
+  end
+
+  def ended?(*args)
+    return Resque.redis.get("restricted_job_ended#{self}:#{args.to_json}") == true
+  end
+end
+
+class NoRestrictionJob
+  extend RunCountHelper
+  @queue = 'normal'
+end
+
+class RestrictionJob
+  extend RunCountHelper
+  extend Resque::Plugins::ConcurrentRestriction
+  concurrent 1
+  @queue = 'normal'
+end
+
+class IdentifiedRestrictionJob
+  extend RunCountHelper
+  extend Resque::Plugins::ConcurrentRestriction
+  concurrent 1
+  @queue = 'normal'
+
+  def self.concurrent_identifier(*args)
+    args.first.to_s
+  end
+
+end
+
+class ConcurrentRestrictionJob
+  extend RunCountHelper
+  extend Resque::Plugins::ConcurrentRestriction
+  concurrent 1
+
+  @queue = 'normal'
+
+  def self.perform(*args)
+    raise args.first if args.first
+    sleep 0.2
+  end
+end
+
+class MultipleConcurrentRestrictionJob
+  extend RunCountHelper
+  extend Resque::Plugins::ConcurrentRestriction
+  concurrent 4
+
+  @queue = 'normal'
+
+  def self.perform(*args)
+    sleep 0.5
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: resque-concurrent-restriction
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Matt Conway
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-08 00:00:00 -04: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 
+        version: "1.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 
+        version: "2.5"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: awesome_print
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: A resque plugin for limiting how many of a specific job can run concurrently
+email: 
+- matt@conwaysplace.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/resque-concurrent-restriction.rb
+- lib/resque/plugins/concurrent_restriction/concurrent_restriction_job.rb
+- lib/resque/plugins/concurrent_restriction/resque_worker_extension.rb
+- lib/resque/plugins/concurrent_restriction/version.rb
+- resque-concurrent-restriction.gemspec
+- spec/concurrent_restriction_job_spec.rb
+- spec/redis-test.conf
+- spec/resque_worker_extensions_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/wr0ngway/resque-concurrent-restriction
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: resque-concurrent-restriction
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: A resque plugin for limiting how many of a specific job can run concurrently
+test_files: 
+- spec/concurrent_restriction_job_spec.rb
+- spec/redis-test.conf
+- spec/resque_worker_extensions_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb