estore 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1eaa9c5801e991ca2643e6412176c10144e2dcb7
-  data.tar.gz: 61800929c52882a40cb9fd234a0238902d7e66b0
+  metadata.gz: 4ffaed9c9b3874fa4950a194ebc95a84474f5891
+  data.tar.gz: aa3d8f02bba1e085557a7fc0567b619d28b97467
 SHA512:
-  metadata.gz: a5231c8eb6a0e0713b71b2f80c9640892202cee0aaed8f224b975dad02739b9c3f90c2feec3bdc33302a67e80fd895e3ec11b03f0cc546f4eab43359231fd278
-  data.tar.gz: 9da5606ca43d26bcac0ce1e860ae290b162de59d49691107a7fd92dd83ab643ffd1a726ff8cc1369b8c94633b1ddf4ba516153e36579add0b5c66ce6dd9d9cfa
+  metadata.gz: 1dc0acb4b9d8c53e5c58547cbdf610343c221646444f44341b0365d082e327f32c2c8234ac4efe1b8d7ee4faa3670b4c0abd4add84182cd5668085aa61de584e
+  data.tar.gz: 329da382ffb6ae45ad9c0033598232a2b757d0461a7071b569f479b1c3b75fc48e1fdb918b48eb7672b170732ef8659f5550b2ccabac3ed6cb48c807810f74db

data/lib/estore/catchup_subscription.rb

@@ -0,0 +1,87 @@
+module Estore
+  # Catch-Up Subscriptions
+  #
+  # This kind of subscription specifies a starting point, in the form of an
+  # event number or transaction file position. The given function will be
+  # called for events from the starting point until the end of the stream,
+  # and then for subsequently written events.
+  #
+  # For example, if a starting point of 50 is specified when a stream has 100
+  # events in it, the subscriber can expect to see events 51 through 100, and
+  # then any events subsequently written until such time as the subscription is
+  # dropped or closed.
+  class CatchUpSubscription < Subscription
+    MAX_READ_BATCH = 100
+
+    attr_reader :from, :caught_up
+
+    def initialize(estore, stream, from, options = {})
+      super(estore, stream, options)
+
+      @from = from
+      @caught_up = false
+      @mutex = Mutex.new
+      @queue = []
+      @position = from - 1
+      @batch_size = options[:batch_size] || 100
+    end
+
+    def on_catchup(&block)
+      @on_catchup = block if block
+    end
+
+    def start
+      subscribe
+      backfill
+      switch_to_live
+      call_on_catchup
+    end
+
+    private
+
+    def event_appeared(event)
+      unless caught_up
+        @mutex.synchronize do
+          @queue.push(event) unless caught_up
+        end
+      end
+      dispatch(event) if caught_up
+    end
+
+    def switch_to_live
+      @mutex.synchronize do
+        dispatch_events(received_while_backfilling)
+        @queue = nil
+        @caught_up = true
+      end
+    end
+
+    def backfill
+      loop do
+        events, finished = fetch_batch(@position + 1)
+        @mutex.synchronize do
+          dispatch_events(events)
+        end
+        break if finished
+      end
+    end
+
+    def dispatch_events(events)
+      events.each { |e| dispatch(e) }
+    end
+
+    def fetch_batch(from)
+      prom = @estore.read(stream, from, @batch_size)
+      response = prom.sync
+      [Array(response.events), response.is_end_of_stream]
+    end
+
+    def received_while_backfilling
+      @queue.find_all { |event| event.original_event_number > @position }
+    end
+
+    def call_on_catchup
+      @on_catchup.call if @on_catchup
+    end
+  end
+end

data/lib/estore/connection/buffer.rb

@@ -4,6 +4,7 @@ module Estore
     # 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')
@@ -14,37 +15,46 @@ module Estore
         bytes = bytes.force_encoding('BINARY') if
           bytes.respond_to? :force_encoding
 
-        @mutex.synchronize do
+        mutex.synchronize do
           @buffer << bytes
         end
 
-        consume_packages
+        consume_available_packages
       end
 
-      def consume_packages
-        while (pkg = read_package)
+      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
+        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]
+        mutex.synchronize do
+          @buffer = buffer[(4 + pkg.bytesize)..-1]
         end
       end
 
       def handle(pkg)
         code, flags, uuid_bytes, message = parse(pkg)
         command = Estore::Connection.command_name(code)
-        @handler.call(message, command, Package.parse_uuid(uuid_bytes), flags)
+        handler.call(command, message, Package.parse_uuid(uuid_bytes), flags)
       end
 
       def parse(pkg)

data/lib/estore/connection.rb

@@ -3,9 +3,7 @@ module Estore
   # It also starts a background thread to read from the TCP socket and handle
   # received packages, dispatching them to the calling app.
   class Connection
-    extend Forwardable
-
-    delegate [:register, :remove] => :@context
+    attr_reader :host, :port, :context, :buffer, :mutex
 
     def initialize(host, port, context)
       @host = host
@@ -20,25 +18,65 @@ module Estore
       socket.close
     end
 
-    def write(uuid, command, msg = nil)
+    def send_command(command, msg = nil, handler = nil, uuid = nil)
+      code = COMMANDS.fetch(command)
       msg.validate! if msg
 
-      code = COMMANDS.fetch(command)
-      frame = Package.encode(code, uuid, msg)
+      correlation_id = uuid || SecureRandom.uuid
+      frame = Package.encode(code, correlation_id, msg)
 
-      @mutex.synchronize do
+      mutex.synchronize do
+        promise = context.register_command(correlation_id, command, handler)
         socket.write(frame.to_s)
+        promise
       end
     end
 
     private
 
-    def on_received_package(message, type, uuid, _flags)
-      if type == 'HeartbeatRequestCommand'
-        write(SecureRandom.uuid, 'HeartbeatResponseCommand')
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def on_received_package(command, message, uuid, _flags)
+      case command
+      when 'Pong'
+        context.fulfill(uuid, 'Pong')
+      when 'HeartbeatRequestCommand'
+        send_command('HeartbeatResponseCommand')
+      when 'SubscriptionConfirmation'
+        context.fulfill(uuid, decode(SubscriptionConfirmation, message))
+      when 'ReadStreamEventsForwardCompleted'
+        context.fulfill(uuid, decode(ReadStreamEventsCompleted, message))
+      when 'StreamEventAppeared'
+        resolved_event = decode(StreamEventAppeared, message).event
+        context.trigger(uuid, :event_appeared, resolved_event)
+      when 'WriteEventsCompleted'
+        on_write_events_completed(uuid, decode(WriteEventsCompleted, message))
       else
-        @context.dispatch(uuid, message, type)
+        raise command
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+
+    def on_write_events_completed(uuid, response)
+      if response.result != OperationResult::Success
+        p fn: 'on_write_events_completed', at: error, result: response.result
+        context.rejected_command(uuid, response)
+        return
       end
+
+      context.fulfill(uuid, response)
+    end
+
+    def decode(type, message)
+      type.decode(message)
+    rescue => error
+      puts "Protobuf decoding error on connection #{object_id}"
+      puts error.inspect
+      p type: type, message: message
+      puts "\n\n"
+      puts(*error.backtrace)
+      raise error
     end
 
     def socket
@@ -46,7 +84,7 @@ module Estore
     end
 
     def connect
-      @socket = TCPSocket.open(@host, @port)
+      @socket = TCPSocket.open(host, port)
       Thread.new do
         process_downstream
       end
@@ -54,12 +92,12 @@ module Estore
     rescue TimeoutError, Errno::ECONNREFUSED, Errno::EHOSTDOWN,
            Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ETIMEDOUT
       raise CannotConnectError, "Error connecting to Eventstore on "\
-        "#{@host.inspect}:#{@port.inspect} (#{$ERROR_INFO.class})"
+        "#{host.inspect}:#{port.inspect} (#{$ERROR_INFO.class})"
     end
 
     def process_downstream
       loop do
-        @buffer << socket.sysread(4096)
+        buffer << socket.sysread(4096)
       end
     rescue IOError, EOFError
       on_disconnect
@@ -74,10 +112,8 @@ module Estore
     end
 
     def on_exception(error)
-      puts "process_downstream_error"
-      puts error.message
-      puts error.backtrace
-      @context.on_error(error)
+      puts "process_downstream_error #{error.inspect}"
+      context.on_error(error)
     end
   end
 end

data/lib/estore/connection_context.rb

@@ -1,28 +1,92 @@
 require 'promise'
 
 module Estore
-  # Registry storing handlers for the pending commands
+  # 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
-      @commands = {}
+      @requests = {}
+      @targets = {}
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    def register_command(uuid, command, target = nil)
+      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 raise "Unknown command #{command}"
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+    def fulfill(uuid, value)
+      prom = nil
+
+      mutex.synchronize do
+        prom = requests.delete(uuid)
+      end
+
+      prom.fulfill(value) if prom
     end
 
-    def register(command)
-      @mutex.synchronize do
-        @commands[command.uuid] = command
+    def rejected_command(uuid, error)
+      prom = nil
+
+      mutex.synchronize do
+        prom = requests.delete(uuid)
       end
+
+      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 remove(command)
-      @mutex.synchronize do
-        @commands.delete(command.uuid)
+    def on_error(error = nil, &block)
+      if block
+        @error_handler = block
+      else
+        @error_handler.call(error) if @error_handler
       end
     end
 
-    def dispatch(uuid, message, type)
-      command = @commands[uuid]
-      command.handle(message, type) if command
+    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

@@ -1,4 +1,4 @@
 module Estore
-  CannotConnectError = Class.new(RuntimeError)
-  DisconnectionError = Class.new(RuntimeError)
+  class CannotConnectError < RuntimeError; end
+  class DisconnectionError < RuntimeError; end
 end

data/lib/estore/session.rb

@@ -31,44 +31,70 @@ module Estore
     end
 
     def ping
-      command(Commands::Ping)
+      command('Ping')
     end
 
-    def read(stream, options = {})
-      from = options[:from] || 0
-      limit = options[:limit]
+    def read(stream, start, limit)
+      msg = ReadStreamEvents.new(
+        event_stream_id: stream,
+        from_event_number: start,
+        max_count: limit,
+        resolve_link_tos: true,
+        require_master: false
+      )
 
-      if limit
-        read_batch(stream, from, limit)
-      else
-        read_forward(stream, from)
-      end
+      command('ReadStreamEventsForward', msg)
     end
 
-    def read_batch(stream, from, limit)
-      command(Commands::ReadBatch, stream, from, limit).call
-    end
+    def append(stream, events, options = {})
+      msg = WriteEvents.new(
+        event_stream_id: stream,
+        expected_version: options[:expected_version] || -2,
+        events: Array(events).map { |event| new_event(event) },
+        require_master: true
+      )
 
-    def read_forward(stream, from, batch_size = nil, &block)
-      command(Commands::ReadForward, stream, from, batch_size, &block).call
+      command('WriteEvents', msg)
     end
 
-    def append(stream, events, options = {})
-      command(Commands::Append, stream, events, options).call
+    def subscribe(stream, handler, options = {})
+      msg = SubscribeToStream.new(
+        event_stream_id: stream,
+        resolve_link_tos: options[:resolve_link_tos]
+      )
+
+      command('SubscribeToStream', msg, handler)
     end
 
     def subscription(stream, options = {})
-      if options[:from]
-        command(Commands::CatchUpSubscription, stream, options[:from], options)
+      if options[:catch_up_from]
+        CatchUpSubscription.new(self, stream, options[:catch_up_from], options)
       else
-        command(Commands::Subscription, stream, options)
+        Subscription.new(self, stream, options)
       end
     end
 
     private
 
-    def command(command, *args)
-      command.new(connection, *args)
+    CONTENT_TYPES = {
+      json: 1
+    }
+
+    def new_event(event)
+      uuid = event[:id] || SecureRandom.uuid
+      content_type = event.fetch(:content_type, :json)
+
+      NewEvent.new(
+        event_id: Package.encode_uuid(uuid),
+        event_type: event[:type],
+        data: event[:data],
+        data_content_type: CONTENT_TYPES.fetch(content_type, 0),
+        metadata_content_type: 1
+      )
+    end
+
+    def command(*args)
+      connection.send_command(*args)
     end
   end
 end

data/lib/estore/subscription.rb

@@ -0,0 +1,57 @@
+module Estore
+  # 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 :id, :stream, :resolve_link_tos, :position
+
+    def initialize(estore, stream, options = {})
+      @estore = estore
+      @stream = stream
+      @resolve_link_tos = options.fetch(:resolve_link_tos, true)
+    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
+      @estore.unsubscribe(id) if id
+      @id = nil
+    end
+
+    private
+
+    def subscribe
+      prom = @estore.subscribe(stream, self, resolve_link_tos: 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

@@ -1,3 +1,3 @@
 module Estore
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/estore.rb

@@ -6,5 +6,6 @@ require 'estore/message_extensions'
 require 'estore/connection_context'
 require 'estore/connection'
 require 'estore/connection/buffer'
-require 'estore/connection/protocol'
-require 'estore/commands'
+require 'estore/connection/commands'
+require 'estore/subscription'
+require 'estore/catchup_subscription'

data/spec/integration/session_spec.rb

@@ -33,88 +33,74 @@ describe Estore::Session do
     "test-#{SecureRandom.uuid}"
   end
 
-  def stream_with(count, stream = nil)
+  def populate(count, stream = nil)
     stream ||= random_stream
     session.append(stream, events(count)).sync
     stream
   end
 
-  RSpec::Matchers.define :start_from do |start|
-    match do |events|
-      events.each_with_index do |event, index|
-        expect(parse_data(event)).to eql('id' => index + start)
-      end
-    end
-  end
-
-  it 'reads all the events from a stream' do
-    events = session.read(stream_with(200)).sync
-
-    expect(events.size).to be(200)
-    expect(events).to start_from(0)
-  end
-
-  it 'reads all the events forward from a stream' do
-    events = session.read(stream_with(100), from: 20).sync
+  it 'reads events from a stream' do
+    stream = populate(20)
+    read = session.read(stream, 0, 20).sync
 
-    expect(events.size).to be(80)
-    expect(events).to start_from(20)
-  end
+    expect(read.events.size).to be(20)
 
-  it 'reads a batch of events from a stream' do
-    events = session.read(stream_with(30), from: 10, limit: 15).sync
-
-    expect(events.size).to be(15)
-    expect(events).to start_from(10)
+    read.events.each_with_index do |event, index|
+      expect(parse_data(event)).to eql('id' => index)
+    end
   end
 
   it 'allows to make a live subscription' do
     stream = random_stream
-    received = []
-
-    stream_with(20, stream)
+    received = 0
 
     sub = session.subscription(stream)
-    sub.on_event { |event| received << event }
+    sub.on_error { |error| raise error.inspect }
+
+    sub.on_event do |event|
+      expect(parse_data(event)).to eql('id' => received)
+      received += 1
+    end
+
     sub.start
 
-    stream_with(50, stream)
+    populate(50, stream)
 
     Timeout.timeout(5) do
       loop do
-        break if received.size >= 50
+        break if received >= 50
         sleep(0.1)
       end
     end
-
-    expect(received.size).to be(50)
-    expect(received).to start_from(20)
   end
 
   it 'allows to make a catchup subscription' do
     stream = random_stream
-    received = []
+    received = 0
 
-    stream_with(2100, stream)
+    populate(50, stream)
+
+    sub = session.subscription(stream, catch_up_from: 20)
+    sub.on_error { |error| raise error.inspect }
+
+    sub.on_event do |event|
+      expect(parse_data(event)).to eql('id' => received + 20)
+      received += 1
+    end
 
-    sub = session.subscription(stream, from: 20)
-    sub.on_event { |event| received << event }
     sub.start
 
     Thread.new do
       50.times do
-        stream_with(2, stream)
+        populate(2, stream)
       end
     end
 
     Timeout.timeout(5) do
       loop do
-        break if received.size >= 2180
+        break if received >= 130
         sleep(0.1)
       end
     end
-
-    expect(received.size).to be(2180)
-    expect(received).to start_from(20)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: estore
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Mathieu Ravaux
@@ -100,24 +100,17 @@ files:
 - Rakefile
 - estore.gemspec
 - lib/estore.rb
-- lib/estore/commands.rb
-- lib/estore/commands/append.rb
-- lib/estore/commands/base.rb
-- lib/estore/commands/catch_up_subscription.rb
-- lib/estore/commands/ping.rb
-- lib/estore/commands/promise.rb
-- lib/estore/commands/read_batch.rb
-- lib/estore/commands/read_forward.rb
-- lib/estore/commands/subscription.rb
+- lib/estore/catchup_subscription.rb
 - lib/estore/connection.rb
 - lib/estore/connection/buffer.rb
-- lib/estore/connection/protocol.rb
+- lib/estore/connection/commands.rb
 - lib/estore/connection_context.rb
 - lib/estore/errors.rb
 - lib/estore/message_extensions.rb
 - lib/estore/messages.rb
 - lib/estore/package.rb
 - lib/estore/session.rb
+- lib/estore/subscription.rb
 - lib/estore/version.rb
 - spec/integration/session_spec.rb
 - spec/spec_helper.rb

data/lib/estore/commands/append.rb

@@ -1,56 +0,0 @@
-module Estore
-  module Commands
-    class Append
-      include Command
-
-      CONTENT_TYPES = {
-        json: 1
-      }
-
-      def initialize(connection, stream, events, options = {})
-        super(connection)
-        @stream, @events, @options = stream, events, options
-      end
-
-      def call
-        msg = WriteEvents.new(
-          event_stream_id: @stream,
-          expected_version: @options[:expected_version] || -2,
-          events: Array(@events).map { |event| new_event(event) },
-          require_master: true
-        )
-
-        register!
-        write('WriteEvents', msg)
-        promise
-      end
-
-      def handle(message, *)
-        response = decode(WriteEventsCompleted, message)
-
-        if response.result != OperationResult::Success
-          # TODO: Create custom exceptions
-          raise "WriteEvents command failed with uuid #{@uuid}"
-        end
-
-        remove!
-        promise.fulfill(response)
-      end
-
-      private
-
-      def new_event(event)
-        uuid = event[:id] || SecureRandom.uuid
-        content_type = event.fetch(:content_type, :json)
-
-        NewEvent.new(
-          event_id: Package.encode_uuid(uuid),
-          event_type: event[:type],
-          data: event[:data],
-          data_content_type: CONTENT_TYPES.fetch(content_type, 0),
-          metadata_content_type: 1
-        )
-      end
-    end
-  end
-end

data/lib/estore/commands/base.rb

@@ -1,51 +0,0 @@
-module Estore
-  module Commands
-    module Command
-      attr_reader :uuid
-
-      def initialize(connection)
-        @connection = connection
-        @uuid = SecureRandom.uuid
-      end
-
-      def register!
-        @connection.register(self)
-      end
-
-      def remove!
-        @connection.remove(self)
-      end
-
-      def write(command, message = nil)
-        @connection.write(@uuid, command, message)
-      end
-
-      def promise
-        @promise ||= Promise.new(@uuid)
-      end
-
-      def decode(type, message)
-        type.decode(message)
-      rescue => error
-        puts "Protobuf decoding error on connection #{object_id}"
-        puts type: type, message: message
-        puts error.backtrace
-        raise error
-      end
-
-      module ReadStreamForward
-        def read(stream, from, limit)
-          msg = ReadStreamEvents.new(
-            event_stream_id: stream,
-            from_event_number: from,
-            max_count: limit,
-            resolve_link_tos: true,
-            require_master: false
-          )
-
-          write('ReadStreamEventsForward', msg)
-        end
-      end
-    end
-  end
-end

data/lib/estore/commands/catch_up_subscription.rb

@@ -1,60 +0,0 @@
-module Estore
-  module Commands
-    class CatchUpSubscription < Subscription
-      include Command
-
-      def initialize(connection, stream, from, options = {})
-        super(connection, options)
-        @stream = stream
-        @from = from
-        @batch = options[:batch_size]
-        @mutex = Mutex.new
-        @queue = []
-        @caught_up = false
-        @last_worker = nil
-      end
-
-      def start
-        super
-
-        # TODO: Think about doing something more clever?
-        read = ReadForward.new(@connection, @stream, @from, @batch) do |events|
-          @last_worker = Thread.new(@last_worker) do |last_worker|
-            last_worker.join if last_worker
-            events.each { |event| dispatch(event) }
-          end
-        end
-
-        read.call.sync
-        @last_worker.join if @last_worker
-
-        switch_to_live
-      end
-
-      def switch_to_live
-        @mutex.synchronize do
-          queued_events.each { |event| dispatch(event) }
-          @caught_up = true
-        end
-      end
-
-      def queued_events
-        @queue.find_all { |event| event.original_event_number > @position }
-      end
-
-      def handle(message, type)
-        if type == 'StreamEventAppeared'
-          event = decode(StreamEventAppeared, message).event
-
-          unless @caught_up
-            @mutex.synchronize do
-              @queue << event unless @caught_up
-            end
-          end
-
-          dispatch(event) if @caught_up
-        end
-      end
-    end
-  end
-end

data/lib/estore/commands/ping.rb

@@ -1,16 +0,0 @@
-module Estore
-  module Commands
-    class Ping
-      include Command
-
-      def call
-        write('Ping')
-        promise
-      end
-
-      def handle(*)
-        promise.fulfill('Pong')
-      end
-    end
-  end
-end

data/lib/estore/commands/promise.rb

@@ -1,19 +0,0 @@
-module Estore
-  module Commands
-    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
-  end
-end

data/lib/estore/commands/read_batch.rb

@@ -1,25 +0,0 @@
-module Estore
-  module Commands
-    class ReadBatch
-      include Command
-      include Command::ReadStreamForward
-
-      def initialize(connection, stream, from, limit)
-        super(connection)
-        @stream, @from, @limit = stream, from, limit
-      end
-
-      def call
-        register!
-        read(@stream, @from, @limit)
-        promise
-      end
-
-      def handle(message, *)
-        remove!
-        response = decode(ReadStreamEventsCompleted, message)
-        promise.fulfill(Array(response.events))
-      end
-    end
-  end
-end

data/lib/estore/commands/read_forward.rb

@@ -1,39 +0,0 @@
-module Estore
-  module Commands
-    class ReadForward
-      include Command
-      include Command::ReadStreamForward
-
-      def initialize(connection, stream, from, batch_size = nil, &block)
-        super(connection)
-
-        @stream = stream
-        @from = from
-        @batch_size = batch_size || 1000
-        @block = block
-        @events = []
-      end
-
-      def call
-        register!
-        read(@stream, @from, @batch_size)
-        promise
-      end
-
-      def handle(message, *)
-        response = decode(ReadStreamEventsCompleted, message)
-        events = Array(response.events)
-
-        @from += events.size
-        read(@stream, @from, @batch_size) unless response.is_end_of_stream
-
-        @block ? @block.call(events) : @events.push(*events)
-
-        if response.is_end_of_stream
-          remove!
-          promise.fulfill(@block ? nil : @events)
-        end
-      end
-    end
-  end
-end

data/lib/estore/commands/subscription.rb

@@ -1,53 +0,0 @@
-module Estore
-  module Commands
-    class Subscription
-      include Command
-
-      def initialize(connection, stream, options = {})
-        super(connection)
-        @has_finished = false
-        @stream = stream
-        @resolve_link_tos = options.fetch(:resolve_link_tos, true)
-      end
-
-      def finished?
-        @has_finished
-      end
-
-      def call
-        start
-      end
-
-      def start
-        raise 'Subscription block not defined' unless @handler
-
-        msg = SubscribeToStream.new(
-          event_stream_id: @stream,
-          resolve_link_tos: @resolve_link_tos
-        )
-
-        register!
-        write('SubscribeToStream', msg)
-      end
-
-      def close
-        write('UnsubscribeFromStream', UnsubscribeFromStream.new)
-        remove!
-      end
-
-      def on_event(&block)
-        @handler = block
-      end
-
-      def handle(message, type)
-        dispatch(decode(StreamEventAppeared, message).event) if
-          type == 'StreamEventAppeared'
-      end
-
-      def dispatch(event)
-        @position = event.original_event_number
-        @handler.call(event)
-      end
-    end
-  end
-end

data/lib/estore/commands.rb

@@ -1,8 +0,0 @@
-require 'estore/commands/promise'
-require 'estore/commands/base'
-require 'estore/commands/append'
-require 'estore/commands/ping'
-require 'estore/commands/read_batch'
-require 'estore/commands/read_forward'
-require 'estore/commands/subscription'
-require 'estore/commands/catch_up_subscription'