aggro 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0390645ca46508f02d985623d99edef035ab1dbe
-  data.tar.gz: d4835e34b8fbf89d108a9b349b603ce6f677de9d
+  metadata.gz: f0a86dcceeca3a9a1fd14a21861d052541ad178c
+  data.tar.gz: e9bd46d0f4ea83a97e355df1b8ddc4dd9ddc2022
 SHA512:
-  metadata.gz: 20423f5017bd38745a381efa55e7e863269e9e568ea47456587a0977e2cd96c8edd147e97001dccaa0ea70a4a6c3f54e270c59a346b905130037b9a9b72ca20e
-  data.tar.gz: ca72c456d6292cc417f2629449efed271189327b06da282be82b10cb269322d613029e6e0882f0ec5d3884e1acf36d7bef1da6e23ce3481929b7778978db8414
+  metadata.gz: ff83f579f3a4aae8abc6fda0b3f4f428b8b74266b11532c7ec4073d5299dde185f12c478a5a90b89c920befa29bd5e65d1d801fba30b5abd367ca4eb3d930fa7
+  data.tar.gz: f907f007f9cdb1b2a4fe7adb529cf2f37ee913a921c27f6337c7bfd2c599dcda4c122d08b883bda8197ac14065087f372fc696a79f4bc624515d61f6c80a92cc

data/.rubocop.yml

@@ -3,6 +3,14 @@ AllCops:
     - aggro.gemspec
     - lib/aggro/version.rb
 
+Documentation:
+  Exclude:
+    - spec/**/*
+
 Eval:
   Exclude:
     - spec/spec_helper.rb
+
+RaiseArgs:
+  Exclude:
+    - lib/aggro/nanomsg_transport/connection.rb

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - jruby-19mode
+  - ruby-head
+  - jruby-head
+matrix:
+  allow_failures:
+    - rvm: jruby-19mode
+    - rvm: jruby-head
+    - rvm: ruby-head
+script: bundle exec rspec
+before_install:
+  - git clone git://github.com/nanomsg/nanomsg.git
+  - cd nanomsg && ./autogen.sh && ./configure && sudo make install && sudo ldconfig && cd ${TRAVIS_BUILD_DIR}

data/Gemfile

@@ -2,3 +2,12 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in aggro.gemspec
 gemspec
+
+gem 'money'
+gem 'monetize'
+
+gem 'time-interval'
+
+group :ci do
+  gem 'coveralls', require: false
+end

data/README.md

@@ -1,6 +1,10 @@
 # Aggro
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/SebastianEdwards/aggro.svg?branch=master)](https://travis-ci.org/SebastianEdwards/aggro)
+[![Code Climate](https://codeclimate.com/github/SebastianEdwards/aggro/badges/gpa.svg)](https://codeclimate.com/github/SebastianEdwards/aggro)
+[![Coverage Status](https://coveralls.io/repos/SebastianEdwards/aggro/badge.svg)](https://coveralls.io/r/SebastianEdwards/aggro)
+
+Distributed in-memory event-store.
 
 ## Installation
 

data/Rakefile

@@ -1 +1,11 @@
 require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task default: :spec
+rescue LoadError
+  puts 'no rspec available'
+end

data/aggro.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Aggro::VERSION
   spec.authors       = ['Sebastian Edwards']
   spec.email         = ['me@sebastianedwards.co.nz']
-  spec.summary       = 'Distributed in-memory aggregates.'
+  spec.summary       = 'Distributed in-memory event-store.'
   spec.description   = ''
   spec.homepage      = ''
   spec.license       = 'MIT'
@@ -24,5 +24,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'guard-rspec'
   spec.add_development_dependency 'rubocop'
 
+  spec.add_runtime_dependency 'activemodel'
+  spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'concurrent-ruby'
   spec.add_runtime_dependency 'consistent-hashing'
+  spec.add_runtime_dependency 'invokr'
+  spec.add_runtime_dependency 'nio4r'
+  spec.add_runtime_dependency 'nn-core'
+  spec.add_runtime_dependency 'object-stream'
 end

data/lib/aggro.rb

@@ -1,22 +1,206 @@
 require 'aggro/version'
 
+require 'active_model'
+require 'active_support/core_ext/hash/keys'
+require 'concurrent'
 require 'consistent_hashing'
+require 'invokr'
+require 'fileutils'
+require 'msgpack'
+require 'object-stream'
+require 'yaml'
 
+# Private: Define methods to protect handlers from code reloading.
+module Aggro
+  module_function
+
+  def class_attributes
+    @class_attributes ||= Hash.new { |hash, key| hash[key] = {} }
+  end
+
+  def command_handlers
+    @command_handlers ||= Hash.new { |hash, key| hash[key] = {} }
+  end
+
+  def query_handlers
+    @query_handlers ||= Hash.new { |hash, key| hash[key] = {} }
+  end
+
+  def step_handlers
+    @step_handlers ||= Hash.new { |hash, key| hash[key] = {} }
+  end
+end
+
+require 'aggro/abstract_store'
+require 'aggro/attribute_dsl'
+require 'aggro/event_dsl'
+
+require 'aggro/message/ask'
+require 'aggro/message/command'
+require 'aggro/message/create_aggregate'
+require 'aggro/message/endpoint'
+require 'aggro/message/events'
+require 'aggro/message/get_events'
+require 'aggro/message/heartbeat'
+require 'aggro/message/invalid_target'
+require 'aggro/message/ok'
+require 'aggro/message/publisher_endpoint_inquiry'
+require 'aggro/message/query'
+require 'aggro/message/result'
+require 'aggro/message/start_saga'
+require 'aggro/message/unhandled_operation'
+require 'aggro/message/unknown_operation'
+
+require 'aggro/handler/command'
+require 'aggro/handler/create_aggregate'
+require 'aggro/handler/get_events'
+require 'aggro/handler/query'
+require 'aggro/handler/start_saga'
+
+require 'aggro/transform/boolean'
+require 'aggro/transform/email'
+require 'aggro/transform/id'
+require 'aggro/transform/integer'
+require 'aggro/transform/money'
+require 'aggro/transform/noop'
+require 'aggro/transform/string'
+require 'aggro/transform/time_interval'
+
+require 'aggro/aggregate'
 require 'aggro/aggregate_ref'
+require 'aggro/binding_dsl'
+require 'aggro/block_helper'
+require 'aggro/channel'
+require 'aggro/client'
+require 'aggro/cluster_config'
+require 'aggro/command'
+require 'aggro/concurrent_actor'
+require 'aggro/event_bus'
+require 'aggro/event_proxy'
+require 'aggro/event_serializer'
+require 'aggro/file_store'
+require 'aggro/local_node'
+require 'aggro/locator'
+require 'aggro/message_parser'
+require 'aggro/message_router'
+require 'aggro/nanomsg_transport'
+require 'aggro/node'
+require 'aggro/node_list'
+require 'aggro/projection'
+require 'aggro/query'
+require 'aggro/saga'
+require 'aggro/saga_runner'
+require 'aggro/saga_status'
+require 'aggro/server'
+require 'aggro/subscriber'
+require 'aggro/subscription'
 
 # Public: Module for namespacing and configuration methods.
 module Aggro
-  def self.initialize_hash_ring(servers = servers_from_env)
-    ConsistentHashing::Ring.new.tap do |ring|
-      servers.each { |server| ring.add server }
+  ClientNode = Struct.new(:id)
+  Event = Struct.new(:name, :occured_at, :details)
+  EventArgument = Struct.new(:data, :type)
+  EventStream = Struct.new(:id, :type, :events)
+  QueryError = Struct.new(:cause)
+
+  MESSAGE_TYPES = Message
+                  .constants
+                  .map { |sym| Message.const_get sym }
+                  .select { |m| m.const_defined? 'TYPE_CODE' }
+                  .each_with_object({}) { |m, h| h.merge! m::TYPE_CODE => m }
+                  .freeze
+
+  class << self
+    attr_writer :data_dir
+    attr_writer :port
+    attr_writer :publisher_port
+    attr_writer :transport
+  end
+
+  module_function
+
+  def channels
+    if cluster_config.server_node?
+      @channels ||= begin
+        Aggro.store.registry.reduce({}) do |channels, (id, type)|
+          channels.merge id => Channel.new(id, type)
+        end
+      end
+    else
+      @channels ||= {}
+    end
+  end
+
+  def cluster_config
+    @cluster_config ||= ClusterConfig.new cluster_config_path
+  end
+
+  def cluster_config_path
+    [data_dir, 'cluster.yml'].join('/')
+  end
+
+  def data_dir
+    @data_dir ||= begin
+      ENV.fetch('AGGRO_DIR') { './tmp/aggro' }.tap do |dir|
+        FileUtils.mkdir_p dir
+      end
+    end
+  end
+
+  def event_bus
+    @event_bus ||= EventBus.new
+  end
+
+  def local_node
+    if cluster_config.server_node?
+      @local_node ||= LocalNode.new(cluster_config.node_name)
+    else
+      @local_node ||= ClientNode.new(SecureRandom.uuid)
+    end
+  end
+
+  def node_list
+    @node_list ||= begin
+      NodeList.new.tap do |node_list|
+        nodes = cluster_config.nodes
+        nodes.each { |name, server| node_list.add Node.new(name, server) }
+        node_list.add local_node if cluster_config.server_node?
+      end
     end
   end
 
-  def self.hash_ring
-    @hash_ring ||= initialize_hash_ring
+  def port
+    @port ||= ENV.fetch('PORT') { 5000 }.to_i
+  end
+
+  def publisher_port
+    @publisher_port ||= ENV.fetch('PUBLISHER_PORT') { 6000 }.to_i
+  end
+
+  def reset
+    @cluster_config = nil
+    @event_bus.shutdown if @event_bus
+    @event_bus = nil
+    @local_node = nil
+    @node_list = nil
+    @port = nil
+    @publisher = nil
+    @publisher_port = nil
+    @server = nil
+    @store = nil
+  end
+
+  def server
+    return unless cluster_config.server_node?
+
+    @server ||= Server.new(local_node.endpoint, local_node.publisher_endpoint)
+  end
+
+  def store
+    @store ||= FileStore.new(data_dir)
   end
 
-  def self.servers_from_env
-    ENV['AGGRO_SERVERS'] ? ENV['AGGRO_SERVERS'].split(',') : []
+  def transport
+    @transport ||= NanomsgTransport
   end
 end

data/lib/aggro/abstract_store.rb

@@ -0,0 +1,12 @@
+module Aggro
+  # Private: Abstract class for an event store.
+  class AbstractStore
+    def read(_refs)
+      fail NotImplementedError
+    end
+
+    def write(_event_streams)
+      fail NotImplementedError
+    end
+  end
+end

data/lib/aggro/aggregate.rb

@@ -0,0 +1,98 @@
+module Aggro
+  # Public: Mixin to turn a PORO into an Aggro aggregate.
+  module Aggregate
+    extend ActiveSupport::Concern
+    include EventDSL
+
+    def initialize(id)
+      @id = id
+
+      @projections = self.class.projections.reduce({}) do |h, (name, klass)|
+        class_eval { define_method(name) { @projections[name] } }
+        h.merge name => klass.new(id)
+      end
+
+      Aggro.event_bus.subscribe(id, self)
+    end
+
+    private
+
+    def apply_command(command)
+      return unless self.class.allows? command
+
+      @_context = command.attributes
+
+      handler = self.class.handler_for_command(command.class)
+      instance_exec command, &handler
+    ensure
+      @_context = nil
+    end
+
+    def did
+      fail 'Must be called within a command handler' unless @_context
+
+      @event_caller ||= EventProxy.new(self, @id)
+    end
+
+    def run_query(query)
+      return unless self.class.responds_to? query
+
+      handler = self.class.handler_for_query(query.class)
+      instance_exec query, &handler
+    rescue RuntimeError => e
+      QueryError.new(e)
+    end
+
+    class_methods do
+      def allows(command_class, &block)
+        command_handlers[command_class] = block if block
+      end
+
+      def allows?(command)
+        command_handlers.keys.include? command.class
+      end
+
+      def create(id = SecureRandom.uuid)
+        find(id).create
+      end
+
+      def find(id)
+        AggregateRef.new id, name
+      end
+
+      def handler_for_command(command_class)
+        command_handlers[command_class]
+      end
+
+      def handler_for_query(query_class)
+        query_handlers[query_class]
+      end
+
+      def projection(projection_name, via:)
+        projections[projection_name] = via
+      end
+
+      def projections
+        @projections ||= {}
+      end
+
+      def responds_to(query_class, &block)
+        query_handlers[query_class] = block if block
+      end
+
+      def responds_to?(query)
+        query_handlers.keys.include? query.class
+      end
+
+      private
+
+      def command_handlers
+        Aggro.command_handlers[name]
+      end
+
+      def query_handlers
+        Aggro.query_handlers[name]
+      end
+    end
+  end
+end

data/lib/aggro/aggregate_ref.rb

@@ -1,14 +1,76 @@
 module Aggro
   # Public: Reference to an Aggregate which may be local or remote.
-  class AggregateRef
-    attr_reader :id
+  class AggregateRef < Struct.new(:id, :type)
+    def command(command)
+      response = send_command(command)
 
-    def initialize(id)
-      @id = id
+      if response.is_a? Message::InvalidTarget
+        create
+        response = send_command(command)
+      end
+
+      fail 'Could not send command' unless response.is_a? Message::OK
+
+      self
+    end
+
+    def create
+      response = client.post build_create_message
+
+      fail 'Could not create aggregate' unless response.is_a? Message::OK
+
+      self
+    end
+
+    def query(query)
+      response = send_query(query)
+
+      if response.is_a? Message::InvalidTarget
+        create
+        response = send_query(query)
+      end
+
+      handle_query_response response
+    end
+
+    private
+
+    def build_command_message(command)
+      Message::Command.new(Aggro.local_node.id, id, command.to_details)
+    end
+
+    def build_create_message
+      Message::CreateAggregate.new(Aggro.local_node.id, id, type)
+    end
+
+    def build_query_message(query)
+      Message::Query.new(Aggro.local_node.id, id, query.to_details)
+    end
+
+    def client
+      locator.primary_node.client
+    end
+
+    def handle_query_response(message)
+      fail 'Could not execute query' unless message.is_a? Message::Result
+
+      if message.result.is_a? Aggro::QueryError
+        fail message.result.cause
+      else
+        message.result
+      end
+    end
+
+    def locator
+      @locator ||= Locator.new(id)
+    end
+
+    def send_command(command)
+      client.post build_command_message(command)
     end
 
-    def server
-      @server ||= Aggro.hash_ring.node_for(id)
+    def send_query(query)
+      client.post build_query_message(query)
     end
   end
 end