legionio 0.3.0 → 0.3.5

data/lib/legion/extensions/helpers/transport.rb

@@ -1,43 +0,0 @@
-require_relative 'base'
-
-module Legion
-  module Extensions
-    module Helpers
-      module Transport
-        include Legion::Extensions::Helpers::Base
-
-        def transport_path
-          @transport_path ||= "#{full_path}/transport"
-        end
-
-        def transport_class
-          @transport_class ||= lex_class::Transport
-        end
-
-        def messages
-          @messages ||= transport_class::Messages
-        end
-
-        def queues
-          @queues ||= transport_class::Queues
-        end
-
-        def exchanges
-          @exchanges ||= transport_class::Exchanges
-        end
-
-        def default_exchange
-          @default_exchange ||= build_default_exchange
-        end
-
-        def build_default_exchange
-          exchange = "#{transport_class}::Exchanges::#{lex_const}"
-          return Object.const_get(exchange) if transport_class::Exchanges.const_defined? lex_const
-
-          transport_class::Exchanges.const_set(lex_const, Class.new(Legion::Transport::Exchange))
-          @default_exchange = Kernel.const_get(exchange)
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/transport.rb

@@ -1,155 +0,0 @@
-module Legion
-  module Extensions
-    module Transport
-      include Legion::Extensions::Helpers::Transport
-
-      attr_accessor :exchanges, :queues, :consumers, :messages
-
-      def build
-        @queues = []
-        @exchanges = []
-        @messages = []
-        @consumers = []
-        generate_base_modules
-        require_transport_items
-
-        build_e_to_e
-        build_e_to_q(e_to_q)
-        build_e_to_q(additional_e_to_q)
-        auto_create_dlx_exchange
-        auto_create_dlx_queue
-      rescue StandardError => e
-        Legion::Logging.error e.message
-        Legion::Logging.error e.backtrace
-      end
-
-      def generate_base_modules
-        lex_class.const_set('Transport', Module.new) unless lex_class.const_defined?('Transport')
-        %w[Queues Exchanges Messages Consumers].each do |thing|
-          next if transport_class.const_defined? thing
-
-          transport_class.const_set(thing, Module.new)
-        end
-      end
-
-      def require_transport_items
-        { 'exchanges': @exchanges, 'queues': @queues, 'consumers': @consumers, 'messages': @messages }.each do |item, obj|
-          Dir[File.expand_path("#{transport_path}/#{item}/*.rb")].sort.each do |file|
-            require file
-            file_name = file.to_s.split('/').last.split('.').first
-            obj.push(file_name) unless obj.include?(file_name)
-          end
-        end
-      end
-
-      def auto_create_exchange(exchange, default_exchange = false) # rubocop:disable Style/OptionalBooleanParameter
-        if Object.const_defined? exchange
-          Legion::Logging.warn "#{exchange} is already defined"
-          return
-        end
-        return build_default_exchange if default_exchange
-
-        transport_class::Exchanges.const_set(exchange.split('::').pop, Class.new(Legion::Transport::Exchange) do
-          def exchange_name
-            self.class.ancestors.first.to_s.split('::')[5].downcase
-          end
-        end)
-      end
-
-      def auto_create_queue(queue)
-        if Kernel.const_defined?(queue)
-          Legion::Logging.warn "#{queue} is already defined"
-          return
-        end
-
-        transport_class::Queues.const_set(queue.split('::').last, Class.new(Legion::Transport::Queue))
-      end
-
-      def auto_create_dlx_exchange
-        return if transport_class::Exchanges.const_defined? 'Dlx'
-
-        dlx = transport_class::Exchanges.const_set('Dlx', Class.new(default_exchange) do
-          def exchange_name
-            "#{super}.dlx"
-          end
-        end)
-        dlx.new
-        dlx
-      end
-
-      def auto_create_dlx_queue
-        return if transport_class::Queues.const_defined?('Dlx')
-
-        special_name = default_exchange.new.exchange_name
-        dlx_queue = Legion::Transport::Queue.new "#{special_name}.dlx", auto_delete: false
-        dlx_queue.bind("#{special_name}.dlx", { routing_key: '#' })
-      end
-
-      def build_e_to_q(array)
-        array.each do |binding|
-          binding[:routing_key] = nil unless binding.key? :routing_key
-          binding[:to] = nil unless binding.key? :to
-          bind_e_to_q(**binding)
-        end
-      end
-
-      def bind_e_to_q(to:, from: default_exchange, routing_key: nil)
-        if from.is_a? String
-          from = "#{transport_class}::Exchanges::#{from.split('_').collect(&:capitalize).join}" unless from.include?('::')
-          auto_create_exchange(from) unless Object.const_defined? from
-        end
-
-        if to.is_a? String
-          to = "#{transport_class}::Queues::#{to.split('_').collect(&:capitalize).join}" unless to.include?('::')
-          auto_create_queue(to) unless Object.const_defined?(to)
-        end
-
-        routing_key = to.to_s.split('::').last.downcase if routing_key.nil?
-        bind(from, to, routing_key: routing_key)
-      end
-
-      def build_e_to_e
-        e_to_e.each do |binding|
-          if binding[:from].is_a? String
-            binding[:from] = "#{transport_class}::Exchanges::#{binding[:from].capitalize}" unless binding[:from].include?('::')
-            auto_create_exchange(binding[:from]) unless Object.const_defined? binding[:from]
-          end
-
-          if binding[:to].is_a? String
-            binding[:to] = "#{transport_class}::Exchanges::#{binding[:to].capitalize}" unless binding[:to].include?('::')
-            auto_create_exchange(binding[:to]) unless Object.const_defined? binding[:to]
-          end
-
-          bind(binding[:from], binding[:to], binding)
-        end
-      end
-
-      def bind(from, to, routing_key: nil, **_options)
-        from = from.is_a?(String) ? Kernel.const_get(from).new : from.new
-        to = to.is_a?(String) ? Kernel.const_get(to).new : to.new
-        to.bind(from, routing_key: routing_key)
-      rescue StandardError => e
-        Legion::Logging.fatal e.message
-        Legion::Logging.fatal e.backtrace
-        Legion::Logging.fatal({ from: from, to: to, routing_key: routing_key })
-      end
-
-      def e_to_q
-        [] if !@exchanges.count != 1
-        auto = []
-        @queues.each do |queue|
-          auto.push(from: @exchanges.first, to: queue, routing_key: queue)
-        end
-        auto
-      end
-
-      def e_to_e
-        []
-      end
-
-      def additional_e_to_q
-        []
-      end
-    end
-  end
-end

data/lib/legion/process.rb

@@ -1,126 +0,0 @@
-require 'fileutils'
-
-module Legion
-  class Process
-    def self.run!(options)
-      Legion::Process.new(options).run!
-    end
-
-    attr_reader :options, :quit, :service
-
-    def initialize(options)
-      @options = options
-      options[:logfile] = File.expand_path(logfile) if logfile?
-      options[:pidfile] = File.expand_path(pidfile) if pidfile?
-    end
-
-    def daemonize?
-      options[:daemonize]
-    end
-
-    def logfile
-      options[:logfile]
-    end
-
-    def pidfile
-      options[:pidfile]
-    end
-
-    def logfile?
-      !logfile.nil?
-    end
-
-    def pidfile?
-      !pidfile.nil?
-    end
-
-    def info(msg)
-      puts "[#{::Process.pid}] [#{Time.now}] #{msg}"
-    end
-
-    def run!
-      start_time = Time.now
-      @options[:time_limit] = @options[:time_limit].to_i if @options.key? :time_limit
-      @quit = false
-      check_pid
-      daemonize if daemonize?
-      write_pid
-      trap_signals
-
-      until quit
-        sleep(1)
-        if @options.key? :time_limit
-          @quit = true if Time.now - start_time > @options[:time_limit]
-        end
-      end
-      Legion::Logging.info('Legion is shutting down!')
-      Legion.shutdown
-      Legion::Logging.info('Legion has shutdown. Goodbye!')
-
-      exit
-    end
-
-    #==========================================================================
-    # DAEMONIZING, PID MANAGEMENT, and OUTPUT REDIRECTION
-    #==========================================================================
-
-    def daemonize
-      exit if fork
-      ::Process.setsid
-      exit if fork
-      Dir.chdir '/'
-    end
-
-    def write_pid
-      if pidfile?
-        begin
-          File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY) { |f| f.write(::Process.pid.to_s) }
-          at_exit { File.delete(pidfile) if File.exist?(pidfile) }
-        rescue Errno::EEXIST
-          check_pid
-          retry
-        end
-      end
-      false
-    end
-
-    def check_pid
-      if pidfile?
-        case pid_status(pidfile)
-        when :running, :not_owned
-          exit(1)
-        when :dead
-          File.delete(pidfile)
-        end
-      end
-      false
-    end
-
-    def pid_status(pidfile)
-      return :exited unless File.exist?(pidfile)
-
-      pid = ::File.read(pidfile).to_i
-      return :dead if pid.zero?
-
-      ::Process.kill(0, pid)
-      :running
-    rescue Errno::ESRCH
-      :dead
-    rescue Errno::EPERM
-      :not_owned
-    end
-
-    def trap_signals
-      trap('SIGTERM') do
-        info 'sigterm'
-      end
-
-      trap('SIGHUP') do
-        info 'sithup'
-      end
-      trap('SIGINT') do
-        @quit = true
-      end
-    end
-  end
-end

data/lib/legion/runner.rb

@@ -1,55 +0,0 @@
-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,10 +0,0 @@
-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,69 +0,0 @@
-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]
-        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