legionio 0.1.1 → 0.2.0

data/lib/legion/extension/loader.rb

@@ -1,96 +0,0 @@
-require 'legion/transport/messages/lex_register'
-
-module Legion
-  module Extension
-    # New magical extension loader
-    class Loader
-      attr_reader :loaded_extensions
-      def initialize(supervision, _extensions = Legion::Settings[:legion][:extensions])
-        @loaded_extensions = []
-        @supervision = supervision
-      end
-
-      def load_extensions(extensions = Legion::Settings[:legion][:extensions])
-        extensions.each do |extension, values|
-          Legion::Logging.debug "Skipping #{extension} because it's disabled" unless values[:enabled]
-          next unless values[:enabled]
-
-          result = load_extension(extension, values)
-          Legion::Logging.info("#{extension} was loaded") if result
-          Legion::Logging.warn("#{extension} failed to load") unless result
-          @loaded_extensions.push(extension) if result
-        end
-      end
-
-      def load_actor_pool(klass, name, size = 1)
-        @supervision.supervision_group.pool(klass, as: name, size: size)
-      end
-
-      def register_lex(_extension, lex_methods)
-        lex_methods.each do |namespace|
-          namespace[:class_methods].each do |class_method, _attrs|
-            options = { namespace: {}, method: {} }
-            options[:namespace][:queue] = namespace[:queue] unless namespace[:queue].nil?
-            options[:namespace][:uri] = namespace[:uri] unless namespace[:uri].nil?
-            Legion::Transport::Messages::LexRegister.new(namespace[:namespace], class_method, options).publish
-          end
-        end
-      end
-
-      def load_extension(extension, values) # rubocop:disable Metrics/AbcSize
-        Legion::Logging.debug "Skipping #{extension} because it's disabled" unless values[:enabled]
-        return false unless values[:enabled]
-
-        unless gem_load(extension)
-          Legion::Logging.warn "#{extension} failed to load gem path"
-          return false
-        end
-
-        klass = Kernel.const_get(values[:class])
-        klass.autobuild
-
-        register_lex(extension, klass.lex_methods)
-
-        klass.actors.each do |actor|
-          load_actor_pool(actor[:class], actor[:group_name], 1)
-        end
-        true
-      rescue Sequel::DatabaseConnectionError => exception
-        Legion::Logging.fatal("Legion::Extension #{extension} requires a database connection but failed")
-        Legion::Logging.debug("Extension failed with #{exception.message}")
-        Legion::Logging.debug("Backtrace: #{exception.backtrace}")
-        false
-      rescue NameError => exception
-        Legion::Logging.fatal("Legion::Extension #{extension} failed to load, moving on without it")
-        Legion::Logging.warn("Extension failed with #{exception.message}")
-        Legion::Logging.warn("Backtrace: #{exception.backtrace}")
-        false
-      rescue LoadError => exception
-        Legion::Logging.fatal("Legion::Extension #{extension} failed to load, moving on without it")
-        Legion::Logging.warn("Extension failed with #{exception.message}")
-        Legion::Logging.warn("Backtrace: #{exception.backtrace}")
-        false
-      rescue StandardError => exception
-        Legion::Logging.fatal("Legion::Extension #{extension} failed to load, moving on without it")
-        Legion::Logging.fatal("#{extension} was caught by default")
-        Legion::Logging.warn("Extension failed with #{exception.message}")
-        Legion::Logging.warn("Backtrace: #{exception.backtrace}")
-        false
-      end
-
-      def gem_load(name)
-        search_name = 'lex-' + name.to_s
-        Legion::Logging.unknown search_name
-        gem_dir = Gem::Specification.find_by_name(search_name).gem_dir
-        Legion::Logging.unknown gem_dir
-        require "#{gem_dir}/lib/legion/extensions/#{name}"
-        true
-      rescue LoadError => ex
-        Legion::Logging.unknown ex.message
-        Legion::Logging.unknown ex.backtrace
-        Legion::Logging.warn "gem path:  #{gem_dir}/lib/legion/extensions/#{name}"
-        false
-      end
-    end
-  end
-end

data/lib/legion/runners/runner.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/transport/messages/task_check_subtask'
-require 'legion/transport/messages/task_update'
-
-module Legion
-  module Runner
-    # Base running class that will run everything
-    class Runner
-      def initialize(klass, method, options = {}) # rubocop:disable Metrics/AbcSize
-        klass = Kernel.const_get(klass) if klass.is_a? String
-        result = if options[:args].nil?
-                   klass.send(method)
-                 else
-                   klass.send(method, options[:args])
-                 end
-        update_status(options[:task_id]) unless options[:task_id].nil?
-        Legion::Transport::Messages::TaskCheckSubtask.new(klass, method, result, options).publish
-      rescue StandardError => ex
-        Legion::Logging.error(ex.message)
-        Legion::Logging.warn(ex.backtrace)
-        return if options[:task_id].nil?
-
-        update_status(options[:task_id], 'task.exception', msg: ex.message)
-      end
-
-      def update_status(_task_id, status = 'task.completed', options = {})
-        Legion::Transport::Messages::TaskUpdate.new(options[:task_id], status, options).publish
-        # if Legion::Settings[:data][:connected]
-        #   update_status_database(task_id, status)
-        # else
-        #   update_status_rmq(task_id, status)
-        # end
-      end
-
-      def update_status_rmq(_task_id, status = 'task.completed', options = {})
-        Legion::Transport::Messages::TaskUpdate.new(options[:task_id], status).publish
-      end
-
-      def update_status_database(task_id, _status = 'task.completed', _options = {})
-        require 'legion/data/models/task'
-        task = Legion::Data::Model::Task[task_id]
-        task.update(status: 'task.completed')
-      end
-    end
-  end
-end
-
-# Status
-# task.scheduled
-# condition.queued
-# condition.failed
-# condition.succeeded
-# condition.exception
-# transformation.queued
-# transformation.succeeded
-# transformation.exception
-# task.completed