resque_solo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1439a366dbc27ba7ab5fda8a4f2d3cd8249b2f2b
+  data.tar.gz: a4fbc3cfd7eb599ebdaab59c99be4bbdc7413c7b
+SHA512:
+  metadata.gz: df1a343cf086b25b8b35d1f8d4498f481977d2c3bf123cd7238ae942706d74c466b37e0fd435cac47eae9c5c71f48f9e4d57f3b5548fe55b18dd22df9e36ed6a
+  data.tar.gz: 34d522a75a2e5dee71423271280b114e1a9d1c104643e4e4b5b36e1415ae47bf07b015f39f25406f5ca6922d10de293b99fc8e8e9992bfcaf8d6775dafaeb5eb

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle
+.config
+Gemfile.lock
+coverage
+pkg
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+group :test do
+  gem 'test-unit'
+  gem 'mocha'
+  gem 'shoulda-context'
+  gem 'pry'
+  gem 'pry-byebug'
+  gem 'fakeredis'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,34 @@
+Copyright (c) 2010 Moviepilot GmbH http://moviepilot.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Copyright (c) 2013 Tee Parham
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.

data/README.md

@@ -0,0 +1,45 @@
+# ResqueSolo
+
+ResqueSolo is a resque plugin to add unique jobs to resque.
+
+It is a re-write of [resque-loner](https://github.com/jayniz/resque-loner).
+
+It requires ruby 2.0 and resque 1.25.
+
+It removes the dependency on `Resque::Helpers`, which is deprecated for resque 2.0.
+
+## Install
+
+Add the gem to your Gemfile:
+
+    gem 'resque_solo'
+
+## Usage
+
+```ruby
+class UpdateCat
+  include Resque::Plugins::UniqueJob
+  @queue = :cats
+
+  def self.perform(cat_id)
+    # do something
+  end
+end
+```
+
+If you attempt to queue a unique job multiple times, it is ignored:
+
+```
+Resque.enqueue UpdateCat, 1
+=> "OK"
+Resque.enqueue UpdateCat, 1
+=> "EXISTED"
+Resque.enqueue UpdateCat, 1
+=> "EXISTED"
+Resque.size :cats
+=> 1
+Resque.enqueued? UpdateCat, 1
+=> true
+Resque.enqueued_in? :dogs, UpdateCat, 1
+=> false
+```

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/resque_ext/job.rb

@@ -0,0 +1,40 @@
+module Resque
+  class Job
+    class << self
+      # Mark an item as queued after Resque::Job.create has called Resque.push
+      def create_solo(queue, klass, *args)
+        return create_without_solo(queue, klass, *args) if Resque.inline?
+        item = {class: klass.to_s, args: args}
+        return "EXISTED" if ResqueSolo::Queue.queued?(queue, item)
+        # multi returns array of keys
+        create_return_value = false
+        Resque.redis.multi do
+          create_return_value = create_without_solo(queue, klass, *args)
+          ResqueSolo::Queue.mark_queued(queue, item)
+        end
+        create_return_value
+      end
+
+      # Mark an item as unqueued
+      def reserve_solo(queue)
+        item = reserve_without_solo(queue)
+        ResqueSolo::Queue.mark_unqueued(queue, item) if item && !Resque.inline?
+        item
+      end
+
+      # Mark all destroyed jobs as unqueued.
+      # The original method only returns the amount of jobs destroyed, but not the jobs themselves.
+      def destroy_solo(queue, klass, *args)
+        ResqueSolo::Queue.destroy(queue, klass, *args) unless Resque.inline?
+        destroy_without_solo(queue, klass, *args)
+      end
+
+      alias_method :create_without_solo, :create
+      alias_method :create, :create_solo
+      alias_method :reserve_without_solo, :reserve
+      alias_method :reserve, :reserve_solo
+      alias_method :destroy_without_solo, :destroy
+      alias_method :destroy, :destroy_solo
+    end
+  end
+end

data/lib/resque_ext/resque.rb

@@ -0,0 +1,21 @@
+module Resque
+  class << self
+    def enqueued?(klass, *args)
+      enqueued_in?(queue_from_class(klass), klass, *args )
+    end
+
+    def enqueued_in?(queue, klass, *args)
+      item = {class: klass.to_s, args: args}
+      return nil unless ResqueSolo::Queue.is_unique?(item)
+      ResqueSolo::Queue.queued?(queue, item)
+    end
+
+    def remove_queue_with_cleanup(queue)
+      remove_queue_without_cleanup(queue)
+      ResqueSolo::Queue.cleanup(queue)
+    end
+
+    alias_method :remove_queue_without_cleanup, :remove_queue
+    alias_method :remove_queue, :remove_queue_with_cleanup
+  end
+end

data/lib/resque_solo.rb

@@ -0,0 +1,6 @@
+require 'resque'
+require 'resque_ext/job'
+require 'resque_ext/resque'
+require 'resque_solo/version'
+require 'resque_solo/queue'
+require 'resque_solo/unique_job'

data/lib/resque_solo/queue.rb

@@ -0,0 +1,82 @@
+module ResqueSolo
+  class Queue
+    class << self
+      def queued?(queue, item)
+        return false unless is_unique?(item)
+        redis.get(unique_key(queue, item)) == "1"
+      end
+
+      def mark_queued(queue, item)
+        return unless is_unique?(item)
+        key = unique_key(queue, item)
+        redis.set(key, 1)
+        ttl = item_ttl(item)
+        redis.expire(key, ttl) if ttl >= 0
+      end
+
+      def mark_unqueued(queue, job)
+        item = job.is_a?(Resque::Job) ? job.payload : job
+        return unless is_unique?(item)
+        ttl = lock_after_execution_period(item)
+        if ttl == 0
+          redis.del(unique_key(queue, item))
+        else
+          redis.expire(unique_key(queue, item), ttl)
+        end
+      end
+
+      def unique_key(queue, item)
+        "solo:queue:#{queue}:job:#{const_for(item).redis_key(item)}"
+      end
+
+      def is_unique?(item)
+        const_for(item).included_modules.include?(::Resque::Plugins::UniqueJob)
+      rescue NameError
+        false
+      end
+
+      def item_ttl(item)
+        const_for(item).ttl
+      rescue NameError
+        -1
+      end
+
+      def lock_after_execution_period(item)
+        const_for(item).lock_after_execution_period
+      rescue NameError
+        0
+      end
+
+      def destroy(queue, klass, *args)
+        klass = klass.to_s
+        redis_queue = "queue:#{queue}"
+
+        redis.lrange(redis_queue, 0, -1).each do |string|
+          json = JSON.parse(string)
+          next unless json['class'] == klass
+          next unless json['args'] == args if args.any?
+          ResqueSolo::Queue.mark_unqueued(queue, json)
+        end
+      end
+
+      def cleanup(queue)
+        keys = redis.keys("solo:queue:#{queue}:job:*")
+        redis.del(*keys) if keys.any?
+      end
+
+    private
+
+      def redis
+        Resque.redis
+      end
+
+      def item_class(item)
+        item[:class] || item['class']
+      end
+
+      def const_for(item)
+        const_get item_class(item)
+      end
+    end
+  end
+end

data/lib/resque_solo/unique_job.rb

@@ -0,0 +1,53 @@
+require 'digest/md5'
+
+module Resque
+  module Plugins
+    module UniqueJob
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # Payload is what Resque stored for this job along with the job's class name:
+        # a hash containing :class and :args
+        def redis_key(payload)
+          payload = JSON.parse(JSON.generate(payload)) # todo - .stringify_keys
+          job  = payload["class"]
+          args = payload["args"]
+          args.map! do |arg|
+            arg.is_a?(Hash) ? arg.sort : arg
+          end
+
+          Digest::MD5.hexdigest JSON.generate(class: job, args: args)
+        end
+
+        # The default ttl of a locking key is -1 (forever).
+        # To expire the lock after a certain amount of time, set a ttl (in seconds).
+        # For example:
+        #
+        # class FooJob
+        #   include Resque::Plugins::UniqueJob
+        #   @ttl = 40
+        #   end
+        # end
+        def ttl
+          @ttl || -1
+        end
+
+        # The default ttl of a persisting key is 0, i.e. immediately deleted.
+        # Set lock_after_execution_period to block the execution
+        # of the job for a certain amount of time (in seconds).
+        # For example:
+        #
+        # class FooJob
+        #   include Resque::Plugins::UniqueJob
+        #   @lock_after_execution_period = 40
+        #   end
+        # end
+        def lock_after_execution_period
+          @lock_after_execution_period || 0
+        end
+      end
+    end
+  end
+end

data/lib/resque_solo/version.rb

@@ -0,0 +1,3 @@
+module ResqueSolo
+  VERSION = "0.0.1"
+end

data/resque_solo.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'resque_solo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "resque_solo"
+  spec.version       = ResqueSolo::VERSION
+  spec.authors       = ["Tee Parham"]
+  spec.email         = %w(tee@neighborland.com)
+  spec.description   = %q{Resque plugin to add unique jobs}
+  spec.summary       = %q{Resque plugin to add unique jobs}
+  spec.homepage      = "https://github.com/teeparham/resque_solo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(test|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.add_dependency "resque", "~> 1.25.1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/test/fake_jobs.rb

@@ -0,0 +1,38 @@
+class FakeJob
+  @queue = :normal
+end
+
+class FakeUniqueJob
+  include Resque::Plugins::UniqueJob
+  @queue = :unique
+
+  def self.perform(_)
+  end
+end
+
+class FailingUniqueJob
+  include Resque::Plugins::UniqueJob
+  @queue = :unique
+
+  def self.perform(_)
+    raise "Fail"
+  end
+end
+
+class UniqueJobWithTtl
+  include Resque::Plugins::UniqueJob
+  @queue = :unique_with_ttl
+  @ttl = 300
+
+  def self.perform(*_)
+  end
+end
+
+class UniqueJobWithLock
+  include Resque::Plugins::UniqueJob
+  @queue = :unique_with_lock
+  @lock_after_execution_period = 150
+
+  def self.perform(*_)
+  end
+end

data/test/job_test.rb

@@ -0,0 +1,107 @@
+require 'test_helper'
+
+class JobTest < Test::Unit::TestCase
+  setup do
+    Resque.redis.flushall
+  end
+
+  should "enqueue identical jobs once" do
+    Resque.enqueue FakeUniqueJob, "x"
+    Resque.enqueue FakeUniqueJob, "x"
+    assert_equal 1, Resque.size(:unique)
+  end
+
+  should "allow the same jobs to be executed one after the other" do
+    Resque.enqueue FakeUniqueJob, "foo"
+    Resque.enqueue FakeUniqueJob, "foo"
+    assert_equal 1, Resque.size(:unique)
+    Resque.reserve(:unique)
+    assert_equal 0, Resque.size(:unique)
+    Resque.enqueue FakeUniqueJob, "foo"
+    Resque.enqueue FakeUniqueJob, "foo"
+    assert_equal 1, Resque.size(:unique)
+  end
+
+  should "consider equivalent hashes regardless of key order" do
+    Resque.enqueue FakeUniqueJob, bar: 1, foo: 2
+    Resque.enqueue FakeUniqueJob, foo: 2, bar: 1
+    assert_equal 1, Resque.size(:unique)
+  end
+
+  should "treat string and symbol keys equally" do
+    Resque.enqueue FakeUniqueJob, bar: 1, foo: 1
+    Resque.enqueue FakeUniqueJob, bar: 1, "foo" => 1
+    assert_equal 1, Resque.size(:unique)
+  end
+
+  should "mark jobs as unqueued, when Job.destroy is killing them" do
+    Resque.enqueue FakeUniqueJob, "foo"
+    Resque.enqueue FakeUniqueJob, "foo"
+    assert_equal 1, Resque.size(:unique)
+    Resque::Job.destroy(:unique, FakeUniqueJob)
+    assert_equal 0, Resque.size(:unique)
+    Resque.enqueue FakeUniqueJob, "foo"
+    Resque.enqueue FakeUniqueJob, "foo"
+    assert_equal 1, Resque.size(:unique)
+  end
+
+  should "mark jobs as unqueued when they raise an exception" do
+    2.times { Resque.enqueue( FailingUniqueJob, "foo" ) }
+    assert_equal 1, Resque.size(:unique)
+    worker = Resque::Worker.new(:unique)
+    worker.work 0
+    assert_equal 0, Resque.size(:unique)
+    2.times { Resque.enqueue( FailingUniqueJob, "foo" ) }
+    assert_equal 1, Resque.size(:unique)
+  end
+
+  should "report if a unique job is enqueued" do
+    Resque.enqueue FakeUniqueJob, "foo"
+    assert Resque.enqueued?(FakeUniqueJob, "foo")
+    refute Resque.enqueued?(FakeUniqueJob, "bar")
+  end
+
+  should "report if a job is enqueued" do
+    default_queue = FakeUniqueJob.instance_variable_get(:@queue)
+    FakeUniqueJob.instance_variable_set(:@queue, :other)
+    Resque.enqueue FakeUniqueJob, "foo"
+    assert Resque.enqueued_in?(:other, FakeUniqueJob, "foo")
+    FakeUniqueJob.instance_variable_set(:@queue, default_queue)
+    refute Resque.enqueued?(FakeUniqueJob, "foo")
+  end
+
+  should "cleanup when a queue is destroyed" do
+    Resque.enqueue FakeUniqueJob, "foo"
+    Resque.enqueue FailingUniqueJob, "foo"
+    Resque.remove_queue(:unique)
+    Resque.enqueue(FakeUniqueJob, "foo")
+    assert_equal 1, Resque.size(:unique)
+  end
+
+  should "honor ttl in the redis key" do
+    Resque.enqueue UniqueJobWithTtl
+    assert Resque.enqueued?(UniqueJobWithTtl)
+    keys = Resque.redis.keys "solo:queue:unique_with_ttl:job:*"
+    assert_equal 1, keys.length
+    assert_in_delta UniqueJobWithTtl.ttl, Resque.redis.ttl(keys.first), 2
+  end
+
+  should "not allow the same job to be enqueued after execution if lock_after_execution_period is set" do
+    Resque.enqueue UniqueJobWithLock, "foo"
+    Resque.enqueue UniqueJobWithLock, "foo"
+    assert_equal 1, Resque.size(:unique_with_lock)
+    Resque.reserve(:unique_with_lock)
+    assert_equal 0, Resque.size(:unique_with_lock)
+    Resque.enqueue UniqueJobWithLock, "foo"
+    assert_equal 0, Resque.size(:unique_with_lock)
+  end
+
+  should "honor lock_after_execution_period in the redis key" do
+    Resque.enqueue UniqueJobWithLock
+    Resque.reserve(:unique_with_lock)
+    keys = Resque.redis.keys "solo:queue:unique_with_lock:job:*"
+    assert_equal 1, keys.length
+    assert_in_delta UniqueJobWithLock.lock_after_execution_period, Resque.redis.ttl(keys.first), 2
+  end
+  
+end

data/test/queue_test.rb

@@ -0,0 +1,5 @@
+require 'test_helper'
+
+class QueueTest < Test::Unit::TestCase
+
+end

data/test/resque_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class ResqueTest < Test::Unit::TestCase
+  setup do
+    Resque.redis.flushall
+  end
+
+  should "enqueue normal jobs" do
+    Resque.enqueue FakeJob, "x"
+    Resque.enqueue FakeJob, "x"
+    assert_equal 2, Resque.size(:normal)
+  end
+
+  should "not be able to report if a non-unique job was enqueued" do
+    assert_nil Resque.enqueued?(FakeJob)
+  end
+
+  should "not raise when deleting an empty queue" do
+    assert_nothing_raised do
+      Resque.remove_queue(:unique)
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+require 'shoulda-context'
+require 'mocha/setup'
+require 'resque_solo'
+require 'pry'
+require 'pry-byebug'
+require 'fake_jobs'

data/test/unique_job_test.rb

@@ -0,0 +1,5 @@
+require 'test_helper'
+
+class UniqueJobTest < Test::Unit::TestCase
+
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: resque_solo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tee Parham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.25.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.25.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Resque plugin to add unique jobs
+email:
+- tee@neighborland.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/resque_ext/job.rb
+- lib/resque_ext/resque.rb
+- lib/resque_solo.rb
+- lib/resque_solo/queue.rb
+- lib/resque_solo/unique_job.rb
+- lib/resque_solo/version.rb
+- resque_solo.gemspec
+- test/fake_jobs.rb
+- test/job_test.rb
+- test/queue_test.rb
+- test/resque_test.rb
+- test/test_helper.rb
+- test/unique_job_test.rb
+homepage: https://github.com/teeparham/resque_solo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Resque plugin to add unique jobs
+test_files:
+- test/fake_jobs.rb
+- test/job_test.rb
+- test/queue_test.rb
+- test/resque_test.rb
+- test/test_helper.rb
+- test/unique_job_test.rb