estore 0.0.1

data/lib/estore/package.rb

@@ -0,0 +1,31 @@
+class Eventstore
+  # Package is a length-prefixed binary frame transferred over TCP
+  class Package
+    def self.encode(code, correlation_id, msg)
+      command = Beefcake::Buffer.new
+      command << code
+      command << 0x0 # non authenticated
+      uuid_bytes = encode_uuid(correlation_id)
+      uuid_bytes.each_byte { |b| command << b }
+      msg.encode(command) if msg
+
+      prefix_with_length(command)
+    end
+
+    def self.prefix_with_length(command)
+      package = Beefcake::Buffer.new
+      package.append_fixed32(command.length)
+      package << command
+      package
+    end
+
+    def self.encode_uuid(uuid)
+      uuid.scan(/[0-9a-f]{4}/).map { |x| x.to_i(16) }.pack('n*')
+    end
+
+    def self.parse_uuid(bytes)
+      a, b, c, d, e, f, g, h = *bytes.unpack('n*').map { |n| n.to_s(16) }.map { |n| n.rjust(4, '0') }
+      [a, b, '-', c, '-', d, '-', e, '-', f, g, h].join('')
+    end
+  end
+end

data/lib/estore/subscription.rb

@@ -0,0 +1,57 @@
+class Eventstore
+  # Volatile Subscriptions
+  #
+  # This kind of subscription calls a given function for events written
+  # after the subscription is established.
+  #
+  # For example, if a stream has 100 events in it when a subscriber connects,
+  # the subscriber can expect to see event number 101 onwards until the time
+  # the subscription is closed or dropped.
+  class Subscription
+    attr_reader :eventstore, :stream, :resolve_link_tos, :id, :position
+
+    def initialize(eventstore, stream, resolve_link_tos: true)
+      @eventstore = eventstore
+      @stream = stream
+      @resolve_link_tos = resolve_link_tos
+    end
+
+    def on_error(&block)
+      @on_error = block if block
+    end
+
+    def on_event(&block)
+      @on_event = block if block
+    end
+
+    def start
+      subscribe
+    end
+
+    def stop
+      eventstore.unsubscribe_from_stream(id) if id
+      @id = nil
+    end
+
+    private
+
+    def subscribe
+      prom = eventstore.subscribe_to_stream(self, stream, resolve_link_tos)
+      @id = prom.correlation_id
+      prom.sync
+    end
+
+    def call_on_error(error)
+      @on_error.call(error) if @on_error
+    end
+
+    def dispatch(event)
+      @on_event.call(event) if @on_event
+      @position = event.original_event_number
+    end
+
+    def event_appeared(event)
+      dispatch(event)
+    end
+  end
+end

data/lib/estore/version.rb

@@ -0,0 +1,3 @@
+module EventStore
+  VERSION = '0.0.1'
+end

data/spec/eventstore_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Eventstore do
+  let(:es) { Eventstore.new('localhost', 1113) }
+  subject { new_estore }
+  let(:injector) { new_estore }
+
+  def new_estore
+    es = Eventstore.new('localhost', 1113)
+    es.on_error { |error| Thread.main.raise(error) }
+    es
+  end
+
+  it 'supports the PING command' do
+    Timeout.timeout(1) do
+      promise = es.ping
+      result = promise.sync
+      expect(result).to eql 'Pong'
+    end
+  end
+
+  def inject_event(stream)
+    event_type = 'TestEvent'
+    data = JSON.generate(at: Time.now.to_i, foo: 'bar')
+    event = injector.new_event(event_type, data)
+    # puts ">#{stream}\t\t#{event.inspect}"
+    prom = injector.write_events(stream, event)
+    prom.sync
+  end
+
+  it 'dumps the content of the outlet stream from the last checkpoint' do
+    inject_events('outlet', 50)
+    events = subject.read_stream_events_forward('outlet', 1, 20).sync
+    expect(events).to be_kind_of(Eventstore::ReadStreamEventsCompleted)
+    events.events.each do |event|
+      expect(event).to be_kind_of(Eventstore::ResolvedIndexedEvent)
+      JSON.parse(event.event.data)
+    end
+  end
+
+  def inject_events_async(stream, target)
+    Thread.new do
+      begin
+        inject_events(stream, target)
+      rescue => error
+        puts(error.inspect)
+        puts(*error.backtrace)
+        Thread.main.raise(error)
+      end
+    end
+  end
+
+  def inject_events(stream, target)
+    target.times do |_i|
+      inject_event(stream)
+    end
+  end
+
+  it 'allows to make a live subscription' do
+    stream = "catchup-test-#{SecureRandom.uuid}"
+    received = 0
+
+    sub = subject.new_subscription(stream)
+    sub.on_event { |_event| received += 1 }
+    sub.on_error { |error| fail(error.inspect) }
+    sub.start
+
+    inject_events(stream, 50)
+
+    Timeout.timeout(20) do
+      loop do
+        break if received >= 50
+        sleep(0.1)
+      end
+    end
+  end
+
+  it 'allows to make a catch-up subscription' do
+    stream = "catchup-test-#{SecureRandom.uuid}"
+    received = 0
+    mutex = Mutex.new
+
+    expect(subject.ping.sync).to eql 'Pong'
+
+    # puts "stream: #{stream}"
+
+    inject_events(stream, 1220)
+
+    sub = subject.new_catchup_subscription(stream, -1)
+    sub.on_event { |_event| mutex.synchronize { received += 1 } }
+    sub.on_error { |error| fail error.inspect }
+    sub.start
+
+    inject_events_async(stream, 780)
+
+    Timeout.timeout(10) do
+      loop do
+        break if received >= 2000
+        sleep(0.1)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'estore'
+
+require 'json'
+
+trap 'TTIN' do
+  Thread.list.each do |thread|
+    puts "Thread TID-#{thread.object_id.to_s(36)}"
+    puts thread.backtrace.join("\n")
+    puts "\n\n\n"
+  end
+end

data/vendor/proto/ClientMessageDtos.proto

@@ -0,0 +1,261 @@
+package EventStore.Client.Messages;
+
+enum OperationResult
+{
+	Success = 0;
+	PrepareTimeout = 1;
+	CommitTimeout = 2;
+	ForwardTimeout = 3;
+	WrongExpectedVersion = 4;
+	StreamDeleted = 5;
+	InvalidTransaction = 6;
+	AccessDenied = 7;
+}
+
+message NewEvent {
+	required bytes event_id = 1;
+	required string event_type = 2;
+	required int32 data_content_type = 3;
+	required int32 metadata_content_type = 4;
+	required bytes data = 5;
+	optional bytes metadata = 6;
+}
+
+message EventRecord {
+	required string event_stream_id = 1;
+	required int32 event_number = 2;
+	required bytes event_id = 3;
+	required string event_type = 4;
+	required int32 data_content_type = 5;
+	required int32 metadata_content_type = 6;
+	required bytes data = 7;
+	optional bytes metadata = 8;
+	optional int64 created = 9;
+	optional int64 created_epoch = 10;
+}
+
+message ResolvedIndexedEvent {
+	required EventRecord event = 1;
+	optional EventRecord link = 2;
+}
+
+message ResolvedEvent {
+	required EventRecord event = 1;
+	optional EventRecord link = 2;
+	required int64 commit_position = 3;
+	required int64 prepare_position = 4;
+}
+
+message WriteEvents {
+	required string event_stream_id = 1;
+	required int32 expected_version = 2;
+	repeated NewEvent events = 3;
+	required bool require_master = 4;
+}
+
+message WriteEventsCompleted {
+	required OperationResult result = 1;
+	optional string message = 2;
+	required int32 first_event_number = 3;
+	required int32 last_event_number = 4;
+	optional int64 prepare_position = 5;
+	optional int64 commit_position = 6;
+}
+
+message DeleteStream {
+	required string event_stream_id = 1;
+	required int32 expected_version = 2;
+	required bool require_master = 3;
+	optional bool hard_delete = 4;
+}
+
+message DeleteStreamCompleted {
+	required OperationResult result = 1;
+	optional string message = 2;
+	optional int64 prepare_position = 3;
+	optional int64 commit_position = 4;
+}
+
+message TransactionStart {
+	required string event_stream_id = 1;
+	required int32 expected_version = 2;
+	required bool require_master = 3;
+}
+
+message TransactionStartCompleted {
+	required int64 transaction_id = 1;
+	required OperationResult result = 2;
+	optional string message = 3;
+}
+
+message TransactionWrite {
+	required int64 transaction_id = 1;
+	repeated NewEvent events = 2;
+	required bool require_master = 3;
+}
+
+message TransactionWriteCompleted {
+	required int64 transaction_id = 1;
+	required OperationResult result = 2;
+	optional string message = 3;
+}
+
+message TransactionCommit {
+	required int64 transaction_id = 1;
+	required bool require_master = 2;
+}
+
+message TransactionCommitCompleted {
+	required int64 transaction_id = 1;
+	required OperationResult result = 2;
+	optional string message = 3;
+	required int32 first_event_number = 4;
+	required int32 last_event_number = 5;
+	optional int64 prepare_position = 6;
+	optional int64 commit_position = 7;
+}
+
+message ReadEvent {
+	required string event_stream_id = 1;
+	required int32 event_number = 2;
+	required bool resolve_link_tos = 3;
+	required bool require_master = 4;
+}
+
+message ReadEventCompleted {
+
+	enum ReadEventResult {
+		Success = 0;
+		NotFound = 1;
+		NoStream = 2;
+		StreamDeleted = 3;
+		Error = 4;
+		AccessDenied = 5;
+	}
+
+	required ReadEventResult result = 1;
+	required ResolvedIndexedEvent event = 2;
+
+	optional string error = 3;
+}
+
+message ReadStreamEvents {
+	required string event_stream_id = 1;
+	required int32 from_event_number = 2;
+	required int32 max_count = 3;
+	required bool resolve_link_tos = 4;
+	required bool require_master = 5;
+}
+
+message ReadStreamEventsCompleted {
+
+	enum ReadStreamResult {
+		Success = 0;
+		NoStream = 1;
+		StreamDeleted = 2;
+		NotModified = 3;
+		Error = 4;
+		AccessDenied = 5;
+	}
+
+	repeated ResolvedIndexedEvent events = 1;
+	required ReadStreamResult result = 2;
+	required int32 next_event_number = 3;
+	required int32 last_event_number = 4;
+	required bool is_end_of_stream = 5;
+	required int64 last_commit_position = 6;
+
+	optional string error = 7;
+}
+
+message ReadAllEvents {
+	required int64 commit_position = 1;
+	required int64 prepare_position = 2;
+	required int32 max_count = 3;
+	required bool resolve_link_tos = 4;
+	required bool require_master = 5;
+}
+
+message ReadAllEventsCompleted {
+
+	enum ReadAllResult {
+		Success = 0;
+		NotModified = 1;
+		Error = 2;
+		AccessDenied = 3;
+	}
+
+	required int64 commit_position = 1;
+	required int64 prepare_position = 2;
+	repeated ResolvedEvent events = 3;
+	required int64 next_commit_position = 4;
+	required int64 next_prepare_position = 5;
+
+	optional ReadAllResult result = 6 [default = Success];
+	optional string error = 7;
+}
+
+message SubscribeToStream {
+	required string event_stream_id = 1;
+	required bool resolve_link_tos = 2;
+}
+
+message SubscriptionConfirmation {
+	required int64 last_commit_position = 1;
+	optional int32 last_event_number = 2;
+}
+
+message StreamEventAppeared {
+	required ResolvedEvent event = 1;
+}
+
+message UnsubscribeFromStream {
+}
+
+message SubscriptionDropped {
+
+	enum SubscriptionDropReason {
+		Unsubscribed = 0;
+		AccessDenied = 1;
+	}
+	
+	optional SubscriptionDropReason reason = 1 [default = Unsubscribed];
+}
+
+message NotHandled {
+	
+	enum NotHandledReason {
+		NotReady = 0;
+		TooBusy = 1;
+		NotMaster = 2;
+	}
+	
+	required NotHandledReason reason = 1;
+	optional bytes additional_info = 2;
+
+	message MasterInfo {
+		required string external_tcp_address = 1;
+		required int32 external_tcp_port = 2;
+		required string external_http_address = 3;
+		required int32 external_http_port = 4;
+		optional string external_secure_tcp_address = 5;
+		optional int32 external_secure_tcp_port = 6;
+	}
+}
+
+message ScavengeDatabase {
+}
+
+message ScavengeDatabaseCompleted {
+	
+	enum ScavengeResult {
+		Success = 0;
+		InProgress = 1;
+		Failed = 2;
+	}
+	
+	required ScavengeResult result = 1;
+	optional string error = 2;
+	required int32 total_time_ms = 3;
+	required int64 total_space_saved = 4;
+}