legionio 0.2.0 → 0.3.4

data/lib/legion/exceptions/missingargument.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Exception
-    class MissingArgument < StandardError
-    end
-  end
-end

data/lib/legion/exceptions/wrongtype.rb

@@ -1,10 +0,0 @@
-require_relative 'wrongtypes/array'
-require_relative 'wrongtypes/hash'
-require_relative 'wrongtypes/integer'
-require_relative 'wrongtypes/string'
-
-module Legion
-  module Exception
-    class WrongType < StandardError; end
-  end
-end

data/lib/legion/exceptions/wrongtypes/array.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Exception
-    module WrongType
-      # This thing should be an array
-      class Array < TypeError
-      end
-    end
-  end
-end

data/lib/legion/exceptions/wrongtypes/hash.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Exception
-    module WrongType
-      # This thing should be a hash
-      class Hash < TypeError
-      end
-    end
-  end
-end

data/lib/legion/exceptions/wrongtypes/integer.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Exception
-    module WrongType
-      # This thing should be an int
-      class Integer < TypeError
-      end
-    end
-  end
-end

data/lib/legion/exceptions/wrongtypes/string.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Exception
-    module WrongType
-      # This thing should be a string
-      class String < TypeError
-      end
-    end
-  end
-end

data/lib/legion/extensions.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/extensions/core'
-require 'legion/runner'
-
-module Legion
-  module Extensions
-    class << self
-      def setup
-        hook_extensions
-      end
-
-      def hook_extensions
-        @timer_tasks = []
-        @loop_tasks = []
-        @once_tasks = []
-        @poll_tasks = []
-        @subscription_tasks = []
-        @actors = []
-
-        find_extensions
-        load_extensions
-      end
-
-      def shutdown
-        @subscription_tasks.each do |task|
-          task[:threadpool].shutdown
-          task[:threadpool].wait_for_termination(2)
-          task[:threadpool].kill
-        end
-        @loop_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
-        @once_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
-        @timer_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
-        @poll_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
-
-        Legion::Logging.info 'Successfully shut down all actors'
-      end
-
-      def load_extensions
-        @extensions ||= {}
-        @loaded_extensions ||= []
-        @extensions.each do |extension, values|
-          if values.key(:enabled) && !values[:enabled]
-            Legion::Logging.info "Skipping #{extension} because it's disabled"
-            next
-          end
-
-          if Legion::Settings[:extensions].key?(extension.to_sym) && Legion::Settings[:extensions][extension.to_sym].key?(:enabled) && !Legion::Settings[:extensions][extension.to_sym][:enabled] # rubocop:disable Layout/LineLength
-            next
-          end
-
-          unless load_extension(extension, values)
-            Legion::Logging.warn("#{extension} failed to load")
-            next
-          end
-          @loaded_extensions.push(extension)
-        end
-        Legion::Logging.info "#{@extensions.count} extensions loaded with subscription:#{@subscription_tasks.count},every:#{@timer_tasks.count},poll:#{@poll_tasks.count},once:#{@once_tasks.count},loop:#{@loop_tasks.count}"
-      end
-
-      def load_extension(extension, values)
-        return unless gem_load(values[:gem_name], extension)
-
-        extension = Kernel.const_get(values[:extension_class])
-        has_logger = extension.respond_to?(:log)
-        extension.autobuild
-
-        require 'legion/transport/messages/lex_register'
-        Legion::Transport::Messages::LexRegister.new(function: 'save', opts: extension.runners).publish
-
-        if extension.respond_to?(:meta_actors) && extension.meta_actors.is_a?(Array)
-          extension.meta_actors.each do |_key, actor|
-            extension.log.debug("hooking meta actor: #{actor}") if has_logger
-            hook_actor(**actor)
-          end
-        end
-
-        extension.actors.each do |_key, actor|
-          extension.log.debug("hooking literal actor: #{actor}") if has_logger
-          hook_actor(**actor)
-        end
-        extension.log.info 'Loaded'
-      rescue StandardError => e
-        Legion::Logging.error e.message
-        Legion::Logging.error e.backtrace
-        false
-      end
-
-      def hook_actor(extension:, extension_name:, actor_class:, size: 1, **opts)
-        size = 1 unless size.is_a? Integer
-        extension_hash = {
-          extension:      extension,
-          extension_name: extension_name,
-          actor_class:    actor_class,
-          size:           size,
-          **opts
-        }
-        extension_hash[:running_class] = if actor_class.ancestors.include? Legion::Extensions::Actors::Subscription
-                                           actor_class
-                                         else
-                                           actor_class.new
-                                         end
-
-        if actor_class.ancestors.include? Legion::Extensions::Actors::Every
-          @timer_tasks.push(extension_hash)
-        elsif actor_class.ancestors.include? Legion::Extensions::Actors::Once
-          @once_tasks.push(extension_hash)
-        elsif actor_class.ancestors.include? Legion::Extensions::Actors::Loop
-          @loop_tasks.push(extension_hash)
-        elsif actor_class.ancestors.include? Legion::Extensions::Actors::Poll
-          @poll_tasks.push(extension_hash)
-        elsif actor_class.ancestors.include? Legion::Extensions::Actors::Subscription
-          extension_hash[:threadpool] = Concurrent::FixedThreadPool.new(100)
-          size.times do
-            extension_hash[:threadpool].post do
-              actor_class.new.async.subscribe
-            end
-          end
-          @subscription_tasks.push(extension_hash)
-        else
-          Legion::Logging.fatal 'did not match any actor classes'
-        end
-      end
-
-      def gem_load(gem_name, name)
-        gem_path = "#{Gem::Specification.find_by_name(gem_name).gem_dir}/lib/legion/extensions/#{name}"
-        require gem_path
-        true
-      rescue LoadError => e
-        Legion::Logging.error e.message
-        Legion::Logging.error e.backtrace
-        Legion::Logging.error "gem_path: #{gem_path}" unless gem_path.nil?
-        false
-      end
-
-      def find_extensions
-        @extensions ||= {}
-        Gem::Specification.all_names.each do |gem|
-          next unless gem[0..3] == 'lex-'
-
-          lex = gem.split('-')
-          @extensions[lex[1]] = { full_gem_name:   gem,
-                                  gem_name:        "lex-#{lex[1]}",
-                                  extension_name:  lex[1],
-                                  version:         lex[2],
-                                  extension_class: "Legion::Extensions::#{lex[1].capitalize}" }
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'hashdiff'
-
-module Legion
-  module Extensions
-    module Actors
-      module Base
-        include Legion::Extensions::Helpers::Lex
-
-        def runner
-          # runner_class:, function:, task_id: nil, args: nil, check_subtask: true, generate_task: true, parent_id: nil, master_id: nil, **opts
-          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
-          # Legion::Runner.run(runner_class: runner_class, function: runner_function, check_subtask: false, generate_task: false, args: args)
-          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,50 +0,0 @@
-# frozen_string_literal: true
-
-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,34 +0,0 @@
-# frozen_string_literal: true
-
-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,42 +0,0 @@
-# frozen_string_literal: true
-
-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,90 +0,0 @@
-# frozen_string_literal: true
-
-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.to_s + '_' + 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