sandthorn_sequel_projection 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d9e616e9522822b606892aacf8e5b123747b90c7
+  data.tar.gz: 1655704ac3c4573906381d6aa3186df2f3ac7a02
+SHA512:
+  metadata.gz: 8ac17d0d63990bd20f59e1bae9e79a61938796c03ea5446938a0fc2e3691d5ca4fa67f980458dd136668819a7dde801e472c3296c92bb553eff8cde279626519
+  data.tar.gz: 539c42725038075dc4f094d125ddf818a31cd4cc15ad3c20def9e7838ecab8e296bd964ffea61733a487ddac3a922ecdb767a3d30efe891c09fc8073225b9ba6

data/.autotest

@@ -0,0 +1,3 @@
+Autotest.add_hook :initialize do |at|
+    %w{.git spec/db}.each {|exception| at.add_exception(exception)}
+end

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+sandthorn_sequel_projection

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0
+addons:
+  codeclimate:
+    repo_token: d57433c34e6540ec1ede44f03df0843c49e8f9b83bdf6ce7a767e9be0c9c6fd7
+after_script:
+  - cat lcov.info | codeclimate

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sandthorn_sequel_projection.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Lars Krantz
+
+MIT License
+
+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,130 @@
+# SandthornSequelProjection
+
+A DSL and some convenience utilities for creating projections based on event data.
+Uses the Sequel gem for storage.
+ 
+Main points:
+
+- DSL for registering event handlers that listen to filtered event streams
+- Event handlers receive one event at a time
+- Planned: projection manifests are used to declare dependent projections. This information can be used to execute
+  non-dependent projections in parallel
+
+Requirements on event handling:
+
+- It must be possible to define event handlers such that the execution order is defined
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sandthorn_sequel_projection'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sandthorn_sequel_projection
+
+## Usage
+
+### 1. Configure
+
+The default configuration expects that the Sandthorn gem is present and uses it to fetch events.
+
+SandthornSequelProjection uses Sequel to connected to a database. Configure it like this:
+
+    SandthornSequelProjection.configure do |thorn|
+      thorn.db_connection = Sequel.sqlite
+    end
+    
+### 2. Define projections
+
+    class MyProjection < SandthornSequelProjection::Projection
+
+      # Start by defining any needed migrations.
+      # See SimpleMigrator::Migratable for details
+      migration("MyProjection20150215-1") do |db_connection|
+        db_connection.create_table?(:my_table) do
+          primary_key :id
+        end
+      end
+      
+      # Event handlers will be executed in the order they were defined
+      # The key is the name of the method to be executed. Filters are defined in the value.
+      # Handlers with only a symbol will execute for all events.
+      define_event_handlers do |handlers|
+        handlers.add new_user: { aggregate_type: MyAggregates::User, event_name: :new }
+        handlers.add foo_changed: { aggregate_types: [MyAggregates::User, MyAggregates::Foo] }
+        handlers.add :wildcard
+      end 
+        
+      def new_users(event)
+        # handle new user events, one at a time
+      end
+      
+      def foo_changed(event)
+        # handle the events defined in the foo_changed-listener, one at a time
+      end
+      
+      def wildcard(event)
+        # Will receive all events
+      end
+    end
+
+### 3. Create a manifest
+
+Manifests are used to define the order in which projections are run.
+
+    manifest = SandthornSequelProjections::Manifest.create
+      [
+        MyProjection,
+        MyProjections::SomeOtherProjection
+      ]
+  
+### 4. Run the projections
+
+Create a runner and give it the manifest. Run your projections.
+
+    runner = SandthornSequelProjection::Runner.new(manifest)
+    runner.run
+    
+The runner runs migrations for all of the projections and then 
+polls the event store for changes and passes new events to the projections.
+
+## Plans for the future
+
+The projection manifest should define dependent projections, similar to how Rake tasks are defined.
+In this way, we could identify the most efficient way of splitting up projections over multiple 
+threads.
+
+For example:
+
+    SandthornSequelProjection.manifest do
+      projection my_dependent_projection: [:projection_foo, :projection_bar]
+      projection my_other_dependent_projection: [:my_dependent_projection, :projection_bar]
+      projection my_third_dependent_projection: :projection_qux
+    end
+
+This manifest would create two independent branches:
+
+    :projection_foo               :projection_bar               :projection_qux
+              \                     /                                   |
+             :my_dependent_projection                          :my_third_dependent_projection
+                         |
+                         |
+           :my_other_dependent_projection
+       
+       
+       
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/sandthorn_sequel_projection/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+task :console do
+  require 'awesome_print'
+  require 'pry'
+  require 'bundler'
+  require 'sandthorn_sequel_projection'
+  ARGV.clear
+  Pry.start
+end

data/lib/sandthorn_sequel_projection.rb

@@ -0,0 +1,57 @@
+require "sequel"
+require "sandthorn_event_filter"
+require "simple_migrator"
+require "sandthorn"
+
+require "sandthorn_sequel_projection/errors"
+require "sandthorn_sequel_projection/version"
+require "sandthorn_sequel_projection/utilities"
+require "sandthorn_sequel_projection/cursor"
+require "sandthorn_sequel_projection/event_handler"
+require "sandthorn_sequel_projection/event_handler_collection"
+require "sandthorn_sequel_projection/projection"
+require "sandthorn_sequel_projection/lock"
+require "sandthorn_sequel_projection/processed_events_tracker"
+require "sandthorn_sequel_projection/manifest"
+require "sandthorn_sequel_projection/runner"
+
+module SandthornSequelProjection
+
+  class << self
+    require 'delegate'
+    extend Forwardable
+
+    def_delegators :configuration, :batch_size, :event_stores
+
+    attr_accessor :configuration
+
+    def configure
+      @configuration ||= Configuration.default
+      yield(configuration) if block_given?
+      start
+    end
+
+    def start
+      ProcessedEventsTracker.migrate!(configuration.db_connection)
+    end
+
+    def find_event_store(name)
+      Sandthorn.find_event_store(name)
+    end
+  end
+
+  class Configuration
+
+    attr_accessor :db_connection, :event_stores, :projections_folder, :batch_size
+
+    def initialize
+      yield(self) if block_given?
+    end
+
+    def self.default
+      self.new do |c|
+        c.batch_size = 40
+      end
+    end
+  end
+end

data/lib/sandthorn_sequel_projection/cursor.rb

@@ -0,0 +1,39 @@
+module SandthornSequelProjection
+  class Cursor
+
+    attr_reader :last_sequence_number, :batch_size
+
+    def initialize(
+        after_sequence_number: 0,
+        event_store: SandthornSequelProjection.default_event_store,
+        batch_size: SandthornSequelProjection.batch_size)
+      @last_sequence_number = after_sequence_number
+      @batch_size = batch_size
+      @event_store = event_store
+    end
+
+    def get_batch
+      events = get_events
+      events.tap do |events|
+        if last_event = events.last
+          @last_sequence_number = last_event[:sequence_number]
+        end
+      end
+    end
+
+  private
+    
+    def get_events
+      wrap(get_event_array)
+    end
+
+    def wrap(events)
+      SandthornEventFilter.filter(events)
+    end
+
+    def get_event_array
+      @event_store.get_events(after_sequence_number: last_sequence_number, take: batch_size)
+    end
+
+  end
+end

data/lib/sandthorn_sequel_projection/errors.rb

@@ -0,0 +1,14 @@
+module SandthornSequelProjection
+
+  class SandthornSequelProjectionError < StandardError; end
+
+  class MigrationError < SandthornSequelProjectionError
+    def initialize(error)
+      super(error.message)
+      @error = error
+    end
+  end
+
+  class InvalidEventStoreError < SandthornSequelProjectionError; end
+
+end

data/lib/sandthorn_sequel_projection/event_handler.rb

@@ -0,0 +1,49 @@
+module SandthornSequelProjection
+  class EventHandler
+
+    attr_reader :projection, :filter, :message
+
+    def initialize(options)
+      @filter = SandthornEventFilter::Filter.new
+      parse_options(options)
+    end
+
+    def handle(target, event)
+      if filter.match?(event)
+        call_handler(target, event)
+      end
+    end
+
+  private
+
+    def parse_options(options)
+      if options.is_a? Symbol
+        set_method(options)
+      elsif options.is_a? Hash
+        method_name = options.keys.first
+        set_method(method_name)
+        construct_filter(options[method_name])
+      end
+    end
+
+    def call_handler(target, event)
+      target.send(message, event)
+    end
+
+    def construct_filter(options)
+      types, event_names = extract_filter_options(options)
+      @filter = @filter.extract(types: types) if types.any?
+      @filter = @filter.extract(events: event_names) if types.any?
+    end
+
+    def extract_filter_options(options)
+      types   = Array.wrap(options[:aggregate_type] || options[:aggregate_types])
+      events  = Array.wrap(options[:event_name] || options[:event_names])
+      [types, events]
+    end
+
+    def set_method(message)
+      @message = message
+    end
+  end
+end

data/lib/sandthorn_sequel_projection/event_handler_collection.rb

@@ -0,0 +1,27 @@
+require "forwardable"
+
+module SandthornSequelProjection
+  class EventHandlerCollection
+    extend Forwardable
+    def_delegators :handlers, :length, :each, :first
+
+    attr_reader :handlers
+
+    def initialize
+      @handlers = Set.new
+    end
+
+    def define(handler_data)
+      @handlers << EventHandler.new(handler_data)
+    end
+
+    def handle(projection, events)
+      events.each do |event|
+        handlers.each do |handler|
+          handler.handle(projection, event)
+        end
+      end
+    end
+
+  end
+end

data/lib/sandthorn_sequel_projection/lock.rb

@@ -0,0 +1,83 @@
+require 'forwardable'
+module SandthornSequelProjection
+  class Lock
+    extend Forwardable
+
+    attr_reader :db_connection, :identifier
+
+    def_delegators :db_connection, :transaction
+
+    DEFAULT_TIMEOUT = 3*60 # 3 minutes
+    DEFAULT_LOCK_COLUMN = :locked_at
+
+    def initialize(identifier, db_connection = nil, table_name = nil)
+      @identifier     = identifier.to_s
+      @db_connection  = db_connection || SandthornDriverSequel.configuration.db_connection
+      @table_name     = table_name || ProcessedEventsTracker::DEFAULT_TABLE_NAME
+    end
+
+    def locked?
+      !unlocked?
+    end
+
+    def unlocked?
+      locked_at.nil?
+    end
+
+    def expired?
+      locked_at && (Time.now - locked_at > timeout)
+    end
+
+    def timeout
+      DEFAULT_TIMEOUT
+    end
+
+    def acquire
+      if attempt_lock
+        begin
+          yield
+        ensure
+          release
+        end
+      end
+    end
+
+    def release
+      set_lock(nil)
+    end
+
+    def attempt_lock
+      transaction do
+        if unlocked? || expired?
+          lock
+        end
+      end
+    end
+
+    def lock_column_name
+      DEFAULT_LOCK_COLUMN
+    end
+
+    def lock
+      set_lock(Time.now)
+    end
+
+    def db_row
+      table.where(identifier: @identifier)
+    end
+
+    def table
+      db_connection[@table_name]
+    end
+
+    def set_lock(value)
+      db_row.update(lock_column_name => value)
+    end
+
+    def locked_at
+      if row = db_row.first
+        row[lock_column_name]
+      end
+    end
+  end
+end