legionio 0.3.5 → 0.4.0

data/lib/legion/extensions/core.rb

@@ -0,0 +1,131 @@
+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 'helpers/data'
+require_relative 'helpers/cache'
+
+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_data if Legion::Settings[:data][:connected] && data_required?
+        build_helpers
+        build_runners
+        build_actors
+      end
+
+      def data_required?
+        false
+      end
+
+      def transport_required?
+        true
+      end
+
+      def cache_required?
+        false
+      end
+
+      def crypt_required?
+        false
+      end
+
+      def vault_required?
+        false
+      end
+
+      def build_data
+        auto_generate_data
+        lex_class::Data.build
+      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
+
+      def auto_generate_data
+        require 'legion/extensions/data'
+        log.debug 'running meta magic to generate a data base class'
+        Kernel.const_get(lex_class.to_s).const_set('Data', Module.new { extend Legion::Extensions::Data })
+      rescue StandardError => e
+        log.error e.message
+        log.error e.backtrace
+      end
+    end
+  end
+end

data/lib/legion/extensions/data.rb

@@ -0,0 +1,58 @@
+require 'legion/extensions/data/migrator'
+require 'legion/extensions/data/model'
+
+module Legion
+  module Extensions
+    module Data
+      include Legion::Extensions::Helpers::Data
+      include Legion::Extensions::Helpers::Logger
+
+      def build
+        @models = []
+        @migrations = []
+        if Dir[File.expand_path("#{data_path}/migrations/*.rb")].count.positive?
+          log.debug('Has migrations, checking status')
+          run
+        end
+
+        models = Dir[File.expand_path("#{data_path}/models/*.rb")]
+        if models.count.positive?
+          log.debug('Including LEX models')
+          models.each do |file|
+            require file
+          end
+
+          models_class.constants.select do |model|
+            models_class.const_get(model).extend Legion::Extensions::Data::Model
+          end
+        end
+
+        true
+      end
+
+      def extension_model
+        Legion::Data::Model::Extension[namespace: lex_class.to_s]
+      end
+
+      def schema_version
+        extension_model.values[:schema_version]
+      end
+
+      def migrations_path
+        "#{data_path}/migrations/"
+      end
+
+      def migrate_class
+        @migrate_class ||= Legion::Extensions::Data::Migrator.new(migrations_path, lex_class.to_s)
+      end
+
+      def run
+        return true if migrate_class.is_current?
+
+        log.debug('Running LEX schema migrator')
+        results = migrate_class.run
+        extension_model.update(schema_version: results)
+      end
+    end
+  end
+end

data/lib/legion/extensions/data/migrator.rb

@@ -0,0 +1,28 @@
+require 'sequel/extensions/migration'
+
+module Legion
+  module Extensions
+    module Data
+      class Migrator < Sequel::IntegerMigrator
+        def initialize(path, extension, **)
+          @path = path
+          @extension = extension
+          super(Legion::Data::Connection.sequel, path)
+        end
+
+        def default_schema_column
+          :schema_version
+        end
+
+        def default_schema_table
+          :extensions
+        end
+
+        def schema_dataset
+          Legion::Data::Connection.sequel.from(default_schema_table).where(namespace: @extension)
+        end
+        alias ds schema_dataset
+      end
+    end
+  end
+end

data/lib/legion/extensions/data/model.rb

@@ -0,0 +1,8 @@
+module Legion
+  module Extensions
+    module Data
+      module Model
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+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]/) { "_#{Regexp.last_match(0)}" }.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]/) { "_#{Regexp.last_match(0)}" }.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]/) { "_#{Regexp.last_match(0)}" }.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/cache.rb

@@ -0,0 +1,23 @@
+require 'legion/extensions/helpers/base'
+
+module Legion
+  module Extensions
+    module Helpers
+      module Cache
+        include Legion::Extensions::Helpers::Base
+
+        def cache_namespace
+          @cache_namespace ||= lex_name
+        end
+
+        def cache_set(key, value, ttl: 60, **)
+          Legion::Cache.set(cache_namespace + key, value, ttl: ttl)
+        end
+
+        def cache_get(key)
+          Legion::Cache.get(cache_namespace + key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+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/data.rb

@@ -0,0 +1,23 @@
+require 'legion/extensions/helpers/base'
+
+module Legion
+  module Extensions
+    module Helpers
+      module Data
+        include Legion::Extensions::Helpers::Base
+
+        def data_path
+          @data_path ||= "#{full_path}/data"
+        end
+
+        def data_class
+          @data_class ||= lex_class::Data
+        end
+
+        def models_class
+          @models_class ||= data_class::Model
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Legion
+  module Extensions
+    module Helpers
+      module Lex
+        include Legion::Extensions::Helpers::Core
+        include Legion::Extensions::Helpers::Logger
+
+        def function_example(function, example)
+          function_set(function, :example, example)
+        end
+
+        def function_options(function, options)
+          function_set(function, :options, options)
+        end
+
+        def function_desc(function, desc)
+          function_set(function, :desc, desc)
+        end
+
+        def function_set(function, key, value)
+          unless respond_to? function
+            log.debug "function_#{key} called but function doesn't exist, f: #{function}"
+            return nil
+          end
+          settings[:functions] = {} if settings[:functions].nil?
+          settings[:functions][function] = {} if settings[:functions][function].nil?
+          settings[:functions][function][key] = value
+        end
+
+        def runner_desc(desc)
+          settings[:runners] = {} if settings[:runners].nil?
+          settings[:runners][actor_name.to_sym] = {} if settings[:runners][actor_name.to_sym].nil?
+          settings[:runners][actor_name.to_sym][:desc] = desc
+        end
+
+        def self.included(base)
+          base.send :extend, Legion::Extensions::Helpers::Core if base.instance_of?(Class)
+          base.send :extend, Legion::Extensions::Helpers::Logger if base.instance_of?(Class)
+          base.extend base if base.instance_of?(Module)
+        end
+
+        def default_settings
+          { logger: { level: 'info' }, workers: 1, runners: {}, functions: {} }
+        end
+      end
+    end
+  end
+end