aggro 0.0.1 → 0.0.2

data/lib/aggro/event_proxy.rb

@@ -0,0 +1,23 @@
+module Aggro
+  # Private: Used as a proxy to apply and save events to an aggregate.
+  class EventProxy
+    def initialize(aggregate, id)
+      @aggregate = aggregate
+      @id = id
+    end
+
+    def method_missing(method_sym, *args)
+      details = merge_details_with_command_context(args.pop || {})
+      event = Event.new(method_sym, Time.now, details)
+
+      Aggro.store.write_single @id, event
+      Aggro.event_bus.publish @id, event
+    end
+
+    private
+
+    def merge_details_with_command_context(details)
+      @aggregate.instance_variable_get(:@_context).merge(details)
+    end
+  end
+end

data/lib/aggro/event_serializer.rb

@@ -0,0 +1,14 @@
+module Aggro
+  # Public: Converts events to and from serialized data.
+  module EventSerializer
+    module_function
+
+    def deserialize(serialized)
+      Marshal.load serialized
+    end
+
+    def serialize(deserialized)
+      Marshal.dump deserialized
+    end
+  end
+end

data/lib/aggro/file_store.rb

@@ -0,0 +1,97 @@
+require 'aggro/file_store/reader'
+require 'aggro/file_store/writer'
+
+module Aggro
+  # Public: Stores and retrieves events by serializing them to flat files.
+  class FileStore < AbstractStore
+    INDEX_DIRECTORY = 'indexes'.freeze
+    EVENT_DIRECTORY = 'events'.freeze
+    REGISTRY_FILE = 'registry'.freeze
+
+    def initialize(directory)
+      @event_directory = [directory, EVENT_DIRECTORY].join('/')
+      @index_directory = [directory, INDEX_DIRECTORY].join('/')
+
+      FileUtils.mkdir_p @event_directory
+      FileUtils.mkdir_p @index_directory
+
+      @registry_file = [directory, REGISTRY_FILE].join('/')
+      initialize_registry if File.exist? @registry_file
+    end
+
+    def all
+      read registry.keys
+    end
+
+    def create(id, type)
+      File.open(@registry_file, 'ab') do |registry_file|
+        registry_file.write Marshal.dump [id, type]
+        registry[id] = type
+      end
+
+      self
+    end
+
+    def exists?(id)
+      registry[id] == true
+    end
+
+    def read(ids)
+      ids.map { |id| id_to_event_stream id }
+    end
+
+    def registry
+      @registry ||= {}
+    end
+
+    def write(event_streams)
+      event_streams.each do |stream|
+        FileStore::Writer.new(
+          event_file(stream.id, 'ab'),
+          index_file(stream.id, 'ab')
+        ).write stream.events
+      end
+
+      self
+    end
+
+    def write_single(id, event)
+      FileStore::Writer.new(
+        event_file(id, 'ab'),
+        index_file(id, 'ab')
+      ).write [event]
+    end
+
+    private
+
+    def event_file(id, flags = 'rb')
+      File.new [@event_directory, id].join('/'), flags
+    end
+
+    def id_to_event_stream(id)
+      EventStream.new id, type_for_id(id), id_to_reader(id).read
+    rescue Errno::ENOENT
+      EventStream.new id, type_for_id(id), []
+    end
+
+    def id_to_reader(id)
+      FileStore::Reader.new event_file(id), index_file(id)
+    end
+
+    def index_file(id, flags = 'rb')
+      File.new [@index_directory, id].join('/'), flags
+    end
+
+    def initialize_registry
+      File.open(@registry_file) do |file|
+        ObjectStream.new(file, type: 'marshal').each do |id, type|
+          registry[id] = type
+        end
+      end
+    end
+
+    def type_for_id(id)
+      registry[id]
+    end
+  end
+end

data/lib/aggro/file_store/reader.rb

@@ -0,0 +1,21 @@
+module Aggro
+  class FileStore < AbstractStore
+    # Private: Deserialized events from an IO object.
+    class Reader
+      def initialize(data_io, index_io)
+        @data_io = data_io
+        @index_io = index_io
+      end
+
+      def read
+        ObjectStream.new(@data_io, type: 'marshal')
+      end
+
+      private
+
+      def index
+        @index ||= ObjectStream.new(@index_io, type: 'marshal')
+      end
+    end
+  end
+end

data/lib/aggro/file_store/writer.rb

@@ -0,0 +1,27 @@
+module Aggro
+  class FileStore < AbstractStore
+    # Private: Serializes events to an IO object.
+    class Writer
+      def initialize(data_io, index_io)
+        @data_io = data_io
+        @index_io = index_io
+      end
+
+      def write(events)
+        events.each do |event|
+          @data_io.write EventSerializer.serialize(event)
+          write_to_index @data_io.pos
+        end
+
+        @data_io.flush
+        @index_io.flush
+      end
+
+      private
+
+      def write_to_index(offset)
+        @index_io.write Marshal.dump(offset)
+      end
+    end
+  end
+end

data/lib/aggro/handler/command.rb

@@ -0,0 +1,60 @@
+module Aggro
+  module Handler
+    # Private: Handler for incoming command requests.
+    class Command < Struct.new(:message, :server)
+      def call
+        commandee_local? ? handle_local : handle_foreign
+      end
+
+      private
+
+      def channel
+        Aggro.channels[commandee_id]
+      end
+
+      def command
+        @command ||= message.to_command
+      end
+
+      def commandee_id
+        message.commandee_id
+      end
+
+      def command_known?
+        !command.nil?
+      end
+
+      def commandee_local?
+        comandee_locator.local?
+      end
+
+      def comandee_locator
+        @comandee_locator ||= Locator.new(commandee_id)
+      end
+
+      def handle_foreign
+        comandee_locator.primary_node.client.post message
+      end
+
+      def handle_known
+        if channel.handles_command?(command)
+          channel.forward_command command
+
+          Message::OK.new
+        else
+          Message::UnhandledOperation.new
+        end
+      rescue NoMethodError
+        Message::InvalidTarget.new
+      end
+
+      def handle_local
+        command_known? ? handle_known : handle_unknown
+      end
+
+      def handle_unknown
+        Message::UnknownOperation.new
+      end
+    end
+  end
+end

data/lib/aggro/handler/create_aggregate.rb

@@ -0,0 +1,42 @@
+module Aggro
+  module Handler
+    # Private: Handler for incoming command requests.
+    class CreateAggregate < Struct.new(:message, :server)
+      def call
+        local? ? handle_local : handle_foreign
+      end
+
+      private
+
+      def add_to_channels
+        channel = Channel.new(message.id, message.type)
+        Aggro.channels[message.id] = channel
+      end
+
+      def exists_in_channels?
+        Aggro.channels.keys.include?(message.id)
+      end
+
+      def handle_local
+        unless exists_in_channels?
+          Aggro.store.create message.id, message.type
+          add_to_channels
+        end
+
+        Message::OK.new
+      end
+
+      def handle_foreign
+        Message::Ask.new locator.primary_node.id
+      end
+
+      def local?
+        locator.local?
+      end
+
+      def locator
+        @locator ||= Locator.new(message.id)
+      end
+    end
+  end
+end

data/lib/aggro/handler/get_events.rb

@@ -0,0 +1,30 @@
+module Aggro
+  module Handler
+    # Private: Handler for incoming command requests.
+    class GetEvents < Struct.new(:message, :server)
+      def call
+        local? ? handle_local : handle_foreign
+      end
+
+      private
+
+      def handle_local
+        events = Aggro.store.read([message.id]).first.events
+
+        Message::Events.new(message.id, events.to_a)
+      end
+
+      def handle_foreign
+        Message::Ask.new locator.primary_node.id
+      end
+
+      def local?
+        locator.local?
+      end
+
+      def locator
+        @locator ||= Locator.new(message.id)
+      end
+    end
+  end
+end

data/lib/aggro/handler/query.rb

@@ -0,0 +1,60 @@
+module Aggro
+  module Handler
+    # Private: Handler for incoming query requests.
+    class Query < Struct.new(:message, :server)
+      def call
+        queryee_local? ? handle_local : handle_foreign
+      end
+
+      private
+
+      def channel
+        Aggro.channels[queryable_id]
+      end
+
+      def query
+        @query ||= message.to_query
+      end
+
+      def queryable_id
+        message.queryable_id
+      end
+
+      def query_known?
+        !query.nil?
+      end
+
+      def queryee_local?
+        comandee_locator.local?
+      end
+
+      def comandee_locator
+        @comandee_locator ||= Locator.new(queryable_id)
+      end
+
+      def handle_foreign
+        comandee_locator.primary_node.client.post message
+      end
+
+      def handle_known
+        if channel.handles_query?(query)
+          result = channel.run_query(query)
+
+          Message::Result.new result.value(5)
+        else
+          Message::UnhandledOperation.new
+        end
+      rescue NoMethodError
+        Message::InvalidTarget.new
+      end
+
+      def handle_local
+        query_known? ? handle_known : handle_unknown
+      end
+
+      def handle_unknown
+        Message::UnknownOperation.new
+      end
+    end
+  end
+end

data/lib/aggro/handler/start_saga.rb

@@ -0,0 +1,56 @@
+module Aggro
+  module Handler
+    # Private: Handler for incoming command requests.
+    class StartSaga < Struct.new(:message, :server)
+      def call
+        locator.local? ? handle_local : handle_foreign
+      end
+
+      private
+
+      def create_channel
+        channel = Channel.new message.id, 'Aggro::SagaRunner'
+
+        Aggro.channels[message.id] = channel
+      end
+
+      def create_saga
+        Aggro.store.create message.id, 'Aggro::SagaRunner'
+      end
+
+      def locator
+        @locator ||= Locator.new(message.id)
+      end
+
+      def handle_foreign
+        locator.primary_node.client.post message
+      end
+
+      def handle_known
+        create_saga
+        create_channel
+
+        Aggro.channels[message.id].forward_command start_command
+
+        Message::OK.new
+      end
+
+      def handle_local
+        saga_known? ? handle_known : handle_unknown
+      end
+
+      def handle_unknown
+        Message::UnknownOperation.new
+      end
+
+      def saga_known?
+        ActiveSupport::Inflector.safe_constantize message.name
+      end
+
+      def start_command
+        SagaRunner::StartSaga.new name: message.name, details: message.args,
+                                  id: message.id
+      end
+    end
+  end
+end

data/lib/aggro/local_node.rb

@@ -0,0 +1,28 @@
+module Aggro
+  # Public: Represents the local aggro server node.
+  class LocalNode < Struct.new(:id)
+    def client
+      @client ||= create_loopback_client
+    end
+
+    def endpoint
+      "tcp://127.0.0.1:#{Aggro.port}"
+    end
+
+    def publisher_endpoint
+      "tcp://127.0.0.1:#{Aggro.publisher_port}"
+    end
+
+    def to_s
+      id
+    end
+
+    private
+
+    def create_loopback_client
+      ->(msg) { Aggro.server.handle_message msg }.tap do |proc|
+        proc.class_eval { alias_method :post, :call }
+      end
+    end
+  end
+end