aggro 0.0.1 → 0.0.2

data/lib/aggro/node.rb

@@ -0,0 +1,29 @@
+module Aggro
+  # Public: Represents an aggro server node.
+  class Node < Struct.new(:id, :endpoint)
+    def client
+      @client ||= Aggro::Client.new(endpoint)
+    end
+
+    def publisher_endpoint
+      @publisher_endpoint ||= discover_publisher_endpoint
+    end
+
+    def to_s
+      id
+    end
+
+    private
+
+    def discover_publisher_endpoint
+      message = Message::PublisherEndpointInquiry.new(Aggro.local_node.id)
+      response = client.post(message)
+
+      if response.is_a? Message::Endpoint
+        response.endpoint
+      else
+        fail "Could not discover publisher endpoint for #{id}"
+      end
+    end
+  end
+end

data/lib/aggro/node_list.rb

@@ -0,0 +1,39 @@
+module Aggro
+  # Public: Computes which nodes are responsible for a given aggregate ID.
+  class NodeList
+    DEFAULT_REPLICATION_FACTOR = 3
+
+    attr_reader :state
+
+    def add(node)
+      hash_ring << node
+
+      update_state
+    end
+
+    def nodes_for(id, replication_factor = default_replication_factor)
+      nodes
+        .cycle
+        .take(nodes.index(hash_ring.node_for(id)) + replication_factor)
+        .last(replication_factor)
+    end
+
+    def nodes
+      hash_ring.nodes.sort_by(&:id)
+    end
+
+    private
+
+    def default_replication_factor
+      [nodes.length, DEFAULT_REPLICATION_FACTOR].min
+    end
+
+    def hash_ring
+      @hash_ring ||= ConsistentHashing::Ring.new
+    end
+
+    def update_state
+      @state = Digest::MD5.hexdigest(nodes.map(&:to_s).join)[0..16].hex
+    end
+  end
+end

data/lib/aggro/projection.rb

@@ -0,0 +1,13 @@
+module Aggro
+  # Public: Mixin to turn a PORO into an Aggro projection.
+  module Projection
+    extend ActiveSupport::Concern
+
+    include BindingDSL
+    include EventDSL
+
+    def initialize(id)
+      Aggro.event_bus.subscribe(id, self)
+    end
+  end
+end

data/lib/aggro/query.rb

@@ -0,0 +1,11 @@
+module Aggro
+  # Public: Mixin to turn a PORO into an Aggro query.
+  module Query
+    extend ActiveSupport::Concern
+    include AttributeDSL
+
+    def to_details
+      { name: model_name.name, args: serialized_attributes }
+    end
+  end
+end

data/lib/aggro/saga.rb

@@ -0,0 +1,94 @@
+module Aggro
+  # Public: Mixin to turn a PORO into an Aggro saga.
+  module Saga
+    extend ActiveSupport::Concern
+
+    include AttributeDSL
+    include BindingDSL
+    include EventDSL
+
+    included do
+      generate_id :causation_id
+      generate_id :correlation_id
+    end
+
+    def bindings
+      @runner.bindings
+    end
+
+    def default_filters
+      { correlation_id: correlation_id }
+    end
+
+    def saga_id
+      @saga_id ||= SecureRandom.uuid
+    end
+
+    def start
+      fail 'Saga is not valid' unless valid?
+
+      promise = SagaStatus.new(saga_id)
+
+      message = Message::StartSaga.new Aggro.local_node.id, saga_id, to_details
+      response = primary_node.client.post message
+
+      if response.is_a? Message::OK
+        promise
+      else
+        fail 'Saga could not be started'
+      end
+    end
+
+    private
+
+    def primary_node
+      @primary_node ||= Locator.new(saga_id).primary_node
+    end
+
+    def to_details
+      { name: model_name.name, args: serialized_attributes }
+    end
+
+    def reject(reason = nil)
+      fail 'Runner not set' unless @runner
+
+      @runner.reject reason
+    end
+
+    def resolve(value = nil)
+      fail 'Runner not set' unless @runner
+
+      @runner.resolve value
+    end
+
+    def transition(step_name, *args)
+      fail 'Runner not set' unless @runner
+
+      @runner.transition step_name, *args
+    end
+
+    class_methods do
+      def handler_for_step(step_name)
+        steps[step_name]
+      end
+
+      def handles_step?(step_name)
+        steps.key? step_name
+      end
+
+      def initial(step_name = nil)
+        step_name ? @initial = step_name : @initial
+      end
+
+      def step(step_name, &block)
+        steps[step_name] = block
+      end
+
+      private
+
+      def steps
+        Aggro.step_handlers[name]
+      end
+    end
+  end
+end

data/lib/aggro/saga_runner.rb

@@ -0,0 +1,87 @@
+require 'aggro/saga_runner/start_saga'
+
+module Aggro
+  # Private: Aggregate which runs saga processes.
+  class SagaRunner
+    include Aggregate
+
+    allows StartSaga do |command|
+      @details = command.details
+
+      @klass = ActiveSupport::Inflector.constantize command.name
+
+      @saga = @klass.new(@details).tap do |saga|
+        saga.instance_variable_set(:@saga_id, command.id)
+        saga.instance_variable_set(:@runner, self)
+      end
+
+      did.started state: @klass.initial
+
+      run_step @klass.initial
+    end
+
+    def bindings
+      @bindings ||= []
+    end
+
+    def cancel_bindings
+      bindings.each(&:cancel)
+      @bindings = []
+    end
+
+    def reject(reason)
+      did.rejected reason: reason
+
+      teardown
+    end
+
+    def resolve(value)
+      did.resolved value: value
+
+      teardown
+    end
+
+    def transition(step_name, *args)
+      cancel_bindings
+      did.transitioned state: step_name, args: args
+
+      run_step step_name, args
+    end
+
+    private
+
+    def did
+      @_context = @details
+      super
+    end
+
+    def run_step(step_name, args = [])
+      with_thread_ids do
+        handler = @klass.handler_for_step(step_name)
+
+        fail "Step '#{step_name}' does not exist" unless handler
+
+        @saga.send(:instance_exec, *args, &handler)
+      end
+    rescue => e
+      reject e.to_s
+    end
+
+    def teardown
+      @saga = nil
+      cancel_bindings
+      Aggro.event_bus.subscribe(@id, self)
+    end
+
+    def with_thread_ids
+      old_causation_id = Thread.current[:causation_id]
+      old_correlation_id = Thread.current[:correlation_id]
+      Thread.current[:causation_id] = @details[:causation_id]
+      Thread.current[:correlation_id] = @details[:correlation_id]
+      yield
+    ensure
+      Thread.current[:causation_id] = old_causation_id
+      Thread.current[:correlation_id] = old_correlation_id
+    end
+  end
+end

data/lib/aggro/saga_runner/start_saga.rb

@@ -0,0 +1,12 @@
+module Aggro
+  class SagaRunner
+    # Private: Command to start a SagaRunner.
+    class StartSaga
+      include Command
+
+      id :id
+      string :name
+      attribute :details
+    end
+  end
+end

data/lib/aggro/saga_status.rb

@@ -0,0 +1,29 @@
+module Aggro
+  # Public: Tracks the state of a saga as it processes.
+  class SagaStatus
+    include Projection
+    include Concurrent::Obligation
+
+    def initialize(id)
+      @state = :unscheduled
+      init_obligation
+      super
+    end
+
+    events do
+      def started
+        self.state = :pending
+      end
+
+      def rejected(reason)
+        set_state false, nil, reason
+        event.set
+      end
+
+      def resolved(value)
+        set_state true, value, nil
+        event.set
+      end
+    end
+  end
+end

data/lib/aggro/server.rb

@@ -0,0 +1,88 @@
+module Aggro
+  # Public: Binds a transport endpoint and handles incoming messages.
+  class Server
+    RAW_HANDLER = :handle_raw
+
+    HANDLERS = {
+      Message::Command                  => :handle_command,
+      Message::CreateAggregate          => :handle_create,
+      Message::GetEvents                => :handle_get_events,
+      Message::Heartbeat                => :handle_heartbeat,
+      Message::PublisherEndpointInquiry => :handle_publisher_endpoint_inquiry,
+      Message::Query                    => :handle_query,
+      Message::StartSaga                => :handle_start_saga
+    }
+
+    def initialize(endpoint, publisher_endpoint)
+      @endpoint = endpoint
+      @publisher_endpoint = publisher_endpoint
+
+      @transport_server = Aggro.transport.server endpoint, method(RAW_HANDLER)
+      @transport_publisher = Aggro.transport.publisher publisher_endpoint
+    end
+
+    def bind
+      @transport_server.start
+      @transport_publisher.open_socket
+    end
+
+    def handle_message(message)
+      message_router.route message
+    end
+
+    def publish(message)
+      @transport_publisher.publish message
+    end
+
+    def stop
+      @transport_server.stop
+      @transport_publisher.close_socket
+    end
+
+    private
+
+    def handle_command(message)
+      Handler::Command.new(message, self).call
+    end
+
+    def handle_create(message)
+      Handler::CreateAggregate.new(message, self).call
+    end
+
+    def handle_get_events(message)
+      Handler::GetEvents.new(message, self).call
+    end
+
+    def handle_heartbeat(_message)
+      Message::OK.new
+    end
+
+    def handle_publisher_endpoint_inquiry(_message)
+      Message::Endpoint.new @publisher_endpoint
+    end
+
+    def handle_query(message)
+      Handler::Query.new(message, self).call
+    end
+
+    def handle_raw(raw)
+      handle_message MessageParser.parse raw
+    end
+
+    def handle_start_saga(message)
+      Handler::StartSaga.new(message, self).call
+    end
+
+    def message_router
+      @message_router ||= begin
+        MessageRouter.new.tap do |router|
+          HANDLERS.each { |type, sym| router.attach_handler type, method(sym) }
+        end
+      end
+    end
+
+    def publisher
+      @publisher ||= Publisher.new(local_node.publisher_endpoint)
+    end
+  end
+end

data/lib/aggro/subscriber.rb

@@ -0,0 +1,48 @@
+module Aggro
+  # Public: Subscribes to topics at a given endpoint.
+  class Subscriber
+    RAW_HANDLER = :handle_raw
+
+    def initialize(endpoint, callable = nil, &block)
+      if callable
+        @callback = callable
+      elsif block_given?
+        @callback = block
+      else
+        fail ArgumentError
+      end
+
+      @transport_sub = Aggro.transport.subscriber endpoint, method(RAW_HANDLER)
+      @subscribed_topics = Set.new
+    end
+
+    def bind
+      @transport_sub.start
+    end
+
+    def handle_message(message)
+      @callback.call message.id, message.events if message.is_a? Message::Events
+    end
+
+    def stop
+      @transport_sub.stop
+    end
+
+    def subscribe_to_topic(topic)
+      return if @subscribed_topics.include? topic
+
+      @subscribed_topics << topic
+      @transport_sub.add_subscription message_prefix_for_topic(topic)
+    end
+
+    private
+
+    def handle_raw(raw)
+      handle_message MessageParser.parse raw
+    end
+
+    def message_prefix_for_topic(topic)
+      Message::Events::TYPE_CODE + topic
+    end
+  end
+end