active_projection 0.5.0.rc3 → 0.5.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3300767c58d38551a2844322cece40fcfdbd2df
-  data.tar.gz: 0c7d4bae4ef6276563e64e15d0a2f7a05cc6dff4
+  metadata.gz: b9efdd612a791bf02b6a1f3f809ffffca7c7841b
+  data.tar.gz: 8596080a556b2d9639534923c00589cb55cc9235
 SHA512:
-  metadata.gz: 4a9dd96e797d670fc8b11e53202f12a786258a9e266cd6b988d7568a3a297a4ae552ce2a66d79170a1bc7156ff10f934317e6c760c1f805001edb7153693138e
-  data.tar.gz: fd00e8748edfe21a30fcf6f548c499d8b0d071e15ed46dea43002c1413dc1dd9d51f6c61ad5e3e696713c09caae73df3252030915795b2a8018988bb782477f4
+  metadata.gz: 11fe3536a9b6318bbd5a34970cf2a949c5c0c9ab13f5c0e2436c03d19e1183289737567de9b4c96dcbddd026c0b69710a2ff9321e126eb3ac4ba64c5c9954629
+  data.tar.gz: f32df5da5a87329fe6e5c47a9027788460bf28c56b78245eb0bd9fc7843ac26c86d3dbcdaeb474dbba7807b036f98cc23a88c391660ed0d3a0c7b743cd64569e

data/app/models/active_projection/cached_projection_repository.rb

@@ -0,0 +1,55 @@
+module ActiveProjection
+  #
+  # This implements a fully cached projection repository.
+  #
+  # notice: NOT thread safe!
+  class CachedProjectionRepository
+    def self.last_ids
+      projections.values.map(&:last_id)
+    end
+
+    def self.get_last_id(id)
+      projections[id].last_id
+    end
+
+    def self.set_last_id(id, last_id)
+      projections[id].update! last_id: last_id
+    end
+
+    def self.set_broken(id)
+      projections[id].update! solid: false
+    end
+
+    def self.get_all_broken
+      projections.values.reject(&:solid).map(&:class_name)
+    end
+
+    def self.solid?(id)
+      projections[id].solid
+    end
+
+    def self.ensure_exists(projection_class)
+      Projection.transaction do
+        projection = Projection.find_or_create_by! class_name: projection_class
+        projections[projection.id] = projection
+      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
+        projections[projection.id] = projection
+      end
+    end
+
+    private
+
+    def self.initialize
+    end
+
+    cattr_accessor :projections do
+      {}
+    end
+  end
+end

data/app/models/active_projection/projection_repository.rb

@@ -1,51 +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)
-      @@last_id[id] ||= Projection.find(id).last_id
+      Projection.find(id).last_id
     end
 
     def self.set_last_id(id, last_id)
       Projection.find(id).update! last_id: last_id
-      @@last_id[id] += 1
     end
 
     def self.set_broken(id)
-      @@broken[id] = false
       Projection.find(id).update! solid: false
     end
 
     def self.get_all_broken
-      broken_projections = []
-      Projection.all.to_a.each do |p|
-        broken_projections << p.class_name unless p.solid?
-      end
-      broken_projections
+      Projection.where(solid: false).to_a.map { |p| p.class_name }
     end
 
     def self.solid?(id)
-      @@broken[id] ||= Projection.find(id).solid
+      Projection.find(id).solid
     end
 
-    def self.create_or_get(projection_class)
-      projection = Projection.where(class_name: projection_class).first
-      if projection.nil?
-        projection = Projection.create! class_name: projection_class, last_id: 0, solid: true
-      else
+    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
-      projection
     end
 
     private
+
     def self.initialize
     end
-
-    @@last_id = {}
-    @@broken = {}
   end
-end
+end

data/db/migrate/01_create_projections.rb

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

data/lib/active_projection/autoload.rb

@@ -3,40 +3,7 @@ module ActiveProjection
     include ActiveEvent::Support::Autoload
     private
     def self.dir_names
-      %W(app/models)
-    end
-
-    def self.reload
-      ActiveEvent::Support::Autoloader.reload_from pdirs
-      super
-    end
-
-    def self.worker_config=(config)
-      set_pdirs config
-      ActiveEvent::Support::Autoloader.load_from pdirs
-    end
-
-    def self.watchable_dirs
-      watchable_dirs = super
-      watchable_dirs['app/projections'] = [:rb]
-      watchable_dirs
-    end
-
-    private
-    def self.set_pdirs(config)
-      @pdirs = []
-      projections_dir = "#{config[:path]}/app/projections/**/*.rb"
-      if config[:count] == 1
-        @pdirs << projections_dir
-      else
-        Dir[*projections_dir].each_with_index.map { |item, i| i % config[:count] == config[:number] ? item : nil }.compact.each do |dir|
-          @pdirs << dir
-        end
-      end
-    end
-
-    def self.pdirs
-      @pdirs ||= []
+      %W(app/models app/projections)
     end
   end
-end
+end

data/lib/active_projection/event_client.rb

@@ -1,77 +1,139 @@
 require 'singleton'
 require 'bunny'
+
 module ActiveProjection
   class EventClient
     include Singleton
 
     def self.start(options)
-      instance.options = options
-      instance.start
+      instance.configure(options).start
+    end
+
+    def configure(options)
+      raise 'Unsupported! Cannot configure running client' if running
+      self.options = options
+      self
     end
 
     def start
-      event_connection.start
-      sync_projections
-      listen_for_events
-      request_missing_events
-      event_channel.work_pool.join
+      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 e
+      raise
     end
 
-    def sync_projections
-      ProjectionTypeRegistry.sync_projections
+    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 listen_for_events
-      subscribe_to event_queue do |delivery_info, properties, body|
-        event_received properties, body
-        send_browser_notification properties.headers[:id]
+    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 request_missing_events
-      listen_for_replayed_events
-      send_request_for min_last_id
+    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
-      subscribe_to replay_queue do |delivery_info, properties, body|
-        event_received properties, body unless replay_done? body
+      replay_queue.subscribe do |delivery_info, properties, body|
+        if 'replay_done' == body
+          replay_done
+        else
+          event_received properties, body
+        end
       end
     end
 
-    def send_browser_notification(id)
-      server_side_events_exchange.publish id.to_s
+    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.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?(body)
-      if 'replay_done' == body
-        LOGGER.debug 'All replayed events received'
-        broken_projections = ProjectionRepository.get_all_broken
-        LOGGER.error "These projections are still broken: #{broken_projections.join(", ")}" unless broken_projections.empty?
-        replay_queue.unbind(resend_exchange)
-        return true
-      end
-      false
+    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}"
-      ProjectionTypeRegistry.process properties.headers.deep_symbolize_keys!, build_event(properties.type, JSON.parse(body))
-    end
-
-    def build_event(type, data)
-      Object.const_get(type).new(data.deep_symbolize_keys)
+      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
@@ -82,14 +144,6 @@ module ActiveProjection
       @event_queue ||= event_channel.queue('', auto_delete: true).bind(event_exchange)
     end
 
-    def min_last_id
-      ProjectionRepository.last_ids.min || 0
-    end
-
-    def subscribe_to(queue, &block)
-      queue.subscribe(&block)
-    end
-
     def event_connection
       @event_server ||= Bunny.new URI::Generic.build(options[:event_connection]).to_s
     end
@@ -113,11 +167,5 @@ module ActiveProjection
     def server_side_events_exchange
       @server_side_events_exchange ||= event_channel.fanout "server_side_#{options[:event_exchange]}"
     end
-
-    def options
-      @options
-    end
-
-    attr_writer :options
   end
-end
+end

data/lib/active_projection/projection_type.rb

@@ -52,12 +52,11 @@ module ActiveProjection
         rescue Exception => e
           LOGGER.error "[#{self.class.name}]: error processing #{event_type}[#{event_id}]\n#{e.message}\n#{e.backtrace}"
           set_broken
+          raise
         end
       end
-      if solid?
-        update_last_id event_id
-        LOGGER.debug "[#{self.class.name}]: sucessfully processed #{event_type}[#{event_id}]"
-      end
+      update_last_id event_id
+      LOGGER.debug "[#{self.class.name}]: sucessfully processed #{event_type}[#{event_id}]"
     end
 
     private
@@ -69,7 +68,7 @@ module ActiveProjection
     end
 
     def projection_id
-      @projection_id ||= ProjectionRepository.create_or_get(self.class.name).id
+      @projection_id ||= ProjectionRepository.ensure_exists(self.class.name).id
     end
 
     def solid?

data/lib/active_projection/projection_type_registry.rb

@@ -4,45 +4,25 @@ module ActiveProjection
   class ProjectionTypeRegistry
     include Singleton
 
+    # register a new projection class
+    #
+    # The best way to create a new projection is using the ProjectionType module
+    # This module automatically registers each class
     def self.register(projection)
       self.registry << projection
     end
 
-    def self.process(headers, event)
-      instance.process headers, event
+    # @return an enumerable with all projections
+    def self.projections
+      instance.projections.each
     end
 
-    def process(headers, event)
-      projections.each do |projection|
-        ActiveRecord::Base.transaction do
-          projection.invoke(event, headers) if projection.evaluate headers
-        end
-      end
-    end
-
-    def self.sync_projections
-      instance.sync_projections
-    end
-
-    def sync_projections
-      projections.each do |projection|
-        ProjectionRepository.create_or_get(projection.class.name)
-      end
+    def projections
+      @projections ||= self.class.registry.freeze.map { |projection_class| projection_class.new }.freeze
     end
 
     private
 
-    cattr_accessor :registry
-    attr_accessor :projections
-
-    def initialize
-      self.projections = []
-      self.class.registry.freeze.each do |projection|
-        projections << projection.new
-      end
-      projections.freeze
-    end
-
-    self.registry = []
+    cattr_accessor(:registry) { [] }
   end
-end
+end

data/lib/active_projection/server.rb

@@ -12,7 +12,6 @@ module ActiveProjection
     end
 
     def run
-      ActiveRecord::Base.establish_connection options[:projection_database]
       EventClient.start options
     end
 

data/lib/active_projection/version.rb

@@ -1,7 +1,7 @@
 module ActiveProjection
   # Returns the version of the currently loaded ActiveProjection as a Gem::Version
   def self.version
-    Gem::Version.new '0.5.0.rc3'
+    Gem::Version.new '0.5.0.rc4'
   end
 
   module VERSION #:nodoc:

data/lib/active_projection.rb

@@ -13,4 +13,5 @@ module ActiveProjection
 
   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/spec/lib/projection_type_registry_spec.rb

@@ -22,7 +22,7 @@ describe ActiveProjection::ProjectionTypeRegistry do
   end
 
   it 'synchronizes the known projections with the db' do
-    expect(ActiveProjection::ProjectionRepository).to receive(:create_or_get).with('TestProjection')
+    expect(ActiveProjection::ProjectionRepository).to receive(:ensure_exists).with('TestProjection')
     ActiveProjection::ProjectionTypeRegistry.sync_projections
   end
 end

data/spec/models/projection_repository_spec.rb

@@ -7,14 +7,14 @@ describe ActiveProjection::ProjectionRepository do
       FactoryGirl.create :projection, id: i, class_name: "TestProjection#{i}", last_id: 5 - i
     end
   end
-  describe 'create_or_get' do
+  describe 'ensure_exists' do
     it 'creates a projection, if classname is not present' do
-      expect(ActiveProjection::ProjectionRepository.create_or_get('TestProjection5').id).to eq 5
+      expect(ActiveProjection::ProjectionRepository.ensure_exists('TestProjection5').id).to eq 5
       expect(ActiveProjection::Projection.all.to_a.length).to eq 6
     end
 
     it 'does not create a projection, if classname is present' do
-      expect(ActiveProjection::ProjectionRepository.create_or_get('TestProjection3').id).to eq 3
+      expect(ActiveProjection::ProjectionRepository.ensure_exists('TestProjection3').id).to eq 3
       expect(ActiveProjection::Projection.all.to_a.length).to eq 5
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_projection
 version: !ruby/object:Gem::Version
-  version: 0.5.0.rc3
+  version: 0.5.0.rc4
 platform: ruby
 authors:
 - HicknHack Software
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-24 00:00:00.000000000 Z
+date: 2014-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_event
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.0.rc3
+        version: 0.5.0.rc4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.0.rc3
+        version: 0.5.0.rc4
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -159,6 +159,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- app/models/active_projection/cached_projection_repository.rb
 - app/models/active_projection/projection.rb
 - app/models/active_projection/projection_repository.rb
 - db/migrate/01_create_projections.rb