hermes_messenger_of_the_gods 2.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hermes_messenger_of_the_gods"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/fly_hermes

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'bundler/setup'
+require 'hermes_messenger_of_the_gods'
+
+class FlyHermes < Thor
+  desc 'start', 'Starts a worker'
+  method_option :worker, type: :string
+  method_option :pool, type: :array
+  method_option :require, type: :string
+  method_option :name, type: :string
+
+  def start
+    if options[:require]
+      require options[:require]
+    else
+      require File.expand_path('config/environment.rb')
+    end
+
+    pools = []
+    if options[:worker]
+       pools << [options[:worker].constantize, 1]
+    elsif options[:pool]
+
+      options[:pool].each do |pool|
+        pool_klass, pool_size = pool.split('--', 2)
+        pool_size = pool_size.to_i if pool_size
+        raise "Pool size must be > 0" if pool_size.nil? or pool_size < 1
+
+        pools << [
+          pool_klass.constantize,
+          pool_size
+        ]
+      end
+    end
+
+    if pools.empty?
+      raise "No workers specified. --worker or --pool is required"
+    end
+
+    pools.each do |worker_klass, count|
+      count.times do |i|
+        fork do
+          worker = worker_klass.build_worker
+          worker.name = options[:name] if options[:name]
+          worker.name += "::#{i}"
+          worker.work_off
+        end
+      end
+    end
+
+    Process.waitall
+  end
+end
+
+FlyHermes.start(ARGV)

data/hermes_messenger_of_the_gods.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hermes_messenger_of_the_gods/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hermes_messenger_of_the_gods'
+  spec.version       = HermesMessengerOfTheGods::VERSION
+  spec.authors       = ['Brian Malinconico', 'Stevie Vines']
+  spec.email         = ['bmalinconico@terminus.com', 'stevievines@gmail.com']
+  spec.metadata['allowed_push_host'] = "https://www.rubygems.org"
+
+  spec.summary       = 'Create and receive messages like a god!'
+  spec.description   = 'Things'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activemodel', '> 4.2.3'
+  spec.add_dependency 'activesupport', '> 4.2.3'
+  spec.add_dependency 'aws-sdk-sns', '~> 1.0'
+  spec.add_dependency 'aws-sdk-sqs', '~> 1.0'
+  spec.add_dependency 'protobuf3_fixer'
+  spec.add_dependency 'thor'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'memory_profiler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov', '~> 1.14'
+  spec.add_development_dependency 'timecop'
+end

data/lib/hermes_messenger_of_the_gods.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'hermes_messenger_of_the_gods/version'
+
+require 'hermes_messenger_of_the_gods/exceptions'
+require 'hermes_messenger_of_the_gods/configuration'
+
+require 'hermes_messenger_of_the_gods/logging_helpers'
+require 'hermes_messenger_of_the_gods/endpoint_builder'
+
+require 'hermes_messenger_of_the_gods/concerns/base'
+require 'hermes_messenger_of_the_gods/concerns/message'
+require 'hermes_messenger_of_the_gods/concerns/worker'
+require 'hermes_messenger_of_the_gods/concerns/mono_message'
+require 'hermes_messenger_of_the_gods/concerns/grpc_protobuf'
+
+require 'hermes_messenger_of_the_gods/endpoints'
+
+require 'hermes_messenger_of_the_gods/output/basic'
+
+module HermesMessengerOfTheGods
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      configuration
+    end
+    alias config configure
+
+    def async_dispatches_in_progress
+      @async_dispatches_in_progress ||= 0
+    end
+
+    def increment_async_dispatches_in_progress
+      monitor.synchronize do
+        self.async_dispatches_in_progress += 1
+      end
+    end
+
+    def decrement_async_dispatches_in_progress
+      monitor.synchronize do
+        self.async_dispatches_in_progress -= 1
+      end
+    end
+
+    private
+
+    attr_writer :async_dispatches_in_progress
+
+    def monitor
+      @monitor ||= Monitor.new
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/concerns/base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/object/blank'
+
+module HermesMessengerOfTheGods
+  module Concerns
+    module Base
+      extend ActiveSupport::Concern
+
+      include EndpointBuilder::Helpers
+      include LoggingHelpers
+
+      included do
+        def instrument(name, payload = {}, &blk)
+          name = [
+            'hermes_messenger_of_the_gods',
+            notification_prefix,
+            name
+          ].reject(&:blank?).join('.')
+
+          payload[_instrument_key] ||= self if _instrument_key
+          ActiveSupport::Notifications.instrument(name, payload, &blk)
+        end
+
+        def notification_prefix
+          _instrument_key
+        end
+
+        def _instrument_key
+          if is_a?(HermesMessengerOfTheGods::Concerns::Worker)
+            :worker
+          elsif is_a?(HermesMessengerOfTheGods::Concerns::Message)
+            :message
+          elsif is_a?(HermesMessengerOfTheGods::Endpoints::Base)
+            :endpoint
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/concerns/grpc_protobuf.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'protobuf3_fixer'
+module HermesMessengerOfTheGods
+  module Concerns
+    module GrpcProtobuf
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_protobuf_class
+
+        alias_method :_pre_grpc_protobuff_init, :initialize
+        def initialize(protobuf, options = {})
+          unless protobuf.is_a?(self.class._protobuf_class)
+            raise "#{self.class} requires a Protobuf for initialization"
+          end
+
+          _pre_grpc_protobuff_init(protobuf.to_h.merge!(options))
+        end
+
+        def _build_for_transmission
+          # Hermes expects a hash
+          JSON.parse(serialize_with_defaults)
+        end
+
+        def serialize_with_defaults
+          # Use the protobuf class' encode_json to generate defaults for any missing keys
+          self.class._protobuf_class.encode_json(message_as_proto, emit_defaults: true)
+        end
+
+        def message_as_proto
+          # Build a proto with the incoming hash
+          self.class._protobuf_class.new(to_message)
+        end
+
+      end
+
+      class_methods do
+        def build(message)
+          new(protobuf_class.new(message))
+        end
+
+        def from_message(attrs = {}, &blk)
+          # Hermes provides a hash, but we want to leverage the protobuf's built in deserialization, so dump it to json
+          pb = _protobuf_class.decode_json(JSON.dump(attrs))
+          new(pb, &blk)
+        end
+
+        def protobuf_class
+          _protobuf_class
+        end
+
+        def protobuf_class=(klass)
+          self._protobuf_class = klass
+          klass.descriptor.each do |f|
+            attr_accessor f.name.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/concerns/message.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_support'
+require 'active_support/core_ext/hash'
+
+require 'hermes_messenger_of_the_gods/concerns/base'
+
+module HermesMessengerOfTheGods
+  module Concerns
+    module Message
+      extend ActiveSupport::Concern
+
+      include ActiveModel::Model
+      include HermesMessengerOfTheGods::Concerns::Base
+
+      attr_accessor :targeted_endpoints
+
+      def original_message
+        @original_message
+      end
+
+      def initialize(options = {})
+        @monitor = Monitor.new
+        self.targeted_endpoints = options.delete(:endpoints)
+        super
+      end
+
+      def validate!
+        raise HermesMessengerOfTheGods::ValidationError, self unless valid?
+      end
+
+      def dispatch
+        dispatch!
+      rescue StandardError
+        false
+      end
+
+      def dispatch_async
+        HermesMessengerOfTheGods.increment_async_dispatches_in_progress
+        Thread.new do
+          dispatch
+        ensure
+          HermesMessengerOfTheGods.decrement_async_dispatches_in_progress
+        end
+      end
+
+      def dispatch_async!
+        HermesMessengerOfTheGods.increment_async_dispatches_in_progress
+        Thread.new do
+          dispatch!
+        ensure
+          HermesMessengerOfTheGods.decrement_async_dispatches_in_progress
+        end
+      end
+
+      def dispatch!(endpoint_args: {})
+        run_callbacks :dispatch do
+          validate!
+
+          endpoints.collect do |ep_name, endpoint|
+            next if targeted_endpoints && !targeted_endpoints.include?(ep_name)
+
+            Thread.new do
+              endpoint.dispatch!(self, endpoint_args) unless HermesMessengerOfTheGods.config.stub_dispatch
+              register_success(ep_name, endpoint.result)
+            rescue StandardError => e
+              register_failure(ep_name, e)
+            ensure
+              endpoint.teardown
+            end
+          end.compact.map(&:join)
+
+          unless dispatch_errors.empty?
+            klass = if successes.empty?
+                      HermesMessengerOfTheGods::MessageDispatchTotalFailure
+                    else
+                      HermesMessengerOfTheGods::MessageDispatchPartialFailure
+                    end
+
+            ex = klass.new
+            ex.exceptions = dispatch_errors
+            raise ex
+          end
+        end
+
+        true
+      end
+
+      def register_failure(ep_name, error)
+        @monitor.synchronize do
+          instrument(:dispatch_failure, endpoint_name: ep_name, exception: error)
+          dispatch_errors[ep_name] = error
+        end
+      end
+
+      def register_success(ep_name, return_value)
+        @monitor.synchronize do
+          successes[ep_name] = return_value
+        end
+      end
+
+      def dispatch_errors
+        @dispatch_errors ||= {}
+      end
+
+      def successes
+        @successes ||= {}
+      end
+
+      def _build_for_transmission
+        to_message
+      end
+
+      def to_message
+        attributes
+      end
+
+      def attributes
+        (self.class._defined_attributes || []).each.with_object({}) do |attr, hsh|
+          hsh[attr] = send(attr)
+        end
+      end
+
+      def inspect
+        "<#{self.class}: #{attributes}>"
+      end
+
+      included do
+        class_attribute :_defined_attributes, :_endpoints, :_circuit_breaker_errors, :_max_consecutive_failures
+
+        define_model_callbacks :dispatch
+
+        around_dispatch { |_, blk| instrument(:dispatch, &blk) }
+      end
+
+      class_methods do
+        def from_message(attrs = {}, &blk)
+          attrs = attrs.slice(*_defined_attributes.map(&:to_s))
+          new(attrs, &blk)
+        end
+
+        def attr_accessor(*args)
+          self._defined_attributes ||= []
+          self._defined_attributes += args
+          super
+        end
+
+        def endpoints
+          _endpoints
+        end
+
+        def circuit_breaker_errors
+          _circuit_breaker_errors
+        end
+
+
+        def max_consecutive_failures
+          _max_consecutive_failures
+        end
+
+        def max_consecutive_failures=(val)
+          raise 'Expected an Integer' unless val.is_a?(Integer) || val.is_a?(NilClass)
+          self._max_consecutive_failures = val
+        end
+
+        def circuit_breaker_errors=(val)
+          val ||= {}
+          raise 'Expected a hash' unless val.is_a?(Hash)
+
+          val.each do |err, actions|
+            val[err][:sleep] ||= 0
+            val[err][:fatal] ||= false
+          end
+
+          val.each do |err, actions|
+            raise ':sleep must be a number' unless actions[:sleep].is_a?(Numeric)
+            raise ':fatal must be a boolean' unless [true, false].include?(actions[:fatal])
+          end
+
+          self._circuit_breaker_errors = val
+        end
+
+        def endpoints=(val)
+          unless val.is_a?(Hash)
+            raise 'Endpoints expects a hash {endpoint_name: endpoint_handler}'
+          end
+
+          self._endpoints = val
+        end
+      end
+    end
+  end
+end