evt-event_store-http 0.0.0.0

data/lib/event_store/http/read_stream/defaults.rb

@@ -0,0 +1,31 @@
+module EventStore
+  module HTTP
+    class ReadStream
+      module Defaults
+        def self.batch_size
+          batch_size = ENV['EVENT_STORE_HTTP_READ_BATCH_SIZE']
+
+          return batch_size.to_i if batch_size
+
+          20
+        end
+
+        def self.direction
+          :forward
+        end
+
+        def self.long_poll_duration
+          long_poll_duration = ENV['EVENT_STORE_HTTP_LONG_POLL_DURATION']
+
+          return long_poll_duration.to_i if long_poll_duration
+
+          2
+        end
+
+        def self.position
+          0
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/read_stream/log_text.rb

@@ -0,0 +1,17 @@
+module EventStore
+  module HTTP
+    class ReadStream
+      module LogText
+        def self.attributes(stream, position, batch_size, direction, response: nil)
+          text = "Stream: #{stream}, Position: #{position}, BatchSize: #{batch_size}"
+
+          unless response.nil?
+            text << ", StatusCode: #{response.code}, ReasonPhrase: #{response.message}, ContentLength: #{response.body&.bytesize.to_i}"
+          end
+
+          text
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/read_stream/substitute.rb

@@ -0,0 +1,90 @@
+module EventStore
+  module HTTP
+    class ReadStream
+      module Substitute
+        def self.build
+          ReadStream.build
+        end
+
+        class ReadStream
+          initializer :telemetry_sink
+
+          attr_accessor :body_embed_enabled
+          attr_accessor :long_poll_enabled
+          attr_accessor :rich_embed_enabled
+
+          dependency :telemetry, ::Telemetry
+
+          def self.build
+            telemetry_sink = Telemetry::Sink.new
+
+            instance = new telemetry_sink
+
+            telemetry = ::Telemetry.configure instance
+            telemetry.register telemetry_sink
+
+            instance
+          end
+
+          def call(stream, position: nil, direction: nil, batch_size: nil)
+            unless direction.nil?
+              unless EventStore::HTTP::ReadStream.directions.include? direction
+                raise ArgumentError
+              end
+            end
+
+            page = streams.fetch stream do
+              raise EventStore::HTTP::ReadStream::StreamNotFoundError
+            end
+
+            telemetry.record :read, Telemetry::Read.new(stream, position, direction, batch_size)
+
+            page
+          end
+
+          def read?(&block)
+            block ||= proc { true }
+
+            telemetry_sink.recorded? do |record|
+              block.(*record.data.to_a)
+            end
+          end
+
+          def enable_long_poll
+            self.long_poll_enabled = true
+          end
+
+          def embed_rich
+            self.rich_embed_enabled = true
+          end
+
+          def embed_body
+            self.body_embed_enabled = true
+          end
+
+          def set_response(stream, page, position: nil)
+            streams[stream] = page
+          end
+
+          def streams
+            @streams ||= {}
+          end
+
+          alias_method :long_poll_enabled?, :long_poll_enabled
+          alias_method :rich_embed_enabled?, :rich_embed_enabled
+          alias_method :body_embed_enabled?, :body_embed_enabled
+        end
+
+        module Telemetry
+          class Sink
+            include ::Telemetry::Sink
+
+            record :read
+          end
+
+          Read = Struct.new :stream, :position, :direction, :batch_size
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/read_stream.rb

@@ -0,0 +1,100 @@
+module EventStore
+  module HTTP
+    class ReadStream
+      include Log::Dependency
+      include Request
+
+      configure :read_stream
+
+      attr_accessor :long_poll_duration
+      attr_accessor :embed
+
+      attr_writer :output_schema
+
+      def output_schema
+        @output_schema ||= default_output_schema
+      end
+
+      def call(stream, position: nil, batch_size: nil, direction: nil)
+        batch_size ||= Defaults.batch_size
+        position ||= Defaults.position
+        direction ||= Defaults.direction
+
+        logger.trace { "Reading stream (#{LogText.attributes stream, position, batch_size, direction})" }
+
+        unless self.class.directions.include? direction
+          error_message = "Invalid direction; not `forward' or `backward' (#{LogText.attributes stream, position, batch_size, direction})"
+          logger.trace { error_message }
+          raise ArgumentError, error_message
+        end
+
+        slice_path = self.slice_path stream, position, batch_size, direction
+
+        request = Net::HTTP::Get.new slice_path
+        request['Accept'] = MediaTypes::Atom.mime
+        request['ES-LongPoll'] = long_poll_duration.to_s if long_poll_duration
+
+        response = connection.request request
+
+        case response
+        when Net::HTTPSuccess
+          page = Transform::Read.(response.body, :json, output_schema)
+
+          logger.info { "Stream read (#{LogText.attributes stream, position, batch_size, direction, response: response}, OutputSchema: #{output_schema})" }
+
+          page
+
+        when Net::HTTPNotFound
+          error_message = "Stream not found (#{LogText.attributes stream, position, batch_size, direction, response: response})"
+          logger.error error_message
+          raise StreamNotFoundError, error_message
+
+        else
+          error_message = "Client error (#{LogText.attributes stream, position, batch_size, direction, response: response})"
+          logger.error error_message
+          raise Error, error_message
+        end
+      end
+
+      def slice_path(stream, position, batch_size, direction)
+        path = "/streams/#{stream}/#{position}/#{direction}/#{batch_size}"
+
+        if embed
+          path << "?embed=#{embed}"
+        end
+
+        path
+      end
+
+      def default_output_schema
+        case embed
+        when :body
+          MediaTypes::Atom::Page::Embed::Body
+        when :rich
+          MediaTypes::Atom::Page::Embed::Rich
+        else
+          MediaTypes::Atom::Page::Embed::None
+        end
+      end
+
+      def enable_long_poll
+        self.long_poll_duration = Defaults.long_poll_duration
+      end
+
+      def embed_rich
+        self.embed = :rich
+      end
+
+      def embed_body
+        self.embed = :body
+      end
+
+      def self.directions
+        [:forward, :backward]
+      end
+
+      Error = Class.new StandardError
+      StreamNotFoundError = Class.new Error
+    end
+  end
+end

data/lib/event_store/http/request.rb

@@ -0,0 +1,48 @@
+module EventStore
+  module HTTP
+    module Request
+      def self.included(cls)
+        cls.class_exec do
+          dependency :connection, Net::HTTP
+
+          extend Build
+          extend Call
+        end
+      end
+
+      Virtual::Method.define self, :call
+
+      Virtual::Method.define self, :configure do |session: nil|
+      end
+
+      module Build
+        def build(connection: nil, session: nil)
+          instance = new
+
+          if session.nil?
+            Connect.configure_connection instance, connection: connection
+          elsif !connection.nil?
+            raise ArgumentError, "Cannot specify both connection and session"
+          else
+            instance.connection = session
+          end
+
+          instance.configure(session: session)
+          instance
+        end
+      end
+
+      module Call
+        def call(*arguments, connection: nil, session: nil, **keyword_arguments)
+          instance = build connection: connection, session: session
+
+          if keyword_arguments.empty?
+            instance.(*arguments)
+          else
+            instance.(*arguments, **keyword_arguments)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/retry/substitute.rb

@@ -0,0 +1,44 @@
+module EventStore
+  module HTTP
+    class Retry
+      module Substitute
+        def self.build
+          Retry.build
+        end
+
+        class Retry < Retry
+          attr_accessor :error
+          attr_accessor :telemetry_sink
+
+          def self.build
+            instance = new
+
+            ::Telemetry.configure instance
+            instance.telemetry_sink = Retry.register_telemetry_sink instance
+
+            instance.retry_duration = 0
+            instance.retry_limit = 1
+            instance
+          end
+
+          def call(&block)
+            super do |_, retries|
+              return_value = block.(self, retries)
+
+              if error = self.error
+                self.error = nil
+                raise error
+              end
+
+              return_value
+            end
+          end
+
+          def set_error(error)
+            self.error = error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/retry/telemetry.rb

@@ -0,0 +1,15 @@
+module EventStore
+  module HTTP
+    class Retry
+      module Telemetry
+        class Sink
+          include ::Telemetry::Sink
+
+          record :retried
+        end
+
+        Retried = Struct.new :error, :retries, :retry_limit
+      end
+    end
+  end
+end

data/lib/event_store/http/retry.rb

@@ -0,0 +1,98 @@
+module EventStore
+  module HTTP
+    class Retry
+      include Log::Dependency
+
+      configure :retry
+
+      dependency :telemetry, ::Telemetry
+
+      setting :retry_limit
+      setting :retry_duration
+
+      def retry_limit
+        @retry_limit ||= Defaults.retry_limit
+      end
+
+      def retry_duration
+        @retry_duration ||= Defaults.retry_duration
+      end
+
+      def self.build(settings=nil, namespace: nil)
+        settings ||= Settings.instance
+        namespace ||= Array(namespace)
+
+        instance = new
+        ::Telemetry.configure instance
+        settings.set instance, namespace
+        instance
+      end
+
+      def self.register_telemetry_sink(instance)
+        sink = Telemetry::Sink.new
+        instance.telemetry.register sink
+        sink
+      end
+
+      def call(&block)
+        retries ||= 0
+
+        logger.trace { "Performing operation (Retries: #{retries}/#{retry_limit})" }
+
+        return_value = block.(self, retries)
+
+        logger.debug { "Operation succeeded (Retries: #{retries}/#{retry_limit})" }
+
+        return_value
+
+      rescue => error
+        if retries == retry_limit
+          logger.error { "Operation failed; retry limit exceeded (Retries: #{retries}/#{retry_limit}, ErrorClass: #{error.class}, ErrorMessage: #{error.message.empty? ? '(none)' : error.message})" }
+          raise error
+        end
+
+        logger.warn { "Operation failed; retrying (Retries: #{retries}/#{retry_limit}, ErrorClass: #{error.class}, ErrorMessage: #{error.message.empty? ? '(none)' : error.message})" }
+
+        retries += 1
+        sleep retry_duration_seconds
+        record_retry error, retries
+
+        retry
+      end
+
+      def failed(error=nil)
+        error ||= Trigger.new
+
+        raise error
+      end
+
+      def record_retry(error, retries)
+        telemetry.record :retried, Telemetry::Retried.new(error, retries, retry_limit)
+      end
+
+      def retry_duration_seconds
+        Rational(retry_duration, 1_000)
+      end
+
+      Trigger = Class.new StandardError
+
+      module Defaults
+        def self.retry_duration
+          value = ENV['EVENT_STORE_HTTP_RETRY_DURATION']
+
+          return value.to_i if value
+
+          300
+        end
+
+        def self.retry_limit
+          value = ENV['EVENT_STORE_HTTP_RETRY_LIMIT']
+
+          return value.to_i if value
+
+          3
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/session/any_member.rb

@@ -0,0 +1,9 @@
+module EventStore
+  module HTTP
+    module Session
+      class AnyMember
+        include Session
+      end
+    end
+  end
+end

data/lib/event_store/http/session/defaults.rb

@@ -0,0 +1,11 @@
+module EventStore
+  module HTTP
+    module Session
+      module Defaults
+        def self.type
+          :leader
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/session/factory.rb

@@ -0,0 +1,74 @@
+module EventStore
+  module HTTP
+    module Session
+      class Factory
+        include Log::Dependency
+
+        initializer :settings, :namespace
+
+        attr_writer :type
+
+        def type
+          @type ||= get_type
+        end
+
+        def self.build(settings=nil, namespace: nil, type: nil)
+          settings ||= Settings.instance
+          namespace = Array(namespace)
+
+          instance = new settings, namespace
+          instance.type = type unless type.nil?
+          instance
+        end
+
+        def self.call(settings=nil, **arguments)
+          instance = build settings, **arguments
+          instance.()
+        end
+
+        def call
+          logger.trace { "Constructing Session (Type: #{type.inspect})" }
+
+          cls = resolve_class
+
+          instance = cls.new
+
+          settings.set instance, namespace
+
+          Retry.configure instance, settings, namespace: namespace
+          Log::Data.configure instance, Session, attr_name: :data_logger
+          connect = Connect.configure instance, settings, namespace: namespace
+
+          instance.configure
+
+          logger.debug { "Session constructed (Type: #{type.inspect}, Class: #{instance.class})" }
+
+          instance
+        end
+
+        def get_type
+          type = settings.get :type, namespace
+          type ||= Defaults.type
+          type.to_sym
+        end
+
+        def resolve_class
+          self.class.types.fetch type do
+            error_message = "Unknown session type (Type: #{type.inspect}, KnownTypes: #{self.class.types.keys.inspect})"
+            logger.error { error_message }
+            raise UnknownType, error_message
+          end
+        end
+
+        def self.types
+          @types ||= {
+            :any_member => AnyMember,
+            :leader => Leader
+          }
+        end
+
+        UnknownType = Class.new StandardError
+      end
+    end
+  end
+end

data/lib/event_store/http/session/leader.rb

@@ -0,0 +1,33 @@
+module EventStore
+  module HTTP
+    module Session
+      class Leader
+        include Session
+
+        def configure
+          connect.extend Connect::Leader
+        end
+
+        def request(request)
+          request['ES-RequireMaster'] ||= 'True'
+
+          response = super
+
+          if Net::HTTPRedirection === response
+            location = URI.parse response['location']
+
+            leader_ip_address = location.host
+
+            net_http = reconnect leader_ip_address
+
+            reset_request request
+
+            response = request request
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/session/log_text.rb

@@ -0,0 +1,41 @@
+module EventStore
+  module HTTP
+    module Session
+      module LogText
+        def self.request(request, response=nil)
+          text = %[Action: #{request.method}, Path: #{request.path}, RequestLength: #{request.body&.bytesize.to_i}]
+
+          unless response.nil?
+            text << %[, StatusCode: #{response.code}, ReasonPhrase: #{response.message}, ResponseLength: #{response.body&.bytesize.to_i}]
+          end
+
+          text
+        end
+
+        def self.header_data(message)
+          text = String.new
+
+          message.each_header do |name, value|
+            text << "#{name}: #{value}\n"
+          end
+
+          if text.empty?
+            text << "(none)"
+          else
+            text.insert 0, "\n\n"
+          end
+
+          text
+        end
+
+        def self.body_data(message)
+          if message.body.to_s.empty?
+            '(none)'
+          else
+            "\n\n#{message.body}\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_store/http/session/read.rb

@@ -0,0 +1,22 @@
+module EventStore
+  module HTTP
+    module Session
+      module Read
+        def self.get(settings=nil, namespace: nil)
+          settings = Settings::Read.get settings, namespace: namespace
+
+          Session.build settings
+        end
+
+        def self.configure(receiver, settings=nil, namespace: nil, attr_name: nil, session: nil)
+          attr_name ||= :session
+
+          session ||= get settings, namespace: namespace
+
+          receiver.public_send "#{attr_name}=", session
+          session
+        end
+      end
+    end
+  end
+end