legionio 0.3.2 → 0.4.1

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
@@ -158,13 +176,19 @@ module Legion
                                   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}")
+          install = Gem.install("lex-#{extension}", values[:version])
           Legion::Logging.debug(install)
           lex = Gem::Specification.find_by_name("lex-#{extension}")
 
@@ -176,9 +200,19 @@ module Legion
             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::Logging.warn "A total of #{requested - enabled} where skipped"
+        if ENV.key?('_') && 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/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/logger.rb

@@ -2,22 +2,19 @@ module Legion
   module Extensions
     module Helpers
       module Logger
-        def log # rubocop:disable Metrics/AbcSize
+        def log
           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[:level] = settings[:logger].key?(:level) ? settings[:logger][:level] : 'info'
+            logger_hash[:log_file] = settings[:logger][:log_file] if 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

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

@@ -30,7 +30,7 @@ module Legion
               return true
             end
           rescue StandardError => e
-            log.warn("task_update failed, reverting to rmq message, e: #{e.message}")
+            log.debug("task_update failed, reverting to rmq message, e: #{e.message}")
           end
 
           update_hash = { task_id: task_id, status: status }

data/lib/legion/lex.rb

@@ -0,0 +1,89 @@
+require 'thor'
+require 'legion/cli/version'
+require 'legion/cli/lex/actor'
+require 'legion/cli/lex/exchange'
+require 'legion/cli/lex/message'
+require 'legion/cli/lex/queue'
+require 'legion/cli/lex/runner'
+
+module Legion
+  class Cli
+    class LexBuilder < Thor
+      check_unknown_options!
+      include Thor::Actions
+
+      no_commands do
+        def lex
+          Dir.pwd.split('/').last.split('-').last
+        end
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      desc 'actor', 'creates and manages actors'
+      subcommand 'actor', Legion::Cli::Lex::Actor
+
+      desc 'exchange', 'creates and manages exchanges'
+      subcommand 'exchange', Legion::Cli::Lex::Exchange
+
+      desc 'messages', 'creates and manages messages'
+      subcommand 'message',  Legion::Cli::Lex::Message
+
+      desc 'queue', 'creates and manages queues'
+      subcommand 'queue', Legion::Cli::Lex::Queue
+
+      desc 'runner', 'creates and manages runners'
+      subcommand 'runner', Legion::Cli::Lex::Runner
+
+      desc 'version', 'Display Version'
+      map %w[-v --version] => :version
+      def version
+        say "Legion::CLI #{Legion::Cli::VERSION}"
+      end
+
+      method_option rspec: true
+      method_option pipeline: true
+      method_option git_init: true
+      method_option bundle_install: true
+      desc 'create :name', 'creates a new lex'
+      def create(name)
+        if Dir.pwd.include?('lex-')
+          say('already inside a lex_gen, try moving to a different directory', :red)
+          return nil
+        end
+
+        vars = { filename: "lex-#{name}", class_name: name.capitalize, lex: name }
+        filename = vars[:filename]
+        template('cli/lex/templates/base/gemspec.erb', "#{filename}/#{filename}.gemspec", vars)
+        template('cli/lex/templates/base/gemfile.erb', "#{filename}/Gemfile", vars)
+        template('cli/lex/templates/base/gitignore.erb', "#{filename}/.gitignore", vars)
+        template('cli/lex/templates/base/lic.erb', "#{filename}/LICENSE.txt", vars)
+        template('cli/lex/templates/base/rakefile.erb', "#{filename}/Rakefile", vars)
+        template('cli/lex/templates/base/rubocop.yml.erb', "#{filename}/.rubocop.yml", vars)
+        template('cli/lex/templates/base/readme.md.erb', "#{filename}/README.md", **vars)
+        template('cli/lex/templates/base/lex.erb', "#{filename}/lib/legion/extensions/#{name}.rb", vars)
+        template('cli/lex/templates/base/version.erb', "#{filename}/lib/legion/extensions/#{name}/version.rb", vars)
+        template('cli/lex/templates/base/bitbucket.yml.erb', "#{filename}/bitbucket-pipelines.yml", vars) if options[:pipeline]
+        template('cli/lex/templates/base/spec_helper.rb.erb', "#{filename}/spec/spec_helper.rb", vars)
+        template('cli/lex/templates/base/lex_spec.erb', "#{filename}/spec/legion/#{name}_spec.rb", vars)
+
+        return if !options[:git_init] && !options[:bundle_install]
+
+        run("cd lex_gen-#{filename}")
+        if options[:git_init]
+          run('git init')
+          run('git add .')
+          run('git commit -m \'Initial commit\'')
+        end
+
+        run('bundle update') if options[:bundle_install]
+      end
+    end
+  end
+end