resque-restriction 0.4.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9262042b42b7838c1b204a900d56f13263afb3d5
-  data.tar.gz: 3fd139447714181f6b99a7f2ad484a5ad70461c9
+SHA256:
+  metadata.gz: 681852b48ac3fb45d6a5d1806af5617d6c4c566ee6483c777d1e7d1e837443ba
+  data.tar.gz: '0706749a9fc0beb80cb532a84e5988157055759b0151e48b1a08d2fa8c515b21'
 SHA512:
-  metadata.gz: 3058d61e4310002f6d2e5f6c5f85c6e7b830507138852e8fdfbc99d5a2f68b8467d63df2ea8a516cec09100e3cc00db1a13ad7e5a1976bec199b1516fc00ddff
-  data.tar.gz: 74d9ddcb8677d8c0ea764d8b9bae61e702aabec26e548e83546725a6cac5f38afdba12dbd3f9b3660e3052dfaca51117827cf88a892ccadf5de0f0f354b3f5ec
+  metadata.gz: 2015e5527ba932161e0cdfbf20efb102214403232f5595f496571df3b8964d5157bef27fa21e3feb2363f89fbf502576c8b13596b9322ef61873861669c71a32
+  data.tar.gz: b7fce8d53acc85f50d6c21626b03e7aed86a5f04d0cd01f3a40301ff2534ae149bf3caf7cd53a5e093765a25d233c06ff6819f733f7fcc502a7586d1ac940ec9

data/.gitignore

@@ -0,0 +1,7 @@
+spec/dump.rdb
+pkg/**
+.idea
+.rvmrc
+spec/stdout
+.rspec_status
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.3
+before_install: gem install bundler -v 1.16.0

data/CHANGELOG.md

@@ -1,7 +1,22 @@
 ### Unreleased
 
+# 0.7.0 (2021-06-06)
+
+* Support `per_second`
+* Reduce Redis thrashing on large restriction queues
+
+# 0.6.0
+
+* support customized period like `per_minute_and_user_id`
+* prepend restriction to `cache_key`
+
+# 0.5.0
+
+* drop activejob support
+* reorganize file structure
+
 # 0.4.0
 * release for Rails>=4.2 with ActiveJob
 
 # 0.3.0
-* release for Rails<4.2
+* release for Rails<4.2

data/README.md

@@ -0,0 +1,112 @@
+resque-restriction
+===============
+
+[![AwesomeCode Status for flyerhzm/resque-restriction](https://awesomecode.io/projects/ebc1a493-78f5-4d8a-9bb7-097fdaa657ec/status)](https://awesomecode.io/repos/flyerhzm/resque-restriction)
+[![Build Status](https://secure.travis-ci.org/flyerhzm/resque-restriction.png)](http://travis-ci.org/flyerhzm/resque-restriction)
+
+Resque Restriction is a plugin for the [Resque](https://github.com/resque/resque) queueing system. It adds two functions:
+
+1. it will limit the execution number of certain jobs in a period time. For example, it can limit a certain job can be executed 1000 times per day, 100 time per hour and 30 times per 300 seconds.
+
+2. it will execute the exceeded jobs at the next period. For example, you restrict the email sending jobs to run 1000 times per day. If your system generates 1010 email sending jobs, only 1000 email sending jobs can be executed today, and the other 10 email sending jobs will be executed tomorrow.
+
+Resque Restriction requires Resque 1.7.0.
+
+*Please make sure your workers are checking restriction_xxx queue.*.
+e.g., if you add restriction plugin to high_priority queue, you need to
+check restriction_high_priority queue.
+
+Attention
+---------
+
+The `identifier` method is renamed to `restriction_identifier` to solve the confliction with resque-retry from version 0.3.0.
+
+Install
+-------
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'resque-restriction'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install resque-restriction
+
+To use
+------
+
+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:
+
+```ruby
+class InvitationJob
+  extend Resque::Plugins::Restriction
+
+  restrict :per_day => 1000, :per_hour => 100, :per_300 => 30
+
+  # rest of your class here
+end
+```
+
+That means the InvitationJob can not be executed more than 1000 times per day, 100 times per hour and 30 times per 300 seconds.  All restrictions have to be met for the job to execute.
+
+The argument of restrict method is a hash, the key of the hash is a period time, including :concurrent, :per_second, :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.  The :concurrent option restricts the number of jobs that run simultaneously.
+
+Advance
+-------
+
+### Custom Restrictions
+
+You can also add customized restriction as you like. For example, we have a job to restrict the facebook post numbers 40 times per user per day, we can define as:
+
+
+```ruby
+class GenerateFacebookShares
+  extend Resque::Plugins::Restriction
+
+  restrict :per_day_and_user_id => 40
+
+  # rest of your class here
+  def self.perform(options)
+    # options["user_id"] exists
+  end
+end
+```
+
+```ruby
+class GenerateFacebookShares
+  extend Resque::Plugins::Restriction
+
+  restrict :per_day => 40
+
+  def self.restriction_identifier(options)
+    [self.to_s, options["user_id"]].join(":")
+  end
+
+  # rest of your class here
+end
+```
+
+options["user_id"] returns the user's facebook uid, the key point is that the different restriction_identifiers can restrict different job execution numbers.
+
+### Reducing Redis Thrashing
+
+With large restriction queues (1,000+ jobs), Redis is hit with a large number of `Resque.pop` and re-enqueue calls which puts the job immediately back into the restriction queue. That process translates to extraneous Redis requests.
+
+To avoid the extraneous Redis calls, configure `max_queue_peek`. An appropriate `max_queue_peek` value depends on your application, number of workers, job processing time, and peek jobs in the queue. By default `max_queue_peek` is disabled.
+
+```ruby
+Resque::Restriction.configure do |config|
+  config.max_queue_peek = 100 # jobs
+end
+```
+
+Contributing
+------------
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/flyerhzm/resque-restriction.

data/Rakefile

@@ -1,22 +1,6 @@
-require 'rake'
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "resque-restriction"
-    gemspec.summary = "resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time."
-    gemspec.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."
-    gemspec.email = "flyerhzm@gmail.com"
-    gemspec.homepage = "http://github.com/flyerhzm/resque-restriction"
-    gemspec.authors = ["Richard Huang"]
-    gemspec.add_dependency "resque", ">=1.7.0"
-  end
-  Jeweler::GemcutterTasks.new
-rescue
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
+task default: :spec

data/lib/{resque-restriction → resque/plugins}/job.rb

@@ -7,8 +7,8 @@ module Resque
         if queue =~ /^#{Plugins::Restriction::RESTRICTION_QUEUE_PREFIX}/
           # If processing the restriction queue, when poping and pushing to end,
           # we can't tell when we reach the original one, so just walk the length
-          # of the queue so we don't run infinitely long
-          Resque.size(queue).times do |i|
+          # of the queue or up to max_queue_peek so we don't run infinitely long
+          [Resque.size(queue), Restriction.config.max_queue_peek(queue)].compact.min.times do
             # For the job at the head of the queue, repush to restricition queue
             # if still restricted, otherwise we have a runnable job, so create it
             # and return
@@ -19,7 +19,7 @@ module Resque
               end
             end
           end
-          return nil
+          nil
         else
           # drop through to original Job::Reserve if not restriction queue
           origin_reserve(queue)

data/lib/{resque-restriction/restriction_job.rb → resque/plugins/restriction.rb}

@@ -1,10 +1,8 @@
-require 'active_job'
-
 module Resque
   module Plugins
-
     module Restriction
       SECONDS = {
+        :per_second => 1,
         :per_minute => 60,
         :per_hour => 60*60,
         :per_day => 24*60*60,
@@ -23,6 +21,8 @@ module Resque
       end
 
       def before_perform_restriction(*args)
+        return if Resque.inline?
+
         keys_decremented = []
         settings.each do |period, number|
           key = redis_key(period, *args)
@@ -65,25 +65,32 @@ module Resque
       end
 
       def redis_key(period, *args)
-        period_str = case period
+        period_key, custom_key = period.to_s.split('_and_')
+        period_str = case period_key.to_sym
                      when :concurrent then "*"
-                     when :per_minute, :per_hour, :per_day, :per_week then (Time.now.to_i / SECONDS[period]).to_s
+                     when :per_second, :per_minute, :per_hour, :per_day, :per_week then (Time.now.to_i / SECONDS[period_key.to_sym]).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.restriction_identifier(*args), period_str].compact.join(":")
+                     else period_key =~ /^per_(\d+)$/ and (Time.now.to_i / $1.to_i).to_s end
+        custom_value = (custom_key && args.first && args.first.is_a?(Hash)) ? args.first[custom_key] : nil
+        [RESTRICTION_QUEUE_PREFIX, self.restriction_identifier(*args), custom_value, period_str].compact.join(":")
       end
 
       def restriction_identifier(*args)
         self.to_s
       end
 
+      def restriction_queue_name
+        queue_name = Resque.queue_from_class(self)
+        "#{RESTRICTION_QUEUE_PREFIX}_#{queue_name}"
+      end
 
       def seconds(period)
-        if SECONDS.keys.include? period
-          SECONDS[period]
+        period_key, _ = period.to_s.split('_and_')
+        if SECONDS.keys.include?(period_key.to_sym)
+          SECONDS[period_key.to_sym]
         else
-          period.to_s =~ /^per_(\d+)$/ and $1.to_i
+          period_key =~ /^per_(\d+)$/ and $1.to_i
         end
       end
 
@@ -111,26 +118,5 @@ module Resque
         Resque.redis.expire(key, seconds(period)) unless period == :concurrent
       end
     end
-
-    class RestrictionJob < ActiveJob::Base
-      extend Restriction
-
-      before_perform do |job|
-        self.class.before_perform_restriction(*job.arguments)
-      end
-
-      after_perform do |job|
-        self.class.after_perform_restriction(*job.arguments)
-      end
-
-      rescue_from(StandardError) do |err|
-        self.class.on_failure_restriction(err, *self.arguments)
-      end
-
-      def self.restriction_queue_name
-        queue_name = self.new.queue_name
-        "#{Resque::Plugins::Restriction::RESTRICTION_QUEUE_PREFIX}_#{queue_name}"
-      end
-    end
   end
 end

data/lib/resque/restriction.rb

@@ -0,0 +1,4 @@
+require 'resque'
+require 'resque/restriction/config'
+require 'resque/plugins/job'
+require 'resque/plugins/restriction'

data/lib/resque/restriction/config.rb

@@ -0,0 +1,49 @@
+module Resque
+  module Restriction
+    def self.configure
+      yield config
+    end
+
+    def self.config
+      @config ||= Config.new
+    end
+
+    class Config
+      def initialize
+        @max_queue_peek = nil
+      end
+
+      def max_queue_peek=(value_or_callable)
+        if value_or_callable.respond_to?(:call)
+          @max_queue_peek = value_or_callable
+        elsif value_or_callable.nil?
+          @max_queue_peek = nil
+        else
+          @max_queue_peek = validated_max_queue_peek(value_or_callable)
+        end
+      end
+
+      def max_queue_peek(queue)
+        @max_queue_peek.respond_to?(:call) ? @max_queue_peek.call(queue) : @max_queue_peek
+      end
+
+      private
+
+      def validated_max_queue_peek(value)
+        peek = nil
+
+        begin
+          peek = Integer(value)
+
+          if peek <= 0
+            raise ArgumentError
+          end
+        rescue ArgumentError
+          raise ArgumentError, "max_queue_peek should be either nil or an Integer greater than 0 but #{value.inspect} was provided"
+        end
+
+        peek
+      end
+    end
+  end
+end

data/lib/resque/restriction/version.rb

@@ -0,0 +1,5 @@
+module Resque
+  module Restriction
+    VERSION = '0.7.0'
+  end
+end

data/resque-restriction.gemspec

@@ -1,59 +1,26 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-# stub: resque-restriction 0.4.0 ruby lib
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'resque/restriction/version'
 
-Gem::Specification.new do |s|
-  s.name = "resque-restriction"
-  s.version = "0.4.0"
+Gem::Specification.new do |spec|
+  spec.name          = 'resque-restriction'
+  spec.version       = Resque::Restriction::VERSION
+  spec.authors       = ['Richard Huang']
+  spec.email         = ['flyerhzm@gmail.com']
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.require_paths = ["lib"]
-  s.authors = ["Richard Huang"]
-  s.date = "2015-10-19"
-  s.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."
-  s.email = "flyerhzm@gmail.com"
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.markdown"
-  ]
-  s.files = [
-    "CHANGELOG.md",
-    "Gemfile",
-    "Gemfile.lock",
-    "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_helper.rb"
-  ]
-  s.homepage = "http://github.com/flyerhzm/resque-restriction"
-  s.rubygems_version = "2.4.8"
-  s.summary = "resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time."
+  spec.summary       = 'resque-restriction is an extension to resque queue system that restricts the execution number of certain jobs in a period time.'
+  spec.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.'
+  spec.homepage      = 'https://github.com/flyerhzm/resque-restriction'
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<resque-restriction>, [">= 0"])
-      s.add_runtime_dependency(%q<resque>, [">= 1.7.0"])
-    else
-      s.add_dependency(%q<resque-restriction>, [">= 0"])
-      s.add_dependency(%q<resque>, [">= 1.7.0"])
-    end
-  else
-    s.add_dependency(%q<resque-restriction>, [">= 0"])
-    s.add_dependency(%q<resque>, [">= 1.7.0"])
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
   end
-end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
 
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'resque', '>= 1.7.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -1,23 +1,37 @@
 --- !ruby/object:Gem::Specification
 name: resque-restriction
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Richard Huang
-autorequire: 
-bindir: bin
+autorequire:
+bindir: exe
 cert_chain: []
-date: 2015-10-19 00:00:00.000000000 Z
+date: 2021-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: resque-restriction
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -31,44 +45,53 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.0
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 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
+email:
+- flyerhzm@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE
-- README.markdown
+extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
-- Gemfile.lock
 - LICENSE
-- README.markdown
+- README.md
 - Rakefile
-- VERSION
-- init.rb
-- lib/resque-restriction.rb
-- lib/resque-restriction/job.rb
-- lib/resque-restriction/restriction_job.rb
-- rails/init.rb
+- lib/resque/plugins/job.rb
+- lib/resque/plugins/restriction.rb
+- lib/resque/restriction.rb
+- lib/resque/restriction/config.rb
+- lib/resque/restriction/version.rb
 - resque-restriction.gemspec
-- spec/redis-test.conf
-- spec/resque-restriction/job_spec.rb
-- spec/resque-restriction/restriction_job_spec.rb
-- spec/spec_helper.rb
-homepage: http://github.com/flyerhzm/resque-restriction
+homepage: https://github.com/flyerhzm/resque-restriction
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -83,9 +106,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.8
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: resque-restriction is an extension to resque queue system that restricts
   the execution number of certain jobs in a period time.

data/Gemfile.lock

@@ -1,116 +0,0 @@
-PATH
-  remote: .
-  specs:
-    resque-restriction (0.4.0)
-      activejob
-      jeweler
-      mocha
-      resque
-      rspec
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activejob (4.2.0)
-      activesupport (= 4.2.0)
-      globalid (>= 0.3.0)
-    activesupport (4.2.0)
-      i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    addressable (2.3.6)
-    builder (3.2.2)
-    descendants_tracker (0.0.4)
-      thread_safe (~> 0.3, >= 0.3.1)
-    diff-lcs (1.2.5)
-    faraday (0.9.0)
-      multipart-post (>= 1.2, < 3)
-    git (1.2.9.1)
-    github_api (0.12.4)
-      addressable (~> 2.3)
-      descendants_tracker (~> 0.0.4)
-      faraday (~> 0.8, < 0.10)
-      hashie (>= 3.4)
-      multi_json (>= 1.7.5, < 2.0)
-      nokogiri (~> 1.6.6)
-      oauth2
-    globalid (0.3.3)
-      activesupport (>= 4.1.0)
-    hashie (3.4.2)
-    highline (1.6.21)
-    i18n (0.7.0)
-    jeweler (2.0.1)
-      builder
-      bundler (>= 1.0)
-      git (>= 1.2.5)
-      github_api
-      highline (>= 1.6.15)
-      nokogiri (>= 1.5.10)
-      rake
-      rdoc
-    json (1.8.3)
-    jwt (1.0.0)
-    metaclass (0.0.4)
-    mini_portile (0.6.1)
-    minitest (5.7.0)
-    mocha (1.1.0)
-      metaclass (~> 0.0.1)
-    mono_logger (1.1.0)
-    multi_json (1.11.2)
-    multi_xml (0.5.5)
-    multipart-post (2.0.0)
-    nokogiri (1.6.6.2)
-      mini_portile (~> 0.6.0)
-    oauth2 (1.0.0)
-      faraday (>= 0.8, < 0.10)
-      jwt (~> 1.0)
-      multi_json (~> 1.3)
-      multi_xml (~> 0.5)
-      rack (~> 1.2)
-    rack (1.6.0)
-    rack-protection (1.5.3)
-      rack
-    rake (10.4.2)
-    rdoc (4.1.0)
-    redis (3.2.1)
-    redis-namespace (1.5.1)
-      redis (~> 3.0, >= 3.0.4)
-    resque (1.25.2)
-      mono_logger (~> 1.0)
-      multi_json (~> 1.0)
-      redis-namespace (~> 1.3)
-      sinatra (>= 0.9.2)
-      vegas (~> 0.1.2)
-    rspec (3.1.0)
-      rspec-core (~> 3.1.0)
-      rspec-expectations (~> 3.1.0)
-      rspec-mocks (~> 3.1.0)
-    rspec-core (3.1.7)
-      rspec-support (~> 3.1.0)
-    rspec-expectations (3.1.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.1.0)
-    rspec-mocks (3.1.3)
-      rspec-support (~> 3.1.0)
-    rspec-support (3.1.2)
-    sinatra (1.4.5)
-      rack (~> 1.4)
-      rack-protection (~> 1.4)
-      tilt (~> 1.3, >= 1.3.4)
-    thread_safe (0.3.5)
-    tilt (1.4.1)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
-    vegas (0.1.11)
-      rack (>= 1.0.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  resque-restriction!
-
-BUNDLED WITH
-   1.10.3

data/README.markdown

@@ -1,83 +0,0 @@
-resque-restriction
-===============
-
-Resque Restriction is a plugin for the [Resque][0] queueing system (http://github.com/defunkt/resque). It adds two functions:
-
-1. it will limit the execution number of certain jobs in a period time. For example, it can limit a certain job can be executed 1000 times per day, 100 time per hour and 30 times per 300 seconds.
-
-2. it will execute the exceeded jobs at the next period. For example, you restrict the email sending jobs to run 1000 times per day. If your system generates 1010 email sending jobs, only 1000 email sending jobs can be executed today, and the other 10 email sending jobs will be executed tomorrow.
-
-Resque Restriction requires Resque 1.7.0.
-
-Attention
----------
-
-The <code>identifier</code> method is renamed to <code>restriction_identifier</code> to solve the confliction with resque-retry from version 0.3.0.
-
-Install
--------
-
-  sudo gem install resque-restriction
-
-To use
-------
-
-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 InvitationJob < Resque::Plugins::RestrictionJob
-	  restrict :per_day => 1000, :per_hour => 100, :per_300 => 30
-
-	  #rest of your class here
-	end
-
-That means the InvitationJob can not be executed more than 1000 times per day, 100 times per hour and 30 times per 300 seconds.  All restrictions have to be met for the job to execute.
-
-The argument of restrict method is a hash, the key of the hash is a period time, including :concurrent, :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.  The :concurrent option restricts the number of jobs that run simultaneously.
-
-Advance
--------
-
-You can also add customized restriction as you like. For example, we have a job to restrict the facebook post numbers 40 times per user per day, we can define as:
-
-	class GenerateFacebookShares < Resque::Plugins::RestrictionJob
-	  restrict :per_day => 40
-
-	  def self.restriction_identifier(options)
-	    [self.to_s, options["user_id"]].join(":")
-	  end
-
-	  #rest of your class here
-	end
-
-options["user_id"] returns the user's facebook uid, the key point is that the different restriction_identifiers can restrict different job execution numbers.
-
-
-Contributing
-------------
-
-Once you've made your commits:
-
-1. [Fork][1] Resque Restriction
-2. Create a topic branch - `git checkout -b my_branch`
-3. Push to your branch - `git push origin my_branch`
-4. Create an [Issue][2] with a link to your branch
-5. That's it!
-
-Author
-------
-Richard Huang :: flyerhzm@gmail.com :: @flyerhzm
-
-Contributors
-------------
-Matt Conway :: matt@conwaysplace.com :: @mattconway
-
-Martin Fourcade :: fourcade.m@gmail.com :: @mfourcade
-
-Copyright
----------
-Copyright (c) 2010 Richard Huang. See LICENSE for details.
-
-[0]: http://github.com/defunkt/resque
-[1]: http://help.github.com/forking/
-[2]: http://github.com/flyerhzm/resque-restriction/issues
-

data/VERSION

@@ -1 +0,0 @@
-0.4.0

data/init.rb

@@ -1 +0,0 @@
-require File.join(File.dirname(__FILE__) + '/rails/init')

data/lib/resque-restriction.rb

@@ -1,3 +0,0 @@
-require 'resque'
-require 'resque-restriction/job'
-require 'resque-restriction/restriction_job'

data/rails/init.rb

@@ -1 +0,0 @@
-require File.join(File.dirname(__FILE__) + '/../lib/resque-restriction')

data/spec/redis-test.conf

@@ -1,132 +0,0 @@
-# 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
-
-# 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/spec/resque-restriction/job_spec.rb

@@ -1,39 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-
-RSpec.describe Resque::Job do
-  before(:example) do
-    Resque.redis.flushall
-  end
-
-  it "should repush restriction queue when reserve" do
-    Resque.push('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
-    expect(Resque::Job.reserve('restriction_normal')).to eq Resque::Job.new('restriction_normal', {'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
-    expect(Resque::Job.reserve('restriction_normal')).to be_nil
-    expect(Resque::Job.reserve('normal')).to be_nil
-  end
-
-  it "should push back to restriction queue when still restricted" do
-    Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), -1)
-    Resque.push('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
-    expect(Resque::Job.reserve('restriction_normal')).to be_nil
-    expect(Resque.pop('restriction_normal')).to eq({'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
-    expect(Resque::Job.reserve('normal')).to be_nil
-  end
-
-  it "should not repush when reserve normal queue" do
-    Resque.push('normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
-    expect(Resque::Job.reserve('normal')).to eq Resque::Job.new('normal', {'class' => 'OneHourRestrictionJob', 'args' => ['any args']})
-    expect(Resque::Job.reserve('normal')).to be_nil
-    expect(Resque::Job.reserve('restriction_normal')).to be_nil
-  end
-
-  it "should only push back queue_length times to restriction queue" do
-    Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), -1)
-    3.times { Resque.push('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args']) }
-    expect(Resque.size('restriction_normal')).to eq 3
-    expect(OneHourRestrictionJob).to receive(:repush).exactly(3).times.and_return(true)
-    Resque::Job.reserve('restriction_normal')
-  end
-
-
-end

data/spec/resque-restriction/restriction_job_spec.rb

@@ -1,222 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-
-RSpec.describe Resque::Plugins::RestrictionJob do
-  skip "should follow the convention" do
-    Resque::Plugin.lint(Resque::Plugins::RestrictionJob)
-  end
-
-  context "redis_key" do
-    it "should get redis_key with different period" do
-      expect(Resque::Plugins::RestrictionJob.redis_key(:per_minute)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 60}"
-      expect(Resque::Plugins::RestrictionJob.redis_key(:per_hour)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / (60*60)}"
-      expect(Resque::Plugins::RestrictionJob.redis_key(:per_day)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / (24*60*60)}"
-      expect(Resque::Plugins::RestrictionJob.redis_key(:per_month)).to eq "Resque::Plugins::RestrictionJob:#{Date.today.strftime("%Y-%m")}"
-      expect(Resque::Plugins::RestrictionJob.redis_key(:per_year)).to eq "Resque::Plugins::RestrictionJob:#{Date.today.year}"
-    end
-
-    it "should accept customization" do
-      expect(Resque::Plugins::RestrictionJob.redis_key(:per_1800)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 1800}"
-      expect(Resque::Plugins::RestrictionJob.redis_key(:per_7200)).to eq "Resque::Plugins::RestrictionJob:#{Time.now.to_i / 7200}"
-    end
-  end
-
-  context "settings" do
-    it "get correct number to restriction jobs" do
-      expect(OneDayRestrictionJob.settings).to eq({:per_day => 100})
-      expect(OneHourRestrictionJob.settings).to eq({:per_hour => 10})
-      expect(MultipleRestrictionJob.settings).to eq({:per_hour => 10, :per_300 => 2})
-      expect(MultiCallRestrictionJob.settings).to eq({:per_hour => 10, :per_300 => 2})
-    end
-  end
-
-  context 'restriction_queue_name' do
-    class MyJob < Resque::Plugins::RestrictionJob
-      queue_as 'awesome_queue_name'
-
-      def perform(args)
-      end
-    end
-
-    it 'concats restriction queue prefix with queue name' do
-      expect(MyJob.restriction_queue_name).to eq("#{Resque::Plugins::Restriction::RESTRICTION_QUEUE_PREFIX}_awesome_queue_name")
-    end
-  end
-
-  context "resque" do
-    include PerformJob
-
-    before(:example) do
-      Resque.redis.flushall
-    end
-
-    it "should set execution number and decrement it when one job first executed" do
-      result = perform_job(OneHourRestrictionJob, "any args")
-      expect(Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour))).to eq "9"
-    end
-
-    it "should use restriction_identifier to set exclusive execution counts" do
-      result = perform_job(IdentifiedRestrictionJob, 1)
-      result = perform_job(IdentifiedRestrictionJob, 1)
-      result = perform_job(IdentifiedRestrictionJob, 2)
-
-      expect(Resque.redis.get(IdentifiedRestrictionJob.redis_key(:per_hour, 1))).to eq "8"
-      expect(Resque.redis.get(IdentifiedRestrictionJob.redis_key(:per_hour, 2))).to eq "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")
-
-      expect(Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour))).to eq "5"
-    end
-
-    it "should increment execution number when concurrent job completes" do
-      t = Thread.new do
-        perform_job(ConcurrentRestrictionJob, "any args")
-      end
-      sleep 0.1
-      expect(Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent))).to eq "0"
-      t.join
-      expect(Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent))).to eq "1"
-    end
-
-    it "should increment execution number when concurrent job fails" do
-      expect_any_instance_of(ConcurrentRestrictionJob).to receive(:perform).and_raise("bad")
-      perform_job(ConcurrentRestrictionJob, "any args") rescue nil
-      expect(Resque.redis.get(ConcurrentRestrictionJob.redis_key(:concurrent))).to eq "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")
-      # expect(result).to_not be(true)
-      expect(Resque.redis.get(OneHourRestrictionJob.redis_key(:per_hour))).to eq "0"
-      expect(Resque.redis.lrange("queue:restriction_normal", 0, -1)).to eq [Resque.encode(:class => "OneHourRestrictionJob", :args => ["any args"])]
-    end
-
-    describe "expiration of period keys" do
-      class MyJob < Resque::Plugins::RestrictionJob
-        def perform(args)
-        end
-      end
-
-      shared_examples_for "expiration" do
-        before(:example) do
-          MyJob.restrict period => 10
-        end
-
-        context "when the key is not set" do
-          it "should mark period keys to expire" do
-            perform_job(MyJob, "any args")
-            expect(Resque.redis.ttl(MyJob.redis_key(period))).to eq MyJob.seconds(period)
-          end
-        end
-
-        context "when the key is set" do
-          before(:example) do
-            Resque.redis.set(MyJob.redis_key(period), 5)
-          end
-
-          it "should not mark period keys to expire" do
-            perform_job(MyJob, "any args")
-            expect(Resque.redis.ttl(MyJob.redis_key(period))).to eq -1
-          end
-        end
-      end
-
-      describe "per minute" do
-        def period
-          :per_minute
-        end
-
-        it_should_behave_like "expiration"
-      end
-
-      describe "per hour" do
-        def period
-          :per_hour
-        end
-
-        it_should_behave_like "expiration"
-      end
-
-      describe "per day" do
-        def period
-          :per_day
-        end
-
-        it_should_behave_like "expiration"
-      end
-
-      describe "per week" do
-        def period
-          :per_week
-        end
-
-        it_should_behave_like "expiration"
-      end
-
-      describe "per month" do
-        def period
-          :per_month
-        end
-
-        it_should_behave_like "expiration"
-      end
-
-      describe "per year" do
-        def period
-          :per_year
-        end
-
-        it_should_behave_like "expiration"
-      end
-
-      describe "per custom period" do
-        def period
-          :per_359
-        end
-
-        it_should_behave_like "expiration"
-      end
-    end
-
-    context "multiple restrict" do
-      it "should restrict per_minute" do
-        result = perform_job(MultipleRestrictionJob, "any args")
-        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour))).to eq "9"
-        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300))).to eq "1"
-        result = perform_job(MultipleRestrictionJob, "any args")
-        result = perform_job(MultipleRestrictionJob, "any args")
-        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour))).to eq "8"
-        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300))).to eq "0"
-      end
-
-      it "should restrict per_hour" do
-        Resque.redis.set(MultipleRestrictionJob.redis_key(:per_hour), 1)
-        Resque.redis.set(MultipleRestrictionJob.redis_key(:per_300), 2)
-        result = perform_job(MultipleRestrictionJob, "any args")
-        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour))).to eq "0"
-        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300))).to eq "1"
-        result = perform_job(MultipleRestrictionJob, "any args")
-        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_hour))).to eq "0"
-        expect(Resque.redis.get(MultipleRestrictionJob.redis_key(:per_300))).to eq "1"
-      end
-    end
-
-    context "repush" do
-      it "should push restricted jobs onto restriction queue" do
-        Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), -1)
-        expect(Resque).to receive(:push).once.with('restriction_normal', :class => 'OneHourRestrictionJob', :args => ['any args'])
-        expect(OneHourRestrictionJob.repush('any args')).to be(true)
-      end
-
-      it "should not push unrestricted jobs onto restriction queue" do
-        Resque.redis.set(OneHourRestrictionJob.redis_key(:per_hour), 1)
-        expect(Resque).not_to receive(:push)
-        expect(OneHourRestrictionJob.repush('any args')).to be(false)
-      end
-
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,107 +0,0 @@
-require 'rubygems'
-require 'mocha'
-
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
-require 'resque-restriction'
-
-#
-# 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 $!
-
-  exit_code = Spec::Runner.run
-
-  pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
-  puts "Killing test redis server [#{pid}]..."
-  `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'
-
-#
-# Helper to perform job classes
-#
-module PerformJob
-  def perform_job(klass, *args)
-    klass.perform_now(*args)
-  end
-end
-
-class OneDayRestrictionJob < Resque::Plugins::RestrictionJob
-  restrict :per_day => 100
-
-  queue_as 'normal'
-
-  def perform(args)
-  end
-end
-
-class OneHourRestrictionJob < Resque::Plugins::RestrictionJob
-  restrict :per_hour => 10
-
-  queue_as 'normal'
-
-  def perform(args)
-  end
-end
-
-class IdentifiedRestrictionJob < Resque::Plugins::RestrictionJob
-  restrict :per_hour => 10
-
-  queue_as 'normal'
-
-  def self.restriction_identifier(*args)
-    [self.to_s, args.first].join(":")
-  end
-
-  def perform(args)
-  end
-end
-
-class ConcurrentRestrictionJob < Resque::Plugins::RestrictionJob
-  restrict :concurrent => 1
-
-  queue_as 'normal'
-
-  def perform(args)
-    sleep 0.2
-  end
-end
-
-class MultipleRestrictionJob < Resque::Plugins::RestrictionJob
-  restrict :per_hour => 10, :per_300 => 2
-
-  queue_as 'normal'
-
-  def perform(args)
-  end
-end
-
-class MultiCallRestrictionJob < Resque::Plugins::RestrictionJob
-  restrict :per_hour => 10
-  restrict :per_300 => 2
-
-  queue_as 'normal'
-
-  def perform(args)
-  end
-end