pebbles-river 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 810c3766a5dca1d09e230dd2fa33b2cfc2f17a6e
-  data.tar.gz: 907a549065e1ae8013cfa6738466c92dbaa5e4ef
+  metadata.gz: e2e7d4334cd98eebaa0bb87f18ff27cb94c373bf
+  data.tar.gz: 21845c17a52a8c30aa620cf77e7d872fda365751
 SHA512:
-  metadata.gz: ea19b805fe8d0c09f826a0cd6f52bdf155173d2c530347fa04c487baecd7a2924a1aac866b1dfb0fccfbde1c2de18790631c416566157ff6125b431256aee347
-  data.tar.gz: 117fcfcf720e0de40ed98f6f37f0b1a9bf037748fcb9e1e8de84039dc3e9e9d0a21ef791b5fa8ef66626523471607f4ceced93cbce692ad47f7b3dd347b82df3
+  metadata.gz: b9757df6f8aa96fafca5646fd75dc0b31741d80b6c49a5713b70c6a16c2a26a6fa5ec9c5a1e12bf2b6d619b99a891923f0671364f6372f83b43568b56e27bbc7
+  data.tar.gz: 734552e446937b0016bf4aded20221f477fc6083f6e4f378c0c633bd74f40cf7cbe38e23e203146176af684f7a374ffa62c06836d245868d449f2aeabbef89b3

data/lib/pebbles/river.rb

@@ -9,7 +9,6 @@ require_relative "river/version"
 require_relative "river/errors"
 require_relative "river/message"
 require_relative "river/worker"
-require_relative "river/subscription"
 require_relative "river/supervisor"
 require_relative "river/routing"
 require_relative "river/river"

data/lib/pebbles/river/river.rb

@@ -8,12 +8,18 @@ module Pebbles
       attr_reader :session
       attr_reader :channel
       attr_reader :prefetch
+      attr_reader :exchange_name
 
       def initialize(options = {})
         options = {environment: options} if options.is_a?(String)  # Backwards compatibility
 
         @environment = (options[:environment] || ENV['RACK_ENV'] || 'development').dup.freeze
+
+        @exchange_name = 'pebblebed.river'
+        @exchange_name << ".#{environment}" if @environment != 'production'
+
         @last_connect_attempt = nil
+
         @prefetch = options[:prefetch]
       end
 
@@ -25,15 +31,13 @@ module Pebbles
         unless @session and @channel and @exchange
           disconnect
           handle_session_error do
-            session = Bunny::Session.new(::Pebbles::River.rabbitmq_options)
-            session.start
-
-            channel = session.create_channel
-            channel.prefetch(@prefetch) if @prefetch
+            @session = Bunny::Session.new(::Pebbles::River.rabbitmq_options)
+            @session.start
 
-            exchange = channel.exchange(exchange_name, EXCHANGE_OPTIONS.dup)
+            @channel = @session.create_channel
+            @channel.prefetch(@prefetch) if @prefetch
 
-            @session, @channel, @exchange = session, channel, exchange
+            @exchange = @channel.exchange(@exchange_name, EXCHANGE_OPTIONS.dup)
           end
         end
       end
@@ -70,16 +74,27 @@ module Pebbles
       end
 
       def queue(options = {})
+        options.assert_valid_keys(:name, :ttl, :event, :path, :klass,
+          :dead_letter_routing_key, :routing_key)
+
         raise ArgumentError.new 'Queue must be named' unless options[:name]
 
-        queue_opts = {durable: true}
+        queue_args = {}
         if (ttl = options[:ttl])
-          queue_opts[:arguments] = {'x-message-ttl' => ttl}
+          queue_args['x-message-ttl'] = ttl
+        end
+        if (dead_letter_routing_key = options[:dead_letter_routing_key])
+          queue_args['x-dead-letter-exchange'] = @exchange_name
+          queue_args['x-dead-letter-routing-key'] = dead_letter_routing_key
         end
+        queue_opts = {durable: true, arguments: queue_args}
 
         connect
         queue = @channel.queue(options[:name], queue_opts)
-        Subscription.new(options).queries.each do |key|
+        if (routing_key = options[:routing_key])
+          queue.bind(exchange.name, key: routing_key)
+        end
+        Routing.binding_routing_keys_for(options.slice(:event, :class, :path)).each do |key|
           queue.bind(exchange.name, key: key)
         end
         queue
@@ -87,20 +102,10 @@ module Pebbles
 
       private
 
-        def exchange_name
-          return @exchange_name ||= format_exchange_name
-        end
-
-        def format_exchange_name
-          name = 'pebblebed.river'
-          name << ".#{environment}" if @environment != 'production'
-          name
-        end
-
         def handle_session_error(exception_klass = ConnectFailure, &block)
           last_exception = nil
           Timeout.timeout(MAX_RETRY_TIMEOUT) do
-            retry_until, retry_count = nil, 0
+            retry_count = 0
             begin
               yield
             rescue *CONNECTION_EXCEPTIONS => exception
@@ -112,6 +117,9 @@ module Pebbles
             end
           end
         rescue Timeout::Error => timeout_exception
+          # Timeouts can screw up the connection, so forcibly close it
+          disconnect
+
           if last_exception
             raise exception_klass.new(last_exception.message, last_exception)
           else

data/lib/pebbles/river/routing.rb

@@ -4,7 +4,6 @@ module Pebbles
 
       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]
 
@@ -13,6 +12,40 @@ module Pebbles
         key.join('._.')
       end
 
+      def self.binding_routing_keys_for(options)
+        options.assert_valid_keys(:path, :class, :event)
+        keys = []
+        if options[:event] or options[:path] or options[:class]
+          element_to_routing_key_parts(options[:event]).each do |event|
+            element_to_routing_key_parts(options[:class]).each do |klass|
+              element_to_routing_key_parts(options[:path]).each do |pathspec|
+                path_to_routing_key_parts(pathspec).each do |path|
+                  keys << [event, klass, path].join('._.')
+                end
+              end
+            end
+          end
+        end
+        keys
+      end
+
+      private
+
+        def self.path_to_routing_key_parts(s)
+          required, optional = s.split('^').map { |p| p.split('.') }
+          required = Array(required.join('.'))
+          optional ||= []
+          (0..optional.length).map {|i| required + optional[0,i]}.map {|p| p.join('.')}
+        end
+
+        def self.element_to_routing_key_parts(s)
+          s ||= '#'
+          if s.respond_to?(:to_a)
+            s = s.join('|')
+          end
+          s.gsub('**', '#').split('|')
+        end
+
     end
   end
-end
+end

data/lib/pebbles/river/version.rb

@@ -1,5 +1,5 @@
 module Pebbles
   module River
-    VERSION = '0.2.6'
+    VERSION = '0.3.0'
   end
 end

data/lib/pebbles/river/worker.rb

@@ -50,6 +50,7 @@ module Pebbles
         else
           @managed_acking = true
         end
+        @dead_lettered = !!@queue_options[:dead_letter_routing_key]
         @on_exception = options[:on_exception] || ->(*args) { }
         @handler = handler
         @river = River.new(options.slice(:prefetch))
@@ -137,7 +138,7 @@ module Pebbles
             message = Message.new(content, delivery_info, queue)
           rescue => exception
             ignore_exceptions do
-              queue.channel.nack(delivery_info, false, true)
+              reject(delivery_info)
             end
             raise exception
           else
@@ -148,7 +149,7 @@ module Pebbles
             rescue => exception
               if @managed_acking
                 ignore_exceptions do
-                  message.nack
+                  reject(delivery_info)
                 end
               end
               raise exception
@@ -156,7 +157,7 @@ module Pebbles
               if @managed_acking
                 case result
                   when false
-                    message.nack
+                    reject(delivery_info)
                   else
                     message.ack
                 end
@@ -165,6 +166,14 @@ module Pebbles
           end
         end
 
+        def reject(delivery_info)
+          # Normally requeue, except if we are dead-lettering to another queue, where
+          # requeue = false means to bounce it to DLX.
+          requeue = !@dead_lettered
+
+          queue.channel.reject(delivery_info.delivery_tag.to_i, requeue)
+        end
+
         def with_exceptions(&block)
           begin
             yield

data/spec/lib/routing_spec.rb

@@ -6,20 +6,72 @@ describe Pebbles::River::Routing do
     Pebbles::River::Routing
   end
 
-  describe "routing keys" do
-
+  describe '#routing_key_for' do
     specify do
-      options = {:event => 'created', :uid => 'post.awesome.event:feeds.bagera.whatevs$123'}
+      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
+    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
+    specify 'uid is required' do
+      ->{ subject.routing_key_for(event: 'whatevs') }.should raise_error ArgumentError
+    end
+  end
+
+  describe '#binding_routing_keys_for' do
+    specify 'simple, direct match' do
+      expect(subject.binding_routing_keys_for(event: 'create', class: 'post.event', path: 'feed.bagera')).to eq [
+        'create._.post.event._.feed.bagera'
+      ]
+    end
+
+    specify 'simple wildcard match' do
+      options = {event: '*.create', class: 'post.*', path: '*.bagera.*'}
+      expect(subject.binding_routing_keys_for(options)).to eq(['*.create._.post.*._.*.bagera.*'])
     end
 
+    describe "anything matchers" do
+      specify 'match anything (duh)' do
+        expect(subject.binding_routing_keys_for({event: '**', class: '**', path: '**'})).to eq(['#._.#._.#'])
+      end
+
+      specify 'match nothing if not specified' do
+        expect(subject.binding_routing_keys_for({})).to eq []
+      end
+    end
+
+    it 'handles "or" queries' do
+      options = {event: 'create|delete', class: 'post', path: 'bagera|bandwagon'}
+      expected = ['create._.post._.bagera', 'delete._.post._.bagera', 'create._.post._.bandwagon', 'delete._.post._.bandwagon'].sort
+      expect(subject.binding_routing_keys_for(options).sort).to eq(expected)
+    end
+
+    # FIXME
+    # 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', class: 'post', path: 'feeds.bagera.^fb.concerts'}
+      expected = ['create._.post._.feeds.bagera', 'create._.post._.feeds.bagera.fb', 'create._.post._.feeds.bagera.fb.concerts'].sort
+      expect(subject.binding_routing_keys_for(options).sort).to eq(expected)
+    end
+
+    it "combines all kinds of weird stuff" do
+      options = {event: 'create', class: '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
+      expect(subject.binding_routing_keys_for(options).sort).to eq(expected)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pebbles-river
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Alexander Staubo
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-02 00:00:00.000000000 Z
+date: 2016-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pebblebed
@@ -157,14 +157,12 @@ files:
 - lib/pebbles/river/rate_limiter.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: ''
@@ -187,14 +185,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.2.5
 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: 

data/lib/pebbles/river/subscription.rb

@@ -1,44 +0,0 @@
-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/spec/lib/subscription_spec.rb

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