legion-transport 0.1.0 → 1.1.3

data/lib/legion/transport/consumer.rb

@@ -1,6 +1,13 @@
 module Legion
   module Transport
-    class Connection
+    class Consumer < Legion::Transport::CONNECTOR::Consumer
+      include Legion::Transport::Common
+      attr_reader :consumer_tag
+
+      def initialize(queue:, no_ack: false, exclusive: false, consumer_tag: generate_consumer_tag, **opts)
+        @consumer_tag = consumer_tag
+        super(channel, queue, consumer_tag, no_ack, exclusive, opts)
+      end
     end
   end
 end

data/lib/legion/transport/exchange.rb

@@ -1,12 +1,50 @@
 module Legion
   module Transport
-    if RUBY_ENGINE == 'jruby'
-      require 'legion/transport/exchanges/marchhare'
-      class Exchange < Legion::Transport::Exchanges::Marchhare
+    class Exchange < Legion::Transport::CONNECTOR::Exchange
+      include Legion::Transport::Common
+
+      def initialize(exchange = exchange_name, options = {})
+        @options = options
+        @type = options[:type] || default_type
+        super(channel, @type, exchange, options_builder(default_options, exchange_options, @options))
+      rescue ::Bunny::PreconditionFailed, ::Bunny::ChannelAlreadyClosed
+        raise unless @retries.nil?
+
+        @retries = 1
+        delete_exchange(exchange)
+        retry
       end
-    else
-      require 'legion/transport/exchanges/bunny'
-      class Exchange < Legion::Transport::Exchanges::Bunny
+
+      def delete_exchange(exchange)
+        Legion::Logging.warn "Exchange:#{exchange} exists with wrong parameters, deleting and creating"
+        channel.exchange_delete(exchange)
+      end
+
+      def default_options
+        hash = {}
+        hash[:durable] = true
+        hash[:auto_delete] = false
+        hash[:arguments] = {}
+        hash
+      end
+
+      def exchange_name
+        self.class.ancestors.first.to_s.split('::')[2].downcase
+      end
+
+      def exchange_options
+        {}
+      end
+
+      def delete(options = {})
+        super(options)
+        true
+      rescue ::Bunny::PreconditionFailed
+        false
+      end
+
+      def default_type
+        'topic'
       end
     end
   end

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/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/message.rb

@@ -1,8 +1,106 @@
 module Legion
   module Transport
     class Message
-      require 'legion/transport/messages/base'
-      include Legion::Transport::Messages::Base
+      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

@@ -4,32 +4,24 @@ module Legion
   module Transport
     module Messages
       class LexRegister < Legion::Transport::Message
-        def initialize(namespace, method, options = {})
-          @namespace = namespace
-          @method = method
-          @options = options
-        end
-
         def exchange
           Legion::Transport::Exchanges::Lex
         end
 
         def routing_key
-          'lex.methods.register'
+          'lex.register.save'
         end
 
-        def message(namespace = @namespace, method = @method, options = @options)
-          obj = { args: { namespace: namespace, method: method } }
-          obj[:args][:namespace_queue] = options[:namespace][:queue] unless options[:namespace][:queue].nil?
-          obj[:args][:namespace_uri] = options[:namespace][:uri] unless options[:namespace][:uri].nil?
-          Legion::JSON.dump(obj)
-        end
-
-        def validate(namespace = @namespace, _method = @method, _options = @options)
-          raise unless namespace.is_a? String
-
-          # raise unless method.is_a? String
-          # raise unless options.is_a? Hash
+        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

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

@@ -11,15 +11,6 @@ module Legion
   module Transport
     module Messages
       class TaskUpdate < Legion::Transport::Message
-        attr_accessor :status
-        attr_reader :task_id, :valid
-        def initialize(task_id, status = 'unknown', _options = {})
-          @status = status
-          @task_id = task_id
-          @routing_key = 'task.update'
-          validate
-        end
-
         def routing_key
           'task.update'
         end
@@ -28,23 +19,11 @@ module Legion
           Legion::Transport::Exchanges::Task
         end
 
-        def message(status = @status, task_id = @task_id, options = {})
-          Legion::JSON.dump(args: { status: status, task_id: task_id, options: options })
-        end
-
-        def validate(status = @status, task_id = @task_id)
-          raise Legion::Exception::InvalidTaskId unless task_id.is_a? Integer
-          raise Legion::Exception::InvalidTaskStatus unless valid_status.include? status
-
-          @valid = true
-        end
-
         def valid_status
           conditioner = ['conditioner.queued', 'conditioner.failed', 'conditioner.exception']
-          transfomer = ['transformer.queued', 'transformer.succeeded', 'transformer.exception']
-          task = ['task.scheduled', 'task.queued', 'task.completed', 'task.exception']
-          status = conditioner + transfomer + task
-          status
+          transformer = ['transformer.queued', 'transformer.succeeded', 'transformer.exception']
+          task = ['task.scheduled', 'task.queued', 'task.completed', 'task.exception', 'task.delayed']
+          conditioner + transformer + task
         end
       end
     end