euston-eventstore 1.0.2-java

data/lib/euston-eventstore/persistence/mongodb/mongo_config.rb

@@ -0,0 +1,28 @@
+require 'singleton'
+
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        class Config
+          include ::Singleton
+
+          def host
+            @host ||= 'localhost'
+          end
+
+          def port
+            @port ||= 27017
+          end
+
+          def options
+            @options ||= { :safe => { :fsync => true }}
+          end
+
+          attr_writer :host, :port, :options
+          attr_accessor :database, :logger
+        end
+      end
+    end
+  end
+end

data/lib/euston-eventstore/persistence/mongodb/mongo_event_message.rb

@@ -0,0 +1,31 @@
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        module MongoEventMessage
+          extend ::ActiveSupport::Concern
+
+          class << self
+            def from_hash(hash)
+              {}.recursive_symbolize_keys!
+              message = EventMessage.new hash['body'].recursive_symbolize_keys!
+              message.instance_variable_set :@headers, hash['headers'].recursive_symbolize_keys!
+              message
+            end
+          end
+
+          def to_hash
+            {
+              :headers => headers,
+              :body => body.to_hash.recursive_stringify_symbol_values!
+            }
+          end
+        end
+      end
+    end
+
+    class EventMessage
+      include Persistence::Mongodb::MongoEventMessage
+    end
+  end
+end

data/lib/euston-eventstore/persistence/mongodb/mongo_persistence_engine.rb

@@ -0,0 +1,167 @@
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        class MongoPersistenceEngine
+          def initialize(store)
+            @store = store
+
+            collection_names = store.collection_names
+            store.create_collection 'commits'  unless collection_names.include? 'commits'    # :safe = true
+            store.create_collection 'snapshot' unless collection_names.include? 'snapshot'   # :safe = false
+            store.create_collection 'streams'  unless collection_names.include? 'streams'    # :safe = false
+          end
+
+          def add_snapshot(snapshot)
+            return false if snapshot.nil?
+
+            begin
+              mongo_snapshot = snapshot.is_a?(Hash) ? snapshot : snapshot.to_hash
+              id = { '_id' => mongo_snapshot[:_id] }
+
+              persisted_snapshots.update(id, { 'payload' => mongo_snapshot[:payload] }.merge(id), { :upsert => true })
+
+              # jmongo's find_one is broken
+              if defined?(JMongo)
+                stream_head = MongoStreamHead.from_hash persisted_stream_heads.find({ '_id' => snapshot.stream_id }).to_a.first
+              else
+                stream_head = MongoStreamHead.from_hash persisted_stream_heads.find_one({ '_id' => snapshot.stream_id })
+              end
+
+              unsnapshotted = stream_head.head_revision - snapshot.stream_revision
+              persisted_stream_heads.update({ '_id' => snapshot.stream_id },
+                                            { '$set' => { 'snapshot_revision' => snapshot.stream_revision, 'unsnapshotted' => unsnapshotted } })
+              return true
+            rescue Mongo::OperationFailure
+              return false
+            end
+          end
+
+          def commit(attempt)
+            try_mongo do
+              commit = attempt.to_mongo_commit
+
+              begin
+                # for concurrency / duplicate commit detection safe mode is required
+                persisted_commits.insert commit, :safe => true
+                update_stream_head_async attempt.stream_id, attempt.stream_revision, attempt.events.length
+              rescue Mongo::OperationFailure, NativeException => e
+                raise(Euston::EventStore::StorageError, e.message, e.backtrace) unless e.message.include? CONCURRENCY_EXCEPTION
+
+                # jmongo's find_one is broken
+                if defined?(JMongo)
+                  committed = persisted_commits.find(attempt.to_id_query).to_a.first
+                else
+                  committed = persisted_commits.find_one(attempt.to_id_query)
+                end
+
+                raise Euston::EventStore::DuplicateCommitError if !committed.nil? && committed['commit_id'] == attempt.commit_id
+                raise Euston::EventStore::ConcurrencyError
+              end
+            end
+          end
+
+          def get_from(options)
+            try_mongo do
+              if options.has_key? :timestamp
+                query = { 'commit_timestamp' => { '$gte' => options[:timestamp].to_f } }
+                order = [ 'commit_timestamp', Mongo::ASCENDING ]
+              else
+                query = { '_id.stream_id' => options[:stream_id],
+                          'events.stream_revision' => { '$gte' => options[:min_revision], '$lte' => options[:max_revision] } }
+
+                order = [ 'events.stream_revision', Mongo::ASCENDING ]
+              end
+
+              persisted_commits.find(query).sort(order).to_a.map { |hash| MongoCommit.from_hash hash }
+            end
+          end
+
+          def get_snapshot(stream_id, max_revision)
+            try_mongo do
+              query = { '_id' => {  '$gt' => { 'stream_id' => stream_id, 'stream_revision' => nil },
+                                   '$lte' => { 'stream_id' => stream_id, 'stream_revision' => max_revision } } }
+              order = [ '_id', Mongo::DESCENDING ]
+
+              persisted_snapshots.find(query).sort(order).limit(1).to_a.map { |hash| MongoSnapshot::from_hash hash }.first
+            end
+          end
+
+          def get_streams_to_snapshot(max_threshold)
+            try_mongo do
+              query = { 'unsnapshotted' => { '$gte' => max_threshold } }
+              order = [ 'unsnapshotted', Mongo::DESCENDING ]
+
+              persisted_stream_heads.find(query).sort(order).to_a.map { |hash| MongoStreamHead.from_hash hash }
+            end
+          end
+
+          def get_undispatched_commits
+            try_mongo do
+              query = { 'dispatched' => false }
+              order = [ 'commit_timestamp', Mongo::ASCENDING ]
+
+              persisted_commits.find(query).sort(order).to_a.map { |hash| MongoCommit.from_hash hash }
+            end
+          end
+
+          def init
+            try_mongo do
+              persisted_commits.ensure_index [ ['dispatched', Mongo::ASCENDING],
+                                               ['commit_timestamp', Mongo::ASCENDING] ], :unique => false, :name => 'dispatched_index'
+
+              persisted_commits.ensure_index [ ['_id.stream_id', Mongo::ASCENDING],
+                                               ['events.stream_revision', Mongo::ASCENDING] ], :unique => true,  :name => 'get_from_index'
+
+              persisted_commits.ensure_index [ ['commit_timestamp', Mongo::ASCENDING] ], :unique => false, :name => 'commit_timestamp_index'
+
+              persisted_stream_heads.ensure_index [ ['unsnapshotted', Mongo::ASCENDING] ], :unique => false, :name => 'unsnapshotted_index'
+            end
+            self
+          end
+
+          def mark_commit_as_dispatched(commit)
+            try_mongo do
+              persisted_commits.update commit.to_id_query, { '$set' => { 'dispatched' => true }}
+            end
+          end
+
+          private
+
+          def persisted_commits
+            @store.collection 'commits'
+          end
+
+          def persisted_snapshots
+            @store.collection 'snapshots'
+          end
+
+          def persisted_stream_heads
+            @store.collection 'streams'
+          end
+
+          def try_mongo(&block)
+            begin
+              yield block
+            rescue Mongo::ConnectionError => e
+              raise Euston::EventStore::StorageUnavailableError, e.to_s, e.backtrace
+            rescue Mongo::MongoDBError => e
+              raise Euston::EventStore::StorageError, e.to_s, e.backtrace
+            end
+          end
+
+          def update_stream_head_async(stream_id, stream_revision, events_count)
+            Thread.fork do
+              persisted_stream_heads.update(
+                { '_id' => stream_id },
+                { '$set' => { 'head_revision' => stream_revision }, '$inc' => { 'snapshot_revision' => 0, 'unsnapshotted' => events_count } },
+                { :upsert  => true })
+            end
+          end
+
+          CONCURRENCY_EXCEPTION = "E1100"
+        end
+      end
+    end
+  end
+end

data/lib/euston-eventstore/persistence/mongodb/mongo_persistence_factory.rb

@@ -0,0 +1,31 @@
+if RUBY_PLATFORM.to_s == 'java'
+  module JMongo
+    module BasicDBObjectExtentions
+      include HashKeys
+    end
+  end
+
+  require 'jmongo'
+else
+  require 'mongo'
+end
+
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        class MongoPersistenceFactory
+          def self.build
+            config = Config.instance
+            connection = ::Mongo::Connection.new(config.host, config.port, config.options)
+
+            MongoPersistenceEngine.new connection.db(config.database)
+          end
+          def self.build_with_proxy()
+            ZmqPersistenceEngineProxy.new(build.init)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/euston-eventstore/persistence/mongodb/mongo_snapshot.rb

@@ -0,0 +1,32 @@
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        module MongoSnapshot
+          extend ::ActiveSupport::Concern
+
+          class << self
+            def from_hash(hash)
+              return nil if hash.nil?
+
+              id = hash['_id']
+
+              Euston::EventStore::Snapshot.new id['stream_id'], id['stream_revision'], hash['payload']
+            end
+          end
+
+          def to_hash
+            {
+              :_id => { :stream_id => stream_id, :stream_revision => stream_revision },
+              :payload => payload.recursive_stringify_symbol_values!
+            }
+          end
+        end
+      end
+    end
+
+    class Snapshot
+      include Persistence::Mongodb::MongoSnapshot
+    end
+  end
+end

data/lib/euston-eventstore/persistence/mongodb/mongo_stream_head.rb

@@ -0,0 +1,29 @@
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        module MongoStreamHead
+          extend ::ActiveSupport::Concern
+
+          class << self
+            def from_hash(hash)
+              Euston::EventStore::Persistence::StreamHead.new hash['_id'], hash['head_revision'], hash['snapshot_revision']
+            end
+          end
+
+          def to_hash
+            {
+              :stream_id => @stream_id,
+              :head_revision => @head_revision,
+              :snapshot_revision => @snapshot_revision
+            }
+          end
+        end
+      end
+
+      class StreamHead
+        include Mongodb::MongoStreamHead
+      end
+    end
+  end
+end

data/lib/euston-eventstore/persistence/stream_head.rb

@@ -0,0 +1,23 @@
+module Euston
+  module EventStore
+    module Persistence
+      # Indicates the most recent information representing the head of a given stream.
+      class StreamHead
+        def initialize(stream_id, head_revision, snapshot_revision)
+          @stream_id = stream_id
+          @head_revision = head_revision
+          @snapshot_revision = snapshot_revision
+        end
+
+        # Gets the value which uniquely identifies the stream where the last snapshot exceeds the allowed threshold.
+        attr_reader :stream_id
+
+        # Gets the value which indicates the revision, length, or number of events committed to the stream.
+        attr_reader :head_revision
+
+        # Gets the value which indicates the revision at which the last snapshot was taken.
+        attr_reader :snapshot_revision
+      end
+    end
+  end
+end

data/lib/euston-eventstore/snapshot.rb

@@ -0,0 +1,21 @@
+module Euston
+  module EventStore
+    # Represents a materialized view of a stream at specific revision.
+    class Snapshot
+      def initialize(stream_id, stream_revision, payload)
+        @stream_id = stream_id
+        @stream_revision = stream_revision
+        @payload = payload
+      end
+
+      # Gets the value which uniquely identifies the stream to which the snapshot applies.
+      attr_reader :stream_id
+
+      # Gets the position at which the snapshot applies.
+      attr_reader :stream_revision
+
+      # Gets the snapshot or materialized view of the stream at the revision indicated.
+      attr_reader :payload
+    end
+  end
+end

data/lib/euston-eventstore/version.rb

@@ -0,0 +1,5 @@
+module Euston
+  module EventStore
+    VERSION = "1.0.2"
+  end
+end

data/lib/euston-eventstore.rb

@@ -0,0 +1,7 @@
+require 'active_support/concern'
+require 'hash-keys'
+require 'require_all'
+
+require_rel 'euston-eventstore'
+
+Json = JSON if defined?(JSON) && !defined?(Json)

data/spec/event_store/dispatcher/asynchronous_dispatcher_spec.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Euston::EventStore do
+  let(:uuid) { Uuid }
+
+  describe 'asynchronous dispatcher' do
+    context 'when instantiating the asynchronous dispatcher' do
+      let(:stream_id) { uuid.generate }
+      let(:commits) { [ new_commit(:stream_id => stream_id), new_commit(:stream_id => stream_id) ] }
+      let(:bus) { stub('bus').as_null_object }
+      let(:persistence) { stub('persistence').as_null_object }
+
+      before do
+        persistence.should_receive(:init).once
+        persistence.should_receive(:get_undispatched_commits).once { commits }
+        bus.should_receive(:publish).with(commits.first).once
+        bus.should_receive(:publish).with(commits.last).once
+
+        Euston::EventStore::Dispatcher::AsynchronousDispatcher.new bus, persistence
+        sleep 0.25
+      end
+
+      it('initializes the persistence engine') { persistence.rspec_verify }
+      it('gets the set of undispatched commits') { persistence.rspec_verify }
+      it('provides the commits to the published') { bus.rspec_verify }
+    end
+
+    context 'when asynchronously dispatching a commit' do
+      let(:commit) { new_commit }
+      let(:bus) { stub('bus').as_null_object }
+      let(:persistence) { stub('persistence').as_null_object }
+
+      before do
+        bus.should_receive(:publish).with(commit).once
+        persistence.should_receive(:mark_commit_as_dispatched).with(commit).once
+
+        @dispatcher = Euston::EventStore::Dispatcher::AsynchronousDispatcher.new bus, persistence
+        @dispatcher.dispatch commit
+        sleep 0.25
+      end
+
+      it('provides the commit to the message bus') { bus.rspec_verify }
+      it('marks the commit as dispatched') { persistence.rspec_verify }
+    end
+
+    context 'when an asynchronously dispatched commit throws an exception' do
+      let(:commit) { new_commit }
+      let(:persistence) { stub('persistence').as_null_object }
+
+      before do
+        persistence.stub(:get_undispatched_commits) { [] }
+
+        @dispatcher = Euston::EventStore::Dispatcher::AsynchronousDispatcher.new nil, persistence do |commit, exception|
+          @caught_commit = commit
+          @caught_exception = exception
+        end
+
+        @dispatcher.dispatch commit
+        sleep 0.25
+      end
+
+      it('provides the commit that caused the error') { @caught_commit.should be_an(Euston::EventStore::Commit) }
+      it('provides the exception') { @caught_exception.should be_an(Exception) }
+    end
+
+    def new_commit(options = {})
+      defaults = { :stream_id => uuid.generate,
+                   :stream_revision => 0,
+                   :commit_id => uuid.generate,
+                   :commit_sequence => 0 }
+
+      Euston::EventStore::Commit.new(defaults.merge options)
+    end
+  end
+end

data/spec/event_store/dispatcher/synchronous_dispatcher_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Euston::EventStore do
+  let(:uuid) { Uuid }
+
+  describe 'synchronous dispatcher' do
+    let(:bus) { stub('bus').as_null_object }
+    let(:persistence) { stub('persistence').as_null_object }
+
+    context 'when synchronously dispatching a commit' do
+      let(:commit) { new_commit }
+
+      before do
+        persistence.stub(:get_undispatched_commits) { [] }
+        persistence.should_receive(:mark_commit_as_dispatched).with(commit).once
+
+        @dispatched_commits = []
+
+        @dispatcher = Euston::EventStore::Dispatcher::SynchronousDispatcher.new(persistence) do |c|
+          @dispatched_commits << c
+        end
+
+        @dispatcher.dispatch commit
+      end
+
+      it('provides the commit to the message bus') { @dispatched_commits.should have(1).item }
+      it('marks the commit as dispatched') { persistence.rspec_verify }
+    end
+
+    def new_commit(options = {})
+      defaults = { :stream_id => uuid.generate,
+                   :stream_revision => 0,
+                   :commit_id => uuid.generate,
+                   :commit_sequence => 0 }
+
+      Euston::EventStore::Commit.new(defaults.merge options)
+    end
+  end
+end