kafo 5.1.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5bb233f06b493ded5dfc032260f4069329eecf431cdfe6c6b93ea20ed7303af
-  data.tar.gz: f8af42dfbbf78ddb16971c776f1e658a7d0aa0306216f7b06ccd984f912c0a96
+  metadata.gz: f5cb69151feb9aff8869369e3c3d16b1899bd51248ab4cb8a2cf08f862d78c72
+  data.tar.gz: f7760b031fb5f00e4ad853d8ac7c139555cc0606dcbd40ba542f340bfbe08135
 SHA512:
-  metadata.gz: 26c1cde782d8ad9e78f63627223492471b66504efb82491f723ee1a8d9efbd427455fc2219b92eee190217158788b1c42091633dd1a162a6a9e5502c671d4007
-  data.tar.gz: e546068a983e2e6d45cd61e08945eb02903c366f9aebbc03d70bbf90df94af8b74d4d86e4034970c77d9b3bda145981bc9861e64323d84e0f9210c40477f90b9
+  metadata.gz: 27baf9be9b11280cd352cc418b62955473396b9d4b3245bc558e9e335e353d209c904acce90936644a9b023e82f60b5fba78ab902eb1aafd8068ae92d34e14ea
+  data.tar.gz: aa2ff036cca2d1d24fa11003272ffecaa51d1a8a03a482471a2074adf92edbbe94b17b82e998a79134635f207e611056d9e91187a6a4ce88191f36836588dbd1

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/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,19 @@
+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,16 @@
+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/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)
@@ -179,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))
 
@@ -204,7 +222,7 @@ EOS
           end
         end
 
-        @logger.info "... finished"
+        @logger.notice "... finished"
 
         load_yaml_from_output(stdout.split($/))
       end
@@ -309,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,25 +117,37 @@ 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
@@ -110,28 +157,44 @@ module Kafo
     # 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

data/lib/kafo/hooking.rb

@@ -2,15 +2,16 @@ require 'kafo/hook_context'
 
 module Kafo
   class Hooking
-    # pre_migrations - just after kafo reads its configuration - useful for config file updates. Only in this stage it is posible to request config reload (`Kafo.request_config_reload`) to get in our changes
-    # boot - before kafo is ready to work, useful for adding new app arguments, logger won't work yet
-    # init - just after hooking is initialized and kafo is configured, parameters have no values yet
-    # pre_values - just before value from CLI is set to parameters (they already have default values)
-    # pre_validations - just after system checks and before validations are executed (and before interactive wizard is started), at this point all parameter values are already set but not yet stored in answer file
-    # 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
-    # post - just after puppet is executed to converge system
-    TYPES = [:pre_migrations, :boot, :init, :pre, :post, :pre_values, :pre_validations, :pre_commit]
+    # * pre_migrations - just after kafo reads its configuration - useful for config file updates. Only in this stage it is posible to request config reload (`Kafo.request_config_reload`) to get in our changes
+    # * boot - before kafo is ready to work, useful for adding new app arguments, logger won't work yet
+    # * init - just after hooking is initialized and kafo is configured, parameters have no values yet
+    # * pre_values - just before value from CLI is set to parameters (they already have default values)
+    # * pre_validations - just after system checks and before validations are executed (and before interactive wizard is started), at this point all parameter values are already set but not yet stored in answer file
+    # * 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
+    # * post - just after puppet is executed to converge system
+    # * pre_exit - happens during exit handling, before exit is completed
+    TYPES = [:pre_migrations, :boot, :init, :pre_values, :pre_validations, :pre_commit, :pre, :post, :pre_exit]
 
     attr_accessor :hooks, :kafo
 
@@ -44,14 +45,16 @@ module Kafo
       @loaded
     end
 
-    def execute(group)
-      logger.info "Executing hooks in group #{group}"
+    def execute(group, log_stage: true)
+      logger = Logger.new(group)
+      logger.notice "Executing hooks in group #{group}" if log_stage
       self.hooks[group].keys.sort_by(&:to_s).each do |name|
         hook = self.hooks[group][name]
-        result = HookContext.execute(self.kafo, &hook)
+        result = HookContext.execute(self.kafo, logger, &hook)
         logger.debug "Hook #{name} returned #{result.inspect}"
       end
-      logger.info "All hooks in group #{group} finished"
+      logger.notice "All hooks in group #{group} finished" if log_stage
+      @group = nil
     end
 
     def register_pre_migrations(name, &block)
@@ -86,6 +89,10 @@ module Kafo
       register(:post, name, &block)
     end
 
+    def register_pre_exit(name, &block)
+      register(:pre_exit, name, &block)
+    end
+
     private
 
     def register(group, name, &block)