isimud 0.7.0 → 1.3.1

data/lib/isimud/event_observer.rb

@@ -4,6 +4,9 @@ require 'active_support/concern'
 require 'active_support/core_ext/module/attribute_accessors'
 
 # Module for attaching and listening to events
+#
+# Note: the following columns must be defined in your model:
+#   :exchange_routing_keys text
 module Isimud
   module EventObserver
     extend ::ActiveSupport::Concern
@@ -17,9 +20,19 @@ module Isimud
       Mutex.new
     end
 
+    included do
+      register_class
+      before_save :set_routing_keys
+      serialize :exchange_routing_keys, Array
+      after_commit :create_queue, on: :create, if: :enable_listener?, prepend: true
+      after_commit :update_queue, on: :update, prepend: true
+      after_commit :delete_queue, on: :destroy, prepend: true
+      include Isimud::ModelWatcher unless self.include?(Isimud::ModelWatcher)
+    end
+
     # Event handling hook. Override in your class.
     def handle_event(event)
-      Rails.logger.warn("Isimud::EventObserver#handle_event not implemented for #{event_queue_name}")
+      logger.warn("Isimud::EventObserver#handle_event not implemented for #{event_queue_name}")
     end
 
     # Routing keys that are bound to the event queue. Override in your subclass
@@ -32,16 +45,18 @@ module Isimud
       true
     end
 
-    # Exchange used for listening to events. Override in your subclass if you want to specify an alternative exchange for
-    # events. Otherwise
+    # Exchange used for listening to events. Override in your subclass if you want to specify an alternative exchange.
     def observed_exchange
       nil
     end
 
     # Create or attach to a queue on the specified exchange. When an event message that matches the observer's routing keys
     # is received, parse the event and call handle_event on same.
-    def observe_events(client, default_exchange)
-      client.bind(event_queue_name, observed_exchange || default_exchange, *routing_keys) do |message|
+    # Returns the consumer for the observer
+    def observe_events(client)
+      return unless enable_listener?
+      queue = client.kind_of?(Isimud::TestClient) ? create_queue(client) : client.find_queue(event_queue_name)
+      client.subscribe(queue) do |message|
         event = Event.parse(message)
         handle_event(event)
       end
@@ -51,6 +66,56 @@ module Isimud
       self.class.event_queue_name(id)
     end
 
+    def isimud_client
+      Isimud.client
+    end
+
+    # Activate the queues for an observer. This will create the observer queue and send an update message on the
+    # instance, which will trigger EventListener instances to set up consumers. This is useful for situations when
+    # an observer is to be made active without an update.
+    def activate_observer(client = isimud_client)
+      create_queue(client)
+      isimud_send_action_message(:update)
+    end
+
+    # Deactivate the queues for an observer. This will destroy the observer queue and send an update message on the
+    # instance, which will trigger EventListener instances to cancel consumers. Note that enable_listener? should
+    # resolve to false in order for the EventListener to cancel corresponding event consumers.
+    def deactivate_observer(client = isimud_client)
+      delete_queue(client)
+      isimud_send_action_message(:update)
+    end
+
+    private
+
+    def create_queue(client = isimud_client)
+      exchange = observed_exchange || Isimud.events_exchange
+      log "Isimud::EventObserver: creating queue #{event_queue_name} on exchange #{exchange} with bindings [#{exchange_routing_keys.join(',')}]"
+      client.create_queue(event_queue_name, exchange, routing_keys: exchange_routing_keys)
+    end
+
+    def update_queue
+      if enable_listener?
+        routing_key_changes = previous_changes[:exchange_routing_keys]
+        prev_keys    = routing_key_changes.try(:[], 0) || []
+        current_keys = routing_key_changes.try(:[], 1) || exchange_routing_keys
+        queue        = isimud_client.find_queue(event_queue_name)
+        exchange     = observed_exchange || Isimud.events_exchange
+        (prev_keys - current_keys).each { |key| queue.unbind(exchange, routing_key: key) }
+        (current_keys).each { |key| queue.bind(exchange, routing_key: key) }
+      else
+        isimud_client.delete_queue(event_queue_name)
+      end
+    end
+
+    def delete_queue
+      isimud_client.delete_queue(event_queue_name)
+    end
+
+    def set_routing_keys
+      self.exchange_routing_keys = routing_keys
+    end
+
     module ClassMethods
       # Method used to retrieve active observers. Override in your EventObserver class
       def find_active_observers
@@ -76,10 +141,5 @@ module Isimud
         end
       end
     end
-
-    included do
-      include Isimud::ModelWatcher unless self.include?(Isimud::ModelWatcher)
-      register_class
-    end
   end
 end

data/lib/isimud/model_watcher.rb

@@ -135,7 +135,7 @@ module Isimud
           id:        id,
           timestamp: (updated_at || Time.now).utc
       }
-      payload[:attributes] = isimud_attribute_data unless action == :destroy
+      payload[:attributes] = isimud_attribute_data
       routing_key          = isimud_model_watcher_routing_key(action)
       log "Isimud::ModelWatcher#publish: exchange #{isimud_model_watcher_exchange} routing_key #{routing_key} payload #{payload.inspect}"
       Isimud.client.publish(isimud_model_watcher_exchange, routing_key, payload.to_json)

data/lib/isimud/test_client.rb

@@ -1,42 +1,66 @@
 module Isimud
+
+  # Interface for a messaging client that is suitable for testing. No network connections are involved.
+  # Note that all message deliveries are handled in a synchronous manner. When a message is published to the
+  # client, each declared queue is examined and, if the message's routing key matches any of the patterns bound to the
+  # queue, the queue's block is called with the message. Any uncaught exceptions raised within a message processing
+  # block will cause any declared exception handlers to be run. However, the message will not be re-placed onto the
+  # queue should this occur.
   class TestClient < Isimud::Client
     attr_accessor :queues
 
     class Queue
       include Isimud::Logging
-      attr_reader :name, :routing_keys
+      attr_reader :name, :bindings
+      attr_accessor :proc
 
-      def initialize(name, listener)
+      def initialize(name, proc = Proc.new{ |_| } )
         @name         = name
-        @listener     = listener
-        @routing_keys = Set.new
+        @bindings     = Hash.new{ |hash, key| hash[key] = Set.new }
+        @proc         = proc
+      end
+
+      def bind(exchange, opts = {})
+        routing_key = opts[:routing_key]
+        log "TestClient: adding routing key #{routing_key} for exchange #{exchange} to queue #{name}"
+        @bindings[exchange] << routing_key
+      end
+
+      def cancel
+        @proc = nil
       end
 
-      def bind(exchange, options = {})
-        key = "\\A#{options[:routing_key]}\\Z"
-        log "TestClient: adding routing key #{key} to queue #{name}"
-        @routing_keys << Regexp.new(key.gsub(/\./, "\\.").gsub(/\*/, ".*"))
+      def delete(opts = {})
+        log "TestClient: delete queue #{name}"
+        @bindings.clear
+        @proc = nil
       end
 
-      def unbind(exchange)
-        @routing_keys.clear
+      def unbind(exchange, opts = {})
+        routing_key = opts[:routing_key]
+        log "TestClient: removing routing key #{routing_key} for exchange #{exchange} from queue #{name}"
+        @bindings[exchange].delete(routing_key)
       end
 
-      def has_matching_key?(route)
-        @routing_keys.any? { |k| route =~ k }
+      def make_regexp(key)
+        Regexp.new(key.gsub(/\./, "\\.").gsub(/\*/, '.*'))
+      end
+
+      def has_matching_key?(exchange, route)
+        @bindings[exchange].any? { |key| route =~ make_regexp(key) }
       end
 
       def deliver(data)
         begin
-          @listener.call(data)
+          @proc.try(:call, data)
         rescue => e
           log "TestClient: error delivering message: #{e.message}\n  #{e.backtrace.join("\n  ")}", :error
-          @listener.exception_handler.try(:call, e)
+          run_exception_handlers(e)
         end
       end
     end
 
-    def initialize(connection = nil, options = nil)
+    def initialize(connection = nil, options = {})
       self.queues = Hash.new
     end
 
@@ -59,29 +83,33 @@ module Isimud
       queues.delete(queue_name)
     end
 
-    def bind(queue_name, exchange_name, *keys, &method)
-      create_queue(queue_name, exchange_name, routing_keys: keys, &method)
+    def bind(queue_name, exchange_name, *keys, &block)
+      queue = create_queue(queue_name, exchange_name, routing_keys: keys)
+      subscribe(queue, &block)
     end
 
-    def rebind(queue_name, exchange_name, keys)
-      queue = queues[queue_name] || return
-      queue.unbind(exchange_name)
-      keys.each { |key| queue.bind(exchange_name, routing_key: key) }
+    def find_queue(queue_name, options = {})
+      queues[queue_name] ||= Queue.new(queue_name)
     end
 
-    def create_queue(queue_name, exchange_name, options = {}, &method)
+    def create_queue(queue_name, exchange_name, options = {})
       keys = options[:routing_keys] || []
       log "Isimud::TestClient: Binding queue #{queue_name} for keys #{keys.inspect}"
-      queue = queues[queue_name] ||= Queue.new(queue_name, method)
+      queue = find_queue(queue_name)
       keys.each do |k|
         queue.bind(exchange_name, routing_key: k)
       end
       queue
     end
 
-    def publish(exchange, routing_key, payload, _options = {})
-      log "Isimud::TestClient: Delivering message key: #{routing_key} payload: #{payload}"
-      call_queues = queues.values.select { |queue| queue.has_matching_key?(routing_key) }
+    def subscribe(queue, options = {}, &block)
+      queue.proc = block
+      queue
+    end
+
+    def publish(exchange, routing_key, payload)
+      log "Isimud::TestClient: Delivering message exchange: #{exchange} key: #{routing_key} payload: #{payload}"
+      call_queues = queues.values.select { |queue| queue.has_matching_key?(exchange, routing_key) }
       call_queues.each do |queue|
         log "Isimud::TestClient: Queue #{queue.name} matches routing key #{routing_key}"
         queue.deliver(payload)

data/lib/isimud/version.rb

@@ -1,3 +1,3 @@
 module Isimud
-  VERSION = '0.7.0'
+  VERSION = '1.3.1'
 end

data/lib/isimud.rb

@@ -37,7 +37,7 @@ module Isimud
     100
   end
   config_accessor :logger do
-    Rails.logger
+    logger
   end
   config_accessor :log_level do
     :debug

data/spec/internal/app/models/company.rb

@@ -13,6 +13,10 @@ class Company < ActiveRecord::Base
     active
   end
 
+  def observed_exchange
+    'isimud.test.events'
+  end
+
   def routing_keys
     ["*.User.create", "*.User.destroy"]
   end
@@ -20,15 +24,9 @@ class Company < ActiveRecord::Base
   def handle_event(event)
     user = User.find(event.parameters[:id])
     return unless user.company_id == id
-    case event.action.to_s
-      when 'create'
-        reload
-        update_attributes!(user_count: user_count + 1)
-      when 'destroy'
-        reload
-        update_attributes!(user_count: user_count - 1)
-      else
-        raise "unexpected action: #{event.action}"
-    end
+    raise "unexpected action: #{event.action}" unless ['create','destroy' ].include?(event.action.to_s)
+    self.user_count = User.where(company: self).count
+    self.total_points = user_count * points_per_user
+    save!
   end
 end

data/spec/internal/app/models/user.rb

@@ -5,7 +5,9 @@ class User < ActiveRecord::Base
 
   belongs_to :company
 
-  attr_accessor :events, :routing_keys
+  attr_accessor :events
+
+  serialize :keys, Array
 
   scope :active, -> {where('deactivated != ?', true)}
 
@@ -18,6 +20,14 @@ class User < ActiveRecord::Base
     'test'
   end
 
+  def routing_keys
+    keys
+  end
+
+  def enable_listener?
+    !deactivated
+  end
+
   watch_attributes :key, :login_count
 
   def key

data/spec/internal/db/schema.rb

@@ -5,6 +5,9 @@ ActiveRecord::Schema.define do
     t.string :url
     t.integer :user_count, default: 0, null: false
     t.boolean :active, default: true, null: false
+    t.string :exchange_routing_keys
+    t.integer :points_per_user, default: 1, null: false
+    t.integer :total_points, default: 0, null: false
     t.timestamps
   end
 
@@ -17,6 +20,8 @@ ActiveRecord::Schema.define do
     t.boolean :is_admin
     t.boolean :deactivated
     t.integer :login_count, default: 0, null: false
+    t.string :keys
+    t.string :exchange_routing_keys
     t.timestamps
   end
 end

data/spec/isimud/bunny_client_spec.rb

@@ -29,17 +29,29 @@ describe Isimud::BunnyClient do
 
 
     it 'creates a new queue' do
-      queue = client.bind('my_queue', @exchange_name, keys, &proc)
-      expect(queue).to be_a Bunny::Queue
-      expect(queue.name).to eq('my_queue')
+      consumer = client.bind('my_queue', @exchange_name, keys, &proc)
+      expect(consumer).to be_a Bunny::Consumer
+      expect(consumer.queue_name).to eq('my_queue')
+    end
+
+    context 'when a block is passed to the call' do
+      it 'binds specified routing keys and subscribes to the specified exchange' do
+        queue = double('queue', name: 'my_queue', bind: 'ok')
+        expect(client).to receive(:find_queue).with('my_queue', durable: true).and_return(queue)
+        expect(queue).to receive(:subscribe).with({manual_ack: true})
+        keys.each { |key| expect(queue).to receive(:bind).with(@exchange_name, routing_key: key, nowait: false).once }
+        client.bind('my_queue', @exchange_name, *keys, &proc)
+      end
     end
 
-    it 'binds specified routing keys and subscribes to the specified exchange' do
-      queue = double('queue', bind: 'ok')
-      expect(channel).to receive(:queue).and_return(queue)
-      expect(queue).to receive(:subscribe).with(manual_ack: true)
-      keys.each { |key| expect(queue).to receive(:bind).with(@exchange_name, routing_key: key, nowait: false).once }
-      client.bind('my_queue', @exchange_name, *keys, proc)
+    context 'when a block is NOT passed' do
+      it 'binds specified routing keys BUT does not subscribes to the specified exchange' do
+        queue = double('queue', name: 'my_queue', bind: 'ok')
+        expect(client).to receive(:find_queue).with('my_queue', durable: true).and_return(queue)
+        expect(queue).not_to receive(:subscribe).with(manual_ack: true)
+        keys.each { |key| expect(queue).to receive(:bind).with(@exchange_name, routing_key: key, nowait: false).once }
+        client.bind('my_queue', @exchange_name, *keys)
+      end
     end
 
     it 'calls block when a message is received' do

data/spec/isimud/client_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Isimud::Client do
+  let(:client) { Isimud::Client.new }
+
+  before do
+    @exceptions_1 = Array.new
+    @exceptions_2 = Array.new
+  end
+
+  describe 'exception handling' do
+    let!(:exception_handler_1) { Proc.new { |e| @exceptions_1 << e } }
+    let!(:exception_handler_2) { Proc.new { |e| @exceptions_2 << e } }
+    let!(:exception) { double(:exception) }
+
+    context 'with one handler added' do
+      before do
+        client.on_exception(&exception_handler_1)
+        client.run_exception_handlers(exception)
+      end
+
+      it 'calls the exception handler' do
+        expect(@exceptions_1).to include(exception)
+      end
+    end
+
+    context 'with two handlers added' do
+      before do
+        client.on_exception(&exception_handler_1)
+        client.on_exception(&exception_handler_2)
+        client.run_exception_handlers(exception)
+      end
+
+      it 'calls both exception handlers' do
+        expect(@exceptions_1).to include(exception)
+        expect(@exceptions_2).to include(exception)
+      end
+    end
+  end
+end

data/spec/isimud/event_listener_spec.rb

@@ -26,8 +26,8 @@ describe Isimud::EventListener do
     it 'applies defaults' do
       listener = Isimud::EventListener.new
       expect(listener.events_exchange).to eq('events')
-      expect(listener.models_exchange).to eq('models')
-      expect(listener.error_limit).to eq(10)
+      expect(listener.models_exchange).to eq('isimud.test.events')
+      expect(listener.error_limit).to eq(50)
       expect(listener.error_interval).to eq(1.hour)
       expect(listener.name).to eq('combustion-listener')
     end
@@ -52,35 +52,63 @@ describe Isimud::EventListener do
       end
     end
 
-    describe 'handling messages' do
-      it 'dispatches events to observer' do
-        expect {
-          User.create!(company: company, first_name: 'Larry', last_name: 'Page')
-          company.reload
-        }.to change(company, :user_count)
+    describe '#handle_observer_event' do
+      context 'handling observer destroy messages' do
+        it 'purges the queue for a destroy observer' do
+          expect(listener).to have_observer(company)
+          company.destroy
+          expect(listener).not_to have_observer(company)
+        end
       end
-    end
 
-    describe 'handling observer updates' do
-      it 'registers a new observer' do
-        another_company = Company.create!(name: 'Apple', active: true)
-        expect(listener.has_observer?(another_company)).to eql(true)
-      end
+      context 'handling new observer messages' do
+        it 'registers a new observer' do
+          another_company = Company.create!(name: 'Apple', active: true)
+          expect(listener).to have_observer(another_company)
+        end
 
-      it 're-registers an updated observer' do
-        expect(listener.has_observer?(company)).to eql(true)
-        company.update_attributes!(active: false)
-        expect(listener.has_observer?(company)).to eql(false)
+        it 'does not register an observer when listening is disabled' do
+          another_company = Company.create!(name: 'Apple', active: false)
+          expect(listener).not_to have_observer(another_company)
+        end
       end
 
-      it 'does not register an observer when listening is disabled'
+      context 'handling observer update messages' do
+        it 'reloads the observer and processes events accordingly' do
+          company.update_attributes!(points_per_user: 2)
+          expect(listener).to have_observer(company)
+          expect {
+            User.create!(company: company, first_name: 'Larry', last_name: 'Page')
+            company.reload
+          }.to change(company, :user_count).by(1)
+          expect(company.total_points).to eql(company.user_count * 2)
+        end
+      end
 
-      it 'purges the queue for a deleted observer'
+      context 'handling messages' do
+        it 'dispatches events to observer' do
+          expect {
+            User.create!(company: company, first_name: 'Larry', last_name: 'Page')
+            company.reload
+          }.to change(company, :user_count)
+        end
+      end
     end
 
     describe 'handling errors' do
-      it 'counts errors'
-      it 'triggers a shutdown if errors exceed limit'
+      before do
+        @some_company = Company.create!(name: 'Apple', active: true)
+      end
+      xit 'counts errors' do
+        # Verify that the listener's error count starts from zero
+        expect(listener.error_count).to eql 0
+
+        # Verify that the listener's error count increased to one with the first new exception
+        # Verify that the listener's error count increased to two with the second new exception
+      end
+      xit 'triggers a shutdown if errors exceed limit' do
+        # Verify that the listener shuts down / stops listening when the threshold is exceeded
+      end
     end
   end
 end

data/spec/isimud/event_observer_spec.rb

@@ -1,32 +1,123 @@
+require 'spec_helper'
+
 describe Isimud::EventObserver do
-  let(:client) { Isimud.client }
+  before do
+    Isimud.model_watcher_exchange = 'isimud.test.events'
+    @client                       = Isimud.client
+  end
+
+  #let(:client) { Isimud.client }
   let(:exchange_name) { 'events' }
-  let(:user) { User.create!(first_name:         'Geo',
-                            last_name:          'Feil',
-                            encrypted_password: "itsasecret",
-                            email:              'george.feil@keas.com') }
-  let!(:eventful) { Company.create!(name: 'Keas', description: 'Health Engagement Platform', url: 'http://keas.com') }
+  let(:company) { Company.create!(name: 'Keas', description: 'Health Engagement Platform', url: 'http://keas.com') }
+  let(:keys) { %w(a.b.c d.*.f) }
+  let(:user_params) { {first_name:         'Geo',
+                       last_name:          'Feil',
+                       encrypted_password: "itsasecret",
+                       keys:               keys,
+                       email:              'george.feil@keas.com'} }
   let(:time) { 1.hour.ago }
   let(:params) { {'a' => 'foo', 'b' => 123} }
-  let!(:evented) { User.create(routing_keys:       ['model.Company.*.create', 'model.Event.*.report']) }
-  let(:event) { Isimud::Event.new(user, eventful, action: :create, occurred_at: time, parameters: params) }
-
 
   it 'registers class in observed_models' do
     expect(Isimud::EventObserver.observed_models).to include(User)
   end
 
-  describe '#observe_events' do
-    before(:each) do
-      evented.observe_events(client, exchange_name)
+  describe 'when created' do
+    before do
+      @queue    = double(:queue)
+      @exchange = Isimud.events_exchange
+    end
+
+    it 'creates observer queue' do
+      expect(@client).to receive(:find_queue).and_return(@queue)
+      keys.each { |key| expect(@queue).to receive(:bind).with(@exchange, routing_key: key) }
+      User.create(user_params)
+    end
+
+    it 'does not create observer queue when listener is not enabled' do
+      expect(@client).not_to receive(:create_queue)
+      User.create(user_params.merge(deactivated: true))
+    end
+
+    it 'sets exchange_routing_keys' do
+      user = User.create(user_params)
+      expect(user.exchange_routing_keys).to eql(user.routing_keys)
+    end
+  end
+
+  describe 'when modified' do
+    before do
+      @exchange = Isimud.events_exchange
+    end
+
+    context 'for an instance that is made active on update' do
+      before do
+        @user  = User.create(user_params.merge(deactivated: true))
+        @queue = @client.find_queue(@user.event_queue_name)
+      end
+
+      it 'creates the queue' do
+        expect(@client).to receive(:find_queue).with(@user.event_queue_name).and_call_original
+        @user.update_attributes(deactivated: false)
+      end
+
+      it 'binds the routing keys' do
+        @user.exchange_routing_keys.each do |k|
+          expect(@queue).to receive(:bind).with(@exchange, routing_key: k).and_call_original
+        end
+        @user.update_attributes(deactivated: false)
+      end
+    end
+
+    context 'for an already active instance' do
+      before do
+        @user  = User.create(user_params)
+        @queue = @client.find_queue(@user.event_queue_name)
+      end
+
+      it 'binds new keys' do
+        @user.exchange_routing_keys.each do |k|
+          expect(@queue).to receive(:bind).with(@exchange, routing_key: k).and_call_original
+        end
+        expect(@queue).to receive(:bind).with(@exchange, routing_key: 'some_other_value').and_call_original
+        @user.transaction do
+          @user.keys << 'some_other_value'
+          @user.save!
+        end
+      end
+
+      it 'removes old keys' do
+        expect(@queue).to receive(:unbind).with(@exchange, routing_key: 'a.b.c')
+        expect(@queue).not_to receive(:unbind).with(@exchange, routing_key: 'd.*.f')
+        @user.keys.delete('a.b.c')
+        @user.save!
+      end
     end
+  end
 
-    it 'binds routing keys to the named queue in the exchange' do
-      queue = client.queues["combustion.user.#{evented.id}"]
-      expect(queue).to have_matching_key("model.Company.123.create")
+  describe 'when destroyed' do
+    before do
+      @exchange = Isimud.events_exchange
+      @user     = User.create(user_params)
     end
 
-    it 'parses messages and dispatches to the handle_event method'
+    it 'removes the queue' do
+      expect(@client).to receive(:delete_queue).with("combustion.user.#{@user.id}")
+      @user.destroy
+    end
+  end
+
+  describe '#observe_events' do
+    before do
+      @user = User.create(user_params.merge(keys: ['model.Company.*.create']))
+      @user.observe_events(@client)
+    end
+
+    it 'parses messages and dispatches to the handle_event method' do
+      event = Isimud::Event.new(@user, company, exchange: @exchange, action: :create, occurred_at: time, parameters: params)
+      event.publish
+      expect(@user.events).not_to be_empty
+    end
   end
 
 end