legion-transport 1.1.4 → 1.2.0

data/NOTICE.txt

@@ -0,0 +1,9 @@
+Legion::Transport(legion-transport)
+Copyright 2021 Optum
+
+Project Description:
+====================
+Connects the LegionIO framework to the transport tier(RabbitMQ)
+
+Author(s):
+Esity

data/README.md

@@ -1,3 +1,91 @@
-# Legion::Transport
+Legion::Transport
+=====
 
-Used to connect Legion to RabbitMQ and is a core component of Legion.
+Legion::Transport is the gem responsible for connecting LegionIO to the FIFO queue system(RabbitMQ over AMQP 0.9.1)
+
+Supported Ruby versions and implementations
+------------------------------------------------
+
+Legion::Transport should work identically on:
+
+* JRuby 9.2+
+* Ruby 2.4+
+
+
+Installation and Usage
+------------------------
+
+You can verify your installation using this piece of code:
+
+```bash
+gem install legion-transport
+```
+
+```ruby
+require 'legion/transport'
+conn = Legion::Transport::Connection
+conn.setup
+conn.channel # => ::Bunny::Channel
+conn.session # => ::Bunny::Session
+```
+
+Settings
+----------
+
+```json
+{
+  "type": "rabbitmq",
+  "connected": false,
+  "logger_level": "info",
+  "messages": {
+    "encrypt": false,
+    "ttl": null,
+    "priority": 0,
+    "persistent": true
+  },
+  "prefetch": 2,
+  "exchanges": {
+    "type": "topic",
+    "arguments": {},
+    "auto_delete": false,
+    "durable": true,
+    "internal": false
+  },
+  "queues": {
+    "manual_ack": true,
+    "durable": true,
+    "exclusive": false,
+    "block": false,
+    "auto_delete": false,
+    "arguments": {
+      "x-max-priority": 255,
+      "x-overflow": "reject-publish"
+    }
+  },
+  "connection": {
+    "read_timeout": 1,
+    "heartbeat": 30,
+    "automatically_recover": true,
+    "continuation_timeout": 4000,
+    "network_recovery_interval": 1,
+    "connection_timeout": 1,
+    "frame_max": 65536,
+    "user": "guest",
+    "password": "guest",
+    "host": "127.0.0.1",
+    "port": "5672",
+    "vhost": "/",
+    "recovery_attempts": 100,
+    "logger_level": "info",
+    "connected": false
+  },
+  "channel": {
+    "default_worker_pool_size": 1,
+    "session_worker_pool_size": 8
+  }
+}
+```
+Authors
+----------
+
+* [Matthew Iverson](https://github.com/Esity) - current maintainer

data/SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+## Supported Versions
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.x.x   | :white_check_mark: |
+
+## Reporting a Vulnerability
+To be added

data/attribution.txt

@@ -0,0 +1 @@
+Add attributions here.

data/legion-transport.gemspec

@@ -1,43 +1,33 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'legion/transport/version'
+# frozen_string_literal: true
+
+require_relative 'lib/legion/transport/version'
 
 Gem::Specification.new do |spec|
-  spec.name = (RUBY_ENGINE == 'jruby' ? 'legion-transport-java' : 'legion-transport')
+  spec.name = 'legion-transport'
   spec.version       = Legion::Transport::VERSION
   spec.authors       = ['Esity']
-  spec.email         = ['matthewdiverson@gmail.com']
-
-  spec.summary       = 'Used by Legion to connect with RabbitMQ'
-  spec.description   = 'The Legion transport gem'
-  spec.homepage      = 'https://bitbucket.org/legion-io/legion-transport'
-  spec.required_ruby_version = '>= 2.5.0'
+  spec.email         = %w[matthewdiverson@gmail.com ruby@optum.com]
 
+  spec.summary       = 'Manages the connection to the transport tier(RabbitMQ)'
+  spec.description   = 'The Gem to connect LegionIO and it\'s extensions to the transport tier'
+  spec.homepage      = 'https://github.com/Optum/legion-transport'
+  spec.license       = 'Apache-2.0'
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.5'
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.test_files        = spec.files.select { |p| p =~ %r{^test/.*_test.rb} }
+  spec.extra_rdoc_files  = %w[README.md LICENSE CHANGELOG.md]
   spec.metadata = {
-    'bug_tracker_uri' => 'https://legionio.atlassian.net/projects/TRANSPORT/issues',
-    'changelog_uri' => 'https://bitbucket.org/legion-io/legion-transport/src/master/CHANGELOG.md',
-    'homepage_uri' => 'https://bitbucket.org/legion-io/legion-transport',
-    'wiki_uri' => 'https://bitbucket.org/legion-io/legion-transport/wiki/Home'
+    'bug_tracker_uri' => 'https://github.com/Optum/legion-transport/issues',
+    'changelog_uri' => 'https://github.com/Optum/legion-transport/src/main/CHANGELOG.md',
+    'documentation_uri' => 'https://github.com/Optum/legion-transport',
+    'homepage_uri' => 'https://github.com/Optum/LegionIO',
+    'source_code_uri' => 'https://github.com/Optum/legion-transport',
+    'wiki_uri' => 'https://github.com/Optum/legion-transport/wiki'
   }
 
-  spec.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'codecov'
-  spec.add_development_dependency 'legion-logging'
-  spec.add_development_dependency 'legion-settings'
-  spec.add_development_dependency 'march_hare' if RUBY_ENGINE == 'jruby'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'rspec_junit_formatter'
-  spec.add_development_dependency 'rubocop'
-  spec.add_development_dependency 'simplecov'
-
-  spec.add_dependency 'bunny'
-  spec.add_dependency 'concurrent-ruby'
+  spec.add_dependency 'bunny', '>= 2.17.0'
+  spec.add_dependency 'concurrent-ruby', '>= 1.1.7'
   spec.add_dependency 'legion-json'
+  spec.add_dependency 'legion-settings'
 end

data/lib/legion/transport.rb

@@ -1,5 +1,6 @@
-require_relative 'transport/version'
-require_relative 'transport/settings'
+require 'legion/transport/version'
+require 'legion/settings'
+require 'legion/transport/settings'
 
 module Legion
   module Transport
@@ -12,6 +13,28 @@ module Legion
       TYPE = 'bunny'.freeze
       CONNECTOR = ::Bunny
     end
+
+    class << self
+      def logger
+        @logger unless @logger.nil?
+
+        if ::Legion.const_defined?('Logging')
+          @logger = ::Legion::Logging
+        else
+          require 'logger'
+          @logger = ::Logger.new($stdout)
+          @logger.level = Logger::ERROR
+        end
+
+        @logger
+      end
+
+      def settings
+        Legion::Settings[:transport] if Legion.const_defined? 'Settings'
+
+        Legion::Transport::Settings.default
+      end
+    end
   end
 
   require_relative 'transport/common'

data/lib/legion/transport/common.rb

@@ -52,14 +52,14 @@ module Legion
       end
 
       def close!
-        Legion::Logging.error 'close! called'
+        Legion::Transport.logger.error 'close! called'
         false unless Legion::Transport::Connection.channel_open?
         Legion::Transport::Connection.channel.close
       end
 
       def close
-        Legion::Logging.error 'close called'
-        Legion::Logging.warn 'close called, but method is called close!'
+        Legion::Transport.logger.error 'close called'
+        Legion::Transport.logger.warn 'close called, but method is called close!'
         close!
       end
 

data/lib/legion/transport/connection.rb

@@ -4,51 +4,73 @@ module Legion
   module Transport
     module Connection
       class << self
+        def settings
+          Legion::Settings[:transport]
+        end
+
+        def new
+          clone
+        end
+
         def connector
           Legion::Transport::CONNECTOR
         end
 
-        def setup # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
-          Legion::Logging.info("Using transport connector: #{Legion::Transport::CONNECTOR}")
+        def reconnect(connection_name: 'Legion', **)
+          @session = nil
+          @channel_thread = Concurrent::ThreadLocalVar.new(nil)
+          setup(connection_name: connection_name)
+        end
+
+        def setup(connection_name: 'Legion', **) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          Legion::Transport.logger.info("Using transport connector: #{Legion::Transport::CONNECTOR}")
 
           if @session.respond_to?(:value) && session.respond_to?(:closed?) && session.closed?
             @channel_thread = Concurrent::ThreadLocalVar.new(nil)
           elsif @session.respond_to?(:value) && session.respond_to?(:closed?) && session.open?
             nil
           elsif Legion::Transport::TYPE == 'march_hare'
-            @session ||= Concurrent::Atom.new(
-              MarchHare.connect(host: Legion::Settings[:transport][:connection][:host],
-                                vhost: Legion::Settings[:transport][:connection][:vhost],
-                                user: Legion::Settings[:transport][:connection][:user],
-                                password: Legion::Settings[:transport][:connection][:password],
-                                port: Legion::Settings[:transport][:connection][:port])
+            @session ||= Concurrent::AtomicReference.new(
+              MarchHare.connect(host: settings[:connection][:host],
+                                vhost: settings[:connection][:vhost],
+                                user: settings[:connection][:user],
+                                password: settings[:connection][:password],
+                                port: settings[:connection][:port])
             )
             @channel_thread = Concurrent::ThreadLocalVar.new(nil)
             session.start
-            session.create_channel.basic_qos(1)
+            session.create_channel.basic_qos(settings[:prefetch])
+            Legion::Settings[:transport][:connected] = true
           else
-            @session ||= Concurrent::Atom.new(
+            @session ||= Concurrent::AtomicReference.new(
               connector.new(
                 Legion::Settings[:transport][:connection],
-                logger: Legion::Logging::Logger.new(level: 'warn'),
+                connection_name: connection_name,
+                logger: Legion::Transport.logger,
                 log_level: :info
               )
             )
             @channel_thread = Concurrent::ThreadLocalVar.new(nil)
             session.start
-            session.create_channel.basic_qos(20, true)
+            session.create_channel(nil, settings[:channel][:session_worker_pool_size])
+                   .basic_qos(settings[:prefetch], true)
+            Legion::Settings[:transport][:connected] = true
           end
 
           if session.respond_to? :on_blocked
-            session.on_blocked { Legion::Logging.warn('Legion::Transport is being blocked by RabbitMQ!') }
+            session.on_blocked { Legion::Transport.logger.warn('Legion::Transport is being blocked by RabbitMQ!') }
           end
 
           if session.respond_to? :on_unblocked
-            session.on_unblocked { Legion::Logging.info('Legion::Transport is no longer being blocked by RabbitMQ') }
+            session.on_unblocked do
+              Legion::Transport.logger.info('Legion::Transport is no longer being blocked by RabbitMQ')
+            end
           end
 
           if session.respond_to? :after_recovery_completed
-            session.after_recovery_completed { Legion::Logging.info('Legion::Transport has completed recovery') }
+            session.after_recovery_completed do
+              Legion::Transport.logger.info('Legion::Transport has completed recovery')
+            end
           end
 
           true
@@ -57,11 +79,11 @@ module Legion
         def channel # rubocop:disable Metrics/AbcSize
           return @channel_thread.value if !@channel_thread.value.nil? && @channel_thread.value.open?
 
-          @channel_thread.value = session.create_channel
+          @channel_thread.value = session.create_channel(nil, settings[:channel][:default_worker_pool_size], false, 10)
           if Legion::Transport::TYPE == 'march_hare'
-            @channel_thread.value.basic_qos(Legion::Settings[:transport][:prefetch])
+            @channel_thread.value.basic_qos(settings[:prefetch])
           else
-            @channel_thread.value.prefetch(Legion::Settings[:transport][:prefetch])
+            @channel_thread.value.prefetch(settings[:prefetch])
           end
           @channel_thread.value
         end
@@ -77,14 +99,19 @@ module Legion
 
         def channel_open?
           channel.open?
+        rescue StandardError
+          false
         end
 
         def session_open?
           session.open?
+        rescue StandardError
+          false
         end
 
         def shutdown
           session.close
+          @session = nil
         end
       end
     end

data/lib/legion/transport/connection/ssl.rb

@@ -0,0 +1,35 @@
+module Legion
+  module Transport
+    module Connection
+      module SSL
+        def settings
+          Legion::Settings[:transport][:tls] || {}
+        end
+
+        def use_vault_pki?
+          settings[:use_vault_pki] && Legion::Settings[:crypt][:vault][:connected]
+        end
+
+        def use_tls?
+          settings[:use_tls] || Legion::Settings[:transport][:port] == 5671
+        end
+
+        def tls_cert
+          settings[:tls_cert]
+        end
+
+        def tls_key
+          settings[:tls_key]
+        end
+
+        def ca_certs
+          settings[:ca_certs]
+        end
+
+        def verify_peer?
+          settings[:verify_peer] || false
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/connection/vault.rb

@@ -0,0 +1,9 @@
+module Legion
+  module Transport
+    module Connection
+      module Vault
+        # vault write pki/issue/example-dot-com common_name=www.my-website.com
+      end
+    end
+  end
+end

data/lib/legion/transport/exchange.rb

@@ -22,24 +22,29 @@ module Legion
       end
 
       def delete_exchange(exchange)
-        Legion::Logging.warn "Exchange:#{exchange} exists with wrong parameters, deleting and creating"
+        Legion::Transport.logger.warn "Exchange:#{exchange} exists with wrong parameters, deleting and creating"
         channel.exchange_delete(exchange)
       end
 
       def default_options
-        hash = {}
+        hash = Concurrent::Hash.new
         hash[:durable] = true
         hash[:auto_delete] = false
         hash[:arguments] = {}
+        hash[:passive] = passive?
         hash
       end
 
+      def passive?
+        false
+      end
+
       def exchange_name
         self.class.ancestors.first.to_s.split('::')[2].downcase
       end
 
       def exchange_options
-        {}
+        Concurrent::Hash.new
       end
 
       def delete(options = {})
@@ -52,6 +57,13 @@ module Legion
       def default_type
         'topic'
       end
+
+      def channel
+        @channel ||= Legion::Transport::Connection.channel
+      rescue ChannelLevelException => e
+        @channel = Legion::Transport::Connection.channel
+        raise e unless @channel.open?
+      end
     end
   end
 end