estore 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ffaed9c9b3874fa4950a194ebc95a84474f5891
-  data.tar.gz: aa3d8f02bba1e085557a7fc0567b619d28b97467
+  metadata.gz: 18db1ad6f67a5c73ecd75dbe6fc80f5f03b717f2
+  data.tar.gz: 47b240aa7ce8fddbe969103718a42a1668575f8d
 SHA512:
-  metadata.gz: 1dc0acb4b9d8c53e5c58547cbdf610343c221646444f44341b0365d082e327f32c2c8234ac4efe1b8d7ee4faa3670b4c0abd4add84182cd5668085aa61de584e
-  data.tar.gz: 329da382ffb6ae45ad9c0033598232a2b757d0461a7071b569f479b1c3b75fc48e1fdb918b48eb7672b170732ef8659f5550b2ccabac3ed6cb48c807810f74db
+  metadata.gz: b5d4d2f91f7e7c2296684ac876e11b9c3959db6988e5b48cf0a8e5888723cd048acf68b14ebe159b0e9c2d4494030d2179912ef1777c6a4b878b5c85fbebcb60
+  data.tar.gz: abaeaa10b0ec1c4d623bddb40550cee7f8d8afe2eddf36f19baea5092548cd5a74b6dd8098329f6d07a5b2626c634e57ae45d3bb846d79868f57dd8e9bb6c035

data/estore.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Mathieu Ravaux', 'Héctor Ramón']
   spec.email         = ['mathieu.ravaux@gmail.com', 'hector0193@gmail.com']
   spec.summary       = 'An Event Store driver for Ruby'
-  spec.description   = spec.summary
+  spec.description   = 'TCP driver to read and write events to Event Store'
   spec.homepage      = 'https://github.com/rom-eventstore/estore'
   spec.license       = 'MIT'
 
@@ -22,6 +22,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'promise.rb', '~> 0.6.1'
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rubocop', '~> 0.28.0'
 end

data/lib/estore.rb

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

data/lib/estore/commands.rb

@@ -0,0 +1,8 @@
+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'

data/lib/estore/commands/append.rb

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,53 @@
+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/connection.rb

@@ -3,7 +3,9 @@ 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
-    attr_reader :host, :port, :context, :buffer, :mutex
+    extend Forwardable
+
+    delegate [:register, :remove] => :@context
 
     def initialize(host, port, context)
       @host = host
@@ -18,65 +20,25 @@ module Estore
       socket.close
     end
 
-    def send_command(command, msg = nil, handler = nil, uuid = nil)
-      code = COMMANDS.fetch(command)
+    def write(uuid, command, msg = nil)
       msg.validate! if msg
 
-      correlation_id = uuid || SecureRandom.uuid
-      frame = Package.encode(code, correlation_id, msg)
+      code = COMMANDS.fetch(command)
+      frame = Package.encode(code, uuid, msg)
 
-      mutex.synchronize do
-        promise = context.register_command(correlation_id, command, handler)
+      @mutex.synchronize do
         socket.write(frame.to_s)
-        promise
       end
     end
 
     private
 
-    # 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))
+    def on_received_package(message, type, uuid, _flags)
+      if type == 'HeartbeatRequestCommand'
+        write(SecureRandom.uuid, 'HeartbeatResponseCommand')
       else
-        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
+        @context.dispatch(uuid, message, type)
       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
@@ -84,7 +46,7 @@ module Estore
     end
 
     def connect
-      @socket = TCPSocket.open(host, port)
+      @socket = TCPSocket.open(@host, @port)
       Thread.new do
         process_downstream
       end
@@ -92,12 +54,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
@@ -112,8 +74,10 @@ module Estore
     end
 
     def on_exception(error)
-      puts "process_downstream_error #{error.inspect}"
-      context.on_error(error)
+      puts "process_downstream_error"
+      puts error.message
+      puts error.backtrace
+      @context.on_error(error)
     end
   end
 end

data/lib/estore/connection/buffer.rb

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

data/lib/estore/connection_context.rb

@@ -1,92 +1,28 @@
 require 'promise'
 
 module Estore
-  # 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
+  # Registry storing handlers for the pending commands
   class ConnectionContext
-    attr_reader :mutex,  :requests, :targets
     def initialize
       @mutex = Mutex.new
-      @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
+      @commands = {}
     end
 
-    def rejected_command(uuid, error)
-      prom = nil
-
-      mutex.synchronize do
-        prom = requests.delete(uuid)
+    def register(command)
+      @mutex.synchronize do
+        @commands[command.uuid] = command
       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 on_error(error = nil, &block)
-      if block
-        @error_handler = block
-      else
-        @error_handler.call(error) if @error_handler
+    def remove(command)
+      @mutex.synchronize do
+        @commands.delete(command.uuid)
       end
     end
 
-    private
-
-    def promise(uuid, target = nil)
-      prom = Promise.new(uuid)
-      mutex.synchronize do
-        requests[uuid] = prom
-        targets[uuid] = target
-      end
-      prom
+    def dispatch(uuid, message, type)
+      command = @commands[uuid]
+      command.handle(message, type) if command
     end
   end
 end

data/lib/estore/errors.rb

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

data/lib/estore/session.rb

@@ -31,70 +31,44 @@ module Estore
     end
 
     def ping
-      command('Ping')
+      command(Commands::Ping)
     end
 
-    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
-      )
+    def read(stream, options = {})
+      from = options[:from] || 0
+      limit = options[:limit]
 
-      command('ReadStreamEventsForward', msg)
+      if limit
+        read_batch(stream, from, limit)
+      else
+        read_forward(stream, from)
+      end
     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
-      )
-
-      command('WriteEvents', msg)
+    def read_batch(stream, from, limit)
+      command(Commands::ReadBatch, stream, from, limit).call
     end
 
-    def subscribe(stream, handler, options = {})
-      msg = SubscribeToStream.new(
-        event_stream_id: stream,
-        resolve_link_tos: options[:resolve_link_tos]
-      )
+    def read_forward(stream, from, batch_size = nil, &block)
+      command(Commands::ReadForward, stream, from, batch_size, &block).call
+    end
 
-      command('SubscribeToStream', msg, handler)
+    def append(stream, events, options = {})
+      command(Commands::Append, stream, events, options).call
     end
 
     def subscription(stream, options = {})
-      if options[:catch_up_from]
-        CatchUpSubscription.new(self, stream, options[:catch_up_from], options)
+      if options[:from]
+        command(Commands::CatchUpSubscription, stream, options[:from], options)
       else
-        Subscription.new(self, stream, options)
+        command(Commands::Subscription, stream, options)
       end
     end
 
     private
 
-    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)
+    def command(command, *args)
+      command.new(connection, *args)
     end
   end
 end

data/lib/estore/version.rb

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

data/spec/integration/session_spec.rb

@@ -33,74 +33,88 @@ describe Estore::Session do
     "test-#{SecureRandom.uuid}"
   end
 
-  def populate(count, stream = nil)
+  def stream_with(count, stream = nil)
     stream ||= random_stream
     session.append(stream, events(count)).sync
     stream
   end
 
-  it 'reads events from a stream' do
-    stream = populate(20)
-    read = session.read(stream, 0, 20).sync
+  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
 
-    expect(read.events.size).to be(20)
+  it 'reads all the events from a stream' do
+    events = session.read(stream_with(200)).sync
 
-    read.events.each_with_index do |event, index|
-      expect(parse_data(event)).to eql('id' => index)
-    end
+    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
+
+    expect(events.size).to be(80)
+    expect(events).to start_from(20)
+  end
+
+  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)
   end
 
   it 'allows to make a live subscription' do
     stream = random_stream
-    received = 0
+    received = []
 
-    sub = session.subscription(stream)
-    sub.on_error { |error| raise error.inspect }
-
-    sub.on_event do |event|
-      expect(parse_data(event)).to eql('id' => received)
-      received += 1
-    end
+    stream_with(20, stream)
 
+    sub = session.subscription(stream)
+    sub.on_event { |event| received << event }
     sub.start
 
-    populate(50, stream)
+    stream_with(50, stream)
 
     Timeout.timeout(5) do
       loop do
-        break if received >= 50
+        break if received.size >= 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 = 0
+    received = []
 
-    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
+    stream_with(2100, stream)
 
+    sub = session.subscription(stream, from: 20)
+    sub.on_event { |event| received << event }
     sub.start
 
     Thread.new do
       50.times do
-        populate(2, stream)
+        stream_with(2, stream)
       end
     end
 
     Timeout.timeout(5) do
       loop do
-        break if received >= 130
+        break if received.size >= 2180
         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.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Mathieu Ravaux
@@ -57,16 +57,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +81,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.28.0
-description: An Event Store driver for Ruby
+description: TCP driver to read and write events to Event Store
 email:
 - mathieu.ravaux@gmail.com
 - hector0193@gmail.com
@@ -100,17 +100,24 @@ files:
 - Rakefile
 - estore.gemspec
 - lib/estore.rb
-- lib/estore/catchup_subscription.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/connection.rb
 - lib/estore/connection/buffer.rb
-- lib/estore/connection/commands.rb
+- lib/estore/connection/protocol.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/catchup_subscription.rb

@@ -1,87 +0,0 @@
-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/subscription.rb

@@ -1,57 +0,0 @@
-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