aggro 0.0.1 → 0.0.2

data/lib/aggro/attribute_dsl.rb

@@ -0,0 +1,96 @@
+module Aggro
+  # Public: Adds a DSL defining attributes and validations.
+  module AttributeDSL
+    extend ActiveSupport::Concern
+
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+
+    def initialize(attrs = {})
+      if Thread.current[:causation_id] && respond_to?(:causation_id=)
+        attrs.merge! causation_id: Thread.current[:causation_id]
+      end
+
+      if Thread.current[:correlation_id] && respond_to?(:correlation_id=)
+        attrs.merge! correlation_id: Thread.current[:correlation_id]
+      end
+
+      super
+    end
+
+    def attributes
+      self.class.attributes.keys.reduce({}) do |hash, name|
+        hash.merge name => send(name)
+      end
+    end
+
+    def serialized_attributes
+      self.class.attributes.reduce({}) do |hash, (name, transform)|
+        hash.merge name => transform.serialize(send(name))
+      end
+    end
+
+    class_methods do
+      def attributes
+        Aggro.class_attributes[name]
+      end
+
+      def attribute(name)
+        create_attrs name, Transform::NOOP
+      end
+
+      def boolean(name)
+        create_attrs name, Transform::Boolean
+      end
+
+      def email(name)
+        create_attrs name, Transform::Email
+      end
+
+      def generate_id(name)
+        create_attrs name, Transform::ID.new(generate: true)
+      end
+
+      def id(name)
+        create_attrs name, Transform::ID.new
+      end
+
+      def integer(name)
+        create_attrs name, Transform::Integer
+      end
+
+      def money(name)
+        require 'money'
+        require 'monetize'
+
+        create_attrs name, Transform::Money
+      rescue LoadError
+        puts '`money` and `monetize` gems must be present to use money type'
+      end
+
+      def string(name)
+        create_attrs name, Transform::String
+      end
+
+      def time_interval(name)
+        require 'time-interval'
+
+        create_attrs name, Transform::TimeInterval
+      rescue LoadError
+        puts '`time-interval` gem must be present to use time_interval type'
+      end
+
+      private
+
+      def create_attrs(name, transformer)
+        attr_reader name
+        attributes[name] = transformer
+
+        define_method("#{name}=") do |value|
+          transformed = self.class.attributes[name].deserialize value
+          instance_variable_set "@#{name}", transformed
+        end
+      end
+    end
+  end
+end

data/lib/aggro/binding_dsl.rb

@@ -0,0 +1,45 @@
+module Aggro
+  # Public: Adds a DSL creating domain event bindings.
+  module BindingDSL
+    def bind(ref, filters: default_filters, to: nil, &block)
+      if to
+        bindings << Aggro.event_bus.subscribe(ref.id, self, to, filters)
+      else
+        bind_block ref, filters, &block
+      end
+    end
+
+    private
+
+    def bind_block(ref, filters, namespace = generate_namespace, &block)
+      new_methods = BlockHelper.method_definitions(&block)
+      event_methods[namespace] = Set.new(new_methods)
+
+      class_eval(&block)
+      move_methods_to_namespace(new_methods, namespace)
+
+      bindings << Aggro.event_bus.subscribe(ref.id, self, namespace, filters)
+    end
+
+    def bindings
+      @bindings ||= []
+    end
+
+    def default_filters
+      {}
+    end
+
+    def generate_namespace
+      [*('a'..'z')].sample(8).join
+    end
+
+    def move_methods_to_namespace(method_list, namespace)
+      class_eval do
+        method_list.each do |method|
+          alias_method "#{namespace}_#{method}", method
+          remove_method method
+        end
+      end
+    end
+  end
+end

data/lib/aggro/block_helper.rb

@@ -0,0 +1,14 @@
+module Aggro
+  # Private: Helper fuction for common operations on blocks.
+  module BlockHelper
+    module_function
+
+    def method_definitions(&block)
+      test_class = Class.new(BasicObject)
+      starting_methods = test_class.instance_methods
+      test_class.class_eval(&block)
+
+      test_class.instance_methods - starting_methods
+    end
+  end
+end

data/lib/aggro/channel.rb

@@ -0,0 +1,37 @@
+module Aggro
+  # Private: Provides an interface to communicate with an aggregate or saga.
+  #          Only loads the target object when needed.
+  class Channel < Struct.new(:id, :type)
+    def forward_command(command)
+      target << command if handles_command?(command)
+    end
+
+    def handles_command?(command)
+      target_class.allows? command
+    end
+
+    def handles_query?(query)
+      target_class.responds_to? query
+    end
+
+    def run_query(query)
+      target.ask query if handles_query? query
+    end
+
+    private
+
+    def target
+      @target ||= begin
+        ConcurrentActor.spawn!(
+          name: id,
+          args: [target_class.new(id)],
+          executor: Concurrent.configuration.global_task_pool
+        )
+      end
+    end
+
+    def target_class
+      @target_class ||= ActiveSupport::Inflector.constantize type
+    end
+  end
+end

data/lib/aggro/client.rb

@@ -0,0 +1,12 @@
+module Aggro
+  # Public: Makes requests against a given endpoint returning parsed responses.
+  class Client
+    def initialize(endpoint)
+      @transport_client = Aggro.transport.client(endpoint)
+    end
+
+    def post(message)
+      MessageParser.parse @transport_client.post message
+    end
+  end
+end

data/lib/aggro/cluster_config.rb

@@ -0,0 +1,57 @@
+module Aggro
+  # Public: Stores the current cluster config. Persists to disk after changes.
+  class ClusterConfig
+    attr_reader :node_name
+
+    def initialize(path)
+      @path = path
+
+      if File.exist? path
+        load_config
+      else
+        initialize_config
+        persist_config
+      end
+    end
+
+    def add_node(name, server)
+      @nodes = nodes.merge(name => server).freeze
+      persist_config
+    end
+
+    def nodes
+      @nodes ||= {}.freeze
+    end
+
+    def server_node?
+      @is_server_node == true
+    end
+
+    private
+
+    def initialize_config
+      @node_name = SecureRandom.uuid
+      @is_server_node = false
+    end
+
+    def load_config
+      YAML.load_file(@path).each do |key, value|
+        instance_variable_set "@#{key}", value.freeze
+      end
+    end
+
+    def persist_config
+      File.open @path, 'w' do |file|
+        file.write YAML.dump to_h
+      end
+    end
+
+    def to_h
+      {
+        node_name: node_name,
+        nodes: nodes,
+        is_server_node: server_node?
+      }
+    end
+  end
+end

data/lib/aggro/command.rb

@@ -0,0 +1,16 @@
+module Aggro
+  # Public: Mixin to turn a PORO into an Aggro command.
+  module Command
+    extend ActiveSupport::Concern
+    include AttributeDSL
+
+    included do
+      generate_id :causation_id
+      generate_id :correlation_id
+    end
+
+    def to_details
+      { name: model_name.name, args: serialized_attributes }
+    end
+  end
+end

data/lib/aggro/concurrent_actor.rb

@@ -0,0 +1,26 @@
+module Aggro
+  # Private: Wraps a given target in an concurrent actor.
+  class ConcurrentActor < Concurrent::Actor::Context
+    def initialize(target)
+      @target = target
+    end
+
+    def on_message(message)
+      if command? message
+        @target.send :apply_command, message
+      elsif query? message
+        @target.send :run_query, message
+      end
+    end
+
+    private
+
+    def command?(message)
+      message.class.included_modules.include? Command
+    end
+
+    def query?(message)
+      message.class.included_modules.include? Query
+    end
+  end
+end

data/lib/aggro/event_bus.rb

@@ -0,0 +1,94 @@
+module Aggro
+  # Public: Publishes events to any subscribed listeners.
+  class EventBus
+    def initialize
+      @remote_publishers = {}
+    end
+
+    def publish(topic, event)
+      Aggro.server.publish Message::Events.new(topic, [event])
+
+      return unless subscriptions.key? topic
+
+      subscriptions[topic].each do |subscription|
+        subscription.handle_event event
+      end
+    end
+
+    def subscribe(topic, subscriber, event_namespace = nil, filters = {})
+      subscription = Subscription.new(topic, subscriber, event_namespace,
+                                      filters, 0)
+
+      catchup_subscriber topic, subscription
+
+      subscriptions[topic] ||= []
+      subscriptions[topic] << subscription
+
+      subscribe_bus_to_publisher topic
+
+      subscription
+    end
+
+    def unsubscribe(topic, subscriber)
+      subscriptions[topic].delete subscriber
+    end
+
+    def shutdown
+      remote_publishers.values.each(&:stop)
+    end
+
+    private
+
+    attr_reader :remote_publishers
+
+    def catchup_local(topic, subscription)
+      Aggro.store.read([topic]).first.events.each do |event|
+        subscription.handle_event event
+      end
+    end
+
+    def catchup_remote(topic, subscription, node)
+      message = Message::GetEvents.new(Aggro.local_node.id, topic, 0)
+      response = node.client.post message
+
+      if response.is_a? Message::Events
+        response.events.each { |event| subscription.handle_event event }
+      else
+        fail 'Could not catchup subscriber'
+      end
+    end
+
+    def catchup_subscriber(topic, subscription)
+      node = Locator.new(topic).primary_node
+
+      if node.is_a? LocalNode
+        catchup_local(topic, subscription)
+      else
+        catchup_remote(topic, subscription, node)
+      end
+    end
+
+    def handle_events(topic, events)
+      subscriptions[topic].each do |subscription|
+        events.each { |event| subscription.handle_event event }
+      end
+    end
+
+    def subscribe_bus_to_publisher(topic)
+      node = Locator.new(topic).primary_node
+
+      return if node.is_a? LocalNode
+
+      publisher_endpoint = node.publisher_endpoint
+      remote_publishers[publisher_endpoint] ||= begin
+        Subscriber.new(publisher_endpoint, method(:handle_events)).tap(&:bind)
+      end
+
+      remote_publishers[publisher_endpoint].subscribe_to_topic topic
+    end
+
+    def subscriptions
+      @subscriptions ||= {}
+    end
+  end
+end

data/lib/aggro/event_dsl.rb

@@ -0,0 +1,53 @@
+module Aggro
+  # Public: Adds a DSL defining event handlers.
+  module EventDSL
+    extend ActiveSupport::Concern
+
+    def handles_event?(event_name, namespace = nil)
+      self.class.handles_event?(event_name, namespace) || \
+        namespace?(namespace) && event_methods[namespace].include?(event_name)
+    end
+
+    private
+
+    def event_methods
+      @event_methods ||= {}
+    end
+
+    def namespace?(namespace)
+      !event_methods[namespace].nil?
+    end
+
+    class_methods do
+      def events(namespace = nil, &block)
+        new_methods = BlockHelper.method_definitions(&block)
+
+        event_methods[namespace] ||= Set.new
+        new_methods.each { |method| event_methods[namespace] << method }
+
+        class_eval(&block)
+
+        class_eval do
+          new_methods.each do |method|
+            alias_method "#{namespace}_#{method}", method
+            remove_method method
+          end
+        end
+      end
+
+      def handles_event?(event_name, namespace = nil)
+        namespace?(namespace) && event_methods[namespace].include?(event_name)
+      end
+
+      private
+
+      def event_methods
+        @event_methods ||= {}
+      end
+
+      def namespace?(namespace)
+        !event_methods[namespace].nil?
+      end
+    end
+  end
+end