legion-transport-java 1.1.3

data/lib/legion/transport/exchanges/crypt.rb

@@ -0,0 +1,11 @@
+module Legion
+  module Transport
+    module Exchanges
+      class Lex < Legion::Transport::Exchange
+        def exchange_name
+          'crypt'
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/exchanges/lex.rb

@@ -0,0 +1,11 @@
+module Legion
+  module Transport
+    module Exchanges
+      class Lex < Legion::Transport::Exchange
+        def exchange_name
+          'lex'
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/exchanges/node.rb

@@ -0,0 +1,11 @@
+module Legion
+  module Transport
+    module Exchanges
+      class Node < Legion::Transport::Exchange
+        def exchange_name
+          'node'
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/exchanges/task.rb

@@ -0,0 +1,11 @@
+module Legion
+  module Transport
+    module Exchanges
+      class Task < Legion::Transport::Exchange
+        def exchange_name
+          'task'
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/message.rb

@@ -0,0 +1,106 @@
+module Legion
+  module Transport
+    class Message
+      include Legion::Transport::Common
+
+      def initialize(**options)
+        @options = options
+        validate
+      end
+
+      def publish(options = @options) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        raise unless @valid
+
+        exchange_dest = exchange.respond_to?(:new) ? exchange.new : exchange
+        exchange_dest.publish(encode_message,
+                              routing_key: routing_key || '',
+                              content_type: options[:content_type] || content_type,
+                              content_encoding: options[:content_encoding] || content_encoding,
+                              type: options[:type] || type,
+                              priority: options[:priority] || priority,
+                              expiration: options[:expiration] || expiration,
+                              headers: headers)
+      end
+
+      def message
+        @options
+      end
+
+      def encode_message
+        message_payload = message
+        message_payload = Legion::JSON.dump(message_payload) unless message_payload.is_a? String
+
+        if encrypt?
+          encrypted = Legion::Crypt.encrypt(message_payload)
+          headers[:iv] = encrypted[:iv]
+          @options[:content_encoding] = 'encrypted/cs'
+          return encrypted[:enciphered_message]
+        else
+          @options[:content_encoding] = 'identity'
+        end
+
+        message_payload
+      end
+
+      def encrypt_message(message, _type = 'cs')
+        Legion::Crypt.encrypt(message)
+      end
+
+      def encrypt?
+        Legion::Settings[:transport][:messages][:encrypt] && Legion::Settings[:crypt][:cs_encrypt_ready]
+      end
+
+      def exchange_name
+        lex = self.class.ancestors.first.to_s.split('::')[2].downcase
+        "Legion::Extensions::#{lex.capitalize}::Transport::Exchanges::#{lex.capitalize}"
+      end
+
+      def exchange
+        Kernel.const_get(exchange_name)
+      end
+
+      def headers
+        @options[:headers] ||= {}
+        %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| # rubocop:disable Layout/LineLength
+          next unless @options.key? header
+
+          @options[:headers][header] = @options[header].to_s
+        end
+        @options[:headers]
+      rescue StandardError => e
+        Legion::Logging.error e.message
+        Legion::Logging.error e.backtrace
+      end
+
+      def priority
+        0
+      end
+
+      def expiration
+        nil
+      end
+
+      def content_type
+        'application/json'
+      end
+
+      def content_encoding
+        'identity'
+      end
+
+      def type
+        'task'
+      end
+
+      def timestamp
+        now.to_i
+      end
+
+      def validate
+        @valid = true
+      end
+    end
+  end
+end
+
+Dir["#{__dir__}/messages/*.rb"].sort.each { |file| require file }

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

@@ -0,0 +1,25 @@
+require 'legion/transport/exchanges/task'
+
+module Legion
+  module Transport
+    module Messages
+      class CheckSubtask < Legion::Transport::Message
+        def exchange
+          Legion::Transport::Exchanges::Task
+        end
+
+        def exchange_name
+          'Legion::Transport::Exchanges::Task'
+        end
+
+        def routing_key
+          'task.subtask.check'
+        end
+
+        def validate
+          @valid = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Legion::Transport::Messages # rubocop:disable Style/ClassAndModuleChildren
+  class Dynamic < Legion::Transport::Message
+    attr_accessor :options
+
+    def type
+      'task'
+    end
+
+    def message
+      { args: @options[:args] || @options }
+    end
+
+    def routing_key
+      "#{function.runner.extension.values[:name]}.#{function.runner.values[:name]}.#{function.values[:name]}"
+    end
+
+    def exchange
+      Legion::Transport::Exchange.new(function.runner.extension.values[:exchange])
+    end
+
+    def function
+      @function ||= Legion::Data::Model::Function[@options[:function_id]]
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'legion/transport/exchanges/lex'
+
+module Legion
+  module Transport
+    module Messages
+      class LexRegister < Legion::Transport::Message
+        def exchange
+          Legion::Transport::Exchanges::Lex
+        end
+
+        def routing_key
+          'lex.register.save'
+        end
+
+        def validate
+          unless @options[:runner_namespace].is_a? String
+            # raise "runner_namespace is a #{@options[:runner_namespace].class}"
+          end
+          unless @options[:extension_namespace].is_a? String
+            # raise "extension_namespace is a #{@options[:extension_namespace].class}"
+          end
+          unless @options[:function].is_a?(String) || @options[:function].is_a?(Symbol)
+            # raise "function is a #{@options[:function].class}"
+          end
+
+          @valid = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'legion/transport/exchanges/lex'
+
+module Legion
+  module Transport
+    module Messages
+      class NodeHealth < Legion::Transport::Message
+        def exchange
+          Legion::Transport::Exchanges::Node
+        end
+
+        def routing_key
+          'health'
+        end
+
+        def validate
+          @valid = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Legion::Transport::Messages # rubocop:disable Style/ClassAndModuleChildren
+  class RequestClusterSecret < Legion::Transport::Message
+    def routing_key
+      'node.crypt.push_cluster_secret'
+    end
+
+    def message
+      { function: 'push_cluster_secret',
+        node_name: Legion::Settings[:client][:name],
+        queue_name: "node.#{Legion::Settings[:client][:name]}",
+        runner_class: 'Legion::Extensions::Node::Runners::Crypt',
+        # public_key: Base64.encode64(Legion::Crypt.public_key) }
+        public_key: Legion::Crypt.public_key }
+    end
+
+    def exchange
+      require 'legion/transport/exchanges/node'
+      Legion::Transport::Exchanges::Node
+    end
+
+    def encrypt?
+      false
+    end
+
+    def type
+      'task'
+    end
+
+    def validate
+      @valid = true
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'legion/transport/exchanges/task'
+
+module Legion
+  module Transport
+    module Messages
+      class SubTask < Legion::Transport::Message
+        def exchange
+          Legion::Transport::Exchanges::Task
+        end
+
+        def message
+          {
+            transformation: @options[:transformation] || '{}',
+            conditions: @options[:conditions] || '{}',
+            results: @options[:results] || '{}'
+          }
+        end
+
+        def routing_key # rubocop:disable Metrics/AbcSize
+          if @options[:conditions].is_a?(String) && @options[:conditions].length > 2
+            'task.subtask.conditioner'
+          elsif @options[:transformation].is_a?(String) && @options[:transformation].length > 2
+            'task.subtask.transform'
+          elsif @options[:function_id].is_a? Integer
+            function = Legion::Data::Model::Function[@options[:function_id]]
+            "#{function.runner.extension.values[:exchange]}.#{function.runner.values[:queue]}.#{function.values[:name]}"
+          end
+        end
+
+        def validate
+          raise TypeError unless @options[:function].is_a? String
+
+          @valid = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'legion/transport/exchanges/task'
+
+module Legion
+  module Transport
+    module Messages
+      class TaskLog < Legion::Transport::Message
+        def routing_key
+          "task.logs.create.#{@options[:task_id]}"
+        end
+
+        def exchange
+          Legion::Transport::Exchanges::Task
+        end
+
+        def message
+          @options[:function] = 'add_log'
+          @options[:runner_class] = 'Legion::Extensions::Tasker::Runners::Log'
+          @options
+        end
+
+        def generate_task?
+          false
+        end
+
+        def validate
+          @options[:task_id] = @options[:task_id].to_i if @options[:task_id].is_a? String
+          unless @options[:task_id].is_a? Integer
+            raise "task_id must be an integer but is #{@options[:task_id].class}(#{@options[:task_id]})"
+          end
+
+          @valid = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'legion/transport/exchanges/task'
+
+module Legion
+  module Exception
+    class InvalidTaskStatus; end
+    class InvalidTaskId; end
+  end
+end
+
+module Legion
+  module Transport
+    module Messages
+      class TaskUpdate < Legion::Transport::Message
+        def routing_key
+          'task.update'
+        end
+
+        def exchange
+          Legion::Transport::Exchanges::Task
+        end
+
+        def valid_status
+          conditioner = ['conditioner.queued', 'conditioner.failed', 'conditioner.exception']
+          transformer = ['transformer.queued', 'transformer.succeeded', 'transformer.exception']
+          task = ['task.scheduled', 'task.queued', 'task.completed', 'task.exception', 'task.delayed']
+          conditioner + transformer + task
+        end
+      end
+    end
+  end
+end

data/lib/legion/transport/queue.rb

@@ -0,0 +1,72 @@
+module Legion
+  module Transport
+    class Queue < Legion::Transport::CONNECTOR::Queue
+      include Legion::Transport::Common
+
+      def initialize(queue = queue_name, options = {})
+        retries ||= 0
+        @options = options
+        super(channel, queue, options_builder(default_options, queue_options, options))
+      rescue ::Bunny::PreconditionFailed
+        retries.zero? ? retries = 1 : raise
+        recreate_queue(channel, queue)
+        retry
+      end
+
+      def recreate_queue(channel, queue)
+        Legion::Logging.warn "Queue:#{queue} exists with wrong parameters, deleting and creating"
+        queue = ::Bunny::Queue.new(channel, queue, no_declare: true, passive: true)
+        queue.delete(if_empty: true)
+      end
+
+      def default_options
+        hash = {}
+        hash[:manual_ack] = true
+        hash[:durable] = true
+        hash[:exclusive] = false
+        hash[:block] = false
+        hash[:auto_delete] = false
+        hash[:arguments] = {
+          'x-max-priority': 255,
+          'x-overflow': 'reject-publish',
+          'x-dead-letter-exchange': "#{self.class.ancestors.first.to_s.split('::')[2].downcase}.dlx"
+        }
+        hash
+      end
+
+      def queue_options
+        {}
+      end
+
+      def queue_name
+        ancestor = self.class.ancestors.first.to_s.split('::')
+        name = if ancestor[5].scan(/[A-Z]/).length > 1
+                 ancestor[5].gsub!(/(.)([A-Z])/, '\1_\2').downcase!
+               else
+                 ancestor[5].downcase!
+               end
+        "#{ancestor[2].downcase}.#{name}"
+      end
+
+      def delete(options = { if_unused: true, if_empty: true })
+        super(options)
+        true
+      rescue ::Bunny::PreconditionFailed
+        false
+      end
+
+      def acknowledge(delivery_tag)
+        channel.acknowledge(delivery_tag)
+      end
+
+      def reject(delivery_tag, requeue: false)
+        channel.reject(delivery_tag, requeue)
+      end
+    end
+  end
+end
+
+require_relative 'queues/node'
+require_relative 'queues/node_status'
+require_relative 'queues/task_log'
+require_relative 'queues/task_update'