legionio 0.3.1 → 0.4.0

data/lib/legion/cli/relationship.rb

@@ -0,0 +1,22 @@
+module Legion
+  class Cli
+    class Relationship < Thor
+      desc 'create', 'creates a new relationship'
+      def create(_name, _type)
+        trigger_id = invoke('legion:cli:function:find', [], internal: true, capture: true) # rubocop:disable Lint/UselessAssignment
+      end
+
+      desc 'activate', 'actives a relationship'
+      def active; end
+
+      desc 'deactivate', 'deactivates a relationship'
+      def deactivate; end
+
+      desc 'modify', 'modify an existing relationship'
+      def modify; end
+
+      desc 'delete', 'deletes a relationship'
+      def delete; end
+    end
+  end
+end

data/lib/legion/cli/task.rb

@@ -0,0 +1,49 @@
+module Legion
+  class Cli
+    class Task < Thor
+      package_name 'Legion'
+
+      option :limit, type: :numeric, required: true, default: 10, desc: 'how many tasks to return'
+      desc 'show', 'show'
+      option :status, type: :string, required: false, desc: 'search for specific status'
+      def show
+        Legion::Service.new(cache: false, crypt: false, extensions: false, log_level: 'error')
+        rows = [%w[id relationship function status]]
+        Legion::Data::Model::Task.limit(options[:limit]).order(:id).reverse_each do |row|
+          rows.push([row.values[:id], row.values[:relationship_id], row.values[:function_id], row.values[:status]])
+        end
+
+        print_table rows
+      end
+
+      desc 'test', 'test'
+      def status(id)
+        Legion::Service.new(cache: false, crypt: false, extensions: false, log_level: 'error')
+        say Legion::Data::Model::Task[id].values
+      end
+
+      desc 'logs', 'logs'
+      option :limit, type: :numeric, required: true, default: 10, desc: 'how many tasks to return'
+      def logs(id)
+        Legion::Service.new(cache: false, crypt: false, extensions: false, log_level: 'error')
+        rows = [%w[id node_id created entry]]
+        Legion::Data::Model::TaskLog.where(task_id: id).limit(options[:limit]).each do |row|
+          rows.push([row.values[:id], row.values[:node_id], row.values[:created], row.values[:entry]])
+        end
+        print_table rows
+      end
+
+      desc 'purge', 'purge'
+      def purge
+        Legion::Service.new(cache: false, crypt: false, extensions: false, log_level: 'error')
+        days = ask 'how many days do you want to keep?', default: 7
+        dataset = Legion::Data::Model::Task.where { created < DateTime.now - days.to_i }
+        yes? "This will delete #{dataset.count} tasks, continue?", :red
+        dataset.delete
+        say 'Done!'
+      end
+
+      default_task :show
+    end
+  end
+end

data/lib/legion/cli/trigger.rb

@@ -0,0 +1,88 @@
+module Legion
+  class Cli
+    class Trigger < Thor
+      desc 'queue', 'used to send a job directly to a worker via Legion::Transport'
+      option :extension, type: :string, required: false, desc: 'extension short name'
+      option :runner, type: :string, required: false, desc: 'runner short name'
+      option :function, type: :string, required: false, desc: 'function short name'
+      option :delay, type: :numeric, default: 0, desc: 'how long to wait before running the task'
+      def queue(*args) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+        Legion::Service.new(cache: false, crypt: false, extensions: false, log_level: 'error')
+        include Legion::Extensions::Helpers::Task
+        response = if options['extension'].is_a? String
+                     options[:extension]
+                   else
+                     ask 'trigger extension?', limited_to: Legion::Data::Model::Extension.map(:name)
+                   end
+        trigger_extension = Legion::Data::Model::Extension.where(name: response).first
+        runners = Legion::Data::Model::Runner.where(extension_id: trigger_extension.values[:id])
+        if runners.count == 1
+          trigger_runner = runners.first
+          say "Auto selecting #{trigger_runner.values[:name]} since it is the only option for runners"
+        else
+          response = options[:runner].is_a?(String) ? options[:runner] : ask('trigger runner?', limited_to: runners.map(:name))
+          trigger_runner = Legion::Data::Model::Runner.where(name: response).where(extension_id: trigger_extension.values[:id]).first
+        end
+
+        functions = Legion::Data::Model::Function.where(runner_id: trigger_runner.values[:id])
+
+        if functions.count == 1
+          trigger_function = functions.first
+          say "Auto selecting #{trigger_function.values[:name]} since it is the only option for functions"
+        else
+          response = if options[:function].is_a?(String)
+                       options[:function]
+                     else
+                       ask('trigger function?',
+                           limited_to: Legion::Data::Model::Function.where(runner_id: trigger_runner.values[:id]).map(:name))
+                     end
+          trigger_function = Legion::Data::Model::Function.where(runner_id: trigger_runner.values[:id]).where(name: response).first
+        end
+        say "#{trigger_runner.values[:namespace]}.#{trigger_function.values[:name]} selected as trigger", :green, :italicized
+        payload = {}
+        auto_opts = {}
+        unless args.count.zero?
+          args.each do |arg|
+            test = arg.split(':')
+            auto_opts[test[0].to_sym] = test[1]
+          end
+        end
+
+        Legion::JSON.load(trigger_function.values[:args]).each do |arg, required|
+          next if %w[args payload opts options].include? arg.to_s
+
+          if auto_opts.key? arg
+            payload[arg.to_sym] = auto_opts[arg]
+            next
+          end
+          response = ask "#{required == 'keyreq' ? '[required]' : '[optional]'} #{arg} value:"
+          if response.empty? && required == 'keyreq'
+            say "Error! #{arg} is required and cannot be empty", :red
+            redo
+          end
+          payload[arg.to_sym] = response unless response.empty?
+        end
+
+        status = options[:delay].zero? ? 'task.queued' : 'task.delayed'
+        task = generate_task_id(function_id: trigger_function.values[:id], status: status, runner_id: trigger_runner.values[:id], args: payload,
+delay: options[:delay])
+
+        unless options[:delay].zero?
+          say "Task: #{task[:task_id]} is queued and will be run in #{options[:delay]}s"
+          return true
+        end
+
+        routing_key = "#{trigger_extension.values[:exchange]}.#{trigger_runner.values[:queue]}.#{trigger_function.values[:name]}"
+        exchange = Legion::Transport::Messages::Dynamic.new(function: trigger_function.values[:name], function_id: trigger_function.values[:id],
+routing_key: routing_key, args: payload)
+        exchange.options[:task_id] = task[:task_id]
+        exchange.publish if options[:delay].zero?
+
+        say "Task: #{task[:task_id]} was queued"
+      end
+      remove_command :generate_task_id
+
+      default_task :queue
+    end
+  end
+end

data/lib/legion/cli/version.rb

@@ -0,0 +1,5 @@
+module Legion
+  class Cli
+    VERSION = '0.2.0'.freeze
+  end
+end

data/lib/legion/extensions.rb

@@ -54,6 +54,7 @@ module Legion
             next
           end
           @loaded_extensions.push(extension)
+          sleep(0.1)
         end
         Legion::Logging.info "#{@extensions.count} extensions loaded with subscription:#{@subscription_tasks.count},every:#{@timer_tasks.count},poll:#{@poll_tasks.count},once:#{@once_tasks.count},loop:#{@loop_tasks.count}"
       end
@@ -62,6 +63,21 @@ module Legion
         return unless gem_load(values[:gem_name], extension)
 
         extension = Kernel.const_get(values[:extension_class])
+        if extension.data_required? && Legion::Settings[:data][:connected] == false
+          Legion::Logging.warn "#{values[:extension_name]} requires Legion::Data but isn't enabled, skipping"
+          return false
+        end
+
+        if extension.cache_required? && Legion::Settings[:cache][:connected] == false
+          Legion::Logging.warn "#{values[:extension_name]} requires Legion::Cache but isn't enabled, skipping"
+          return false
+        end
+
+        if extension.vault_required? && Legion::Settings[:crypt][:vault][:connected] == false
+          Legion::Logging.warn "#{values[:extension_name]} requires Legion::Crypt::Vault but isn't enabled, skipping"
+          return false
+        end
+
         has_logger = extension.respond_to?(:log)
         extension.autobuild
 
@@ -109,6 +125,8 @@ module Legion
                                            actor_class.new
                                          end
 
+        return if extension_hash[:running_class].respond_to?(:enabled?) && !extension_hash[:running_class].enabled?
+
         if actor_class.ancestors.include? Legion::Extensions::Actors::Every
           @timer_tasks.push(extension_hash)
         elsif actor_class.ancestors.include? Legion::Extensions::Actors::Once
@@ -136,8 +154,7 @@ module Legion
       end
 
       def gem_load(gem_name, name)
-        gem_path = "#{Gem::Specification.find_by_name(gem_name).gem_dir}/lib/legion/extensions/#{name}"
-        require gem_path
+        require "#{Gem::Specification.find_by_name(gem_name).gem_dir}/lib/legion/extensions/#{name}"
         true
       rescue LoadError => e
         Legion::Logging.error e.message
@@ -148,62 +165,6 @@ module Legion
 
       def find_extensions
         @extensions ||= {}
-        # puts Gem.install('lex-esphome')
-        # puts Gem::Installer.new('lex-esphome')
-        # test = Gem::Installer.new('lex-esphome')
-        # puts test.install
-        # puts Gem::Dependency.new('lex-esphome')
-        # $LOAD_PATH << "#{ENV['GEM_HOME']}/gems/lex-esphome-0.1.0/lib"
-        # require 'legion/extensions/esphome'
-        # $LOAD_PATH << "#{ENV['GEM_HOME']}/gems/lex-esphome-0.1.0/lib"
-        # ENV['MY_RUBY_HOME'] #/Users/miverso2/.rvm/rubies/ruby-2.7.0
-        # ENV['GEM_HOME'] # /Users/miverso2/.rvm/gems/ruby-2.7.0
-        # require 'rubygems/dependency_installer.rb'
-        # puts Gem::DependencyInstaller.new.install('lex-esphome')
-        # puts Gem::Installer.new('lex-esphome').install
-        # puts Gem::Installer.new('lex-esphome').ensure_loadable_spec
-        # puts Gem.search('lex-esphome')
-        # Gem.clear_paths
-        # require 'legion/extensions/esphome'
-
-        # puts Gem.use_gemdeps
-        # pp Gem.gemdeps
-        # puts 'gems things'
-        # puts Gem.loaded_specs.key? 'lex-esphome'
-        # pp Gem.loaded_specs.keys
-        #
-        # require 'rubygems'
-        # require 'rubygems/command.rb'
-        # require 'rubygems/dependency_installer.rb'
-        #
-        # Gem::Command.build_args = ARGV
-        # inst = Gem::DependencyInstaller.new
-        # puts inst.installed_gems
-        # puts inst.install 'lex-esphome', install_as_default: true
-        # puts inst.installed_gems
-        # puts '....'
-        # test = Gem::DependencyList.new
-        # test.add(inst)
-        # pp test.find_name('lex-esphome')
-        # pp test.find_name('lex-logger')
-        # pp test.specs
-        # pp Gem::DependencyList.from_specs
-        # pp Gem::DependencyList.from_specs.key? 'lex-logg'
-        # pp inst
-        #
-        # pp Gem.new.all_specs
-        # load 'legion/extensions/esphome.rb'
-        # puts Gem.register_default_spec()
-        #  :use_gemdeps,
-        #  :detect_gemdeps,
-        #  :source_date_epoch,
-        #  :gemdeps,
-        # :register_default_spec,
-        #  :find_unresolved_default_spec,
-        #  :clear_default_specs,
-        # :loaded_specs,
-        # :default_path,
-
         Gem::Specification.all_names.each do |gem|
           next unless gem[0..3] == 'lex-'
 
@@ -212,12 +173,46 @@ module Legion
                                   gem_name:        "lex-#{lex[1]}",
                                   extension_name:  lex[1],
                                   version:         lex[2],
-                                  extension_class: "Legion::Extensions::#{lex[1].capitalize}" }
+                                  extension_class: "Legion::Extensions::#{lex[1].split('_').collect(&:capitalize).join}" }
+        end
+
+        enabled = 0
+        requested = 0
+
+        Legion::Settings[:extensions].each do |extension, values|
+          next if @extensions.key? extension.to_s
+          next if values[:enabled] == false
+
+          requested += 1
+          next if values[:auto_install] == false
+          next if ENV['_'].include? 'bundle'
+
+          Legion::Logging.warn "#{extension} is missing, attempting to install automatically.."
+          install = Gem.install("lex-#{extension}", values[:version])
+          Legion::Logging.debug(install)
+          lex = Gem::Specification.find_by_name("lex-#{extension}")
+
+          @extensions[extension.to_s] = {
+            full_gem_name:   "lex-#{extension}-#{lex.version}",
+            gem_name:        "lex-#{extension}",
+            extension_name:  extension.to_s,
+            version:         lex.version,
+            extension_class: "Legion::Extensions::#{extension.to_s.split('_').collect(&:capitalize).join}"
+          }
+
+          enabled += 1
+
+        rescue StandardError, Gem::MissingSpecError => e
+          Legion::Logging.error "Failed to auto install #{extension}, e: #{e.message}"
         end
+        return true if requested == enabled
 
-        # Legion::Settings[:extensions].each do |extension|
-        #   puts extension unless @extensions.key? extension
-        # end
+        Legion::Logging.warn "A total of #{requested - enabled} where skipped"
+        if ENV['_'].include?('bundle')
+          Legion::Logging.warn 'Please add them to your Gemfile since you are using bundler'
+        else
+          Legion::Logging.warn 'You must have auto_install_missing_lex set to true to auto install missing extensions'
+        end
       end
     end
   end

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

@@ -1,5 +1,3 @@
-require 'hashdiff'
-
 module Legion
   module Extensions
     module Actors

data/lib/legion/extensions/actors/poll.rb

@@ -1,5 +1,4 @@
 require_relative 'base'
-require 'hashdiff'
 require 'time'
 
 module Legion

data/lib/legion/extensions/actors/subscription.rb

@@ -12,6 +12,7 @@ module Legion
         def initialize(**_options)
           super()
           @queue = queue.new
+          @queue.channel.prefetch(prefetch) if defined? prefetch
         rescue StandardError => e
           log.fatal e.message
           log.fatal e.backtrace

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

@@ -20,6 +20,7 @@ module Legion
             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,
@@ -30,6 +31,10 @@ module Legion
               class_methods:   {}
             }
 
+            if settings.key?(:runners) && settings[:runners].key?(runner_name.to_sym)
+              @runners[runner_name.to_sym][:desc] = settings[:runners][runner_name.to_sym][:desc]
+            end
+
             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

data/lib/legion/extensions/core.rb

@@ -39,7 +39,7 @@ module Legion
         @messages = {}
         build_settings
         build_transport
-        build_data
+        build_data if Legion::Settings[:data][:connected] && data_required?
         build_helpers
         build_runners
         build_actors
@@ -61,9 +61,13 @@ module Legion
         false
       end
 
+      def vault_required?
+        false
+      end
+
       def build_data
         auto_generate_data
-        extension_class::Data.build
+        lex_class::Data.build
       end
 
       def build_transport
@@ -117,9 +121,10 @@ module Legion
       def auto_generate_data
         require 'legion/extensions/data'
         log.debug 'running meta magic to generate a data base class'
-        return if Kernel.const_defined? "#{lex_class}::Data"
-
         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

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

@@ -8,7 +8,7 @@ module Legion
         alias extension_class lex_class
 
         def lex_name
-          @lex_name ||= calling_class_array[2].gsub(/(?<!^)[A-Z]/) { "_#{$&}" }.downcase
+          @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
@@ -30,7 +30,7 @@ module Legion
         end
 
         def actor_name
-          @actor_name ||= calling_class_array.last.gsub(/(?<!^)[A-Z]/) { "_#{$&}" }.downcase
+          @actor_name ||= calling_class_array.last.gsub(/(?<!^)[A-Z]/) { "_#{Regexp.last_match(0)}" }.downcase
         end
 
         def actor_const
@@ -42,7 +42,7 @@ module Legion
         end
 
         def runner_name
-          @runner_name ||= runner_class.to_s.split('::').last.gsub(/(?<!^)[A-Z]/) { "_#{$&}" }.downcase
+          @runner_name ||= runner_class.to_s.split('::').last.gsub(/(?<!^)[A-Z]/) { "_#{Regexp.last_match(0)}" }.downcase
         end
 
         def runner_const

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

@@ -5,6 +5,34 @@ module Legion
         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)
@@ -12,7 +40,7 @@ module Legion
         end
 
         def default_settings
-          { logger: { level: 'info' }, workers: 1 }
+          { logger: { level: 'info' }, workers: 1, runners: {}, functions: {} }
         end
       end
     end