legionio 0.2.0 → 0.3.4

data/lib/legion/runner.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/exceptions/handled_task'
-require_relative 'runner/log'
-require_relative 'runner/status'
-require 'legion/transport'
-require 'legion/transport/messages/check_subtask'
-
-module Legion
-  module Runner
-    def self.run(runner_class:, function:, task_id: nil, args: nil, check_subtask: true, generate_task: true, parent_id: nil, master_id: nil, **opts) # rubocop:disable Metrics/ParameterLists
-      runner_class = Kernel.const_get(runner_class) if runner_class.is_a? String
-
-      if task_id.nil? && generate_task
-        task_gen = Legion::Runner::Status.generate_task_id(
-          function: function,
-           runner_class: runner_class,
-         parent_id: parent_id, master_id: master_id, task_id: task_id, **opts
-        )
-        task_id = task_gen[:task_id] unless task_gen.nil?
-      end
-
-      args = opts if args.nil?
-      args[:task_id] = task_id unless task_id.nil?
-      args[:master_id] = master_id unless master_id.nil?
-      args[:parent_id] = parent_id unless parent_id.nil?
-
-      result = runner_class.send(function, args)
-    rescue Legion::Exception::HandledTask
-      status = 'task.exception'
-      result = { error: {} }
-    rescue StandardError => e
-      runner_class.handle_exception(e,
-                                    **opts,
-                                    runner_class:  runner_class,
-                                    args:          args,
-                                    function:      function,
-                                    task_id:       task_id,
-                                    generate_task: generate_task,
-                                    check_subtask: check_subtask)
-      status = 'task.exception'
-      result = { success: false, status: status, error: { message: e.message, backtrace: e.backtrace } }
-    else
-      status = 'task.completed'
-    ensure
-      Legion::Runner::Status.update(task_id: task_id, status: status) unless task_id.nil?
-      if check_subtask && status == 'task.completed'
-        Legion::Transport::Messages::CheckSubtask.new(runner_class:  runner_class,
-                                                      function:      function,
-                                                      result:        result,
-                                                      original_args: args,
-                                                      **opts).publish
-      end
-      return { success: true, status: status, result: result, task_id: task_id } # rubocop:disable Lint/EnsureReturn
-    end
-  end
-end

data/lib/legion/runner/log.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Runner
-    module Log
-      def self.exception(exc, **opts)
-        Legion::Logging.error exc.message
-        Legion::Logging.error opts
-      end
-    end
-  end
-end

data/lib/legion/runner/status.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Runner
-    module Status
-      def self.update(task_id:, status: 'task.completed', **opts)
-        Legion::Logging.debug "Legion::Runner::Status.update called, #{task_id}, status: #{status}, #{opts}"
-        return if status.nil?
-
-        if Legion::Settings[:data][:connected]
-          update_db(task_id: task_id, status: status, **opts)
-        else
-          update_rmq(task_id: task_id, status: status, **opts)
-        end
-      end
-
-      def self.update_rmq(task_id:, status: 'task.completed', **opts)
-        return if status.nil?
-
-        Legion::Transport::Messages::TaskUpdate.new(task_id: task_id, status: status, **opts).publish
-      rescue StandardError => e
-        Legion::Logging.fatal e.message
-        Legion::Logging.fatal e.backtrace
-        retries ||= 0
-        Legion::Logging.fatal 'Will retry in 3 seconds' if retries < 5
-        sleep(3)
-        retry if (retries += 1) < 5
-      end
-
-      def self.update_db(task_id:, status: 'task.completed', **opts)
-        return if status.nil?
-
-        task = Legion::Data::Model::Task[task_id]
-        task.update(status: status)
-      rescue StandardError => e
-        Legion::Logging.warn e.message
-        Legion::Logging.warn 'Legion::Runner.update_status_db failed, defaulting to rabbitmq'
-        Legion::Logging.warn e.backtrace
-        update_rmq(task_id: task_id, status: status, **opts)
-      end
-
-      def self.generate_task_id(runner_class:, function:, status: 'task.queued', **opts)
-        Legion::Logging.debug "Legion::Runner::Status.generate_task_id called, #{runner_class}, #{function}, status: #{status}, #{opts}"
-        return nil unless Legion::Settings[:data][:connected]
-
-        runner = Legion::Data::Model::Runner.where(namespace: runner_class.to_s.downcase).first
-        return nil if runner.nil?
-
-        function = Legion::Data::Model::Function.where(runner_id: runner.values[:id], name: function).first
-        return nil if function.nil?
-
-        insert = { status: status, function_id: function.values[:id] }
-        insert[:parent_id] = opts[:task_id] if opts.key? :task_id
-        insert[:master_id] = opts[:task_id] if opts.key? :task_id
-        insert[:payload] = Legion::JSON.dump(opts[:payload]) if opts.key? :payload
-
-        %i[function_args master_id parent_id relationship_id].each do |column|
-          next unless opts.key? column
-
-          insert[column] = opts[column].is_a?(Hash) ? Legion::JSON.dump(opts[column]) : opts[column]
-          # insert[column] = opts[column] if opts.key? column
-        end
-
-        { success: true, task_id: Legion::Data::Model::Task.insert(insert), **insert }
-      rescue StandardError => e
-        Legion::Logging.error e.message
-        Legion::Logging.error e.backtrace
-        raise(e)
-      end
-    end
-  end
-end

data/lib/legion/service.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  class Service
-    def modules
-      [Legion::Crypt, Legion::Transport, Legion::Cache, Legion::Data, Legion::Supervision].freeze
-    end
-
-    def initialize(transport: true, cache: true, data: true, supervision: true, extensions: true, crypt: true, log_level: 'info') # rubocop:disable Metrics/ParameterLists
-      setup_logging(log_level)
-      Legion::Logging.debug('Starting Legion::Service')
-      setup_settings
-      Legion::Logging.info "node name: #{Legion::Settings[:client][:name]}"
-
-      require 'legion/crypt' if crypt
-      Legion::Crypt.start if crypt
-      setup_transport if transport
-      setup_cache if cache
-      setup_data if data
-      setup_supervision if supervision
-      require 'legion/runner'
-
-      load_extensions if extensions
-      Legion::Crypt.setup_safe if crypt
-
-      Legion::Settings[:client][:ready] = true
-    end
-
-    def setup_cache
-      require 'legion/cache'
-      Legion::Cache.setup
-    end
-
-    def setup_data
-      require 'legion/data'
-      Legion::Settings.merge_settings(:data, Legion::Data::Settings.default)
-      Legion::Data.setup
-    end
-
-    def setup_settings
-      require 'legion/settings'
-      Legion::Logging.debug('Loading Legion::Settings')
-      Legion::Settings.load(config_dir: './settings')
-      Legion::Logging.info('Legion::Settings Loaded')
-    end
-
-    def setup_logging(_log_level = 'info')
-      require 'legion/logging'
-      Legion::Logging.setup(level: 'info', trace: true)
-    end
-
-    def setup_transport
-      require 'legion/transport'
-      Legion::Settings.merge_settings(:transport, Legion::Transport::Settings.default)
-      Legion::Transport::Connection.setup
-    end
-
-    def setup_supervision
-      require_relative('supervison')
-      @supervision = Legion::Supervision.setup
-    end
-
-    def shutdown
-      Legion::Logging.info('Legion::Service.shutdown was called')
-      @shutdown = true
-      Legion::Extensions.shutdown
-
-      sleep(0.2)
-      Legion::Data.shutdown
-      Legion::Cache.shutdown
-      Legion::Transport::Connection.shutdown
-      Legion::Crypt.shutdown
-    end
-
-    def load_extensions
-      require 'legion/runner'
-      Legion::Extensions.hook_extensions
-    end
-  end
-end

data/lib/legion/supervison.rb

@@ -1,14 +0,0 @@
-module Legion
-  module Supervision
-    class << self
-      attr_accessor :timer_tasks
-      def setup
-        @timer_tasks = Concurrent::AtomicReference.new([])
-        @once_tasks = Concurrent::AtomicReference.new([])
-        @loop_tasks = Concurrent::AtomicReference.new([])
-        @poll_tasks = Concurrent::AtomicReference.new([])
-        @subscriptions = Concurrent::AtomicReference.new([])
-      end
-    end
-  end
-end

data/lib/legion/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  VERSION = '0.2.0'
-end

data/settings/client.json

@@ -1,9 +0,0 @@
-{
-  "client": {
-    "keepalive": {
-      "thresholds": {
-        "warning": 10
-      }
-    }
-  }
-}