legionio 0.3.5 → 0.4.0

data/lib/legion/extensions/actors/loop.rb

@@ -0,0 +1,32 @@
+require_relative 'base'
+
+module Legion
+  module Extensions
+    module Actors
+      class Loop
+        include Concurrent::Async
+        include Legion::Extensions::Actors::Base
+
+        def initialize
+          @loop = true
+          async.run
+        rescue StandardError => e
+          Legion::Logging.error e
+          Legion::Logging.error e.backtrace
+        end
+
+        def run
+          action while @loop
+        end
+
+        def action(**_opts)
+          Legion::Logging.warn 'An extension is using the default action for a loop'
+        end
+
+        def cancel
+          @loop = false
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/actors/nothing.rb

@@ -0,0 +1,15 @@
+require_relative 'base'
+
+module Legion
+  module Extensions
+    module Actors
+      class Nothing
+        include Legion::Extensions::Actors::Base
+
+        def initialize; end
+
+        def cancel; end
+      end
+    end
+  end
+end

data/lib/legion/extensions/actors/once.rb

@@ -0,0 +1,40 @@
+require_relative 'base'
+
+module Legion
+  module Extensions
+    module Actors
+      class Once
+        include Legion::Extensions::Actors::Base
+
+        def initialize
+          return if disabled?
+
+          if respond_to? :functions
+            functions.each do
+              function
+              @task = Concurrent::ScheduledTask.execute(delay) do
+                use_runner ? runner : manual
+              end
+            end
+          else
+            @task = Concurrent::ScheduledTask.execute(delay) do
+              use_runner ? runner : manual
+            end
+          end
+        rescue StandardError => e
+          Legion::Logging.error e
+        end
+
+        def delay
+          1.0
+        end
+
+        def cancel
+          return if disabled?
+
+          @task.cancel unless @task.cancelled?
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/actors/poll.rb

@@ -0,0 +1,87 @@
+require_relative 'base'
+require 'time'
+
+module Legion
+  module Extensions
+    module Actors
+      class Poll
+        include Legion::Extensions::Actors::Base
+
+        def initialize # rubocop:disable Metrics/AbcSize
+          log.debug "Starting timer for #{self.class} with #{{ execution_interval: time, timeout_interval: timeout, run_now: run_now?, check_subtask: check_subtask? }}"
+          @timer = Concurrent::TimerTask.new(execution_interval: time, timeout_interval: timeout, run_now: run_now?) do
+            t1 = Time.now
+            log.debug "Running #{self.class}"
+            old_result = Legion::Cache.get(cache_name)
+            log.debug "Cached value for #{self.class}: #{old_result}"
+            results = Legion::JSON.load(Legion::JSON.dump(manual))
+            Legion::Cache.set(cache_name, results, time * 2)
+
+            unless old_result.nil?
+              results[:diff] = Hashdiff.diff(results, old_result, numeric_tolerance: 0.0, array_path: false) do |_path, obj1, obj2|
+                if int_percentage_normalize.positive? && obj1.is_a?(Integer) && obj2.is_a?(Integer)
+                  obj1.between?(obj2 * (1 - int_percentage_normalize), obj2 * (1 + int_percentage_normalize))
+                end
+              end
+              results[:changed] = results[:diff].count.positive?
+
+              Legion::Logging.info results[:diff] if results[:changed]
+              Legion::Transport::Messages::CheckSubtask.new(runner_class: runner_class.to_s,
+                                                            function:     runner_function,
+                                                            result:       results,
+                                                            type:         'poll_result',
+                                                            polling:      true).publish
+            end
+
+            sleep_time = 1 - (Time.now - t1)
+            sleep(sleep_time) if sleep_time.positive?
+            log.debug("#{self.class} result: #{results}")
+            results
+          rescue StandardError => e
+            Legion::Logging.fatal e.message
+            Legion::Logging.fatal e.backtrace
+          end
+          @timer.execute
+        rescue StandardError => e
+          Legion::Logging.error e.message
+          Legion::Logging.error e.backtrace
+        end
+
+        def cache_name
+          "#{lex_name}_#{runner_name}"
+        end
+
+        def int_percentage_normalize
+          0.00
+        end
+
+        def time
+          9
+        end
+
+        def run_now?
+          true
+        end
+
+        def check_subtask?
+          true
+        end
+
+        def timeout
+          5
+        end
+
+        def action(_payload = {})
+          Legion::Logging.warn 'An extension is using the default block from Legion::Extensions::Runners::Every'
+        end
+
+        def cancel
+          Legion::Logging.debug 'Cancelling Legion Poller'
+          @timer.shutdown
+        rescue StandardError => e
+          Legion::Logging.error e.message
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/actors/subscription.rb

@@ -0,0 +1,139 @@
+require_relative 'base'
+require 'date'
+
+module Legion
+  module Extensions
+    module Actors
+      class Subscription
+        include Concurrent::Async
+        include Legion::Extensions::Actors::Base
+        include Legion::Extensions::Helpers::Transport
+
+        def initialize(**_options)
+          super()
+          @queue = queue.new
+          @queue.channel.prefetch(prefetch) if defined? prefetch
+        rescue StandardError => e
+          log.fatal e.message
+          log.fatal e.backtrace
+        end
+
+        def create_queue
+          queues.const_set(actor_const, Class.new(Legion::Transport::Queue))
+          exchange_object = default_exchange.new
+          queue_object = Kernel.const_get(queue_string).new
+
+          queue_object.bind(exchange_object, routing_key: actor_name)
+          queue_object.bind(exchange_object, routing_key: "#{lex_name}.#{actor_name}.#")
+        end
+
+        def queue
+          create_queue unless queues.const_defined?(actor_const)
+          Kernel.const_get queue_string
+        end
+
+        def queue_string
+          @queue_string ||= "#{queues}::#{actor_const}"
+        end
+
+        def cancel
+          return true unless @queue.channel.active
+
+          log.debug "Closing subscription to #{@queue.name}"
+          @consumer.cancel
+          @queue.channel.close
+          true
+        end
+
+        def block
+          false
+        end
+
+        def consumers
+          1
+        end
+
+        def manual_ack
+          true
+        end
+
+        def delay_start
+          0
+        end
+
+        def include_metadata_in_message?
+          true
+        end
+
+        def process_message(message, metadata, delivery_info)
+          payload = if metadata.content_encoding && metadata.content_encoding == 'encrypted/cs'
+                      Legion::Crypt.decrypt(message, metadata.headers['iv'])
+                    elsif metadata.content_encoding && metadata.content_encoding == 'encrypted/pk'
+                      Legion::Crypt.decrypt_from_keypair(metadata.headers[:public_key], message)
+                    else
+                      message
+                    end
+
+          message = if metadata.content_type == 'application/json'
+                      Legion::JSON.load(payload)
+                    else
+                      { value: payload }
+                    end
+          if include_metadata_in_message?
+            message = message.merge(metadata.headers.transform_keys(&:to_sym)) unless metadata.headers.nil?
+            message[:routing_key] = if Legion::Transport::TYPE == 'march_hare'
+                                      metadata.routing_key
+                                    else
+                                      delivery_info[:routing_key]
+                                    end
+          end
+
+          message[:timestamp] = (message[:timestamp_in_ms] / 1000).round if message.key?(:timestamp_in_ms) && !message.key?(:timestamp)
+          message[:datetime] = Time.at(message[:timestamp].to_i).to_datetime.to_s if message.key?(:timestamp)
+          message
+        end
+
+        def find_function(message = {})
+          return runner_function if actor_class.instance_methods(false).include?(:runner_function)
+          return function if actor_class.instance_methods(false).include?(:function)
+          return action if actor_class.instance_methods(false).include?(:action)
+          return message[:function] if message.key? :function
+
+          function
+        end
+
+        def subscribe
+          sleep(delay_start)
+          consumer_tag = "#{Legion::Settings[:client][:name]}_#{lex_name}_#{runner_name}_#{Thread.current.object_id}"
+          on_cancellation = block { cancel }
+
+          @consumer = @queue.subscribe(manual_ack: manual_ack, block: false, consumer_tag: consumer_tag, on_cancellation: on_cancellation) do |*rmq_message|
+            payload = rmq_message.pop
+            metadata = rmq_message.last
+            delivery_info = rmq_message.first
+
+            message = process_message(payload, metadata, delivery_info)
+            if use_runner?
+              Legion::Runner.run(**message,
+                                 runner_class:  runner_class,
+                                 function:      find_function(message),
+                                 check_subtask: check_subtask?,
+                                 generate_task: generate_task?)
+            else
+              runner_class.send(find_function(message), **message)
+            end
+            @queue.acknowledge(delivery_info.delivery_tag) if manual_ack
+
+            cancel if Legion::Settings[:client][:shutting_down]
+          rescue StandardError => e
+            Legion::Logging.error e.message
+            Legion::Logging.error e.backtrace
+            Legion::Logging.error message
+            Legion::Logging.error function
+            @queue.reject(delivery_info.delivery_tag) if manual_ack
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/builders/actors.rb

@@ -0,0 +1,61 @@
+require_relative 'base'
+
+module Legion
+  module Extensions
+    module Builder
+      module Actors
+        include Legion::Extensions::Builder::Base
+
+        attr_reader :actors
+
+        def build_actors
+          @actors = {}
+          require_files(actor_files)
+          build_actor_list
+          build_meta_actor_list
+        end
+
+        def build_actor_list
+          actor_files.each do |file|
+            actor_name = file.split('/').last.sub('.rb', '')
+            actor_class = "#{lex_class}::Actor::#{actor_name.split('_').collect(&:capitalize).join}"
+            @actors[actor_name.to_sym] = {
+              extension:      lex_class.to_s.downcase,
+              extension_name: extension_name,
+              actor_name:     actor_name,
+              actor_class:    Kernel.const_get(actor_class),
+              type:           'literal'
+            }
+          end
+        end
+
+        def build_meta_actor_list
+          @runners.each do |runner, attr|
+            next if @actors[runner.to_sym].is_a? Hash
+
+            actor_class = "#{attr[:extension_class]}::Actor::#{runner.to_s.split('_').collect(&:capitalize).join}"
+            build_meta_actor(runner, attr) unless Kernel.const_defined? actor_class
+            @actors[runner.to_sym] = {
+              extension:      attr[:extension],
+              extension_name: attr[:extension_name],
+              actor_name:     attr[:runner_name],
+              actor_class:    Kernel.const_get(actor_class),
+              type:           'meta'
+            }
+          end
+        end
+
+        def build_meta_actor(runner, attr)
+          define_constant_two('Actor', root: lex_class)
+
+          Kernel.const_get("#{attr[:extension_class]}::Actor")
+                .const_set(runner.to_s.split('_').collect(&:capitalize).join, Class.new(Legion::Extensions::Actors::Subscription))
+        end
+
+        def actor_files
+          @actor_files ||= find_files('actors')
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/builders/base.rb

@@ -0,0 +1,36 @@
+module Legion
+  module Extensions
+    module Builder
+      module Base
+        def find_files(name, path = extension_path)
+          files = []
+          return files unless Dir.exist? "#{path}/#{name}"
+
+          Dir["#{path}/#{name}/*.rb"].each do |file|
+            files.push(file)
+          end
+          files
+        end
+
+        def require_files(files)
+          files.each { |file| require file }
+        end
+
+        def const_defined_two?(item, root = Kernel)
+          root.const_defined?(item.to_s)
+        end
+
+        def define_constant_two(item, root: Kernel, type: Module)
+          return true if const_defined?(item, root: root)
+
+          root.const_set(item.to_s, type.new)
+        end
+
+        def define_get(item, root: Kernel, type: Module)
+          define_constant_two(item, root: root, type: type) if const_defined_two?(item, root: root)
+          root.const_get(item)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/builders/helpers.rb

@@ -0,0 +1,24 @@
+require_relative 'base'
+
+module Legion
+  module Extensions
+    module Builder
+      module Helpers
+        include Legion::Extensions::Builder::Base
+
+        def build_helpers
+          @helpers ||= []
+          @helpers.push(require_files(helper_files))
+        end
+
+        def helper_files
+          @helper_files ||= find_files('helpers')
+        end
+
+        def helpers
+          @helpers
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/builders/runners.rb

@@ -0,0 +1,58 @@
+require_relative 'base'
+
+module Legion
+  module Extensions
+    module Builder
+      module Runners
+        include Legion::Extensions::Builder::Base
+
+        attr_reader :runners
+
+        def build_runners
+          @runners = {}
+          lex_class.const_set('Runners', Module.new) unless lex_class.const_defined?('Runners')
+          require_files(runner_files)
+          build_runner_list
+        end
+
+        def build_runner_list
+          runner_files.each do |file|
+            runner_name = file.split('/').last.sub('.rb', '')
+            runner_class =  "#{lex_class}::Runners::#{runner_name.split('_').collect(&:capitalize).join}"
+            loaded_runner = Kernel.const_get(runner_class)
+
+            @runners[runner_name.to_sym] = {
+              extension:       lex_class.to_s.downcase,
+              extension_name:  extension_name,
+              extension_class: lex_class,
+              runner_name:     runner_name,
+              runner_class:    runner_class,
+              runner_path:     file,
+              class_methods:   {}
+            }
+
+            if settings.key?(:runners) && settings[:runners].key?(runner_name.to_sym)
+              @runners[runner_name.to_sym][:desc] = settings[:runners][runner_name.to_sym][:desc]
+            end
+
+            loaded_runner.public_instance_methods(false).each do |runner_method|
+              @runners[runner_name.to_sym][:class_methods][runner_method] = {
+                args: loaded_runner.instance_method(runner_method).parameters
+              }
+            end
+
+            loaded_runner.methods(false).each do |runner_method|
+              @runners[runner_name.to_sym][:class_methods][runner_method] = {
+                args: loaded_runner.method(runner_method).parameters
+              }
+            end
+          end
+        end
+
+        def runner_files
+          @runner_files ||= find_files('runners')
+        end
+      end
+    end
+  end
+end