multiple_man 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b69cb35c812dfa3b4814a81a6cdca0aaa495afc
-  data.tar.gz: ea18e5f3984487b6f7278febc96269612b7038b3
+  metadata.gz: 82202196c1530933abce0b808052135a271a9b6b
+  data.tar.gz: 59a804a32f6dcf3810976b983419e6fe3638aaff
 SHA512:
-  metadata.gz: 8c1b1b58da01c48d575aea0ce54eac633e9996fed67a3f8860396596c721f122cdb92175823b2bb528d403fb7fb05e7748c55c14f1ead348fd32e2f6ce79a19c
-  data.tar.gz: 93b9be1ffd2e8a8427c35791ad87c76ef4e3a3b4f401cf8150b4a048797af2e0a8c4758826c8aa24b1d3fe120c0c34cc12d3e2b5e04b4ed019fdae1f23e3b3f3
+  metadata.gz: a865251110618cc5dfbde0a91eb4b3af2b291333f69e794fbac5bf0f801f64c4bcbafd7d2317cda920f12d60c3dde69125e64aeb52a28a74daf16146a9a6a93e
+  data.tar.gz: e507296ff7fb57a709331f23b13a208d5d1a3139f46feb42826033471092724334818e559ac9803e4a21a3165f0a779158ec9923b8184d93f32d2f36108e0c7f

data/README.md

@@ -49,27 +49,79 @@ calling MultipleMan.configure like so:
       # Rails application name if you're using rails
       config.app_name = "MyApp"
 
+      # Specify what should happen when MultipleMan
+      # encounters an exception. 
+      config.on_error do |exception|
+        ErrorLogger.log(exception)
+      end 
+
       # Where you want to log errors to. Should be an instance of Logger
       # Defaults to the Rails logger (for Rails) or STDOUT otherwise.
       config.logger = Logger.new(STDOUT)
     end
 
+### A note on errors
+
+It's extremely important to specify the `on_error` setting
+in your configuration. ActiveRecord by default swallows
+exceptions encountered in an `after_commit` block, meaning
+that without handling these errors through the configuration,
+they will be silently ignored.
+
 ### Publishing models
 
-To publish a model, include the following in your model definition:
+#### Directly from the model
+
+Include this in your model definition:
 
     class Widget < ActiveRecord::Base
       include MultipleMan::Publisher
-      publish fields: [:id, :name, :type], identifier: :code
+      publish fields: [:id, :name, :type]
     end
 
+#### In an initializer / config file
+
+Add this to an initializer (i.e. `multiple_man.rb`):
+
+```
+MultipleMan.publish Widget, fields: [:id, :name, :type]
+```
+
 You can use the following options when publishing:
 
 - `fields` - An array of all the fields you want to send to the message queue. These
   can be either ActiveRecord attributes or methods on your model.
-- `identifier` - Either a symbol or a proc used by MultipleMan to identify your model.
-  `id` is used by default and is generally fine, unless you're working in a multi-tenant
-  environment where ids may be shared between two different models of the same class.
+- `with` - As an alternative to `fields`, you can specify
+  an ActiveRecord serializer (or anything that takes your
+  record in the constructor and has an `as_json` method) to
+  serialize models instead.
+- `as` - If you want the name of the model from the 
+  perspective of MultipleMan to be different than the model
+  name in Rails, specify `as` with the name you want to use. 
+  Useful for STI.
+- `identify_by` - Specify an array of fields that MultipleMan
+  should use to identify your record on the subscriber end.
+  `id` is used by default and is generally fine, unless you're working in a multi-tenant environment where ids may 
+  be shared between two different models of the same class.
+- (DEPRECATED) `identifier` - Either a symbol or a proc used by MultipleMan to identify your model.
+  
+### Publishing
+
+By default, MultipleMan will publish all of your models whenever you save a model (in an `after_commit` hook). If you need to manually publish models, you can do so with the `multiple_man_publish` method, which acts like a scope on your models, like so:
+
+```
+# Publish all widgets to MultipleMan
+Widget.multiple_man_publish  
+
+# Publish a subset of widgets to MultipleMan
+Widget.where(published: true).multiple_man_publish
+
+# Publish an individual widget
+Widget.first.multiple_man_publish
+```
+
+If you're publishing multiple models, it's best to use the 
+version of multiple_man_publish that operates on a collection. By calling the individual version, a channel is opened and closed for each model, which can impact the thoroughput of MultipleMan.
 
 ### Subscribing to models
 
@@ -77,20 +129,45 @@ You can subscribe to a model as follows (in a seperate consumer app):
 
     class Widget < ActiveRecord::Base
       include MultipleMan::Subscriber
+      subscribe fields: [:id, :name]
     end
 
-Currently, there's a few assumptions made of subscriber models:
+You can pass the following options to the `subscribe` call:
+
+- `fields` - Specify which fields you want to receive from
+  the publisher. If this is blank, then any field that is published where your subscriber model has a corresponding `field=` method will be subscribed to.
+
+By default, MultipleMan will attempt to identify which model on the subscriber matches a model sent by the publisher by id. However, if your publisher specifies an `identify_by` array, MultipleMan will locate your record by finding a record where all of those fields match.
 
-- They need to have all of the fields that are published.
-- They need an additional field, called `multiple_man_identifier`, that is the
-  same type as what's passed from the publisher side (just an integer if you're using
-  id)
+### DEPRECATED: multiple_man_identifier
+
+If your publisher specifies an `identifier` option, you *must* include a column on the subscriber side called `multiple_man_identifier`. MultipleMan will attempt to locate models on the subscriber side by this column.
+
+## Listening for subscriptions
 
 Once you've set up your subscribers, you'll need to run a background worker to manage
 the subscription process. Just run the following:
 
     rake multiple_man:worker
 
+## Seeding
+
+One common problem when using MultipleMan on an existing project is that there's already a lot of data that you want to process using your listeners. MultipleMan provides a mechanism called "seeding" to accomplish this. 
+
+1. On the subscriber side, start listening for seed requests with the following rake task: 
+
+```
+rake multiple_man:seed
+```
+
+2. On the publisher side, indicate that your models should be seeded with the following command:
+
+```
+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 
+
 ## Contributing
 
 1. Fork it

data/lib/multiple_man.rb

@@ -17,6 +17,7 @@ module MultipleMan
   require 'multiple_man/seeder_listener'
   require 'multiple_man/model_populator'
   require 'multiple_man/identity'
+  require 'multiple_man/publish'
 
   def self.logger
     configuration.logger

data/lib/multiple_man/identity.rb

@@ -1,18 +1,49 @@
 module MultipleMan
   class Identity
-    def initialize(record, identifier = :id)
+    def self.build(record, options)
+      if options[:identifier].present?
+        SingleField.new(record, options[:identifier])
+      else
+        MultipleField.new(record, options[:identify_by])
+      end
+    end
+
+    def initialize(record)
       self.record = record
-      self.identifier = identifier || :id
     end
 
-    def value
-      if identifier.class == Proc
-        identifier.call(record).to_s
-      else
-        record.send(identifier).to_s
+    attr_accessor :record
+
+    class MultipleField < Identity
+      def initialize(record, identify_by)
+        self.identify_by = identify_by ? [*identify_by] : [:id]
+        super(record)
+      end
+      def value
+        Hash[identify_by.map do |field|
+          [field, record.send(field)]
+        end]
       end
+
+      attr_accessor :identify_by
     end
 
-    attr_accessor :record, :identifier
+    class SingleField < Identity
+      def initialize(record, identifier = :id)
+        MultipleMan.logger.warn("Using :identifier in publish is deprecated, please switch to identify_by.")
+        self.identifier = identifier || :id
+        super(record)
+      end
+
+      def value
+        if identifier.class == Proc
+          identifier.call(record).to_s
+        else
+          record.send(identifier).to_s
+        end
+      end
+
+      attr_accessor :identifier
+    end
   end
 end

data/lib/multiple_man/listener.rb

@@ -18,6 +18,8 @@ module MultipleMan
       attr_accessor :connection
     end
 
+    delegate :queue_name, to: :subscription
+
     def initialize(subscription)
       self.subscription = subscription
     end
@@ -26,7 +28,7 @@ module MultipleMan
 
     def listen
       MultipleMan.logger.info "Listening for #{subscription.klass} with routing key #{routing_key}."
-      queue.bind(connection.topic, routing_key: routing_key).subscribe do |delivery_info, meta_data, payload|
+      queue.bind(connection.topic, routing_key: routing_key).subscribe(ack: true) do |delivery_info, meta_data, payload|
         process_message(delivery_info, payload)
       end
     end
@@ -40,6 +42,7 @@ module MultipleMan
         MultipleMan.error(ex)
       else
         MultipleMan.logger.debug "   Successfully processed!"
+        queue.channel.acknowledge(delivery_info.delivery_tag, false)
       end
     end
 
@@ -48,7 +51,7 @@ module MultipleMan
     end
 
     def queue
-      connection.queue(subscription.queue_name, durable: true, auto_delete: false)
+      connection.queue(queue_name, durable: true, auto_delete: false)
     end
 
     def routing_key

data/lib/multiple_man/model_publisher.rb

@@ -45,7 +45,7 @@ module MultipleMan
 
     def record_data(record)
       {
-        id: Identity.new(record, identifier).value,
+        id: Identity.build(record, options).value,
         data: serializer(record).as_json
       }.to_json
     end

data/lib/multiple_man/publish.rb

@@ -0,0 +1,6 @@
+module MultipleMan
+  def self.publish(klass, options)
+    klass.send(:include, MultipleMan::Publisher)
+    klass.publish options
+  end
+end

data/lib/multiple_man/seeder_listener.rb

@@ -8,5 +8,9 @@ module MultipleMan
     def operation(delivery_info)
       "create"
     end
+
+    def queue
+      connection.queue(subscription.queue_name + ".seed", auto_delete: true)
+    end
   end
 end

data/lib/multiple_man/subscribers/model_subscriber.rb

@@ -25,7 +25,11 @@ module MultipleMan::Subscribers
   private
 
     def find_model(id)
-      klass.find_or_initialize_by(multiple_man_identifier: id)
+      klass.where(find_conditions(id)).first || klass.new
+    end
+
+    def find_conditions(id)
+      id.kind_of?(Hash) ? id : {multiple_man_identifier: id}
     end
 
     attr_writer :klass

data/lib/multiple_man/version.rb

@@ -1,3 +1,3 @@
 module MultipleMan
-  VERSION = "0.4.0"
+  VERSION = "0.5.1"
 end

data/spec/connection_spec.rb

@@ -9,7 +9,7 @@ describe MultipleMan::Connection do
     it "should open a connection and a channel" do
       mock_bunny.should_receive(:start)
       Bunny.should_receive(:new).and_return(mock_bunny)
-      mock_bunny.should_receive(:create_channel)
+      mock_bunny.should_receive(:create_channel).any_number_of_times
 
       described_class.connect
     end

data/spec/identity_spec.rb

@@ -2,18 +2,42 @@ require 'spec_helper'
 
 describe MultipleMan::Identity do 
   let(:record) { double(:model, id: 1, foo: 'foo', bar: 'bar' )}
-  subject { described_class.new(record, identifier).value }
 
-  context "proc identifier" do
-    let(:identifier) { lambda{|record| "#{record.foo}-#{record.id}" } }
-    it { should == "foo-1" }
-  end
-  context "symbol identifier" do
-    let(:identifier) { :foo }
-    it { should == "foo" }
-  end
-  context "no identifier" do
+  context "with identifier" do
+    subject { described_class.build(record, identifier: identifier).value }
     let(:identifier) { :id }
-    it { should == "1" }
+
+    context "proc identifier" do
+      let(:identifier) { lambda{|record| "#{record.foo}-#{record.id}" } }
+      it { should == "foo-1" }
+    end
+    context "symbol identifier" do
+      let(:identifier) { :foo }
+      it { should == "foo" }
+    end
+    context "id identifier" do
+      let(:identifier) { :id }
+      it { should == "1" }
+    end
+    it "should log a deprecation notice" do
+      MultipleMan.logger.should_receive(:warn)
+      subject
+    end
+  end
+
+  context "with identify_by" do
+    subject { described_class.build(record, identify_by: identify_by).value }
+    context "single field" do
+      let(:identify_by) { :foo }
+      it { should == { foo: 'foo'} }
+    end
+    context "no identify_by" do
+      let(:identify_by) { nil }
+      it { should == { id: 1 } }
+    end
+    context "multiple_fields" do
+      let(:identify_by) { [:foo, :bar] }
+      it { should == { foo: 'foo', bar: 'bar' } }
+    end
   end
 end

data/spec/listener_spec.rb

@@ -37,8 +37,12 @@ describe MultipleMan::Listener do
   end
 
   specify "process_message should send the correct data" do
-    subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#")
+    connection_stub = double(MultipleMan::Connection).as_null_object
+    MultipleMan::Listener.stub(:connection).and_return(connection_stub)
+    subscriber = double(MultipleMan::Subscribers::ModelSubscriber, klass: MockClass1, routing_key: "MockClass1.#").as_null_object
     listener = MultipleMan::Listener.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

data/spec/model_publisher_spec.rb

@@ -30,7 +30,7 @@ describe MultipleMan::ModelPublisher do
   describe "publish" do
     it "should send the jsonified version of the model to the correct routing key" do
       MultipleMan::AttributeExtractor.any_instance.should_receive(:as_json).and_return({foo: "bar"})
-      topic_stub.should_receive(:publish).with('{"id":"10","data":{"foo":"bar"}}', routing_key: "app.MockObject.create")
+      topic_stub.should_receive(:publish).with('{"id":{"id":10},"data":{"foo":"bar"}}', routing_key: "app.MockObject.create")
       described_class.new(fields: [:foo]).publish(MockObject.new)
     end
 
@@ -55,7 +55,7 @@ describe MultipleMan::ModelPublisher do
 
     it "should get its data from the serializer" do
       obj = MockObject.new
-      topic_stub.should_receive(:publish).with('{"id":"10","data":{"a":"yes"}}', routing_key: "app.MockObject.create")
+      topic_stub.should_receive(:publish).with('{"id":{"id":10},"data":{"a":"yes"}}', routing_key: "app.MockObject.create")
       subject.publish(obj)
     end
   end

data/spec/subscribers/model_subscriber_spec.rb

@@ -8,7 +8,7 @@ describe MultipleMan::Subscribers::ModelSubscriber do
   describe "create" do
     it "should create a new model" do
       mock_object = MockClass.new
-      MockClass.stub(:find_or_initialize_by).with(multiple_man_identifier: 5).and_return(mock_object)
+      MockClass.stub(:where).and_return([mock_object])
       mock_populator = double(MultipleMan::ModelPopulator)
       MultipleMan::ModelPopulator.should_receive(:new).and_return(mock_populator)
       mock_populator.should_receive(:populate).with({a: 1, b: 2})
@@ -18,10 +18,23 @@ describe MultipleMan::Subscribers::ModelSubscriber do
     end
   end
 
+  describe "find_model" do
+    it "should find by multiple_man_identifier for a single field" do
+      mock_object = double(MockClass).as_null_object
+      MockClass.should_receive(:where).with(multiple_man_identifier: 5).and_return([mock_object])
+      described_class.new(MockClass, {}).create({id: 5, data:{a: 1, b: 2}})
+    end
+    it "should find by the hash for multiple fields" do
+      mock_object = double(MockClass).as_null_object
+      MockClass.should_receive(:where).with(foo: 'bar').and_return([mock_object])
+      described_class.new(MockClass, {}).create({id: {foo: 'bar'}, data:{a: 1, b: 2}})
+    end
+  end
+
   describe "destroy" do
     it "should destroy the model" do
       mock_object = MockClass.new
-      MockClass.should_receive(:find_or_initialize_by).and_return(mock_object)
+      MockClass.should_receive(:where).and_return([mock_object])
       mock_object.should_receive(:destroy!)
 
       described_class.new(MockClass, {}).destroy({id: 1})

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multiple_man
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Ryan Brunner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-21 00:00:00.000000000 Z
+date: 2014-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -117,6 +117,7 @@ files:
 - lib/multiple_man/mixins/subscriber.rb
 - lib/multiple_man/model_populator.rb
 - lib/multiple_man/model_publisher.rb
+- lib/multiple_man/publish.rb
 - lib/multiple_man/railtie.rb
 - lib/multiple_man/routing_key.rb
 - lib/multiple_man/seeder_listener.rb