kafo 0.6.12 → 0.7.0

data/config/kafo.yaml.example

@@ -3,14 +3,17 @@
 # note current configuration is written to kafo.yaml every time kafo is run
 
 ## Installer configuration
-# Your project name
-# :name: Kafo
+# Human readable scenario name
+# :name: default
+# Description of the installer scenario and its purpose
+# :description:
 # Path to answer file, if the file does not exist a $pwd/config/answers.yaml is used as a fallback
 # :answer_file: /etc/kafo/answers.yaml
 # Custom installer path
 # :installer_dir: /usr/share/kafo/
-# Uncomment if you want to load puppet modules from a specific path, $pwd/modules is used by default
-# :modules_dir: /usr/share/kafo/modules
+# Uncomment if you want to load puppet modules from a specific path, $pwd/modules is used by default,
+# multiple dirs are allowed
+# :module_dirs: /usr/share/kafo/modules
 # Similar as modules_dir but for kafo internal modules, leave nil if you don't need to change it
 # :kafo_modules_dir:
 # Enable colors? If you don't touch this, we'll autodetect terminal capabilities
@@ -44,6 +47,11 @@
 # :hook_dirs:
 # - /opt/hooks
 
+## Checks - system checks in these extra directories will be loaded
+# by default $installer_dir/checks is used
+# :check_dirs:
+# - /opt/checks
+
 # custom storage is handy if you use hooks and you must store some configuration
 # which should persist among installer runs. It can be also used for passing
 # value from one hook to another.

data/lib/kafo/color_scheme.rb

@@ -2,12 +2,18 @@ require 'highline/import'
 
 module Kafo
   class ColorScheme
-    def initialize(config)
-      @config = config
+
+    def self.colors_possible?
+      ::ENV['TERM'] && !`which tput 2> /dev/null`.empty? && `tput colors`.to_i > 0
+    end
+
+    def initialize(options={})
+      @background = options[:background].nil? ? :dark : options[:background]
+      @colors = options[:colors].nil? ? self.class.colors_possible? : options[:colors]
     end
 
     def setup
-      if @config.app[:colors]
+      if @colors
         HighLine.color_scheme = build_color_scheme
         HighLine.use_color = true
       else
@@ -28,6 +34,7 @@ module Kafo
     def color_hash
       @color_hash ||= {
           :headline => build_color(:yellow),
+          :title => build_color(:yellow),
           :horizontal_line => build_color(:white),
           :important => build_color(:white),
           :question => build_color(:green),
@@ -41,7 +48,7 @@ module Kafo
     end
 
     def build_color(color)
-      bright = @config.app[:color_of_background].to_s == 'bright'
+      bright = @background.to_s == 'bright'
       color = convert_bright_to_dark(color) if bright
 
       attributes = [ color ]

data/lib/kafo/configuration.rb

@@ -3,16 +3,15 @@ require 'yaml'
 require 'tmpdir'
 require 'kafo/puppet_module'
 require 'kafo/password_manager'
+require 'kafo/color_scheme'
 
 module Kafo
   class Configuration
     attr_reader :config_file, :answer_file
 
-    def self.colors_possible?
-      !`which tput 2> /dev/null`.empty? && `tput colors`.to_i > 0
-    end
-
     DEFAULT = {
+        :name                 => '',
+        :description          => '',
         :log_dir              => '/var/log/kafo',
         :log_name             => 'configuration.log',
         :log_level            => 'info',
@@ -20,13 +19,14 @@ module Kafo
         :mapping              => {},
         :answer_file          => './config/answers.yaml',
         :installer_dir        => '.',
-        :modules_dir          => './modules',
+        :module_dirs          => ['./modules'],
         :default_values_dir   => '/tmp',
-        :colors               => Configuration.colors_possible?,
+        :colors               => Kafo::ColorScheme.colors_possible?,
         :color_of_background  => :dark,
         :hook_dirs            => [],
         :custom               => {},
         :low_priority_modules => [],
+        :verbose_log_level    => 'info'
     }
 
     def initialize(file, persist = true)
@@ -37,7 +37,7 @@ module Kafo
 
       @answer_file = app[:answer_file]
       begin
-        @data = YAML.load_file(@answer_file)
+        @data = load_yaml_file(@answer_file)
       rescue Errno::ENOENT => e
         puts "No answer file at #{@answer_file} found, can not continue"
         KafoConfigure.exit(:no_answer_file)
@@ -62,13 +62,15 @@ module Kafo
     def app
       @app ||= begin
         begin
-          configuration = YAML.load_file(@config_file)
+          configuration = load_yaml_file(@config_file)
         rescue => e
           configuration = {}
         end
 
         result            = DEFAULT.merge(configuration || {})
         result[:password] ||= PasswordManager.new.password
+        result[:module_dirs] = result[:modules_dir] || result[:module_dirs]
+        result.delete(:modules_dir)
         result
       end
     end
@@ -82,11 +84,31 @@ module Kafo
     end
 
     def modules
-      @modules ||= @data.keys.map { |mod| PuppetModule.new(mod).parse }.sort
+      @modules ||= @data.keys.map { |mod| PuppetModule.new(mod, KafoParsers::PuppetModuleParser, self).parse }.sort
+    end
+
+    def root_dir
+      File.expand_path(app[:installer_dir])
+    end
+
+    def check_dirs
+      [app[:check_dirs] || File.join(root_dir, 'checks')].flatten
+    end
+
+    def module_dirs
+      [app[:module_dirs] || (app[:installer_dir] + '/modules')].flatten.map { |dir| File.expand_path(dir) }
+    end
+
+    def gem_root
+      File.join(File.dirname(__FILE__), '../../')
+    end
+
+    def kafo_modules_dir
+      app[:kafo_modules_dir] || (gem_root + '/modules')
     end
 
     def add_module(name)
-      mod = PuppetModule.new(name).parse
+      mod = PuppetModule.new(name, KafoParsers::PuppetModuleParser, self).parse
       unless modules.map(&:name).include?(mod.name)
         mod.enable
         @modules << mod
@@ -98,13 +120,25 @@ module Kafo
       save_configuration(app)
     end
 
+    def migrate_configuration(from_config, options={})
+      keys_to_skip = options.fetch(:skip, [])
+      keys = [:log_dir, :log_name, :log_level, :no_prefix, :default_values_dir,
+        :colors, :color_of_background, :custom, :password, :verbose_log_level]
+      keys += options.fetch(:with, [])
+      keys.each do |key|
+        next if keys_to_skip.include?(key)
+        app[key] = from_config.app[key]
+      end
+      save_configuration(app)
+    end
+
     def params_default_values
       @params_default_values ||= begin
         @logger.debug "Creating tmp dir within #{app[:default_values_dir]}..."
         temp_dir = Dir.mktmpdir(nil, app[:default_values_dir])
         KafoConfigure.exit_handler.register_cleanup_path temp_dir
         @logger.info 'Loading default values from puppet modules...'
-        command = PuppetCommand.new("$temp_dir=\"#{temp_dir}\" #{includes} dump_values(#{params})").append('2>&1').command
+        command = PuppetCommand.new("$temp_dir=\"#{temp_dir}\" #{includes} dump_values(#{params_to_dump})", ['--noop'], self).append('2>&1').command
         result = `#{command}`
         @logger.debug result
         unless $?.exitstatus == 0
@@ -116,7 +150,7 @@ module Kafo
           KafoConfigure.exit(:defaults_error)
         end
         @logger.info "... finished"
-        YAML.load_file(File.join(temp_dir, 'default_values.yaml'))
+        load_yaml_file(File.join(temp_dir, 'default_values.yaml'))
       end
     end
 
@@ -133,7 +167,7 @@ module Kafo
     end
 
     def config_header
-      files          = [app[:config_header_file], File.join(KafoConfigure.gem_root, '/config/config_header.txt')].compact
+      files          = [app[:config_header_file], File.join(gem_root, '/config/config_header.txt')].compact
       file           = files.select { |f| File.exists?(f) }.first
       @config_header ||= file.nil? ? '' : File.read(file)
     end
@@ -145,6 +179,83 @@ module Kafo
       File.open(filename, 'w') { |file| file.write(config_header + format(YAML.dump(data))) }
     end
 
+    def params
+      @params ||= modules.map(&:params).flatten
+    end
+
+    def param(mod, name)
+      params.detect { |p| p.name == name && p.module.name == mod }
+    end
+
+    def preset_defaults_from_puppet
+      # set values based on default_values
+      params.each do |param|
+        param.set_default(params_default_values)
+      end
+    end
+
+    def preset_defaults_from_yaml
+      # set values based on YAML
+      params.each do |param|
+        param.set_value_by_config(self)
+      end
+    end
+
+    def preset_defaults_from_other_config(other_config)
+      params_changed(other_config).each do |par|
+        param(par.module.class_name, par.name).value = other_config.param(par.module.class_name, par.name).value
+      end
+    end
+
+    def params_changed(old_config)
+      # finds params that had different value in the old config
+      params.select do |par|
+        next unless par.module.enabled?
+        old_param = old_config.param(par.module.class_name, par.name)
+        old_param && old_param.value != par.value
+      end
+    end
+
+    def params_missing(old_config)
+      # finds params that are present but will be missing in the new config
+      old_config.params.select do |par|
+        next if !par.module.enabled? || !module_enabled?(par.module.name)
+        param(par.module.class_name, par.name).nil?
+      end
+    end
+
+    def temp_config_file
+      @temp_config_file ||= "/tmp/kafo_answers_#{rand(1_000_000)}.yaml"
+    end
+
+    def log_file
+      File.join(app[:log_dir], app[:log_name])
+    end
+
+    def log_exists?
+      File.exists?(log_file) && File.size(log_file) > 0
+    end
+
+    def answers
+      @data
+    end
+
+    def run_migrations
+      migrations = Kafo::Migrations.new(migrations_dir)
+      @app, @data = migrations.run(app, answers)
+      if migrations.migrations.count > 0
+        @modules = nil # force the lazy loaded modules to reload next time they are used
+        save_configuration(app)
+        store(answers)
+        migrations.store_applied
+        @logger.info("#{migrations.migrations.count} migration/s were applied. Updated configuration was saved.")
+      end
+    end
+
+    def migrations_dir
+      @config_file.gsub(/\.yaml$/, '.migrations')
+    end
+
     private
 
     def custom_storage
@@ -153,20 +264,26 @@ module Kafo
 
     def includes
       modules.map do |mod|
-        params_file = File.join(KafoConfigure.modules_dir, mod.params_path)
-        @logger.debug "checking presence of #{params_file}"
-        File.exist?(params_file) ? "include #{mod.dir_name}::#{mod.params_class_name}" : nil
+        module_dir = module_dirs.find do |dir|
+          params_file = File.join(dir, mod.params_path)
+          @logger.debug "checking presence of #{params_file}"
+          File.exist?(params_file)
+        end
+        module_dir ? "include #{mod.dir_name}::#{mod.params_class_name}" : nil
       end.uniq.compact.join(' ')
     end
 
-    def params
-      params = modules.map(&:params).flatten
-      params = params.select { |p| p.default != 'UNSET' }
-      params.map { |param| "#{param.dump_default}" }.join(',')
+    def params_to_dump
+      parameters = params.select { |p| p.default != 'UNSET' }
+      parameters.map { |param| "#{param.dump_default}" }.join(',')
     end
 
     def format(data)
       data.gsub('!ruby/sym ', ':')
     end
+
+    def load_yaml_file(filename)
+      YAML.load_file(filename)
+    end
   end
 end

data/lib/kafo/exit_handler.rb

@@ -15,7 +15,9 @@ module Kafo
           :manifest_error => 22,
           :no_answer_file => 23,
           :unknown_module => 24,
-          :defaults_error => 25
+          :defaults_error => 25,
+          :unknown_scenario => 26,
+          :scenario_error => 27
       }
     end
 
@@ -23,7 +25,7 @@ module Kafo
       @exit_code = translate_exit_code(code)
       block.call if block
       KafoConfigure.logger.debug "Exit with status code: #{@exit_code} (signal was #{code})"
-      KafoConfigure.logger.dump_errors
+      KafoConfigure.logger.dump_errors unless KafoConfigure.verbose
       cleanup
       Kernel.exit(@exit_code)
     end

data/lib/kafo/hooking.rb

@@ -2,6 +2,7 @@ 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)
@@ -9,7 +10,7 @@ module Kafo
     # 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 = [:boot, :init, :pre, :post, :pre_values, :pre_validations, :pre_commit]
+    TYPES = [:pre_migrations, :boot, :init, :pre, :post, :pre_values, :pre_validations, :pre_commit]
 
     attr_accessor :hooks, :kafo
 
@@ -53,6 +54,10 @@ module Kafo
       logger.info "All hooks in group #{group} finished"
     end
 
+    def register_pre_migrations(name, &block)
+      register(:pre_migrations, name, &block)
+    end
+
     def register_boot(name, &block)
       register(:boot, name, &block)
     end

data/lib/kafo/kafo_configure.rb

@@ -9,8 +9,10 @@ end
 
 require 'pty'
 require 'clamp'
+require 'kafo/color_scheme'
 require 'kafo_parsers/exceptions'
 require 'kafo/exceptions'
+require 'kafo/migrations'
 require 'kafo/configuration'
 require 'kafo/logger'
 require 'kafo/string_helper'
@@ -21,6 +23,7 @@ require 'kafo/puppet_command'
 require 'kafo/progress_bar'
 require 'kafo/hooking'
 require 'kafo/exit_handler'
+require 'kafo/scenario_manager'
 
 module Kafo
   class KafoConfigure < Clamp::Command
@@ -28,8 +31,8 @@ module Kafo
 
     class << self
       attr_accessor :config, :root_dir, :config_file, :gem_root, :temp_config_file,
-                    :modules_dir, :kafo_modules_dir, :verbose, :app_options, :logger,
-                    :exit_handler
+                    :module_dirs, :kafo_modules_dir, :verbose, :app_options, :logger,
+                    :check_dirs, :exit_handler, :scenario_manager
       attr_writer :hooking
 
       def hooking
@@ -38,29 +41,53 @@ module Kafo
     end
 
     def initialize(*args)
+      self.class.preset_color_scheme
       self.class.logger           = Logger.new
       self.class.exit_handler     = ExitHandler.new
-      self.class.config_file      = config_file
-      self.class.config           = Configuration.new(self.class.config_file)
-      self.class.root_dir         = File.expand_path(self.class.config.app[:installer_dir])
-      modules_dir                 = self.class.config.app[:modules_dir] || (self.class.config.app[:installer_dir] + '/modules')
-      self.class.modules_dir      = File.expand_path(modules_dir)
-      self.class.gem_root         = File.join(File.dirname(__FILE__), '../../')
-      self.class.kafo_modules_dir = self.class.config.app[:kafo_modules_dir] || (self.class.gem_root + '/modules')
       @progress_bar               = nil
-      self.class.hooking.load
-      self.class.hooking.kafo     = self
+      @config_reload_requested    = false
+
+      scenario_manager = setup_scenario_manager
+      self.class.scenario_manager = scenario_manager
+
+      # Handle --list-scenarios before we need them
+      scenario_manager.list_available_scenarios if ARGV.include?('--list-scenarios')
+      setup_config(config_file)
+
+      self.class.hooking.execute(:pre_migrations)
+
+      # run migrations
+      self.class.config.run_migrations
+
+      # reload config
+      if @config_reload_requested
+        scenario_manager = setup_scenario_manager
+        self.class.scenario_manager = scenario_manager
+        setup_config(self.class.config_file)
+        self.class.logger.info('Installer configuration was reloaded')
+      end
+
+      if scenario_manager.configured?
+        scenario_manager.check_scenario_change(self.class.config_file)
+        if scenario_manager.scenario_changed?(self.class.config_file)
+          prev_config = scenario_manager.load_configuration(scenario_manager.previous_scenario)
+          prev_config.run_migrations
+          self.class.config.migrate_configuration(prev_config, :skip => [:log_name])
+          setup_config(self.class.config_file)
+          self.class.logger.info("Due to scenario change the configuration (#{self.class.config_file}) was updated with #{scenario_manager.previous_scenario} and reloaded.")
+        end
+      end
 
       super
 
       self.class.hooking.execute(:boot)
-      set_app_options
+      set_app_options # define args for installer
       # we need to parse app config params using clamp even before run method does it
       # so we limit parsing only to app config options (because of --help and later defined params)
       parse clamp_app_arguments
-      parse_app_arguments
+      parse_app_arguments # set values from ARGS to config.app
       Logger.setup
-      ColorScheme.new(config).setup
+      self.class.set_color_scheme
 
       self.class.hooking.execute(:init)
       set_parameters # here the params gets parsed and we need app config populated
@@ -104,10 +131,11 @@ module Kafo
 
       self.class.hooking.execute(:pre_commit)
       if dont_save_answers? || noop?
-        self.class.temp_config_file = temp_config_file
-        store_params(temp_config_file)
+        self.class.temp_config_file = self.class.config.temp_config_file
+        store_params(self.class.config.temp_config_file)
       else
         store_params
+        self.class.scenario_manager.link_last_scenario(self.class.config_file) if self.class.scenario_manager.configured?
       end
       run_installation
       return self
@@ -178,21 +206,39 @@ module Kafo
     end
 
     def param(mod, name)
-      params.detect { |p| p.name == name && p.module.name == mod }
+      config.param(mod, name)
     end
 
+    def request_config_reload
+      @config_reload_requested = true
+    end
+
+
     private
 
-    def set_parameters
-      # set values based on default_values
-      params.each do |param|
-        param.set_default(config.params_default_values)
-      end
+    def setup_config(conf_file)
+      self.class.config_file      = conf_file
+      self.class.config           = Configuration.new(self.class.config_file)
+      self.class.root_dir         = self.class.config.root_dir
+      self.class.check_dirs       = self.class.config.check_dirs
+      self.class.module_dirs      = self.class.config.module_dirs
+      self.class.gem_root         = self.class.config.gem_root
+      self.class.kafo_modules_dir = self.class.config.kafo_modules_dir
+      self.class.hooking.load
+      self.class.hooking.kafo     = self
+    end
+
+    def setup_scenario_manager
+      ScenarioManager.new((defined?(CONFIG_DIR) && CONFIG_DIR) || (defined?(CONFIG_FILE) && CONFIG_FILE))
+    end
 
+    def set_parameters
+      config.preset_defaults_from_puppet
       self.class.hooking.execute(:pre_values)
-      # set values based on YAML
-      params.each do |param|
-        param.set_value_by_config(config)
+      config.preset_defaults_from_yaml
+      if self.class.scenario_manager.scenario_changed?(config.config_file)
+        prev_scenario = self.class.scenario_manager.load_and_setup_configuration(self.class.scenario_manager.previous_scenario)
+        config.preset_defaults_from_other_config(prev_scenario)
       end
     end
 
@@ -216,6 +262,10 @@ module Kafo
       self.class.app_option ['-v', '--verbose'], :flag, 'Display log on STDOUT instead of progressbar'
       self.class.app_option ['-l', '--verbose-log-level'], 'LEVEL', 'Log level for verbose mode output',
                             :default => 'info'
+      self.class.app_option ['-S', '--scenario'], 'SCENARIO', 'Use installation scenario'
+      self.class.app_option ['--list-scenarios'], :flag, 'List available installation scenaraios'
+      self.class.app_option ['--force'], :flag, 'Force change of installation scenaraio'
+      self.class.app_option ['--compare-scenarios'], :flag, 'Show changes between last used scenario and the scenario specified with -S or --scenario argument'
     end
 
     def set_options
@@ -341,7 +391,7 @@ module Kafo
       end
       @progress_bar.close if @progress_bar
       logger.info "Puppet has finished, bye!"
-      FileUtils.rm(temp_config_file, :force => true)
+      FileUtils.rm(self.class.config.temp_config_file, :force => true)
       self.class.exit(exit_code) do
         self.class.hooking.execute(:post)
       end
@@ -375,13 +425,32 @@ module Kafo
 
     def config_file
       return CONFIG_FILE if defined?(CONFIG_FILE) && File.exists?(CONFIG_FILE)
+      return self.class.scenario_manager.select_scenario if self.class.scenario_manager.configured?
       return '/etc/kafo/kafo.yaml' if File.exists?('/etc/kafo/kafo.yaml')
       return "#{::RbConfig::CONFIG['sysconfdir']}/kafo/kafo.yaml" if File.exists?("#{::RbConfig::CONFIG['sysconfdir']}/kafo/kafo.yaml")
       File.join(Dir.pwd, 'config', 'kafo.yaml')
     end
 
-    def temp_config_file
-      @temp_config_file ||= "/tmp/kafo_answers_#{rand(1_000_000)}.yaml"
+    def self.use_colors?
+      if config
+        colors = config.app[:colors]
+      else
+        colors = ARGV.include?('--no-colors') ? false : nil
+        colors = ARGV.include?('--colors') ? true : nil if colors.nil?
+      end
+      colors
+    end
+
+    def self.preset_color_scheme
+      match = ARGV.join(' ').match /--color-of-background[ =](\w+)/
+      background = match && match[1]
+      ColorScheme.new(:background => background, :colors => use_colors?).setup
+    end
+
+    def self.set_color_scheme
+      ColorScheme.new(
+        :background => config.app[:color_of_background],
+        :colors => use_colors?).setup
     end
   end
 end