legionio 0.3.0 → 0.3.5

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

@@ -1,36 +0,0 @@
-module Legion
-  module Extensions
-    module Builder
-      module Base
-        def find_files(name, path = extension_path)
-          files = []
-          return files unless Dir.exist? "#{path}/#{name}"
-
-          Dir["#{path}/#{name}/*.rb"].each do |file|
-            files.push(file)
-          end
-          files
-        end
-
-        def require_files(files)
-          files.each { |file| require file }
-        end
-
-        def const_defined_two?(item, root = Kernel)
-          root.const_defined?(item.to_s)
-        end
-
-        def define_constant_two(item, root: Kernel, type: Module)
-          return true if const_defined?(item, root: root)
-
-          root.const_set(item.to_s, type.new)
-        end
-
-        def define_get(item, root: Kernel, type: Module)
-          define_constant_two(item, root: root, type: type) if const_defined_two?(item, root: root)
-          root.const_get(item)
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require_relative 'base'
-
-module Legion
-  module Extensions
-    module Builder
-      module Helpers
-        include Legion::Extensions::Builder::Base
-
-        def build_helpers
-          @helpers ||= []
-          @helpers.push(require_files(helper_files))
-        end
-
-        def helper_files
-          @helper_files ||= find_files('helpers')
-        end
-
-        def helpers
-          @helpers
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/builders/runners.rb

@@ -1,53 +0,0 @@
-require_relative 'base'
-
-module Legion
-  module Extensions
-    module Builder
-      module Runners
-        include Legion::Extensions::Builder::Base
-
-        attr_reader :runners
-
-        def build_runners
-          @runners = {}
-          lex_class.const_set('Runners', Module.new) unless lex_class.const_defined?('Runners')
-          require_files(runner_files)
-          build_runner_list
-        end
-
-        def build_runner_list
-          runner_files.each do |file|
-            runner_name = file.split('/').last.sub('.rb', '')
-            runner_class =  "#{lex_class}::Runners::#{runner_name.split('_').collect(&:capitalize).join}"
-            loaded_runner = Kernel.const_get(runner_class)
-            @runners[runner_name.to_sym] = {
-              extension:       lex_class.to_s.downcase,
-              extension_name:  extension_name,
-              extension_class: lex_class,
-              runner_name:     runner_name,
-              runner_class:    runner_class,
-              runner_path:     file,
-              class_methods:   {}
-            }
-
-            loaded_runner.public_instance_methods(false).each do |runner_method|
-              @runners[runner_name.to_sym][:class_methods][runner_method] = {
-                args: loaded_runner.instance_method(runner_method).parameters
-              }
-            end
-
-            loaded_runner.methods(false).each do |runner_method|
-              @runners[runner_name.to_sym][:class_methods][runner_method] = {
-                args: loaded_runner.method(runner_method).parameters
-              }
-            end
-          end
-        end
-
-        def runner_files
-          @runner_files ||= find_files('runners')
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/core.rb

@@ -1,94 +0,0 @@
-require_relative 'builders/actors'
-require_relative 'builders/helpers'
-require_relative 'builders/runners'
-
-require_relative 'helpers/core'
-require_relative 'helpers/task'
-require_relative 'helpers/logger'
-require_relative 'helpers/lex'
-require_relative 'helpers/transport'
-
-require_relative 'actors/base'
-require_relative 'actors/every'
-require_relative 'actors/loop'
-require_relative 'actors/once'
-require_relative 'actors/poll'
-require_relative 'actors/subscription'
-require_relative 'actors/nothing'
-
-module Legion
-  module Extensions
-    module Core
-      include Legion::Extensions::Helpers::Transport
-      include Legion::Extensions::Helpers::Lex
-
-      include Legion::Extensions::Builder::Runners
-      include Legion::Extensions::Builder::Helpers
-      include Legion::Extensions::Builder::Actors
-
-      def autobuild
-        @actors = {}
-        @meta_actors = {}
-        @runners = {}
-        @helpers = []
-
-        @queues = {}
-        @exchanges = {}
-        @messages = {}
-        build_settings
-        build_transport
-        build_helpers
-        build_runners
-        build_actors
-      end
-
-      def build_transport
-        if File.exist? "#{extension_path}/transport/autobuild.rb"
-          require "#{extension_path}/transport/autobuild"
-          extension_class::Transport::AutoBuild.build
-          log.warn 'still using transport::autobuild, please upgrade'
-        elsif File.exist? "#{extension_path}/transport.rb"
-          require "#{extension_path}/transport"
-          extension_class::Transport.build
-        else
-          auto_generate_transport
-          extension_class::Transport.build
-        end
-      end
-
-      def build_settings # rubocop:disable Metrics/AbcSize
-        if Legion::Settings[:extensions].key?(lex_name.to_sym)
-          Legion::Settings[:default_extension_settings].each do |key, value|
-            Legion::Settings[:extensions][lex_name.to_sym][key.to_sym] = if Legion::Settings[:extensions][lex_name.to_sym].key?(key.to_sym)
-                                                                           value.merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
-                                                                         else
-                                                                           value
-                                                                         end
-          end
-        else
-          Legion::Settings[:extensions][lex_name.to_sym] = Legion::Settings[:default_extension_settings]
-        end
-
-        default_settings.each do |key, value|
-          Legion::Settings[:extensions][lex_name.to_sym][key.to_sym] = if Legion::Settings[:extensions][lex_name.to_sym].key?(key.to_sym)
-                                                                         value.merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
-                                                                       else
-                                                                         value
-                                                                       end
-        end
-      end
-
-      def default_settings
-        {}
-      end
-
-      def auto_generate_transport
-        require 'legion/extensions/transport'
-        log.debug 'running meta magic to generate a transport base class'
-        return if Kernel.const_defined? "#{lex_class}::Transport"
-
-        Kernel.const_get(lex_class.to_s).const_set('Transport', Module.new { extend Legion::Extensions::Transport })
-      end
-    end
-  end
-end

data/lib/legion/extensions/data.rb

@@ -1,10 +0,0 @@
-module Legion
-  module Extensions
-    module Data
-      def build
-        @models = []
-        @migrations = []
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-module Legion
-  module Extensions
-    module Helpers
-      module Base
-        def lex_class
-          @lex_class ||= Kernel.const_get(calling_class_array[0..2].join('::'))
-        end
-        alias extension_class lex_class
-
-        def lex_name
-          @lex_name ||= calling_class_array[2].gsub(/(?<!^)[A-Z]/) { "_#{$&}" }.downcase
-        end
-        alias extension_name lex_name
-        alias lex_filename lex_name
-
-        def lex_const
-          @lex_const ||= calling_class_array[2]
-        end
-
-        def calling_class
-          @calling_class ||= respond_to?(:ancestors) ? ancestors.first : self.class
-        end
-
-        def calling_class_array
-          @calling_class_array ||= calling_class.to_s.split('::')
-        end
-
-        def actor_class
-          calling_class
-        end
-
-        def actor_name
-          @actor_name ||= calling_class_array.last.gsub(/(?<!^)[A-Z]/) { "_#{$&}" }.downcase
-        end
-
-        def actor_const
-          @actor_const ||= calling_class_array.last
-        end
-
-        def runner_class
-          @runner_class ||= Kernel.const_get(actor_class.to_s.sub!('Actor', 'Runners'))
-        end
-
-        def runner_name
-          @runner_name ||= runner_class.to_s.split('::').last.gsub(/(?<!^)[A-Z]/) { "_#{$&}" }.downcase
-        end
-
-        def runner_const
-          @runner_const ||= runner_class.to_s.split('::').last
-        end
-
-        def full_path
-          @full_path ||= "#{Gem::Specification.find_by_name("lex-#{lex_name}").gem_dir}/lib/legion/extensions/#{lex_filename}"
-        end
-        alias extension_path full_path
-
-        def from_json(string)
-          Legion::JSON.load(string)
-        end
-
-        def normalize(thing)
-          if thing.is_a? String
-            to_json(from_json(thing))
-          else
-            from_json(to_json(thing))
-          end
-        end
-
-        def to_dotted_hash(hash, recursive_key = '')
-          hash.each_with_object({}) do |(k, v), ret|
-            key = recursive_key + k.to_s
-            if v.is_a? Hash
-              ret.merge! to_dotted_hash(v, "#{key}.")
-            else
-              ret[key.to_sym] = v
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require_relative 'base'
-module Legion
-  module Extensions
-    module Helpers
-      module Core
-        include Legion::Extensions::Helpers::Base
-
-        def settings
-          if Legion::Settings[:extensions].key?(lex_filename.to_sym)
-            Legion::Settings[:extensions][lex_filename.to_sym]
-          else
-            { logger: { level: 'info', extended: false, internal: false } }
-          end
-        end
-
-        # looks local, then in crypt, then settings, then cache, then env
-        def find_setting(name, **opts)
-          log.debug ".find_setting(#{name}) called"
-          return opts[name.to_sym] if opts.key? name.to_sym
-
-          string_name = "#{lex_name}_#{name.to_s.downcase}"
-          if Legion::Settings[:crypt][:vault][:connected] && Legion::Crypt.exist?(lex_name)
-            log.debug "looking for #{string_name} in Legion::Crypt"
-            crypt_result = Legion::Crypt.get(lex_name)
-            return crypt_result[name.to_sym] if crypt_result.is_a?(Hash) && crypt_result.key?(name.to_sym)
-          end
-          return settings[name.to_sym] if settings.key? name.to_sym
-
-          if Legion::Settings[:cache][:connected]
-            log.debug "looking for #{string_name} in Legion::Cache"
-            cache_result = Legion::Cache.get(string_name)
-            return cache_result unless cache_result.nil?
-          end
-
-          ENV[string_name] if ENV.key? string_name
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Legion
-  module Extensions
-    module Helpers
-      module Lex
-        include Legion::Extensions::Helpers::Core
-        include Legion::Extensions::Helpers::Logger
-
-        def self.included(base)
-          base.send :extend, Legion::Extensions::Helpers::Core if base.class == Class
-          base.send :extend, Legion::Extensions::Helpers::Logger if base.class == Class
-          base.extend base if base.class == Module
-        end
-
-        def default_settings
-          { logger: { level: 'info' } }
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-module Legion
-  module Extensions
-    module Helpers
-      module Logger
-        def log # rubocop:disable Metrics/AbcSize
-          return @log unless @log.nil?
-
-          logger_hash = { lex: lex_filename || nil }
-          logger_hash[:lex] = lex_filename.first if logger_hash[:lex].is_a? Array
-          if respond_to?(:settings) && settings.key?(:logger)
-            logger_hash[:level] = settings[:logger][:level] if settings[:logger].key? :level
-            logger_hash[:level] = settings[:logger][:log_file] if settings[:logger].key? :log_file
-            logger_hash[:level] = 'info' unless settings[:logger].key? :log_file
-            logger_hash[:trace] = settings[:logger][:trace] if settings[:logger].key? :trace
-            logger_hash[:extended] = settings[:logger][:extended] if settings[:logger].key? :extended
-          elsif respond_to?(:settings)
-            Legion::Logging.warn Legion::Settings[:extensions][lex_filename.to_sym]
-            Legion::Logging.warn "#{lex_name} has settings but no :logger key"
-          else
-            Legion::Logging.warn 'no settings'
-          end
-          @log = Legion::Logging::Logger.new(**logger_hash)
-        end
-
-        def handle_exception(exception, task_id: nil, **opts)
-          log.error exception.message + " for task_id: #{task_id} but was logged "
-          log.error exception.backtrace[0..10]
-          log.error opts
-
-          unless task_id.nil?
-            Legion::Transport::Messages::TaskLog.new(
-              task_id:      task_id,
-              runner_class: to_s,
-              entry:        {
-                exception: true,
-                message:   exception.message,
-                **opts
-              }
-            ).publish
-          end
-
-          raise Legion::Exception::HandledTask
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'legion/transport'
-require 'legion/transport/messages/task_update'
-require 'legion/transport/messages/task_log'
-
-module Legion
-  module Extensions
-    module Helpers
-      module Task
-        def generate_task_log(task_id:, runner_class: to_s, function:, **payload)
-          Legion::Transport::Messages::TaskLog.new(task_id: task_id, runner_class: runner_class, function: function, entry: payload).publish
-        end
-
-        def task_update(task_id, status, **opts)
-          return if task_id.nil? || status.nil?
-
-          update_hash = { task_id: task_id, status: status }
-          %i[results payload function_args payload results].each do |column|
-            update_hash[column] = opts[column] if opts.key? column
-          end
-          Legion::Transport::Messages::TaskUpdate.new(**update_hash).publish
-        rescue StandardError => e
-          log.fatal e.message
-          log.fatal e.backtrace
-          raise e
-        end
-
-        def generate_task_id(function_id:, status: 'task.queued', **opts)
-          insert = { status: status, function_id: function_id }
-          insert[:payload] = Legion::JSON.dump(opts[:payload]) if opts.key? :payload
-          insert[:function_args] = Legion::JSON.dump(opts[:args]) if opts.key? :args
-          %i[master_id parent_id relationship_id task_id].each do |column|
-            insert[column] = opts[column] if opts.key? column
-          end
-
-          { success: true, task_id: Legion::Data::Model::Task.insert(insert), **insert }
-        end
-      end
-    end
-  end
-end