active_projection 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0250b8914b32ef0061eaf8a9f32683d12182e536
-  data.tar.gz: 21ed583c9e15ae256996bacd4230c9ae4b3f5d15
+  metadata.gz: b77647433fbea824ae8677e63891935e731f517c
+  data.tar.gz: 739f2e01e001a89ec1ecffbd96be77c9067b45ec
 SHA512:
-  metadata.gz: 7b107890a963279d3d1884a5b0bbe109240dc1f1fcda356cd13d401e311beacb62c41cd1e5ae4914e12fc6f127d6e3c8fe59ecf762700f6dacf961bf17016c09
-  data.tar.gz: a6b4677d68994653d8ba0839e59e315dcfd660f70cecb2619ed7ee418ffdfd0e732302082923b49b44f6baab12da253bcdda07103a4293bd43b932283ed4604c
+  metadata.gz: 4f3712e937fc43d98700dd7e14fd713b34c2e27081de26dbb16e0a9818c1f2341ebe86275d0c7d3be2a1602e6d210c126845f70d0d931fd8a385acd1fd764de1
+  data.tar.gz: e64c810df7a0c3668b6000e61c385ba465dd94241540aed0f42cb108a3bf0cfe70ffcccd55db95fd353857cd058a4c18477ef676918870adcd758590a489a7fc

data/MIT-LICENSE

@@ -1,20 +1,20 @@
-Copyright (c) 2013 Andreas Reischuck
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+Copyright (c) 2013 Andreas Reischuck
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,7 +1,7 @@
-# Active Projection
-
-Contains everything necessary to build and run projection servers for Rails Disco.
-
-Projections process events into database models that are optimized for the Rails views.
-
-Have a look at the [rails-disco](https://github.com/hicknhack-software/rails-disco/wiki) documentation on Github for more details.
+# Active Projection
+
+Contains everything necessary to build and run projection servers for Rails Disco.
+
+Projections process events into database models that are optimized for the Rails views.
+
+Have a look at the [rails-disco](https://github.com/hicknhack-software/rails-disco/wiki) documentation on Github for more details.

data/app/models/active_projection/cached_projection_repository.rb

@@ -8,7 +8,7 @@ module ActiveProjection
       projections.values.map(&:last_id)
     end
 
-    def self.get_last_id(id)
+    def self.last_id(id)
       projections[id].last_id
     end
 
@@ -16,11 +16,11 @@ module ActiveProjection
       projections[id].update! last_id: last_id
     end
 
-    def self.set_broken(id)
+    def self.mark_broken(id)
       projections[id].update! solid: false
     end
 
-    def self.get_all_broken
+    def self.all_broken
       projections.values.reject(&:solid).map(&:class_name)
     end
 
@@ -45,7 +45,7 @@ module ActiveProjection
 
     private
 
-    def self.initialize
+    def initialize
     end
 
     cattr_accessor :projections do

data/app/models/active_projection/projection.rb

@@ -1,5 +1,5 @@
-module ActiveProjection
-  class Projection < ActiveRecord::Base
-    self.table_name = 'projections'
-  end
-end
+module ActiveProjection
+  class Projection < ActiveRecord::Base
+    self.table_name = 'projections'
+  end
+end

data/app/models/active_projection/projection_repository.rb

@@ -1,45 +1,45 @@
-module ActiveProjection
-  class ProjectionRepository
-    def self.last_ids
-      Projection.all.to_a.map { |p| p.last_id }
-    end
-
-    def self.get_last_id(id)
-      Projection.find(id).last_id
-    end
-
-    def self.set_last_id(id, last_id)
-      Projection.find(id).update! last_id: last_id
-    end
-
-    def self.set_broken(id)
-      Projection.find(id).update! solid: false
-    end
-
-    def self.get_all_broken
-      Projection.where(solid: false).to_a.map { |p| p.class_name }
-    end
-
-    def self.solid?(id)
-      Projection.find(id).solid
-    end
-
-    def self.ensure_exists(projection_class)
-      Projection.transaction do
-        Projection.find_or_create_by! class_name: projection_class
-      end
-    end
-
-    def self.ensure_solid(projection_class)
-      Projection.transaction do
-        projection = Projection.find_or_initialize_by class_name: projection_class
-        projection.update! solid: true
-      end
-    end
-
-    private
-
-    def self.initialize
-    end
-  end
-end
+module ActiveProjection
+  class ProjectionRepository
+    def self.last_ids
+      Projection.all.to_a.map { |p| p.last_id }
+    end
+
+    def self.last_id(id)
+      Projection.find(id).last_id
+    end
+
+    def self.set_last_id(id, last_id)
+      Projection.find(id).update! last_id: last_id
+    end
+
+    def self.mark_broken(id)
+      Projection.find(id).update! solid: false
+    end
+
+    def self.all_broken
+      Projection.where(solid: false).to_a.map { |p| p.class_name }
+    end
+
+    def self.solid?(id)
+      Projection.find(id).solid
+    end
+
+    def self.ensure_exists(projection_class)
+      Projection.transaction do
+        Projection.find_or_create_by! class_name: projection_class
+      end
+    end
+
+    def self.ensure_solid(projection_class)
+      Projection.transaction do
+        projection = Projection.find_or_initialize_by class_name: projection_class
+        projection.update! solid: true
+      end
+    end
+
+    private
+
+    def initialize
+    end
+  end
+end

data/db/migrate/01_create_projections.rb

@@ -1,10 +1,10 @@
-class CreateProjections < ActiveRecord::Migration
-  def change
-    create_table :projections do |t|
-      t.string :class_name
-      t.integer :last_id, default: 0
-      t.boolean :solid, default: true
-    end
-    add_index :projections, :class_name
-  end
-end
+class CreateProjections < ActiveRecord::Migration
+  def change
+    create_table :projections do |t|
+      t.string :class_name
+      t.integer :last_id, default: 0
+      t.boolean :solid, default: true
+    end
+    add_index :projections, :class_name
+  end
+end

data/lib/active_projection.rb

@@ -1,17 +1,17 @@
-require 'active_event'
-require 'active_support/core_ext'
-require 'active_projection/version'
-
-module ActiveProjection
-  extend ActiveSupport::Autoload
-
-  autoload :Autoload
-  autoload :EventClient
-  autoload :ProjectionType
-  autoload :ProjectionTypeRegistry
-  autoload :Server
-
-  autoload :Projection, (File.expand_path '../../app/models/active_projection/projection', __FILE__)
-  autoload :ProjectionRepository, (File.expand_path '../../app/models/active_projection/projection_repository', __FILE__)
-  autoload :CachedProjectionRepository, (File.expand_path '../../app/models/active_projection/cached_projection_repository', __FILE__)
-end
+require 'active_event'
+require 'active_support/core_ext'
+require 'active_projection/version'
+
+module ActiveProjection
+  extend ActiveSupport::Autoload
+
+  autoload :Autoload
+  autoload :EventClient
+  autoload :ProjectionType
+  autoload :ProjectionTypeRegistry
+  autoload :Server
+
+  autoload :Projection, (File.expand_path '../../app/models/active_projection/projection', __FILE__)
+  autoload :ProjectionRepository, (File.expand_path '../../app/models/active_projection/projection_repository', __FILE__)
+  autoload :CachedProjectionRepository, (File.expand_path '../../app/models/active_projection/cached_projection_repository', __FILE__)
+end

data/lib/active_projection/autoload.rb

@@ -1,9 +1,11 @@
-module ActiveProjection
-  module Autoload
-    include ActiveEvent::Support::Autoload
-    private
-    def self.dir_names
-      %W(app/models app/projections)
-    end
-  end
-end
+module ActiveProjection
+  module Autoload
+    include ActiveEvent::Support::Autoload
+
+    private
+
+    def self.dir_names
+      %w(app/models app/projections)
+    end
+  end
+end

data/lib/active_projection/event_client.rb

@@ -1,171 +1,171 @@
-require 'singleton'
-require 'bunny'
-
-module ActiveProjection
-  class EventClient
-    include Singleton
-
-    def self.start(options)
-      instance.configure(options).start
-    end
-
-    def configure(options)
-      raise 'Unsupported! Cannot configure running client' if running
-      self.options = options
-      self
-    end
-
-    def start
-      run_once do
-        prepare
-        sync_projections
-        listen_for_events
-        listen_for_replayed_events
-        request_missing_events
-        event_channel.work_pool.join
-      end
-    rescue Interrupt
-      LOGGER.info 'Catching Interrupt'
-    rescue Exception => e
-      LOGGER.error e.message
-      LOGGER.error e.backtrace.join("\n")
-      raise
-    end
-
-    private
-
-    attr_accessor :options
-    attr_accessor :running # true once start was called
-    attr_accessor :current # true after missing events are processed
-    attr_accessor :delay_queue # stores events while processing missing events
-
-    def run_once
-      raise 'Unsupported! Connot start a running client' if running
-      self.running = true
-      yield
-    ensure
-      self.running = false
-    end
-
-    def prepare
-      self.delay_queue = []
-      init_database_connection
-      event_connection.start
-    end
-
-    def init_database_connection
-      ActiveRecord::Base.establish_connection options[:projection_database]
-    end
-
-    def sync_projections
-      server_projections.each do |projection|
-        CachedProjectionRepository.ensure_solid(projection.class.name)
-      end
-    end
-
-    def server_projections
-      @server_projections ||= ProjectionTypeRegistry.projections.drop(WORKER_NUMBER).each_slice(WORKER_COUNT).map(&:first)
-    end
-
-    def listen_for_events
-      event_queue.subscribe do |delivery_info, properties, body|
-        if current
-          event_received properties, body
-        else
-          delay_queue << [properties, body]
-        end
-      end
-    end
-
-    def listen_for_replayed_events
-      replay_queue.subscribe do |delivery_info, properties, body|
-        if 'replay_done' == body
-          replay_done
-        else
-          event_received properties, body
-        end
-      end
-    end
-
-    def request_missing_events
-      send_request_for(CachedProjectionRepository.last_ids.min || 0)
-    end
-
-    def send_projection_notification(event_id, projection, error = nil)
-      message = {event: event_id, projection: projection.class.name}
-      message.merge! error: "#{error.class.name}: #{error.message}", backtrace: error.backtrace if error
-      server_side_events_exchange.publish message.to_json
-    end
-
-    def send_request_for(id)
-      resend_request_exchange.publish id.to_s, routing_key: 'resend_request'
-    end
-
-    def replay_done
-      LOGGER.debug 'All replayed events received'
-      broken_projections = CachedProjectionRepository.get_all_broken
-      LOGGER.error "These projections are still broken: #{broken_projections.join(", ")}" unless broken_projections.empty?
-      replay_queue.unbind(resend_exchange)
-      self.current = true
-      flush_delay_queue
-    end
-
-    def flush_delay_queue
-      delay_queue.each { |properties, body| event_received properties, body }
-      self.delay_queue = []
-    end
-
-    def event_received(properties, body)
-      RELOADER.execute_if_updated
-      LOGGER.debug "Received #{properties.type} with #{body}"
-      headers = properties.headers.deep_symbolize_keys!
-      event = ActiveEvent::EventType.create_instance properties.type, JSON.parse(body).deep_symbolize_keys!
-      process_event headers, event
-    end
-
-    def process_event(headers, event)
-      server_projections.select { |p| p.evaluate headers }.each do |projection|
-        begin
-          ActiveRecord::Base.transaction do
-            projection.invoke event, headers
-          end
-          send_projection_notification headers[:id], projection
-        rescue Exception => e
-          send_projection_notification headers[:id], projection, e
-        end
-      end
-    end
-
-    def replay_queue
-      @replay_queue ||= event_channel.queue('', auto_delete: true).bind(resend_exchange)
-    end
-
-    def event_queue
-      @event_queue ||= event_channel.queue('', auto_delete: true).bind(event_exchange)
-    end
-
-    def event_connection
-      @event_server ||= Bunny.new URI::Generic.build(options[:event_connection]).to_s
-    end
-
-    def event_channel
-      @event_channel ||= event_connection.create_channel
-    end
-
-    def event_exchange
-      @event_exchange ||= event_channel.fanout options[:event_exchange]
-    end
-
-    def resend_exchange
-      @resend_exchange ||= event_channel.fanout "resend_#{options[:event_exchange]}"
-    end
-
-    def resend_request_exchange
-      @resend_request_exchange ||= event_channel.direct "resend_request_#{options[:event_exchange]}"
-    end
-
-    def server_side_events_exchange
-      @server_side_events_exchange ||= event_channel.fanout "server_side_#{options[:event_exchange]}"
-    end
-  end
-end
+require 'singleton'
+require 'bunny'
+
+module ActiveProjection
+  class EventClient
+    include Singleton
+
+    def self.start(options)
+      instance.configure(options).start
+    end
+
+    def configure(options)
+      fail 'Unsupported! Cannot configure running client' if running
+      self.options = options
+      self
+    end
+
+    def start
+      run_once do
+        prepare
+        sync_projections
+        listen_for_events
+        listen_for_replayed_events
+        request_missing_events
+        event_channel.work_pool.join
+      end
+    rescue Interrupt
+      LOGGER.info 'Catching Interrupt'
+    rescue => e
+      LOGGER.error e.message
+      LOGGER.error e.backtrace.join("\n")
+      raise
+    end
+
+    private
+
+    attr_accessor :options
+    attr_accessor :running # true once start was called
+    attr_accessor :current # true after missing events are processed
+    attr_accessor :delay_queue # stores events while processing missing events
+
+    def run_once
+      fail 'Unsupported! Connot start a running client' if running
+      self.running = true
+      yield
+    ensure
+      self.running = false
+    end
+
+    def prepare
+      self.delay_queue = []
+      init_database_connection
+      event_connection.start
+    end
+
+    def init_database_connection
+      ActiveRecord::Base.establish_connection options[:projection_database]
+    end
+
+    def sync_projections
+      server_projections.each do |projection|
+        CachedProjectionRepository.ensure_solid(projection.class.name)
+      end
+    end
+
+    def server_projections
+      @server_projections ||= ProjectionTypeRegistry.projections.drop(WORKER_NUMBER).each_slice(WORKER_COUNT).map(&:first)
+    end
+
+    def listen_for_events
+      event_queue.subscribe do |_delivery_info, properties, body|
+        if current
+          event_received properties, body
+        else
+          delay_queue << [properties, body]
+        end
+      end
+    end
+
+    def listen_for_replayed_events
+      replay_queue.subscribe do |_delivery_info, properties, body|
+        if 'replay_done' == body
+          replay_done
+        else
+          event_received properties, body
+        end
+      end
+    end
+
+    def request_missing_events
+      send_request_for(CachedProjectionRepository.last_ids.min || 0)
+    end
+
+    def send_projection_notification(event_id, projection, error = nil)
+      message = {event: event_id, projection: projection.class.name}
+      message.merge! error: "#{error.class.name}: #{error.message}", backtrace: error.backtrace if error
+      server_side_events_exchange.publish message.to_json
+    end
+
+    def send_request_for(id)
+      resend_request_exchange.publish id.to_s, routing_key: 'resend_request'
+    end
+
+    def replay_done
+      LOGGER.debug 'All replayed events received'
+      broken_projections = CachedProjectionRepository.all_broken
+      LOGGER.error "These projections are still broken: #{broken_projections.join(', ')}" unless broken_projections.empty?
+      replay_queue.unbind(resend_exchange)
+      self.current = true
+      flush_delay_queue
+    end
+
+    def flush_delay_queue
+      delay_queue.each { |properties, body| event_received properties, body }
+      self.delay_queue = []
+    end
+
+    def event_received(properties, body)
+      RELOADER.execute_if_updated
+      LOGGER.debug "Received #{properties.type} with #{body}"
+      headers = properties.headers.deep_symbolize_keys!
+      event = ActiveEvent::EventType.create_instance properties.type, JSON.parse(body).deep_symbolize_keys!
+      process_event headers, event
+    end
+
+    def process_event(headers, event)
+      server_projections.select { |p| p.evaluate headers }.each do |projection|
+        begin
+          ActiveRecord::Base.transaction do
+            projection.invoke event, headers
+          end
+          send_projection_notification headers[:id], projection
+        rescue => e
+          send_projection_notification headers[:id], projection, e
+        end
+      end
+    end
+
+    def replay_queue
+      @replay_queue ||= event_channel.queue('', auto_delete: true).bind(resend_exchange)
+    end
+
+    def event_queue
+      @event_queue ||= event_channel.queue('', auto_delete: true).bind(event_exchange)
+    end
+
+    def event_connection
+      @event_server ||= Bunny.new URI::Generic.build(options[:event_connection]).to_s
+    end
+
+    def event_channel
+      @event_channel ||= event_connection.create_channel
+    end
+
+    def event_exchange
+      @event_exchange ||= event_channel.fanout options[:event_exchange]
+    end
+
+    def resend_exchange
+      @resend_exchange ||= event_channel.fanout "resend_#{options[:event_exchange]}"
+    end
+
+    def resend_request_exchange
+      @resend_request_exchange ||= event_channel.direct "resend_request_#{options[:event_exchange]}"
+    end
+
+    def server_side_events_exchange
+      @server_side_events_exchange ||= event_channel.fanout "server_side_#{options[:event_exchange]}"
+    end
+  end
+end