nexia_event_store 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e9d038884a630f02031c484aa423b935018288d
-  data.tar.gz: 2d3c0d69031fea0dddeed6805e483a9b14c33901
+  metadata.gz: a36ee7d65c27df5609edfe9b2807da29142fd332
+  data.tar.gz: 9e3e8394fae1ff84857675343bee94e9daa08738
 SHA512:
-  metadata.gz: a10cbfaf1914a3cf6b0ee03a45e2548f56a552268deb082459b97e929790c0c03da0854fbc4048b840f59712c3cf3bdc1955187bfdb1a4994d97e297fad5688a
-  data.tar.gz: b4da3da2eb6921f930c7dff3d64db1ece57bd2b4a99ae862321893d705af51f389d9dc978ffea1dc6d433e8ee152ccf7253492aac0a1f4fd11d1b0f1ddd7f1dc
+  metadata.gz: 8971a7a3bc6b4d3a6af6d439d7058720a56ef77b02e49e56df5e81d78631c034260b85b4007c6981b0662448cf1f7bdb359222b867eba2cfed4c03aaecb48b9f
+  data.tar.gz: a0012132f78ea8b63d6d2ab010f8480ee3e2b57321b5ae1abcf197e053489a88eac7714a38c830cc14bb0103742f1ea120ec4ed062e7e85bfc7583fa7f33df63

data/lib/event_store.rb

@@ -12,6 +12,7 @@ require 'event_store/aggregate'
 require 'event_store/client'
 require 'event_store/errors'
 require 'yaml'
+require 'zlib'
 
 Sequel.extension :migration
 
@@ -40,8 +41,9 @@ module EventStore
     @db
   end
 
-  def self.redis
-    @redis
+  def self.redis(hostname)
+    hash = Zlib::crc32(hostname)
+    @redis[hash % @redis.length]
   end
 
   def self.connect(*args)
@@ -49,7 +51,14 @@ module EventStore
   end
 
   def self.redis_connect(config_hash)
-    @redis ||= Redis.new(config_hash)
+    if config_hash["hosts"]
+      generic_config = config_hash["hosts"].reject { |k, _| k == "hosts" }
+      @redis = config_hash["hosts"].map { |hostname|
+        Redis.new(generic_config.merge("host" => hostname))
+      }
+    else
+      @redis ||= [Redis.new(config_hash)]
+    end
   end
 
   def self.local_redis_config
@@ -103,7 +112,7 @@ module EventStore
     return unless connected?
     EventStore.db.from(fully_qualified_table).delete
     EventStore.db.from(fully_qualified_names_table).delete
-    EventStore.redis.flushdb
+    @redis.map(&:flushdb)
   end
 
   def self.postgres(environment = 'test', table_name = 'events', schema = 'event_store_test')
@@ -142,14 +151,14 @@ module EventStore
 
   def self.custom_config(database_config, redis_config, table_name = 'events', environment = 'production')
     self.redis_connect(redis_config)
-    database_config = database_config.inject({}) {|memo, (k,v)| memo[k.to_s] = v; memo}
-    redis_config    = redis_config.inject({}) {|memo, (k,v)| memo[k.to_s] = v; memo}
-
-    @adapter        = database_config["adapter"].to_s
-    @environment    = environment
-    @db_config      = database_config
-    @table_name     = table_name
-    @schema         = database_config["schema"].to_s
+    database_config = database_config.each_with_object({}) {|(k,v), memo| memo[k.to_s] = v}
+    redis_config    = redis_config.each_with_object({}) {|(k,v), memo| memo[k.to_s] = v}
+
+    @adapter         = database_config["adapter"].to_s
+    @environment     = environment
+    @db_config       = database_config
+    @table_name      = table_name
+    @schema          = database_config["schema"].to_s
     @use_names_table = database_config.fetch("use_names_table", true)
     connect_db
   end
@@ -168,7 +177,7 @@ module EventStore
 
   def self.create_db
     connect_db
-    table = "#{schema}__schema_info".to_sym
+    table = Sequel.qualify(schema, "schema_info")
     @db.run("CREATE SCHEMA IF NOT EXISTS #{schema}")
     Sequel::Migrator.run(@db, File.expand_path(File.join('..','..','db', self.migrations_dir), __FILE__), table: table)
   end

data/lib/event_store/aggregate.rb

@@ -4,7 +4,7 @@ module EventStore
   class Aggregate
     extend Forwardable
 
-    attr_reader :id, :type, :event_table, :snapshot, :event_stream, :checkpoint_event
+    attr_reader :id, :type, :event_table, :snapshot, :event_stream, :checkpoint_events
 
     def_delegators :snapshot,
       :last_event,
@@ -35,13 +35,13 @@ module EventStore
       EventStore.db.from(EventStore.fully_qualified_table).select(:aggregate_id).distinct.order(:aggregate_id).limit(limit, offset).all.map{|item| item[:aggregate_id]}
     end
 
-    def initialize(id, type = EventStore.table_name, checkpoint_event = nil)
+    def initialize(id, type = EventStore.table_name, checkpoint_events = [])
       @id = id
       @type = type
 
-      @checkpoint_event = checkpoint_event
-      @snapshot         = Snapshot.new(self)
-      @event_stream     = EventStream.new(self)
+      @checkpoint_events = checkpoint_events
+      @snapshot          = Snapshot.new(self)
+      @event_stream      = EventStream.new(self)
     end
 
     def append(events, logger)

data/lib/event_store/client.rb

@@ -22,8 +22,9 @@ module EventStore
       Aggregate.ids(offset, limit)
     end
 
-    def initialize(aggregate_id, aggregate_type = EventStore.table_name, checkpoint_event = nil)
-      @aggregate = Aggregate.new(aggregate_id, aggregate_type, checkpoint_event)
+    def initialize(aggregate_id, aggregate_type = EventStore.table_name, checkpoint_events = [])
+      checkpoint_events = [checkpoint_events].flatten
+      @aggregate = Aggregate.new(aggregate_id, aggregate_type, checkpoint_events)
     end
 
     def exists?

data/lib/event_store/event_stream.rb

@@ -2,15 +2,15 @@ module EventStore
   class EventStream
     include Enumerable
 
-    attr_reader :event_table, :checkpoint_event
+    attr_reader :event_table, :checkpoint_events
 
     def initialize aggregate
       @aggregate = aggregate
       @id = @aggregate.id
-      @checkpoint_event = aggregate.checkpoint_event
+      @checkpoint_events = aggregate.checkpoint_events
       @event_table_alias = "events"
-      @event_table = "#{EventStore.schema}__#{EventStore.table_name}".to_sym
-      @aliased_event_table = "#{event_table}___#{@event_table_alias}".to_sym
+      @event_table = Sequel.qualify(EventStore.schema, EventStore.table_name)
+      @aliased_event_table = event_table.as(@event_table_alias)
       @names_table = EventStore.fully_qualified_names_table
     end
 
@@ -57,17 +57,25 @@ module EventStore
         begin
           query = EventStore.db.from(@aliased_event_table).where(:aggregate_id => @id.to_s)
           query = query.join(@names_table, id: :fully_qualified_name_id) if EventStore.use_names_table?
-          query = query.order("#{@event_table_alias}__id".to_sym).select_all(:events)
+          query = query.order { events[:id] }.select_all(:events)
           query = query.select_append(:fully_qualified_name) if EventStore.use_names_table?
           query
         end
     end
 
     def snapshot_events
-      last_checkpoint = last_event_before(Time.now.utc, [checkpoint_event]).first if checkpoint_event
+      last_checkpoint = nil
+
+      if checkpoint_events
+        checkpoints = last_event_before(Time.now.utc, checkpoint_events)
+        if checkpoints.map { |e| e[:fully_qualified_name] }.uniq.length > 1
+          raise "unexpected multiple checkpoint event types"
+        end
+        last_checkpoint = checkpoints.last
+      end
 
       if last_checkpoint
-        events.where{ events__id >= last_checkpoint[:id].to_i }
+        events.where{ events[:id] >= last_checkpoint[:id].to_i }
       else
         events
       end
@@ -75,7 +83,7 @@ module EventStore
 
     def events_from(event_id, max = nil)
       # note: this depends on the events table being aliased to "events" above.
-      events.limit(max).where{events__id >= event_id.to_i }.all.map do |event|
+      events.limit(max).where{events[:id] >= event_id.to_i }.all.map do |event|
         event[:serialized_event] = EventStore.unescape_bytea(event[:serialized_event])
         event
       end
@@ -99,8 +107,8 @@ module EventStore
       timestampz = start_time.strftime("%Y-%m-%d %H:%M:%S%z")
 
       rows = fully_qualified_names.inject([]) { |memo, name|
-        memo + events.where(events__id: events.where(fully_qualified_name: name).where { occurred_at < timestampz }
-                 .select { max(:events__id) }.unordered.group(:sub_key)).all
+        memo + events.where(Sequel.qualify("events", "id") => events.where(fully_qualified_name: name).where { occurred_at < timestampz }
+                 .select { max(events[:id]) }.unordered.group(:sub_key)).all
       }.sort_by { |r| r[:occurred_at] }
 
       rows.map {|r| r[:serialized_event] = EventStore.unescape_bytea(r[:serialized_event]); r}

data/lib/event_store/snapshot.rb

@@ -8,7 +8,7 @@ module EventStore
 
     def initialize aggregate
       @aggregate = aggregate
-      @redis = EventStore.redis
+      @redis = EventStore.redis(aggregate.id)
       @snapshot_table = "#{@aggregate.type}_snapshots_for_#{@aggregate.id}"
       @snapshot_event_id_table = "#{@aggregate.type}_snapshot_event_ids_for_#{@aggregate.id}"
     end
@@ -65,7 +65,7 @@ module EventStore
     end
 
     def delete_snapshot!
-      EventStore.redis.del [snapshot_table, snapshot_event_id_table]
+      @redis.del [snapshot_table, snapshot_event_id_table]
     end
 
     def store_snapshot(prepared_events, logger=default_logger)

data/lib/event_store/version.rb

@@ -1,3 +1,3 @@
 module EventStore
-  VERSION = '0.10.1'
+  VERSION = '0.11.0'
 end

data/spec/event_store/client_spec.rb

@@ -56,7 +56,7 @@ describe EventStore::Client do
       end
 
       it "should be empty for aggregates without events" do
-        stream = es_client.new(100, :device).raw_event_stream
+        stream = es_client.new("100", :device).raw_event_stream
         expect(stream.empty?).to be_truthy
       end
 
@@ -80,7 +80,7 @@ describe EventStore::Client do
       end
 
       it "should be empty for aggregates without events" do
-        stream = es_client.new(100, :device).raw_event_stream
+        stream = es_client.new("100", :device).raw_event_stream
         expect(stream.empty?).to be_truthy
       end
 
@@ -116,6 +116,7 @@ describe EventStore::Client do
       end
     end
 
+
     describe "#raw_event_streams_from_event_id" do
       subject { es_client.new(AGGREGATE_ID_ONE, :device) }
       let(:raw_stream) { subject.raw_event_stream }

data/spec/event_store/event_stream_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+module EventStore
+  describe EventStream do
+    let(:aggregate_id) { SecureRandom.uuid }
+    let(:checkpoint_events) {
+      %w[ checkpoint_event_1 checkpoint_event_2 ]
+    }
+    let(:aggregate) {
+      Aggregate.new(
+        aggregate_id,
+        EventStore.table_name,
+        checkpoint_events
+      )
+    }
+
+    let(:event_time) { Time.parse("2001-01-01 00:00:00 UTC") }
+
+    let(:events) {
+      [EventStore::Event.new(aggregate_id, (event_time - 2000).utc, "old_event", "zone", "#{1000.to_s(2)}_foo"),
+       EventStore::Event.new(aggregate_id, (event_time - 1000).utc, "checkpoint_event_2", "zone", "#{1001.to_s(2)}_foo"),
+       EventStore::Event.new(aggregate_id, (event_time + 100).utc,  "after_checkpoint_1", "zone", "#{1002.to_s(2)}_foo"),
+       EventStore::Event.new(aggregate_id, (event_time).utc,        "after_checkpoint_2", "zone", "#{12.to_s(2)}_foo")]
+    }
+
+    subject(:event_stream) { EventStream.new aggregate }
+
+    let(:logger) { Logger.new("/dev/null") }
+
+    before(:each) do
+      event_stream.append events, logger
+    end
+
+    describe "#snapshot_events" do
+      it "returns events since the last of one of multiple checkpoint events" do
+        snapshot_events = event_stream.snapshot_events
+
+        expect(snapshot_events.count).to eql(3)
+
+        expect(
+          snapshot_events.find { |event| event[:fully_qualified_name] == 'checkpoint_event_2' }
+        ).not_to be_nil
+
+        expect(
+          snapshot_events.find { |event| event[:fully_qualified_name] == 'after_checkpoint_1' }
+        ).not_to be_nil
+
+        expect(
+          snapshot_events.find { |event| event[:fully_qualified_name] == 'after_checkpoint_2' }
+        ).not_to be_nil
+      end
+
+      it "raises an exception if multiple event types are returned" do
+        event = EventStore::Event.new(aggregate_id,
+                                      (event_time - 1000).utc,
+                                      "checkpoint_event_1",
+                                      "zone",
+                                      "#{1001.to_s(2)}_foo")
+
+        event_stream.append [event], logger
+
+        expect { event_stream.snapshot_events }.to raise_error do |error|
+          expect(error).to be_a(RuntimeError)
+          expect(error.message).to eql("unexpected multiple checkpoint event types")
+        end
+      end
+    end
+  end
+end

data/spec/event_store/snapshot_spec.rb

@@ -6,13 +6,15 @@ AGGREGATE_ID_TWO = SecureRandom.uuid
 
 module EventStore
   describe "Snapshots" do
+    let(:redis)  { EventStore.redis("") }
+
     context "when there are no events" do
-      let(:client)    { EventStore::Client.new(AGGREGATE_ID_ONE) }
+      let(:client) { EventStore::Client.new(AGGREGATE_ID_ONE) }
 
       it "should build an empty snapshot for a new client" do
         expect(client.snapshot.any?).to eq(false)
         expect(client.event_id).to eq(-1)
-        expect(EventStore.redis.hget(client.snapshot_event_id_table, :current_event_id)).to eq(nil)
+        expect(redis.hget(client.snapshot_event_id_table, :current_event_id)).to eq(nil)
       end
 
       it "a client should rebuild a snapshot" do
@@ -104,8 +106,8 @@ module EventStore
           before(:each) { snapshot.reject! { true } }
 
           it "deletes the snapshot out of Redis" do
-            expect(EventStore.redis.keys(snapshot.snapshot_table).length).to eq(0)
-            expect(EventStore.redis.keys(snapshot.snapshot_event_id_table).length).to eq(0)
+            expect(redis.keys(snapshot.snapshot_table).length).to eq(0)
+            expect(redis.keys(snapshot.snapshot_event_id_table).length).to eq(0)
           end
         end
       end

data/spec/unit/snapshot_unit_spec.rb

@@ -3,7 +3,7 @@ require "mock_redis"
 
 module EventStore
   describe Snapshot do
-    let(:redis)            { EventStore.redis }
+    let(:redis)            { EventStore.redis("") } # there's only one in test env anyway
     let(:aggregate_type)   { "awesome" }
     let(:aggregate_id)     { "superman" }
     let(:events)           { [] }
@@ -14,7 +14,7 @@ module EventStore
              type: aggregate_type,
              id: aggregate_id,
              events: double(all: events),
-             checkpoint_event: checkpoint_event,
+             checkpoint_events: [checkpoint_event],
              snapshot_events: double(all: snapshot_events))
     }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nexia_event_store
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Paul Saieg, John Colvin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-08 00:00:00.000000000 Z
+date: 2017-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -208,6 +208,7 @@ files:
 - spec/event_store/client_spec.rb
 - spec/event_store/config_spec.rb
 - spec/event_store/event_store_spec.rb
+- spec/event_store/event_stream_spec.rb
 - spec/event_store/serialized_binary_event_data.txt
 - spec/event_store/snapshot_spec.rb
 - spec/event_store/vertica guy notes.txt
@@ -235,7 +236,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of an EventSource (A+ES) for the Nexia Ecosystem
@@ -247,6 +248,7 @@ test_files:
 - spec/event_store/client_spec.rb
 - spec/event_store/config_spec.rb
 - spec/event_store/event_store_spec.rb
+- spec/event_store/event_stream_spec.rb
 - spec/event_store/serialized_binary_event_data.txt
 - spec/event_store/snapshot_spec.rb
 - spec/event_store/vertica guy notes.txt