parallel_minion 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a490fae075880a809d3d3542381454e2737ee560
+  data.tar.gz: bec1bb591e8d19b490821f5153cb195083e9e58a
+SHA512:
+  metadata.gz: 49c1e58bcb4011633cd0f80d666a6872f8fea1719cb5e2085dc463e6afd0ed71672ee1e49c5846fca668a0704beebdf22f0b816d804a7590f88e02571bf7ecd6
+  data.tar.gz: 383505b36f1990379463117143231f2c069dc3451658a05fcc8d5c303a1394cdf76a232a4439f0d90660e8af3305ddc6445f5c74171f75f70940df7f0f43f534

data/README.md

@@ -0,0 +1,234 @@
+parallel_minion
+===============
+
+Parallel Minion supports easily handing work off to Minions (Threads) so that tasks
+that would normally be performed sequentially can easily be executed in parallel.
+This allows Ruby and Rails applications to very easily do many tasks at the same
+time so that results are returned more quickly.
+
+Our use-case for Minions is where an application grew to a point where it would
+be useful to run some of the steps in fulfilling a single request in parallel.
+
+## Features:
+
+Exceptions
+
+- Any exceptions raised in Minions are captured and propagated back to the
+  calling thread when #result is called
+- Makes exception handling simple with a drop-in replacement in existing code
+
+Timeouts
+
+- Timeout when a Minion does not return within a specified time
+- Timeouts are a useful feature when one of the Minions fails to respond in a
+  reasonable amount of time. For example when a call to a remote service hangs
+  we can send back a partial response of other work that was completed rather
+  than just "hanging" or failing completely.
+
+Logging
+
+- Built-in support to log the duration of all Minion tasks to make future analysis
+  of performance issues much easier
+- Logs any exceptions thrown to assist fwith problem diagnosis
+
+## Example
+
+Simple example
+
+```ruby
+ParallelMinion::Minion.new(10.days.ago, description: 'Doing something else in parallel', timeout: 1000) do |date|
+  MyTable.where('created_at <= ?', date).count
+end
+```
+
+## Example
+
+For example, in the code below there are several steps that are performed sequentially:
+
+```ruby
+# Contrived example to show how to do parallel code execution
+# with (unreal) sample durations in the comments
+
+def process_request(request)
+  # Count number of entries in a table.
+  #   Average response time 150ms
+  person_count = Person.where(state: 'FL').count
+
+  # Count the number of requests for this user (usually more complex with were clauses etc.)
+  #   Average response time 320ms
+  request_count = Requests.where(user_id: request.user.id).count
+
+  # Call an external provider
+  #   Average response time 1800ms ( Sometimes "hangs" when supplier does not respond )
+  inventory = inventory_supplier.check_inventory(request.product.id)
+
+  # Call another provider for more info on the user
+  #   Average response time 1500ms
+  user_info = user_supplier.more_info(request.user.name)
+
+  # Build up the reply
+  reply = MyReply.new(user_id: request.user.id)
+
+  reply.number_of_people   = person_count
+  reply.number_of_requests = request_count
+  reply.user_details       = user_info.details
+  if inventory.product_available?
+    reply.available        = true
+    reply.quantity         = 100
+  else
+    reply.available = false
+  end
+
+  reply
+end
+```
+The average response time when calling #process_request is around 3,780 milli-seconds.
+
+The first step could be to run the supplier calls in parallel.
+Through log analysis we have determined that the first supplier call takes on average
+1,800 ms and we have decided that it should not wait longer than 2,200 ms for a response.
+
+```ruby
+# Now with a single parallel call
+
+def process_request(request)
+  # Count number of entries in a table.
+  #   Average response time 150ms
+  person_count = Person.where(state: 'FL').count
+
+  # Count the number of requests for this user (usually more complex with were clauses etc.)
+  #   Average response time 320ms
+  request_count = Requests.where(user_id: request.user.id).count
+
+  # Call an external provider
+  #   Average response time 1800ms ( Sometimes "hangs" when supplier does not respond )
+  inventory_minion = ParallelMinion::Minion.new(request.product.id, description: 'Inventory Lookup', timeout: 2200) do |product_id|
+    inventory_supplier.check_inventory(product_id)
+  end
+
+  # Call another provider for more info on the user
+  #   Average response time 1500ms
+  user_info = user_supplier.more_info(request.user.name)
+
+  # Build up the reply
+  reply = MyReply.new(user_id: request.user.id)
+
+  reply.number_of_people   = person_count
+  reply.number_of_requests = request_count
+  reply.user_details       = user_info.details
+
+  # Get inventory result from Inventory Lookup minion
+  inventory = inventory_minion.result
+
+  if inventory.product_available?
+    reply.available        = true
+    reply.quantity         = 100
+  else
+    reply.available = false
+  end
+
+  reply
+end
+```
+
+The above changes drop the average processing time from 3,780 milli-seconds to
+2,280 milli-seconds.
+
+By moving the supplier call to the top of the function call it can be optimized
+to about 1,970 milli-seconds.
+
+We can further parallelize the processing to gain even greater performance.
+
+```ruby
+# Now with two parallel calls
+
+def process_request(request)
+  # Call an external provider
+  #   Average response time 1800ms ( Sometimes "hangs" when supplier does not respond )
+  inventory_minion = ParallelMinion::Minion.new(request.product.id, description: 'Inventory Lookup', timeout: 2200) do |product_id|
+    inventory_supplier.check_inventory(product_id)
+  end
+
+  # Count the number of requests for this user (usually more complex with were clauses etc.)
+  #   Average response time 320ms
+  request_count_minion = ParallelMinion::Minion.new(request.user.id, description: 'Request Count', timeout: 500) do |user_id|
+    Requests.where(user_id: user_id).count
+  end
+
+  # Leave the current thread some work to do too
+
+  # Count number of entries in a table.
+  #   Average response time 150ms
+  person_count = Person.where(state: 'FL').count
+
+  # Call another provider for more info on the user
+  #   Average response time 1500ms
+  user_info = user_supplier.more_info(request.user.name)
+
+  # Build up the reply
+  reply = MyReply.new(user_id: request.user.id)
+
+  reply.number_of_people   = person_count
+  # The request_count is retrieved from the request_count_minion first since it
+  # should complete before the inventory_minion
+  reply.number_of_requests = request_count_minion.result
+  reply.user_details       = user_info.details
+
+  # Get inventory result from Inventory Lookup minion
+  inventory = inventory_minion.result
+
+  if inventory.product_available?
+    reply.available        = true
+    reply.quantity         = 100
+  else
+    reply.available = false
+  end
+
+  reply
+end
+```
+
+The above #process_request method should now take on average 1,810 milli-seconds
+which is significantly faster than the 3,780 milli-seconds it took to perform
+the exact same request, but using only a single thread
+
+The exact breakdown of which calls to do in the main thread versus a Minion is determined
+through experience and trial and error over time. The key is logging the duration
+of each call which Minion does by default so that the exact processing breakdown
+can be fine-tuned over time.
+
+Meta
+----
+
+* Code: `git clone git://github.com/reidmorrison/parallel_minion.git`
+* Home: <https://github.com/reidmorrison/parallel_minion>
+* Bugs: <http://github.com/reidmorrison/parallel_minion/issues>
+* Gems: <http://rubygems.org/gems/parallel_minion>
+
+This project uses [Semantic Versioning](http://semver.org/).
+
+Author
+-------
+
+Reid Morrison :: reidmo@gmail.com :: @reidmorrison
+
+Contributors
+------------
+
+
+License
+-------
+
+Copyright 2013 Reid Morrison
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,23 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'rubygems'
+require 'rubygems/package'
+require 'rake/clean'
+require 'rake/testtask'
+require 'parallel_minion/version'
+
+desc "Build gem"
+task :gem  do |t|
+  Gem::Package.build(Gem::Specification.load('parallel_minion.gemspec'))
+end
+
+desc "Run Test Suite"
+task :test do
+  Rake::TestTask.new(:functional) do |t|
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose    = true
+  end
+
+  Rake::Task['functional'].invoke
+end

data/lib/parallel_minion.rb

@@ -0,0 +1,8 @@
+require 'thread'
+require 'semantic_logger'
+
+module ParallelMinion
+  autoload :Minion,    'parallel_minion/minion'
+end
+
+require 'parallel_minion/railtie' if defined?(Rails)

data/lib/parallel_minion/horde.rb

@@ -0,0 +1,41 @@
+require 'minion'
+
+# A Horde is way to manage a group of Minions
+#
+# Horde supports the following features for minions
+# - Limit the number of Minions in the Horde to prevent overloading the system
+# - Queue up requests for Minions when the lmit is reached
+# - Optionally block submitting work for Minions when the queued up requests
+#   reach a specified number
+class Horde
+  include SemanticLogger::Loggable
+
+  # Returns the description for this Horde
+  attr_reader :description
+
+  # Returns the maximum number of Minions active in this Horde at any time
+  attr_reader :capacity
+
+  # Returns the maximum number of queued up requests before blocking
+  # new requests for work
+  attr_reader :max_queue_size
+
+  # Create a new Horde of Minions
+  #
+  # Parameters
+  #   :description
+  #     Description for this task that the Minion is performing
+  #     Put in the log file along with the time take to complete the task
+  #
+  #   :capacity
+  #     Maximum number of Minions active in this Horde at any time
+  #     Default: 10
+  #
+  #   :max_queue_size
+  #     Maximum number of queued up requests before blocking
+  #     new requests for work
+  #     Default: -1 (unlimited)
+  #
+  def initialize(params={})
+  end
+end

data/lib/parallel_minion/minion.rb

@@ -0,0 +1,237 @@
+# Instruct a Minion to perform a specific task in a separate thread
+module ParallelMinion
+  class Minion
+    include SemanticLogger::Loggable
+
+    # Returns [String] the description supplied on the initializer
+    attr_reader :description
+
+    # Returns [Exception] the exception that was raised otherwise nil
+    attr_reader :exception
+
+    # Returns [Integer] the maximum duration in milli-seconds that the Minion may take to complete the task
+    attr_reader :timeout
+
+    # Give an infinite amount of time to wait for a Minion to complete a task
+    INFINITE = -1
+
+    # Sets whether to run in Synchronous mode
+    #
+    # By Setting synchronous to true all Minions that have not yet been started
+    # will run in the thread from which they are started and not in their own
+    # threads
+    #
+    # This is useful:
+    # - to run tests under the Capybara gem
+    # - when debugging code so that all code is run sequentially in the current thread
+    #
+    # Note: Do not set this setting to true in Production
+    def self.synchronous=(synchronous)
+      @@synchronous = synchronous
+    end
+
+    # Returns whether running in Synchronous mode
+    def self.synchronous?
+      @@synchronous
+    end
+
+    # The list of classes for which the current scope must be copied into the
+    # new Minion (Thread)
+    #
+    # Example:
+    #   ...
+    def self.scoped_classes
+      @@scoped_classes
+    end
+
+    # Create a new thread and
+    #   Log the time for the thread to complete processing
+    #   The exception without stack trace is logged whenever an exception is
+    #   thrown in the thread
+    #   Re-raises any unhandled exception in the calling thread when it call #result
+    #   Copy the logging tags and specified ActiveRecord scopes to the new thread
+    #
+    # Parameters
+    #   :description [String]
+    #     Description for this task that the Minion is performing
+    #     Put in the log file along with the time take to complete the task
+    #
+    #   :timeout [Integer]
+    #     Maximum amount of time in milli-seconds that the task may take to complete
+    #     before #result times out
+    #     Set to Minion::INFINITE to give the thread an infinite amount of time to complete
+    #     Default: Minion::INFINITE
+    #
+    #     Notes:
+    #     - :timeout does not affect what happens to the Minion running the
+    #       the task, it only affects how long #result will take to return.
+    #     - The Minion will continue to run even after the timeout has been exceeded
+    #     - If :synchronous is true, or ParallelMinion::Minion.synchronous is
+    #       set to true, then :timeout is ignored and assumed to be Minion::INFINITE
+    #       since the code is run in the calling thread when the Minion is created
+    #
+    #   :synchronous [Boolean]
+    #     Whether the Minion should run in the current thread
+    #     Not recommended in Production, but is useful for debugging purposes
+    #     Default: false
+    #
+    #   *args
+    #     Any number of arguments can be supplied that are passed into the block
+    #     in the order they are listed
+    #     It is recommended to duplicate and/or freeze objects passed as arguments
+    #     so that they are not modified at the same time by multiple threads
+    #
+    #   Proc / lambda
+    #     A block of code must be supplied that the Minion will execute
+    #     NOTE: This block will be executed within the scope of the created minion
+    #           instance and _not_ within the scope of where the Proc/lambda was
+    #           originally created.
+    #           This is done to force all parameters to be passed in explicitly
+    #           and should be read-only or duplicates of the original data
+    #
+    # The overhead for moving the task to a Minion (separate thread) vs running it
+    # sequentially is about 0.3 ms if performing other tasks in-between starting
+    # the task and requesting its result.
+    #
+    # The following call adds 0.5 ms to total processing time vs running the
+    # code in-line:
+    #   ParallelMinion::Minion.new(description: 'Count', timeout: 5) { 1 }.result
+    #
+    # NOTE:
+    #   On JRuby it is very important to add the following setting to .jrubyrc
+    #       thread.pool.enabled=true
+    #
+    # Example:
+    #   ParallelMinion::Minion.new(10.days.ago, description: 'Doing something else in parallel', timeout: 1000) do |date|
+    #     MyTable.where('created_at <= ?', date).count
+    #   end
+    def initialize(*args, &block)
+      raise "Missing mandatory block that Minion must perform" unless block
+      @start_time = Time.now
+      @exception = nil
+
+      options = self.class.extract_options!(args).dup
+
+      @timeout  = (options.delete(:timeout) || Minion::INFINITE).to_f
+      @description   = (options.delete(:description) || 'Minion').to_s
+      @log_exception = options.delete(:log_exception)
+      @synchronous   = options.delete(:synchronous) || self.class.synchronous?
+
+      # Warn about any unknown options.
+      options.each_pair { |key,val| logger.warn "Ignoring unknown option: #{key.inspect} => #{val.inspect}" }
+
+      # Run the supplied block of code in the current thread for testing or
+      # debugging purposes
+      if @synchronous == true
+        begin
+          logger.info("Started synchronously #{@description}")
+          logger.benchmark_info("Completed synchronously #{@description}", log_exception: @log_exception) do
+            @result = instance_exec(*args, &block)
+          end
+        rescue Exception => exc
+          @exception = exc
+        end
+        return
+      end
+
+      tags = (logger.tags || []).dup
+
+      # Copy current scopes for new thread. Only applicable for AR models
+      scopes = self.class.current_scopes.dup if defined?(ActiveRecord::Base)
+
+      @thread = Thread.new(*args) do
+        # Copy logging tags from parent thread
+        logger.tagged(*tags) do
+          # Set the current thread name to the description for this Minion
+          # so that all log entries in this thread use this thread name
+          Thread.current.name = "#{@description}-#{Thread.current.object_id}"
+          logger.info("Started #{@description}")
+
+          begin
+            logger.benchmark_info("Completed #{@description}", log_exception: @log_exception) do
+              # Use the current scope for the duration of the task execution
+              if scopes.nil? || (scopes.size == 0)
+                @result = instance_exec(*args, &block)
+              else
+                # Each Class to scope requires passing a block to .scoping
+                proc = Proc.new { instance_exec(*args, &block) }
+                first = scopes.shift
+                scopes.each {|scope| proc = Proc.new { scope.scoping(&proc) } }
+                @result = first.scoping(&proc)
+              end
+            end
+          rescue Exception => exc
+            @exception = exc
+            nil
+          ensure
+            # Return any database connections used by this thread back to the pool
+            ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+          end
+        end
+      end
+    end
+
+    # Returns the result when the thread completes
+    # Returns nil if the thread has not yet completed
+    # Raises any unhandled exception in the thread, if any
+    #
+    # Note: The result of any thread cannot be nil
+    def result
+      # Return nil if Minion is still working and has time left to finish
+      if working?
+        ms = time_left
+        return if @thread.join(ms.nil? ? nil: ms / 1000).nil?
+      end
+
+      # Return the exception, if any, otherwise the task result
+      exception.nil? ? @result : Kernel.raise(exception)
+    end
+
+    # Returns [Boolean] whether the minion is still working on the assigned task
+    def working?
+      synchronous? ? false : @thread.alive?
+    end
+
+    # Returns [Boolean] whether the minion has completed working on the task
+    def completed?
+      synchronous? ? true : @thread.stop?
+    end
+
+    # Returns [Boolean] whether the minion failed while performing the assigned task
+    def failed?
+      !exception.nil?
+    end
+
+    # Returns the amount of time left in milli-seconds that this Minion has to finish its task
+    # Returns 0 if no time is left
+    # Returns nil if their is no time limit. I.e. :timeout was set to Minion::INFINITE (infinite time left)
+    def time_left
+      return nil if @timeout == INFINITE
+      duration = @timeout - (Time.now - @start_time) * 1000
+      duration <= 0 ? 0 : duration
+    end
+
+    # Returns [Boolean] whether synchronous mode has been enabled for this minion instance
+    def synchronous?
+      @synchronous
+    end
+
+    # Returns the current scopes for each of the models for which scopes will be
+    # copied to the Minions
+    def self.current_scopes
+      # Apparently #scoped is deprecated, but its replacement #all does not behave the same
+      @@scoped_classes.collect {|klass| klass.scoped.dup}
+    end
+
+    protected
+
+    @@synchronous = false
+    @@scoped_classes = []
+
+    # Extract options from a hash.
+    def self.extract_options!(args)
+      args.last.is_a?(Hash) ? args.pop : {}
+    end
+
+  end
+end

data/lib/parallel_minion/railtie.rb

@@ -0,0 +1,20 @@
+module ParallelMinion #:nodoc:
+  class Railtie < Rails::Railtie #:nodoc:
+    #
+    # Make the ParallelMinion config available in the Rails application config
+    #
+    # Example: Make debugging easier
+    #    in file config/environments/development.rb
+    #
+    #   Rails::Application.configure do
+    #
+    #     # Run Minions in the current thread to make debugging easier
+    #     config.parallel_minion.synchronous = true
+    #
+    #     # Add a model so that its current scope is copied to the Minion
+    #     config.parallel_minion.scoped_classes << MyScopedModel
+    #   end
+    config.parallel_minion = ::ParallelMinion::Minion
+
+  end
+end

data/lib/parallel_minion/version.rb

@@ -0,0 +1,3 @@
+module ParallelMinion #:nodoc
+  VERSION = "0.0.1"
+end

data/test/config/database.yml

@@ -0,0 +1,5 @@
+test:
+  adapter:  sqlite3
+  database: test/test_db.sqlite3
+  pool:     5
+  timeout:  5000

data/test/minion_scope_test.rb

@@ -0,0 +1,74 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'semantic_logger'
+# Register an appender if one is not already registered
+SemanticLogger.default_level = :trace
+SemanticLogger.add_appender('test.log', &SemanticLogger::Appender::Base.colorized_formatter) if SemanticLogger.appenders.size == 0
+
+require 'rubygems'
+require 'erb'
+require 'test/unit'
+# Since we want both the AR and Mongoid extensions loaded we need to require them first
+require 'active_record'
+require 'active_record/relation'
+# Should redefines Proc#bind so must include after Rails
+require 'shoulda'
+require 'parallel_minion'
+
+ActiveRecord::Base.logger = SemanticLogger[ActiveRecord]
+ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read('test/config/database.yml')).result)
+ActiveRecord::Base.establish_connection('test')
+
+ActiveRecord::Schema.define :version => 0 do
+  create_table :people, :force => true do |t|
+    t.string :name
+    t.string :state
+    t.string :zip_code
+  end
+end
+
+class Person < ActiveRecord::Base
+end
+
+class MinionScopeTest < Test::Unit::TestCase
+
+  context ParallelMinion::Minion do
+    [false, true].each do |synchronous|
+      context ".new with synchronous: #{synchronous.inspect}" do
+        setup do
+          Person.create(name: 'Jack', state: 'FL', zip_code: 38729)
+          Person.create(name: 'John', state: 'FL', zip_code: 35363)
+          Person.create(name: 'Jill', state: 'FL', zip_code: 73534)
+          Person.create(name: 'Joe',  state: 'NY', zip_code: 45325)
+          Person.create(name: 'Jane', state: 'NY', zip_code: 45325)
+          Person.create(name: 'James', state: 'CA', zip_code: 123123)
+          # Instruct Minions to adhere to any dynamic scopes for Person model
+          ParallelMinion::Minion.scoped_classes << Person
+          ParallelMinion::Minion.synchronous = synchronous
+        end
+
+        teardown do
+          Person.destroy_all
+          ParallelMinion::Minion.scoped_classes.clear
+          SemanticLogger.flush
+        end
+
+        should 'copy across model scope' do
+          assert_equal 6, Person.count
+
+          Person.unscoped.where(state: 'FL').scoping { Person.count }
+
+          Person.unscoped.where(state: 'FL').scoping do
+            assert_equal 3, Person.count
+            minion = ParallelMinion::Minion.new(description: 'Scope Test', log_exception: :full) do
+              Person.count
+            end
+            assert_equal 3, minion.result
+          end
+        end
+
+      end
+    end
+  end
+end

data/test/minion_test.rb

@@ -0,0 +1,109 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'shoulda'
+require 'parallel_minion'
+
+# Register an appender if one is not already registered
+SemanticLogger.default_level = :trace
+SemanticLogger.add_appender('test.log', &SemanticLogger::Appender::Base.colorized_formatter) if SemanticLogger.appenders.size == 0
+
+# Test ParallelMinion standalone without Rails
+# Run this test standalone to verify it has no Rails dependencies
+class MinionTest < Test::Unit::TestCase
+  include SemanticLogger::Loggable
+
+  context ParallelMinion::Minion do
+
+    [false, true].each do |synchronous|
+      context ".new with synchronous: #{synchronous.inspect}" do
+        setup do
+          ParallelMinion::Minion.synchronous = synchronous
+        end
+
+        should 'without parameters' do
+          minion = ParallelMinion::Minion.new { 196 }
+          assert_equal 196, minion.result
+        end
+
+        should 'with a description' do
+          minion = ParallelMinion::Minion.new(description: 'Test') { 197 }
+          assert_equal 197, minion.result
+        end
+
+        should 'with an argument' do
+          p1 = { name: 198 }
+          minion = ParallelMinion::Minion.new(p1, description: 'Test') do |v|
+            v[:name]
+          end
+          assert_equal 198, minion.result
+        end
+
+        should 'raise exception' do
+          minion = ParallelMinion::Minion.new(description: 'Test') { raise "An exception" }
+          assert_raise RuntimeError do
+            minion.result
+          end
+        end
+
+# TODO Blocks still have access to their original scope if variables cannot be
+#      resolved first by the parameters, then by the values in Minion itself
+#        should 'not have access to local variables' do
+#          name = 'Jack'
+#          minion = ParallelMinion::Minion.new(description: 'Test') { puts name }
+#          assert_raise NameError do
+#            minion.result
+#          end
+#        end
+
+        should 'run minion' do
+          hash = { value: 23 }
+          value = 47
+          minion = ParallelMinion::Minion.new(hash, description: 'Test') do |h|
+            value = 321
+            h[:value] = 123
+            456
+          end
+          assert_equal 456, minion.result
+          assert_equal 123, hash[:value]
+          assert_equal 321, value
+        end
+
+        should 'copy across logging tags' do
+          minion = nil
+          logger.tagged('TAG') do
+            assert_equal 'TAG', logger.tags.last
+            minion = ParallelMinion::Minion.new(description: 'Tag Test') do
+              logger.tags.last
+            end
+          end
+          assert_equal 'TAG', minion.result
+        end
+
+        should 'handle multiple minions concurrently' do
+          # Start 10 minions
+          minions = 10.times.collect do |i|
+            # Each Minion returns its index in the collection
+            ParallelMinion::Minion.new(i, description: "Minion:#{i}") {|counter| counter }
+          end
+          assert_equal 10, minions.count
+          # Fetch the result from each Minion
+          minions.each_with_index do |minion, index|
+            assert_equal index, minion.result
+          end
+        end
+
+        should 'timeout' do
+          minion = ParallelMinion::Minion.new(description: 'Test', timeout: 100) { sleep 1 }
+          # Only Parallel Minions time-out when they exceed timeout
+          unless synchronous
+            assert_equal nil, minion.result
+          end
+        end
+      end
+
+    end
+
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: parallel_minion
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Reid Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: semantic_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parallel Minion supports easily handing work off to Minions (Threads)
+  so that tasks that would normally be performed sequentially can easily be executed
+  in parallel
+email:
+- reidmo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/parallel_minion/horde.rb
+- lib/parallel_minion/minion.rb
+- lib/parallel_minion/railtie.rb
+- lib/parallel_minion/version.rb
+- lib/parallel_minion.rb
+- Rakefile
+- README.md
+- test/config/database.yml
+- test/minion_scope_test.rb
+- test/minion_test.rb
+- test/test_db.sqlite3
+homepage: https://github.com/ClarityServices/semantic_logger
+licenses:
+- Apache License V2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '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: Concurrent processing made easy with Minions (Threads)
+test_files:
+- test/config/database.yml
+- test/minion_scope_test.rb
+- test/minion_test.rb
+- test/test_db.sqlite3