legionio 0.3.2 → 0.3.3

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

@@ -1,49 +0,0 @@
-require 'hashdiff'
-
-module Legion
-  module Extensions
-    module Actors
-      module Base
-        include Legion::Extensions::Helpers::Lex
-
-        def runner
-          Legion::Runner.run(runner_class: runner_class, function: function, check_subtask: check_subtask?, generate_task: generate_task?)
-        rescue StandardError => e
-          Legion::Logging.error e.message
-          Legion::Logging.error e.backtrace
-        end
-
-        def manual
-          runner_class.send(runner_function, **args)
-        rescue StandardError => e
-          Legion::Logging.error e.message
-          Legion::Logging.error e.backtrace
-        end
-
-        def function
-          nil
-        end
-
-        def use_runner?
-          true
-        end
-
-        def args
-          {}
-        end
-
-        def check_subtask?
-          true
-        end
-
-        def generate_task?
-          false
-        end
-
-        def enabled?
-          true
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require_relative 'base'
-
-module Legion
-  module Extensions
-    module Actors
-      class Every
-        include Legion::Extensions::Actors::Base
-
-        def initialize(**_opts)
-          @timer = Concurrent::TimerTask.new(execution_interval: time, timeout_interval: timeout, run_now: run_now?) do
-            use_runner? ? runner : manual
-          end
-
-          @timer.execute
-        rescue StandardError => e
-          Legion::Logging.error e.message
-          Legion::Logging.error e.backtrace
-        end
-
-        def time
-          1
-        end
-
-        def timeout
-          5
-        end
-
-        def run_now?
-          false
-        end
-
-        def action(**_opts)
-          Legion::Logging.warn 'An extension is using the default block from Legion::Extensions::Runners::Every'
-        end
-
-        def cancel
-          Legion::Logging.debug 'Cancelling Legion Timer'
-          return true unless @timer.respond_to?(:shutdown)
-
-          @timer.shutdown
-        rescue StandardError => e
-          Legion::Logging.error e.message
-          Legion::Logging.error e.backtrace
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,88 +0,0 @@
-require_relative 'base'
-require 'hashdiff'
-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

@@ -1,138 +0,0 @@
-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
-        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

@@ -1,61 +0,0 @@
-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