estore 0.0.1

data/lib/estore/connection/buffer.rb

@@ -0,0 +1,67 @@
+class Eventstore
+  class Connection
+    # Buffer receives data from the TCP connection, and parses the binary packages.
+    # Parsed packages are given back to the given handler as they are decoded.
+    class Buffer
+      attr_reader :buffer, :handler, :mutex
+      def initialize(&block)
+        @mutex = Mutex.new
+        @buffer = ''.force_encoding('BINARY')
+        @handler = block
+      end
+
+      def <<(bytes)
+        bytes = bytes.force_encoding('BINARY') if bytes.respond_to? :force_encoding
+        mutex.synchronize do
+          @buffer << bytes
+        end
+
+        consume_available_packages
+      end
+
+      def consume_available_packages
+        while consume_package
+        end
+      end
+
+      def consume_package
+        pkg = read_package
+        if pkg
+          handle(pkg)
+          discard_bytes(pkg)
+          true
+        else
+          false
+        end
+      end
+
+      def read_package
+        return nil if buffer.length < 4
+        package_length = buffer[0...4].unpack('l<').first
+        bytes = buffer[4...(4 + package_length)].dup
+        bytes if bytes.bytesize >= package_length
+      end
+
+      def discard_bytes(pkg)
+        mutex.synchronize do
+          @buffer = buffer[(4 + pkg.bytesize)..-1]
+        end
+      end
+
+      def handle(pkg)
+        code, flags, uuid_bytes, message = parse(pkg)
+        command = Eventstore::Connection.command_name(code)
+        handler.call(command, message, Package.parse_uuid(uuid_bytes), flags)
+      end
+
+      def parse(pkg)
+        [
+          pkg[0].unpack('C').first,
+          pkg[1].unpack('C').first,
+          pkg[2...(2 + 16)],
+          pkg[18..-1]
+        ]
+      end
+    end
+  end
+end

data/lib/estore/connection/commands.rb

@@ -0,0 +1,90 @@
+class Eventstore
+  # Mapping between command names and codes
+  # From https://github.com/EventStore/EventStore/blob/master/src/EventStore.ClientAPI/SystemData/TcpCommand.cs
+  class Connection
+    COMMANDS = {
+      'HeartbeatRequestCommand'.freeze => 0x01,
+      'HeartbeatResponseCommand'.freeze => 0x02,
+
+      'Ping'.freeze => 0x03,
+      'Pong'.freeze => 0x04,
+
+      'PrepareAck'.freeze => 0x05,
+      'CommitAck'.freeze => 0x06,
+
+      'SlaveAssignment'.freeze => 0x07,
+      'CloneAssignment'.freeze => 0x08,
+
+      'SubscribeReplica'.freeze => 0x10,
+      'ReplicaLogPositionAck'.freeze => 0x11,
+      'CreateChunk'.freeze => 0x12,
+      'RawChunkBulk'.freeze => 0x13,
+      'DataChunkBulk'.freeze => 0x14,
+      'ReplicaSubscriptionRetry'.freeze => 0x15,
+      'ReplicaSubscribed'.freeze => 0x16,
+
+      # "CLIENT COMMANDS
+      # "CreateStream".freeze => 0x80,
+      # "CreateStreamCompleted".freeze => 0x81,
+
+      'WriteEvents'.freeze => 0x82,
+      'WriteEventsCompleted'.freeze => 0x83,
+
+      'TransactionStart'.freeze => 0x84,
+      'TransactionStartCompleted'.freeze => 0x85,
+      'TransactionWrite'.freeze => 0x86,
+      'TransactionWriteCompleted'.freeze => 0x87,
+      'TransactionCommit'.freeze => 0x88,
+      'TransactionCommitCompleted'.freeze => 0x89,
+
+      'DeleteStream'.freeze => 0x8A,
+      'DeleteStreamCompleted'.freeze => 0x8B,
+
+      'ReadEvent'.freeze => 0xB0,
+      'ReadEventCompleted'.freeze => 0xB1,
+      'ReadStreamEventsForward'.freeze => 0xB2,
+      'ReadStreamEventsForwardCompleted'.freeze => 0xB3,
+      'ReadStreamEventsBackward'.freeze => 0xB4,
+      'ReadStreamEventsBackwardCompleted'.freeze => 0xB5,
+      'ReadAllEventsForward'.freeze => 0xB6,
+      'ReadAllEventsForwardCompleted'.freeze => 0xB7,
+      'ReadAllEventsBackward'.freeze => 0xB8,
+      'ReadAllEventsBackwardCompleted'.freeze => 0xB9,
+
+      'SubscribeToStream'.freeze => 0xC0,
+      'SubscriptionConfirmation'.freeze => 0xC1,
+      'StreamEventAppeared'.freeze => 0xC2,
+      'UnsubscribeFromStream'.freeze => 0xC3,
+      'SubscriptionDropped'.freeze => 0xC4,
+      'ConnectToPersistentSubscription'.freeze => 0xC5,
+      'PersistentSubscriptionConfirmation'.freeze => 0xC6,
+      'PersistentSubscriptionStreamEventAppeared'.freeze => 0xC7,
+      'CreatePersistentSubscription'.freeze => 0xC8,
+      'CreatePersistentSubscriptionCompleted'.freeze => 0xC9,
+      'DeletePersistentSubscription'.freeze => 0xCA,
+      'DeletePersistentSubscriptionCompleted'.freeze => 0xCB,
+      'PersistentSubscriptionAckEvents'.freeze => 0xCC,
+      'PersistentSubscriptionNakEvents'.freeze => 0xCD,
+      'UpdatePersistentSubscription'.freeze => 0xCE,
+      'UpdatePersistentSubscriptionCompleted'.freeze => 0xCF,
+
+      'ScavengeDatabase'.freeze => 0xD0,
+      'ScavengeDatabaseCompleted'.freeze => 0xD1,
+
+      'BadRequest'.freeze => 0xF0,
+      'NotHandled'.freeze => 0xF1,
+      'Authenticate'.freeze => 0xF2,
+      'Authenticated'.freeze => 0xF3,
+      'NotAuthenticated'.freeze => 0xF4
+    }
+
+    def self.command_name(code)
+      @names ||= reverse_lookup_table
+      @names.fetch(code)
+    end
+
+    def self.reverse_lookup_table
+      COMMANDS.inject({}) { |h, (k, v)| h.merge!(v => k) }
+    end
+  end
+end

data/lib/estore/connection_context.rb

@@ -0,0 +1,90 @@
+require 'promise'
+
+class Eventstore
+  # Extension of a Ruby implementation of the Promises/A+ spec
+  # that carries the correlation id of the command.
+  # @see https://github.com/lgierth/promise.rb
+  class Promise < ::Promise
+    attr_reader :correlation_id
+    def initialize(correlation_id)
+      super()
+      @correlation_id = correlation_id
+    end
+
+    def wait
+      t = Thread.current
+      resume = proc { t.wakeup }
+      self.then(resume, resume)
+      sleep
+    end
+  end
+
+  # Registry storing handlers for the outstanding commands and
+  # current subscriptions
+  class ConnectionContext
+    attr_reader :mutex,  :requests, :targets
+    def initialize
+      @mutex = Mutex.new
+      @requests = {}
+      @targets = {}
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength
+    def register_command(uuid, command, target = nil)
+      # p fn: "register_command", uuid: uuid, command: command
+      case command
+      when 'Ping' then promise(uuid)
+      when 'ReadStreamEventsForward' then promise(uuid)
+      when 'SubscribeToStream' then promise(uuid, target)
+      when 'WriteEvents' then promise(uuid)
+      when 'HeartbeatResponseCommand' then :nothing_to_do
+      when 'UnsubscribeFromStream' then :nothing_to_do
+      else fail("Unknown command #{command}")
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength
+
+    def fulfilled_command(uuid, value)
+      prom = nil
+      mutex.synchronize do
+        prom = requests.delete(uuid)
+      end
+      # p fn: "fulfilled_command", uuid: uuid, prom: prom, requests: requests
+      prom.fulfill(value) if prom
+    end
+
+    def rejected_command(uuid, error)
+      prom = nil
+      mutex.synchronize do
+        prom = requests.delete(uuid)
+      end
+      # p fn: "fulfilled_command", uuid: uuid, prom: prom, requests: requests
+      prom.reject(error) if prom
+    end
+
+    def trigger(uuid, method, *args)
+      target = mutex.synchronize { targets[uuid] }
+      return if target.nil?
+      target.__send__(method, *args)
+    end
+
+    def on_error(error = nil, &block)
+      if block
+        @error_handler = block
+      else
+        @error_handler.call(error) if @error_handler
+      end
+    end
+
+    private
+
+    def promise(uuid, target = nil)
+      prom = Promise.new(uuid)
+      mutex.synchronize do
+        requests[uuid] = prom
+        targets[uuid] = target
+      end
+      prom
+    end
+  end
+end

data/lib/estore/errors.rb

@@ -0,0 +1,4 @@
+class Eventstore
+  class CannotConnectError < RuntimeError; end
+  class DisconnectionError < RuntimeError; end
+end

data/lib/estore/message_extensions.rb

@@ -0,0 +1,19 @@
+class Eventstore
+  # @see https://github.com/EventStore/EventStore/blob/master/src/EventStore.Core/Data/ResolvedEvent.cs#L9
+  module OriginalEventMixin
+    def original_event
+      link ? link : event
+    end
+
+    def original_stream_id
+      original_event.event_stream_id
+    end
+
+    def original_event_number
+      original_event.event_number
+    end
+  end
+end
+
+Eventstore::ResolvedEvent.include(Eventstore::OriginalEventMixin)
+Eventstore::ResolvedIndexedEvent.include(Eventstore::OriginalEventMixin)

data/lib/estore/messages.rb

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