pebbles-river 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0738174b6c9733edbe9524576e2ecf48ca2ad56e
+  data.tar.gz: bdf513a26a16bd44be5a02dec8af1ac9b11f467f
+SHA512:
+  metadata.gz: 9068b048fa0c91a0640d15d77756dc742c3add7aa0a3106fd50178bf86e58717caa0d917497879b92394b596d74353ae8ca7a9b2ee3ceda8a68455e0d4a6689b
+  data.tar.gz: 8f0747a995edcd03ca44e64122ef63187904263fe248a22417860a44f854da54ad40c4da1629a448868d0fca7f30ca1595648c64d70a1bb8788f488672fbef19

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alexander Staubo
+
+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,3 @@
+# River
+
+An extension to [Pebblebed](//github.com/bengler/pebblebed) that provides a simple framework for publishing and consuming asynchronous events via RabbitMQ.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/pebbles/river/compatibility.rb

@@ -0,0 +1,11 @@
+unless defined?(Pebblebed::River)
+
+  module Pebblebed
+
+    # For backward compatibility with existing projects.
+    class River < Pebbles::River::River
+    end
+
+  end
+
+end

data/lib/pebbles/river/message.rb

@@ -0,0 +1,57 @@
+module Pebbles
+  module River
+
+    class InvalidPayloadError < StandardError
+
+      attr_reader :payload
+
+      def initalize(message, payload)
+        super(message)
+        @payload = payload
+      end
+
+    end
+
+    class Message
+
+      attr_reader :payload
+      attr_reader :queue
+
+      def self.deserialize_payload(payload)
+        if payload
+          begin
+            return JSON.parse(payload)
+          rescue => e
+            raise InvalidPayloadError.new(e.message, payload)
+          end
+        end
+      end
+
+      def initialize(raw_message, queue = nil)
+        @queue = queue
+        @raw_message = raw_message
+        @payload = self.class.deserialize_payload(raw_message[:payload])
+      end
+
+      def ==(other)
+        other &&
+          other.is_a?(Message) &&
+          other.payload == @payload
+      end
+
+      def delivery_tag
+        @raw_message[:delivery_details][:delivery_tag]
+      end
+
+      def ack
+        @queue.ack(delivery_tag: delivery_tag)
+      end
+
+      def nack
+        @queue.nack(delivery_tag: delivery_tag)
+      end
+
+    end
+
+  end
+end

data/lib/pebbles/river/river.rb

@@ -0,0 +1,114 @@
+module Pebbles
+  module River
+
+    class SendFailure < StandardError
+
+      attr_reader :connection_exception
+
+      def initialize(message, connection_exception = nil)
+        super(message)
+        @connection_exception = connection_exception
+      end
+
+    end
+
+    class River
+
+      attr_reader :environment
+
+      def initialize(options = {})
+        options = {environment: options} if options.is_a?(String)  # Backwards compatibility
+
+        @environment = (options[:environment] || ENV['RACK_ENV'] || 'development').dup.freeze
+      end
+
+      def connected?
+        bunny.connected?
+      end
+
+      def connect
+        unless connected?
+          bunny.start
+          bunny.qos
+        end
+      end
+
+      def disconnect
+        bunny.stop if connected?
+      end
+
+      def publish(options = {})
+        connect
+        handle_connection_error do
+          exchange.publish(options.to_json,
+            persistent: options.fetch(:persistent, true),
+            key: Routing.routing_key_for(options.slice(:event, :uid)))
+        end
+      end
+
+      def queue(options = {})
+        raise ArgumentError.new 'Queue must be named' unless options[:name]
+
+        connect
+
+        queue = bunny.queue(options[:name], QUEUE_OPTIONS.dup)
+        Subscription.new(options).queries.each do |key|
+          queue.bind(exchange.name, key: key)
+        end
+        queue
+      end
+
+      def exchange_name
+        return @exchange_name ||= format_exchange_name
+      end
+
+      private
+
+        def bunny
+          @bunny ||= Bunny.new
+        end
+
+        def format_exchange_name
+          name = 'pebblebed.river'
+          name << ".#{environment}" if @environment != 'production'
+          name
+        end
+
+        def exchange
+          connect
+          @exchange ||= bunny.exchange(exchange_name, EXCHANGE_OPTIONS.dup)
+        end
+
+        def handle_connection_error(&block)
+          retry_until = nil
+          begin
+            yield
+          rescue *CONNECTION_EXCEPTIONS => exception
+            retry_until ||= Time.now + 4
+            if Time.now < retry_until
+              sleep(0.5)
+              retry
+            else
+              raise SendFailure.new(exception.message, exception)
+            end
+          end
+        end
+
+        QUEUE_OPTIONS = {durable: true}.freeze
+
+        EXCHANGE_OPTIONS = {type: :topic, durable: :true}.freeze
+
+        CONNECTION_EXCEPTIONS = [
+          Bunny::ConnectionError,
+          Bunny::ForcedChannelCloseError,
+          Bunny::ForcedConnectionCloseError,
+          Bunny::ServerDownError,
+          Bunny::ProtocolError,
+          # These should be caught by Bunny, but apparently aren't.
+          Errno::ECONNRESET
+        ].freeze
+
+    end
+
+  end
+end

data/lib/pebbles/river/routing.rb

@@ -0,0 +1,18 @@
+module Pebbles
+  module River
+    module Routing
+
+      def self.routing_key_for(options)
+        options.assert_valid_keys(:uid, :event)
+
+        raise ArgumentError.new(':event is required') unless options[:event]
+        raise ArgumentError.new(':uid is required') unless options[:uid]
+
+        uid = Pebblebed::Uid.new(options[:uid])
+        key = [options[:event], uid.klass, uid.path].compact
+        key.join('._.')
+      end
+
+    end
+  end
+end

data/lib/pebbles/river/subscription.rb

@@ -0,0 +1,44 @@
+module Pebbles
+  module River
+
+    class Subscription
+
+      attr_reader :events, :klasses, :paths
+
+      def initialize(options = {})
+        @events = querify(options[:event]).split('|')
+        @paths = querify(options[:path]).split('|')
+        @klasses = querify(options[:klass]).split('|')
+      end
+
+      def queries
+        qx = []
+        # If we add more than one more level,
+        # it's probably time to go recursive.
+        events.each do |event|
+          klasses.each do |klass|
+            paths.each do |pathspec|
+              pathify(pathspec).each do |path|
+                qx << [event, klass, path].join('._.')
+              end
+            end
+          end
+        end
+        qx
+      end
+
+      def querify(query)
+        (query || '#').gsub('**', '#')
+      end
+
+      def pathify(s)
+        required, optional = s.split('^').map {|s| s.split('.')}
+        required = Array(required.join('.'))
+        optional ||= []
+        (0..optional.length).map {|i| required + optional[0,i]}.map {|p| p.join('.')}
+      end
+
+    end
+
+  end
+end

data/lib/pebbles/river/supervisor.rb

@@ -0,0 +1,63 @@
+module Pebbles
+  module River
+
+    class Supervisor < Servolux::Server
+
+      def initialize(name, options = {})
+        super(name, {interval: 5}.merge(options.slice(:logger, :pid_file)))
+
+        options.assert_valid_keys(:logger, :pid_file, :worker_count, :worker)
+
+        @worker_count = options[:worker_count] || 1
+        @worker = options[:worker]
+
+        worker = @worker
+        @pool = Servolux::Prefork.new(min_workers: @worker_count) do
+          $0 = "#{name}: worker"
+          trap('TERM') { worker.stop }
+          worker.run
+        end
+      end
+
+      def before_starting
+        $0 = "#{name}: master"
+
+        logger.info "Starting workers"
+        @pool.start(1)
+      end
+
+      def after_stopping
+        shutdown_workers
+      end
+
+      def usr2
+        shutdown_workers
+      end
+
+      def run
+        @pool.ensure_worker_pool_size
+      rescue => e
+        if logger.respond_to? :exception
+          logger.exception(e)
+        else
+          logger.error(e.inspect)
+          logger.error(e.backtrace.join("\n"))
+        end
+      end
+
+      private
+
+        def shutdown_workers
+          logger.info "Shutting down all workers"
+          @pool.stop
+          loop do
+            break if @pool.live_worker_count <= 0
+            logger.info "Waiting for workers to quit"
+            sleep 0.25
+          end
+        end
+
+    end
+
+  end
+end

data/lib/pebbles/river/version.rb

@@ -0,0 +1,5 @@
+module Pebbles
+  module River
+    VERSION = "0.0.1"
+  end
+end

data/lib/pebbles/river/worker.rb

@@ -0,0 +1,204 @@
+module Pebbles
+  module River
+
+    # Implements a queue worker.
+    class Worker
+
+      class << self
+        def run(handler, options = {})
+          Worker.new(handler, options).run
+        end
+      end
+
+      attr_reader :queue_options
+      attr_reader :handler
+      attr_reader :river
+
+      # Initializes worker with a handler. Options:
+      #
+      # * `queue`: Same queue options as `River#queue`.
+      # * `on_exception`: If provided, called when a message could not be handled
+      #   due to an exception.
+      # * `on_connection_error`: If provided, call on recovered connection errors.
+      #   Uses `on_exception` if not implemented.
+      # * `managed_acking`: If true, ack/nack handling is automatic; every message
+      #   is automatically acked unless the handler returns false or the handler
+      #   raises an exception, in which case it's nacked. If false, the handler
+      #   must do the ack/nacking. Defaults to true.
+      #
+      # The handler must implement `call(payload, extra)`, where the payload is
+      # the message payload, and the extra argument contains message metadata as
+      # a hash. If the handler returns false, it is considered rejected, and will
+      # be nacked. Otherwise, the message with be acked.
+      #
+      def initialize(handler, options = {})
+        options.assert_valid_keys(
+          :queue,
+          :on_exception,
+          :on_connection_error,
+          :managed_acking)
+
+        unless handler.respond_to?(:call)
+          raise ArgumentError.new('Handler must implement #call protocool')
+        end
+
+        @queue_options = (options[:queue] || {}).freeze
+        @managed_acking = !!options.fetch(:managed_acking, true)
+        @on_exception = options[:on_exception] || ->(e) { }
+        @on_connection_error = options[:on_connection_error] || @on_exception
+        @handler = handler
+        @river = River.new
+        @next_event_time = Time.now
+      end
+
+      # Runs the handler once.
+      def run_once
+        with_exceptions do
+          now = Time.now
+
+          if @next_event_time > now
+            sleep(@next_event_time - now)
+            now = Time.now
+          end
+
+          if should_run?
+            if process_next
+              @next_event_time = now
+            else
+              if @handler.respond_to?(:on_idle)
+                with_exceptions do
+                  @handler.on_idle
+                end
+              end
+              @next_event_time = now + 1
+            end
+          else
+            @next_event_time = now + 5
+          end
+        end
+        nil
+      end
+
+      # Runs the handler. This will process the queue indefinitely.
+      def run
+        @enabled = true
+        while enabled? do
+          run_once
+        end
+      end
+
+      # Stops any concurrent run.
+      def stop
+        @enabled = false
+      end
+
+      # Are we enabled?
+      def enabled?
+        @enabled
+      end
+
+      private
+
+        def should_run?
+          if @handler.respond_to?(:should_run?)
+            @handler.should_run?
+          else
+            true
+          end
+        end
+
+        def queue
+          @river.connect unless @river.connected?
+          return @queue ||= @river.queue(@queue_options)
+        end
+
+        def process_next
+          with_exceptions do
+            with_connection_error_handling do
+              queue.pop(auto_ack: false, ack: true) do |raw_message|
+                if raw_message[:payload] != :queue_empty
+                  process_message(raw_message)
+                  return true
+                else
+                  return false
+                end
+              end
+            end
+          end
+        end
+
+        def process_message(raw_message)
+          begin
+            message = Message.new(raw_message, queue)
+          rescue => exception
+            ignore_exceptions do
+              queue.nack(delivery_tag: message[:delivery_details][:delivery_tag])
+            end
+            raise exception
+          else
+            begin
+              result = @handler.call(message)
+            rescue *CONNECTION_EXCEPTIONS
+              raise
+            rescue => exception
+              if @managed_acking
+                ignore_exceptions do
+                  message.nack
+                end
+              end
+              raise exception
+            else
+              if result != false and @managed_acking
+                message.ack
+              end
+            end
+          end
+        end
+
+        def with_connection_error_handling(&block)
+          yield
+        rescue *CONNECTION_EXCEPTIONS => exception
+          if @queue
+            ignore_exceptions do
+              @queue.close
+            end
+            @queue = nil
+          end
+
+          @river.disconnect
+
+          ignore_exceptions do
+            @on_connection_error.call(exception)
+          end
+        end
+
+        def with_exceptions(&block)
+          begin
+            yield
+          rescue => exception
+            ignore_exceptions do
+              @on_exception.call(exception)
+            end
+          end
+        end
+
+        def ignore_exceptions(&block)
+          yield
+        rescue
+          # Ignore
+        end
+
+        CONNECTION_EXCEPTIONS = [
+          Bunny::ConnectionError,
+          Bunny::ForcedChannelCloseError,
+          Bunny::ForcedConnectionCloseError,
+          Bunny::ServerDownError,
+          Bunny::ProtocolError,
+          # These should be caught by Bunny, but apparently aren't.
+          Errno::ECONNRESET
+        ].freeze
+
+    end
+
+  end
+end

data/lib/pebbles/river.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/slice'
+require 'json'
+require 'bunny'
+require 'pebblebed/uid'
+require 'servolux'
+
+require_relative "river/version"
+require_relative "river/message"
+require_relative "river/worker"
+require_relative "river/subscription"
+require_relative "river/supervisor"
+require_relative "river/routing"
+require_relative "river/river"
+require_relative "river/compatibility"

data/pebbles-river.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'pebbles/river/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pebbles-river"
+  spec.version       = Pebbles::River::VERSION
+  spec.authors       = ["Alexander Staubo", "Simen Svale Skogsrud"]
+  spec.email         = ["alex@bengler.no"]
+  spec.summary       =
+  spec.description   = %q{Implements an event river mechanism for Pebblebed.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'pebblebed', '>= 0.1.3'
+  spec.add_runtime_dependency 'bunny', '~> 0.8.0'
+  spec.add_runtime_dependency 'activesupport', '>= 3.0'
+  spec.add_runtime_dependency 'servolux', '~> 0.10'
+
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov"
+end

data/spec/lib/river_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+# Note to readers. This is verbose and ugly
+# because I'm trying to understand what I'm doing.
+# When I do understand it, I'll clean up the tests.
+# Until then, please just bear with me.
+# Or explain it to me :)
+describe Pebbles::River::River do
+
+  subject do
+    Pebbles::River::River.new('whatever')
+  end
+
+  CONNECTION_EXCEPTIONS = [
+    Bunny::ConnectionError,
+    Bunny::ForcedChannelCloseError,
+    Bunny::ForcedConnectionCloseError,
+    Bunny::ServerDownError,
+    Bunny::ProtocolError,
+    Errno::ECONNRESET
+  ]
+
+  after(:each) do
+    subject.send(:bunny).queues.each do |name, queue|
+      queue.purge
+      # If you don't delete the queue, the subscription will not
+      # change, even if you give it a new one.
+      queue.delete
+    end
+    subject.disconnect
+  end
+
+  it { subject.should_not be_connected }
+
+  it "gets the name right" do
+    subject.exchange_name.should eq('pebblebed.river.whatever')
+  end
+
+  context "in production" do
+    subject { Pebbles::River::River.new('production') }
+
+    it "doesn't append the thing" do
+      subject.exchange_name.should eq('pebblebed.river')
+    end
+  end
+
+  it "connects" do
+    subject.connect
+    subject.should be_connected
+  end
+
+  it "disconnects" do
+    subject.connect
+    subject.should be_connected
+    subject.disconnect
+    subject.should_not be_connected
+  end
+
+  it "connects if you try to publish something" do
+    subject.should_not be_connected
+    subject.publish(:event => :test, :uid => 'klass:path$123', :attributes => {:a => 'b'})
+    subject.should be_connected
+  end
+
+  it "connects if you try to talk to the exchange" do
+    subject.should_not be_connected
+    subject.send(:exchange)
+    subject.should be_connected
+  end
+
+  describe "publishing" do
+
+    it "gets selected messages" do
+      queue = subject.queue(:name => 'thingivore', :path => 'rspec', :klass => 'thing')
+
+      queue.message_count.should eq(0)
+      subject.publish(:event => 'smile', :uid => 'thing:rspec$1', :attributes => {:a => 'b'})
+      subject.publish(:event => 'frown', :uid => 'thing:rspec$2', :attributes => {:a => 'b'})
+      subject.publish(:event => 'laugh', :uid => 'thing:testunit$3', :attributes => {:a => 'b'})
+      sleep(0.1)
+      queue.message_count.should eq(2)
+    end
+
+    it "gets everything if it connects without a key" do
+      queue = subject.queue(:name => 'omnivore')
+
+      queue.message_count.should eq(0)
+      subject.publish(:event => 'smile', :uid => 'thing:rspec$1', :attributes => {:a => 'b'})
+      subject.publish(:event => 'frown', :uid => 'thing:rspec$2', :attributes => {:a => 'b'})
+      subject.publish(:event => 'laugh', :uid => 'testunit:rspec$3', :attributes => {:a => 'b'})
+      sleep(0.1)
+      queue.message_count.should eq(3)
+    end
+
+    it "sends messages as json" do
+      queue = subject.queue(:name => 'eatseverything')
+      subject.publish(:event => 'smile', :source => 'rspec', :uid => 'klass:path$1', :attributes => {:a => 'b'})
+      sleep(0.1)
+      JSON.parse(queue.pop[:payload])['uid'].should eq('klass:path$1')
+    end
+
+    CONNECTION_EXCEPTIONS.each do |exception_class|
+      context "on temporary failure with #{exception_class}" do
+        it "retries sending until success" do
+          exchange = double('exchange')
+
+          count = 0
+          exchange.stub(:publish) do
+            count += 1
+            if count < 3
+              raise exception_class.new
+            end
+          end
+
+          subject.stub(:exchange) { exchange }
+          subject.stub(:sleep) { }
+
+          expect(subject).to receive(:sleep).at_least(2).times
+
+          expect(exchange).to receive(:publish).at_least(2).times
+
+          subject.publish({event: 'explode', uid: 'thing:rspec$1'})
+        end
+      end
+    end
+
+    CONNECTION_EXCEPTIONS.each do |exception_class|
+      context "on permanent failure with #{exception_class}" do
+        it "re-raises #{exception_class} wrapped in SendFailure exception" do
+          exchange = double('exchange')
+          exchange.stub(:publish) do
+            raise exception_class.new
+          end
+
+          subject.stub(:exchange) { exchange }
+          subject.stub(:sleep) { }
+
+          expect(-> { subject.publish({event: 'explode', uid: 'thing:rspec$1'})}).to raise_error(
+            Pebbles::River::SendFailure)
+        end
+      end
+    end
+
+  end
+
+  it "subscribes" do
+    queue = subject.queue(:name => 'alltestivore', :path => 'area51.rspec|area51.testunit|area52.*|area53.**', :klass => 'thing', :event => 'smile')
+
+    queue.message_count.should eq(0)
+    subject.publish(:event => 'smile', :uid => 'thing:area51.rspec$1', :attributes => {:a => 'b'})
+    subject.publish(:event => 'smile', :uid => 'thing:area51.testunit$2', :attributes => {:a => 'b'})
+    subject.publish(:event => 'smile', :uid => 'thing:area51.whatever$3', :attributes => {:a => 'b'}) # doesn't match path
+    subject.publish(:event => 'frown', :uid => 'thing:area51.rspec$4', :attributes => {:a => 'b'}) # doesn't match event
+    subject.publish(:event => 'smile', :uid => 'thing:area52.one.two.three$5', :attributes => {:a => 'b'}) # doesn't match wildcard path
+    subject.publish(:event => 'smile', :uid => 'thing:area52.one$6', :attributes => {:a => 'b'}) # matches wildcard path
+    subject.publish(:event => 'smile', :uid => 'thing:area53.one.two.three$7', :attributes => {:a => 'b'}) # matches wildcard path
+
+    sleep(0.1)
+    queue.message_count.should eq(4)
+  end
+
+  it "is a durable queue" do
+    queue = subject.queue(:name => 'adurablequeue', :path => 'katrina')
+    subject.publish(:event => 'test', :uid => 'person:katrina$1', :attributes => {:a => rand(1000)}, :persistent => false)
+  end
+
+end

data/spec/lib/routing_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Pebbles::River::Routing do
+
+  subject do
+    Pebbles::River::Routing
+  end
+
+  describe "routing keys" do
+
+    specify do
+      options = {:event => 'created', :uid => 'post.awesome.event:feeds.bagera.whatevs$123'}
+      subject.routing_key_for(options).should eq('created._.post.awesome.event._.feeds.bagera.whatevs')
+    end
+
+    specify "event is required" do
+      ->{ subject.routing_key_for(:uid => 'whatevs') }.should raise_error ArgumentError
+    end
+
+    specify "uid is required" do
+      ->{ subject.routing_key_for(:event => 'whatevs') }.should raise_error ArgumentError
+    end
+
+  end
+end

data/spec/lib/subscription_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+include Pebbles::River
+
+describe Subscription do
+
+  specify 'simple, direct match' do
+    options = {:event => 'create', :klass => 'post.event', :path => 'feed.bagera'}
+    subscription = Subscription.new(options)
+    subscription.queries.should eq(['create._.post.event._.feed.bagera'])
+  end
+
+  specify 'simple wildcard match' do
+    options = {:event => '*.create', :klass => 'post.*', :path => '*.bagera.*'}
+    Subscription.new(options).queries.should eq(['*.create._.post.*._.*.bagera.*'])
+  end
+
+  describe "anything matchers" do
+
+    specify 'match anything (duh)' do
+      options = {:event => '**', :klass => '**', :path => '**'}
+      Subscription.new(options).queries.should eq(['#._.#._.#'])
+    end
+
+    specify 'match anything if not specified' do
+      Subscription.new.queries.should eq(['#._.#._.#'])
+    end
+
+  end
+
+  it 'handles "or" queries' do
+    options = {:event => 'create|delete', :klass => 'post', :path => 'bagera|bandwagon'}
+    expected = ['create._.post._.bagera', 'delete._.post._.bagera', 'create._.post._.bandwagon', 'delete._.post._.bandwagon'].sort
+    Subscription.new(options).queries.sort.should eq(expected)
+  end
+
+  describe "optional paths" do
+    it { Subscription.new.pathify('a.b').should eq(['a.b']) }
+    it { Subscription.new.pathify('a.^b.c').should eq(%w(a a.b a.b.c)) }
+  end
+
+  it "handles optional queries" do
+    options = {:event => 'create', :klass => 'post', :path => 'feeds.bagera.^fb.concerts'}
+    expected = ['create._.post._.feeds.bagera', 'create._.post._.feeds.bagera.fb', 'create._.post._.feeds.bagera.fb.concerts'].sort
+    Subscription.new(options).queries.sort.should eq(expected)
+  end
+
+  it "combines all kinds of weird stuff" do
+    options = {:event => 'create', :klass => 'post', :path => 'a.^b.c|x.^y.z'}
+    expected = [
+      'create._.post._.a',
+      'create._.post._.a.b',
+      'create._.post._.a.b.c',
+      'create._.post._.x',
+      'create._.post._.x.y',
+      'create._.post._.x.y.z',
+    ].sort
+    Subscription.new(options).queries.sort.should eq(expected)
+  end
+
+end

data/spec/lib/worker_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+
+include Pebbles::River
+
+describe Worker do
+
+  subject do
+    Worker
+  end
+
+  let :invalid_handler do
+    Class.new.new
+  end
+
+  let :null_handler do
+    handler = double('null_handler')
+    handler.stub(:call) { }
+    handler
+  end
+
+  let :io_error do
+    IOError.new("This is not the exception you are looking for")
+  end
+
+  let :io_error_raising_handler do
+    handler = double('io_error_raising_handler')
+    handler.stub(:call).and_raise(io_error)
+    handler
+  end
+
+  let :connection_exception do
+    Bunny::ConnectionError.new("Fail!")
+  end
+
+  let :payload do
+    {'answer' => 42}
+  end
+
+  let :raw_message do
+    {
+      header: 'someheader',
+      payload: JSON.dump(payload),
+      delivery_details: {delivery_tag: 'foo'}
+    }
+  end  
+
+  let :queue do
+    queue = double('Bunny::Queue')
+    queue.stub(:close) { nil }
+    queue.stub(:pop) { |&block|
+      block.call(raw_message)
+    }
+    queue.stub(:ack) { }
+    queue.stub(:nack) { }
+    queue
+  end
+
+  let :message do
+    Message.new(raw_message, queue)
+  end
+
+  let :river do
+    river = double('Pebbles::River::River')
+    river.stub(:connected?) { true }
+    river.stub(:queue).and_return(queue)
+    river.stub(:connect).and_return(nil)
+    river
+  end
+
+  before do
+    River.stub(:new).and_return(river)
+  end
+
+  describe '#initialize' do
+    it 'accepts a handler' do
+      worker = subject.new(null_handler)
+      expect(worker.handler).to eq null_handler
+    end
+
+    it 'requires that handler implement #call' do
+      expect(-> {
+        subject.new(invalid_handler)
+      }).to raise_error(ArgumentError)
+    end
+
+    it 'accepts queue options' do
+      worker = subject.new(null_handler, queue: {event: 'foo'})
+      expect(worker.queue_options).to eq({event: 'foo'})
+    end
+  end
+
+  describe '#run_once' do
+
+    it 'creates a queue and runs worker with it' do
+      expect(queue).to receive(:pop).at_least(1).times
+      expect(queue).to receive(:ack).at_least(1).times
+      expect(queue).to_not receive(:nack)
+
+      expect(null_handler).to receive(:call).with(message)
+
+      expect(river).to receive(:connected?).with(no_args).at_least(1).times
+      expect(river).to_not receive(:connect)
+      expect(river).to receive(:queue).with({name: 'foo'})
+
+      subject.new(null_handler, queue: {name: 'foo'}).run_once
+    end
+
+    context 'when queue is empty' do
+      it 'does nothing' do
+        queue.stub(:pop) { |&block|
+          block.call({payload: :queue_empty, delivery_details: {}})
+        }
+
+        expect(queue).to receive(:pop).at_least(1).times
+        expect(queue).to_not receive(:ack)
+        expect(queue).to_not receive(:nack)
+
+        expect(null_handler).not_to receive(:call)
+
+        subject.new(null_handler, queue: {name: 'foo'}).run_once
+      end
+
+      it 'calls #on_idle if implemented' do
+        queue.stub(:pop) { |&block|
+          block.call({payload: :queue_empty, delivery_details: {}})
+        }
+
+        null_handler.stub(:on_idle) { }
+        expect(null_handler).to receive(:on_idle)
+
+        subject.new(null_handler, queue: {name: 'foo'}).run_once
+      end
+    end
+
+    context 'when handler is successful' do
+      it 'acks the message' do
+        expect(queue).to receive(:ack).at_least(1).times
+        expect(queue).to_not receive(:nack)
+        expect(queue).to_not receive(:close)
+
+        expect(river).to receive(:connected?).with(no_args).at_least(1).times
+        expect(river).to_not receive(:connect)
+
+        subject.new(null_handler, queue: {name: 'foo'}).run_once
+      end
+    end
+
+    context 'when handler throws exception' do
+
+      let :on_exception_callback do
+        on_exception_callback = double('on_exception')
+        on_exception_callback.stub(:call) { }
+        on_exception_callback
+      end
+
+      it 'nacks the message' do
+        expect(queue).to receive(:nack).at_least(1).times
+        expect(queue).to_not receive(:close)
+
+        subject.new(io_error_raising_handler, queue: {name: 'foo'}).run_once
+      end
+
+      [
+        Bunny::ConnectionError,
+        Bunny::ForcedChannelCloseError,
+        Bunny::ForcedConnectionCloseError,
+        Bunny::ServerDownError,
+        Bunny::ProtocolError,
+        Errno::ECONNRESET
+      ].each do |exception_class|
+        it "performs connection reset on #{exception_class}" do
+          expect(queue).to receive(:close).at_least(1).times
+
+          handler = double('handler')
+          handler.stub(:call).and_return {
+            raise exception_class.new("Dangit")
+          }
+          expect(handler).to receive(:call).with(message)
+
+          expect(river).to receive(:connected?).with(no_args).at_least(1).times
+          expect(river).to_not receive(:connect)
+          expect(river).to receive(:queue).with({name: 'foo'})
+          expect(river).to receive(:disconnect).at_least(1).times
+
+          subject.new(handler, queue: {name: 'foo'}).run_once
+        end
+      end
+
+      it "calls #on_connection_error if it's implemented" do
+        connection_error_handler = double('on_connection_error')
+        connection_error_handler.stub(:call) { }
+        expect(connection_error_handler).to receive(:call).with(connection_exception)
+
+        expect(queue).to receive(:close).at_least(1).times
+
+        erroring_handler = double('handler')
+        erroring_handler.stub(:call).and_return {
+          raise connection_exception
+        }
+        erroring_handler.stub(:on_connection_error).and_return(nil)
+        expect(erroring_handler).to receive(:call).with(message)
+
+        expect(river).to receive(:connected?).with(no_args).at_least(1).times
+        expect(river).to_not receive(:connect)
+        expect(river).to receive(:disconnect).at_least(1).times
+
+        subject.new(erroring_handler,
+          queue: {name: 'foo'},
+          on_connection_error: connection_error_handler).run_once
+      end
+
+      it "calls #on_exception for non-connection errors" do
+        expect(queue).to_not receive(:close)
+        expect(on_exception_callback).to receive(:call).with(io_error)
+
+        subject.new(io_error_raising_handler,
+          queue: {name: 'foo'},
+          on_exception: on_exception_callback).run_once
+      end
+
+    end
+
+  end
+
+  describe '#run' do
+    it 'runs indefinitely until #enabled? returns false' do
+      count = 0
+
+      handler = double('handler')
+      handler.stub(:call) { }
+
+      expect(handler).to receive(:call).at_least(10).times
+
+      worker = subject.new(handler, queue: {name: 'foo'})
+      worker.stub(:enabled?) {
+        count += 1
+        count <= 10
+      }
+      worker.run
+    end
+
+    context 'when queue is empty' do
+      it 'calls #sleep to delay polling a bit' do
+        queue.stub(:pop) { |&block|
+          block.call({payload: :queue_empty, delivery_details: {}})
+        }
+
+        count = 0
+        worker = subject.new(null_handler, queue: {name: 'foo'})
+        worker.stub(:sleep) { }
+        expect(worker).to receive(:sleep).at_least(9).times
+        worker.stub(:enabled?) {
+          count += 1
+          count <= 10
+        }
+        worker.run
+      end
+    end
+
+    it 'continues on exception'
+    it 'calls #should_run? on handler'
+  end
+
+  describe 'Worker.run' do
+    it 'wraps Worker#run'
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'simplecov'
+require 'rspec'
+require 'rspec/mocks'
+
+SimpleCov.add_filter 'spec'
+SimpleCov.add_filter 'config'
+SimpleCov.start
+
+require_relative '../lib/pebbles/river'
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: pebbles-river
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexander Staubo
+- Simen Svale Skogsrud
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pebblebed
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: servolux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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: simplecov
+  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'
+description: Implements an event river mechanism for Pebblebed.
+email:
+- alex@bengler.no
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pebbles/river.rb
+- lib/pebbles/river/compatibility.rb
+- lib/pebbles/river/message.rb
+- lib/pebbles/river/river.rb
+- lib/pebbles/river/routing.rb
+- lib/pebbles/river/subscription.rb
+- lib/pebbles/river/supervisor.rb
+- lib/pebbles/river/version.rb
+- lib/pebbles/river/worker.rb
+- pebbles-river.gemspec
+- spec/lib/river_spec.rb
+- spec/lib/routing_spec.rb
+- spec/lib/subscription_spec.rb
+- spec/lib/worker_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+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: Implements an event river mechanism for Pebblebed.
+test_files:
+- spec/lib/river_spec.rb
+- spec/lib/routing_spec.rb
+- spec/lib/subscription_spec.rb
+- spec/lib/worker_spec.rb
+- spec/spec_helper.rb
+has_rdoc: