legionio 0.1.1 → 0.2.0

data/lib/legion.rb

@@ -1,12 +1,21 @@
-# frozen_string_literal: true
-
 Process.setproctitle('Legion')
+require 'concurrent-ruby'
+require 'securerandom'
+# require 'legion/exceptions'
 require 'legion/version'
 require 'legion/process'
 require 'legion/service'
+require 'legion/extensions'
 
-# Base Legion Module to start the world
 module Legion
-  Legion::Service.new({})
-  Legion::Logging.info("Started Legion v#{Legion::VERSION}")
+  attr_reader :service
+
+  def self.start
+    @service = Legion::Service.new
+    Legion::Logging.info("Started Legion v#{Legion::VERSION}")
+  end
+
+  def self.shutdown
+    @service.shutdown
+  end
 end

data/lib/legion/exceptions/handled_task.rb

@@ -0,0 +1,6 @@
+module Legion
+  module Exception
+    class HandledTask < StandardError
+    end
+  end
+end

data/lib/legion/exceptions/missingargument.rb

@@ -2,7 +2,7 @@
 
 module Legion
   module Exception
-    # Missing argument exception
-    class MissingArgument < StandardError; end
+    class MissingArgument < StandardError
+    end
   end
 end

data/lib/legion/extensions.rb

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

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

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

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

@@ -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,42 @@
+# 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

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