wind_up 0.0.2

checksums.yaml

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

data/.ruby-gemset

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

data/.ruby-version

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

data/CHANGES.md

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

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,22 @@
+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/README.md

@@ -0,0 +1,92 @@
+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
+
+Usage
+-----
+
+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
+```
+
+Changing Routing Behavior (Advanced)
+------------------------------------
+
+WindUp accepts multiple types of routing behavior. Supported behaviors include:
+
+  * :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)
+
+To configure your queue to use a specific routing style, specify the routing
+behavior when calling .queue:
+
+```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
+
+# Register this router
+WindUp::Routers.register :first, FirstRouter
+
+# Use this router
+q = Klass.queue router: :first
+
+```
+
+Multiple worker types per queue
+-------------------------------
+
+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.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,10 @@
+# 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

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

data/lib/wind_up/queue_manager.rb

@@ -0,0 +1,138 @@
+# 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

@@ -0,0 +1,37 @@
+# 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

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

data/lib/wind_up/routers.rb

@@ -0,0 +1,132 @@
+# A duck-type of Celluloid::Mailbox which forwards messages to subscribers
+#
+# Router is not a mailbox in the strict sense. It acts as a forwarder for
+# calls, accepting and routing them to the next available subscriber. As with
+# Akka routers, pushing a call onto a Router is invoked concurrently from the
+# sender and must be threadsafe.
+module WindUp
+  module Routers
+    def self.register(name, klass)
+      registry[name] = klass
+    end
+
+    def self.registry
+      @registry ||= {}
+    end
+
+    def self.[](name)
+      registry[name] || registry.values.first
+    end
+  end
+
+  module Router
+    class Base
+      def initialize
+        @mutex = Mutex.new
+      end
+
+      # List all subscribers
+      def subscribers
+        @subscribers ||= []
+      end
+
+      # Subscribe to this mailbox for updates of new messages
+      # @param subscriber [Object] the subscriber to send messages to
+      def add_subscriber(subscriber)
+        @mutex.synchronize do
+          subscribers << subscriber unless subscribers.include?(subscriber)
+        end
+      end
+
+      # Remove a subscriber from thie mailbox
+      # @param subscriber [Object] the subscribed object
+      def remove_subscriber(subscriber)
+        @mutex.synchronize do
+          subscribers.delete subscriber
+        end
+      end
+
+      # Send the call to all subscribers
+      def <<(message)
+        @mutex.lock
+        begin
+          target = next_subscriber
+          send_message(target, message) if target
+        ensure
+          @mutex.unlock rescue nil
+        end
+      end
+
+      def broadcast(message)
+        send_message(subscribers, message)
+      end
+
+      # Send a message to the specified target
+      def send_message(target, message)
+        # Array-ize unless we're an Enumerable already that isn't a Mailbox
+        target = [target] unless target.is_a?(Enumerable) && !target.respond_to?(:receive)
+
+        target.each do |targ|
+          begin
+            targ << message
+          rescue Celluloid::MailboxError
+            # Mailbox died, remove subscriber
+            remove_subscriber targ
+          end
+        end
+        nil
+      end
+    end
+
+    # Randomly route messages to workers
+    class Random < Base
+      def next_subscriber
+        subscribers.sample
+      end
+    end
+
+    # Basic router using a RoundRobin strategy
+    class RoundRobin < Base
+      # Signal new work to all subscribers/waiters
+      def next_subscriber
+        subscribers.rotate!
+        subscribers.last
+      end
+    end
+
+    # Send message to the worker with the smallest mailbox
+    class SmallestMailbox < Base
+      def next_subscriber
+        subscribers.sort { |a,b| a.size <=> b.size }.first
+      end
+    end
+
+    # The strategy employed is similar to a ScatterGatherFirstCompleted router in
+    # Akka, but wrapping messages in the ForwardedCall structure so computation is
+    # only completed once.
+    class FirstAvailable < Base
+      def mailbox
+        @mailbox ||= Celluloid::Mailbox.new
+      end
+
+      def <<(msg)
+        @mutex.lock
+        begin
+          mailbox << msg
+          send_message(subscribers, WindUp::ForwardedCall.new(mailbox))
+        ensure
+          @mutex.unlock rescue nil
+        end
+      end
+
+      def shutdown
+        mailbox.shutdown
+      end
+    end
+  end
+
+  Routers.register :first_avaialble, Router::FirstAvailable
+  Routers.register :round_robin, Router::RoundRobin
+  Routers.register :random, Router::Random
+  Routers.register :smallest_mailbox, Router::SmallestMailbox
+end

data/lib/wind_up/version.rb

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

data/lib/wind_up.rb

@@ -0,0 +1,20 @@
+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/version'
+require 'wind_up/celluloid_ext'
+
+module WindUp
+  def self.logger
+    Celluloid.logger
+  end
+
+  def self.logger=(logger)
+    Celluloid.logger = logger
+  end
+end
+
+require 'wind_up/railtie' if defined?(::Rails)

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+begin
+  require 'pry'
+rescue LoadError
+end
+
+require 'celluloid'
+require 'wind_up'
+
+Celluloid.shutdown; Celluloid.boot
+
+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
+end

data/spec/wind_up/queue_manager_spec.rb

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,372 @@
+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/spec/wind_up/routers_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+shared_examples_for 'a router' do
+  describe '#add_subscriber' do
+    it 'adds a subscriber to the list of subscribers' do
+      subject.add_subscriber(subscriber)
+      subject.subscribers.should include(subscriber)
+    end
+  end
+
+  describe '#<<' do
+    it 'forwards messages to a subscriber' do
+      subject.add_subscriber subscriber
+      subject << :ok
+      subscriber.receive(0).should be :ok
+    end
+  end
+end
+
+describe WindUp::Routers do
+  let(:subscriber) { Celluloid::Mailbox.new }
+  let(:origin) { WindUp::Routers[router_class].new }
+  subject { origin }
+
+  describe WindUp::Router::RoundRobin do
+    let(:router_class) { :round_robin }
+    it_behaves_like 'a router'
+  end
+
+  describe WindUp::Router::Random do
+    let(:router_class) { :random }
+    it_behaves_like 'a router'
+  end
+
+  describe WindUp::Router::SmallestMailbox do
+    let(:router_class) { :smallest_mailbox }
+    it_behaves_like 'a router'
+  end
+
+  describe WindUp::Router::FirstAvailable do
+    let(:router_class) { :first_avaialble }
+
+    describe '#add_subscriber' do
+      it 'adds a subscriber to the list of subscribers' do
+        subject.add_subscriber(subscriber)
+        subject.subscribers.should include(subscriber)
+      end
+    end
+
+    describe '#<<' do
+      it 'publishes the Forwarder event to all subscribers' do
+        origin.add_subscriber(subscriber)
+        origin << "New work"
+        subscriber.receive(1).should be_a(WindUp::ForwardedCall)
+      end
+    end
+  end
+end

data/spec/wind_up_spec.rb

@@ -0,0 +1,14 @@
+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
+    end
+  end
+end

data/wind_up.gemspec

@@ -0,0 +1,24 @@
+# -*- 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

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: wind_up
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Ryan Chan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.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
+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/routers.rb
+- lib/wind_up/version.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: {}
+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.0.3
+signing_key: 
+specification_version: 4
+summary: A drop-in replacement for Celluloid pools using the message API
+test_files:
+- 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