event_store_http_client 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e15462829913d70b397c5b8fce0dcdd0bbed6cf2
+  data.tar.gz: feb551b2271a10390f4546c75929de60074163d9
+SHA512:
+  metadata.gz: 6e610073c38d950815118fc81b16f5e42dbf987fffd893ebf5f43ed2707efeb3fd138b5a4c425a7243a56b0694d1c34728a8a5310d93e45f86ddb67db58363e1
+  data.tar.gz: 87a6744712ae80d053eff960b3dbadc09a7bceacac64d9724c7918105188a4b08a596d18a69115c1e98de137ee16c7f5a755e74e5c935e5771f1acefebea1c70

data/lib/event_store_http_client.rb

@@ -0,0 +1,17 @@
+require 'dependency'
+Dependency.activate
+
+require 'logger'
+require 'uuid'
+require 'settings'
+Settings.activate
+
+require 'retry'
+require 'event_store_http_client/settings'
+require 'event_store_http_client/handler'
+require 'event_store_http_client/client/builder'
+require 'event_store_http_client/writer'
+require 'event_store_http_client/events/read'
+require 'event_store_http_client/events/write'
+require 'event_store_http_client/subscriptions/subscribe'
+require 'event_store_http_client/projection/get_state'

data/lib/event_store_http_client/client/builder.rb

@@ -0,0 +1,31 @@
+module EventStore
+  module HTTPClient
+    module Client
+      class Builder
+
+        setting :host
+        setting :port
+
+        def self.build
+          new.tap do |instance|
+            Settings.instance.set instance, 'event_store_connection'
+          end
+        end
+
+        def self.configure(receiver)
+          instance = build
+          logger = Logger.get self
+          logger.trace "Configuring Client"
+
+          client = Vertx::HttpClient.new.tap do |client|
+            client.host = instance.host
+            client.port = instance.port
+          end
+
+          receiver.client = client
+          client
+        end
+      end
+    end
+  end
+end

data/lib/event_store_http_client/events/read.rb

@@ -0,0 +1,69 @@
+module EventStore
+  module HTTPClient
+    module Events
+      class Read
+
+        attr_accessor :stream_name
+        attr_accessor :body
+
+        dependency :client
+        dependency :logger, Logger
+
+        def self.!(params)
+          instance = build(params)
+          instance.! do |result|
+            yield result
+          end
+        end
+
+        def self.build(params)
+          body = params[:body]
+          stream_name = params[:stream_name]
+
+          new(stream_name).tap do |instance|
+            Logger.configure instance
+            EventStore::HTTPClient::Client::Builder.configure instance
+          end
+        end
+
+        def initialize(stream_name)
+          @stream_name = stream_name
+        end
+
+        def !
+          make_request do |result|
+            yield result
+          end
+        end
+
+        def make_request
+          logger.debug "Making request to #{stream_name}"
+          request = client.get("/streams/#{stream_name}?embed=body") do |resp|
+            logger.debug "Response #{resp.status_code}"
+
+            resp.body_handler do |body|
+              status = resp.status_code == 200 ? :success : :error
+              yield({ status: status,
+                      status_code: resp.status_code,
+                      body: body.to_s})
+            end
+          end
+
+          request.put_header('Accept', 'application/vnd.eventstore.atom+json')
+          request.put_header('Content-Type', 'application/json')
+
+          request.exception_handler { |e|
+            logger.error "Failed to read, trying again"
+            Vertx.set_timer(rand(1000)) do
+              make_request do |result|
+                yield result
+              end
+            end
+          }
+
+          request.end
+        end
+      end
+    end
+  end
+end

data/lib/event_store_http_client/events/write.rb

@@ -0,0 +1,90 @@
+module EventStore
+  module HTTPClient
+    module Events
+      class Write
+
+        attr_accessor :data
+        attr_accessor :id
+        attr_accessor :stream_name
+        attr_accessor :location
+        attr_accessor :version
+        attr_accessor :type
+
+        dependency :logger, Logger
+        dependency :settings
+        dependency :client
+
+        def self.!(params)
+          instance = build(params)
+          instance.! do |result|
+            yield result if block_given?
+          end
+        end
+
+        def self.build(params)
+          type = params[:type]
+          version = params[:version]
+          data = params[:data].to_json
+          stream_name = params[:stream_name]
+
+          new(type, data, stream_name, version).tap do |instance|
+            Logger.configure instance
+            EventStore::HTTPClient::Client::Builder.configure instance
+            instance.id = UUID::Random.get
+          end
+        end
+
+        def initialize(type, data, stream_name, version)
+          @type = type
+          @data = data
+          @stream_name = stream_name
+          @version = version
+        end
+
+        def !
+          make_request do |result|
+            yield result
+          end
+        end
+
+        def make_request
+          logger.debug "Making request to #{stream_name}"
+          request = client.post("/streams/#{stream_name}") do |resp|
+            logger.debug "Response #{resp.status_code}"
+
+            if resp.status_code == 201
+              yield :success if block_given?
+            else
+              yield resp.status_code if block_given?
+            end
+            resp.body_handler do |body|
+              # puts "The total body received was #{body.length} bytes"
+              # puts body
+            end
+          end
+
+          request.put_header('ES-EventType', type)
+          request.put_header("ES-EventId", id)
+          request.put_header("ES-ExpectedVersion", version) if version
+          request.put_header('Accept', 'application/vnd.eventstore.atom+json')
+          request.put_header('Content-Length', data.length)
+          request.put_header('Content-Type', 'application/json')
+
+          request.exception_handler { |e|
+            logger.error "Event #{id} failed to write, trying again"
+            logger.error e
+            Vertx.set_timer(rand(1000)+10) do
+              make_request do |result|
+                yield result
+              end
+            end
+          }
+
+          request.write_str(data)
+
+          request.end
+        end
+      end
+    end
+  end
+end

data/lib/event_store_http_client/handler.rb

@@ -0,0 +1,49 @@
+module EventStore
+  module HTTPClient
+    module Handler
+      def self.included(cls)
+        cls.send :dependency, :logger, Logger
+        cls.extend Build unless cls.ancestors.include? Build
+      end
+
+
+      def configure(receiver)
+        receiver.handler = self
+        self
+      end
+
+      def !(event, attempt=0)
+        logger.trace "Event sourced: #{event}"
+        command = command(event)
+
+        logger.trace "Executing #{command.class} on #{event}"
+        command.!
+        logger.debug "Executed #{command.class}"
+      end
+
+      module Build
+        def build
+          new.tap do |instance|
+            Logger.configure instance
+          end
+        end
+      end
+
+      class NullCommand
+        dependency :logger, Logger
+        attr_accessor :event_type
+
+        def !
+          logger.debug "No command to execute for this eventType (type: #{event_type})"
+        end
+
+        def self.build(event_type)
+          new.tap do |instance|
+            Logger.configure instance
+            instance.event_type = event_type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_store_http_client/projection/get_state.rb

@@ -0,0 +1,70 @@
+module EventStore
+  module HTTPClient
+    module Projection
+      class GetState
+
+        attr_accessor :projection
+        attr_accessor :partition
+
+        dependency :client
+        dependency :logger, Logger
+
+        def self.!(params)
+          instance = build(params)
+          instance.! do |result|
+            yield result
+          end
+        end
+
+        def self.build(params)
+          projection = params[:projection]
+          partition = params[:partition]
+
+          new(projection, partition).tap do |instance|
+            Logger.configure instance
+            EventStore::HTTPClient::Client::Builder.configure instance
+          end
+        end
+
+        def initialize(projection, partition)
+          @projection = projection
+          @partition = partition
+        end
+
+        def !
+          make_request do |result|
+            yield result
+          end
+        end
+
+        def make_request
+          logger.debug "Making request to /projection/#{projection}/state?partition=#{partition}"
+          request = client.get("/projection/#{projection}/state?partition=#{partition}") do |resp|
+            logger.debug "Response #{resp.status_code}"
+
+            resp.body_handler do |body|
+              status = resp.status_code == 200 ? :success : :error
+              yield({ status: status,
+                      status_code: resp.status_code,
+                      body: body})
+            end
+          end
+
+          # If I put this 'Accept' header in, it returns a 406.  Else, it works
+          # request.put_header('Accept', 'application/vnd.eventstore.atom+json')
+          request.put_header('Content-Type', 'application/json')
+
+          request.exception_handler { |e|
+            logger.error "Projection failed to query state, trying again"
+            Vertx.set_timer(rand(1000)) do
+              make_request
+            end
+          }
+
+
+          request.end
+        end
+      end
+    end
+  end
+end

data/lib/event_store_http_client/settings.rb

@@ -0,0 +1,9 @@
+module EventStore
+  module HTTPClient
+    class Settings < ::Settings
+      def self.instance
+        @instance ||= build
+      end
+    end
+  end
+end

data/lib/event_store_http_client/subscriptions/subscribe.rb

@@ -0,0 +1,109 @@
+module EventStore
+  module HTTPClient
+
+    def self.subscribe(starting_point, stream, handler)
+      Subscriptions::Subscribe.!(
+        starting_point: starting_point,
+        stream: stream,
+        handler: handler
+      )
+    end
+
+    module Subscriptions
+      class Subscribe
+
+        attr_accessor :stream
+        attr_accessor :starting_point
+        attr_accessor :request_string
+        attr_accessor :handler
+
+        dependency :client
+        dependency :logger, Logger
+
+        def self.!(params)
+          instance = build(params)
+          instance.!
+        end
+
+        def self.build(params)
+          starting_point = params[:starting_point]
+          stream = params[:stream]
+          handler = params[:handler]
+          new(stream, starting_point).tap do |instance|
+            handler.configure instance
+            EventStore::HTTPClient::Client::Builder.configure instance
+            Logger.configure instance
+          end
+        end
+
+        def initialize(stream, starting_point)
+          @stream = stream
+          @starting_point = starting_point
+        end
+
+        def !
+          logger.info "Starting from #{starting_point}"
+          @request_string = "/streams/#{stream}/#{starting_point}/forward/20"
+          make_request
+        end
+
+        def make_request
+          body_embed_link = "#{request_string}?embed=body"
+
+          logger.debug body_embed_link
+
+          request = client.get(body_embed_link) do |resp|
+            resp.body_handler = body_handler
+          end
+
+          request.put_header('Accept', 'application/vnd.eventstore.atom+json')
+          request.put_header('ES-LongPoll', 15)
+
+          request.exception_handler { |e|
+            logger.error "Exception in request: #{e}"
+            Vertx.set_timer(1_000) do
+              make_request
+            end
+          }
+
+          request.end
+        end
+
+        def body_handler(body)
+          if body.length > 0
+            handle_success(body)
+          else
+            handle_failure(:unknown)
+          end
+        end
+
+
+        def handle_success(raw_body)
+          body = JSON.parse(raw_body.to_s)
+          links = body['links']
+
+          body['entries'].reverse.map{|e|
+            logger.trace "Executing handler for #{e} with #{handler.inspect}"
+            ::Retry.!(->(attempt){
+              handler.!(e, attempt)
+              #persist_successfully_handled_event(e['id'])
+            })
+          }
+
+          if previous_link = links.find{|link| link['relation'] == 'previous'}
+            @request_string = previous_link['uri']
+          end
+          make_request
+        end
+
+        def handle_failure(status_code)
+          logger.error "There was an error (#{status_code}) with the subscription request.  Retrying"
+          Vertx.set_timer(rand(1000)+10) do
+            make_request
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/event_store_http_client/writer.rb

@@ -0,0 +1,11 @@
+module EventStore
+  module HTTPClient
+    module Writer
+      def configure(receiver)
+        es_writer = EventStore::HTTPClient::Events::Write
+        receiver.es_writer = es_writer
+        es_writer
+      end
+    end
+  end
+end

data/lib/retry.rb

@@ -0,0 +1,15 @@
+class Retry
+  def self.!(block, attempt=0)
+    logger = Logger.get self
+    logger.debug "Executing #{block}, attempt: #{attempt}"
+    begin
+      block.call(attempt)
+    rescue RetryableError => e
+      logger.info "Exception in #{block}, retrying"
+      attempt += 1
+      Retry.!(block, attempt)
+    end
+  end
+end
+
+class RetryableError < StandardError ; end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: event_store_http_client
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- j@obsidianexchange.com
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-04-07 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/event_store_http_client.rb
+- lib/retry.rb
+- lib/event_store_http_client/handler.rb
+- lib/event_store_http_client/settings.rb
+- lib/event_store_http_client/writer.rb
+- lib/event_store_http_client/client/builder.rb
+- lib/event_store_http_client/events/read.rb
+- lib/event_store_http_client/events/write.rb
+- lib/event_store_http_client/projection/get_state.rb
+- lib/event_store_http_client/subscriptions/subscribe.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: HTTP EventStore client
+test_files: []