eventus 0.2.0 → 0.3.0

data/.gitignore

@@ -4,3 +4,4 @@ Gemfile.lock
 pkg/*
 *.swp
 vendor/bundle
+tags

data/Guardfile

@@ -1,4 +1,4 @@
-guard 'rspec', :version => 2 do
+guard 'rspec', :cli => '--color', :version => 2 do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }

data/lib/eventus/aggregate_root.rb

@@ -3,7 +3,7 @@ module Eventus
     module ClassMethods
       def find(id)
         instance = self.new
-        stream = Eventus::Stream.new(id, persistence)
+        stream = Eventus::Stream.new(id, persistence, Eventus.dispatcher)
         instance.populate(stream)
         instance
       end
@@ -36,7 +36,7 @@ module Eventus
         method_name = "apply_#{name}"
         self.send method_name, body if self.respond_to?(method_name)
 
-        @stream.add({:name => name, :body => body}) if is_new
+        @stream.add(name, body) if is_new
       end
     end
 

data/lib/eventus/dispatchers/synchronous.rb

@@ -0,0 +1,19 @@
+module Eventus
+  module Dispatchers
+    class Synchronous
+      attr_accessor :action
+
+      def initialize(persistence, &block)
+        @persistence = persistence
+        @action = block || lambda {}
+      end
+
+      def dispatch(events)
+        events.each do |e|
+          @action.call(e)
+          @persistence.mark_dispatched e
+        end
+      end
+    end
+  end
+end

data/lib/eventus/dispatchers.rb

@@ -0,0 +1,5 @@
+module Eventus
+  module Dispatchers
+    autoload :Synchronous, 'eventus/dispatchers/synchronous'
+  end
+end

data/lib/eventus/errors.rb

@@ -1,3 +1,4 @@
 module Eventus
   class ConcurrencyError < ::StandardError; end
+  class ConnectionError  < ::StandardError; end
 end

data/lib/eventus/persistence/in_memory.rb

@@ -8,11 +8,11 @@ module Eventus
         @mutex = Mutex.new
       end
 
-      def commit(id, start, events)
+      def commit(events)
         @mutex.synchronize do
           pending = {}
-          events.each_with_index do |event, index|
-            key = build_key(id, start + index)
+          events.each do |event|
+            key = build_key(event['sid'], event['sequence'])
             raise Eventus::ConcurrencyError if @store.include? key
             value = @serializer.serialize(event)
             pending[key] = value
@@ -34,6 +34,23 @@ module Eventus
         end
       end
 
+      def load_undispatched
+        @mutex.synchronize do
+          @store.map { |k,v| @serializer.deserialize(v) }
+                .reject { |e| e['dispatched'] || e[:dispatched] }
+        end
+      end
+
+      def mark_dispatched(stream_id, sequence)
+        key = build_key(stream_id, sequence)
+        value = @store[key]
+        return unless value
+        event = @serializer.deserialize(value)
+        event['dispatched'] = true
+        obj = @serializer.serialize(event)
+        @store[key] = obj
+      end
+
       def build_key(id, index)
         id + ("_%07d" % index)
       end

data/lib/eventus/persistence/kyotocabinet.rb

@@ -6,17 +6,21 @@ module Eventus
 
       def initialize(options = {})
         @db = ::KyotoCabinet::DB::new
-        @db.open(options[:path], ::KyotoCabinet::DB::OCREATE)
-        @serializer = options.fetch(:serializer) { Eventus::Serializers::Marshal }
+        @queue = ::KyotoCabinet::DB::new
+        @serializer = options.delete(:serializer) || Eventus::Serializers::Marshal
+        queue_con = build_connection(:path => options.delete(:queue_path) || '*')
+        con = build_connection(options)
+        raise Eventus::ConnectionError unless @db.open(con) && @queue.open(queue_con)
       end
 
-      def commit(id, start, events)
-        pid = pack_hex(id)
+      def commit(events)
         @db.transaction do
-          events.each_with_index do |event, index|
-            key = build_key(pid, start + index)
+          events.each do |event, index|
+            pid = pack_hex(event['sid'])
+            key = build_key(pid, event['sequence'])
             value = @serializer.serialize(event)
             raise Eventus::ConcurrencyError unless @db.add(key,value)
+            @queue.set(key, "")
           end
         end
       end
@@ -33,6 +37,22 @@ module Eventus
         @db.get_bulk(keys, false).values.map { |obj| @serializer.deserialize(obj) }
       end
 
+      def load_undispatched
+        events = []
+        @queue.each_key do |key|
+          value = @db.get(key[0])
+          next unless value
+          obj = @serializer.deserialize(value)
+          events << obj
+        end
+        events
+      end
+
+      def mark_dispatched(stream_id, sequence)
+        key = build_key(pack_hex(stream_id), sequence)
+        @queue.remove(key)
+      end
+
       def pack_hex(id)
         id.match(/^[0-9a-fA-F]+$/) ? [id].pack('H*') : id
       end
@@ -40,6 +60,24 @@ module Eventus
       def build_key(id, index)
         id + ("_%07d" % index)
       end
+
+      def close
+        @db.close
+        @queue.close
+      end
+
+      private
+
+      def build_connection(options)
+        opts = {
+          :path => '%', #in-memory tree
+          :opts => :linear
+        }.merge!(options)
+
+        path = opts.delete(:path)
+
+        opts.reduce(path) { |memo, kvp| memo << "##{kvp[0]}=#{kvp[1]}" }
+      end
     end
   end
 end

data/lib/eventus/stream.rb

@@ -1,25 +1,33 @@
+require 'time'
+
 module Eventus
   class Stream
 
     attr_reader :id, :committed_events, :uncommitted_events
 
-    def initialize(id, persistence)
+    def initialize(id, persistence, dispatcher)
       @id = id
       @persistence = persistence
       @committed_events = []
       @uncommitted_events = []
+      @dispatcher = dispatcher
       load_events @persistence.load(id)
     end
 
-    def add(event)
-      @uncommitted_events << event
+    def add(name, body={})
+      @uncommitted_events << {'name' => name, 'body' => body}
     end
 
-    alias_method :<<, :add
-
     def commit
-      @persistence.commit @id, version, @uncommitted_events
+      time = Time.now.utc.iso8601
+      @uncommitted_events.each.with_index(version) do |e, i|
+        e['time'] = time
+        e['sid'] = @id
+        e['sequence'] = i
+      end
+      @persistence.commit @uncommitted_events
       load_events @uncommitted_events
+      @dispatcher.dispatch @uncommitted_events if @dispatcher
       @uncommitted_events.clear
     rescue ConcurrencyError => e
       load_events @persistence.load(id, version + 1)

data/lib/eventus/version.rb

@@ -1,3 +1,3 @@
 module Eventus
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/eventus.rb

@@ -1,6 +1,9 @@
 module Eventus
   autoload :Serializers, 'eventus/serializers'
   autoload :AggregateRoot, 'eventus/aggregate_root'
+  autoload :Dispatchers, 'eventus/dispatchers'
+  autoload :Persistence, 'eventus/persistence'
+  autoload :VERSION, 'eventus/version'
 
   class << self
 
@@ -11,7 +14,15 @@ module Eventus
     def persistence=(val)
       @persistence = val
     end
+
+    def dispatcher
+      @dispatcher ||= Eventus::Dispatchers::Synchronous.new(persistence)
+    end
+
+    def dispatcher=(val)
+      @dispatcher = val
+    end
   end
 end
 
-%w{store stream version persistence errors}.each { |r| require "eventus/#{r}" }
+%w{stream errors}.each { |r| require "eventus/#{r}" }

data/spec/dispatchers/synchronous_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Eventus::Dispatchers::Synchronous do
+  let(:persistence){ stub.as_null_object }
+  let(:dispatcher) { Eventus::Dispatchers::Synchronous.new(persistence) { @hit = true } }
+
+  before do
+    persistence.should_receive(:mark_dispatched)
+    dispatcher.dispatch([stub])
+  end
+
+  it "should invoke block" do
+    @hit.should == true
+  end
+end

data/spec/persistence/in_memory_spec.rb

@@ -8,10 +8,11 @@ describe Eventus::Persistence::InMemory do
   it "should store complex objects" do
     id = uuid.generate :compact
     o = {'a' => 'super', 'complex' => ['object', 'with', {'nested' => ['members', 'galore', 1]}]}
-    persistence.commit id, 1, [o]
+    commit = create_commit(id, 1, o)
+    persistence.commit(commit)
 
     result = persistence.load id
-    result[0].should == o
+    result[0].should == commit[0]
   end
 
   it "should return no events when key not found" do
@@ -21,22 +22,22 @@ describe Eventus::Persistence::InMemory do
 
   it "should return events ordered" do
     id = uuid.generate :compact
-    persistence.commit id, 5, ["five", "six"]
-    persistence.commit id, 1, ["one", "two"]
-    persistence.commit id, 3, ["three", "four"]
-    persistence.commit "other", 1, ["cake", "batter"]
+    persistence.commit create_commit(id, 5, "five", "six")
+    persistence.commit create_commit(id, 1, "one", "two")
+    persistence.commit create_commit(id, 3, "three", "four")
+    persistence.commit create_commit("other", 1, "cake", "batter")
 
     result = persistence.load id
-    result.should == ["one", "two", "three", "four", "five", "six"]
+    result.map{|r| r['body']}.should == ["one", "two", "three", "four", "five", "six"]
   end
 
   describe "when events exist" do
     let(:id) { uuid.generate :compact }
-    let(:events) { (1..20).map {|i| "Body #{i}"} }
+    let(:events) { create_commit(id, 1, *(1..20)).each_with_index {|e,i| e['dispatched'] = i.even? } }
     before do
-      persistence.commit id, 1, events
-      other_events = (1..60).map {|i| "Other #{i}"}
-      persistence.commit uuid.generate(:compact), 1, events
+      persistence.commit events
+      other_events = create_commit("other", 1, *(1..60)).each_with_index {|e,i| e['dispatched'] = i.even? }
+      persistence.commit other_events
     end
 
     it "should load events" do
@@ -44,12 +45,26 @@ describe Eventus::Persistence::InMemory do
       result.length.should == 20
     end
 
+    it "should load undispatched events" do
+      result = persistence.load_undispatched
+      result.length.should == 40
+    end
+
+    it "should mark an event as dispatched" do
+      result = persistence.load_undispatched[0]
+      persistence.mark_dispatched(result['sid'], result['sequence'])
+      persistence.load_undispatched.include?(result).should be_false
+    end
+
     it "should throw concurrency exception if the same event number is added" do
-      lambda {persistence.commit id, 3, ["This is taken"]}.should raise_error(Eventus::ConcurrencyError)
+      lambda {persistence.commit create_commit(id, 3, "This is taken")}.should raise_error(Eventus::ConcurrencyError)
     end
 
     it "should rollback changes on concurrency error" do
-      persistence.commit id, 3, ["first", "second", "third"] rescue nil
+      begin
+        persistence.commit create_commit(id, 3, "first", "second", "third")
+      rescue Eventus::ConcurrencyError
+      end
 
       result = persistence.load id
       result.length.should == 20
@@ -70,13 +85,14 @@ describe Eventus::Persistence::InMemory do
     it "should use serializer" do
       input = "original"
       ser = "i'm serialized!"
+      id = uuid.generate :compact
+      commit = create_commit(id, 1, input)
 
-      serializer.should_receive(:serialize).with(input).and_return(ser)
+      serializer.should_receive(:serialize).with(commit[0]).and_return(ser)
       serializer.should_receive(:deserialize).with(ser).and_return(input)
 
-      id = uuid.generate :compact
 
-      persistence.commit id, 1, [input]
+      persistence.commit commit
       result = persistence.load id
       result[0].should == input
     end

data/spec/persistence/kyotocabinet_spec.rb

@@ -1,10 +1,13 @@
 require 'spec_helper'
 
 describe Eventus::Persistence::KyotoCabinet do
-  let(:options) { {:path => '%'} }
-  let(:persistence) { Eventus::Persistence::KyotoCabinet.new(options) }
+  let(:persistence) { @persistence }
   let(:uuid) { UUID.new }
 
+  before(:all) do
+    @persistence = Eventus::Persistence::KyotoCabinet.new
+  end
+
   it "should pack keys" do
     1000.times do
       key = uuid.generate(:compact)
@@ -22,10 +25,11 @@ describe Eventus::Persistence::KyotoCabinet do
   it "should store complex objects" do
     id = uuid.generate :compact
     o = {'a' => 'super', 'complex' => ['object', 'with', {'nested' => ['members', 'galore', 1]}]}
-    persistence.commit id, 1, [o]
+    commit = create_commit(id, 1, o)
+    persistence.commit(commit)
 
     result = persistence.load id
-    result[0].should == o
+    result[0].should == commit[0]
   end
 
   it "should return no events when key not found" do
@@ -35,64 +39,77 @@ describe Eventus::Persistence::KyotoCabinet do
 
   it "should return events ordered" do
     id = uuid.generate :compact
-    persistence.commit id, 5, ["five", "six"]
-    persistence.commit id, 1, ["one", "two"]
-    persistence.commit id, 3, ["three", "four"]
-    persistence.commit "other", 1, ["cake", "batter"]
+    persistence.commit create_commit(id, 5, "five", "six")
+    persistence.commit create_commit(id, 1, "one", "two")
+    persistence.commit create_commit(id, 3, "three", "four")
+    persistence.commit create_commit(uuid.generate, 1, "cake", "batter")
 
     result = persistence.load id
-    result.should == ["one", "two", "three", "four", "five", "six"]
+    result.map{|r| r['body']}.should == ["one", "two", "three", "four", "five", "six"]
   end
 
   describe "when events exist" do
     let(:id) { uuid.generate :compact }
-    let(:events) { (1..20).map {|i| "Body #{i}"} }
+    let(:events) { create_commit(id, 1, *(1..200)) }
     before do
-      persistence.commit id, 1, events
-      other_events = (1..60).map {|i| "Other #{i}"}
-      persistence.commit uuid.generate(:compact), 1, events
+      persistence.commit events
+      other_events = create_commit(uuid.generate(:compact), 1, (1..10))
+      persistence.commit other_events
     end
 
     it "should load events" do
       result = persistence.load id
-      result.length.should == 20
+      result.length.should == events.length
+    end
+
+    it "should load undispatched events" do
+      result = persistence.load_undispatched
+    end
+
+    it "should mark an event as dispatched" do
+      result = persistence.load_undispatched[0]
+      persistence.mark_dispatched(result['sid'], result['sequence'])
+      persistence.load_undispatched.include?(result).should be_false
     end
 
     it "should throw concurrency exception if the same event number is added" do
-      lambda {persistence.commit id, 3, ["This is taken"]}.should raise_error(Eventus::ConcurrencyError)
+      lambda {persistence.commit create_commit(id, 3, "This is taken")}.should raise_error(Eventus::ConcurrencyError)
     end
 
     it "should rollback changes on concurrency error" do
-      persistence.commit id, 3, ["first", "second", "third"] rescue nil
+      begin
+      persistence.commit create_commit(id, 3, "first", "second", "third") 
+      rescue Eventus::ConcurrencyError
+      end
 
       result = persistence.load id
-      result.length.should == 20
+      result.should == events
     end
 
     it "should load all events from a minimum" do
       result = persistence.load id, 10
-      result.length.should == 11
+      result.should == events.select {|e| e['sequence'] >= 10}
     end
   end
 
   describe "when serialization is set" do
     let(:serializer) { stub }
-    before do
-      options[:serializer] = serializer
-    end
+    let(:persistence) { Eventus::Persistence::KyotoCabinet.new(:path => '%', :serializer => serializer) }
 
     it "should use serializer" do
-      input = "original"
-      ser = "i'm serialized!"
+      input = {:name => 'event'}
+      ser = "serialized!!"
+      id = uuid.generate :compact
+      commit = create_commit(id, 1, input)
 
-      serializer.should_receive(:serialize).with(input).and_return(ser)
+      serializer.should_receive(:serialize).with(commit[0]).and_return(ser)
       serializer.should_receive(:deserialize).with(ser).and_return(input)
 
-      id = uuid.generate :compact
 
-      persistence.commit id, 1, [input]
+      persistence.commit commit
       result = persistence.load id
       result[0].should == input
     end
   end
 end
+

data/spec/spec_helper.rb

@@ -11,3 +11,18 @@ Dir[File.join(File.dirname(__FILE__), 'support', '*.rb')].each { |d| require d }
 RSpec.configure do |config|
   config.mock_with :rspec
 end
+
+def create_commit(id, start, *bodies)
+  if bodies[0].is_a? Range
+    bodies = bodies[0]
+  end
+  bodies.each.with_index(start).map do |b, i|
+    {
+      'name' => 'cereal',
+      'body' => b,
+      'time' => Time.now.utc.iso8601,
+      'sid' => id,
+      'sequence' => i
+    }
+  end
+end

data/spec/stream_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 describe Eventus::Stream do
   let(:id) { UUID.generate(:compact) }
-  let(:stream) { Eventus::Stream.new(id, persistence) }
+  let(:stream) { Eventus::Stream.new(id, persistence, dispatcher) }
   let(:persistence) { stub(:persistence).as_null_object }
+  let(:dispatcher) { stub(:dispatcher).as_null_object }
 
   it "should use id" do
     stream.id.should == id
@@ -33,8 +34,8 @@ describe Eventus::Stream do
 
   describe "when events added" do
     before do
-      stream << stub
-      stream.add stub
+      stream.add "french"
+      stream.add "bread"
     end
 
     it "should have uncommitted events" do
@@ -44,9 +45,22 @@ describe Eventus::Stream do
     describe "when committed" do
       before do
         persistence.should_receive(:commit)
+        dispatcher.should_receive(:dispatch)
         stream.commit
       end
 
+      it "should have timestamp on committed events" do
+        stream.committed_events.all?{ |e| e['time'] }.should == true
+      end
+
+      it "should have stream id on committed events" do
+        stream.committed_events.all?{ |e| e['sid'] }.should == true
+      end
+
+      it "should have sequence id on committed events" do
+        stream.committed_events.all?{ |e| e['sequence'] }.should == true
+      end
+
       it "should have committed events" do
         stream.version.should == 2
       end
@@ -60,7 +74,7 @@ describe Eventus::Stream do
   describe "when a concurrency error occurs" do
     before do
       persistence.should_receive(:commit).and_raise(Eventus::ConcurrencyError)
-      stream << stub(:event)
+      stream.add "butter"
     end
 
     it "should reraise concurrency error" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventus
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-09 00:00:00.000000000Z
+date: 2012-01-13 00:00:00.000000000Z
 dependencies: []
 description: An Event Store
 email:
@@ -26,6 +26,8 @@ files:
 - eventus.gemspec
 - lib/eventus.rb
 - lib/eventus/aggregate_root.rb
+- lib/eventus/dispatchers.rb
+- lib/eventus/dispatchers/synchronous.rb
 - lib/eventus/errors.rb
 - lib/eventus/persistence.rb
 - lib/eventus/persistence/in_memory.rb
@@ -33,14 +35,13 @@ files:
 - lib/eventus/serializers.rb
 - lib/eventus/serializers/marshal.rb
 - lib/eventus/serializers/msgpack.rb
-- lib/eventus/store.rb
 - lib/eventus/stream.rb
 - lib/eventus/version.rb
 - spec/aggregate_root_spec.rb
+- spec/dispatchers/synchronous_spec.rb
 - spec/persistence/in_memory_spec.rb
 - spec/persistence/kyotocabinet_spec.rb
 - spec/spec_helper.rb
-- spec/store_spec.rb
 - spec/stream_spec.rb
 homepage: ''
 licenses: []
@@ -56,7 +57,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3611850257360750717
+      hash: 3251011933680470651
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -65,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3611850257360750717
+      hash: 3251011933680470651
 requirements: []
 rubyforge_project: eventus
 rubygems_version: 1.8.13
@@ -74,8 +75,8 @@ specification_version: 3
 summary: Event Store
 test_files:
 - spec/aggregate_root_spec.rb
+- spec/dispatchers/synchronous_spec.rb
 - spec/persistence/in_memory_spec.rb
 - spec/persistence/kyotocabinet_spec.rb
 - spec/spec_helper.rb
-- spec/store_spec.rb
 - spec/stream_spec.rb

data/lib/eventus/store.rb

@@ -1,12 +0,0 @@
-module Eventus
-  class Store
-
-    def initialize(persistence)
-      @persistence = persistence
-    end
-
-    def open id
-      @persistence.get_events(id)
-    end
-  end
-end

data/spec/store_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Eventus::Store do
-  let(:persistence) { stub(:persistence).as_null_object }
-  let(:store) { Eventus::Store.new(persistence) }
-  let(:uuid) { UUID.new }
-  let(:stream) { stub(:stream) }
-
-  describe "when opening an event stream" do
-    let(:id) { uuid.generate(:compact) }
-    let(:result) { store.open id }
-
-    it "should request from persistence" do
-      persistence.should_receive(:get_events)
-      result
-    end
-
-    it "should return a stream" do
-      result.should_not be_nil
-    end
-  end
-end