wind_up 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79c283c998f19e33759901fca41cfb5c00219db2
-  data.tar.gz: 739bf5be6f00edba35343cc8f1fbf9a15b909ad8
+  metadata.gz: b7c5a7df34c4d2083d84ab27b16a1535a645d12a
+  data.tar.gz: dbde5970c7f5437e9d38755b454d552f6cdfd92a
 SHA512:
-  metadata.gz: 6ae64913bcdd2eebcc0bd26f12a8c0649d259b44cb3bb191a35f631c842604791d7111a36a60c62f28d336ca17ed221304f55aad8bcdf83e5085defc0be1c98e
-  data.tar.gz: e13d341414cb2b0ad0c65cdf7757648bbd37110dcc4e5435c782205e81d01153f9c42cab2907d32b38709574218155f138085100c0ae5b915917f4dea820a92a
+  metadata.gz: 1e44db4d841a2dfd63495b9918eacb9a498826b641812f62a99ed04abd7e802adcf9d721c3f3e74b330174248fd98d17226fe252281cc04f821e7dc7f8a4b27e
+  data.tar.gz: 7b476af5f07282981a26aa38bab7e415ca5afd618b6c523293273a461aa7edf5296eac2e3d0a1d6dff04f997f3ed5b7553cd83a9da3a033655650c441be3e638

data/README.md

@@ -1,87 +1,67 @@
-Wind Up
-=======
-WindUp is a drop-in replacement for Celluloid's `PoolManager` class. So why
-would you use WindUp?
-
-* Asynchronous message passing - get all the nice worker-level concurrency
-  Celluloid give you (#sleep, #Celluloid::IO, #future, etc)
-* Separate proxies for QueueManager and queues - no more unexpected behavior
-  between #is_a? and #class
-* Single queue handles multiple workers - Extend WindUp with
-  [MultiWindUp](https://www.github.com/ryanlchan/multi_wind_up) and you can
-  have one pool execute multiple types of workers simultaneously
+WindUp
+===========
 
-Usage
------
-
-WindUp `Queues` are almost drop-in replacements for Celluloid pools.
+WindUp allows you to do super simple background processing using Celluloid
+Actors.
 
+Installation
+------------
 ```ruby
-q = AnyCelluloidClass.queue size: 3 # size defaults to number of cores
-q.any_method                # perform synchronously
-q.async.long_running_method # perform asynchronously
-q.future.i_want_this_back   # perform as a future
+# Gemspec
+gem 'wind_up'
 ```
 
-`Queues` use two separate proxies to control `Queue` commands vs
-`QueueManager` commands.
-```ruby
-# .queue returns the proxy for the queue (i.e. workers)
-q = AnyCelluloidClass.queue # => WindUp::QueueProxy(AnyCelluloidClass)
+Usage
+-----
 
-# Get the proxy for the manager from the QueueProxy
-q.__manager__ # => Celluloid::ActorProxy(WindUp::QueueManager)
+WindUp's `Delegator` allows us to use one queue to process multiple job types.
+`Delegator#perform_with` will instantiate a class and run its `#perform`
+method, passing any additional arguments provided.
 
-# Return to the queue from the manager
-q.__manager__.queue # WindUp::QueueProxy(AnyCelluloidClass)
-```
+Create a new `Delegator` queue using the WindUp Queue method. Use
+`Delegator#perform_with` to send tasks to this queue. Asynchronous processing
+is accomplished the same way you would with a WindUp Queue or Celluloid Pool;
+`#sync`, `#async`, and `#future` all continue to work as expected.
 
-You may store these `Queue` object in the registry as any actor
 ```ruby
-Celluloid::Actor[:queue] = q
-```
-
-Changing Routing Behavior (Advanced)
-------------------------------------
-
-WindUp accepts multiple types of routing behavior. Supported behaviors include:
+# Create a Delegator queue; these are equivalent
+queue = WindUp::Delegator.queue size: 3
+queue = WindUp.queue size: 3
+
+# Create a job class
+class GreetingJob
+  def perform(name = "Bob")
+    "Hello, #{name}!"
+  end
+end
 
-  * :random - Route messages to workers randomly
-  * :round_robin - Route messages to each worker sequentially
-  * :smallest_mailbox - Route messages to the worker with the smallest mailbox
-  * :first_available - Route messages to the first available worker (Default)
+# Send the delayed action to the Delegator queue
+queue.perform_with GreetingJob, "Hurried Harry" # => "Hello, Hurried Harry!", completed synchronously
+queue.async.perform_with GreetingJob, "Mellow Mary" # => nil, work completed in background
+queue.future.perform_with GreetingJob, "Telepathic Tim" # => Celluloid::Future, with value "Hello, Telepathic Tim!"
 
-To configure your queue to use a specific routing style, specify the routing
-behavior when calling .queue:
+# Store this queue for later usage
+Celluloid::Actor[:background] = queue
+# Later...
+Celluloid::Actor[:background].async.perform_with GreetingJob, "Tina"
 
-```ruby
-# Use a random router
-Klass.queue router: :random
 ```
 
-You can specify your own custom routing behavior as well:
-```ruby
-class FirstRouter < WindUp::Router::Base
-  # Returns the next subscriber to route a message to
-  def next_subscriber
-    subscribers.first
-  end
-end
+Tips
+----
 
-# Register this router
-WindUp::Routers.register :first, FirstRouter
+* Don't share state from your current thread with your Jobs!
 
-# Use this router
-q = Klass.queue router: :first
-
-```
+  With WindUp, your jobs will be *eventually* processed, but we have no idea
+  how long it'll be. As such, your jobs and messages should not share state.
+  I.e., don't pass a User object; pass a user.id and recreates the user from
+  the database within your job.
 
-Multiple worker types per queue
--------------------------------
+* Use JSON serializable arguments for your jobs
 
-This part of WindUp has been extracted to its own gem,
-[MultiWindUp](https://www.github.com/ryanlchan/multi_wind_up).
-WindUp now only contains the pooling implementation.
+  Not only is it a good way to prevent yourself from accidentally sharing
+  state (see previous point), but if you want to use a persistant job store
+  you cannot pass in any objects that can't be dumped to JSON.
 
 ## Contributing
 

data/lib/wind_up.rb

@@ -1,20 +1,8 @@
-require 'celluloid'
-require 'wind_up/exceptions'
-require 'wind_up/calls'
-require 'wind_up/routers'
-require 'wind_up/queue_proxy'
-require 'wind_up/queue_manager'
+require 'wind_up/delegator'
 require 'wind_up/version'
-require 'wind_up/celluloid_ext'
 
 module WindUp
-  def self.logger
-    Celluloid.logger
-  end
-
-  def self.logger=(logger)
-    Celluloid.logger = logger
+  def self.queue(opts = {})
+    Delegator.queue opts
   end
 end
-
-require 'wind_up/railtie' if defined?(::Rails)

data/lib/wind_up/delegator.rb

@@ -0,0 +1,50 @@
+# A worker to enable flexible, queue-based background processing
+# ---
+# Ever wish you could reuse the same background worker pool for multiple types
+# of work? WindUp's `Delegator` was designed to solve this problem.
+#
+# `Delegator#perform_with` will instantiate the class and run its
+#   #perform method with any additional arguments provided
+# * Gracefully handles errors/crashes
+# * Use just like a WindUp Queue or Celluloid Pool; `#sync`, `#async`, and
+#   `#future` all work
+#
+# Usage
+# -----
+# Create a new `Delegator` queue using the WindUp Queue method. Use
+# `Delegator#perform_with` to perform tasks in the background.
+#
+# ```ruby
+# # Create a Delegator queue
+# queue = WindUp::Delegator.queue size: 3
+#
+# # Create a job class
+# class GreetingJob
+#   def perform(name = "Bob")
+#     "Hello, #{name}!"
+#   end
+# end
+#
+# # Send the delayed action to the Delegator queue
+# queue.async.perform_with GreetingJob, "Mary" # => nil, work completed in background
+# queue.future.perform_with GreetingJob, "Tim" # => Celluloid::Future, with value "Hello, Tim!"
+#
+# # Store your queue for future usage
+# Celluloid::Actor[:greeting_queue] = queue
+# ```
+module WindUp
+  class InvalidDelegatee < StandardError; end
+
+  class Delegator
+    include Celluloid
+
+    # Instantiate the referenced class and run the #perform action
+    # @param delegatee [Class] the class to delegate to
+    # @return [Object] the return value of the action
+    def perform_with(delegatee, *args)
+      handler = delegatee.new
+      raise InvalidDelegatee, "#{delegatee} does not have a #perform method defined" unless handler.respond_to?(:perform)
+      handler.perform *args
+    end
+  end
+end

data/lib/wind_up/version.rb

@@ -1,3 +1,3 @@
 module WindUp
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/lib/delegator_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+class MissingPerform; end
+
+class TestHandler
+  def perform(*args)
+    if args.size > 0
+      :args
+    else
+      :done
+    end
+  end
+end
+
+class TestQueuer
+  def perform(queue)
+    queue << :done
+  end
+end
+
+
+describe WindUp::Delegator do
+  describe '#perform_with' do
+    let(:worker) { WindUp::Delegator.new }
+    context 'when not passed a delegatee' do
+      it 'raises an exception' do
+        mute_celluloid_logging do
+          expect{ worker.perform_with }.to raise_exception
+        end
+      end
+    end
+
+    context 'when passed a delegatee' do
+      context 'but does not have a #perform method' do
+        it 'raises an exception' do
+          mute_celluloid_logging do
+            expect{ worker.perform_with MissingPerform }.to raise_exception(WindUp::InvalidDelegatee)
+          end
+        end
+      end
+      context 'and has a #perform method' do
+        it 'initializes the handler class' do
+          worker.perform_with(TestHandler).should eq :done
+        end
+
+        it 'passes the arguments from the method' do
+          worker.perform_with(TestHandler, :argument).should eq :args
+        end
+      end
+    end
+  end
+
+  context 'when queued' do
+    let(:queue) { WindUp::Delegator.queue }
+    it 'returns synchronously' do
+      queue.perform_with(TestHandler).should eq :done
+    end
+
+    it 'returns asynchronously' do
+      q = Queue.new
+      queue.async.perform_with TestQueuer, q
+      q.pop.should eq :done
+    end
+
+    it 'returns as a future' do
+      f = queue.future.perform_with TestHandler
+      f.value.should eq :done
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,14 +4,20 @@ rescue LoadError
 end
 
 require 'celluloid'
+require 'wind_up_queue'
 require 'wind_up'
 
 Celluloid.shutdown; Celluloid.boot
 
+LOGGING_MUTEX = Mutex.new
 def mute_celluloid_logging
-  # Temporarily mute celluloid logger
-  Celluloid.logger.level = Logger::FATAL
-  yield if block_given?
-  # Restore celluloid logger
-  Celluloid.logger.level = Logger::DEBUG
+  LOGGING_MUTEX.synchronize do
+    # Temporarily mute celluloid logger
+    Celluloid.logger.level = Logger::FATAL
+    yield if block_given?
+    # Allow any async messages to process before completing
+    sleep 0.01
+    # Restore celluloid logger
+    Celluloid.logger.level = Logger::DEBUG
+  end
 end

data/spec/wind_up_spec.rb

@@ -1,14 +1,9 @@
 require 'spec_helper'
 
 describe WindUp do
-  describe '.logger' do
-    it "delegates get to Celluloid's logger" do
-      WindUp.logger.should == Celluloid.logger
-    end
-
-    it "delegates set to Celluloid's logger" do
-      Celluloid.should_receive(:logger=)
-      WindUp.logger = nil
+  describe '.queue' do
+    it 'creates a delegator queue' do
+      WindUp.queue.should be_a(WindUp::Delegator)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wind_up
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Ryan Chan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-20 00:00:00.000000000 Z
+date: 2013-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -39,50 +39,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: celluloid
+  name: wind_up_queue
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.14.1
+        version: 0.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.14.1
-description: WindUp is a simple background processing library meant to improve on
-  Celluloid's pools
+        version: 0.0.1
+description: WindUp enables simple background processing using Celluloid Actors
 email:
 - ryan@ryanlchan.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .ruby-gemset
-- .ruby-version
-- CHANGES.md
-- Gemfile
-- Gemfile.lock
-- LICENSE.txt
 - README.md
-- Rakefile
-- lib/wind_up.rb
-- lib/wind_up/calls.rb
-- lib/wind_up/celluloid_ext.rb
-- lib/wind_up/exceptions.rb
-- lib/wind_up/queue_manager.rb
-- lib/wind_up/queue_proxy.rb
-- lib/wind_up/railtie.rb
+- lib/wind_up/delegator.rb
 - lib/wind_up/routers.rb
 - lib/wind_up/version.rb
+- lib/wind_up.rb
+- spec/lib/delegator_spec.rb
 - spec/spec_helper.rb
-- spec/wind_up/queue_manager_spec.rb
-- spec/wind_up/queue_spec.rb
 - spec/wind_up/routers_spec.rb
 - spec/wind_up_spec.rb
-- wind_up.gemspec
 homepage: https://github.com/ryanlchan/wind_up
 licenses: []
 metadata: {}
@@ -105,10 +90,9 @@ rubyforge_project:
 rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
-summary: A drop-in replacement for Celluloid pools using the message API
+summary: Super simple background processing
 test_files:
+- spec/lib/delegator_spec.rb
 - spec/spec_helper.rb
-- spec/wind_up/queue_manager_spec.rb
-- spec/wind_up/queue_spec.rb
 - spec/wind_up/routers_spec.rb
 - spec/wind_up_spec.rb

data/.ruby-gemset

@@ -1 +0,0 @@
-wind_up

data/.ruby-version

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

data/CHANGES.md

@@ -1,9 +0,0 @@
-CHANGELOG
-=========
-
-## 0.0.2 ##
-* Use Akka-style routers
-
-
-## 0.0.1 ##
-* Initial release

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in wind_up.gemspec
-gemspec

data/Gemfile.lock

@@ -1,30 +0,0 @@
-PATH
-  remote: .
-  specs:
-    wind_up (0.0.2)
-      celluloid (~> 0.14.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    celluloid (0.14.1)
-      timers (>= 1.0.0)
-    diff-lcs (1.2.4)
-    rake (10.1.0)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.1)
-    timers (1.1.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  rake
-  rspec
-  wind_up!

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2013 Ryan Chan
-
-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.
-
-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.

data/Rakefile

@@ -1,16 +0,0 @@
-require "bundler/gem_tasks"
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new('spec')
-
-# If you want to make this the default task
-task :default => :spec
-task :test => :spec
-
-task :console do
-  exec "irb -r wind_up -I ./lib"
-end
-
-task :rspec do
-  exec "rspec -f doc --color"
-end

data/lib/wind_up/calls.rb

@@ -1,27 +0,0 @@
-module WindUp
-  # WindUp's ForwardedCall tells an actor to pull a message from a source
-  # mailbox when processed
-  class ForwardedCall < Celluloid::Call
-
-    # Do not block if no work found
-    TIMEOUT = 0
-
-    def initialize(source)
-      @source = source
-    end
-
-    # Pull the next message from the source, if available
-    def dispatch(obj)
-      msg = @source.receive(TIMEOUT)
-      ::Celluloid.mailbox << msg if msg
-    end
-  end
-
-  # Wraps a TerminationRequest for standard ordering within a mailbox
-  class DelayedTerminationRequest < Celluloid::Call
-    def initialize
-      @method = :terminate
-    end
-  end
-end
-

data/lib/wind_up/celluloid_ext.rb

@@ -1,10 +0,0 @@
-# Extend Celluloid with the ability to use Klass.queue
-module WindUp
-  module CelluloidExts
-    def queue(options = {})
-      WindUp::QueueManager.new(self, options).queue
-    end
-  end
-end
-
-Celluloid::ClassMethods.send :include, WindUp::CelluloidExts

data/lib/wind_up/exceptions.rb

@@ -1,3 +0,0 @@
-module WindUp
-  class MissingWorkerClass < StandardError; end
-end

data/lib/wind_up/queue_manager.rb

@@ -1,138 +0,0 @@
-# Manages a queue of workers
-# Accumulates/stores messages and supervises a group of workers
-# WindUp `Queues` are almost drop-in replacements for Celluloid pools.
-#
-# ```ruby
-# q = AnyCelluloidClass.queue size: 3 # size defaults to number of cores
-# q.any_method                # perform synchronously
-# q.async.long_running_method # perform asynchronously
-# q.future.i_want_this_back   # perform as a future
-# ```
-#
-# `Queues` use two separate proxies to control `Queue` commands vs
-# `QueueManager` commands.
-# ```ruby
-# # .queue returns the proxy for the queue (i.e. workers)
-# q = AnyCelluloidClass.queue # => WindUp::QueueProxy(AnyCelluloidClass)
-#
-# # Get the proxy for the manager from the QueueProxy
-# q.__manager__ # => Celluloid::ActorProxy(WindUp::QueueManager)
-#
-# # Return to the queue from the manager
-# q.__manager__.queue # WindUp::QueueProxy(AnyCelluloidClass)
-# ```
-#
-# You may store these `Queue` object in the registry as any actor
-# ```ruby
-# Celluloid::Actor[:queue] = q
-# ```
-module WindUp
-  class QueueManager
-    include Celluloid
-    attr_reader :size, :router, :worker_class
-
-    trap_exit :restart_actor
-
-    # Don't use QueueManager.new, use Klass.queue instead
-    def initialize(worker_class, options = {})
-      defaults = { :size => [Celluloid.cores, 2].max,
-                   :router => :first_available }
-      options = defaults.merge options
-
-      @worker_class = worker_class
-      @args = options[:args] ? Array(options[:args]) : []
-      @size = options[:size]
-
-      router_class = Routers[options[:router]]
-      raise ArgumentError, "Router class not recognized" unless router_class
-      @router = router_class.new
-
-      @registry = Celluloid::Registry.root
-      @group    = []
-      resize_group
-    end
-
-    # Terminate our supervised group on finalization
-    finalizer :__shutdown__
-    def __shutdown__
-      @router.shutdown
-      group.reverse_each(&:terminate)
-    end
-
-    ###########
-    # Helpers #
-    ###########
-
-    # Access the Queue's proxy
-    def queue
-      WindUp::QueueProxy.new Actor.current
-    end
-
-    # Resize this queue's worker group
-    # NOTE: Using this to down-size your queue CAN truncate ongoing work!
-    #   Workers which are waiting on blocks/sleeping will receive a termination
-    #   request prematurely!
-    # @param num [Integer] Number of workers to use
-    def size=(num)
-      @size = num
-      resize_group
-    end
-
-    # Return the size of the queue backlog
-    # @return [Integer] the number of messages queueing
-    def backlog
-      @router.size
-    end
-
-    def inspect
-      "<Celluloid::ActorProxy(#{self.class}) @size=#{@size} @worker_class=#{@worker_class} @backlog=#{backlog}>"
-    end
-
-    ####################
-    # Group Management #
-    ####################
-
-    # Restart a crashed actor
-    def restart_actor(actor, reason)
-      member = group.find do |_member|
-        _member.actor == actor
-      end
-      raise "A group member went missing. This shouldn't be!" unless member
-
-      if reason
-        member.restart(reason)
-      else
-        # Remove from group on clean shutdown
-        group.delete_if do |_member|
-          _member.actor == actor
-        end
-      end
-    end
-
-    private
-    def group
-      @group ||= []
-    end
-
-    # Resize the worker group in this queue
-    # You should probably be using #size=
-    # @param target [Integer] the targeted number of workers to grow to
-    def resize_group(target = size)
-      delta = target - group.size
-      if delta == 0
-        # *Twiddle thumbs*
-        return
-      elsif delta > 0
-        # Increase pool size
-        delta.times do
-          worker = Celluloid::SupervisionGroup::Member.new @registry, @worker_class, :args => @args
-          group << worker
-          @router.add_subscriber(worker.actor.mailbox)
-        end
-      else
-        # Truncate pool
-        delta.abs.times { @router << DelayedTerminationRequest.new }
-      end
-    end
-  end
-end

data/lib/wind_up/queue_proxy.rb

@@ -1,37 +0,0 @@
-# A proxy object which sends calls to a Queue mailbox
-module WindUp
-  class QueueProxy < Celluloid::ActorProxy
-     def initialize(manager)
-      @mailbox       = manager.router
-      @klass         = manager.worker_class.to_s
-      @sync_proxy    = ::Celluloid::SyncProxy.new(@mailbox, @klass)
-      @async_proxy   = ::Celluloid::AsyncProxy.new(@mailbox, @klass)
-      @future_proxy  = ::Celluloid::FutureProxy.new(@mailbox, @klass)
-
-      @manager_proxy = manager
-    end
-
-    # Escape route to access the QueueManager actor from the QueueProxy
-    def __manager__
-      @manager_proxy
-    end
-
-    # Reroute termination/alive? to the queue manager
-    def terminate
-      __manager__.terminate
-    end
-
-    def terminate!
-      __manager__.terminate!
-    end
-
-    def alive?
-      __manager__.alive?
-    end
-
-    def inspect
-      orig = super
-      orig.sub("Celluloid::ActorProxy", "WindUp::QueueProxy")
-    end
-  end
-end

data/lib/wind_up/railtie.rb

@@ -1,7 +0,0 @@
-module WindUp
-  class Railtie < ::Rails::Railtie
-    initializer "wind_up.logger" do
-      WindUp.logger = Rails.logger
-    end
-  end
-end

data/spec/wind_up/queue_manager_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-class FakeWorker
-  include Celluloid
-  def process(queue = nil)
-    if queue
-      queue << :done
-    else
-      :done
-    end
-  end
-
-  def crash
-    raise StandardError, "zomgcrash"
-  end
-end
-
-class SleepyWorker < FakeWorker
-  def sleepy
-    sleep 0.2
-    :done
-  end
-end
-
-
-describe WindUp::QueueManager do
-  let(:queue) { FakeWorker.queue size: 2 }
-  describe '#initialize' do
-    it 'creates a supervision group of workers' do
-      expect { FakeWorker.queue size: 1 }.to change { Celluloid::Actor.all.size }.by(2)
-    end
-
-    it 'creates as many workers as number of cores on the system' do
-      cores = FakeWorker.queue
-      cores.__manager__.size.should eq Celluloid.cores
-    end
-
-    it 'requires a worker class' do
-      mute_celluloid_logging do
-        expect { WindUp::QueueManager.new }.to raise_exception
-        sleep 0.1
-      end
-    end
-  end
-
-  describe '#terminate' do
-    it 'terminates the manager' do
-      queue.terminate
-      queue.should_not be_alive
-    end
-
-    it 'terminates the pool' do
-      expect{ queue.terminate }.to change { Celluloid::Actor.all.size }.by(0)
-    end
-  end
-
-  describe '#sync' do
-    it 'processs calls synchronously' do
-      queue.process.should be :done
-    end
-  end
-
-  describe '#async' do
-    it 'processs calls asynchronously' do
-      q = Queue.new
-      queue.async.process(q)
-      q.pop.should be :done
-    end
-
-    it 'processes additional work when workers as sleeping' do
-      sleepy_queue = SleepyWorker.queue size: 1
-      start_time = Time.now
-      vals = 2.times.map { sleepy_queue.future.sleepy }
-      vals.each { |v| v.value }
-      (start_time - Time.now).should be < 0.3
-    end
-
-    it 'handles crashed calls gracefully' do
-      mute_celluloid_logging do
-        queue.async.crash
-        queue.should be_alive
-      end
-    end
-  end
-
-  describe '#future' do
-    it 'processes calls as futures' do
-      f = queue.future.process
-      f.value.should be :done
-    end
-  end
-
-  describe '#size=' do
-    let(:manager) { queue.__manager__ }
-    it 'increases the size of the pool' do
-      manager.size.should eq 2
-      expect { manager.size = 3 }.to change{ Celluloid::Actor.all.size }.by(1)
-    end
-
-    it 'reduces the size of the pool' do
-      manager.size.should eq 2
-      expect { manager.size = 1 }.to change{ Celluloid::Actor.all.size }.by(-1)
-    end
-  end
-end

data/spec/wind_up/queue_spec.rb

@@ -1,372 +0,0 @@
-require 'spec_helper'
-
-class FakeWorker
-  include Celluloid
-  def perform(*args); end;
-end
-
-# Because we use a Singleton model, it's tough to change configurations
-# without redefining a ton of classes. This class just helps us dynamically
-# create Queue classes using a block.
-class QueueFactory
-  ALPHABET = ('a'..'z').to_a
-  def self.bake(&block)
-    name = 10.times.map{ ALPHABET.sample }.join.capitalize
-    c = WindUp::Queue.new name
-
-    if block_given?
-      c.instance_eval &block
-    else
-      c.instance_eval {
-        worker_class FakeWorker
-      }
-    end
-    return c
-  end
-end
-
-# describe WindUp::Queue, pending: "rewrite" do
-#   let(:queue) { QueueFactory.bake }
-#   describe "#store" do
-#     context "by default" do
-#       it "sets the InMemory store" do
-#         queue.store.should be_a(WindUp::Store::InMemory)
-#       end
-#     end
-#     context "when passed :memory or 'memory'" do
-#       it "sets the InMemory store" do
-#         queue.store(:memory).should be_a(WindUp::Store::InMemory)
-#         queue.store("memory").should be_a(WindUp::Store::InMemory)
-#         queue.store.should be_a(WindUp::Store::InMemory)
-#       end
-#     end
-#     context "when passed :redis or 'redis'" do
-#       it "sets the Redis store" do
-#         queue.store(:redis).should be_a(WindUp::Store::Redis)
-#         queue.store("redis").should be_a(WindUp::Store::Redis)
-#         queue.store.should be_a(WindUp::Store::Redis)
-#       end
-
-#       context "with a :url provided" do
-#         it "uses the url to connect to Redis" do
-#           queue.store(:redis, url: "redis://127.0.0.1:6379")
-#           queue.store.should be
-#         end
-#       end
-
-#       context 'with :connection set to a Redis client instance' do
-#         it 'works' do
-#           redis = Redis.new
-#           queue.store(:redis, connection: redis)
-#           queue.store.should be
-#         end
-#       end
-
-#       context 'with :connection set to a Redis connection_pool' do
-#         it 'works' do
-#           redis = ConnectionPool.new(size: 2, timeout: 5) { Redis.new }
-#           queue.store(:redis, connection: redis)
-#           queue.store.should be
-#         end
-#       end
-#     end
-#   end
-
-#   context '#pool' do
-#     context 'configured using :workers/:worker' do
-#       let(:queue) do
-#         QueueFactory.bake do
-#           worker_class FakeWorker
-#           workers 3
-#         end
-#       end
-
-#       it "sets up the pool" do
-#         queue.pool.should be
-#         queue.pool.size.should eq 3
-#       end
-#     end
-
-#     context ':pool_name' do
-#       context 'when given an existing pool' do
-#         it 'uses the existing pool' do
-#           Celluloid::Actor[:pool_name_spec] = FakeWorker.pool size: 2
-#           queue = QueueFactory.bake do
-#             pool_name :pool_name_spec
-#           end
-#           queue.pool.should be Celluloid::Actor[:pool_name_spec]
-#         end
-#       end
-#     end
-#   end
-
-#   context '#priority_level' do
-#     context 'that are equal' do
-#       it 'creates a queue with priority levels' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           priority_level :clone1
-#           priority_level :clone2
-#         end
-
-#         queue.should be
-#         queue.priority_levels.should_not be_empty
-#       end
-#     end
-
-#     context 'that are weighted' do
-#       it 'creates a queue with priority levels' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           priority_level :high, weight: 10
-#           priority_level :low, weight: 1
-#         end
-
-#         queue.should be
-#         queue.priority_levels.should_not be_empty
-#         queue.priority_level_weights.should eq({high: 10, low: 1})
-#       end
-#     end
-
-#     context 'that are strictly ordered' do
-#       it 'creates a queue with priority levels' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           strict true
-#           priority_level :clone1
-#           priority_level :clone2
-#         end
-
-#         queue.should be
-#         queue.priority_levels.should_not be_empty
-#         queue.should be_strict
-#       end
-#     end
-
-#     it 'does not create priority levels with the same name' do
-#       queue = QueueFactory.bake do
-#         worker_class FakeWorker
-#         strict true
-#         priority_level :clone1
-#         priority_level :clone1
-#       end
-
-#       queue.priority_levels.should eq Set[:clone1]
-#     end
-#   end # with priority leels
-
-#   describe '#push' do
-#     context 'when not given a priority level' do
-#       it 'pushes the argument to the store with default priority' do
-#         queue.store.should_receive(:push).with("test", priority_level: nil)
-#         queue.push "test"
-#       end
-#     end
-#     context 'when given a priority level' do
-#       it 'pushes the argument to the store with specified priority' do
-#         queue.store.should_receive(:push).with("test", priority_level: "high")
-#         queue.push "test", priority_level: "high"
-#       end
-#     end
-#   end
-
-#   describe '#pop' do
-#     context 'without a priority level argument' do
-#       context 'with a strictly ordered queue' do
-#         it 'pops priority levels in order' do
-#           queue = QueueFactory.bake do
-#             worker_class FakeWorker
-#             strict true
-#             priority_level :high
-#             priority_level :low
-#           end
-#           queue.store.should_receive(:pop).with([:high, :low]).at_least(1).times
-#           queue.pop
-#         end
-#       end
-#       context 'with a loosely ordered queue' do
-#         it 'pops priority levels in proportion' do
-#           queue = QueueFactory.bake do
-#             worker_class FakeWorker
-#             priority_level :high
-#             priority_level :low
-#           end
-#           queue.store.stub(:pop) { nil }
-#           queue.store.stub(:pop).with { [:high, :low] }.and_return { "success" }
-#           queue.store.stub(:pop).with { [:low, :high] }.and_return { "success" }
-
-#           queue.pop.should be
-#         end
-#       end
-#     end
-#     context 'with a priority_level argument' do
-#       it 'pops the specified priority' do
-#         queue.store.stub(:pop) { nil }
-#         queue.store.stub(:pop).with(["queue"]) { "work" }
-#         queue.pop(["queue"]).should be
-#       end
-#     end
-#   end
-
-#   describe '#workers' do
-#     it 'returns the number of workers in the pool' do
-#       queue = QueueFactory.bake do
-#         worker_class FakeWorker
-#         workers 2
-#       end
-#       queue.workers.should eq 2
-#     end
-#   end
-
-#   describe '#busy_workers' do
-#     it 'returns the number of busy_workers in the pool' do
-#       queue = QueueFactory.bake do
-#         worker_class FakeWorker
-#         workers 2
-#       end
-#       queue.busy_workers.should eq 0
-#     end
-#   end
-
-#   describe '#idle_workers' do
-#     it 'returns the number of idle_workers in the pool' do
-#       queue = QueueFactory.bake do
-#         worker_class FakeWorker
-#         workers 2
-#       end
-#       queue.idle_workers.should eq 2
-#     end
-#   end
-
-#   describe '#backlog?' do
-#     it 'returns true if the pool is fully utilized' do
-#       queue = QueueFactory.bake do
-#         worker_class FakeWorker
-#       end
-#       queue.should_not be_backlog
-#     end
-#   end
-
-#   describe '#size' do
-#     it 'returns the number of jobs in the queue store' do
-#       queue.store.should_receive(:size).and_return(4)
-#       queue.size.should eq 4
-#     end
-#   end
-
-#   describe '#strict?' do
-#     context 'when the queue is strictly ordered' do
-#       it 'returns true' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           strict true
-#         end
-#         queue.should be_strict
-#       end
-#     end
-#     context 'when the queue is not strictly ordered' do
-#       it 'returns false' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#         end
-#         queue.should_not be_strict
-#       end
-#     end
-#   end
-
-#   describe '#priority_levels' do
-#     context 'with a queue with priority levels' do
-#       it 'returns the priority levels for this queue' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           priority_level :high
-#           priority_level :low
-#         end
-#         queue.priority_levels.should eq Set[:high, :low]
-#       end
-
-#       it 'does not return duplicates' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           priority_level :high, weight: 10
-#           priority_level :low, weight: 1
-#         end
-#         queue.priority_levels.should eq Set[:high, :low]
-#       end
-#     end
-#     context 'with a queue without priority levels' do
-#       it 'returns an empty array' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#         end
-#         queue.priority_levels.should eq Set[]
-#       end
-#     end
-#   end
-
-#   describe '#priority_level_weights' do
-#     context 'when run on a queue without priority levels' do
-#       it 'returns an empty hash' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#         end
-#         queue.priority_level_weights.should eq({})
-#       end
-#     end
-
-#     context 'when run on a queue with unweighted priority levels' do
-#       it "returns the priority levels with their weightings" do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           priority_level :high
-#           priority_level :low
-#         end
-#         queue.priority_level_weights.should eq({high: 1, low: 1})
-#       end
-#     end
-
-#     context 'when run on a queue with unweighted priority levels' do
-#       it "returns the priority levels with their weightings" do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           priority_level :high, weight: 10
-#           priority_level :low, weight: 1
-#         end
-#         queue.priority_level_weights.should eq({high: 10, low: 1})
-#       end
-#     end
-#   end
-
-#   describe '#default_priority_level' do
-#     context 'when run on a queue without priority levels' do
-#       it 'returns nil' do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#         end
-#         queue.default_priority_level.should_not be
-#       end
-#     end
-
-#     context 'when run on a queue with priority levels' do
-#       it "returns the first priority level" do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           priority_level :high
-#           priority_level :low
-#         end
-#         queue.default_priority_level.should eq(:high)
-#       end
-#     end
-
-#     context 'when run on a queue with a default priority level explicitly set' do
-#       it "returns the set priority level" do
-#         queue = QueueFactory.bake do
-#           worker_class FakeWorker
-#           priority_level :high, weight: 10
-#           priority_level :low, weight: 1, default: true
-#         end
-#         queue.default_priority_level.should eq(:low)
-#       end
-#     end
-#   end
-# end

data/wind_up.gemspec

@@ -1,24 +0,0 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'wind_up/version'
-
-Gem::Specification.new do |gem|
-  gem.name          = "wind_up"
-  gem.version       = WindUp::VERSION
-  gem.authors       = ["Ryan Chan"]
-  gem.email         = ["ryan@ryanlchan.com"]
-  gem.summary       = %q{A drop-in replacement for Celluloid pools using the message API}
-  gem.description   = %q{WindUp is a simple background processing library meant to improve on Celluloid's pools}
-  gem.homepage      = "https://github.com/ryanlchan/wind_up"
-
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
-
-  gem.add_development_dependency "rspec"
-  gem.add_development_dependency "rake"
-
-  gem.add_dependency "celluloid", "~> 0.14.1"
-end