sneakers 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 840d0c4111ae6ab4c2b97719597fa928632dd34b
-  data.tar.gz: f24a305085c2b43bee74922011ffd3daf5031d24
+  metadata.gz: 6b646dd7a8a5c9389275bd3406ea7e7839d09cd7
+  data.tar.gz: 293440a5a50a41f30064ef85d14ac69d84f26652
 SHA512:
-  metadata.gz: 936db286d2c0638746771efa54c4bdc8cee4f78c641bdc38db42eaa8fad7bed13428223ac6988edcc10f9a5c883a28c054aeb7d4c842f4befcbc24654014c274
-  data.tar.gz: 426cf688b5e91c2e02bcb4c45fe420989592c6041419e0bf1cd8d4ae59b145426164ab669e17ac6e620481dc7734c798fcb53cb1d5c8e2ad1dc42c54f2881998
+  metadata.gz: 9f5b28202fece758dbd64f29239439da4f023e289da2d1f8ef2c484667bec034a580f97c31dc2ab1931b5315130e177df86ba8927b8f94c06d471fba21dd93e1
+  data.tar.gz: 1f53048671fc9e83480891998bf0a01a28796fa7e835906fc40c14489b4143e18b23059f7544ef6b58459eafa288c56e8a06beb3933f4cf133163de0fc605d34

data/.travis.yml

@@ -3,4 +3,4 @@ rvm:
 - 2.2
 - 2.1
 - 2.0.0
-- 1.9.3
+

data/README.md

@@ -27,16 +27,21 @@ complete docs.
 
 Add this line to your application's Gemfile:
 
-    gem 'sneakers'
+``` ruby
+gem 'sneakers'
+```
 
 And then execute:
 
-    $ bundle
+``` shell-session
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install sneakers
-
+``` shell-session
+$ gem install sneakers
+```
 
 ## Quick start 
 
@@ -74,9 +79,7 @@ class Processor
 end
 ```
 
-
-As an example, make a message look like this:
-We'll count errors and error types with Redis. Specifically for an error that looks like this:
+We'll count errors and error types with Redis. As an example, make a message that looks like this:
 
 ```javascript
 {
@@ -90,8 +93,8 @@ We'll count errors and error types with Redis. Specifically for an error that lo
 Let's test it out quickly from the command line:
 
 
-```bash
-sneakers work Processor --require boot.rb
+```shell-session
+$ sneakers work Processor --require boot.rb
 ```
 
 We just told Sneakers to spawn a worker named `Processor`, but first `--require` a file that we dedicate to setting up environment, including workers and what-not.
@@ -109,8 +112,8 @@ If you go to your RabbitMQ admin now, you'll see a new queue named `logs` was cr
 And redis will show this: 
 
 
-```
-➜  ~  redis-cli monitor
+``` shell-session
+$ redis-cli monitor
 1381520329.888581 [0 127.0.0.1:49182] "incr" "processor:CODE001"
 ```
 
@@ -142,13 +145,17 @@ Now push a message again and you'll see:
 2013-10-11T19:44:37Z p-9219 t-oxh8owywg INFO: INC: work.Processor.handled.ack
 ```
 
-Which increments start + end, and times the work unit.
-
+Which increments `started` and `handled.ack`, and times the work unit.
 
 
 From here, you can continue over to the
 [Wiki](https://github.com/jondot/sneakers/wiki)
 
+# Compatibility
+
+* Sneakers 1.1.x and up (using the new generation Bunny 2.x) - Ruby 2.x.x
+* Sneakers 1.x.x and down - Ruby 1.9.x, 2.x.x
+
 # Contributing
 
 Fork, implement, add tests, pull request, get my everlasting thanks and a respectable place here :).
@@ -162,11 +169,4 @@ To all Sneakers [Contributors](https://github.com/jondot/sneakers/graphs/contrib
 
 # Copyright
 
-Copyright (c) 2015 [Dotan Nahum](http://gplus.to/dotan) [@jondot](http://twitter.com/jondot). See MIT-LICENSE for further details.
-
-
-
-
-
-
-
+Copyright (c) 2015 [Dotan Nahum](http://gplus.to/dotan) [@jondot](http://twitter.com/jondot). See [LICENSE](LICENSE.txt) for further details.

data/bin/sneakers

@@ -2,4 +2,5 @@
 require 'sneakers'
 require 'sneakers/cli'
 
+Sneakers.server = true
 Sneakers::CLI.start

data/examples/benchmark_worker.rb

@@ -10,7 +10,8 @@ class BenchmarkWorker
              :prefetch => 50,
              :timeout_job_after => 1,
              :exchange => 'dummy',
-             :heartbeat => 5
+             :heartbeat => 5,
+             :amqp_heartbeat => 10
   def work(msg)
     ack!
   end

data/examples/max_retry_handler.rb

@@ -21,6 +21,7 @@ WORKER_OPTIONS = {
   :prefetch => 1,
   :timeout_job_after => 60,
   :heartbeat => 5,
+  :amqp_heartbeat => 10,
   :retry_timeout => 5000
 }
 

data/examples/profiling_worker.rb

@@ -33,7 +33,8 @@ class ProfilingWorker
              :prefetch => 50,
              :timeout_job_after => 1,
              :exchange => 'sneakers',
-             :heartbeat => 5
+             :heartbeat => 5,
+             :amqp_heartbeat => 10
   def work(msg)
     ack!
   end
@@ -66,4 +67,3 @@ if profiling
 end
 
 r.run
-

data/examples/workflow_worker.rb

@@ -10,7 +10,8 @@ class WorkflowWorker
              :prefetch => 50,
              :timeout_job_after => 1,
              :exchange => 'dummy',
-             :heartbeat => 5
+             :heartbeat => 5,
+             :amqp_heartbeat => 10
 
   def work(msg)
     logger.info("Seriously, i'm DONE.")

data/lib/sneakers.rb

@@ -47,6 +47,10 @@ module Sneakers
     logger.level = loglevel
   end
 
+  def logger=(logger)
+    @logger = logger
+  end
+
   def logger
     @logger
   end
@@ -59,13 +63,25 @@ module Sneakers
     @configured
   end
 
+  def server=(server)
+    @server = server
+  end
+
+  def server?
+    @server
+  end
+
+  def configure_server
+    yield self if server?
+  end
+
   private
 
   def setup_general_logger!
     if [:info, :debug, :error, :warn].all?{ |meth| CONFIG[:log].respond_to?(meth) }
       @logger = CONFIG[:log]
     else
-      @logger = Logger.new(CONFIG[:log])
+      @logger = ServerEngine::DaemonLogger.new(CONFIG[:log])
       @logger.formatter = Sneakers::Support::ProductionFormatter
     end
   end

data/lib/sneakers/configuration.rb

@@ -4,7 +4,7 @@ module Sneakers
   class Configuration
 
     extend Forwardable
-    def_delegators :@hash, :to_hash, :[], :[]=, :==, :fetch, :delete
+    def_delegators :@hash, :to_hash, :[], :[]=, :==, :fetch, :delete, :has_key?
 
     DEFAULTS = {
       # runner
@@ -15,16 +15,19 @@ module Sneakers
       :workers            => 4,
       :log                => STDOUT,
       :pid_path           => 'sneakers.pid',
+      :amqp_heartbeat     => 10,
 
       # workers
       :timeout_job_after  => 5,
       :prefetch           => 10,
       :threads            => 10,
+      :share_threads      => false,
       :durable            => true,
       :ack                => true,
       :heartbeat          => 2,
       :exchange           => 'sneakers',
       :exchange_type      => :direct,
+      :exchange_arguments => {}, # Passed as :arguments to Bunny::Channel#exchange
       :hooks              => {}
     }.freeze
 
@@ -40,10 +43,23 @@ module Sneakers
     end
 
     def merge!(hash)
-      # parse vhost from amqp if vhost is not specified explicitly
-      if hash[:vhost].nil? && !hash[:amqp].nil?
-        hash = hash.dup
-        hash[:vhost] = AMQ::Settings.parse_amqp_url(hash[:amqp]).fetch(:vhost, '/')
+      hash = hash.dup
+
+      # parse vhost from amqp if vhost is not specified explicitly, only
+      # if we're not given a connection to use.
+      if hash[:connection].nil?
+        if hash[:vhost].nil? && !hash[:amqp].nil?
+          hash[:vhost] = AMQ::Settings.parse_amqp_url(hash[:amqp]).fetch(:vhost, '/')
+        end
+      else
+        # If we are given a Bunny object, ignore params we'd otherwise use to
+        # create one.  This removes any question about where config params are
+        # coming from, and makes it more likely that downstream code that needs
+        # this info gets it from the right place.
+        [:vhost, :amqp, :heartbeat].each do |k|
+          hash.delete(k)
+          @hash.delete(k)
+        end
       end
 
       @hash.merge!(hash)
@@ -55,5 +71,16 @@ module Sneakers
       instance.merge! hash
       instance
     end
+
+    def inspect_with_redaction
+      redacted = self.class.new
+      redacted.merge! to_hash
+
+      # redact passwords
+      redacted[:amqp] = redacted[:amqp].sub(/(?<=\Aamqp:\/)[^@]+(?=@)/, "<redacted>")
+      return redacted.inspect_without_redaction
+    end
+    alias_method :inspect_without_redaction, :inspect
+    alias_method :inspect, :inspect_with_redaction
   end
 end

data/lib/sneakers/publisher.rb

@@ -23,7 +23,7 @@ module Sneakers
       @bunny = Bunny.new(@opts[:amqp], heartbeat: @opts[:heartbeat], vhost: @opts[:vhost], :logger => Sneakers::logger)
       @bunny.start
       @channel = @bunny.create_channel
-      @exchange = @channel.exchange(@opts[:exchange], type: @opts[:exchange_type], durable: @opts[:durable])
+      @exchange = @channel.exchange(@opts[:exchange], type: @opts[:exchange_type], durable: @opts[:durable], arguments: @opts[:exchange_arguments])
     end
 
     def connected?

data/lib/sneakers/queue.rb

@@ -16,7 +16,10 @@ class Sneakers::Queue
   # :ack
   #
   def subscribe(worker)
-    @bunny = Bunny.new(@opts[:amqp], :vhost => @opts[:vhost], :heartbeat => @opts[:heartbeat], :logger => Sneakers::logger)
+    # If we've already got a bunny object, use it.  This allows people to
+    # specify all kinds of options we don't need to know about (e.g. for ssl).
+    @bunny = @opts[:connection]
+    @bunny ||= create_bunny_connection
     @bunny.start
 
     @channel = @bunny.create_channel
@@ -25,7 +28,8 @@ class Sneakers::Queue
     exchange_name = @opts[:exchange]
     @exchange = @channel.exchange(exchange_name,
                                   :type => @opts[:exchange_type],
-                                  :durable => @opts[:durable])
+                                  :durable => @opts[:durable],
+                                  :arguments => @opts[:exchange_arguments])
 
     routing_key = @opts[:routing_key] || @name
     routing_keys = [*routing_key]
@@ -60,4 +64,9 @@ class Sneakers::Queue
     @consumer.cancel if @consumer
     @consumer = nil
   end
+
+  def create_bunny_connection
+    Bunny.new(@opts[:amqp], :vhost => @opts[:vhost], :heartbeat => @opts[:heartbeat], :logger => Sneakers::logger)
+  end
+  private :create_bunny_connection
 end

data/lib/sneakers/runner.rb

@@ -63,19 +63,22 @@ module Sneakers
       config
     end
 
-  private
-  def make_serverengine_config
+    private
+
+    def make_serverengine_config
       # From Sneakers#setup_general_logger, there's support for a Logger object
       # in CONFIG[:log].  However, serverengine takes an object in :logger.
       # Pass our logger object so there's no issue about sometimes passing a
       # file and sometimes an object.
-      without_log = Sneakers::CONFIG.merge(@conf)
-      without_log.delete(:log)
-      Sneakers::CONFIG.merge(@conf).merge({
+      serverengine_config =  Sneakers::CONFIG.merge(@conf)
+      serverengine_config.merge!(
         :logger => Sneakers.logger,
         :worker_type => 'process',
         :worker_classes => @worker_classes
-      })
+      )
+      serverengine_config.delete(:log)
+
+      serverengine_config
     end
   end
 

data/lib/sneakers/tasks.rb

@@ -5,7 +5,13 @@ task :environment
 
 namespace :sneakers do
   desc "Start work (set $WORKERS=Klass1,Klass2)"
-  task :run  => :environment do
+  task :run do
+    Sneakers.server = true
+    Rake::Task['environment'].invoke
+
+    if defined?(::Rails)
+      ::Rails.application.eager_load!
+    end
 
     workers, missing_workers = Sneakers::Utils.parse_workers(ENV['WORKERS'])
 
@@ -26,7 +32,7 @@ Please set the classes of the workers you want to run like so:
 EOF
       exit(1)
     end
-    opts = (ENV['WORKER_COUNT'].present? ? {:workers => ENV['WORKER_COUNT'].to_i} : {})
+    opts = (!ENV['WORKER_COUNT'].nil? ? {:workers => ENV['WORKER_COUNT'].to_i} : {})
     r = Sneakers::Runner.new(workers, opts)
 
     r.run

data/lib/sneakers/version.rb

@@ -1,3 +1,3 @@
 module Sneakers
-  VERSION = "1.0.4"
+  VERSION = "1.1.0"
 end

data/lib/sneakers/workergroup.rb

@@ -19,7 +19,11 @@ module Sneakers
     def run
       after_fork
 
-      @workers = config[:worker_classes].map{|w| w.new }
+      # Allocate single thread pool if share_threads is set. This improves load balancing
+      # when used with many workers.
+      pool = config[:share_threads] ? Thread.pool(config[:threads]) : nil
+
+      @workers = config[:worker_classes].map{|w| w.new(nil, pool) }
       # if more than one worker this should be per worker
       # accumulate clients and consumers as well
       @workers.each do |worker|
@@ -27,7 +31,7 @@ module Sneakers
       end
       # end per worker
       #
-      until @stop_flag.wait_for_set(10.0)
+      until @stop_flag.wait_for_set(Sneakers::CONFIG[:amqp_heartbeat])
         Sneakers.logger.debug("Heartbeat: running threads [#{Thread.list.count}]")
         # report aggregated stats?
       end
@@ -44,4 +48,3 @@ module Sneakers
 
   end
 end
-

data/sneakers.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(/^(test|spec|features)\//)
   gem.require_paths = ['lib']
   gem.add_dependency 'serverengine', '~> 1.5.5'
-  gem.add_dependency 'bunny', '~> 1.7.0'
+  gem.add_dependency 'bunny', ['>= 1.7.0', '<= 2.0.0']
   gem.add_dependency 'thread', '~> 0.1.7'
   gem.add_dependency 'thor'
 

data/spec/sneakers/configuration_spec.rb

@@ -2,67 +2,89 @@ require 'spec_helper'
 
 describe Sneakers::Configuration do
 
-  it 'should assign a default value for :amqp' do
-    with_env('RABBITMQ_URL', nil) do
-      config = Sneakers::Configuration.new
-      config[:amqp].must_equal 'amqp://guest:guest@localhost:5672'
+  describe 'with a connection' do
+    let(:connection) { Object.new }
+
+    it 'does not use vhost option if it is specified' do
+      url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      with_env('RABBITMQ_URL', url) do
+        config = Sneakers::Configuration.new
+        config.merge!({ :vhost => 'test_host', :connection => connection })
+        config.has_key?(:vhost).must_equal false
+      end
     end
-  end
 
-  it 'should assign a default value for :vhost' do
-    with_env('RABBITMQ_URL', nil) do
+    it 'does not amqp option if it is specified' do
+      url = 'amqp://foo:bar@localhost:5672'
       config = Sneakers::Configuration.new
-      config[:vhost].must_equal '/'
+      config.merge!({ :amqp => url, :connection => connection })
+      config.has_key?(:vhost).must_equal false
     end
   end
 
-  it 'should read the value for amqp from RABBITMQ_URL' do
-    url = 'amqp://foo:bar@localhost:5672'
-    with_env('RABBITMQ_URL', url) do
-      config = Sneakers::Configuration.new
-      config[:amqp].must_equal url
+  describe 'without a connection' do
+    it 'should assign a default value for :amqp' do
+      with_env('RABBITMQ_URL', nil) do
+        config = Sneakers::Configuration.new
+        config[:amqp].must_equal 'amqp://guest:guest@localhost:5672'
+      end
     end
-  end
 
-  it 'should read the value for vhost from RABBITMQ_URL' do
-    url = 'amqp://foo:bar@localhost:5672/foobarvhost'
-    with_env('RABBITMQ_URL', url) do
-      config = Sneakers::Configuration.new
-      config[:vhost].must_equal 'foobarvhost'
+    it 'should assign a default value for :vhost' do
+      with_env('RABBITMQ_URL', nil) do
+        config = Sneakers::Configuration.new
+        config[:vhost].must_equal '/'
+      end
     end
-  end
 
-  it 'should parse vhost from amqp option' do
-    env_url = 'amqp://foo:bar@localhost:5672/foobarvhost'
-    with_env('RABBITMQ_URL', env_url) do
-      url = 'amqp://foo:bar@localhost:5672/testvhost'
-      config = Sneakers::Configuration.new
-      config.merge!({ :amqp => url })
-      config[:vhost].must_equal 'testvhost'
+    it 'should read the value for amqp from RABBITMQ_URL' do
+      url = 'amqp://foo:bar@localhost:5672'
+      with_env('RABBITMQ_URL', url) do
+        config = Sneakers::Configuration.new
+        config[:amqp].must_equal url
+      end
     end
-  end
 
-  it 'should not parse vhost from amqp option if vhost is specified explicitly' do
-    url = 'amqp://foo:bar@localhost:5672/foobarvhost'
-    config = Sneakers::Configuration.new
-    config.merge!({ :amqp => url, :vhost => 'test_host' })
-    config[:vhost].must_equal 'test_host'
-  end
+    it 'should read the value for vhost from RABBITMQ_URL' do
+      url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      with_env('RABBITMQ_URL', url) do
+        config = Sneakers::Configuration.new
+        config[:vhost].must_equal 'foobarvhost'
+      end
+    end
+
+    it 'should parse vhost from amqp option' do
+      env_url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      with_env('RABBITMQ_URL', env_url) do
+        url = 'amqp://foo:bar@localhost:5672/testvhost'
+        config = Sneakers::Configuration.new
+        config.merge!({ :amqp => url })
+        config[:vhost].must_equal 'testvhost'
+      end
+    end
 
-  it 'should use vhost option if it is specified' do
-    url = 'amqp://foo:bar@localhost:5672/foobarvhost'
-    with_env('RABBITMQ_URL', url) do
+    it 'should not parse vhost from amqp option if vhost is specified explicitly' do
+      url = 'amqp://foo:bar@localhost:5672/foobarvhost'
       config = Sneakers::Configuration.new
-      config.merge!({ :vhost => 'test_host' })
+      config.merge!({ :amqp => url, :vhost => 'test_host' })
       config[:vhost].must_equal 'test_host'
     end
-  end
 
-  it 'should use default vhost if vhost is not specified in amqp option' do
-    url = 'amqp://foo:bar@localhost:5672'
-    config = Sneakers::Configuration.new
-    config.merge!({ :amqp => url })
-    config[:vhost].must_equal '/'
+    it 'should use vhost option if it is specified' do
+      url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+      with_env('RABBITMQ_URL', url) do
+        config = Sneakers::Configuration.new
+        config.merge!({ :vhost => 'test_host' })
+        config[:vhost].must_equal 'test_host'
+      end
+    end
+
+    it 'should use default vhost if vhost is not specified in amqp option' do
+      url = 'amqp://foo:bar@localhost:5672'
+      config = Sneakers::Configuration.new
+      config.merge!({ :amqp => url })
+      config[:vhost].must_equal '/'
+    end
   end
 
   def with_env(key, value)

data/spec/sneakers/publisher_spec.rb

@@ -60,11 +60,12 @@ describe Sneakers::Publisher do
         amqp: 'amqp://someuser:somepassword@somehost:5672',
         heartbeat: 1, exchange: 'another_exchange',
         exchange_type: :topic,
+        exchange_arguments: { 'x-arg' => 'value' },
         log: logger,
         durable: false)
 
       channel = Object.new
-      mock(channel).exchange('another_exchange', type: :topic, durable: false) do
+      mock(channel).exchange('another_exchange', type: :topic, durable: false, arguments: { 'x-arg' => 'value' }) do
         mock(Object.new).publish('test msg', routing_key: 'downloads')
       end
 

data/spec/sneakers/queue_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 require 'sneakers'
 
-
-
 describe Sneakers::Queue do
   let :queue_vars do
     {
@@ -12,103 +10,137 @@ describe Sneakers::Queue do
       :heartbeat => 2,
       :vhost => '/',
       :exchange => "sneakers",
-      :exchange_type => :direct
+      :exchange_type => :direct,
+      :exchange_arguments => { 'x-arg' => 'value' }
     }
   end
 
   before do
     Sneakers.configure
 
-    @mkbunny = Object.new
+    @mkworker = Object.new
+    stub(@mkworker).opts { { :exchange => 'test-exchange' } }
     @mkchan = Object.new
+    mock(@mkchan).prefetch(25)
     @mkex = Object.new
     @mkqueue = Object.new
-    @mkqueue_nondurable = Object.new
-    @mkworker = Object.new
-
-    mock(@mkbunny).start {}
-    mock(@mkbunny).create_channel{ @mkchan }
-    mock(Bunny).new(anything, :vhost => '/', :heartbeat => 2){ @mkbunny }
-
-    mock(@mkchan).prefetch(25)
-
-    stub(@mkworker).opts { { :exchange => 'test-exchange' } }
   end
 
-  describe "#subscribe with sneakers exchange" do
+  describe 'with our own Bunny object' do
     before do
-      mock(@mkchan).exchange("sneakers", :type => :direct, :durable => true){ @mkex }
+      @mkbunny = Object.new
+      @mkqueue_nondurable = Object.new
+
+      mock(@mkbunny).start {}
+      mock(@mkbunny).create_channel{ @mkchan }
+      mock(Bunny).new(anything, :vhost => '/', :heartbeat => 2){ @mkbunny }
     end
 
-    it "should setup a bunny queue according to configuration values" do
-      mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
-      q = Sneakers::Queue.new("downloads", queue_vars)
+    describe "#subscribe with sneakers exchange" do
+      before do
+        mock(@mkchan).exchange("sneakers",
+                               :type => :direct,
+                               :durable => true,
+                               :arguments => { 'x-arg' => 'value' }){ @mkex }
+      end
 
-      mock(@mkqueue).bind(@mkex, :routing_key => "downloads")
-      mock(@mkqueue).subscribe(:block => false, :manual_ack => true)
+      it "should setup a bunny queue according to configuration values" do
+        mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+        q = Sneakers::Queue.new("downloads", queue_vars)
 
-      q.subscribe(@mkworker)
-    end
+        mock(@mkqueue).bind(@mkex, :routing_key => "downloads")
+        mock(@mkqueue).subscribe(:block => false, :manual_ack => true)
 
-    it "supports multiple routing_keys" do
-      mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
-      q = Sneakers::Queue.new("downloads",
-                              queue_vars.merge(:routing_key => ["alpha", "beta"]))
+        q.subscribe(@mkworker)
+      end
 
-      mock(@mkqueue).bind(@mkex, :routing_key => "alpha")
-      mock(@mkqueue).bind(@mkex, :routing_key => "beta")
-      mock(@mkqueue).subscribe(:block => false, :manual_ack => true)
+      it "supports multiple routing_keys" do
+        mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+        q = Sneakers::Queue.new("downloads",
+                                queue_vars.merge(:routing_key => ["alpha", "beta"]))
 
-      q.subscribe(@mkworker)
-    end
+        mock(@mkqueue).bind(@mkex, :routing_key => "alpha")
+        mock(@mkqueue).bind(@mkex, :routing_key => "beta")
+        mock(@mkqueue).subscribe(:block => false, :manual_ack => true)
 
-    it "will use whatever handler the worker specifies" do
-      mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
-      @handler = Object.new
-      worker_opts = { :handler => @handler }
-      stub(@mkworker).opts { worker_opts }
-      mock(@handler).new(@mkchan, @mkqueue, worker_opts).once
-
-      stub(@mkqueue).bind
-      stub(@mkqueue).subscribe
-      q = Sneakers::Queue.new("downloads", queue_vars)
-      q.subscribe(@mkworker)
-    end
+        q.subscribe(@mkworker)
+      end
 
-    it "creates a non-durable queue if :queue_durable => false" do
-      mock(@mkchan).queue("test_nondurable", :durable => false) { @mkqueue_nondurable }
-      queue_vars[:queue_durable] = false
-      q = Sneakers::Queue.new("test_nondurable", queue_vars)
+      it "will use whatever handler the worker specifies" do
+        mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+        @handler = Object.new
+        worker_opts = { :handler => @handler }
+        stub(@mkworker).opts { worker_opts }
+        mock(@handler).new(@mkchan, @mkqueue, worker_opts).once
+
+        stub(@mkqueue).bind
+        stub(@mkqueue).subscribe
+        q = Sneakers::Queue.new("downloads", queue_vars)
+        q.subscribe(@mkworker)
+      end
 
-      mock(@mkqueue_nondurable).bind(@mkex, :routing_key => "test_nondurable")
-      mock(@mkqueue_nondurable).subscribe(:block => false, :manual_ack => true)
+      it "creates a non-durable queue if :queue_durable => false" do
+        mock(@mkchan).queue("test_nondurable", :durable => false) { @mkqueue_nondurable }
+        queue_vars[:queue_durable] = false
+        q = Sneakers::Queue.new("test_nondurable", queue_vars)
 
-      q.subscribe(@mkworker)
-      myqueue = q.instance_variable_get(:@queue)
-    end
-  end
+        mock(@mkqueue_nondurable).bind(@mkex, :routing_key => "test_nondurable")
+        mock(@mkqueue_nondurable).subscribe(:block => false, :manual_ack => true)
 
-  describe "#subscribe with default exchange" do
-    before do
-      # expect default exchange
-      queue_vars[:exchange] = ""
-      mock(@mkchan).exchange("", :type => :direct, :durable => true){ @mkex }
+        q.subscribe(@mkworker)
+        myqueue = q.instance_variable_get(:@queue)
+      end
     end
 
-    it "does not bind to exchange" do
-      mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
-      @handler = Object.new
-      worker_opts = { :handler => @handler }
-      stub(@mkworker).opts { worker_opts }
-      mock(@handler).new(@mkchan, @mkqueue, worker_opts).once
+    describe "#subscribe with default exchange" do
+      before do
+        # expect default exchange
+        queue_vars[:exchange] = ""
+        mock(@mkchan).exchange("", :type => :direct, :durable => true){ @mkex }
+      end
 
-      stub(@mkqueue).bind do
-        raise "bind should not be called"
+      it "does not bind to exchange" do
+        mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+        @handler = Object.new
+        worker_opts = { :handler => @handler }
+        stub(@mkworker).opts { worker_opts }
+        mock(@handler).new(@mkchan, @mkqueue, worker_opts).once
+
+        stub(@mkqueue).bind do
+          raise "bind should not be called"
+        end
+
+        stub(@mkqueue).subscribe
+        q = Sneakers::Queue.new("downloads", queue_vars)
+        q.subscribe(@mkworker)
       end
+    end
+  end
 
-      stub(@mkqueue).subscribe
-      q = Sneakers::Queue.new("downloads", queue_vars)
-      q.subscribe(@mkworker)
+  describe 'with an externally-provided connection' do
+    describe '#subscribe' do
+      before do
+        @external_connection = Bunny.new
+        mock(@external_connection).start {}
+        mock(@external_connection).create_channel{ @mkchan }
+        mock(@mkchan).exchange("sneakers",
+                               :type => :direct,
+                               :durable => true,
+                               :arguments => { 'x-arg' => 'value' }){ @mkex }
+
+        queue_name = 'foo'
+        mock(@mkchan).queue(queue_name, :durable => true) { @mkqueue }
+        mock(@mkqueue).bind(@mkex, :routing_key => queue_name)
+        mock(@mkqueue).subscribe(:block => false, :manual_ack => true)
+
+        my_vars = queue_vars.merge(:connection => @external_connection)
+        @q = Sneakers::Queue.new(queue_name, my_vars)
+      end
+
+      it 'uses that object' do
+        @q.subscribe(@mkworker)
+        @q.instance_variable_get(:@bunny).must_equal @external_connection
+      end
     end
   end
 end

data/spec/sneakers/runner_spec.rb

@@ -24,3 +24,21 @@ describe Sneakers::Runner do
     end
   end
 end
+
+describe Sneakers::RunnerConfig do
+  let(:logger) { Logger.new("logtest.log") }
+  let(:runner_config) { Sneakers::Runner.new([]).instance_variable_get("@runnerconfig") }
+
+  before { Sneakers.configure(log: logger) }
+
+
+  describe "#reload_config!" do
+    it "must not have :log key" do
+      runner_config.reload_config!.has_key?(:log).must_equal false
+    end
+
+    it "must have :logger key as an instance of Logger" do
+      runner_config.reload_config![:logger].is_a?(Logger).must_equal true
+    end
+  end
+end

data/spec/sneakers/sneakers_spec.rb

@@ -54,14 +54,16 @@ describe Sneakers do
 
 
   describe '#setup_general_logger' do
+    let(:logger_class) { ServerEngine::DaemonLogger }
+
     it 'should detect a string and configure a logger' do
       Sneakers.configure(:log => 'sneakers.log')
-      Sneakers.logger.kind_of?(Logger).must_equal(true)
+      Sneakers.logger.kind_of?(logger_class).must_equal(true)
     end
 
     it 'should detect a file-like thing and configure a logger' do
       Sneakers.configure(:log => STDOUT)
-      Sneakers.logger.kind_of?(Logger).must_equal(true)
+      Sneakers.logger.kind_of?(logger_class).must_equal(true)
     end
 
     it 'should detect an actual logger and configure it' do

data/spec/sneakers/worker_spec.rb

@@ -171,15 +171,18 @@ describe Sneakers::Worker do
           :timeout_job_after => 5,
           :prefetch => 10,
           :threads => 10,
+          :share_threads => false,
           :durable => true,
           :ack => true,
           :amqp => "amqp://guest:guest@localhost:5672",
           :vhost => "/",
           :exchange => "sneakers",
           :exchange_type => :direct,
+          :exchange_arguments => {},
           :hooks => {},
           :handler => Sneakers::Handlers::Oneshot,
-          :heartbeat  =>  2
+          :heartbeat => 2,
+          :amqp_heartbeat => 10
         )
       end
 
@@ -196,15 +199,18 @@ describe Sneakers::Worker do
           :timeout_job_after => 1,
           :prefetch => 40,
           :threads => 50,
+          :share_threads => false,
           :durable => false,
           :ack => false,
           :amqp => "amqp://guest:guest@localhost:5672",
           :vhost => "/",
           :exchange => "dummy",
           :exchange_type => :direct,
+          :exchange_arguments => {},
           :hooks => {},
           :handler => Sneakers::Handlers::Oneshot,
-          :heartbeat => 5
+          :heartbeat => 5,
+          :amqp_heartbeat => 10
         )
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sneakers
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Dotan Nahum
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-28 00:00:00.000000000 Z
+date: 2015-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: serverengine
@@ -28,16 +28,22 @@ dependencies:
   name: bunny
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.0
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.0
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: thread
   requirement: !ruby/object:Gem::Requirement