hermes_messenger_of_the_gods 2.0.0

data/lib/hermes_messenger_of_the_gods/exceptions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module HermesMessengerOfTheGods
+  if defined?(ActiveModel::ValidationError)
+    class ValidationError < ActiveModel::ValidationError; end
+  else
+    class ValidationError < StandardError
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+        errors = @model.errors.full_messages.join(', ')
+        super(errors)
+      end
+    end
+  end
+
+  class MessageDispatchFailed < StandardError
+    attr_accessor :exceptions
+  end
+  class MessageDispatchTotalFailure < MessageDispatchFailed; end
+  class MessageDispatchPartialFailure < MessageDispatchFailed; end
+
+  module Endpoints
+    class FatalError < RuntimeError; end
+  end
+end

data/lib/hermes_messenger_of_the_gods/logging_helpers.rb

@@ -0,0 +1,30 @@
+require 'active_support'
+
+module HermesMessengerOfTheGods
+  module LoggingHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      Logger::Severity.constants.each do |sev|
+        define_method(sev.downcase) do |msg = nil, &blk|
+          say("Logger::#{sev}".constantize, msg, &blk)
+        end
+      end
+
+      def say(level, msg = nil, &blk)
+        return if HermesMessengerOfTheGods.config.quiet
+
+        [*HermesMessengerOfTheGods.config.logger].compact.each do |logger|
+          logger.progname = logger.progname.tap do |_|
+            logger.progname = log_message_prefix
+            logger.log(level, msg, &blk)
+          end
+        end
+      end
+
+      def log_message_prefix
+        self.class.to_s
+      end
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/output/basic.rb

@@ -0,0 +1,63 @@
+# Worker Output
+module HermesMessengerOfTheGods
+  module Output
+    module Basic
+      @subscriptions = []
+
+      def self.unsubscribe!
+        @subscriptions.map{|s|ActiveSupport::Notifications.unsubscribe(s) }
+      end
+
+      def self.subscribe!
+        unsubscribe!
+
+        @subscriptions = [
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.worker.starting') do |*_, payload|
+            payload[:worker].info { "Starting Worker" }
+          end,
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.worker.run_job') do |_, start, finish, _, payload|
+            payload[:worker].debug { "Completed #{to_log_s(payload[:job])} in #{finish - start}s" }
+          end,
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.worker.starting_job') do |*_, payload|
+            payload[:worker].info { "Starting Job #{to_log_s(payload[:job])}" }
+          end,
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.worker.success') do |*_, payload|
+            payload[:worker].info { "Finished Job #{to_log_s(payload[:job])}" }
+          end,
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.worker.failure') do |*_, payload|
+            payload[:worker].error { "Error in #{to_log_s(payload[:job])}: #{payload[:error].message}" }
+            payload[:worker].debug { "backtrace: #{payload[:error].backtrace}"  }
+          end,
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.worker.fatal_error') do |*_, payload|
+            payload[:worker].error { "Fatal Error: #{to_log_s(payload[:job])}: #{payload[:exception].message}" }
+            payload[:worker].debug { "backtrace: #{payload[:exception].backtrace}"  }
+          end,
+          # Message Output
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.message.dispatch') do |_, _start, _finish, _, payload|
+            payload[:message].info { "Dispatch complete in #{to_log_s(payload[:job])}s" }
+          end,
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.message.dispatch_failure') do |*_, payload|
+            payload[:message].debug { "Dispatch failure to #{to_log_s(payload[:job])}: #{payload[:exception].inspect}" }
+          end,
+          # Endpoint Output
+          ActiveSupport::Notifications.subscribe('hermes_messenger_of_the_gods.endpoint.dispatch') do |_, start, finish, _, payload|
+            payload[:endpoint].info { "Dispatch complete in #{finish - start}s #{" FAILED" if payload.has_key?(:exception)}" }
+          end,
+          ActiveSupport::Notifications.subscribe(/hermes_messenger_of_the_gods.endpoint.(dispatch|final)_failure/) do |name, *_, payload|
+            payload[:endpoint].debug { "Dispatch #{"final " if name.include?('final_')} failure ##{payload[:try]} to #{payload[:endpoint_name]}: #{payload[:exception].inspect}" }
+          end,
+          ActiveSupport::Notifications.subscribe(/hermes_messenger_of_the_gods.endpoint.read_failure/) do |name, *_, payload|
+            payload[:endpoint].error { "A message was received that could not be decoded: #{payload[:exception].message}" }
+          end,
+        ]
+      end
+      subscribe!
+
+      def self.to_log_s(item)
+        item.respond_to?(:to_log_s) ?
+          item.to_log_s :
+          item.inspect
+      end
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/status_server.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module HermesMessengerOfTheGods
+  class WorkerStatusServer
+    def self.start!(worker:, port: nil)
+      new(worker: worker, port: port).start!
+    end
+
+    attr_accessor :worker, :port
+    def initialize(worker:, port: nil)
+      self.worker = worker
+      self.port = port || ENV.fetch('HERMES_WORKER_STATUS_PORT', 4242).to_i
+    end
+
+    def start!
+      Thread.new do
+        server = TCPServer.open port
+        loop do
+          client = server.accept
+          client.puts construct_response
+          client&.close
+        end
+      end
+    end
+
+    def construct_response
+      if worker.healthy?
+        resp = 'OKAY'
+        status_code = '200 OK'
+      else
+        resp = 'ERROR'
+        status_code = '500 Internal Server Error'
+      end
+
+      <<~RESPONSE
+        HTTP/1.1 #{status_code}
+        Date: #{Time.now.utc.strftime('%a, %d %b %Y %T GMT')}
+        Server: Ruby
+        Content-Type: text/html; charset=iso-8859-1
+        Content-Length: #{resp.length}
+
+        #{resp}
+      RESPONSE
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/testing/array_endpoint.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module HermesMessengerOfTheGods
+  module Endpoints
+    class Local < Base
+      class << self
+        attr_accessor :transmit_method
+
+        def clear_queue!
+          @received = nil
+        end
+
+        def received
+          @received ||= Hash.new { |h, k| h[k] = [] }
+        end
+      end
+
+      def received
+        self.class.received[endpoint]
+      end
+
+      def transmit(msg, raw_msg, opts = {})
+        if self.class.transmit_method
+          self.class.transmit_method.call(self, msg, raw_msg)
+        else
+          do_transmit(msg, opts, raw_msg)
+        end
+      end
+
+      def do_transmit(msg, opts, raw_message = {})
+        pub_opts = fetch_option(:publish_options, raw_message) || {}
+        received << { message: msg, options: opts.merge(pub_opts) }
+        "Recorded msg ##{self.class.received[endpoint].length} for #{endpoint}"
+      end
+    end
+  end
+end
+
+if defined?(RSpec)
+  RSpec.configure do |config|
+    config.after(:each) do
+      HermesMessengerOfTheGods::Endpoints::Local.clear_queue!
+      HermesMessengerOfTheGods::Endpoints::Local.transmit_method = nil
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/testing/dispatch_matcher.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :dispatch do |message|
+  supports_block_expectations
+
+  match do |proc|
+    @matched_early = @endpoint.received.detect do |m|
+      a_hash_including(message).matches?(m[:message]) && (
+        @options.nil? ||
+          a_hash_including(@options).matches?(m[:options])
+      ) && (
+        @message_attributes.nil? || a_hash_including(@message_attributes).matches?(m[:message_attributes])
+      )
+    end
+    return false if @matched_early
+
+    proc.call
+    wait_for_async_dispatches
+
+    !!@endpoint.received.detect do |m|
+      a_hash_including(message).matches?(m[:message]) && (
+        @options.nil? ||
+          a_hash_including(@options).matches?(m[:options])
+      ) && (
+        @message_attributes.nil? || a_hash_including(@message_attributes).matches?(m[:options][:message_attributes])
+      )
+    end
+  end
+
+  chain :to_endpoint do |ep|
+    @endpoint = ep
+  end
+
+  chain :with_options do |options|
+    @options = options
+  end
+
+  chain :with_message_attributes do |attributes|
+    @message_attributes = attributes
+  end
+
+
+  failure_message do |_actual|
+    if @matched_early
+      "endpoint already received message that matched: #{message} - message that matched: #{@matched_early}"
+    else
+      "endpoint did not receive a message with content: #{message} - endpoint messages: #{@endpoint.received}"
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/testing/rspec_helpers.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'hermes_messenger_of_the_gods/testing/array_endpoint'
+require 'timeout'
+
+module HermesMessengerOfTheGods
+  module Testing
+    module RSpecHelpers
+      def mock_endpoints
+        @mock_endpoints ||= Hash.new { |h, k| h[k] = {} }
+      end
+
+      def reset_all_mock_endpoints
+        mock_endpoints.values.map(&:values).flatten.map(&:teardown)
+        @mock_endpoints = nil
+      end
+
+      def fake_endpoint(type, endpoint, *args)
+        klass = "HermesMessengerOfTheGods::Endpoints::#{type.to_s.camelize}".constantize
+
+        build_fake_endpoint(klass, endpoint, *args).tap do |build_ep|
+          allow(HermesMessengerOfTheGods::EndpointBuilder).to receive(:build)
+            .with(anything, klass, endpoint, any_args).and_return(build_ep)
+        end
+      end
+
+      def build_fake_endpoint(klass, endpoint, *args)
+        endpoint = endpoint.to_s
+        raise "Endpoint required" if endpoint == ''
+        mock_endpoints[klass][endpoint].options.merge!(*args) if mock_endpoints[klass][endpoint]
+        mock_endpoints[klass][endpoint] ||= Endpoints::Local.new(endpoint, "#{klass}::#{endpoint}", *args)
+        mock_endpoints[klass][endpoint]
+      end
+
+      def setup_for_fake_endpoints!
+        allow(HermesMessengerOfTheGods::EndpointBuilder).to receive(:build)
+          .and_call_original
+      end
+
+      def fake_all_endpoints!
+        allow(HermesMessengerOfTheGods::EndpointBuilder).to receive(:build) do |_, klass, endpoint, *args|
+          build_fake_endpoint(klass, endpoint, *args)
+        end
+      end
+
+      def wait_for_async_dispatches
+        return if HermesMessengerOfTheGods.async_dispatches_in_progress.zero?
+
+        Timeout.timeout(5) do
+          sleep 0.01 until HermesMessengerOfTheGods.async_dispatches_in_progress.zero?
+        end
+      end
+    end
+  end
+end
+
+if defined?(RSpec)
+  RSpec.configure do |config|
+    config.before(:each) do
+      setup_for_fake_endpoints!
+      reset_all_mock_endpoints
+    end
+  end
+end

data/lib/hermes_messenger_of_the_gods/version.rb

@@ -0,0 +1,3 @@
+module HermesMessengerOfTheGods
+  VERSION = '2.0.0'
+end

data/packageGems.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+docker run --rm -t -i \
+  -v $HOME/.ssh:/root/.ssh \
+  --mount type=bind,source="$(pwd)",target=/app \
+  --workdir=/app/api \
+  getterminus/ruby-docker-images:2.6-je-20190204 \
+    /bin/bash -c "
+      bundle config specific_platform true && \
+      bundle lock --add-platform x86_64-linux && \
+      bundle lock --add-platform x86_64-darwin-18 && \
+      bundle package --all
+    "

data/vendor/cache/Protobuf3Fixer-5f9f1a2d2da9/.circleci/config.yml

@@ -0,0 +1,32 @@
+version: 2 # use CircleCI 2.0
+jobs: # a collection of steps
+  build: # runs not using Workflows must have a `build` job as entry point
+    docker: # run the steps with Docker
+      - image: getterminus/ruby-ci-image:2.6-je-20190205 # ...with this image as the primary container; this is where all `steps` will run
+        environment: # environment variables for primary container
+          BUNDLE_JOBS: 3
+          BUNDLE_RETRY: 3
+          BUNDLE_PATH: vendor/bundle
+    steps: # a collection of executable commands
+      - checkout # special step to check out source code to working directory
+
+      # Restore bundle cache
+      - restore_cache:
+          keys:
+            - bundle-v2-{{ checksum "Gemfile.lock" }}
+            - bundle-v2-
+
+      - run:
+          name: Bundle Install
+          command: bundle check || bundle install
+
+      # Store bundle cache
+      - save_cache:
+          key: bundle-v2-{{ checksum "Gemfile.lock" }}
+          paths:
+            - vendor/bundle
+
+      - run:
+          name: Run rspec 
+          command: |
+            bundle exec rspec --profile 10 --format progress

data/vendor/cache/Protobuf3Fixer-5f9f1a2d2da9/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/vendor/cache/Protobuf3Fixer-5f9f1a2d2da9/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/vendor/cache/Protobuf3Fixer-5f9f1a2d2da9/.rubocop.yml

@@ -0,0 +1,42 @@
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: comma
+
+Layout/EndAlignment:
+  Enabled: true
+
+Lint/UnusedMethodArgument:
+  AllowUnusedKeywordArguments: true
+
+Metrics/LineLength:
+  Enabled: true
+  IgnoredPatterns: ['\A#']
+  Max: 120
+
+Layout/AlignParameters:
+  Enabled: true
+
+Naming/UncommunicativeMethodParamName:
+  Enabled: true
+  AllowedNames: ['io', 'id', 'to', 'by', 'on', 'in', 'at', '_'] # Defaults + _
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: true
+
+Style/ParallelAssignment:
+  Enabled: true
+
+Metrics/MethodLength:
+  Enabled: true
+  Max: 30