akasha 0.2.0 → 0.3.0

data/lib/akasha/repository.rb

@@ -3,6 +3,8 @@ module Akasha
   # Not meant to be used directly (see aggregate/syntax_helpers.rb)
   # See specs for usage.
   class Repository
+    attr_reader :store
+
     STREAM_NAME_SEP = '-'.freeze
 
     # Creates a new repository using the underlying `store` (e.g. `MemoryEventStore`).
@@ -44,6 +46,17 @@ module Akasha
       @subscribers << callable
     end
 
+    # Merges all streams into one, filtering the resulting stream
+    # so it only contains events with the specified names, using
+    # a projection.
+    #
+    # Arguments:
+    #   `into` - name of the new stream
+    #   `only` - array of event names
+    def merge_all_by_event(into:, only:)
+      @store.merge_all_by_event(into: into, only: only)
+    end
+
     private
 
     def stream_name(aggregate_klass, aggregate_id)

data/lib/akasha/storage/http_event_store.rb

@@ -1,24 +1,58 @@
+require_relative 'http_event_store/client'
 require_relative 'http_event_store/stream'
-require 'http_event_store'
 
 module Akasha
   module Storage
     # HTTP-based interface to Eventstore (https://geteventstore.com)
     class HttpEventStore
-      def initialize(host: 'localhost', port: 2113)
-        @client = ::HttpEventStore::Connection.new do |config|
-          config.endpoint = host
-          config.port = port
+      # Base class for all HTTP Event store errors.
+      Error = Class.new(RuntimeError)
+      # Stream name contains invalid characters.
+      InvalidStreamNameError = Class.new(Error)
+
+      # Base class for HTTP errors.
+      class HttpError < Error
+        attr_reader :status_code
+
+        def initialize(status_code)
+          @status_code = status_code
+          super("Unexpected HTTP response: #{@status_code}")
         end
       end
 
+      # 4xx HTTP status code.
+      HttpClientError = Class.new(HttpError)
+      # 5xx HTTP status code.
+      HttpServerError = Class.new(HttpError)
+
+      # Creates a new event store client, connecting to the specified host and port
+      # using an optional username and password.
+      def initialize(host: 'localhost', port: 2113, username: nil, password: nil)
+        @client = Client.new(host: host, port: port, username: username, password: password)
+      end
+
+      # Returns a Hash of streams. You can retrieve a Stream instance corresponding
+      # to any stream by its name. The stream does not have to exist, appending to
+      # it will create it.
       def streams
         self # Use the `[]` method on self.
       end
 
+      # Shortcut for accessing streams by their names.
       def [](stream_name)
         Stream.new(@client, stream_name)
       end
+
+      # Merges all streams into one, filtering the resulting stream
+      # so it only contains events with the specified names, using
+      # a projection.
+      #
+      # Arguments:
+      #   `into` - name of the new stream
+      #   `only` - array of event names
+      def merge_all_by_event(into:, only:)
+        @client.merge_all_by_event(into, only)
+      end
     end
   end
 end

data/lib/akasha/storage/http_event_store/client.rb

@@ -0,0 +1,169 @@
+require 'base64'
+require 'corefines/hash'
+require 'json'
+require 'faraday'
+require 'faraday_middleware'
+require 'rack/utils'
+require 'retries'
+require 'time'
+require 'typhoeus/adapters/faraday'
+
+require_relative 'event_serializer'
+require_relative 'response_handler'
+require_relative 'projection_manager'
+
+module Akasha
+  module Storage
+    class HttpEventStore
+      # Eventstore HTTP client.
+      class Client
+        using Corefines::Hash
+
+        # A lower limit for a retry interval.
+        MIN_RETRY_INTERVAL = 0
+        # An upper limit for a retry interval.
+        MAX_RETRY_INTERVAL = 10.0
+
+        # Creates a new client for the host and port with optional username and password
+        # for authenticating certain requests.
+        def initialize(host: 'localhost', port: 2113, username: nil, password: nil)
+          @username = username
+          @password = password
+          @conn = connection(host, port)
+          @serializer = EventSerializer.new
+        end
+
+        # Append events to stream, idempotently retrying_on_network_failures up to `max_retries`
+        def retry_append_to_stream(stream_name, events, expected_version = nil, max_retries: 0)
+          retrying_on_network_failures(max_retries) do
+            append_to_stream(stream_name, events, expected_version)
+          end
+        end
+
+        # Read events from stream, retrying_on_network_failures up to `max_retries` in case of network failures.
+        # Reads `count` events starting from `start` inclusive.
+        # Can long-poll for events if `poll` is specified.`
+        def retry_read_events_forward(stream_name, start, count, poll = 0, max_retries: 0)
+          retrying_on_network_failures(max_retries) do
+            safe_read_events(stream_name, start, count, poll)
+          end
+        end
+
+        # Merges all streams into one, filtering the resulting stream
+        # so it only contains events with the specified names, using
+        # a projection.
+        #
+        # Arguments:
+        #   `name` - name of the projection stream
+        #   `event_names` - array of event names
+        def merge_all_by_event(name, event_names, max_retries: 0)
+          retrying_on_network_failures(max_retries) do
+            ProjectionManager.new(self).merge_all_by_event(name, event_names)
+          end
+        end
+
+        # Reads stream metadata.
+        def retry_read_metadata(stream_name, max_retries: 0)
+          retrying_on_network_failures(max_retries) do
+            safe_read_metadata(stream_name)
+          end
+        end
+
+        # Updates stream metadata.
+        def retry_write_metadata(stream_name, metadata)
+          event = Akasha::Event.new(:stream_metadata_changed, SecureRandom.uuid, metadata)
+          retry_append_to_stream("#{stream_name}/metadata", [event])
+        end
+
+        # Issues a generic request against the API.
+        def request(method, path, body = nil, headers = {})
+          body = @conn.public_send(method, path, body, auth_headers.merge(headers)).body
+          return {} if body.empty?
+          body
+        end
+
+        private
+
+        def connection(host, port)
+          Faraday.new do |conn|
+            conn.host = host
+            conn.port = port
+            conn.response :json, content_type: 'application/json'
+            conn.use ResponseHandler
+            conn.adapter :typhoeus
+          end
+        end
+
+        def auth_headers
+          if @username && @password
+            auth = Base64.urlsafe_encode64([@username, @password].join(':'))
+            {
+              'Authorization' => "Basic #{auth}"
+            }
+          else
+            {}
+          end
+        end
+
+        def retrying_on_network_failures(max_retries)
+          with_retries(base_sleep_seconds: MIN_RETRY_INTERVAL,
+                       max_sleep_seconds: MAX_RETRY_INTERVAL,
+                       max_tries: 1 + max_retries,
+                       rescue: [Faraday::TimeoutError, Faraday::ConnectionFailed]) do
+            yield
+          end
+        end
+
+        def append_to_stream(stream_name, events, _expected_version = nil)
+          @conn.post("/streams/#{stream_name}") do |req|
+            req.headers = {
+              'Content-Type' => 'application/vnd.eventstore.events+json',
+              # 'ES-ExpectedVersion' => expected_version
+            }
+            req.body = to_event_data(events).to_json
+          end
+        end
+
+        def safe_read_events(stream_name, start, count, poll)
+          resp = @conn.get("/streams/#{stream_name}/#{start}/forward/#{count}") do |req|
+            req.headers = {
+              'Accept' => 'application/json'
+            }
+            req.headers['ES-LongPoll'] = poll if poll&.positive?
+            req.params['embed'] = 'body'
+          end
+          event_data = resp.body['entries']
+          to_events(event_data)
+        rescue HttpClientError => e
+          return [] if e.status_code == 404
+          raise
+        rescue URI::InvalidURIError
+          raise InvalidStreamNameError, "Invalid stream name: #{stream_name}"
+        end
+
+        def safe_read_metadata(stream_name)
+          metadata = request(:get, "/streams/#{stream_name}/metadata", nil, 'Accept' => 'application/json')
+          metadata.symbolize_keys
+        rescue HttpClientError => e
+          return {} if e.status_code == 404
+          raise
+        rescue URI::InvalidURIError
+          raise InvalidStreamNameError, "Invalid stream name: #{stream_name}"
+        end
+
+        def to_event_data(events)
+          @serializer.serialize(events)
+        end
+
+        def to_events(es_events)
+          es_events = es_events.map do |ev|
+            ev['data'] &&= JSON.parse(ev['data'])
+            ev['metaData'] &&= JSON.parse(ev['metaData'])
+            ev
+          end
+          @serializer.deserialize(es_events)
+        end
+      end
+    end
+  end
+end

data/lib/akasha/storage/http_event_store/event_serializer.rb

@@ -0,0 +1,34 @@
+require 'corefines/hash'
+
+module Akasha
+  module Storage
+    class HttpEventStore
+      # Serializes and deserializes events to and from the format required
+      # by the HTTP Eventstore API
+      class EventSerializer
+        using Corefines::Hash
+
+        def serialize(events)
+          events.map do |event|
+            base = {
+              'eventType' => event.name,
+              'data' => event.data,
+              'metaData' => event.metadata
+            }
+            base['eventId'] = event.id unless event.id.nil?
+            base
+          end
+        end
+
+        def deserialize(es_events)
+          es_events.map do |ev|
+            metadata = ev['metaData']&.symbolize_keys || {}
+            data = ev['data']&.symbolize_keys || {}
+            event = Akasha::Event.new(ev['eventType'].to_sym, ev['eventId'], metadata, **data)
+            event
+          end
+        end
+      end
+    end
+  end
+end

data/lib/akasha/storage/http_event_store/projection_manager.rb

@@ -0,0 +1,67 @@
+module Akasha
+  module Storage
+    class HttpEventStore
+      # Manages HTTP ES projections.
+      class ProjectionManager
+        def initialize(client)
+          @client = client
+        end
+
+        # Merges all streams into one, filtering the resulting stream
+        # so it only contains events with the specified names, using
+        # a projection.
+        #
+        # Arguments:
+        #   `name` - name of the projection stream
+        #   `event_names` - array of event names
+        def merge_all_by_event(name, event_names)
+          attempt_create_projection(name, event_names) ||
+            update_projection(name, event_names)
+        end
+
+        private
+
+        def projection_javascript(name, events)
+          callbacks = events.map { |en| "\"#{en}\": function(s,e) { linkTo('#{name}', e) }" }
+          # Alternative code using internal indexing.
+          # It's broken though because it reorders events for aggregates (because the streams
+          # it uses are per-event). An alternative would be to use aggregates as streams
+          # to pull from.
+          # et_streams = events.map { |en| "\"$et-#{en}\"" }
+          # "fromStreams([#{et_streams.join(', ')}]).when({ #{callbacks.join(', ')} });"
+          ''"
+          // This is hard to find, so I'm leaving it here:
+          // options({
+          //   reorderEvents: true,
+          //   processingLag: 100 //time in ms
+          // });
+          fromAll().when({ #{callbacks.join(', ')} });
+          "''
+        end
+
+        def attempt_create_projection(name, event_names)
+          create_options = {
+            name: name,
+            emit: :yes,
+            checkpoints: :yes,
+            enabled: :yes
+          }
+          query_string = Rack::Utils.build_query(create_options)
+          @client.request(:post, "/projections/continuous?#{query_string}",
+                          projection_javascript(name, event_names),
+                          'Content-Type' => 'application/javascript')
+          true
+        rescue HttpClientError => e
+          return false if e.status_code == 409
+          raise
+        end
+
+        def update_projection(name, event_names)
+          @client.request(:put, "/projection/#{name}/query?emit=yet",
+                          projection_javascript(name, event_names),
+                          'Content-Type' => 'application/javascript')
+        end
+      end
+    end
+  end
+end

data/lib/akasha/storage/http_event_store/response_handler.rb

@@ -0,0 +1,17 @@
+module Akasha
+  module Storage
+    class HttpEventStore
+      # Handles responses from Eventstore HTTP API.
+      class ResponseHandler < Faraday::Response::Middleware
+        def on_complete(env)
+          case env[:status]
+          when (400..499)
+            raise HttpClientError, env.status
+          when (500..599)
+            raise HttpServerError, env.status
+          end
+        end
+      end
+    end
+  end
+end

data/lib/akasha/storage/http_event_store/stream.rb

@@ -3,46 +3,46 @@ module Akasha
     class HttpEventStore
       # HTTP Eventstore stream.
       class Stream
+        attr_reader :name
+
         def initialize(client, stream_name)
           @client = client
-          @stream_name = stream_name
+          @name = stream_name
         end
 
         # Appends events to the stream.
         def write_events(events)
-          event_hashes = events.map do |event|
-            {
-              event_type: event.name,
-              data: event.data,
-              metadata: event.metadata
-            }
-          end
-          @client.append_to_stream(@stream_name, event_hashes)
+          return if events.empty?
+          @client.retry_append_to_stream(@name, events)
         end
 
         # Reads events from the stream starting from `start` inclusive.
         # If block given, reads all events from the position in pages of `page_size`.
         # If block not given, reads `size` events from the position.
-        def read_events(start, page_size)
+        # You can also turn on long-polling using `poll` and setting it to the number
+        # of seconds to wait for.
+        def read_events(start, page_size, poll = 0)
           if block_given?
             position = start
             loop do
-              events = read_events(position, page_size)
+              events = read_events(position, page_size, poll)
               return if events.empty?
               yield(events)
               position += events.size
             end
           else
-            safe_read_events(start, page_size)
+            @client.retry_read_events_forward(@name, start, page_size, poll)
           end
         end
 
-        private
+        # Reads stream metadata.
+        def metadata
+          @client.retry_read_metadata(@name)
+        end
 
-        def safe_read_events(start, page_size)
-          @client.read_events_forward(@stream_name, start, page_size)
-        rescue ::HttpEventStore::StreamNotFound
-          []
+        # Updates stream metadata.
+        def metadata=(metadata)
+          @client.retry_write_metadata(@name, metadata)
         end
       end
     end

data/lib/akasha/storage/memory_event_store.rb

@@ -10,7 +10,37 @@ module Akasha
       attr_reader :streams
 
       def initialize
-        @streams = Hash.new { |streams, name| streams[name] = Stream.new }
+        store = self
+        @streams = Hash.new do |streams, name|
+          streams[name] = Stream.new do |new_events|
+            store.update_projections(new_events)
+            new_events
+          end
+        end
+        @projections = []
+      end
+
+      # Merges all streams into one, filtering the resulting stream
+      # so it only contains events with the specified names.
+      #
+      # Arguments:
+      #   `new_stream_name` - name of the new stream
+      #   `only` - array of event names
+      def merge_all_by_event(into:, only:)
+        new_stream = Stream.new do |new_events|
+          new_events.select { |event| only.include?(event.name) }
+        end
+        @streams[into] = new_stream
+        @projections << new_stream
+        new_stream
+      end
+
+      protected
+
+      def update_projections(events)
+        @projections.each do |projection|
+          projection.write_events(events)
+        end
       end
     end
   end