euston-eventstore 1.0.2-java

data/Rakefile

@@ -0,0 +1,126 @@
+require 'date'
+require 'rspec/core/rake_task'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}/version.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+def platform
+  RUBY_PLATFORM.to_s == 'java' ? '-java' : ''
+end
+
+#############################################################################
+#
+# Custom tasks
+#
+#############################################################################
+
+default_rspec_opts = %w[--colour --format Fuubar]
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = default_rspec_opts
+end
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+def built_gem
+  Dir["#{name}*.gem"].first
+end
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{built_gem}"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{built_gem} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  #replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/euston-eventstore.gemspec

@@ -0,0 +1,68 @@
+Gem::Specification.new do |s|
+  s.name        = 'euston-eventstore'
+  s.version     = '1.0.2'
+  s.date        = '2011-09-15'
+  # s.platform    = Gem::Platform::CURRENT
+  s.platform    = RUBY_PLATFORM.to_s == 'java' ? 'java' : Gem::Platform::RUBY
+  s.authors     = ['Lee Henson', 'Guy Boertje']
+  s.email       = ['lee.m.henson@gmail.com', 'guyboertje@gmail.com']
+  s.summary     = %q{Event store for use with Euston.}
+  s.description = "Ruby port for Jonathan Oliver's EventStore. See https://github.com/joliver/EventStore for details."
+  s.homepage    = 'http://github.com/leemhenson/euston-eventstore'
+  # = MANIFEST =
+  s.files = %w[
+    Rakefile
+    euston-eventstore.gemspec
+    lib/euston-eventstore.rb
+    lib/euston-eventstore/commit.rb
+    lib/euston-eventstore/constants.rb
+    lib/euston-eventstore/dispatcher/asynchronous_dispatcher.rb
+    lib/euston-eventstore/dispatcher/null_dispatcher.rb
+    lib/euston-eventstore/dispatcher/synchronous_dispatcher.rb
+    lib/euston-eventstore/errors.rb
+    lib/euston-eventstore/event_message.rb
+    lib/euston-eventstore/optimistic_event_store.rb
+    lib/euston-eventstore/optimistic_event_stream.rb
+    lib/euston-eventstore/persistence/mongodb/mongo_commit.rb
+    lib/euston-eventstore/persistence/mongodb/mongo_commit_id.rb
+    lib/euston-eventstore/persistence/mongodb/mongo_config.rb
+    lib/euston-eventstore/persistence/mongodb/mongo_event_message.rb
+    lib/euston-eventstore/persistence/mongodb/mongo_persistence_engine.rb
+    lib/euston-eventstore/persistence/mongodb/mongo_persistence_factory.rb
+    lib/euston-eventstore/persistence/mongodb/mongo_snapshot.rb
+    lib/euston-eventstore/persistence/mongodb/mongo_stream_head.rb
+    lib/euston-eventstore/persistence/stream_head.rb
+    lib/euston-eventstore/snapshot.rb
+    lib/euston-eventstore/version.rb
+    spec/event_store/dispatcher/asynchronous_dispatcher_spec.rb
+    spec/event_store/dispatcher/synchronous_dispatcher_spec.rb
+    spec/event_store/optimistic_event_store_spec.rb
+    spec/event_store/optimistic_event_stream_spec.rb
+    spec/event_store/persistence/mongodb_spec.rb
+    spec/event_store/serialization/simple_message.rb
+    spec/spec_helper.rb
+    spec/support/array_enumeration_counter.rb
+  ]
+  # = MANIFEST =
+
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  s.add_dependency 'activesupport',             '~> 3.0.9'
+  s.add_dependency 'hash-keys',                 '~> 1.0.0'
+  s.add_dependency 'require_all',               '~> 1.2.0'
+  s.add_dependency 'uuid',                      '~> 2.3.0'
+
+  if RUBY_PLATFORM.to_s == 'java'
+    s.add_dependency 'json-jruby',              '~> 1.5.0'
+    s.add_dependency 'jmongo',                  '~> 1.0.0'
+  else
+    s.add_dependency 'bson_ext',                '~> 1.1.0'
+    s.add_dependency 'json',                    '~> 1.5.0'
+    s.add_dependency 'mongo',                   '~> 1.3.1'
+  end
+
+  s.add_development_dependency 'awesome_print', '~> 0.4.0'
+  s.add_development_dependency 'fuubar',        '~> 0.0.0'
+  s.add_development_dependency 'rspec',         '~> 2.6.0'
+end

data/lib/euston-eventstore/commit.rb

@@ -0,0 +1,77 @@
+module Euston
+  module EventStore
+
+    # Represents a series of events which have been fully committed as a single unit and which apply to the stream indicated.
+    class Commit
+      def initialize(hash)
+        defaults = {
+          :stream_id => nil,
+          :stream_revision => 1,
+          :commit_id => nil,
+          :commit_sequence => 1,
+          :commit_timestamp => Time.now.utc,
+          :headers => OpenStruct.new,
+          :events => []
+        }
+        values = defaults.merge hash
+        defaults.keys.each { |key| instance_variable_set "@#{key}", values[key] }
+      end
+
+      def to_hash
+        {
+          :stream_id => stream_id,
+          :stream_revision => stream_revision,
+          :commit_id => commit_id,
+          :commit_sequence => commit_sequence,
+          :commit_timestamp => commit_timestamp,
+          :headers => headers.is_a?(OpenStruct) ? headers.instance_variable_get(:@table) : headers,
+          :events => events
+        }
+      end
+      # Gets the value which uniquely identifies the stream to which the commit belongs.
+      attr_reader :stream_id
+
+      # Gets the value which indicates the revision of the most recent event in the stream to which this commit applies.
+      attr_reader :stream_revision
+
+      # Gets the value which uniquely identifies the commit within the stream.
+      attr_reader :commit_id
+
+      # Gets the value which indicates the sequence (or position) in the stream to which this commit applies.
+      attr_reader :commit_sequence
+
+      # Gets the point in time at which the commit was persisted.
+      attr_reader :commit_timestamp
+
+      # Gets the metadata which provides additional, unstructured information about this commit.
+      attr_reader :headers
+
+      # Gets the collection of event messages to be committed as a single unit.
+      attr_reader :events
+
+      def ==(other)
+        (other.is_a? Commit) && (@stream_id == other.stream_id) && (@commit_id == other.commit_id)
+      end
+
+      class << self
+        def empty?(attempt)
+          attempt.nil? || attempt.events.empty?
+        end
+
+        def has_identifier?(attempt)
+          !(attempt.stream_id.nil? || attempt.commit_id.nil?)
+        end
+
+        def valid?(attempt)
+          raise ArgumentError.new('The commit must not be nil.') if attempt.nil?
+          raise ArgumentError.new('The commit must be uniquely identified.') unless Commit.has_identifier? attempt
+          raise ArgumentError.new('The commit sequence must be a positive number.') unless attempt.commit_sequence > 0
+          raise ArgumentError.new('The stream revision must be a positive number.') unless attempt.stream_revision > 0
+          raise ArgumentError.new('The stream revision must always be greater than or equal to the commit sequence.') if (attempt.stream_revision < attempt.commit_sequence)
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/euston-eventstore/constants.rb

@@ -0,0 +1,5 @@
+module Euston
+  module EventStore
+    FIXNUM_MAX = (2**(0.size * 8 -2) -1)
+  end
+end

data/lib/euston-eventstore/dispatcher/asynchronous_dispatcher.rb

@@ -0,0 +1,37 @@
+module Euston
+  module EventStore
+    module Dispatcher
+      class AsynchronousDispatcher
+        def initialize(bus, persistence, &block)
+          @bus = bus
+          @persistence = persistence
+          @handle_exception = block_given? ? block : Proc.new {}
+
+          start
+        end
+
+        def dispatch(commit)
+          Thread.fork(commit) { |c| begin_dispatch c }
+        end
+
+        protected
+
+        def begin_dispatch(commit)
+          begin
+            @bus.publish commit
+            @persistence.mark_commit_as_dispatched commit
+          rescue Exception => e
+            @handle_exception.call commit, e
+          end
+        end
+
+        private
+
+        def start
+          @persistence.init
+          @persistence.get_undispatched_commits.each { |commit| dispatch commit }
+        end
+      end
+    end
+  end
+end

data/lib/euston-eventstore/dispatcher/null_dispatcher.rb

@@ -0,0 +1,11 @@
+module Euston
+  module EventStore
+    module Dispatcher
+      class NullDispatcher
+        def dispatch(commit)
+          # no-op
+        end
+      end
+    end
+  end
+end

data/lib/euston-eventstore/dispatcher/synchronous_dispatcher.rb

@@ -0,0 +1,21 @@
+module Euston
+  module EventStore
+    module Dispatcher
+      class SynchronousDispatcher
+        def initialize persistence, &block
+          @persistence = persistence
+          @dispatch = block
+        end
+
+        def dispatch commit
+          @dispatch.call commit
+          @persistence.mark_commit_as_dispatched commit
+        end
+
+        def lookup
+          @persistence.get_undispatched_commits.each { |commit| dispatch commit }
+        end
+      end
+    end
+  end
+end

data/lib/euston-eventstore/errors.rb

@@ -0,0 +1,21 @@
+module Euston
+  module EventStore
+    # Represents an optimistic concurrency conflict between multiple writers.
+    class ConcurrencyError < RuntimeError; end
+
+    # Represents an attempt to commit the same information more than once.
+    class DuplicateCommitError < RuntimeError; end
+
+    # Represents a loss of communications with the storage
+    class StorageUnavailableError < RuntimeError; end
+
+    # Represents a general failure of the storage engine or persistence infrastructure.
+    class StorageError < RuntimeError; end
+
+    # Represents an attempt to commit the same information more than once.
+    class StreamNotFoundError < RuntimeError; end
+
+    # Represents an error when the proxy returns a non 200 code that does not map to any of the above errors.
+    class ProxyCallError < RuntimeError; end
+  end
+end

data/lib/euston-eventstore/event_message.rb

@@ -0,0 +1,26 @@
+module Euston
+  module EventStore
+    # Represents a single element in a stream of events.
+    class EventMessage
+
+      def initialize(arg = nil)
+        if arg.is_a?(Hash) && (arg.keys & ['body','headers']).size == 2
+          @body, @headers = arg.values_at('body','headers')
+        else
+          @headers = {}
+          @body = arg
+        end
+      end
+
+      def to_hash
+        {:headers=>@headers,:body=>@body}
+      end
+
+      # Gets the metadata which provides additional, unstructured information about this message.
+      attr_reader :headers
+
+      # Gets or sets the actual event message body.
+      attr_reader :body
+    end
+  end
+end

data/lib/euston-eventstore/optimistic_event_store.rb

@@ -0,0 +1,68 @@
+module Euston
+  module EventStore
+    class OptimisticEventStore
+      def initialize(persistence)
+        @persistence = persistence
+      end
+
+      def instrumentation
+        return nil unless @persistence.respond_to?(:instrumentation)
+        @persistence.instrumentation
+      end
+
+      def add_snapshot(snapshot)
+        @persistence.add_snapshot snapshot
+      end
+
+      def commit(attempt)
+        return unless Commit.valid?(attempt) && !Commit.empty?(attempt)
+
+        @persistence.commit attempt
+      end
+
+      def create_stream(stream_id)
+        OptimisticEventStream.new(:stream_id => stream_id,
+                                  :persistence => self)
+      end
+
+      def get_from(stream_id, min_revision, max_revision)
+        @persistence.get_from(:stream_id => stream_id,
+                              :min_revision => min_revision,
+                              :max_revision => max_revision).to_enum
+      end
+
+      def get_snapshot(stream_id, max_revision)
+        @persistence.get_snapshot stream_id, validate_max_revision(max_revision)
+      end
+
+      def get_streams_to_snapshot(max_threshold)
+        @persistence.get_streams_to_snapshot max_threshold
+      end
+
+      def open_stream(options)
+        options = { :stream_id => nil,
+                    :min_revision => 0,
+                    :max_revision => 0,
+                    :snapshot => nil }.merge(options)
+
+        options = options.merge(:max_revision => validate_max_revision(options[:max_revision]),
+                                :persistence => self)
+
+        if options[:snapshot].nil?
+          options.delete :snapshot
+        else
+          options.delete :stream_id
+          options.delete :min_revision
+        end
+
+        OptimisticEventStream.new options
+      end
+
+      private
+
+      def validate_max_revision(max_revision)
+        max_revision <= 0 ? FIXNUM_MAX : max_revision
+      end
+    end
+  end
+end

data/lib/euston-eventstore/optimistic_event_stream.rb

@@ -0,0 +1,106 @@
+module Euston
+  module EventStore
+    class OptimisticEventStream
+      def initialize(options)
+        @persistence = options[:persistence]
+        @committed_events = []
+        @uncommitted_events = []
+        @uncommitted_headers = {}
+        @commit_sequence = 0
+        @identifiers = []
+
+        if options.has_key? :snapshot
+          snapshot = options[:snapshot]
+          @stream_id = snapshot.stream_id
+          commits = @persistence.get_from @stream_id, snapshot.stream_revision, options[:max_revision]
+          populate_stream snapshot.stream_revision + 1, options[:max_revision], commits
+          @stream_revision = snapshot.stream_revision + committed_events.length
+        else
+          @stream_id = options[:stream_id]
+          @stream_revision = 0
+          min_revision = options[:min_revision] ||= nil
+          max_revision = options[:max_revision] ||= nil
+
+          unless min_revision.nil? || max_revision.nil?
+            commits = @persistence.get_from @stream_id, min_revision, max_revision
+            populate_stream min_revision, max_revision, commits
+
+            raise StreamNotFoundError if (min_revision > 0 && committed_events.empty?)
+          end
+        end
+      end
+
+      attr_reader :stream_id, :stream_revision, :commit_sequence, :committed_events, :uncommitted_events, :uncommitted_headers
+
+      def <<(event)
+        @uncommitted_events << event unless event.nil? || event.body.nil?
+      end
+
+      def clear_changes
+        @uncommitted_events = []
+        @uncommitted_headers = {}
+      end
+
+      def commit_changes(commit_id)
+        raise Euston::EventStore::DuplicateCommitError if @identifiers.include? commit_id
+
+        return unless has_changes
+
+        begin
+          persist_changes commit_id
+        rescue ConcurrencyError => e
+          commits = @persistence.get_from stream_id, stream_revision + 1, FIXNUM_MAX
+          populate_stream stream_revision + 1, FIXNUM_MAX, commits
+
+          raise e
+        end
+      end
+
+      protected
+
+      def copy_values_to_new_commit(commit_id)
+        Euston::EventStore::Commit.new :stream_id => stream_id,
+                                       :stream_revision => stream_revision + uncommitted_events.length,
+                                       :commit_id => commit_id,
+                                       :commit_sequence => commit_sequence + 1,
+                                       :commit_timestamp => Time.now.utc,
+                                       :headers => uncommitted_headers,
+                                       :events => uncommitted_events
+      end
+
+      def has_changes
+        !uncommitted_events.empty?
+      end
+
+      def persist_changes(commit_id)
+        commit = copy_values_to_new_commit commit_id
+        @persistence.commit commit
+
+        populate_stream stream_revision + 1, commit.stream_revision, [ commit ]
+        clear_changes
+      end
+
+      def populate_stream(min_revision, max_revision, commits = [])
+        commits.each do |commit|
+          @identifiers << commit.commit_id
+          @commit_sequence = commit.commit_sequence
+
+          current_revision = commit.stream_revision - commit.events.length + 1
+
+          return if current_revision > max_revision
+
+          commit.events.each do |event|
+            break if current_revision > max_revision
+
+            unless current_revision < min_revision
+              @committed_events << event
+              @stream_revision = current_revision
+            end
+
+            current_revision += 1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        module MongoCommit
+          extend ::ActiveSupport::Concern
+
+          included do
+            alias_method :original_initialize, :initialize
+            alias_method :initialize, :mongo_initialize
+          end
+
+          class << self
+            def from_hash(hash)
+              return nil if hash.nil?
+
+              id = hash['_id']
+              events = hash['events'].sort_by { |e| e["stream_revision"] }.to_a
+              stream_revision = events.last['stream_revision']
+              events = events.map { |e| Euston::EventStore::Persistence::Mongodb::MongoEventMessage.from_hash e['payload'] }
+
+              Euston::EventStore::Commit.new :stream_id => id['stream_id'],
+                                             :stream_revision => stream_revision,
+                                             :commit_id => hash['commit_id'],
+                                             :commit_sequence => id['commit_sequence'],
+                                             :commit_timestamp => hash['commit_timestamp'],
+                                             :headers => hash['headers'].recursive_symbolize_keys!,
+                                             :events => events
+            end
+          end
+
+          def mongo_initialize(hash)
+            original_initialize(hash)
+            @dispatched = hash[:dispatched]
+          end
+
+          attr_reader :dispatched
+
+          def to_hash
+            {
+              :_id => { :stream_id => stream_id, :commit_sequence => commit_sequence },
+              :commit_id => commit_id,
+              :commit_timestamp => commit_timestamp.to_f,
+              :dispatched => dispatched || false,
+              :events => events.map { |e| e.to_hash },
+              :headers => headers
+            }
+          end
+
+          def to_mongo_commit
+            mongo_stream_revision = stream_revision - (events.length - 1)
+            mongo_events = events.map do |e|
+              hash = { :stream_revision => mongo_stream_revision, :payload => e.to_hash }
+              mongo_stream_revision += 1
+              hash
+            end
+
+            {
+              :_id => { :stream_id => stream_id, :commit_sequence => commit_sequence },
+              :commit_id => commit_id,
+              :commit_timestamp => commit_timestamp.to_f,
+              :headers => headers,
+              :events => mongo_events,
+              :dispatched => false
+            }
+          end
+
+          def to_id_query
+            {
+              '_id.commit_sequence' => commit_sequence,
+              '_id.stream_id' => stream_id
+            }
+          end
+        end
+      end
+    end
+
+    class Commit
+      include Persistence::Mongodb::MongoCommit
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Euston
+  module EventStore
+    module Persistence
+      module Mongodb
+        module MongoCommitId
+          def initialize(stream_id, commit_sequence)
+            @stream_id = stream_id
+            @commit_sequence = commit_sequence
+          end
+
+          attr_reader :stream_id, :commit_sequence
+        end
+      end
+    end
+  end
+end