kafo 5.0.1 → 6.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8444079aa3981305927cda7536f93d476b43bb6feaaaac2a3172a52010ff1575
-  data.tar.gz: f2dd10a6c71c6ee003cc1ca205820e2b9037e182dd9b11c68ab62e13476a2034
+  metadata.gz: d5b062b74a81972dc7e0029799071d8b634ff87d50921e971bea9160ac007179
+  data.tar.gz: 91d16fcc9ce37cece41968d07ca8f44150016ac58cdc66adaef07ec9efa21d9f
 SHA512:
-  metadata.gz: 64ebbbc3909f6fc60c5b9a714bdbe98869602a1f5b320f9e9963cf78d26c1104868cec8fcaf68d928a7f7825981ce7558dbc41043b3c0967f6b775b2c28073de
-  data.tar.gz: 8a86cd7cac3a0f17fdd0006119bb3f60f043e93410e33672dc712cbdc846d5049a5a8db5020f34abf1d2d5f2afa62c8f66901376a4f83aec8fbf472f88cc0b5e
+  metadata.gz: 57abd42df5d5718db2a0ad815fac3c9b7c7e670baa394c9227cedadf3cd0c18f433168d035f23b8aaf4e48d8fe2d2ae17a19371dc8f8756b0857eb31878b5a8c
+  data.tar.gz: ef4f963505fc2e6315fbe19ed8e71e69faa44bf852491b0eebcb3ac778a8ecd86d03989bb2784735e6502ff539f026bd5ae51a12062c01d467601c03fea5ea3e

data/README.md

@@ -736,6 +736,7 @@ We currently support the following hooks.
 * pre_commit - after validations or interactive wizard have completed, all parameter values are set but not yet stored in the answer file
 * pre  - just before puppet is executed to converge system, after parameter values are stored in the answer file
 * post  - just after puppet is executed to converge system
+* pre_exit - happens during exit handling, before exit is completed
 
 For better understanding when the hooks are executed see the [diagram](doc/kafo_run.png).
 

data/Rakefile

@@ -31,6 +31,13 @@ namespace 'test' do
   end
 end
 
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  puts 'Rubocop not loaded'
+end
+
 CLEAN.include 'test/tmp'
 
 task :test => ['test:ruby', 'test:puppet_modules']

data/doc/kafo_run.uml

@@ -105,5 +105,7 @@
 
   #Greenyellow:**post**|
 
+  #Greenyellow:**pre_exit**|
+
   stop
 @enduml

data/lib/kafo/app_option/declaration.rb

@@ -0,0 +1,17 @@
+require_relative 'definition'
+
+module Kafo
+  module AppOption
+    module Declaration
+      include Clamp::Option::Declaration
+
+      def app_option(switches, type, description, opts = {}, &block)
+        AppOption::Definition.new(switches, type, description, opts).tap do |option|
+          block ||= option.default_conversion_block
+          define_accessors_for(option, &block)
+          declared_options << option
+        end
+      end
+    end
+  end
+end

data/lib/kafo/app_option/definition.rb

@@ -0,0 +1,14 @@
+module Kafo
+  module AppOption
+    class Definition < Clamp::Option::Definition
+      def initialize(switches, type, description, options = {})
+        @advanced = options.fetch(:advanced, false)
+        super(switches, type, description, options)
+      end
+
+      def advanced?
+        @advanced
+      end
+    end
+  end
+end

data/lib/kafo/color_scheme.rb

@@ -7,7 +7,7 @@ module Kafo
       ::ENV['TERM'] && !`which tput 2> /dev/null`.empty? && `tput colors`.to_i > 0
     end
 
-    def initialize(options={})
+    def initialize(options = {})
       @background = options[:background].nil? ? :dark : options[:background]
       @colors = options[:colors].nil? ? self.class.colors_possible? : options[:colors]
     end

data/lib/kafo/configuration.rb

@@ -15,9 +15,11 @@ module Kafo
         :description          => '',
         :enabled              => true,
         :log_dir              => '/var/log/kafo',
+        :log_owner            => nil,
+        :log_group            => nil,
         :store_dir            => '',
         :log_name             => 'configuration.log',
-        :log_level            => 'info',
+        :log_level            => 'notice',
         :no_prefix            => false,
         :mapping              => {},
         :answer_file          => './config/answers.yaml',
@@ -26,11 +28,20 @@ module Kafo
         :colors               => Kafo::ColorScheme.colors_possible?,
         :color_of_background  => :dark,
         :hook_dirs            => [],
+        :check_dirs           => nil,
         :custom               => {},
         :facts                => {},
         :low_priority_modules => [],
-        :verbose_log_level    => 'info',
-        :skip_puppet_version_check => false
+        :verbose              => false,
+        :verbose_log_level    => 'notice',
+        :skip_puppet_version_check => false,
+        :parser_cache_path    => nil,
+        :ignore_undocumented  => nil,
+        :order                => nil,
+        :hiera_config         => nil,
+        :kafo_modules_dir     => nil,
+        :config_header_file   => nil,
+        :dont_save_answers    => nil,
     }
 
     def self.get_scenario_id(filename)
@@ -57,10 +68,17 @@ module Kafo
 
     def save_configuration(configuration)
       return true unless @persist
+
+      trimmed = configuration.reject do |key, value|
+        !DEFAULT.key?(key) || value.nil?
+      end
+
       begin
         FileUtils.touch @config_file
         File.chmod 0600, @config_file
-        File.open(@config_file, 'w') { |file| file.write(format(YAML.dump(configuration))) }
+        File.open(@config_file, 'w') do |file|
+          file.write(format(YAML.dump(trimmed.sort.to_h)))
+        end
       rescue Errno::EACCES
         puts "Insufficient permissions to write to #{@config_file}, can not continue"
         KafoConfigure.exit(:insufficient_permissions)
@@ -104,6 +122,10 @@ module Kafo
       custom_fact_storage[key.to_s] = value
     end
 
+    def has_custom_fact?(key)
+      custom_fact_storage.key?(key.to_s)
+    end
+
     def modules
       @modules ||= begin
         register_data_types
@@ -148,7 +170,7 @@ module Kafo
       save_configuration(app)
     end
 
-    def migrate_configuration(from_config, options={})
+    def migrate_configuration(from_config, options = {})
       keys_to_skip = options.fetch(:skip, [])
       keys = [:log_dir, :log_name, :log_level, :no_prefix,
         :colors, :color_of_background, :custom, :verbose_log_level]
@@ -175,7 +197,7 @@ module Kafo
           }
 EOS
 
-        @logger.info 'Loading default values from puppet modules...'
+        @logger.notice 'Loading default values from puppet modules...'
         command = PuppetCommand.new(dump_manifest, [], puppetconf, self).command
         stdout, stderr, status = Open3.capture3(*PuppetCommand.format_command(command))
 
@@ -200,7 +222,7 @@ EOS
           end
         end
 
-        @logger.info "... finished"
+        @logger.notice "... finished"
 
         load_yaml_from_output(stdout.split($/))
       end
@@ -305,7 +327,7 @@ EOS
         save_configuration(app)
         store(answers)
         migrations.store_applied
-        @logger.info("#{migrations.migrations.count} migration/s were applied. Updated configuration was saved.")
+        @logger.notice("#{migrations.migrations.count} migration/s were applied. Updated configuration was saved.")
       end
       migrations.migrations.count
     end

data/lib/kafo/exit_handler.rb

@@ -26,8 +26,8 @@ module Kafo
     def exit(code, &block)
       @exit_code = translate_exit_code(code)
       block.call if block
+      KafoConfigure.hooking.execute(:pre_exit, log_stage: false)
       logger.debug "Exit with status code: #{@exit_code} (signal was #{code})"
-      logger.dump_errors unless KafoConfigure.verbose
       cleanup
       Kernel.exit(@exit_code)
     end

data/lib/kafo/help_builders/base.rb

@@ -2,8 +2,8 @@
 
 module Kafo
   module HelpBuilders
-    DEFAULT_GROUP_NAME   = 'Basic'
-    DEFAULT_MODULE_NAME  = 'Generic'
+    DEFAULT_GROUP_NAME = 'Basic'
+    DEFAULT_MODULE_NAME = 'Generic'
     IGNORE_IN_GROUP_NAME = /\s*parameters:?/
 
     class Base < Clamp::Help::Builder
@@ -15,12 +15,14 @@ module Kafo
       end
 
       def add_list(heading, items)
+        return if items.empty?
         if heading == 'Options'
           puts "\n#{heading}:"
 
           data = by_module(items)
+
           sorted_keys(data).each do |section|
-            if section == 'Generic'
+            if section == DEFAULT_MODULE_NAME
               add_list(header(1, section), data[section])
             else
               add_module(section, data[section])

data/lib/kafo/help_builders/basic.rb

@@ -4,8 +4,15 @@ module Kafo
   module HelpBuilders
     class Basic < Base
       def add_module(name, items)
-        data = by_parameter_groups(except_resets(items))
-        add_list(module_header(name), data['Basic'])
+        pruned = except_resets(items)
+        pruned = except_advanced(pruned)
+        data = by_parameter_groups(pruned)
+        add_list(module_header(name), data[DEFAULT_GROUP_NAME])
+      end
+
+      def add_list(heading, items)
+        pruned = except_advanced(items)
+        super(heading, pruned)
       end
 
       def string
@@ -17,6 +24,10 @@ module Kafo
       def except_resets(items)
         items.select { |i| !i.help.first.strip.start_with?('--reset-') || !i.help.last.include?('to the default value (') }
       end
+
+      def except_advanced(items)
+        items.reject { |item| item.respond_to?(:advanced?) && item.advanced? }
+      end
     end
   end
 end

data/lib/kafo/hook_context.rb

@@ -3,28 +3,36 @@ require 'kafo/base_context'
 
 module Kafo
   class HookContext < BaseContext
+    # @return [Kafo::KafoConfigure]
     attr_reader :kafo
 
-    def self.execute(kafo, &hook)
-      new(kafo).instance_eval(&hook)
-    end
-
-    def initialize(kafo)
-      @kafo = kafo
-    end
-
     # some of hooks won't print any message because logger is not yet configured
     # configuration of logger depends on application configration (log level etc.)
-    # examples:
+    #
+    # @return [Kafo::Logger]
+    #
+    # @example
     #   logger.warn "this combindation of parameters is untested"
-    def logger
-      self.kafo.logger
+    attr_reader :logger
+
+    def self.execute(kafo, logger, &hook)
+      new(kafo, logger).instance_eval(&hook)
+    end
+
+    def initialize(kafo, logger)
+      @kafo = kafo
+      @logger = logger
     end
 
     # if you want to add new app_option be sure to do as soon as possible (usually boot hook)
     # otherwise it may be too late (e.g. when displaying help)
-    # examples:
+    #
+    # @return [Clamp::Option]
+    #
+    # @example
     #   app_option '--log-level', 'LEVEL', 'Log level for log file output', :default => config.app[:log_level]:
+    #
+    # @example
     #   app_option ['-n', '--noop'], :flag, 'Run puppet in noop mode?', :default => false
     def app_option(*args)
       self.kafo.class.app_option(*args)
@@ -32,19 +40,34 @@ module Kafo
 
     # Returns whether the given app option exists. This is useful when there's a conditional option that is
     # determined during boot; this helper can be used in later hooks to determine whether the option exists.
+    #
+    # @param [Symbol, String] option
     def app_option?(option)
       self.kafo.config.app.key?(option.to_sym)
     end
 
-    # examples:
+    # @param [Symbol, String] option
+    #
+    # @example
     #   app_value(:log_level)
+    #
     # note the dash to underscore convention
     def app_value(option)
       self.kafo.config.app[option.to_sym]
     end
 
-    # examples:
+    # Return the parameter of a module. Note that the module may not actually
+    # be enabled.
+    #
+    # @param [String] module_name
+    # @param [String] parameter_name
+    #
+    # @return [Kafo::Param, nil]
+    #
+    # @example
     #   param('foreman', 'interface').value = 'eth0'
+    #
+    # @example
     #   param('foreman', 'interface').value = app_option('bind_on_interface')
     def param(module_name, parameter_name)
       self.kafo.param(module_name, parameter_name)
@@ -55,8 +78,14 @@ module Kafo
     # part of answer file so it also preserves parameter values between runs. It also list
     # its options in help output. You can also specify mapping for this module as a second
     # parameter.
-    # examples:
+    #
+    # @param [String] module_name
+    # @param [Hash, nil] mapping
+    #
+    # @example
     #   add_module('my_module')
+    #
+    # @example
     #   add_module('foreman::plugin::staypuft', {:dir_name => 'foreman', :manifest_name => 'plugin/staypuft'})
     def add_module(module_name, mapping = nil)
       self.kafo.config.add_mapping(module_name, mapping) if mapping
@@ -64,7 +93,10 @@ module Kafo
     end
 
     # Check if a module is enabled in the current configuration.
-    # examples:
+    #
+    # @param [String] module_name
+    #
+    # @example
     #   module_enabled?('example')
     def module_enabled?(module_name)
       mod = self.kafo.module(module_name)
@@ -72,7 +104,10 @@ module Kafo
     end
 
     # Check if a module is present in the current configuration.
-    # examples:
+    #
+    # @param [String] module_name
+    #
+    # @example
     #   module_present?('example')
     def module_present?(module_name)
       mod = self.kafo.module(module_name)
@@ -82,51 +117,84 @@ module Kafo
     # You can trigger installer exit by this method. You must specify exit code as a first
     # argument. You can also specify a symbol alias which is built-in (see exit_handler.rb
     # for more details).
-    # examples:
+    #
+    # @param [Integer, Symbol] code
+    #
+    # @example
     #   exit(0)
+    #
+    # @example
     #   exit(:manifest_error)
     def exit(code)
       self.kafo.class.exit(code)
     end
 
     # You can load a custom config value that has been saved using store_custom_config
+    #
+    # @param [Symbol] key
     def get_custom_config(key)
       self.kafo.config.get_custom(key)
     end
 
     # You can save any value into kafo configuration file, this is useful if you need to
     # share a value between more hooks and persist the values for next run
+    #
+    # @param [Symbol] key
+    # @param [Object] value
     def store_custom_config(key, value)
       self.kafo.config.set_custom(key, value)
     end
 
     # Load a custom fact from the custom fact storage as saved by store_custom_fact
+    #
+    # @param [Symbol] key
     def get_custom_fact(key)
       self.kafo.config.get_custom_fact(key)
     end
 
-    # Store a any custom fact. This will show up as kafo.scenario.custom.your_fact.
+    # Store any custom fact. This will show up as kafo.scenario.custom.your_fact.
     # It is possible to use structures such as arrays and hashes besides the
     # obvious ones such as strings, integers, booleans.
     #
     # These facts can also be used in Hiera hierachy definitions.
+    #
+    # @param [Symbol] key
+    # @param [Object] value
     def store_custom_fact(key, value)
       self.kafo.config.set_custom_fact(key, value)
     end
 
+    # Check whether a custom fact exists, regardless of whether or not it has a value.
+    #
+    # @param [Symbol] key
+    def has_custom_fact?(key)
+      self.kafo.config.has_custom_fact?(key)
+    end
+
     # Return the id of the current scenario
+    #
+    # @return [String]
     def scenario_id
       self.kafo.config.scenario_id
     end
 
     # Return the path to the current scenario
+    #
+    # @return [String]
     def scenario_path
       self.kafo.config.config_file
     end
 
     # Return the actual data in the current scenario
+    #
+    # @return [Hash]
     def scenario_data
       self.kafo.config.app
     end
+
+    # Return the current exit code
+    def exit_code
+      self.kafo.exit_code
+    end
   end
 end