legion-transport 1.2.7 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4289f15bf500b987315e7316a94dfbb57f44f9b4d1fd08f5595181172729858
-  data.tar.gz: 398d87bb9ea0a8e6802e9500ec82ed6fba72cdda980260756c0262cba1807c9e
+  metadata.gz: 55c23d109605074f58032f420c732b94ab43df16c73d5b2d0fe7aeedc2b66918
+  data.tar.gz: 7f80b6e30c52a32bd367a1a98ddd867e462affaf6f72885c2bb17ad2f215b2b8
 SHA512:
-  metadata.gz: ceb892d4f4628ee94357b23762ebf5eccfa7deefe0684aa83c5cc6b9122ec1f7b71623e20a84bf9966b24a0693ce93d87f652e37c7a1deac23ec630737474dfd
-  data.tar.gz: 46f5eec9db954d8e57615a3a0185f9475a4e43052e6be055420892378a9da21e48ddcfaf948e928fd875f57011eaf5cd1114c36e2d1144b1cee44d02695842ce
+  metadata.gz: 579732a7b2688876efbecbdfeb26ece70d24d2a596104b87920cb8663f1ff61f0cb1baabe02158756a2408eaac4603360ef8902b443c1be20acbab674f4f0ceb
+  data.tar.gz: 05d79297bc68c5820c252ce6513c488807d2c4e323c77ad4d680dffdd5334cd7c466d9676f3048fe45cb092741fbe0d7ab45b104140989bb114e29bec9dd4d81

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Legion::Transport ChangeLog
 
+## [1.3.0] - 2026-03-21
+
+### Added
+- RabbitMQ cluster support: `cluster_nodes`, `connection_pool_size`, `region`, `management_port`, `quorum_queue_policy` settings
+- Cluster node rotation: `cluster_nodes` merged into `resolved_hosts` with shuffle for load distribution
+- Connection pool (`Helpers::Pool`): mutex-protected pool of Bunny sessions with configurable size and timeout
+- Channel pool (`Helpers::ChannelPool`): per-connection ring buffer of channels with borrow/return
+- Region header injection: `x-legion-region` and `x-legion-region-affinity` headers on published messages when region is configured
+- Quorum queue policy helper (`Helpers::Policy`): idempotent HTTP PUT to RabbitMQ Management API, opt-in via `quorum_queue_policy.enabled`
+- Connection failover: retry loop across all cluster nodes on TCPConnectionFailed/AuthFailure/ECONNREFUSED
+- `Legion::Transport::PoolTimeout` and `Legion::Transport::ClusterUnavailable` error classes
+
+### Changed
+- `connection_timeout` default 1 -> 10, `network_recovery_interval` default 1 -> 2
+- `build_bunny_opts` now merges `cluster_nodes` into resolved hosts before building Bunny options
+
+## [1.2.9] - 2026-03-21
+
+### Changed
+- `Connection::SSL` module refactored to use `Legion::Crypt::TLS.resolve` for TLS configuration
+- Removed legacy `use_tls?`, `tls_cert`, `tls_key`, `ca_certs`, `verify_peer?` methods
+- TLS options now merged into Bunny connection opts via `tls_options` method
+- SSL module auto-required and included in `Connection` class
+
+## [1.2.8] - 2026-03-21
+
+### Added
+- `TenantTopology` module: exchange/queue name prefixing with tenant context (`t.<tenant_id>.<name>`); disabled by default; shared exchanges (`legion.control`, `legion.health`, `legion.audit`) are never prefixed; delegates to `Legion::TenantContext.current_tenant_id` when no explicit tenant_id given
+- `TenantProvisioner` module: provisions and deprovisions RabbitMQ topology (topic exchanges for tasks/results/events + fanout DLX) for a given tenant; accepts optional channel kwarg for reuse
+- `TenantQuota` module: application-level sliding-window rate limiting per tenant; enforces `messages_per_second` and `bytes_per_second` limits from settings; raises `TenantQuota::QuotaExceededError` on violation
+- `Settings.tenant_topology` defaults block: `enabled: false`, `prefix_format`, `shared_exchanges`, `auto_provision: true`, `quotas: {}`
+- 61 new specs covering all three modules (227 total, 0 failures)
+
 ## [1.2.7] - 2026-03-20
 
 ### Added

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

@@ -4,32 +4,40 @@ module Legion
   module Transport
     module Connection
       module SSL
-        def settings
-          Legion::Settings[:transport][:tls] || {}
-        end
+        def tls_options(tls_config: nil, port: nil)
+          return {} unless defined?(Legion::Crypt::TLS)
 
-        def use_vault_pki?
-          settings[:use_vault_pki] && Legion::Settings[:crypt][:vault][:connected]
-        end
+          tls_config ||= tls_settings
+          port       ||= transport_port
 
-        def use_tls?
-          settings[:use_tls] || Legion::Settings[:transport][:connection][:port].to_i == 5671
-        end
+          tls = Legion::Crypt::TLS.resolve(tls_config, port: port)
+          return {} unless tls[:enabled]
 
-        def tls_cert
-          settings[:tls_cert]
+          {
+            tls:                 true,
+            tls_cert:            tls[:cert],
+            tls_key:             tls[:key],
+            tls_ca_certificates: [tls[:ca]].compact,
+            verify_peer:         tls[:verify] != :none
+          }
         end
 
-        def tls_key
-          settings[:tls_key]
-        end
+        private
+
+        def tls_settings
+          return {} unless defined?(Legion::Settings)
 
-        def ca_certs
-          settings[:ca_certs]
+          Legion::Settings[:transport][:tls] || {}
+        rescue StandardError
+          {}
         end
 
-        def verify_peer?
-          settings[:verify_peer] || false
+        def transport_port
+          return nil unless defined?(Legion::Settings)
+
+          Legion::Settings[:transport][:connection][:port]
+        rescue StandardError
+          nil
         end
       end
     end

data/lib/legion/transport/connection.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require 'concurrent-ruby'
+require_relative 'connection/ssl'
 
 module Legion
   module Transport
     module Connection
       class << self
+        include Legion::Transport::Connection::SSL
+
         def settings
           Legion::Settings[:transport]
         end
@@ -33,7 +36,7 @@ module Legion
             nil
           else
             @session ||= Concurrent::AtomicReference.new(
-              connector.new(build_bunny_opts(connection_name: connection_name))
+              create_session_with_failover(connection_name: connection_name)
             )
             @channel_thread = Concurrent::ThreadLocalVar.new(nil)
             session.start
@@ -42,20 +45,8 @@ module Legion
             Legion::Settings[:transport][:connected] = true
           end
 
-          session.on_blocked { Legion::Transport.logger.warn('Legion::Transport is being blocked by RabbitMQ!') } if session.respond_to? :on_blocked
-
-          if session.respond_to? :on_unblocked
-            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 do
-              Legion::Transport.logger.info('Legion::Transport has completed recovery')
-            end
-          end
-
+          register_session_callbacks
+          apply_quorum_policy_if_enabled
           true
         end
 
@@ -95,22 +86,76 @@ module Legion
 
         private
 
+        def create_session_with_failover(connection_name:)
+          opts = build_bunny_opts(connection_name: connection_name)
+          hosts = opts[:hosts] || [{ host: opts[:host] || '127.0.0.1', port: opts[:port] || 5672 }]
+          last_error = nil
+
+          hosts.each do |host_entry|
+            attempt_opts = opts.dup
+            if host_entry.is_a?(Hash)
+              attempt_opts[:host] = host_entry[:host]
+              attempt_opts[:port] = host_entry[:port]
+            end
+            attempt_opts.delete(:hosts)
+
+            return connector.new(attempt_opts)
+          rescue Bunny::TCPConnectionFailed, Bunny::PossibleAuthenticationFailureError, Errno::ECONNREFUSED => e
+            last_error = e
+            host_desc = host_entry.is_a?(Hash) ? "#{host_entry[:host]}:#{host_entry[:port]}" : host_entry
+            Legion::Transport.logger.warn("Connection failed to #{host_desc}: #{e.message}")
+          end
+
+          raise Legion::Transport::ClusterUnavailable, "All cluster nodes exhausted: #{last_error&.message}" if defined?(Legion::Transport::ClusterUnavailable)
+
+          raise last_error || StandardError.new('No cluster nodes available')
+        end
+
+        def register_session_callbacks
+          session.on_blocked { Legion::Transport.logger.warn('Legion::Transport is being blocked by RabbitMQ!') } if session.respond_to?(:on_blocked)
+
+          if session.respond_to?(:on_unblocked)
+            session.on_unblocked do
+              Legion::Transport.logger.info('Legion::Transport is no longer being blocked by RabbitMQ')
+            end
+          end
+
+          return unless session.respond_to?(:after_recovery_completed)
+
+          session.after_recovery_completed do
+            Legion::Transport.logger.info('Legion::Transport has completed recovery')
+          end
+        end
+
+        def apply_quorum_policy_if_enabled
+          return unless defined?(Legion::Transport::Helpers::Policy)
+
+          Legion::Transport::Helpers::Policy.apply_quorum_policy!
+        rescue StandardError
+          nil
+        end
+
         def build_bunny_opts(connection_name:)
           conn_settings = Legion::Settings[:transport][:connection].dup
           resolved = conn_settings.delete(:resolved_hosts) || []
 
+          cluster_nodes = Array(Legion::Settings[:transport][:cluster_nodes])
+          all_hosts = (resolved + cluster_nodes).uniq
+          all_hosts.shuffle! if all_hosts.length > 1
+
           opts = conn_settings.merge(
             connection_name: connection_name,
             logger:          Legion::Transport.logger,
             log_level:       :warn
           )
 
-          if resolved.length > 1
-            opts[:hosts] = resolved.map { |h| { host: h.split(':').first, port: h.split(':').last.to_i } }
+          if all_hosts.length > 1
+            opts[:hosts] = all_hosts.map { |h| { host: h.split(':').first, port: h.split(':').last.to_i } }
             opts.delete(:host)
             opts.delete(:port)
           end
 
+          opts.merge!(tls_options)
           opts
         end
       end

data/lib/legion/transport/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Legion
+  module Transport
+    class PoolTimeout < StandardError; end
+    class ClusterUnavailable < StandardError; end
+  end
+end

data/lib/legion/transport/helpers/channel_pool.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Legion
+  module Transport
+    module Helpers
+      class ChannelPool
+        def initialize(connection:, size: 10, prefetch: 2)
+          @connection = connection
+          @size       = size
+          @prefetch   = prefetch
+          @available  = []
+          @in_use     = []
+          @mutex      = Mutex.new
+        end
+
+        def borrow
+          @mutex.synchronize do
+            purge_closed_unsafe
+
+            if (ch = @available.pop)
+              @in_use << ch
+              return ch
+            end
+
+            total = @available.size + @in_use.size
+            return nil if total >= @size
+
+            ch = @connection.create_channel
+            ch.prefetch(@prefetch) if ch.respond_to?(:prefetch)
+            @in_use << ch
+            ch
+          end
+        end
+
+        def return(channel)
+          @mutex.synchronize do
+            @in_use.delete(channel)
+            return unless channel.respond_to?(:open?) && channel.open?
+            return if (@available.size + @in_use.size) >= @size
+
+            @available << channel
+          end
+        end
+
+        def purge_closed
+          @mutex.synchronize { purge_closed_unsafe }
+        end
+
+        def close_all
+          @mutex.synchronize do
+            (@available + @in_use).each do |ch|
+              ch.close rescue nil # rubocop:disable Style/RescueModifier
+            end
+            @available.clear
+            @in_use.clear
+          end
+        end
+
+        def size
+          @mutex.synchronize { @available.size + @in_use.size }
+        end
+
+        private
+
+        def purge_closed_unsafe
+          @available.reject! { |c| !c.respond_to?(:open?) || !c.open? }
+          @in_use.reject!    { |c| !c.respond_to?(:open?) || !c.open? }
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/helpers/policy.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Legion
+  module Transport
+    module Helpers
+      module Policy
+        module_function
+
+        def apply_quorum_policy!(settings: nil)
+          settings ||= Legion::Settings[:transport]
+          policy = settings[:quorum_queue_policy]
+          return false unless policy && policy[:enabled]
+
+          conn = settings[:connection]
+          host = conn[:host] || '127.0.0.1'
+          port = settings[:management_port] || 15_672
+          user = conn[:user] || 'guest'
+          pass = conn[:password] || 'guest'
+          vhost = conn[:vhost] || '/'
+
+          encoded_vhost = URI.encode_www_form_component(vhost)
+          uri = URI("http://#{host}:#{port}/api/policies/#{encoded_vhost}/legion-quorum")
+
+          body = {
+            pattern:    policy[:pattern] || '^legion\\.',
+            definition: {
+              'x-queue-type':     'quorum',
+              'x-delivery-limit': policy[:delivery_limit] || 5
+            },
+            'apply-to': 'queues',
+            priority:   0
+          }
+
+          req = Net::HTTP::Put.new(uri)
+          req.basic_auth(user, pass)
+          req.content_type = 'application/json'
+          req.body = ::JSON.dump(body)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.open_timeout = 5
+          http.read_timeout = 5
+          response = http.request(req)
+
+          response.code.start_with?('2')
+        rescue StandardError => e
+          Legion::Transport.logger.warn("Quorum policy apply failed: #{e.message}") if defined?(Legion::Transport)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/helpers/pool.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Legion
+  module Transport
+    module Helpers
+      class Pool
+        def initialize(size: 1, timeout: 5, &block)
+          @size        = size
+          @timeout     = timeout
+          @factory     = block
+          @available   = []
+          @in_use      = []
+          @mutex       = Mutex.new
+          @condition   = ConditionVariable.new
+        end
+
+        def checkout
+          deadline = Time.now + @timeout
+
+          @mutex.synchronize do
+            loop do
+              @available.reject! { |c| c.respond_to?(:closed?) && c.closed? }
+
+              if (conn = @available.pop)
+                @in_use << conn
+                return conn
+              end
+
+              total = @available.size + @in_use.size
+              if total < @size
+                conn = @factory.call
+                @in_use << conn
+                return conn
+              end
+
+              remaining = deadline - Time.now
+              raise Legion::Transport::PoolTimeout, 'timed out waiting for available connection' if remaining <= 0
+
+              @condition.wait(@mutex, remaining)
+            end
+          end
+        end
+
+        def checkin(connection)
+          @mutex.synchronize do
+            @in_use.delete(connection)
+            @available << connection if connection.respond_to?(:open?) && connection.open?
+            @condition.signal
+          end
+        end
+
+        def size
+          @mutex.synchronize { @available.size + @in_use.size }
+        end
+
+        def shutdown
+          @mutex.synchronize do
+            (@available + @in_use).each do |conn|
+              conn.close rescue nil # rubocop:disable Style/RescueModifier
+            end
+            @available.clear
+            @in_use.clear
+          end
+        end
+
+        def connected?
+          @mutex.synchronize do
+            (@available + @in_use).any? { |c| c.respond_to?(:open?) && c.open? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/message.rb

@@ -124,6 +124,7 @@ module Legion
       def headers
         @options[:headers] ||= Concurrent::Hash.new
         @options[:headers]['legion_protocol_version'] ||= '2.0'
+        inject_region_header
         %i[task_id relationship_id trigger_namespace_id trigger_function_id parent_id master_id runner_namespace runner_class namespace_id function_id function
            chain_id debug].each do |header|
           next unless @options.key? header
@@ -172,6 +173,15 @@ module Legion
 
       private
 
+      def inject_region_header
+        region = Legion::Settings[:transport][:region] rescue nil # rubocop:disable Style/RescueModifier
+        return if region.nil?
+
+        @options[:headers]['x-legion-region'] = region
+        affinity = @options[:region_affinity] || 'prefer_local'
+        @options[:headers]['x-legion-region-affinity'] = affinity
+      end
+
       def spool_message(error)
         return unless defined?(Legion::Transport::Spool)
 

data/lib/legion/transport/settings.rb

@@ -16,11 +16,11 @@ module Legion
 
         {
           read_timeout:              1,
-          heartbeat:                 30,
+          heartbeat:                 (ENV['transport.connection.heartbeat'] || 30).to_i,
           automatically_recover:     true,
           continuation_timeout:      4000,
-          network_recovery_interval: 1,
-          connection_timeout:        1,
+          network_recovery_interval: (ENV['transport.connection.recovery_interval'] || 2).to_i,
+          connection_timeout:        (ENV['transport.connection.connection_timeout'] || 10).to_i,
           frame_max:                 65_536,
           user:                      ENV['transport.connection.user'] || 'guest',
           password:                  ENV['transport.connection.password'] || 'guest',
@@ -99,17 +99,38 @@ module Legion
         }
       end
 
+      def self.tenant_topology
+        {
+          enabled:          false,
+          prefix_format:    't.%<tenant_id>s.',
+          shared_exchanges: %w[legion.control legion.health legion.audit],
+          auto_provision:   true,
+          quotas:           {}
+        }
+      end
+
       def self.default
+        cluster_csv = ENV.fetch('transport.cluster_nodes', '')
         {
-          type:         'rabbitmq',
-          connected:    false,
-          logger_level: ENV['transport.logger_level'] || 'info',
-          messages:     messages,
-          prefetch:     ENV['transport.prefetch'].to_i,
-          exchanges:    exchanges,
-          queues:       queues,
-          connection:   connection,
-          channel:      channel
+          type:                 'rabbitmq',
+          connected:            false,
+          logger_level:         ENV['transport.logger_level'] || 'info',
+          messages:             messages,
+          prefetch:             ENV['transport.prefetch'].to_i,
+          exchanges:            exchanges,
+          queues:               queues,
+          connection:           connection,
+          channel:              channel,
+          tenant_topology:      tenant_topology,
+          cluster_nodes:        cluster_csv.empty? ? [] : cluster_csv.split(',').map(&:strip),
+          connection_pool_size: (ENV['transport.connection_pool_size'] || 1).to_i,
+          region:               ENV.fetch('transport.region', nil),
+          management_port:      (ENV['transport.management_port'] || 15_672).to_i,
+          quorum_queue_policy:  {
+            enabled:        ENV['transport.quorum_queue_policy.enabled'] == 'true',
+            pattern:        ENV['transport.quorum_queue_policy.pattern'] || '^legion\\.',
+            delivery_limit: (ENV['transport.quorum_queue_policy.delivery_limit'] || 5).to_i
+          }
         }
       end
     end

data/lib/legion/transport/tenant_provisioner.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'tenant_topology'
+
+module Legion
+  module Transport
+    module TenantProvisioner
+      EXCHANGE_TYPES = %w[tasks results events].freeze
+
+      def self.provision(tenant_id, channel: nil)
+        ch = channel || Legion::Transport.connection.create_channel
+        EXCHANGE_TYPES.each do |type|
+          name = TenantTopology.exchange_name(type, tenant_id: tenant_id)
+          ch.topic(name, durable: true)
+        end
+        dlx = TenantTopology.exchange_name('dlx', tenant_id: tenant_id)
+        ch.fanout(dlx, durable: true)
+        ch.close unless channel
+      end
+
+      def self.deprovision(tenant_id, channel: nil)
+        ch = channel || Legion::Transport.connection.create_channel
+        (EXCHANGE_TYPES + ['dlx']).each do |type|
+          name = TenantTopology.exchange_name(type, tenant_id: tenant_id)
+          begin
+            ch.exchange_delete(name)
+          rescue StandardError
+            nil
+          end
+        end
+        ch.close unless channel
+      end
+    end
+  end
+end

data/lib/legion/transport/tenant_quota.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'tenant_topology'
+
+module Legion
+  module Transport
+    module TenantQuota
+      class QuotaExceededError < StandardError
+      end
+
+      WINDOW_SECONDS = 1
+
+      @counters = {}
+      @mutex = Mutex.new
+
+      class << self
+        def check_publish(tenant_id, message_size: 0)
+          return true unless enabled?
+
+          msg_limit  = rate_limit(tenant_id)
+          size_limit = byte_limit(tenant_id)
+          return true if msg_limit.nil? && size_limit.nil?
+
+          now = current_window
+          @mutex.synchronize do
+            @counters[tenant_id] ||= { window: now, count: 0, bytes: 0 }
+            entry = @counters[tenant_id]
+            if entry[:window] != now
+              entry[:window] = now
+              entry[:count] = 0
+              entry[:bytes] = 0
+            end
+
+            raise QuotaExceededError, "Tenant #{tenant_id} exceeded message rate quota (#{msg_limit} msg/s)" if msg_limit && entry[:count] >= msg_limit
+
+            if size_limit && (entry[:bytes] + message_size) > size_limit
+              raise QuotaExceededError, "Tenant #{tenant_id} exceeded byte rate quota (#{size_limit} bytes/s)"
+            end
+
+            entry[:count] += 1
+            entry[:bytes] += message_size
+          end
+          true
+        end
+
+        def enabled?
+          TenantTopology.enabled?
+        end
+
+        def reset!
+          @mutex.synchronize { @counters.clear }
+        end
+
+        private
+
+        def current_window
+          (::Time.now.to_f / WINDOW_SECONDS).floor
+        end
+
+        def rate_limit(tenant_id)
+          quota_settings(tenant_id)&.dig(:messages_per_second)
+        end
+
+        def byte_limit(tenant_id)
+          quota_settings(tenant_id)&.dig(:bytes_per_second)
+        end
+
+        def quota_settings(tenant_id)
+          return nil unless defined?(Legion::Settings)
+
+          Legion::Settings.dig(:transport, :tenant_topology, :quotas, tenant_id.to_sym)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/tenant_topology.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Transport
+    module TenantTopology
+      SHARED_EXCHANGES = %w[legion.control legion.health legion.audit].freeze
+
+      def self.exchange_name(base_name, tenant_id: nil)
+        return base_name unless enabled?
+
+        tid = tenant_id || current_tenant_id
+        return base_name if tid.nil? || tid == 'default' || shared?(base_name)
+
+        "t.#{tid}.#{base_name}"
+      end
+
+      def self.queue_name(base_name, tenant_id: nil)
+        return base_name unless enabled?
+
+        tid = tenant_id || current_tenant_id
+        return base_name if tid.nil? || tid == 'default'
+
+        "t.#{tid}.#{base_name}"
+      end
+
+      def self.shared?(name)
+        SHARED_EXCHANGES.any? { |prefix| name.start_with?(prefix) }
+      end
+
+      def self.enabled?
+        settings = transport_settings
+        settings.is_a?(Hash) && settings.dig(:tenant_topology, :enabled) == true
+      end
+
+      def self.current_tenant_id
+        return nil unless defined?(Legion::TenantContext)
+
+        Legion::TenantContext.current_tenant_id
+      rescue StandardError
+        nil
+      end
+
+      private_class_method def self.transport_settings
+        return {} unless defined?(Legion::Settings)
+
+        Legion::Settings[:transport] || {}
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

data/lib/legion/transport/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Transport
-    VERSION = '1.2.7'
+    VERSION = '1.3.0'
   end
 end

data/lib/legion/transport.rb

@@ -3,6 +3,7 @@
 require 'legion/transport/version'
 require 'legion/settings'
 require 'legion/transport/settings'
+require_relative 'transport/errors'
 
 module Legion
   module Transport
@@ -39,9 +40,15 @@ module Legion
     end
   end
 
+  require_relative 'transport/helpers/pool'
+  require_relative 'transport/helpers/channel_pool'
+  require_relative 'transport/helpers/policy'
   require_relative 'transport/common'
   require_relative 'transport/queue'
   require_relative 'transport/exchange'
   require_relative 'transport/message'
   require_relative 'transport/spool'
+  require_relative 'transport/tenant_topology'
+  require_relative 'transport/tenant_provisioner'
+  require_relative 'transport/tenant_quota'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-transport
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.3.0
 platform: ruby
 authors:
 - Esity
@@ -104,6 +104,7 @@ files:
 - lib/legion/transport/connection/ssl.rb
 - lib/legion/transport/connection/vault.rb
 - lib/legion/transport/consumer.rb
+- lib/legion/transport/errors.rb
 - lib/legion/transport/exchange.rb
 - lib/legion/transport/exchanges/agent.rb
 - lib/legion/transport/exchanges/crypt.rb
@@ -111,6 +112,9 @@ files:
 - lib/legion/transport/exchanges/lex.rb
 - lib/legion/transport/exchanges/node.rb
 - lib/legion/transport/exchanges/task.rb
+- lib/legion/transport/helpers/channel_pool.rb
+- lib/legion/transport/helpers/policy.rb
+- lib/legion/transport/helpers/pool.rb
 - lib/legion/transport/local.rb
 - lib/legion/transport/message.rb
 - lib/legion/transport/messages/check_subtask.rb
@@ -130,6 +134,9 @@ files:
 - lib/legion/transport/queues/task_update.rb
 - lib/legion/transport/settings.rb
 - lib/legion/transport/spool.rb
+- lib/legion/transport/tenant_provisioner.rb
+- lib/legion/transport/tenant_quota.rb
+- lib/legion/transport/tenant_topology.rb
 - lib/legion/transport/version.rb
 - sonar-project.properties
 homepage: https://github.com/LegionIO/legion-transport