resque-restriction 0.1.0 → 0.2.0

data/.gitignore

@@ -1 +1,2 @@
 spec/dump.rdb
+pkg/**

data/README.markdown

@@ -9,18 +9,23 @@ Resque Restriction is a plugin for the [Resque][0] queueing system (http://githu
 
 Resque Restriction requires Resque 1.7.0.
 
+Install
+-------
+
+  sudo gem install resque-restriction
+
 To use
 ------
 
-The job you wish to restrict should inherit from Resque::Plugins::RestrictionJob class and add restrict definition. Example:
+It is especially useful when a system has an email invitation resque job, because sending emails too frequentyly will be treated as a spam. What you should do for the InvitationJob is to inherit it from Resque::Plugins::RestrictionJob class and add restrict definition. Example:
 
-	class MyRestrictionJob < Resque::Plugins::RestrictionJob
-	  restrict :per_day => 1000, :per_hour => 1000, :per_300 => 30
+	class InvitationJob < Resque::Plugins::RestrictionJob
+	  restrict :per_day => 1000, :per_hour => 100, :per_300 => 30
 
 	  #rest of your class here
 	end
 
-MyRestrictionJob can be run 1000 times per day, 100 times per hour and 30 times per 300 seconds.
+That means the InvitationJob can not be executed more than 1000 times per day, 100 times per hour and 30 times per 300 seconds.
 
 The argument of restrict method is a hash, the key of the hash is a period time, including :per_minute, :per_hour, :per_day, :per_week, :per_month, :per_year, and you can also define any period like :per_300 means per 300 seconds. the value of the hash is the job execution limit number in a period.
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/resque-restriction/job.rb

@@ -4,8 +4,8 @@ module Resque
       alias_method :origin_reserve, :reserve
       
       def reserve(queue)
-        if queue == 'restriction' && payload = Resque.peek(queue)
-          constantize(payload['class']).repush
+        if queue == 'restriction' && payload = Resque.pop(queue)
+          constantize(payload['class']).repush(*payload['args'])
           return
         end
         origin_reserve(queue)

data/lib/resque-restriction/restriction_job.rb

@@ -1,6 +1,6 @@
 module Resque
   module Plugins
-    class RestrictionJob
+    module Restriction
       SECONDS = {
         :per_minute => 60,
         :per_hour => 60*60,
@@ -10,77 +10,92 @@ module Resque
         :per_year => 366*24*60*60
       }
 
-      class <<self
-        def settings
-          @options ||= {}
-        end
+      def settings
+        @options ||= {}
+      end
 
-        def restrict(options={})
-          settings.merge!(options)
-        end
-        
-        def before_perform_restriction(*args)
-          settings.each do |period, number|
-            key = redis_key(period)
-            value = get_restrict(key)
+      def restrict(options={})
+        settings.merge!(options)
+      end
+
+      def before_perform_restriction(*args)
+        keys_decremented = []
+        settings.each do |period, number|
+          key = redis_key(period, *args)
+
+          # first try to set period key to be the total allowed for the period
+          # if we get a 0 result back, the key wasn't set, so we know we are
+          # already tracking the count for that period'
+          period_active = ! Resque.redis.setnx(key, number.to_i - 1)
 
-            if value.nil? or value == ""
-              set_restrict(key, seconds(period), number)
-            elsif value.to_i <= 0
+          # If we are already tracking that period, then decrement by one to
+          # see if we are allowed to run, pushing to restriction queue to run
+          # later if not.  Note that the value stored is the number of outstanding
+          # jobs allowed, thus we need to reincrement if the decr discovers that
+          # we have bypassed the limit
+          if period_active
+            value = Resque.redis.decrby(key, 1).to_i
+            keys_decremented << key
+            if value < 0
+              # reincrement the keys if one of the periods triggers DontPerform so
+              # that we accurately track capacity
+              keys_decremented.each {|k| Resque.redis.incrby(k, 1) }
               Resque.push "restriction", :class => to_s, :args => args
               raise Resque::Job::DontPerform
             end
           end
         end
-        
-        def after_perform_restriction(*args)
-          settings.each do |period, number|
-            key = redis_key(period)
-            Resque.redis.decrby(key, 1)
-          end
-        end
+      end
 
-        def redis_key(period)
-          period_str = case period
-                       when :per_minute, :per_hour, :per_day, :per_week then (Time.now.to_i / SECONDS[period]).to_s
-                       when :per_month then Date.today.strftime("%Y-%m")
-                       when :per_year then Date.today.year.to_s
-                       else period.to_s =~ /^per_(\d+)$/ and (Time.now.to_i / $1.to_i).to_s end
-          [self.to_s, period_str].compact.join(":")
+      def after_perform_restriction(*args)
+        if settings[:concurrent]
+          key = redis_key(:concurrent, *args)
+          Resque.redis.incrby(key, 1)
         end
+      end
 
-        def seconds(period)
-          if SECONDS.keys.include? period
-            SECONDS[period]
-          else
-            period.to_s =~ /^per_(\d+)$/ and $1
-          end
+      def redis_key(period, *args)
+        period_str = case period
+                     when :concurrent then "*"
+                     when :per_minute, :per_hour, :per_day, :per_week then (Time.now.to_i / SECONDS[period]).to_s
+                     when :per_month then Date.today.strftime("%Y-%m")
+                     when :per_year then Date.today.year.to_s
+                     else period.to_s =~ /^per_(\d+)$/ and (Time.now.to_i / $1.to_i).to_s end
+        [self.identifier(*args), period_str].compact.join(":")
+      end
+
+      def identifier(*args)
+        self.to_s
+      end
+
+      def seconds(period)
+        if SECONDS.keys.include? period
+          SECONDS[period]
+        else
+          period.to_s =~ /^per_(\d+)$/ and $1
         end
+      end
 
-        def repush
-          settings.each do |period, number|
-            key = redis_key(period)
-            value = get_restrict(key)
-            queue_name = Resque.queue_from_class(self)
-            if value.nil? or value == ""
-              Resque.redis.rpoplpush('queue:restriction', "queue:#{queue_name}")
-            end
-          end
+      def repush(*args)
+        no_restrictions = true
+        queue_name = Resque.queue_from_class(self)
+        settings.each do |period, number|
+          key = redis_key(period, *args)
+          value = Resque.redis.get(key)
+          no_restrictions &&= (value.nil? or value == "" or value.to_i > 0)
+        end
+        if no_restrictions
+          Resque.push queue_name, :class => to_s, :args => args
+        else
+          Resque.push "restriction", :class => to_s, :args => args
         end
+      end
 
-        private
-          # after operation incrby - expire, then decrby will reset the value to 0 first
-          # use operation set - expire - incrby instead
-          def set_restrict(key, seconds, number)
-            Resque.redis.set(key, '')
-            Resque.redis.expire(key, seconds)
-            Resque.redis.incrby(key, number)
-          end
+    end
 
-          def get_restrict(key)
-            Resque.redis.get(key)
-          end
-      end
+    class RestrictionJob
+      extend Restriction
     end
+
   end
 end

data/resque-restriction.gemspec

@@ -0,0 +1,61 @@
+# 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-restriction}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Richard Huang"]
+  s.date = %q{2010-06-29}
+  s.description = %q{resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time, the exceeded jobs will be executed at the next period.}
+  s.email = %q{flyerhzm@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/resque-restriction.rb",
+     "lib/resque-restriction/job.rb",
+     "lib/resque-restriction/restriction_job.rb",
+     "rails/init.rb",
+     "resque-restriction.gemspec",
+     "spec/redis-test.conf",
+     "spec/resque-restriction/job_spec.rb",
+     "spec/resque-restriction/restriction_job_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/flyerhzm/resque-restriction}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time.}
+  s.test_files = [
+    "spec/resque-restriction/job_spec.rb",
+     "spec/resque-restriction/restriction_job_spec.rb",
+     "spec/spec_helper.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<resque>, [">= 1.7.0"])
+    else
+      s.add_dependency(%q<resque>, [">= 1.7.0"])
+    end
+  else
+    s.add_dependency(%q<resque>, [">= 1.7.0"])
+  end
+end
+

data/spec/resque-restriction/job_spec.rb

@@ -1,17 +1,26 @@
 require File.join(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Resque::Job do
-  it "should repush restrictioin queue when reserve" do
+  it "should repush restriction queue when reserve" do
     Resque.redis.flushall
-    Resque.push('restriction', :class => 'OneHourRestrictionJob', :args => 'any args')
+    Resque.push('restriction', :class => 'OneHourRestrictionJob', :args => ['any args'])
     Resque::Job.reserve('restriction').should be_nil
-    Resque::Job.reserve('normal').should == Resque::Job.new('normal', {'class' => 'OneHourRestrictionJob', 'args' => 'any args'})
+    Resque::Job.reserve('normal').should == Resque::Job.new('normal', {'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
+    Resque::Job.reserve('normal').should be_nil
+  end
+
+  it "should push back to restriction queue when still restricted" do
+    Resque.redis.flushall
+    Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), -1)
+    Resque.push('restriction', :class => 'OneHourRestrictionJob', :args => ['any args'])
+    Resque::Job.reserve('restriction').should be_nil
+    Resque.pop('restriction').should == {'class' => 'OneHourRestrictionJob', 'args' => ['any args']}
     Resque::Job.reserve('normal').should be_nil
   end
 
   it "should not repush when reserve normal queue" do
-    Resque.push('normal', :class => 'OneHourRestrictionJob', :args => 'any args')
-    Resque::Job.reserve('normal').should == Resque::Job.new('normal', {'class' => 'OneHourRestrictionJob', 'args' => 'any args'})
+    Resque.push('normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
+    Resque::Job.reserve('normal').should == Resque::Job.new('normal', {'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
     Resque::Job.reserve('normal').should be_nil
   end
 end

data/spec/resque-restriction/restriction_job_spec.rb

@@ -42,6 +42,17 @@ describe Resque::Plugins::RestrictionJob do
       Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour)).should == "9"
     end
 
+    it "should use identifier to set exclusive execution counts" do
+      result = perform_job(IdentifiedRestrictionJob, 1)
+      result.should be_true
+      result = perform_job(IdentifiedRestrictionJob, 1)
+      result.should be_true
+      result = perform_job(IdentifiedRestrictionJob, 2)
+      result.should be_true
+      Resque.redis.get(IdentifiedRestrictionJob.redis_key(:per_hour, 1)).should == "8"
+      Resque.redis.get(IdentifiedRestrictionJob.redis_key(:per_hour, 2)).should == "9"
+    end
+
     it "should decrement execution number when one job executed" do
       Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), 6)
       result = perform_job(OneHourRestrictionJob, "any args")
@@ -49,7 +60,18 @@ describe Resque::Plugins::RestrictionJob do
       Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour)).should == "5"
     end
 
-    it "should put the job into restriction queue when execution count <= 0" do
+    it "should increment execution number when concurrent job completes" do
+      t = Thread.new do
+        result = perform_job(ConcurrentRestrictionJob, "any args")
+        result.should be_true
+      end
+      sleep 0.1
+      Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent)).should == "0"
+      t.join
+      Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent)).should == "1"
+    end
+
+    it "should put the job into restriction queue when execution count < 0" do
       Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), 0)
       result = perform_job(OneHourRestrictionJob, "any args")
       result.should_not be_true

data/spec/spec_helper.rb

@@ -28,7 +28,7 @@ at_exit do
   exit_code = Spec::Runner.run
 
   pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
-  puts "Killing test redis server..."
+  puts "Killing test redis server [#{pid}]..."
   `rm -f #{dir}/dump.rdb`
   Process.kill("KILL", pid.to_i)
   exit exit_code
@@ -66,6 +66,29 @@ class OneHourRestrictionJob < Resque::Plugins::RestrictionJob
   end
 end
 
+class IdentifiedRestrictionJob < Resque::Plugins::RestrictionJob
+  restrict :per_hour => 10
+
+  @queue = 'normal'
+
+  def self.identifier(*args)
+    [self.to_s, args.first].join(":")
+  end
+
+  def self.perform(*args)
+  end
+end
+
+class ConcurrentRestrictionJob < Resque::Plugins::RestrictionJob
+  restrict :concurrent => 1
+
+  @queue = 'normal'
+
+  def self.perform(*args)
+    sleep 0.2
+  end
+end
+
 class MultipleRestrictionJob < Resque::Plugins::RestrictionJob
   restrict :per_hour => 10, :per_300 => 2
 

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: resque-restriction
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Richard Huang
@@ -9,19 +14,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-30 00:00:00 -06:00
+date: 2010-06-29 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: resque
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 7
+        - 0
         version: 1.7.0
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time, the exceeded jobs will be executed at the next period.
 email: flyerhzm@gmail.com
 executables: []
@@ -42,6 +51,7 @@ files:
 - lib/resque-restriction/job.rb
 - lib/resque-restriction/restriction_job.rb
 - rails/init.rb
+- resque-restriction.gemspec
 - spec/redis-test.conf
 - spec/resque-restriction/job_spec.rb
 - spec/resque-restriction/restriction_job_spec.rb
@@ -60,18 +70,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time.