active_projection 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d9052c28e84c5b64ab1b4350b291e02077f824ec
+  data.tar.gz: a7ad85d0ff185230ba7d350efa4a123143e60499
+SHA512:
+  metadata.gz: b617e60a34666ba1fb02b110113c6d94a7b72c7f91d1c2a64d4272e44e7eec28894c4a4234491638b4babccae0cf1600a22089ce8630f7c9d3e33471c2662467
+  data.tar.gz: 1abea3c7eb6b8921ecbf7a4c3896642dd0ac55301439dd09b5013a51c4a12f9c8713b912f36004ac15d6aad45dff4751b48f4c4dec7eb4d6f39be76d747fd867

data/MIT-LICENSE

@@ -0,0 +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
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# Active Projection
+
+TODO: Write a gem description

data/app/models/active_projection/projection.rb

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

data/app/models/active_projection/projection_repository.rb

@@ -0,0 +1,43 @@
+module ActiveProjection
+  class ProjectionRepository
+
+    def self.all
+      Projection.all
+    end
+
+    def self.get_last_id(id)
+      @@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
+      @@last_id[id] += 1
+    end
+
+    def self.set_broken(id)
+      @@broken[id] = false
+      Projection.find(id).update! solid: false
+    end
+
+    def self.solid?(id)
+      @@broken[id] ||= 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
+        projection.update! solid: true
+      end
+      projection
+    end
+
+    private
+    def self.initialize
+    end
+
+    @@last_id = {}
+    @@broken = {}
+  end
+end

data/db/migrate/01_create_projections.rb

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

data/lib/active_projection.rb

@@ -0,0 +1,16 @@
+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__)
+end

data/lib/active_projection/autoload.rb

@@ -0,0 +1,20 @@
+module ActiveProjection
+  module Autoload
+    def self.worker_config=(config)
+      dirs = []
+      projections_dir = "#{config[:path]}**/*.rb"
+      if config[:count] == 1
+        dirs << projections_dir
+      else
+        Dir[*projections_dir].each_with_index.map { |item, i| i % config[:count] == config[:number] ? item : nil }.compact.each do |dir|
+          dirs << dir
+        end
+      end
+      ActiveEvent::Support::Autoloader.load_from dirs
+    end
+
+    def self.app_path=(path)
+      ActiveEvent::Support::Autoloader.load_from "#{path}/models/**/*.rb"
+    end
+  end
+end

data/lib/active_projection/event_client.rb

@@ -0,0 +1,55 @@
+require 'singleton'
+require 'bunny'
+module ActiveProjection
+  class EventClient
+    include Singleton
+
+    def self.start(options)
+      instance.start options
+    end
+
+    def start(options)
+      self.options = options
+      event_connection.start
+      begin
+        event_channel.queue('', auto_delete: true).bind(event_exchange).subscribe do |delivery_info, properties, body|
+          puts "Received #{properties.type} with #{body}"
+          ProjectionTypeRegistry.process(properties.headers.deep_symbolize_keys, Object.const_get(properties.type).new((JSON.parse body).deep_symbolize_keys))
+        end
+      rescue Interrupt => _
+        event_channel.close
+        event_connection.close
+      end
+      last_ids = ProjectionRepository.all.to_a.map { |p| p.last_id }
+      request_events_after last_ids.min || 0
+      event_channel.work_pool.join
+    end
+
+    def request_events_after(id)
+      resend_exchange.publish id.to_s, routing_key: 'resend'
+    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.direct "resend_#{options[:event_exchange]}"
+    end
+
+    def options
+      @options
+    end
+
+    private
+    attr_writer :options
+  end
+end

data/lib/active_projection/projection_type.rb

@@ -0,0 +1,56 @@
+module ActiveProjection
+  module ProjectionType
+    extend ActiveSupport::Concern
+    class WrongArgumentsCountError < StandardError
+    end
+    included do
+      ProjectionTypeRegistry::register(self)
+    end
+
+    def initialize
+      self.handlers = Hash.new do |hash, key|
+        hash[key] = []
+      end
+      self.class.public_instance_methods(false).each do |method_name|
+        method = self.class.instance_method method_name
+        event_type = method_name.to_s.camelcase.to_sym
+        raise WrongArgumentsCountError if 1 != method.arity
+        handlers[event_type] << method.name
+      end
+    end
+
+    def evaluate(headers)
+      return false unless ProjectionRepository.solid? projection_id #projection is broken and shouldn't process any incoming event
+      last_id = ProjectionRepository.get_last_id projection_id
+      case
+        when last_id + 1 == headers[:store_id] #process incoming event
+          ProjectionRepository.set_last_id projection_id, headers[:store_id]
+          puts "process this event"
+          true
+        when last_id >= headers[:store_id] #incoming event already processed
+          puts "event already processed"
+          false
+        when last_id < headers[:store_id] #incoming event is in future, so we are missing some
+          puts "events are missing"
+          ProjectionRepository.set_broken projection_id
+          false
+      end
+    end
+
+    def invoke(event)
+      event_type = event.class.name.split('::').last.to_sym
+      return unless handlers.has_key? event_type
+      handlers[event_type].each do |method|
+        self.send method, event
+      end
+    end
+
+    private
+    attr_accessor :handlers
+    attr_writer :projection_id
+
+    def projection_id
+      @projection_id ||= ProjectionRepository.create_or_get(self.class.name).id
+    end
+  end
+end

data/lib/active_projection/projection_type_registry.rb

@@ -0,0 +1,38 @@
+require 'singleton'
+
+module ActiveProjection
+  class ProjectionTypeRegistry
+    include Singleton
+
+    def self.register(projection)
+      self.registry << projection
+    end
+
+    def self.process(headers, event)
+      instance.process headers, event
+    end
+
+    def process(headers, event)
+      projections.each do |projection|
+        ActiveRecord::Base.transaction do
+          projection.invoke event if projection.evaluate headers
+        end
+      end
+    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 = []
+  end
+end

data/lib/active_projection/railtie.rb

@@ -0,0 +1,8 @@
+require 'active_projection'
+require 'rails'
+
+module ActiveProjection
+  class Railtie < Rails::Railtie # :nodoc:
+    config.eager_load_namespaces << ActiveProjection
+  end
+end

data/lib/active_projection/server.rb

@@ -0,0 +1,60 @@
+require 'active_record'
+
+module ActiveProjection
+  class Server
+
+    def self.run(options = nil)
+      self.new(options).run
+    end
+
+    def initialize(new_options = nil)
+      self.options = new_options.deep_symbolize_keys! unless new_options.nil?
+    end
+
+    def run
+      ActiveRecord::Base.establish_connection options[:projection_database]
+      EventClient.start options
+    end
+
+    def env
+      @env = ENV['PROJECTION_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    def options
+      @options ||= parse_options(ARGV)
+    end
+
+    cattr_accessor :base_path
+    cattr_accessor :config_file
+
+    def config_file
+      self.class.config_file || File.expand_path('config/disco.yml', base_path)
+    end
+
+    private
+
+    attr_writer :options
+    attr_writer :domain
+
+    def default_options
+      {
+          projection_database: {
+              adapter: 'sqlite3',
+              database: File.expand_path('db/projection.sqlite3', base_path)
+          },
+          event_connection: {
+              scheme: 'amqp',
+              userinfo: nil,
+              host: '127.0.0.1',
+              port: 9797,
+          },
+          event_exchange: 'events'
+      }
+    end
+
+    def parse_options(args)
+      options = default_options
+      options.merge! YAML.load_file(config_file)[env].deep_symbolize_keys! unless config_file.blank?
+    end
+  end
+end

data/lib/active_projection/version.rb

@@ -0,0 +1,11 @@
+module ActiveProjection
+  # Returns the version of the currently loaded ActiveProjection as a Gem::Version
+  def self.version
+    Gem::Version.new '0.1.0'
+  end
+
+  module VERSION #:nodoc:
+    MAJOR, MINOR, TINY, PRE = ActiveProjection.version.segments
+    STRING = ActiveProjection.version.to_s
+  end
+end

data/spec/factories/event_factory.rb

@@ -0,0 +1,8 @@
+require 'factory_girl'
+
+FactoryGirl.define do
+  factory :projection, class: ActiveProjection::Projection do
+    last_id 4
+    solid true
+  end
+end

data/spec/lib/projection_type_registry_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../spec_helper'
+
+describe ActiveProjection::ProjectionTypeRegistry do
+  class TestEvent
+  end
+  class TestProjection
+  end
+  before :all do
+    ActiveProjection::ProjectionTypeRegistry.register(TestProjection)
+  end
+
+  it 'initializes' do
+    ActiveProjection::ProjectionTypeRegistry.instance.should be
+  end
+
+  it 'invokes event handlers' do
+    event = TestEvent.new
+    expect_any_instance_of(TestProjection).to receive(:evaluate).with('test').and_return(true)
+    expect_any_instance_of(TestProjection).to receive(:invoke).with(event)
+    ActiveProjection::ProjectionTypeRegistry.process('test', event)
+  end
+end

data/spec/lib/projecton_type_spec.rb

@@ -0,0 +1,74 @@
+require_relative '../spec_helper'
+require_relative '../support/active_record'
+
+describe ActiveProjection::ProjectionType do
+  it 'should register automatically' do
+    expect(ActiveProjection::ProjectionTypeRegistry).to receive(:register) do |arg|
+      arg.name.to_sym.should eq :DummyProjection
+    end
+    class DummyProjection
+      include ActiveProjection::ProjectionType
+    end
+  end
+  describe 'instance' do
+    class TestProjection
+      def test_event(event)
+      end
+
+      def dummy_event(event)
+      end
+    end
+    class TestEvent
+    end
+    before :each do
+      allow(ActiveProjection::ProjectionTypeRegistry).to receive(:register)
+      TestProjection.send(:include, ActiveProjection::ProjectionType)
+      @projection = TestProjection.new
+    end
+    it 'initializes all handler' do
+      handlers = @projection.instance_variable_get(:@handlers)
+      handlers.length.should eq 2
+      handlers['TestEvent'].should be
+      handlers['DummyEvent'].should be
+    end
+
+    describe 'evaluate' do
+      before :each do
+        allow(@projection).to receive(:projection_id).and_return(0)
+      end
+
+      it 'rejects processing, if projection is broken' do
+        expect(ActiveProjection::ProjectionRepository).to receive(:solid?).and_return(false)
+        expect(ActiveProjection::ProjectionRepository).to_not receive(:get_last_id)
+        @projection.evaluate({store_id: 1})
+      end
+
+      describe 'with solid projection' do
+        before :each do
+          allow(ActiveProjection::ProjectionRepository).to receive(:solid?).and_return(true)
+          expect(ActiveProjection::ProjectionRepository).to receive(:get_last_id).and_return(5)
+        end
+
+        it 'processes event with the correct id' do
+          expect(ActiveProjection::ProjectionRepository).to receive(:set_last_id).with(0, 6)
+          expect(@projection.evaluate({store_id: 6})).to be_true
+        end
+
+        it 'rejects event with last id smaller event id' do
+          expect(@projection.evaluate({store_id: 3})).to be_false
+        end
+
+        it 'rejects event with last greater equal event id' do
+          expect(ActiveProjection::ProjectionRepository).to receive(:set_broken).with(0)
+          expect(@projection.evaluate({store_id: 7})).to be_false
+        end
+      end
+    end
+
+    it 'invokes all handler' do
+      expect(@projection).to receive(:test_event)
+      expect(@projection).to_not receive(:dummy_event)
+      @projection.invoke(TestEvent.new)
+    end
+  end
+end

data/spec/models/projection_repository_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../spec_helper'
+require_relative '../support/active_record'
+
+describe ActiveProjection::ProjectionRepository do
+  before :all do
+    5.times do |i|
+      FactoryGirl.create :projection, id: i, class_name: "TestProjection#{i}"
+    end
+  end
+  describe 'create_or_get' do
+    it 'creates a projection, if classname is not present' do
+      expect(ActiveProjection::ProjectionRepository.create_or_get('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::Projection.all.to_a.length).to eq 5
+    end
+  end
+  describe 'broken' do
+    it 'sets solid to false' do
+      ActiveProjection::ProjectionRepository.set_broken 0
+      expect(ActiveProjection::Projection.where(id:0).first.solid).to be_false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'active_projection'

data/spec/support/active_record.rb

@@ -0,0 +1,38 @@
+
+require 'active_record'
+
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+
+ActiveRecord::Migrator.up 'db/migrate'
+
+module ActiveModel::Validations
+  # Extension to enhance `should have` on AR Model instances.  Calls
+  # model.valid? in order to prepare the object's errors object.
+  #
+  # You can also use this to specify the content of the error messages.
+  #
+  # @example
+  #
+  #     model.should have(:no).errors_on(:attribute)
+  #     model.should have(1).error_on(:attribute)
+  #     model.should have(n).errors_on(:attribute)
+  #
+  #     model.errors_on(:attribute).should include("can't be blank")
+  def errors_on(attribute)
+    self.valid?
+    [self.errors[attribute]].flatten.compact
+  end
+  alias :error_on :errors_on
+end
+
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end
+
+require 'factory_girl'
+FactoryGirl.find_definitions

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification
+name: active_projection
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andreas Reischuck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_event
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Projection environment for rails-disco
+email: andreas.reischuck@hicknhack-software.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/models/active_projection/projection.rb
+- app/models/active_projection/projection_repository.rb
+- db/migrate/01_create_projections.rb
+- lib/active_projection/autoload.rb
+- lib/active_projection/event_client.rb
+- lib/active_projection/projection_type.rb
+- lib/active_projection/projection_type_registry.rb
+- lib/active_projection/railtie.rb
+- lib/active_projection/server.rb
+- lib/active_projection/version.rb
+- lib/active_projection.rb
+- README.md
+- MIT-LICENSE
+- spec/factories/event_factory.rb
+- spec/lib/projection_type_registry_spec.rb
+- spec/lib/projecton_type_spec.rb
+- spec/models/projection_repository_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+homepage: https://github.com/hicknhack-software/rails-disco
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: Projection related stuff (part of rails-disco)
+test_files:
+- spec/factories/event_factory.rb
+- spec/lib/projection_type_registry_spec.rb
+- spec/lib/projecton_type_spec.rb
+- spec/models/projection_repository_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb