resque-real-serial-queues 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f93dfead3f604771c085987d5080ad96e4b89cf9
-  data.tar.gz: 22bd5633ae333f60b33b47c4bd38e6a88a8f784f
+  metadata.gz: bdd9fb0afaa0e42a40abd457eba4dd1fc86519d3
+  data.tar.gz: 4738f36a9abf515bea030d2ca4650477738e588e
 SHA512:
-  metadata.gz: be4ae6f091c52bb056129b7f7a9fa58c04d24533a0d48e49e3233e62359cee5a5e25233554517a522948517648011e099d249a3532de0bf9ee58a8b5bb2547a7
-  data.tar.gz: 23113e249184a5ec4c50a0b67654d95eead593e6bcbb784767524e44665386299f7548aafd69276992e8c06efa9205f1f778ea54fe3689fe4491b382f89c30b8
+  metadata.gz: bef8645d3a33619d53e68488a2f8834b57c41d5e9b42b226c188e29862c0268e6016b65b2c7688c0c47f3e4c5921c5729f19090b29b6212bea8c6ce53355f032
+  data.tar.gz: 56bc2bf9062532e4f3e3586ffdb426e6a88609fd57e26340e019aad16f7af44df14595f7b597e3c45c217222cb66ab992bbb0713dab901a9064331db8f88d4cb

data/README.md

@@ -5,7 +5,7 @@ from the same queue as the potential job currently being processed by one of you
 
 It is primarily meant to be used to queue long running background jobs across multiple queues in conjunction with something like [resque-scheduler](https://github.com/resque/resque-scheduler)
 
-A key difference between this and [resque-lonely_job](https://github.com/wallace/resque-lonely_job) is that the queue is not touched when we check to see if we can process the job.  However, because we must check all the workers
+A key difference between this and [resque-lonely_job](https://github.com/wallace/resque-lonely_job) is that the queue is not touched when we check to see if we can process the job (thus there is no danger of your queues getting processed in a different order).  However, because we must check all the workers
 currently working on the system this plugin may not scale well to large numbers of workers.
 
 This gem is under active development - so please use caution if your jobs are responsible for controlling rocket ships or providing food and shelter to young children.
@@ -40,6 +40,32 @@ Or install it yourself as:
   directory with the above line should do the trick.
 
   Note that this will currently affect all queues
+
+## Configuration and Adding Non-Serial Queues
+  By default all queues are considered serial if you just install the plugin.  If you'd like to have some queues that do not get processed serially - you can add them via a configuration option after you require the plugin:
+
+  ```ruby
+  # you can pass it straight in as a hash
+  Resque::Plugins::RealSerialQueues.config = {
+    non_serial_queues: ['non_serial_queue_one', 'non_serial_queue_two']
+  }
+
+  # or you can place it in a config file
+  require 'yaml'
+
+  Resque::Plugins::RealSerialQueues.config = YAML.load_file('your_config_file.yml')
+  ```
+
+  If you choose to use a YAML config file - the queue names must be specified as a list:
+
+  ```yaml
+  non_serial_queues:
+    - non_serial_queue_one
+    - non_serial_queue_two
+  ```
+
+  Not specifying any configuration will cause all queues to be processed serially.
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/resque-real-serial-queues/fork )

data/Rakefile

@@ -1,2 +1,7 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
 
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/*_test.rb"
+end

data/lib/resque/plugins/real_serial_queues.rb

@@ -6,12 +6,11 @@ require "resque/plugins/version"
 module Resque
   class Job
 
-    # Given a queue name and a potential job (the one we are considering popping off the queue)
-    # determine whether there is a worker currently working on a job with the same queue, class, and args
-    # return true if we find an identical job, false if not
-    def self.job_from_same_queue_is_currently_being_run(queue, job)
-      return false unless job
-
+    # Given a queue name
+    # determine whether there is a worker currently working on a 
+    # job from the same queue
+    # return true 
+    def self.job_from_same_queue_is_currently_being_run?(queue)
       Worker.working.each do |worker|
         processing_job = worker.job
         next unless processing_job
@@ -28,10 +27,16 @@ module Resque
     # Given a string queue name, returns an instance of Resque::Job
     # if any jobs are available. If not, returns nil.
     # This is a resque method overridden to first check
-    # if the queue item has an identical job currently being worked on
+    # if there is another job from the queue being checked currently
+    # being worked on.  This check can be bypassed by setting
+    # non_serial_queues via Resque::Plugins::RealSerialQueues.config=
+    # in your Resque config
     def self.reserve(queue)
-      potential_job = Resque.peek(queue)
-      return if job_from_same_queue_is_currently_being_run(queue, potential_job)
+      non_serial_queues = Resque::Plugins::RealSerialQueues.non_serial_queues
+
+      unless non_serial_queues && non_serial_queues.include?(queue)
+        return if job_from_same_queue_is_currently_being_run?(queue)
+      end
       return unless payload = Resque.pop(queue)
       new(queue, payload)
     end
@@ -39,9 +44,40 @@ module Resque
 end
 
 # if we add any actual method extensions add them here
-module Resque # :nodoc:
-  module Plugins # :nodoc
+module Resque
+  module Plugins
     module RealSerialQueues
+      class InvalidConfigurationError < StandardError; end
+
+      class << self
+        attr_accessor :non_serial_queues
+      end
+
+      def self.config=(config_hash)
+        if config_hash
+          self.check_if_config_is_valid(config_hash)
+          self.non_serial_queues = config_hash[:non_serial_queues]
+        end
+      end
+
+      private
+
+      def self.check_if_config_is_valid(config_hash)
+        if !config_hash.is_a?(Hash)
+          fail(
+            InvalidConfigurationError,
+            'Something is wrong with your config file.  Sorry...'
+          )
+        elsif config_hash[:non_serial_queues] &&
+              !config_hash[:non_serial_queues].is_a?(Array)
+          fail(
+            InvalidConfigurationError,
+            'Please specify non-serial queue names in an array ' +
+            '(or collection if you are using YAML: http://yaml4r.' +
+            'sourceforge.net/doc/page/collections_in_yaml.htm)'
+          )
+        end
+      end
     end
   end
 end

data/lib/resque/plugins/version.rb

@@ -1,7 +1,7 @@
 module Resque # :nodoc:
   module Plugins # :nodoc
     module RealSerialQueues
-      VERSION = "0.0.1"
+      VERSION = "0.0.2"
     end
   end
 end

data/resque-real-serial-queues.gemspec

@@ -18,8 +18,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "resque", "~> 1.25"
+  spec.add_dependency 'resque', '~> 1.25'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest', '~> 5.3'
+  spec.add_development_dependency 'mocha', '~> 1.1'
 end

data/test/resque_test.rb

@@ -0,0 +1,148 @@
+require 'test_helper'
+
+describe Resque::Job do
+  before do
+    @fake_queue = 'fake_queue'
+    @worker = Resque::Worker.new(@fake_queue)
+    # Resque checks redis for the worker's value and 
+    # returns a hash decoded by MultiJSON
+    @job =  {
+      'queue'   => @fake_queue,
+      'payload' => {
+        'class' => 'SomeJob',
+        'args'  => []
+      } 
+    }
+  end
+
+  describe '#job_from_same_queue_is_currently_being_run?' do
+    it 'returns false if no workers' do
+      Resque::Worker.expects(:working).returns([])
+      Resque::Job
+        .job_from_same_queue_is_currently_being_run?('some_queue')
+        .must_equal(false)
+    end
+
+    it 'returns true if the queue name of any processing ' +
+       'job matches the queue name passed in' do
+
+      Resque::Worker.expects(:working).returns([@worker])
+      @worker.expects(:job).returns(@job)
+      Resque::Job
+        .job_from_same_queue_is_currently_being_run?(@fake_queue)
+        .must_equal(true)
+    end
+
+    it 'returns false if there are jobs but none from the specified queue' do
+      Resque::Worker.expects(:working).returns([@worker])
+      @worker.expects(:job).returns(@job)
+      Resque::Job
+        .job_from_same_queue_is_currently_being_run?('a_different_queue')
+        .must_equal(false)
+    end
+  end
+
+  describe '#reserve' do
+    describe 'when there are no non-serial queues specified' do
+      before do
+        Resque::Plugins::RealSerialQueues.config = {}
+      end
+
+      it 'should return nil if job from requested queue is being performed' do
+        Resque::Job
+          .expects(:job_from_same_queue_is_currently_being_run?)
+          .returns(true)
+        Resque::Job.reserve('queue_name').must_equal(nil)
+      end
+
+      it 'should return at instance of Resque::Job if no ' +
+         'job from requested queue is being performed' do
+        Resque::Job
+          .expects(:job_from_same_queue_is_currently_being_run?)
+          .returns(false)
+
+        Resque.expects(:pop).returns(@job)
+
+        result = Resque::Job.reserve(@fake_queue)
+        
+        result.must_be_instance_of(Resque::Job)
+      end
+    end
+
+    describe 'when there are non-serial queues specified' do
+      before do
+        @serial_queue = 'so_serial'
+        @non_serial   = 'not_so_serial'
+        Resque::Plugins::RealSerialQueues.config = {
+          non_serial_queues: [@non_serial]
+        }
+
+        Resque.stubs(:pop).returns(@job)
+      end
+      
+      describe 'and there is a job from the same queue being performed' do
+        before do
+          Resque::Job.stubs(:job_from_same_queue_is_currently_being_run?)
+            .returns(true)
+        end
+
+        it 'should return an Resque::Job instance if in the non-serial queue' do
+          result = Resque::Job.reserve(@non_serial)
+          result.must_be_instance_of(Resque::Job)
+        end
+
+        it 'should return nil if not in the non-serial queue' do
+          result = Resque::Job.reserve(@serial_queue)
+          result.must_be_nil
+        end
+      end
+
+      describe 'and there is no job from the same queue being performed' do
+        before do
+          Resque::Job.stubs(:job_from_same_queue_is_currently_being_run?)
+            .returns(false)
+        end
+
+        it 'should return a Resque::Job instance if in non-serial queue' do
+          result = Resque::Job.reserve(@non_serial)
+          result.must_be_instance_of(Resque::Job)
+        end
+
+        it 'should return a Resque::Job instance if in serial queue' do
+          result = Resque::Job.reserve(@serial_queue)
+          result.must_be_instance_of(Resque::Job)
+        end
+      end
+    end
+  end
+end
+
+describe Resque::Plugins::RealSerialQueues do
+  describe '#config=' do
+    it 'should take in the config hash in a way that is accessible' do
+      Resque::Plugins::RealSerialQueues.config = {
+        non_serial_queues:[:camera, :bear]
+      }
+
+      Resque::Plugins::RealSerialQueues
+        .non_serial_queues
+        .must_equal([:camera, :bear])
+    end
+
+    it 'should throw an error if the config is not a Hash' do
+      -> {
+        Resque::Plugins::RealSerialQueues.config = 'good morning bear'
+      }.must_raise(
+        Resque::Plugins::RealSerialQueues::InvalidConfigurationError
+      )
+    end
+
+    it 'should throw an error if non serial queues not specified in an array' do
+      -> { 
+        Resque::Plugins::RealSerialQueues.config = {
+          non_serial_queues: 'best_queue, better_queue'
+        } 
+      }.must_raise(Resque::Plugins::RealSerialQueues::InvalidConfigurationError)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'resque'
+require 'resque_real_serial_queues'
+require 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha/mini_test'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resque-real-serial-queues
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Javier Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-16 00:00:00.000000000 Z
+date: 2014-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.3'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: The plugin is designed for sequential running of different jobs in the
   same queue across multiple queues.  Specifically meant for running a variety of
   long-running background tasks scheduled ahead of time using something like reque-scheduler.  May
@@ -74,6 +102,8 @@ files:
 - lib/resque/plugins/version.rb
 - lib/resque_real_serial_queues.rb
 - resque-real-serial-queues.gemspec
+- test/resque_test.rb
+- test/test_helper.rb
 homepage: https://github.com/4141done/resque-real-serial-queues
 licenses:
 - MIT
@@ -99,4 +129,6 @@ signing_key:
 specification_version: 4
 summary: Resque plugin to allow queues to be processed serially without modifying
   the queue order
-test_files: []
+test_files:
+- test/resque_test.rb
+- test/test_helper.rb