multiple_man 0.8.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ffabcdb730b52881f54be58ff8cb9a5f0da82b7
-  data.tar.gz: 15a4b0417183785e3234f28cf0c321b4249a8319
+  metadata.gz: eff9e5989a0fe4702caf87df4d8a50b0fb5cea03
+  data.tar.gz: 04361d38e491938b791dfb98e16727240ee33daa
 SHA512:
-  metadata.gz: 1e0d0b0df3f6eee4f9b1aae2f856514d5e063ef64bc3eb277b046c15ea92b4e9100db5f71821d8e06e9d9d8265dcd413da9a08f691ef7d175040f756b673cf9c
-  data.tar.gz: 9196199a4849489924e1cac04e46dd4e24490b09f89d02b70a5c5398df20c4245e7130148fde0cf9c4aa921168c9518b691a1c0bf7618c1db9f6e2d7eeee115a
+  metadata.gz: 4fdf426a23e43e4ee9f13d19d2b940d329b8ead830fe0155043370c0341d7e8b1ef012d8712375f85d9235c9aea2a61e9084b80b6837dd8b37e01f0952c7988a
+  data.tar.gz: 092424fa6b574af0eef20f6585b0fe1026cc0baee453eb4d349bb106d9d71ca2f612df050dee82030140dea45f43f017043d784d5bf3ee70c2b2e74ea9fd1ae3

data/README.md

@@ -68,6 +68,9 @@ exceptions encountered in an `after_commit` block, meaning
 that without handling these errors through the configuration,
 they will be silently ignored.
 
+Errors will be captured and wrapped in a MultipleMan::Error. The
+cause will be preserved in Exception#cause.
+
 ### Publishing models
 
 #### Directly from the model
@@ -111,7 +114,7 @@ By default, MultipleMan will publish all of your models whenever you save a mode
 
 ```
 # Publish all widgets to MultipleMan
-Widget.multiple_man_publish  
+Widget.multiple_man_publish
 
 # Publish a subset of widgets to MultipleMan
 Widget.where(published: true).multiple_man_publish
@@ -184,6 +187,26 @@ MyModel.multiple_man_publish(:seed)
 
 3. Stop the seeder rake task when all of your messages have been processed. You can check your RabbitMQ server
 
+## Upgrading to 1.0
+
+The major change is that MultipleMan will no longer create a queue per listener.
+There is only 1 queue that will have multiple bindings to the exchange so that
+you have a chance to maintain causal consistency.
+
+Assuming you are using vanilla MultipleMan you will need to run both the
+regular worker and the new 'transition_worker' for a short period. The
+transitional worker will connect to your old queues, unbind them and allow them
+to drain. Once the queues are empty you can safely shut the transitional worker
+down and delete the old queues.
+
+So for example if you use a Procfile:
+
+```
+multiple_man_worker: rake multiple_man:worker
+# Temporary until old queues are drained
+transition_worker: rake multiple_man:transition_worker
+```
+
 ## Contributing
 
 1. Fork it

data/circle.yml

@@ -1,3 +1,3 @@
 machine:
   ruby:
-    version: ruby-2.2.2
+    version: ruby-2.2.3

data/lib/multiple_man/channel_maintenance/gc.rb

@@ -5,7 +5,7 @@ module MultipleMan
         proc { queue << RemoveCommand.new(thread_id); reaper.push(channel) }
       end
 
-      def initialize(config, reaper)
+      def initialize(_, reaper)
         @reaper = reaper
         @queue = Queue.new
 

data/lib/multiple_man/configuration.rb

@@ -1,5 +1,19 @@
 module MultipleMan
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration) if block_given?
+  end
+
   class Configuration
+    attr_reader :subscriber_registry
+    attr_accessor :topic_name, :app_name, :connection, :enabled, :error_handler,
+                  :worker_concurrency, :reraise_errors, :connection_recovery,
+                  :queue_name, :prefetch_size
+
+    attr_writer :logger
 
     def initialize
       self.topic_name = "multiple_man"
@@ -7,11 +21,18 @@ module MultipleMan
       self.enabled = true
       self.worker_concurrency = 1
       self.reraise_errors = true
+      self.prefetch_size = 100
       self.connection_recovery = {
         time_before_reconnect: 0.2,
         time_between_retries: 0.8,
         max_retries: 5
       }
+
+      @subscriber_registry = Subscribers::Registry.new
+    end
+
+    def queue_name
+      @queue_name ||= "#{topic_name}.#{app_name}"
     end
 
     def logger
@@ -22,16 +43,12 @@ module MultipleMan
       @error_handler = block
     end
 
-    attr_accessor :topic_name, :app_name, :connection, :enabled, :error_handler,
-                  :worker_concurrency, :reraise_errors, :connection_recovery
-    attr_writer :logger
-  end
-
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
+    def listeners
+      subscriber_registry.subscriptions
+    end
 
-  def self.configure
-    yield(configuration) if block_given?
+    def register_listener(listener)
+      subscriber_registry.register(listener)
+    end
   end
 end

data/lib/multiple_man/consumers/general.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'active_support/core_ext/hash'
+
+module MultipleMan
+  module Consumers
+    class General
+      def initialize(subscribers:, queue:, topic:)
+        self.subscribers = subscribers
+        @topic = topic
+        @queue = queue
+      end
+
+      def listen
+        MultipleMan.logger.debug "Starting listeners."
+        create_bindings
+
+        queue.subscribe(manual_ack: true) do |delivery_info, meta_data, payload|
+          MultipleMan.logger.debug "Processing message for #{delivery_info.routing_key}."
+          message = JSON.parse(payload).with_indifferent_access
+          receive(delivery_info, meta_data, message)
+        end
+      end
+
+      private
+
+      attr_reader :subscribers, :topic, :queue
+
+      def create_bindings
+        subscribers.values.each do |subscriber|
+          MultipleMan.logger.info "Listening for #{subscriber.listen_to} with routing key #{subscriber.routing_key}."
+          queue.bind(topic, routing_key: routing_key_for_subscriber(subscriber))
+        end
+      end
+
+      def receive(delivery_info, _, message)
+        method = operation(message, delivery_info.routing_key)
+        dispatch_subscribers(message, method, delivery_info.routing_key)
+        queue.channel.acknowledge(delivery_info.delivery_tag, false)
+
+        MultipleMan.logger.debug "Successfully processed! #{delivery_info.routing_key}"
+      rescue => ex
+        begin
+          raise ConsumerError
+        rescue => wrapped_ex
+          MultipleMan.logger.debug "\tError #{wrapped_ex.message} \n#{wrapped_ex.backtrace}"
+          MultipleMan.error(wrapped_ex, reraise: false, payload: message, delivery_info: delivery_info)
+          queue.channel.nack(delivery_info.delivery_tag)
+        end
+      end
+
+      def dispatch_subscribers(message, method, routing_key)
+        subscribers.select { |k,s| k.match(routing_key) }
+          .values
+          .each do |s|
+            s.send(method, message)
+          end
+      end
+
+      def operation(message, routing_key)
+        message['operation'] || routing_key.split('.').last
+      end
+
+      def routing_key_for_subscriber(subscriber)
+        subscriber.routing_key
+      end
+
+      def subscribers=(subscribers)
+        @subscribers = subscribers.map { |s|
+          key = routing_key_for_subscriber(s).gsub('.', '\.').gsub('#', '.*')
+          [/^#{key}$/, s]
+        }.to_h
+      end
+    end
+  end
+end

data/lib/multiple_man/consumers/seed.rb

@@ -0,0 +1,15 @@
+module MultipleMan::Consumers
+  class Seed < General
+
+    private
+
+    def operation(_, _)
+      "create"
+    end
+
+    def routing_key_for_subscriber(subscriber)
+      subscriber.routing_key(:seed)
+    end
+
+  end
+end

data/lib/multiple_man/consumers/transitional.rb

@@ -0,0 +1,50 @@
+require 'json'
+require 'active_support/core_ext/hash'
+
+module MultipleMan::Consumers
+  class Transitional
+
+    attr_reader :subscription, :queue, :topic
+
+    def initialize(subscription:, queue:, topic:)
+      @subscription = subscription
+      @topic = topic
+      @queue = queue
+    end
+
+    def listen
+      MultipleMan.logger.info "Listening for #{subscription.listen_to} with routing key #{routing_key}."
+      queue.unbind(topic, routing_key: routing_key).subscribe(manual_ack: true) do |delivery_info, _, payload|
+        process_message(delivery_info, payload)
+      end
+    end
+
+    def process_message(delivery_info, payload)
+      MultipleMan.logger.debug "Processing message for #{delivery_info.routing_key}."
+
+      payload = JSON.parse(payload).with_indifferent_access
+      subscription.send(operation(delivery_info, payload), payload)
+      MultipleMan.logger.debug "   Successfully processed!"
+      queue.channel.acknowledge(delivery_info.delivery_tag, false)
+    rescue => ex
+      raise MultipleMan::ConsumerError rescue handle_error($!, delivery_info)
+    end
+
+    def handle_error(ex, delivery_info)
+      MultipleMan.logger.error "   Error - #{ex.message}\n\n#{ex.backtrace}"
+      MultipleMan.error(ex, reraise: false)
+
+      # Requeue the message
+      queue.channel.nack(delivery_info.delivery_tag)
+    end
+
+    def operation(delivery_info, payload)
+      payload['operation'] || delivery_info.routing_key.split(".").last
+    end
+
+    def routing_key
+      subscription.routing_key
+    end
+
+  end
+end

data/lib/multiple_man/mixins/listener.rb

@@ -1,15 +1,15 @@
 module MultipleMan
   module Listener
-    def Listener.included(base)
+    def self.included(base)
       base.extend(ClassMethods)
     end
 
-    def routing_key(operation=self.operation)
-      MultipleMan::RoutingKey.new(klass, operation).to_s
+    def routing_key(operation = self.operation)
+      MultipleMan::RoutingKey.new(listen_to, operation).to_s
     end
 
-    attr_accessor :klass
     attr_accessor :operation
+    attr_accessor :listen_to
 
     def create(payload)
       # noop
@@ -23,16 +23,13 @@ module MultipleMan
       # noop
     end
 
-    def queue_name
-      "#{MultipleMan.configuration.topic_name}.#{MultipleMan.configuration.app_name}.#{klass}"
-    end
-
     module ClassMethods
       def listen_to(model, operation: '#')
-        listener = self.new
-        listener.klass = model
+        listener = new
+        listener.listen_to = model
         listener.operation = operation
-        Subscribers::Registry.register(listener)
+        MultipleMan.configuration.register_listener(listener)
+        listener
       end
     end
   end

data/lib/multiple_man/mixins/subscriber.rb

@@ -6,7 +6,7 @@ module MultipleMan
 
     module ClassMethods
       def subscribe(options = {})
-        Subscribers::Registry.register(Subscribers::ModelSubscriber.new(self, options))
+        ::MultipleMan.configuration.register_listener(Subscribers::ModelSubscriber.new(self, options))
       end
     end
   end

data/lib/multiple_man/subscribers/base.rb

@@ -7,19 +7,19 @@ module MultipleMan::Subscribers
 
     attr_reader :klass
 
-    def create(payload)
+    def create(_)
       # noop
     end
 
-    def update(payload)
+    def update(_)
       # noop
     end
 
-    def destroy(payload)
+    def destroy(_)
       # noop
     end
 
-    def seed(payload)
+    def seed(_)
       # noop
     end
 
@@ -27,11 +27,11 @@ module MultipleMan::Subscribers
       MultipleMan::RoutingKey.new(klass, operation).to_s
     end
 
-    def queue_name
-      "#{MultipleMan.configuration.topic_name}.#{MultipleMan.configuration.app_name}.#{klass}"
+    def listen_to
+      klass
     end
 
-  private
+    private
 
     attr_writer :klass
   end

data/lib/multiple_man/subscribers/registry.rb

@@ -1,12 +1,13 @@
 module MultipleMan::Subscribers
   class Registry
-    @subscriptions = []
-    class << self
-      attr_accessor :subscriptions
+    attr_reader :subscriptions
 
-      def register(subscription)
-        self.subscriptions << subscription
-      end
+    def initialize
+      @subscriptions = []
+    end
+
+    def register(subscription)
+      self.subscriptions << subscription
     end
   end
 end

data/lib/multiple_man/tasks/worker.rake

@@ -1,18 +1,58 @@
 namespace :multiple_man do
   desc "Run multiple man listeners"
-  task :worker => :environment do
-    run_listener(MultipleMan::Listeners::Listener)
+  task worker: :environment do
+    channel = MultipleMan::Connection.connection.create_channel
+    channel.prefetch(MultipleMan.configuration.prefetch_size)
+    queue_name = MultipleMan.configuration.queue_name
+    queue = channel.queue(queue_name, durable: true, auto_delete: false)
+
+    run_listener(MultipleMan::Consumers::General, queue)
   end
 
   desc 'Run a seeding listener'
   task seed: :environment do
-    run_listener(MultipleMan::Listeners::SeederListener)
+    channel = MultipleMan::Connection.connection.create_channel
+    channel.prefetch(MultipleMan.configuration.prefetch_size)
+    queue_name = MultipleMan.configuration.queue_name + '.seed'
+    queue = channel.queue(queue_name, durable: false, auto_delete: true)
+
+    run_listener(MultipleMan::Consumers::Seed, queue)
+  end
+
+  def run_listener(listener, queue)
+    Rails.application.eager_load! if defined?(Rails)
+
+    subscribers = MultipleMan.configuration.listeners
+    topic = MultipleMan.configuration.topic_name
+
+    listener.new(subscribers: subscribers, queue: queue, topic: topic).listen
+
+    Signal.trap("INT") { puts "received INT"; exit }
+    Signal.trap("QUIT") { puts "received QUIT"; exit }
+    Signal.trap("TERM") { puts "received TERM"; exit }
+
+    sleep
   end
 
-  def run_listener(listener)
-    Rails.application.eager_load!
+  desc 'Run transitional worker'
+  task transition_worker: :environment do
+    Rails.application.eager_load! if defined?(Rails)
 
-    listener.start
+    topic = MultipleMan.configuration.topic_name
+    app_name = MultipleMan.configuration.app_name
+    channel = MultipleMan::Connection.connection.create_channel
+    channel.prefetch(MultipleMan.configuration.prefetch_size)
+
+    MultipleMan.configuration.listeners.each do |listener|
+      queue_name = listener.respond_to?(:queue_name) ?
+                     listener.queue_name :
+                     "#{topic}.#{app_name}.#{listener.listen_to}"
+
+      next unless MultipleMan::Connection.connection.queue_exists?(queue_name)
+      queue = channel.queue(queue_name, durable: true, auto_delete: false)
+
+      MultipleMan::Consumers::Transitional.new(subscription: listener, queue: queue, topic: topic).listen
+    end
 
     Signal.trap("INT") { puts "received INT"; exit }
     Signal.trap("QUIT") { puts "received QUIT"; exit }
@@ -20,4 +60,5 @@ namespace :multiple_man do
 
     sleep
   end
+
 end

data/lib/multiple_man/version.rb

@@ -1,3 +1,3 @@
 module MultipleMan
-  VERSION = "0.8.1"
+  VERSION = "1.0.0"
 end

data/lib/multiple_man.rb

@@ -2,6 +2,9 @@ require "multiple_man/version"
 require 'active_support'
 
 module MultipleMan
+  Error = Class.new(StandardError)
+  ConsumerError = Class.new(Error)
+  
   require 'multiple_man/railtie' if defined?(Rails)
 
   require 'multiple_man/mixins/publisher'
@@ -16,8 +19,9 @@ module MultipleMan
   require 'multiple_man/payload_generator'
   require 'multiple_man/connection'
   require 'multiple_man/routing_key'
-  require 'multiple_man/listeners/listener'
-  require 'multiple_man/listeners/seeder_listener'
+  require 'multiple_man/consumers/general'
+  require 'multiple_man/consumers/transitional'
+  require 'multiple_man/consumers/seed'
   require 'multiple_man/model_populator'
   require 'multiple_man/identity'
   require 'multiple_man/publish'
@@ -38,11 +42,14 @@ module MultipleMan
   end
 
   def self.error(ex, options = {})
-    if configuration.error_handler
-      configuration.error_handler.call(ex)
-      raise ex if configuration.reraise_errors && options[:reraise] != false
+    raise ex unless configuration.error_handler
+
+    if configuration.error_handler.arity == 3
+      configuration.error_handler.call(ex, options[:payload], options[:delivery_info])
     else
-      raise ex
+      configuration.error_handler.call(ex)
     end
+
+    raise ex if configuration.reraise_errors && options[:reraise] != false
   end
 end

data/multiple_man.gemspec

@@ -10,13 +10,17 @@ Gem::Specification.new do |spec|
   spec.email         = ["ryan@influitive.com"]
   spec.description   = %q{MultipleMan syncs changes to ActiveRecord models via AMQP}
   spec.summary       = %q{MultipleMan syncs changes to ActiveRecord models via AMQP}
-  spec.homepage      = ""
+  spec.homepage      = "http://github.com/influitive/multiple_man"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
   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.required_ruby_version = '>= 2.1'
+
+  spec.add_runtime_dependency     "bunny", '>= 1.2'
+  spec.add_runtime_dependency     "activesupport", '>= 3.0'
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "pry"
@@ -25,6 +29,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'codeclimate-test-reporter'
   spec.add_development_dependency 'guard'
   spec.add_development_dependency 'guard-rspec'
-  spec.add_runtime_dependency     "bunny", '>= 1.2'
-  spec.add_runtime_dependency     "activesupport", '>= 3.0'
 end

data/spec/connection_spec.rb

@@ -3,19 +3,18 @@ require 'spec_helper'
 describe MultipleMan::Connection do
 
   let(:mock_bunny) { double(Bunny, open?: true, close: nil) }
-  let(:mock_channel) { double(Bunny::Channel, close: nil, open?: true, topic: nil) }
+  let(:mock_channel) { double(Bunny::Channel, close: nil, open?: true, topic: nil, number: 1) }
 
-  describe "connect" do
-    it "should open a connection and a channel" do
-      MultipleMan::Connection.should_receive(:connection).and_return(mock_bunny)
-      mock_bunny.should_receive(:create_channel).once.and_return(mock_channel)
-
-      described_class.connect { }
-    end
+  after do
+    Thread.current.thread_variable_set(:multiple_man_current_channel, nil)
+    MultipleMan::Connection.reset!
   end
 
-  subject { described_class.new(mock_channel) }
-
-  its(:topic_name) { should == MultipleMan.configuration.topic_name }
+  it "should open a connection and a channel" do
+    MultipleMan::Connection.should_receive(:connection).and_return(mock_bunny)
+    mock_bunny.should_receive(:create_channel).once.and_return(mock_channel)
+    expect(mock_channel).to receive(:topic).with(MultipleMan.configuration.topic_name)
 
+    described_class.connect { }
+  end
 end

data/spec/consumers/general_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe MultipleMan::Consumers::General do
+  let(:listener1) {
+    Class.new do
+      include MultipleMan::Listener
+
+      def initialize
+        self.listen_to = 'SomeClass'
+        self.operation = '#'
+      end
+    end
+  }
+
+  let(:listener2) {
+    Class.new do
+      include MultipleMan::Listener
+
+      def initialize
+        self.listen_to = 'SomeOtherClass'
+        self.operation = '#'
+      end
+    end
+  }
+
+  it "listens to each subscription" do
+    subscriptions = [listener1.new, listener2.new]
+    queue = double(Bunny::Queue)
+
+    expect(queue).to receive(:bind).with('some-topic', routing_key: subscriptions.first.routing_key).ordered
+    expect(queue).to receive(:bind).with('some-topic', routing_key: subscriptions.last.routing_key).ordered
+    expect(queue).to receive(:subscribe).with(manual_ack: true).ordered
+
+    subject = described_class.new(subscribers: subscriptions, queue: queue, topic: 'some-topic')
+
+    subject.listen
+  end
+
+  it "sends the correct data" do
+    channel = double(Bunny::Channel)
+    queue = double(Bunny::Queue, channel: channel).as_null_object
+
+    subscriber = listener1.new
+    subject = described_class.new(subscribers:[subscriber], queue: queue, topic: 'some-topic')
+
+    expect(channel).to receive(:acknowledge)
+    expect(subscriber).to receive(:create).with({"a" => 1, "b" => 2})
+
+    delivery_info = OpenStruct.new(routing_key: "multiple_man.SomeClass.create")
+    payload = '{"a":1,"b":2}'
+    allow(queue).to receive(:subscribe).and_yield(delivery_info, double(:meta), payload)
+
+    subject.listen
+  end
+
+  it "uses the payload to determine the operation if it's available" do
+    channel = double(Bunny::Channel).as_null_object
+    queue = double(Bunny::Queue, channel: channel).as_null_object
+
+    subscriber = listener1.new
+    subject = described_class.new(subscribers:[subscriber], queue: queue, topic: 'some-topic')
+
+    delivery_info = OpenStruct.new(routing_key: "multiple_man.SomeClass.some_other_operation")
+    payload = '{"operation": "create", "a":1,"b":2}'
+    allow(queue).to receive(:subscribe).and_yield(delivery_info, double(:meta), payload)
+
+    subscriber.should_receive(:create)
+
+    subject.listen
+  end
+
+  it "sends a nack on failure" do
+    allow(MultipleMan.configuration).to receive(:error_handler) { double(:handler).as_null_object}
+
+    channel = double(Bunny::Channel)
+    queue = double(Bunny::Queue, channel: channel).as_null_object
+
+    delivery_info = OpenStruct.new(routing_key: "multiple_man.SomeClass.create")
+    payload = '{"a":1,"b":2}'
+    allow(queue).to receive(:subscribe).and_yield(delivery_info, double(:meta), payload)
+
+    subscriber = listener1.new
+    allow(subscriber).to receive(:create).and_raise('anything')
+
+    expect(channel).to receive(:nack)
+    subject = described_class.new(subscribers:[subscriber], queue: queue, topic: 'some-topic')
+    subject.listen
+  end
+
+  it 'wraps errors in ConsumerError' do
+    channel = double(Bunny::Channel)
+    queue = double(Bunny::Queue, channel: channel).as_null_object
+
+    delivery_info = OpenStruct.new(routing_key: "multiple_man.SomeClass.create")
+    payload = '{"a":1,"b":2}'
+    allow(queue).to receive(:subscribe).and_yield(delivery_info, double(:meta), payload)
+
+    subscriber = listener1.new
+    allow(subscriber).to receive(:create).and_raise('anything')
+
+    allow(channel).to receive(:nack)
+
+    expect(MultipleMan).to receive(:error).with(kind_of(MultipleMan::ConsumerError), kind_of(Hash))
+    subject = described_class.new(subscribers:[subscriber], queue: queue, topic: 'some-topic')
+    subject.listen
+  end
+end

data/spec/consumers/seed_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe MultipleMan::Consumers::Seed do
+  let(:listener1) {
+    Class.new do
+      include MultipleMan::Listener
+
+      def initialize
+        self.listen_to = 'SomeClass'
+        self.operation = '#'
+      end
+    end
+  }
+
+  it 'binds for seeding' do
+    channel = double(Bunny::Channel).as_null_object
+    queue = double(Bunny::Queue, channel: channel)
+
+    expect(queue).to receive(:bind).with('some-topic', routing_key: "multiple_man.seed.SomeClass")
+    expect(queue).to receive(:subscribe).with(manual_ack: true)
+
+    subject = described_class.new(subscribers: [listener1.new], queue: queue, topic: 'some-topic')
+    subject.listen
+  end
+
+  it "sends the correct data" do
+    channel = double(Bunny::Channel)
+    queue = double(Bunny::Queue, channel: channel).as_null_object
+
+    subscriber = listener1.new
+    subject = described_class.new(subscribers:[subscriber], queue: queue, topic: 'some-topic')
+
+    expect(channel).to receive(:acknowledge)
+    expect(subscriber).to receive(:create).with({"a" => 1, "b" => 2})
+
+    delivery_info = OpenStruct.new(routing_key: "multiple_man.seed.SomeClass")
+    payload = '{"a":1,"b":2}'
+    allow(queue).to receive(:subscribe).and_yield(delivery_info, double(:meta), payload)
+
+    subject.listen
+  end
+
+  let(:group)         { Class.new { include MultipleMan::Listener } }
+  let(:group_contact) { Class.new { include MultipleMan::Listener } }
+
+  # BUGFIX:
+  it "correctly matches subscribers" do
+    channel = double(Bunny::Channel)
+    queue = double(Bunny::Queue, channel: channel).as_null_object
+
+    g  = group.listen_to 'Group'
+    gc = group_contact.listen_to 'GroupContact'
+
+    subject = described_class.new(subscribers:[g, gc], queue: queue, topic: 'some-topic')
+
+    expect(channel).to receive(:acknowledge)
+    expect(g).to_not receive(:create)
+    expect(gc).to receive(:create).with({"a" => 1, "b" => 2})
+
+    delivery_info = OpenStruct.new(routing_key: "multiple_man.seed.GroupContact")
+    payload = '{"a":1,"b":2}'
+    allow(queue).to receive(:subscribe).and_yield(delivery_info, double(:meta), payload)
+
+    subject.listen
+  end
+end

data/spec/consumers/transitional_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe MultipleMan::Consumers::Transitional do
+  let(:listener1) {
+    Class.new do
+      include MultipleMan::Listener
+
+      def initialize
+        self.listen_to = 'SomeClass'
+        self.operation = '#'
+      end
+    end
+  }
+
+  it 'wraps errors in ConsumerError' do
+    channel = double(Bunny::Channel)
+    queue = double(Bunny::Queue, channel: channel).as_null_object
+
+    delivery_info = OpenStruct.new(routing_key: "multiple_man.SomeClass.create")
+    payload = '{"a":1,"b":2}'
+    allow(queue).to receive(:subscribe).and_yield(delivery_info, double(:meta), payload)
+
+    subscriber = listener1.new
+    allow(subscriber).to receive(:create).and_raise('anything')
+
+    allow(channel).to receive(:nack)
+
+    expect(MultipleMan).to receive(:error).with(kind_of(MultipleMan::ConsumerError), kind_of(Hash))
+    subject = described_class.new(subscription:subscriber, queue: queue, topic: 'some-topic')
+    subject.listen
+  end
+
+end

data/spec/mixins/listener_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe MultipleMan::Subscriber do
+  let(:mock_class) do
+    Class.new do
+
+      include MultipleMan::Listener
+    end
+  end
+
+  describe "listen_to" do
+    it "should register itself" do
+      MultipleMan.configuration.should_receive(:register_listener).with(instance_of(mock_class))
+      mock_class.listen_to "Model"
+    end
+
+    it "should have a routing key for what it's listening to" do
+      listener = mock_class.listen_to "Model"
+      expect(listener.routing_key).to eq("multiple_man.Model.#")
+    end
+  end
+end

data/spec/{subscriber_spec.rb → mixins/subscriber_spec.rb}

@@ -7,7 +7,7 @@ describe MultipleMan::Subscriber do
 
   describe "subscribe" do
     it "should register itself" do
-      MultipleMan::Subscribers::Registry.should_receive(:register).with(instance_of(MultipleMan::Subscribers::ModelSubscriber))
+      expect(MultipleMan.configuration).to receive(:register_listener).with(instance_of(MultipleMan::Subscribers::ModelSubscriber))
       MockClass.subscribe fields: [:foo, :bar]
     end
   end

data/spec/subscribers/base_spec.rb

@@ -8,13 +8,6 @@ describe MultipleMan::Subscribers::Base do
     described_class.new(MockClass).routing_key.should =~ /\.MockClass\.\#$/
   end
 
-  specify "queue name should be the app name + class" do
-    MultipleMan.configure do |config|
-      config.app_name = "test"
-    end
-    described_class.new(MockClass).queue_name.should =~ /\.test\.MockClass$/
-  end
-
   specify "it should be alright to use a string for a class name" do
     described_class.new("MockClass").routing_key.should =~ /\.MockClass\.\#$/
   end

data/spec/subscribers/registry_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
-describe MultipleMan::Subscribers::Registry do 
-  describe "register" do 
+describe MultipleMan::Subscribers::Registry do
+  describe "register" do
     it "should add a subscriber" do
       subscription = double(:subscriber)
-      described_class.register(subscription)
-      described_class.subscriptions[0].should == subscription
+
+      subject.register(subscription)
+      subject.subscriptions[0].should == subscription
     end
   end
-end
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: multiple_man
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Ryan Brunner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-18 00:00:00.000000000 Z
+date: 2016-06-23 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !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: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -108,34 +136,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bunny
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.2'
-- !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'
 description: MultipleMan syncs changes to ActiveRecord models via AMQP
 email:
 - ryan@influitive.com
@@ -157,9 +157,10 @@ files:
 - lib/multiple_man/channel_maintenance/reaper.rb
 - lib/multiple_man/configuration.rb
 - lib/multiple_man/connection.rb
+- lib/multiple_man/consumers/general.rb
+- lib/multiple_man/consumers/seed.rb
+- lib/multiple_man/consumers/transitional.rb
 - lib/multiple_man/identity.rb
-- lib/multiple_man/listeners/listener.rb
-- lib/multiple_man/listeners/seeder_listener.rb
 - lib/multiple_man/mixins/listener.rb
 - lib/multiple_man/mixins/publisher.rb
 - lib/multiple_man/mixins/subscriber.rb
@@ -177,22 +178,24 @@ files:
 - multiple_man.gemspec
 - spec/attribute_extractor_spec.rb
 - spec/connection_spec.rb
+- spec/consumers/general_spec.rb
+- spec/consumers/seed_spec.rb
+- spec/consumers/transitional_spec.rb
 - spec/identity_spec.rb
 - spec/integration/ephermal_model_spec.rb
-- spec/listeners/listener_spec.rb
-- spec/listeners/seeder_listener_spec.rb
 - spec/logger_spec.rb
+- spec/mixins/listener_spec.rb
+- spec/mixins/publisher_spec.rb
+- spec/mixins/subscriber_spec.rb
 - spec/model_populator_spec.rb
 - spec/model_publisher_spec.rb
 - spec/payload_generator_spec.rb
-- spec/publisher_spec.rb
 - spec/routing_key_spec.rb
 - spec/spec_helper.rb
-- spec/subscriber_spec.rb
 - spec/subscribers/base_spec.rb
 - spec/subscribers/model_subscriber_spec.rb
 - spec/subscribers/registry_spec.rb
-homepage: ''
+homepage: http://github.com/influitive/multiple_man
 licenses:
 - MIT
 metadata: {}
@@ -204,7 +207,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -212,25 +215,27 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: MultipleMan syncs changes to ActiveRecord models via AMQP
 test_files:
 - spec/attribute_extractor_spec.rb
 - spec/connection_spec.rb
+- spec/consumers/general_spec.rb
+- spec/consumers/seed_spec.rb
+- spec/consumers/transitional_spec.rb
 - spec/identity_spec.rb
 - spec/integration/ephermal_model_spec.rb
-- spec/listeners/listener_spec.rb
-- spec/listeners/seeder_listener_spec.rb
 - spec/logger_spec.rb
+- spec/mixins/listener_spec.rb
+- spec/mixins/publisher_spec.rb
+- spec/mixins/subscriber_spec.rb
 - spec/model_populator_spec.rb
 - spec/model_publisher_spec.rb
 - spec/payload_generator_spec.rb
-- spec/publisher_spec.rb
 - spec/routing_key_spec.rb
 - spec/spec_helper.rb
-- spec/subscriber_spec.rb
 - spec/subscribers/base_spec.rb
 - spec/subscribers/model_subscriber_spec.rb
 - spec/subscribers/registry_spec.rb

data/lib/multiple_man/listeners/listener.rb

@@ -1,76 +0,0 @@
-require 'json'
-require 'active_support/core_ext/hash'
-
-module MultipleMan::Listeners
-  class Listener
-
-    class << self
-      def start
-        MultipleMan.logger.debug "Starting listeners."
-
-        MultipleMan::Subscribers::Registry.subscriptions.each do |subscription|
-          new(subscription).listen
-        end
-      end
-    end
-
-    delegate :queue_name, to: :subscription
-
-    def initialize(subscription)
-      self.subscription = subscription
-      self.init_connection
-    end
-
-    def init_connection
-      connection = Bunny.new(MultipleMan.configuration.connection)
-      connection.start
-      channel = connection.create_channel(nil, MultipleMan.configuration.worker_concurrency)
-      channel.prefetch(100)
-      self.connection = MultipleMan::Connection.new(channel)
-    end
-
-    attr_accessor :subscription, :connection
-
-    def listen
-
-      MultipleMan.logger.info "Listening for #{subscription.klass} with routing key #{routing_key}."
-      queue.bind(connection.topic, routing_key: routing_key).subscribe(ack: true) do |delivery_info, meta_data, payload|
-        process_message(delivery_info, payload)
-      end
-    end
-
-    def process_message(delivery_info, payload)
-      MultipleMan.logger.info "Processing message for #{delivery_info.routing_key}."
-      begin
-        payload = JSON.parse(payload).with_indifferent_access
-        subscription.send(operation(delivery_info, payload), payload)
-      rescue Exception => ex
-        handle_error(ex, delivery_info)
-      else
-        MultipleMan.logger.debug "   Successfully processed!"
-        queue.channel.acknowledge(delivery_info.delivery_tag, false)
-      end
-    end
-
-    def handle_error(ex, delivery_info)
-      MultipleMan.logger.error "   Error - #{ex.message}\n\n#{ex.backtrace}"
-      MultipleMan.error(ex, reraise: false)
-
-      # Requeue the message
-      queue.channel.nack(delivery_info.delivery_tag)
-    end
-
-    def operation(delivery_info, payload)
-      payload['operation'] || delivery_info.routing_key.split(".").last
-    end
-
-    def queue
-      connection.queue(queue_name, durable: true, auto_delete: false)
-    end
-
-    def routing_key
-      subscription.routing_key
-    end
-
-  end
-end

data/lib/multiple_man/listeners/seeder_listener.rb

@@ -1,16 +0,0 @@
-module MultipleMan::Listeners
-  class SeederListener < Listener
-    def routing_key
-      subscription.routing_key(:seed)
-    end
-
-    # seeds should only ever be a create
-    def operation(delivery_info, payload)
-      "create"
-    end
-
-    def queue
-      connection.queue(subscription.queue_name + ".seed", auto_delete: true)
-    end
-  end
-end

data/spec/listeners/listener_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe MultipleMan::Listeners::Listener do
-  class MockClass1; end
-  class MockClass2; end
-
-  before { MultipleMan::Connection.stub(:connection).and_return(double(Bunny).as_null_object)}
-
-  describe "start" do
-    it "should listen to each subscription" do
-      MultipleMan::Subscribers::Registry.stub(:subscriptions).and_return([
-        mock1 = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1),
-        mock2 = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass2)
-      ])
-
-      mock_listener = double(described_class)
-      described_class.should_receive(:new).twice.and_return(mock_listener)
-
-      # Would actually be two seperate objects in reality, this is for
-      # ease of stubbing.
-      mock_listener.should_receive(:listen).twice
-
-      described_class.start
-    end
-  end
-
-  describe "listen" do
-    let(:connection_stub) { double(MultipleMan::Connection, queue: queue_stub, topic: 'app') }
-    let(:queue_stub) { double(Bunny::Queue, bind: bind_stub) }
-    let(:bind_stub) { double(:bind, subscribe: nil)}
-
-    before { MultipleMan::Connection.stub(:new).and_return(connection_stub) }
-
-    it "should listen to the right topic, and for all updates to a model" do
-      listener = described_class.new(double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#", queue_name: "MockClass1"))
-      queue_stub.should_receive(:bind).with('app', routing_key: "MockClass1.#")
-      listener.listen
-    end
-  end
-
-  specify "process_message should send the correct data" do
-    connection_stub = double(MultipleMan::Connection).as_null_object
-    MultipleMan::Connection.stub(:new).and_return(connection_stub)
-    subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#").as_null_object
-    listener = described_class.new(subscriber)
-
-    connection_stub.should_receive(:acknowledge)
-    subscriber.should_receive(:create).with({"a" => 1, "b" => 2})
-    listener.process_message(OpenStruct.new(routing_key: "app.MockClass1.create"), '{"a":1,"b":2}')
-  end
-
-  specify "process_message should use the payload to determine the operation if it's available" do
-    connection_stub = double(MultipleMan::Connection).as_null_object
-    MultipleMan::Connection.stub(:new).and_return(connection_stub)
-    subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#").as_null_object
-    listener = described_class.new(subscriber)
-
-    connection_stub.should_receive(:acknowledge)
-    subscriber.should_receive(:create)
-    listener.process_message(OpenStruct.new(routing_key: "some random routing key"), '{"operation":"create","data":{"a":1,"b":2}}')
-  end
-
-  it "should nack on failure" do
-    connection_stub = double(MultipleMan::Connection).as_null_object
-    MultipleMan::Connection.stub(:new).and_return(connection_stub)
-    subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#").as_null_object
-    listener = described_class.new(subscriber)
-
-    connection_stub.should_receive(:nack)
-    MultipleMan.should_receive(:error)
-    subscriber.should_receive(:create).with({"a" => 1, "b" => 2}).and_raise("fail!")
-
-    listener.process_message(OpenStruct.new(routing_key: "app.MockClass1.create"), '{"a":1,"b":2}')
-  end
-end

data/spec/listeners/seeder_listener_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe MultipleMan::Listeners::SeederListener do
-  class MockClass1; end
-
-  before { MultipleMan::Connection.stub(:connection).and_return(double(Bunny).as_null_object)}
-  let(:connection_stub) { double(MultipleMan::Connection, queue: queue_stub, topic: 'app') }
-  let(:queue_stub) { double(Bunny::Queue, bind: bind_stub) }
-  let(:bind_stub) { double(:bind, subscribe: nil)}
-
-  before { MultipleMan::Connection.stub(:new).and_return(connection_stub) }
-
-  it 'listens to seed events' do
-    listener = described_class.new(double(MultipleMan::Subscribers::ModelSubscriber,
-                                   klass: MockClass1,
-                                   routing_key: "seed.MockClass1",
-                                   queue_name: "MockClass1"))
-
-    queue_stub.should_receive(:bind).with('app', routing_key: "seed.MockClass1")
-    listener.listen
-  end
-end