legion-transport 1.2.8 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 675cb607fc415c57ee0a7ed48d60caea0fc951a6ce1ac8a092e3f10bc40b229e
-  data.tar.gz: 2e9f5410fca189ba407efebafc6b716289cf2890f914fefe456cb0cea5332fd8
+  metadata.gz: 131a06c178704a57af2c9baef440704001342842e02d15a090297c09572505b5
+  data.tar.gz: e30dd4bdaac3fdfb42cf588f9512f3a3b930ae840b79f34ea073a960276e7fbb
 SHA512:
-  metadata.gz: c6610f64e0958da4ec59124c697c5ec611caabb3d6c08e296518d683c7212135e483d217c66a53b06ed38e6a9b03db3546f0efa7e18c71ca27d8dd35ea1249eb
-  data.tar.gz: ecbcc22eca4559cf40169501810798b02dcb5e2302ff97da1266db9a390fa4d7247b79e74fcad49e972a496a19fb0b7ccfb6aac4403db01ccd414f1055f56cb8
+  metadata.gz: 89b5e05ec97fad24f0e191ac67bf4362afe758d1d4b1481629b6fa5575355e0ec56fa793d78d0f2cf3111213bf1087865d6c3791c234e41884adf3d13bf28568
+  data.tar.gz: 41bff2584db88fd03cc904bbe2996c628d4fdf689f6b793557f6207efb31fa808ad95e9e0aaa350026760d06c95e0411c62e75c9ca6087f21e6d1dd5a3f99acb

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Legion::Transport ChangeLog
 
+## [1.3.2] - 2026-03-21
+
+### Added
+- `Legion::Transport::Exchanges::Logging`: topic exchange (`legion.logging`) for structured log event publishing
+- `Legion::Transport::Queues::RegionOutbound`: durable outbound queues for cross-region message routing (per-peer, skips current region)
+- `Legion::Transport::Messages::RegionReRoute`: re-route message type for forwarding tasks to target regions
+
+## [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

data/CLAUDE.md

@@ -25,7 +25,8 @@ Legion::Transport
 │       ├── Agent       # Agent communication exchange (identity-bound: GAIA frames, preferences, proactive)
 │       ├── Crypt       # Encryption exchange
 │       ├── Extensions  # Extension exchange
-│       └── Lex         # LEX exchange (inherits Extensions)
+│       ├── Lex         # LEX exchange (inherits Extensions)
+│       └── Logging     # Log event exchange (legion.logging) for structured log event publishing
 ├── Queue               # Base queue class (extends Bunny::Queue)
 │   └── Queues/
 │       ├── Node        # Node queue

data/CODEOWNERS

@@ -0,0 +1 @@
+* @Esity

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/exchanges/logging.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Transport
+    module Exchanges
+      class Logging < Legion::Transport::Exchange
+        def exchange_name
+          'legion.logging'
+        end
+      end
+    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,8 @@ module Legion
       def headers
         @options[:headers] ||= Concurrent::Hash.new
         @options[:headers]['legion_protocol_version'] ||= '2.0'
+        inject_region_header
+        inject_legion_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 +174,26 @@ 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 inject_legion_region_header
+        return unless defined?(Legion::Region) &&
+                      Legion::Region.respond_to?(:current) &&
+                      Legion::Region.current
+
+        @options[:headers]['region'] = Legion::Region.current
+        @options[:headers]['region_affinity'] = @options[:region_affinity] ||
+                                                (defined?(Legion::Settings) && Legion::Settings.dig(:region, :default_affinity)) ||
+                                                'prefer_local'
+      end
+
       def spool_message(error)
         return unless defined?(Legion::Transport::Spool)
 

data/lib/legion/transport/messages/region_re_route.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Transport
+    module Messages
+      class RegionReRoute < Legion::Transport::Message
+        def exchange
+          Legion::Transport::Exchanges::Task
+        end
+
+        def routing_key
+          "region.reroute.#{target_region}"
+        end
+
+        def message
+          {
+            original_payload: @options[:original_payload] || @options.except(:target_region),
+            target_region:    target_region,
+            source_region:    source_region,
+            rerouted_at:      Time.now.to_i
+          }
+        end
+
+        def validate
+          raise ArgumentError, 'target_region is required' unless @options[:target_region].is_a?(String) && !@options[:target_region].empty?
+
+          @valid = true
+        end
+
+        private
+
+        def target_region
+          @options[:target_region]
+        end
+
+        def source_region
+          @options[:source_region] ||
+            (defined?(Legion::Settings) && Legion::Settings.dig(:region, :current)) ||
+            'unknown'
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/queue.rb

@@ -84,3 +84,4 @@ require_relative 'queues/node_status'
 require_relative 'queues/task_log'
 require_relative 'queues/task_update'
 require_relative 'queues/agent'
+require_relative 'queues/region_outbound'

data/lib/legion/transport/queues/region_outbound.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Legion
+  module Transport
+    module Queues
+      module RegionOutbound
+        module_function
+
+        def declare_all
+          peers = defined?(Legion::Settings) && Legion::Settings.dig(:region, :peers)
+          return [] unless peers.is_a?(Array) && !peers.empty?
+
+          current = defined?(Legion::Region) ? Legion::Region.current : nil
+          peers.reject { |p| p == current }.map do |peer|
+            declare_outbound(peer)
+          end
+        end
+
+        def declare_outbound(target_region)
+          queue_name = queue_name_for(target_region)
+          channel = Legion::Transport::Connection.channel
+          channel.queue(
+            queue_name,
+            durable:   true,
+            arguments: { 'x-dead-letter-exchange' => 'tasks.dlx' }
+          )
+        rescue StandardError => e
+          Legion::Transport.logger.warn "RegionOutbound: failed to declare queue for #{target_region}: #{e.message}"
+          nil
+        end
+
+        def queue_name_for(target_region)
+          "legion.tasks.outbound.#{target_region}"
+        end
+      end
+    end
+  end
+end

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',
@@ -110,17 +110,27 @@ module Legion
       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,
-          tenant_topology: tenant_topology
+          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/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Transport
-    VERSION = '1.2.8'
+    VERSION = '1.3.2'
   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,6 +40,9 @@ 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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-transport
 version: !ruby/object:Gem::Version
-  version: 1.2.8
+  version: 1.3.2
 platform: ruby
 authors:
 - Esity
@@ -94,6 +94,7 @@ files:
 - ".rubocop.yml"
 - CHANGELOG.md
 - CLAUDE.md
+- CODEOWNERS
 - Gemfile
 - LICENSE
 - README.md
@@ -104,18 +105,24 @@ 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
 - lib/legion/transport/exchanges/extensions.rb
 - lib/legion/transport/exchanges/lex.rb
+- lib/legion/transport/exchanges/logging.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
 - lib/legion/transport/messages/dynamic.rb
 - lib/legion/transport/messages/lex_register.rb
+- lib/legion/transport/messages/region_re_route.rb
 - lib/legion/transport/messages/request_cluster_secret.rb
 - lib/legion/transport/messages/subtask.rb
 - lib/legion/transport/messages/task.rb
@@ -126,6 +133,7 @@ files:
 - lib/legion/transport/queues/node.rb
 - lib/legion/transport/queues/node_crypt.rb
 - lib/legion/transport/queues/node_status.rb
+- lib/legion/transport/queues/region_outbound.rb
 - lib/legion/transport/queues/task_log.rb
 - lib/legion/transport/queues/task_update.rb
 - lib/legion/transport/settings.rb