estore 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a58e5f588a5c8c0d2b25fedf68429869effc0dd
+  data.tar.gz: f59bc201d6f2c2fcc9dcc5f1d2bb825a70f8aac7
+SHA512:
+  metadata.gz: 19c2507e00eca563cb754a645cc4b6a2dde55346a1f99d6a8b82ca406b30d73128e8e2ca5ea5761733514d33464b8a3fc16e7d4ba0618b6c5fae0fa2e08716ab
+  data.tar.gz: 43e2a30135b4b708cd9593e41a51692de8501b4b736db77e2aaf0a281caa7af64f84de2de090192daa626ce5e3b493fce2c298a005b0e0ac97ade2fc310066df

data/.gitignore

@@ -0,0 +1,18 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/bundle/
+/.idea/
+*.bundle
+*.so
+*.o
+*.a
+*.gem
+mkmf.log
+.rspec

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  Exclude:
+    - 'lib/estore/messages.rb'
+    - 'vendor/**/*'
+    - 'spec/fixtures/**/*'
+
+Metrics/LineLength:
+  Max: 140
+
+# Style/Documentation:
+#   Enabled: false

data/.yardopts

@@ -0,0 +1,2 @@
+--no-private
+--exclude lib/estore/messages.rb

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in estore.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Mathieu Ravaux
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,34 @@
+# Eventstore
+
+[![Join the chat at https://gitter.im/mathieuravaux/eventstore-ruby](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/mathieuravaux/eventstore-ruby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Ruby client library Eventstore
+
+Eventstore is an open-source, functional database
+with Complex Event Processing in JavaScript
+
+[![Circle CI](https://circleci.com/gh/mathieuravaux/eventstore-ruby.svg?style=svg)](https://circleci.com/gh/mathieuravaux/eventstore-ruby)
+
+## Install
+
+Add this line to your application's Gemfile and run Bundler:
+
+```ruby
+gem 'estore'
+```
+
+Or install it yourself as:
+
+    $ gem install estore
+
+## Usage
+
+
+
+## Contributing
+
+1. Fork it ( https://github.com/mathieuravaux/eventstore/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+VENDORED_PROTO = 'vendor/proto/ClientMessageDtos.proto'
+PROTO_URL = 'https://raw.githubusercontent.com/EventStore/EventStore/oss-v3.0.1/src/Protos/ClientAPI/ClientMessageDtos.proto'
+PROTO_DIR = 'lib/estore'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+desc 'Update the protobuf messages definition'
+task :proto do
+  system("wget -O #{VENDORED_PROTO} #{PROTO_URL}")
+  system("mkdir -p #{PROTO_DIR}")
+  beefcake_bin = Bundler.bin_path.join('protoc-gen-beefcake').to_s
+  if system("BEEFCAKE_NAMESPACE=Eventstore protoc --plugin=#{beefcake_bin} --beefcake_out lib/estore #{VENDORED_PROTO}")
+    FileUtils.mv('lib/estore/ClientMessageDtos.pb.rb', 'lib/estore/messages.rb')
+    system("sed -i '' 's/module Eventstore/class Eventstore/' lib/estore/messages.rb")
+  end
+end

data/circle.yml

@@ -0,0 +1,3 @@
+notify:
+  webhooks:
+    - url: https://webhooks.gitter.im/e/e20bfa93dc2e11895805

data/estore.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'estore/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'estore'
+  spec.version       = EventStore::VERSION
+  spec.authors       = ['Mathieu Ravaux', 'Héctor Ramón']
+  spec.email         = ['mathieu.ravaux@gmail.com', 'hector0193@gmail.com']
+  spec.summary       = 'Ruby client API for the Event Store.'
+  spec.description   = 'Event Store is an open-source, functional database with Complex Event Processing in JavaScript.'
+  spec.homepage      = 'https://github.com/rom-eventstore/eventstore-ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^spec\//)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'beefcake', '~> 1.1.0.pre1'
+  spec.add_dependency 'promise.rb', '~> 0.6.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
+end

data/lib/estore.rb

@@ -0,0 +1,92 @@
+require 'securerandom'
+
+# The Eventstore class is responsible for maintaining a full-duplex connection
+# between the client and the Event Store server.
+# EventStore is thread-safe, and it is recommended that only one instance per application is created.
+#
+# All operations are handled fully asynchronously, returning a promise.
+# If you need to execute synchronously, simply call .sync on the returned promise.
+#
+# To get maximum performance from the connection, it is recommended that it be used asynchronously.
+class Eventstore
+  attr_reader :host, :port, :connection, :context, :error_handler
+  def initialize(host, port = 2113)
+    @host = host
+    @port = port
+    @context = ConnectionContext.new
+    @connection = Connection.new(host, port, context)
+  end
+
+  def on_error(error = nil, &block)
+    context.on_error(error, &block)
+  end
+
+  def close
+    connection.close
+  end
+
+  def ping
+    command('Ping')
+  end
+
+  def new_event(event_type, data, content_type: 'json', uuid: nil)
+    uuid ||= SecureRandom.uuid
+    content_type_code = { 'json' => 1 }.fetch(content_type, 0)
+    NewEvent.new(
+      event_id: Package.encode_uuid(uuid),
+      event_type: event_type,
+      data: data,
+      data_content_type: content_type_code,
+      metadata_content_type: 1
+    )
+  end
+
+  def write_events(stream, events)
+    events = Array(events)
+    msg = WriteEvents.new(
+      event_stream_id: stream,
+      expected_version: -2,
+      events: events,
+      require_master: true
+    )
+    command('WriteEvents', msg)
+  end
+
+  def read_stream_events_forward(stream, start, max)
+    msg = ReadStreamEvents.new(
+      event_stream_id: stream,
+      from_event_number: start,
+      max_count: max,
+      resolve_link_tos: true,
+      require_master: false
+    )
+    command('ReadStreamEventsForward', msg)
+  end
+
+  def subscribe_to_stream(handler, stream, resolve_link_tos = false)
+    msg = SubscribeToStream.new(event_stream_id: stream, resolve_link_tos: resolve_link_tos)
+    command('SubscribeToStream', msg, handler)
+  end
+
+  def unsubscribe_from_stream(subscription_uuid)
+    msg = UnsubscribeFromStream.new
+    command('UnsubscribeFromStream', msg, uuid: subscription_uuid)
+  end
+
+  private
+
+  def command(*args)
+    connection.send_command(*args)
+  end
+end
+
+require_relative 'estore/errors'
+require_relative 'estore/package'
+require_relative 'estore/messages'
+require_relative 'estore/message_extensions'
+require_relative 'estore/connection_context'
+require_relative 'estore/connection'
+require_relative 'estore/connection/buffer'
+require_relative 'estore/connection/commands'
+require_relative 'estore/subscription'
+require_relative 'estore/catchup_subscription'

data/lib/estore/catchup_subscription.rb

@@ -0,0 +1,94 @@
+class Eventstore
+  # 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(eventstore, stream, from, resolve_link_tos: true, batch_size: MAX_READ_BATCH)
+      super(eventstore, stream, resolve_link_tos: resolve_link_tos)
+      @from = from
+      @caught_up = false
+
+      @mutex = Mutex.new
+      @queue = []
+      @position = from
+      @batch_size = batch_size
+    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
+      log("fn=switch_to_live id=#{@id} stream=#{stream} at=start position=#{@position} queue_size=#{@queue.size}")
+      @mutex.synchronize do
+        dispatch_events(received_while_backfilling)
+        @queue = nil
+        @caught_up = true
+      end
+      log("fn=switch_to_live id=#{@id} stream=#{stream} at=finish position=#{@position}")
+    end
+
+    def backfill
+      log("fn=backfill at=start position=#{@position}")
+      loop do
+        events, finished = fetch_batch(@position + 1)
+        @mutex.synchronize do
+          dispatch_events(events)
+        end
+        break if finished
+      end
+      log("fn=backfill at=finish position=#{@position}")
+    end
+
+    def dispatch_events(events)
+      events.each { |e| dispatch(e) }
+    end
+
+    def fetch_batch(from)
+      prom = eventstore.read_stream_events_forward(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
+
+    def log(msg)
+      puts(msg)
+    end
+  end
+end

data/lib/estore/connection.rb

@@ -0,0 +1,118 @@
+class Eventstore
+  # Connection owns the TCP socket, formats and sends commands over the socket.
+  # 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, :error_handler
+    attr_reader :buffer, :mutex
+
+    def initialize(host, port, context)
+      @host = host
+      @port = Integer(port)
+      @context = context
+
+      @buffer = Buffer.new(&method(:on_received_package))
+      @mutex = Mutex.new
+    end
+
+    def close
+      @terminating = true
+      socket.close
+    end
+
+    def send_command(command, msg = nil, handler = nil, uuid = nil)
+      code = COMMANDS.fetch(command)
+      msg.validate! if msg
+
+      correlation_id = uuid || SecureRandom.uuid
+      frame = Package.encode(code, correlation_id, msg)
+
+      mutex.synchronize do
+        promise = context.register_command(correlation_id, command, handler)
+        # puts "Sending #{command} command with correlation id #{correlation_id}"
+        # puts "Sending to socket: #{frame.length} #{frame.inspect}"
+        to_write = frame.to_s
+        socket.write(to_write)
+        promise
+      end
+    end
+
+    private
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength
+    def on_received_package(command, message, uuid, _flags)
+      # p(fn: "on_received_package", command: command)
+      # callback = context.received_package(uuid, command, message)
+      case command
+      when 'Pong' then                              context.fulfilled_command(uuid, 'Pong')
+      when 'HeartbeatRequestCommand' then           send_command('HeartbeatResponseCommand')
+      when 'SubscriptionConfirmation' then          context.fulfilled_command(uuid, decode(SubscriptionConfirmation, message))
+      when 'ReadStreamEventsForwardCompleted'
+        context.fulfilled_command(uuid, decode(ReadStreamEventsCompleted, message))
+      when 'StreamEventAppeared'
+        resolved_event = decode(StreamEventAppeared, message).event
+        context.trigger(uuid, 'event_appeared', resolved_event)
+      when 'WriteEventsCompleted' then              on_write_events_completed(uuid, decode(WriteEventsCompleted, message))
+      else fail command
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, 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.fulfilled_command(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
+      @socket || connect
+    end
+
+    def connect
+      @socket = TCPSocket.open(host, port)
+      Thread.new do
+        process_downstream
+      end
+      @socket
+    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})"
+    end
+
+    def process_downstream
+      loop do
+        buffer << socket.sysread(4096)
+      end
+    rescue IOError, EOFError
+      on_disconnect
+    rescue => error
+      on_exception(error)
+    end
+
+    def on_disconnect
+      return if @terminating
+      puts 'Eventstore disconnected'
+      context.on_error(DisconnectionError.new('Eventstore disconnected'))
+    end
+
+    def on_exception(error)
+      puts "process_downstream_error #{error.inspect}"
+      context.on_error(error)
+    end
+  end
+end