minfra-cli 1.13.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a51109711adec2427362f6dd5b9721cbb86f7e9ee740a83155b93d2919a3f28
-  data.tar.gz: 1772e50a23ac6503f793c7569faf3d412101f8b171e99abe80e6aca35f983c39
+  metadata.gz: a3935821334bdae6ba17cf1073ab2f45e0dcae4587bb1483d833bd1fb6106672
+  data.tar.gz: 99c16f2c6eb5debdeb83e1c25356cae7c1c2e2b48d58805897c50b20968d608e
 SHA512:
-  metadata.gz: 4bd36e1f60ff64a284236a9d41bd125461b1b583eab989836138277d24963a099e49bc8dd715f912089ea1ac8516dee2dbe019f8642382628be0af276a039be7
-  data.tar.gz: a9f36abba93f8a7ef2fc865f50f116f38a7db7daceeae1ac5a2ec46e275ee1afe5859a4f3aa512158a21c5b6b16de9882ad7b4db01a4d2f895cca570d2d86e1b
+  metadata.gz: 0fcb53d62afde75285eb6e7f5d9fd29eeb196cd2872f29be992272e2584e508486bf645f6b1a5f180af965817a3de7e8b07e6115add457b6d6d49c29d7fcf4fb
+  data.tar.gz: e05c55fc240b2e40c6b9c5796988cc42522f0c7c64c9bf4927f9206601ccd0da174f9338c302dfc91964db0b4639242f4b1a64a11d227eae7348ac8df70a1873

data/.github/workflows/ruby.yml

@@ -9,7 +9,6 @@ name: Ruby
 
 on:
   push:
-    branches: [ $default-branch ]
   pull_request:
     branches: [ $default-branch ]
 
@@ -22,7 +21,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.6', '2.7', '3.0']
+        ruby-version: ['3.1','3.2']
 
     steps:
     - uses: actions/checkout@v3

data/.rubocop.yml

@@ -0,0 +1,31 @@
+---
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  Exclude:
+    - '/**/schema.rb'
+Layout/LineLength:
+  Max: 200
+Metrics/AbcSize:
+  Enabled: false
+
+# disabling it our stack.rb files have big blocks
+Metrics/BlockLength:
+  Enabled: false
+Metrics/MethodLength:
+  Max: 25
+Style/Documentation:
+  Enabled: false
+Style/OpenStructUse:
+  Enabled: false
+# we use extensive blocks for openings and closing connections, give us more room (3 -> 5)
+Metrics/BlockNesting:
+  Max: 5
+
+# we have params like "op","in", ... but not shorter than that please
+Naming/MethodParameterName:
+  MinNameLength: 2
+
+# we have full controll over versions, we don't need this check
+Gemspec/RequiredRubyVersion:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,22 @@
+# 2.0.0
+ Incompatibility
+ * dropping ruby < 3.1 support
+ * config: NO support for "environment" specific overrides in configs, use hiera
+ * only allow to deploy stacks which are in env.roles, env.stacks or project:default_stacks
+ * Minfra::Cli.env not supported
+
+ Refactorings/Features 
+ * refactoring Cli to CliStarter
+ * refactoring Cli to HierLooker
+ * support for argv_file to run commands from a file
+ * tests: more of them
+ * new command: dev envs
+ * new Kernel method: minfra_cli which is the CliStarter Object
+
+# 1.13.3
+ * BUG: fixing 'labelÄ
 # 1.13.2
- * BUG: fixing generic secret
+ * BUG: fixing 'generic_secret'
 # 1.13.1
  * BUG: not every deployer contexts have cleanups
 # 1.13.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    minfra-cli (1.12.0)
+    minfra-cli (2.0.0)
       activesupport (= 7.0.7.2)
       erubis (~> 2.7)
       hashie (~> 3.5)

data/README.md

@@ -3,7 +3,19 @@
 Is a KIND (k8s in docker) based development environment.
 
 
-## Setup
+## Setup/Configuration/Global options
+
+
+| Description | Environment variable | Project key | Global commandline arguments | Hiera key |
+| --- | --- | --- | --- | --- |
+|   | MINFRA_NAME          | name                  |                                              |   |
+|   | MINFRA_PATH          |                       | --minfra_path [PATH TO MINFRA_PROJECT]       |   |
+|   | MINFRA_ENVIRONMENT   |                       | -e [ENV]                                     |   |
+|   | MINFRA_ARGV_FILE     |                       | --minfra_argv_file [PATH TO A CSV FILE FILE] |   |
+|   | MINFRA_LOGGING_LEVEL | minfra.logging_level  |                                              |   |
+|   |                      | minfra.hiera.env_path |                                              |   |
+|   |                      | default_stacks        |                                              | env.stacks | env.roles   |
+
 
 ## Expected hiera data
 

data/exe/minfra

@@ -3,6 +3,4 @@
 $LOAD_PATH << File.expand_path('../lib', __dir__)
 require 'minfra/cli'
 
-Minfra::Cli.init(ARGV)
-Minfra::Cli.run
-
+exit Minfra::Cli.exec(ARGV)

data/lib/deep_merge.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Hashie
   module Extensions
     module DeepMergeConcat
-
       def transform_values
         result = self.class.new
         each do |key, value|
@@ -31,82 +32,83 @@ module Hashie
         self
       end
 
-      def deep_sort_by_key_and_sort_array(exclusions = [], &block)
-        self.keys.sort(&block).reduce({}) do |seed, key|
+      def deep_sort_by_key_and_sort_array(exclusions = [], &)
+        keys.sort(&).each_with_object({}) do |key, seed|
           seed[key] = self[key]
-          unless exclusions.include?(key.to_s)
-            if seed[key].is_a?(Hash)
-              seed[key] = seed[key].deep_sort_by_key_and_sort_array(exclusions, &block)
-            elsif seed[key].is_a?(Hashie::Array)
-              seed[key] = seed[key].sort(&block)
-            end
+          next if exclusions.include?(key.to_s)
+
+          case seed[key]
+          when Hash
+            seed[key] = seed[key].deep_sort_by_key_and_sort_array(exclusions, &)
+          when Hashie::Array
+            seed[key] = seed[key].sort(&)
           end
-          seed
         end
       end
 
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
-      def deep_sort(&block)
+      def deep_sort(&)
         copy = dup
         copy.extend(Hashie::Extensions::DeepMergeConcat) unless copy.respond_to?(:deep_sort!)
-        copy.deep_sort!(&block)
+        copy.deep_sort!(&)
       end
 
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       # Modifies the receiver in place.
-      def deep_sort!(&block)
-        _recursive_sort(self, &block)
+      def deep_sort!(&)
+        _recursive_sort(self, &)
         self
       end
 
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
-      def deep_merge_concat(other_hash, &block)
+      def deep_merge_concat(other_hash, &)
         copy = dup
         copy.extend(Hashie::Extensions::DeepMergeConcat) unless copy.respond_to?(:deep_merge_concat!)
-        copy.deep_merge_concat!(other_hash, &block)
+        copy.deep_merge_concat!(other_hash, &)
       end
 
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       # Modifies the receiver in place.
-      def deep_merge_concat!(other_hash, &block)
+      def deep_merge_concat!(other_hash, &)
         return self unless other_hash.is_a?(::Hash)
-        _recursive_merge_concat(self, other_hash, &block)
+
+        _recursive_merge_concat(self, other_hash, &)
         self
       end
 
-      def deep_transform_values(&block)
-        _deep_transform_values_in_object(self, &block)
+      def deep_transform_values(&)
+        _deep_transform_values_in_object(self, &)
       end
 
-      def deep_transform_values!(&block)
-        _deep_transform_values_in_object!(self, &block)
+      def deep_transform_values!(&)
+        _deep_transform_values_in_object!(self, &)
       end
 
       private
 
-      def _deep_transform_values_in_object(object, &block)
+      def _deep_transform_values_in_object(object, &)
         case object
         when Hash
           object.each_with_object({}) do |arg, result|
             key = arg.first
             value = arg.last
-            result[key] = _deep_transform_values_in_object(value, &block)
+            result[key] = _deep_transform_values_in_object(value, &)
           end
         when Array
-          object.map {|e| _deep_transform_values_in_object(e, &block) }
+          object.map { |e| _deep_transform_values_in_object(e, &) }
         else
           yield(object)
         end
       end
 
-      def _deep_transform_values_in_object!(object, &block)
+      def _deep_transform_values_in_object!(object, &)
         case object
         when Hash
           object.each do |key, value|
-            object[key] = _deep_transform_values_in_object!(value, &block)
+            object[key] = _deep_transform_values_in_object!(value, &)
           end
         when Array
-          object.map! {|e| _deep_transform_values_in_object!(e, &block) }
+          object.map! { |e| _deep_transform_values_in_object!(e, &) }
         else
           yield(object)
         end
@@ -115,31 +117,28 @@ module Hashie
       def _recursive_sort(object, &block)
         case object
         when Hash
-          object = Orchparty::AST::Node.new(object.sort {|a, b| block.call(a[0], b[0]) }.to_h)
+          object = Orchparty::AST::Node.new(object.sort { |a, b| block.call(a[0], b[0]) }.to_h)
           object.each do |key, value|
             object[key] = _recursive_sort(value, &block)
           end
           object
         when Array
-          object.map! {|e| _recursive_sort(e, &block) }.sort(&block)
+          object.map! { |e| _recursive_sort(e, &block) }.sort(&block)
         else
           yield(object)
         end
       end
 
-
       def _recursive_merge_concat(hash, other_hash, &block)
         other_hash.each do |k, v|
           hash[k] = if hash.key?(k) && hash[k].is_a?(::Hash) && v.is_a?(::Hash)
                       _recursive_merge(hash[k], v, &block)
                     elsif hash.key?(k) && hash[k].is_a?(::Array) && v.is_a?(::Array)
                       hash[k].concat(v).uniq
+                    elsif hash.key?(k) && block_given?
+                      block.call(k, hash[k], v)
                     else
-                      if hash.key?(k) && block_given?
-                        block.call(k, hash[k], v)
-                      else
-                        v.respond_to?(:deep_dup) ? v.deep_dup : v
-                      end
+                      v.respond_to?(:deep_dup) ? v.deep_dup : v
                     end
         end
         hash

data/lib/hash.rb

@@ -1,28 +1,29 @@
+# frozen_string_literal: true
+
 class HashUtils
-  def self.transform_hash(original, options={}, &block)
-    original.inject({}){|result, (key,value)|
-      value = if (options[:deep] && Hash === value)
+  def self.transform_hash(original, options = {}, &block)
+    original.each_with_object({}) do |(key, value), result|
+      value = if options[:deep] && value.is_a?(Hash)
                 transform_hash(value, options, &block)
-              else
-                if Array === value
-                  value.map{|v|
-                    if Hash === v
-                      transform_hash(v, options, &block)
-                    else
-                      v
-                    end}
-                else
-                  value
+              elsif value.is_a?(Array)
+                value.map do |v|
+                  if v.is_a?(Hash)
+                    transform_hash(v, options, &block)
+                  else
+                    v
+                  end
                 end
+              else
+                value
               end
-      block.call(result,key,value)
-      result
-    }
+      block.call(result, key, value)
+    end
   end
+
   # Convert keys to strings, recursively
   def self.deep_stringify_keys(hash)
-    transform_hash(hash, :deep => true) {|hash, key, value|
+    transform_hash(hash, deep: true) do |hash, key, value|
       hash[key.to_s] = value
-    }
+    end
   end
 end

data/lib/minfra/cli/ask.rb

@@ -1,42 +1,44 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     module Ask
       def self.boolean(question)
         answered = false
         until answered
-          STDOUT.write "#{question} (y/n)"
-          answer = STDIN.gets.chomp
-          if ['y', 'n'].include?(answer)
+          $stdout.write "#{question} (y/n)"
+          answer = $stdin.gets.chomp
+          if %w[y n].include?(answer)
             answered = true
           else
-            STDOUT.write("I just understand 'y' and 'n', again: ")
+            $stdout.write("I just understand 'y' and 'n', again: ")
           end
         end
         answer == 'y'
       end
 
-      def self.text(question, default=nil)
-        begin
+      def self.text(question, default = nil)
+        loop do
           message = format('%s%s: ', question, default && " (#{default})")
-          STDOUT.write message
-          answer = STDIN.gets.chomp
+          $stdout.write message
+          answer = $stdin.gets.chomp
           answer = default if answer == ''
-        end while answer.nil?
+          break unless answer.nil?
+        end
         answer
       end
 
-      def self.placeholders(templater,placeholders={})
+      def self.placeholders(templater, placeholders = {})
         templater.check_missing do |name|
-          placeholders[name]=self.text("I need a value for: #{name}") unless placeholders[name]
+          placeholders[name] = text("I need a value for: #{name}") unless placeholders[name]
         end
         placeholders
       end
 
-      def self.interactive_template(template_file, out_file, placeholders={})
-        templater=Templater.new(File.read(template_file))
-        params=self.placeholders(templater,placeholders)
-        File.write(out_file,templater.render(params))
-
+      def self.interactive_template(template_file, out_file, placeholders = {})
+        templater = Templater.new(File.read(template_file))
+        params = self.placeholders(templater, placeholders)
+        File.write(out_file, templater.render(params))
       end
     end
   end

data/lib/minfra/cli/cli_starter.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Minfra
+  module Cli
+    class CliStarter
+      attr_reader :options, :argv, :plugins, :config, :env_name, :base_path, :logger, :hiera, :envs, :env
+
+      def minfrarc_loaded?
+        @minfrarc_loaded
+      end
+
+      def minfrarc_me_loaded?
+        @minfrarc_me_loaded
+      end
+
+      def initialize(argv)
+        @argv = argv
+        @options = {} # base_path, env, argv_file
+        @minfrarc_loaded = false
+        @minfrarc_me_loaded = false
+
+        parse_global_options
+
+        @base_path = Pathname.new(@options[:base_path] || ENV.fetch('MINFRA_PATH', nil)).expand_path
+        @env_name = @options[:env] || ENV['MINFRA_ENVIRONMENT'] || 'dev'
+        init_config
+
+        init_logger
+
+        @logger.debug("Minfra: loglevel: #{@logger.level}, env: #{@config.orch_env}")
+
+        init_minfrarc
+        init_envs
+        init_hiera
+        init_plugins
+
+        register_subcommands
+        
+        install # don't like this, but some plugins need the lookup....not good
+        @plugins.setup
+        require_relative 'main_command'
+
+        setup_subcommands
+      end
+
+      def run
+        exit_code = 0
+        if @options[:argv_file]
+          CSV.foreach(@options[:argv_file]) do |row|
+            args = @argv + row
+            @logger.debug("Running (#{env_name}): #{args.join(' ')} ")
+            begin
+              Minfra::Cli::Main.start(args)
+            rescue StandardError # esp. Minfra::Cli::Errors::ExitError !
+              exit_code = 1
+            end
+          end
+          @logger.debug('Done argv_file loop')
+        else
+          begin
+            Minfra::Cli::Main.start(@argv)
+          rescue Minfra::Cli::Errors::ExitError
+            exit_code = 1
+          end
+        end
+        exit_code
+      end
+
+      def install
+        cli = self
+        Kernel.define_method(:minfra_cli) do
+          cli
+        end
+        Kernel.define_method(:l) do |key, default = nil|
+          minfra_cli.hiera.l(key, default)
+        end
+        Kernel.define_method(:l!) do |key, default = nil|
+          minfra_cli.hiera.l!(key, default)
+        end
+      end
+      private
+
+      def root_path
+        Pathname.new(File.expand_path(File.join(__FILE__, '../../../..')))
+      end
+
+      # will parse -e, --argv_file, --
+      def parse_global_options
+        @options = {}
+        if (idx = @argv.index('-e'))
+          @options[:env] = @argv[idx + 1]
+          @argv.delete_at(idx)
+          @argv.delete_at(idx)
+        end
+
+        if (idx = argv.index('--minfra_argv_file'))
+          @options[:argv_file] = @argv[idx + 1]
+          @argv.delete_at(idx)
+          @argv.delete_at(idx)
+        end
+
+        if (idx = argv.index('--minfra_path'))
+          @options[:base_path] = @argv[idx + 1]
+          @argv.delete_at(idx)
+          @argv.delete_at(idx)
+        end
+
+        @options
+      end
+
+      def init_minfrarc
+        # load minfrarc for configs
+        project_minfrarc_path = @config.base_path.join('config', 'minfrarc.rb')
+        if project_minfrarc_path.exist?
+          require project_minfrarc_path
+          @minfrarc_loaded = true
+        end
+
+        # load
+        me_minfrarc_path = @config.me_path.join('minfrarc.rb')
+        return unless me_minfrarc_path.exist?
+
+        require @me_minfrarc_path
+        @minfrarc_me_loaded = true
+      end
+
+      def init_plugins
+        @plugins = Minfra::Cli::Plugins.load(@base_path)
+        @plugins.prepare
+      end
+
+      def init_logger
+        @logger = Logger.new($stderr)
+        @logger.level = ENV['MINFRA_LOGGING_LEVEL'] || @config.project.dig(:minfra, :logging_level) || 'warn'
+        Minfra::Cli.logger = @logger
+      end
+
+      def init_config
+        @config = Config.new(@base_path, @env_name || 'dev')
+        Minfra::Cli.config = @config
+      end
+
+      def init_hiera
+        @hiera = @env.hiera
+      end
+      
+      def init_envs
+        @envs={}
+        env_path = config.project.dig(:minfra, :hiera, :env_path) || 'environments'
+        root = base_path.join('hiera')
+        root.join('hieradata',env_path).glob('*.eyaml').sort.each do |path|
+          env_name = path.basename.sub(/(\..+)/,'').to_s
+          @envs[env_name]=Env.new(hiera_root: root, hiera_env_path: env_path, name: env_name)
+        end
+        @env = @envs[@env_name] # set the current env
+      end
+
+      def register_subcommands
+        # they will call back Minfra::Cli.register
+        root_path.join('lib/minfra/cli/commands').each_child do |command_path|
+          require command_path if command_path.to_s.match(/\.rb$/) && !command_path.to_s.match(/\#/)
+        end
+      end
+
+      def setup_subcommands
+        Minfra::Cli.subcommands.each_value do |sub|
+          Minfra::Cli::Main.desc(sub.name, sub.info)
+          Minfra::Cli::Main.subcommand(sub.name, sub.command)
+        end
+      end
+    end
+  end
+end

data/lib/minfra/cli/command.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     class Command < Thor
@@ -5,9 +7,10 @@ module Minfra
       include Logging
 
       private
+
       def minfra_config
         Minfra::Cli.config
-      end  
+      end
     end
   end
 end

data/lib/minfra/cli/commands/dev.rb

@@ -1,54 +1,65 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 module Minfra
   module Cli
     class Dev < Command
-
-      desc "describe", "get some info about your config (if it's setup)"
+      desc 'describe', "get some info about your config (if it's setup)"
       option :environment, required: false, aliases: ['-e']
       def describe
         pp minfra_config.describe(options[:environment])
       end
 
-      desc "create", "create your development cluster"
+      desc 'create', 'create your development cluster'
       def create
         kube.create
       end
 
-      desc "upgrade", "upgrade kind (moves previous configs and recreates the cluster; use it if you made changes to config/kind.yaml.erb)"
+      desc 'upgrade',
+           'upgrade kind (moves previous configs and recreates the cluster; use it if you made changes to config/kind.yaml.erb)'
       def upgrade
-        info "Destroying existing dev cluster.."
+        info 'Destroying existing dev cluster..'
         destroy
-        Runner.run("mv #{minfra_config.base_path.join('me','kind.yaml.erb')} #{minfra_config.base_path.join('me','kind_old_' + Time.now.strftime("%Y_%m_%dT%H_%M_%SZ") + '.yaml.erb')}", print_stdout: true)
-        Runner.run("mv #{minfra_config.base_path.join('me', 'kube', 'config')} #{minfra_config.base_path.join('me', 'kube', 'config_old_' + Time.now.strftime("%Y_%m_%dT%H_%M_%SZ"))}", print_stdout: true)
+        Runner.run(
+          "mv #{minfra_config.base_path.join('me',
+                                             'kind.yaml.erb')} #{minfra_config.base_path.join('me', "kind_old_#{Time.now.strftime('%Y_%m_%dT%H_%M_%SZ')}.yaml.erb")}", print_stdout: true
+        )
+        Runner.run(
+          "mv #{minfra_config.base_path.join('me', 'kube',
+                                             'config')} #{minfra_config.base_path.join('me', 'kube', "config_old_#{Time.now.strftime('%Y_%m_%dT%H_%M_%SZ')}")}", print_stdout: true
+        )
         Runner.run('yes | minfra setup dev', print_stdout: true) # On an existing cluster this should only ask for recreating the files that we moved previously
-        info "Creating a new dev cluster.."
+        info 'Creating a new dev cluster..'
         create
-        info "I am done upgrading the dev cluster! 🎉"
+        info 'I am done upgrading the dev cluster! 🎉'
       end
 
-      desc "restart", "restart your development cluster"
+      desc 'restart', 'restart your development cluster'
       def restart
         kube.restart
       end
 
-      desc "start", "start your development cluster"
+      desc 'start', 'start your development cluster'
       def start
         restart
       end
 
-      desc "destroy", "tear down your development cluster"
+      desc 'destroy', 'tear down your development cluster'
       def destroy
         kube.destroy_dev_cluster
       end
 
+      desc 'envs', 'list all environments'
+      def envs
+        puts minfra_cli.envs.keys.join(', ')
+      end
       private
 
       def kube
-        @kube ||= Kube.new(options,minfra_config)
+        @kube ||= Kube.new(options, minfra_config)
       end
-
     end
   end
 end
 
-Minfra::Cli.register("dev", "Manage your dev cluster.", Minfra::Cli::Dev)
+Minfra::Cli.register('dev', 'Manage your dev cluster.', Minfra::Cli::Dev)