isimud 0.5.2

data/lib/isimud/tasks.rb

@@ -0,0 +1,20 @@
+namespace :isimud do
+  desc 'Synchronize specified models (default is all synchronized models)'
+  task :sync => :environment do
+    require 'chronic_duration'
+    require 'isimud'
+
+    models = $*.drop(1)
+    models = Isimud::ModelWatcher.watched_models if models.empty?
+
+    start_time = Time.now
+    puts "Synchronizing models: #{models.join(', ')}"
+    models.each do |model|
+      klass = model.constantize
+      puts "\n#{klass.to_s}"
+      klass.synchronize(output: $stdout)
+    end
+    end_time = Time.now
+    puts "Finished synchronization in #{ChronicDuration.output(end_time - start_time)}."
+  end
+end

data/lib/isimud/test_client.rb

@@ -0,0 +1,89 @@
+module Isimud
+  class TestClient < Isimud::Client
+    attr_accessor :queues
+
+    class Queue
+      include Isimud::Logging
+      attr_reader :name, :routing_keys
+
+      def initialize(name, listener)
+        @name         = name
+        @listener     = listener
+        @routing_keys = Set.new
+      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(/\*/, ".*"))
+      end
+
+      def has_matching_key?(route)
+        @routing_keys.any? { |k| route =~ k }
+      end
+
+      def deliver(data)
+        begin
+          @listener.call(data)
+        rescue => e
+          log "TestClient: error delivering message: #{e.message}\n  #{e.backtrace.join("\n  ")}", :error
+          @listener.exception_handler.try(:call, e)
+        end
+      end
+    end
+
+    def initialize(connection = nil, options = nil)
+      self.queues = Hash.new
+    end
+
+    def connect
+      self
+    end
+
+    def channel
+      self
+    end
+
+    def connected?
+      true
+    end
+
+    def close
+    end
+
+    def delete_queue(queue_name)
+      queues.delete(queue_name)
+    end
+
+    def bind(queue_name, exchange_name, *keys, &method)
+      create_queue(queue_name, exchange_name, routing_keys: keys, &method)
+    end
+
+    def create_queue(queue_name, exchange_name, options = {}, &method)
+      keys = options[:routing_keys] || []
+      log "Isimud::TestClient: Binding queue #{queue_name} for keys #{keys.inspect}"
+      queue = queues[queue_name] ||= Queue.new(queue_name, method)
+      keys.each do |k|
+        queue.bind(exchange_name, routing_key: k)
+      end
+      queue
+    end
+
+    def publish(exchange, routing_key, payload)
+      log "Isimud::TestClient: Delivering message key: #{routing_key} payload: #{payload}"
+      call_queues = queues.values.select { |queue| queue.has_matching_key?(routing_key) }
+      call_queues.each do |queue|
+        log "Isimud::TestClient: Queue #{queue.name} matches routing key #{routing_key}"
+        queue.deliver(payload)
+      end
+    end
+
+    def reset
+      self.queues.clear
+    end
+
+    def reconnect
+      self
+    end
+  end
+end

data/lib/isimud/version.rb

@@ -0,0 +1,3 @@
+module Isimud
+  VERSION = '0.5.2'
+end

data/lib/rails/generators/isimud/config_generator.rb

@@ -0,0 +1,12 @@
+module Isimud
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+
+      desc 'Creates an Isimud gem configuration file at config/isimud.yml'
+      def create_config_file
+        template 'isimud.yml', File.join(Rails.root, 'config', 'isimud.yml')
+      end
+    end
+  end
+end

data/lib/rails/generators/isimud/initializer_generator.rb

@@ -0,0 +1,12 @@
+module Isimud
+  module Generators
+    class InitializerGenerator < Rails::Generators::Base
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+
+      desc 'Creates an Isimud gem initializer file at config/isimud.yml'
+      def create_initializer_file
+        template 'initializer.rb', File.join(Rails.root, 'config', 'initializers', 'isimud.rb')
+      end
+    end
+  end
+end

data/lib/rails/generators/isimud/templates/initializer.rb

@@ -0,0 +1,17 @@
+require 'isimud'
+
+configs = begin
+  path = Rails.root.join('config', 'isimud.yml')
+  YAML::load(ERB.new(IO.read(path)).result)
+rescue
+  Rails.logger.warn("Isimud: configuration could not be loaded at: #{path}")
+  {}
+end
+
+Isimud.model_watcher_schema = Rails.configuration.database_configuration[Rails.env]['database']
+
+config = configs[Rails.env]
+
+config.each do |key, val|
+  Isimud.send("#{key}=".to_sym, val)
+end

data/lib/rails/generators/isimud/templates/isimud.yml

@@ -0,0 +1,20 @@
+# Isimud configuration
+# Server may be specified as a URL string, or a hash of connection options accepted by Bunny::Session
+defaults: &defaults
+  client_type: :bunny
+  server: 'amqp://guest:guest@localhost'
+
+development:
+  server: 'amqp://guest:guest@localhost'
+
+test:
+  client_type: :test
+
+develop:
+  <<: *defaults
+
+staging:
+  <<: *defaults
+
+production:
+  <<: *defaults

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

@@ -0,0 +1,2 @@
+class Admin < User
+end

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

@@ -0,0 +1,34 @@
+require_relative "../../../../lib/isimud"
+
+class Company < ActiveRecord::Base
+  include Isimud::EventObserver
+
+  has_many :users
+
+  def self.find_active_observers
+    where(active: true).all
+  end
+
+  def enable_listener?
+    active
+  end
+
+  def routing_keys
+    ["*.User.create", "*.User.destroy"]
+  end
+
+  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
+  end
+end

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

@@ -0,0 +1,27 @@
+require_relative "../../../../lib/isimud"
+
+class User < ActiveRecord::Base
+  include Isimud::EventObserver
+
+  belongs_to :company
+
+  attr_accessor :events, :routing_keys
+
+  scope :active, -> {where('deactivated != ?', true)}
+
+  def handle_event(event)
+    self.events ||= Array.new
+    self.events << event
+  end
+
+  def queue_prefix
+    'test'
+  end
+
+  watch_attributes :key, :login_count
+
+  def key
+    Base64.encode64("user-#{id}")
+  end
+
+end

data/spec/internal/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter:  sqlite3
+  database: db/combustion_test.sqlite

data/spec/internal/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  #
+end

data/spec/internal/db/schema.rb

@@ -0,0 +1,22 @@
+ActiveRecord::Schema.define do
+  create_table(:companies, :force => true) do |t|
+    t.string :name
+    t.string :description
+    t.string :url
+    t.integer :user_count, default: 0, null: false
+    t.boolean :active, default: true, null: false
+    t.timestamps
+  end
+
+  create_table(:users, :force => true) do |t|
+    t.references :company
+    t.string :first_name
+    t.string :last_name
+    t.string :encrypted_password
+    t.string :email
+    t.boolean :is_admin
+    t.boolean :deactivated
+    t.integer :login_count, default: 0, null: false
+    t.timestamps
+  end
+end

data/spec/internal/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/spec/isimud/bunny_client_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Isimud::BunnyClient do
+  before(:each) do
+    @exchange_name = 'isimud_test'
+    @url = 'amqp://guest:guest@localhost'
+  end
+
+  let!(:client) { Isimud::BunnyClient.new(@url) }
+  let!(:connection) { client.connection }
+
+  describe '#initialize' do
+    it 'sets the broker URL' do
+      expect(client.url).to eq(@url)
+    end
+  end
+
+  describe '#bind' do
+    let(:channel) { client.channel }
+    let(:proc) { Proc.new { puts('hello') } }
+    let(:keys) { %w(foo.bar baz.*) }
+    before do
+      Isimud.logger = Logger.new(STDOUT)
+    end
+
+    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')
+    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)
+    end
+
+    it 'calls block when a message is received' do
+      @block_called = Array.new
+      queue_name    = 'test queue'
+      client.bind("#{queue_name}", @exchange_name, 'my.test.key') do |payload|
+        @block_called << payload
+      end
+      client.publish(@exchange_name, 'my.test.key', "Hi there")
+      expect(@block_called).to eq ['Hi there']
+    end
+  end
+
+  describe '#connection' do
+    it 'returns a Bunny session' do
+      expect(connection).to be_a Bunny::Session
+    end
+
+    it 'sets and reuses the connection' do
+      connection = client.connection
+      expect(client.connection).to eql(connection)
+    end
+
+    it 'opens a connection to the broker' do
+      expect(connection).to be_open
+    end
+
+  end
+
+  describe '#channel' do
+    it 'returns a channel' do
+      expect(client.channel).to be_a Bunny::Channel
+    end
+
+    it 'reuses an open channel' do
+      expect(client.channel).to eql(client.channel)
+    end
+
+    it 'creates a new channel if the previous one is closed' do
+      closed_channel = client.channel.tap(&:close)
+      expect(client.channel).not_to eql(closed_channel)
+    end
+
+    it 'enables confirmations' do
+      channel = client.channel
+      expect(channel.next_publish_seq_no).to eq(1)
+    end
+
+    it 'keeps the channel thread local' do
+      channel = client.channel
+      t       = Thread.new do
+        expect(client.channel).not_to eql(channel)
+      end
+      t.join
+    end
+  end
+
+  describe '#connected?' do
+    it 'is true for an open session' do
+      expect(client).to be_connected
+    end
+
+    it 'is false for a closed session' do
+      client.close
+      expect(client).not_to be_connected
+    end
+  end
+
+  describe '#close' do
+    it 'closes the session' do
+      connection = client.connection
+      client.close
+      expect(connection).not_to be_open
+    end
+  end
+
+  describe '#publish' do
+    let(:channel) { client.channel }
+    it 'sends the data with the appropriate routing key to the exchange' do
+      payload = {a: '123', b: 'this is b'}
+      topic   = double(:topic)
+      expect(channel).to receive(:topic).with(@exchange_name, durable: true).and_return(topic)
+      expect(topic).to receive(:publish).with(payload, routing_key: 'foo.bar.baz', persistent: true)
+      client.publish(@exchange_name, 'foo.bar.baz', payload)
+    end
+  end
+
+end

data/spec/isimud/event_listener_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Isimud::EventListener do
+  let!(:company) { Company.create(name: 'Google', active: true) }
+  let!(:inactive_company) { Company.create(name: 'Radio Shack', active: false) }
+  let!(:listener) { Isimud::EventListener.new(name: 'all_ears', error_limit: 5, exchange: 'test-listener') }
+
+  after(:each) do
+    Isimud.client.reset
+  end
+
+  describe 'initialization' do
+    it 'sets parameters' do
+      listener = Isimud::EventListener.new(events_exchange: 'parties',
+                                           models_exchange: 'hot_bods',
+                                           error_limit:     1,
+                                           error_interval:  5.minutes,
+                                           name:            'ear')
+      expect(listener.events_exchange).to eq('parties')
+      expect(listener.models_exchange).to eq('hot_bods')
+      expect(listener.error_limit).to eq(1)
+      expect(listener.error_interval).to eq(5.minutes)
+      expect(listener.name).to eq('ear')
+    end
+
+    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.error_interval).to eq(1.hour)
+      expect(listener.name).to eq('combustion-listener')
+    end
+  end
+
+  describe 'message delivery' do
+    before do
+      listener.bind_queues
+    end
+
+    describe '#bind_queues' do
+      it 'registers active observers' do
+        expect(listener).to have_observer(company)
+      end
+
+      it 'initializes an observer_queue' do
+        expect(listener.instance_variable_get(:@observer_queue)).to be_present
+      end
+
+      it 'skips inactive observers' do
+        expect(listener).not_to have_observer(inactive_company)
+      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)
+      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
+
+      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)
+      end
+
+      it 'does not register an observer when listening is disabled'
+
+      it 'purges the queue for a deleted observer'
+    end
+
+    describe 'handling errors' do
+      it 'counts errors'
+      it 'triggers a shutdown if errors exceed limit'
+    end
+  end
+end