minfra-cli 1.13.2 → 2.0.0

data/lib/minfra/cli/hiera_looker.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Minfra
+  module Cli
+    class HieraLooker
+      def initialize(root:, env_name:, env_path:)
+        @root = Pathname.new(root)
+        @env_name = env_name
+        @cache = {}
+
+        @hiera = Hiera.new(config: @root.join('hiera.yaml').to_s)
+        Hiera.logger = :noop
+
+        hiera_main_path = @root.join("hieradata/#{env_path}/#{env_name}.eyaml")
+
+        raise("unknown environment #{@env_name}, I expect a file at #{hiera_main_path}") unless hiera_main_path.exist?
+
+        scope = { 'hieraroot' => @root.to_s, 'env' => @env_name }
+
+        @special_lookups = @hiera.lookup('lookup_options', {}, scope, nil, :priority)
+        
+        node_scope = @hiera.lookup('env', {}, scope, nil, :deeper)
+        @scope = scope.merge(node_scope)
+      end
+
+      def l(value, default = nil)
+#        debugger if @env_name == 'production-management' && value == 'env.tags'
+        return @cache[value] if @cache.key?(value)
+
+        values = value.split('.')
+        fst_value = values.shift
+
+        lookup_type = if @special_lookups[fst_value]
+                        { merge_behavior: @special_lookups[fst_value]['merge'].to_sym }
+                      else
+                        :deep
+                      end
+        result = @hiera.lookup(fst_value, default, @scope, nil, lookup_type)
+        result = result.dig(*values) if !values.empty? && result.is_a?(Hash) # we return nil or the scalar value and only drill down on hashes
+        result = default if result.nil?
+        result = Hashie::Mash.new(result) if result.is_a?(Hash)
+        @cache[value] = result
+        result
+      end
+
+      def l!(value, default = nil)
+        v = l(value, default)
+        raise("Value not found! #{value}") if v.nil?
+        v
+      end
+      
+    end
+  end
+end

data/lib/minfra/cli/hook.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # no support for around hooks yet
 
 class Thor
@@ -8,20 +10,25 @@ class Thor
       if private_method?(instance)
         instance.class.handle_no_command_error(name)
       elsif public_method?(instance)
-        hooks=instance.instance_variable_get(:@_invocations).values.flatten
+        hooks = instance.instance_variable_get(:@_invocations).values.flatten
         arity = instance.method(name).arity
-        Minfra::Cli.call_before_hooks(instance,hooks)
+        Minfra::Cli.call_before_hooks(instance, hooks)
         instance.__send__(name, *args)
-        Minfra::Cli.call_after_hooks(instance,hooks)
+        Minfra::Cli.call_after_hooks(instance, hooks)
       elsif local_method?(instance, :method_missing)
-        #Minfra::Cli.call_before_hooks(instance,hooks)
+        # Minfra::Cli.call_before_hooks(instance,hooks)
         instance.__send__(:method_missing, name.to_sym, *args)
-        #Minfra::Cli.call_after_hooks(instance,hooks)
+        # Minfra::Cli.call_after_hooks(instance,hooks)
       else
         instance.class.handle_no_command_error(name)
       end
     rescue ArgumentError => e
-      handle_argument_error?(instance, e, caller) ? instance.class.handle_argument_error(self, e, args, arity) : (raise e)
+      if handle_argument_error?(instance, e,
+                                caller)
+        instance.class.handle_argument_error(self, e, args, arity)
+      else
+        (raise e)
+      end
     rescue NoMethodError => e
       handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (raise e)
     end
@@ -33,16 +40,16 @@ module Minfra
     module Hook
       class Hook
         def initialize(type, names, block)
-          @type=type
-          @names=names
-          @block=block
+          @type = type
+          @names = names
+          @block = block
         end
 
         def match?(type, names)
-         @type == type && @names == names.map(&:to_sym)
+          @type == type && @names == names.map(&:to_sym)
         end
 
-        def exec (obj)
+        def exec(obj)
           obj.instance_eval(&@block)
         end
       end
@@ -50,8 +57,8 @@ module Minfra
       class Hooker
         include Logging
         def initialize(klass)
-          @klass=klass
-          @hooks=[]
+          @klass = klass
+          @hooks = []
         end
 
         def register_before(names, block)
@@ -63,16 +70,16 @@ module Minfra
         end
 
         def call_before_hooks(obj, names)
-          @hooks.select do |h| h.match?(:before, names) end.each do |h| 
+          @hooks.select { |h| h.match?(:before, names) }.each do |h|
             debug("Hook before: #{names.join(',')}")
-            h.exec(obj) 
+            h.exec(obj)
           end
         end
 
-        def call_after_hooks(obj,names)
-          @hooks.select do |h| h.match?(:after, names) end.each do |h| 
+        def call_after_hooks(obj, names)
+          @hooks.select { |h| h.match?(:after, names) }.each do |h|
             debug("Hook  after: #{names.join(',')}")
-            h.exec(obj) 
+            h.exec(obj)
           end
         end
       end
@@ -82,21 +89,26 @@ module Minfra
       end
 
       module ClassMethods
-        def after_hook(*names,&block)
+        def after_hook(*names, &block)
           hooks.register_after(names, block)
         end
+
         def before_hook(*names, &block)
           hooks.register_before(names, block)
         end
-        def call_before_hooks(obj,names)
-          hooks.call_before_hooks(obj,names)
+
+        def call_before_hooks(obj, names)
+          hooks.call_before_hooks(obj, names)
         end
-        def call_after_hooks(obj,names)
-          hooks.call_after_hooks(obj,names)
+
+        def call_after_hooks(obj, names)
+          hooks.call_after_hooks(obj, names)
         end
+
         private
+
         def hooks
-          @hooks||=Hooker.new(self)
+          @hooks ||= Hooker.new(self)
         end
       end
     end

data/lib/minfra/cli/kubectl_runner.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     class KubeCtlRunner < Runner
       def initialize(cmd, **args)
-        insecure_flag = l("infra::allow_insecure_k8s_connections") ? "--insecure-skip-tls-verify" : ""
+        insecure_flag = l('infra::allow_insecure_k8s_connections') ? '--insecure-skip-tls-verify' : ''
         cmd = "kubectl #{insecure_flag} #{cmd}"
         super(cmd, **args)
       end

data/lib/minfra/cli/logging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     module Logging
@@ -7,7 +9,7 @@ module Minfra
 
       def exit_error(str)
         error str
-        exit 1
+        raise Minfra::Cli::Errors::ExitError, str
       end
 
       def info(str)
@@ -25,7 +27,9 @@ module Minfra
       def deprecated(comment)
         logger.warn "DEPRECATED: #{comment}"
       end
+
       private
+
       def logger
         Minfra::Cli.logger
       end

data/lib/minfra/cli/main_command.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     class Main < Command
-
       desc 'kube', 'kubectl wrapper and other features'
       option :cluster
       option :stack, required: true

data/lib/minfra/cli/plugin.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Minfra
+  module Cli
+    class Plugins
+      class Plugin
+        include Logging
+        attr_reader :name, :version, :opts, :path
+
+        def initialize(name:, version:, opts:, disabled:)
+          @name = name
+          @version = version
+          @opts = opts.merge(require: false)
+          @disabled = disabled
+          return unless opts['path']
+
+          @path = Minfra::Cli.config.base_path.join(opts['path'])
+        end
+
+        def disabled?
+          @disabled
+        end
+
+        def install
+          if path
+            system("cd #{path}; bundle install")
+          else
+            system("gem install #{name} --version #{version}")
+          end
+        end
+
+        # adds the plugin to the
+        def prepare
+          debug("plugin prepare: #{name}, #{version}, disabled: #{disabled?}")
+          return if disabled?
+
+          if path
+            begin
+              lib_path = path.join('lib')
+              $LOAD_PATH.unshift lib_path
+              require name
+            rescue Gem::Requirement::BadRequirementError, LoadError
+              warn("plugin prepare path: #{name} (#{$ERROR_INFO})")
+            end
+          else
+            begin
+              @gem_spec = Gem::Specification.find_by_name(name)
+              gem name, version
+            rescue Gem::MissingSpecError
+              warn("plugin prepare gem: #{name}, #{version} (#{$ERROR_INFO})")
+            end
+          end
+        end
+
+        def setup
+          return if disabled?
+
+          if path
+            minfra_path = Pathname.new(path).join('minfracs', 'init.rb')
+            if minfra_path.exist?
+              begin
+                require minfra_path # this should register the command
+              rescue LoadError
+                logger.warn("Minfra plugin detected but dependencies not installed: #{minfra_path} (#{$ERROR_INFO}). TRY: minfra plugin install")
+              end
+            end
+          else
+            error('Gem based plugins not supported yet')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minfra/cli/plugins.rb

@@ -1,108 +1,39 @@
+# frozen_string_literal: true
+
+require 'English'
 module Minfra
   module Cli
     class Plugins
-      class Plugin
-        include Logging
-        attr_reader :name, :version, :opts, :path
-        
-        
-        def initialize(name:, version:, opts:, disabled:)
-          @name= name
-          @version = version
-          @opts = opts.merge(require: false)
-          @disabled= disabled
-          if opts["path"]
-            @path= Minfra::Cli.config.base_path.join(opts["path"])
-          end  
-        end
-        def disabled?
-          @disabled
-        end
-        
-        #adds the plugin to the 
-        def prepare
-          debug("plugin prepare: #{name}, #{version}, disabled: #{disabled?}")
-          return if disabled?
-          if path
-            begin
-              lib_path=path.join('lib')
-              $LOAD_PATH.unshift lib_path
-              require name
-            rescue Gem::Requirement::BadRequirementError, LoadError
-                warn("plugin prepare path: #{name} (#{$!})")
-             end
-          else
-            begin
-              @gem_spec=Gem::Specification.find_by_name(name)
-              gem name, version
-            rescue Gem::MissingSpecError
-              warn("plugin prepare gem: #{name}, #{version} (#{$!})")
-            end
-          end
-        end
-        
-        def setup
-          return if disabled?
-          if path 
-            minfra_path = Pathname.new(path).join("minfracs","init.rb")
-            if minfra_path.exist?
-              begin
-                require minfra_path # this should register the command
-              rescue LoadError
-                 logger.warn("Minfra plugin detected but dependencies not installed: #{minfra_path} (#{$!}). TRY: minfra plugin install")
-              end 
-            end  
-          else
-            error("Gem based plugins not supported yet")
-          end    
-        end
-
-        def install
-          return if disabled?
-          if path
-            system("cd #{path}; bundle install")
-          else
-            system("gem install #{name} --version #{version}")
-          end
-        end
-      end
-      
       def initialize(plugins)
-        @plugins=plugins
+        @plugins = plugins
       end
 
       def prepare
         @plugins.each(&:prepare)
       end
+
       def setup
         @plugins.each(&:setup)
       end
-      
-      def install
-        if path
-          system("cd #{path}; bundle install")
-        else
-          system("gem install #{name} --version #{version}")
-        end
-      end
-      
-      def each(&block)
-        @plugins.each(&block)
+
+      def each(&)
+        @plugins.each(&)
       end
-      
-      def self.load
-        found=[]
-        [Pathname.new(ENV["MINFRA_PATH"]).join("config","minfra_plugins.json"),
-        Pathname.new(ENV["MINFRA_PATH"]).join("me","minfra_plugins.json")].each do |file|
+
+      def self.load(base_path)
+        found = []
+        [base_path.join('config', 'minfra_plugins.json'),
+         base_path.join('me', 'minfra_plugins.json')].each do |file|
           next unless File.exist?(file)
-          plugins=JSON.parse(File.read(file))
-          plugins["plugins"].each do |spec|
-            found << Plugin.new(name: spec['name'], opts: spec['opts'] || {}, version: spec['version'], disabled: spec['disabled'])
+
+          plugins = JSON.parse(File.read(file))
+          plugins['plugins'].each do |spec|
+            found << Plugin.new(name: spec['name'], opts: spec['opts'] || {}, version: spec['version'],
+                                disabled: spec['disabled'])
           end
         end
         new(found)
       end
-
     end
   end
 end

data/lib/minfra/cli/runner.rb

@@ -12,7 +12,7 @@ module Minfra
         attr_writer :status
 
         attr_reader :stdout_lines
-        
+
         def initialize
           @stderr_lines = []
           @stdout_lines = []
@@ -33,7 +33,7 @@ module Minfra
         def exitstatus
           @status.exitstatus
         end
-        
+
         def success?
           @status.success?
         end
@@ -70,21 +70,21 @@ module Minfra
 
       def run
         debug("running (#{@runner}): #{@cmd}")
-        res=case @runner
-          when :system
-            run_system(Result.new)
-          when :popen  
-            run_threaded(Result.new)
-          when :exec
-            run_exec(Result.new)  
-          else
-            raise "unknown runner #{@runner}"  
-        end
-        
+        res = case @runner
+              when :system
+                run_system(Result.new)
+              when :popen
+                run_threaded(Result.new)
+              when :exec
+                run_exec(Result.new)
+              else
+                raise "unknown runner #{@runner}"
+              end
+
         if res.error?
           error "command failed: #{@cmd}"
-          debug  res.stdout
-          info  res.stderr
+          debug res.stdout
+          info res.stderr
         end
         if exit_on_error && res.error?
           info "command exiting on error (#{res.exitstatus})"
@@ -92,24 +92,25 @@ module Minfra
         end
         res
       end
-      
+
       private
 
       def run_exec(_res)
         exec(@cmd)
       end
+
       # you don't get stderr .... yet
       def run_system(res)
-        #https://stackoverflow.com/questions/6338908/ruby-difference-between-exec-system-and-x-or-backticks
+        # https://stackoverflow.com/questions/6338908/ruby-difference-between-exec-system-and-x-or-backticks
         begin
-          out=`#{@cmd}`
-          out.each_line do |line| res.add(line, :stdout) end 
+          out = `#{@cmd}`
+          out.each_line { |line| res.add(line, :stdout) }
         rescue StandardError
         end
-        res.status = $?
+        res.status = $CHILD_STATUS
         res
       end
-      
+
       def run_threaded(res)
         begin
           # see: http://stackoverflow.com/a/1162850/83386
@@ -117,7 +118,7 @@ module Minfra
           # Open4 might be a solution. Using Select might be a solution. Using Process.fork might be a solution....
           Open3.popen3(@cmd) do |_stdin, stdout, stderr, thread|
             # read each stream from a new thread
-            { stdout: stdout, stderr: stderr }.each do |key, stream|
+            { stdout:, stderr: }.each do |key, stream|
               Thread.new do
                 until (raw_line = stream.gets).nil?
                   #                   stream.each do |raw_line|
@@ -135,7 +136,6 @@ module Minfra
         end
         res
       end
-      
     end
   end
 end

data/lib/minfra/cli/templater.rb

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 require 'erb'
 
 module Minfra
   module Cli
-    class Templater # not threadsafe!
+    # not threadsafe!
+    class Templater
       def self.read(path, params: {}, fallback: nil)
-        p=Pathname.new(path)
+        p = Pathname.new(path)
         if p.exist?
-          content=File.read(path)
+          content = File.read(path)
         else
-          if fallback
-            content=fallback
-          else
-            raise "file #{path} not found"
-          end
-        end  
+          raise "file #{path} not found" unless fallback
+
+          content = fallback
+
+        end
         render(content, params)
       end
-      
+
       def self.render(template, params)
         new(template).render(params)
       end
@@ -25,7 +27,7 @@ module Minfra
         destination = Pathname.new(dst)
         destination.mkpath
         source = Pathname.new(src)
-        
+
         source.glob('**/*') do |filename|
           rel_path = filename.relative_path_from(source)
 
@@ -40,11 +42,11 @@ module Minfra
           end
         end
       end
-      
+
       def initialize(template)
         @erb = ERB.new(template)
-        @check_mode=false
-        @check_missing=[]
+        @check_mode = false
+        @check_missing = []
       end
 
       def missing?
@@ -70,9 +72,7 @@ module Minfra
 
       def method_missing(name)
         if @check_mode
-          if @check_block
-            @check_block.call(name)
-          end
+          @check_block&.call(name)
           @check_missing << name
         else
           super

data/lib/minfra/cli/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
-    VERSION = '1.13.2'.freeze
+    VERSION = '2.0.0'
   end
 end