kafo 0.6.12 → 0.7.0

data/lib/kafo/logger.rb

@@ -37,6 +37,13 @@ module Kafo
     COLOR_LAYOUT   = Logging::Layouts::Pattern.new(:pattern => PATTERN, :color_scheme => 'bright')
     NOCOLOR_LAYOUT = Logging::Layouts::Pattern.new(:pattern => PATTERN, :color_scheme => nil)
 
+    def self.setup_fatal_logger(layout)
+      fatal_logger           = Logging.logger['fatal']
+      fatal_logger.level     = 'fatal'
+      fatal_logger.appenders = [::Logging.appenders.stderr(:layout => layout)]
+      self.loggers << fatal_logger
+    end
+
     def self.setup
       begin
         FileUtils.mkdir_p(KafoConfigure.config.app[:log_dir], :mode => 0750)
@@ -45,7 +52,7 @@ module Kafo
       end
 
       logger   = Logging.logger['main']
-      filename = "#{KafoConfigure.config.app[:log_dir]}/#{KafoConfigure.config.app[:log_name] || 'configure.log'}"
+      filename = KafoConfigure.config.log_file
       begin
         logger.appenders = ::Logging.appenders.rolling_file('configure',
                                                             :filename => filename,
@@ -59,19 +66,15 @@ module Kafo
       end
 
       logger.level = KafoConfigure.config.app[:log_level]
+      self.loggers << logger
 
-      fatal_logger           = Logging.logger['fatal']
-      fatal_logger.level     = 'fatal'
-      layout                 = KafoConfigure.config.app[:colors] ? COLOR_LAYOUT : NOCOLOR_LAYOUT
-      fatal_logger.appenders = [::Logging.appenders.stderr(:layout => layout)]
-      
-      self.loggers = [logger, fatal_logger]
+      setup_fatal_logger(color_layout) unless loggers.detect {|l| l.name == 'verbose'}
     end
 
     def self.setup_verbose
       logger           = Logging.logger['verbose']
-      logger.level     = KafoConfigure.config.app[:verbose_log_level]
-      layout           = KafoConfigure.config.app[:colors] ? COLOR_LAYOUT : NOCOLOR_LAYOUT
+      logger.level     = (KafoConfigure.config && KafoConfigure.config.app[:verbose_log_level]) || :info
+      layout           = color_layout
       logger.appenders = [::Logging.appenders.stdout(:layout => layout)]
       self.loggers<< logger
     end
@@ -89,8 +92,9 @@ module Kafo
     end
 
     def self.dump_errors
+      setup_fatal_logger(color_layout) if loggers.empty?
       unless self.error_buffer.empty?
-        loggers.each { |logger| logger.error 'Repeating errors encountered during run:' }
+        loggers.each { |logger| logger.error 'Errors encountered during run:' }
         self.dump_buffer(self.error_buffer)
       end
     end
@@ -106,6 +110,10 @@ module Kafo
       buffer.clear
     end
 
+    def self.color_layout
+      KafoConfigure.use_colors? ? COLOR_LAYOUT : NOCOLOR_LAYOUT
+    end
+
     def log(name, *args, &block)
       if self.class.buffering?
         self.class.to_buffer(self.class.buffer, name, args, &block)

data/lib/kafo/migration_context.rb

@@ -0,0 +1,21 @@
+module Kafo
+  class MigrationContext
+
+    attr_accessor :scenario, :answers
+
+    def self.execute(scenario, answers, &migration)
+      context = new(scenario, answers)
+      context.instance_eval(&migration)
+      return context.scenario, context.answers
+    end
+
+    def initialize(scenario, answers)
+      @scenario = scenario
+      @answers = answers
+    end
+
+    def logger
+      KafoConfigure.logger
+    end
+  end
+end

data/lib/kafo/migrations.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+require 'kafo/migration_context'
+
+module Kafo
+  class Migrations
+
+    attr_reader :migrations
+
+    def initialize(migrations_dir)
+      @migrations_dir = migrations_dir
+      @migrations = {}
+      @applied_file = File.join(@migrations_dir, '.applied')
+      load_migrations
+    end
+
+    def applied
+      @applied ||= load_applied
+    end
+
+    def load_migrations
+      Dir.glob(@migrations_dir + "/*.rb").each do |file|
+        next if applied.include?(File.basename(file))
+        KafoConfigure.logger.debug "Loading migration #{file}"
+        migration = File.read(file)
+        migration_block = proc { instance_eval(migration, file, 1) }
+        add_migration(file, &migration_block)
+      end
+    end
+
+    def add_migration(name, &block)
+      @migrations[name] = block
+    end
+
+    def run(scenario, answers)
+      @migrations.keys.sort.each do |name|
+        KafoConfigure.logger.debug "Executing migration #{name}"
+        migration = @migrations[name]
+        scenario, answers = Kafo::MigrationContext.execute(scenario, answers, &migration)
+        applied << File.basename(name.to_s)
+      end
+      return scenario, answers
+    end
+
+    def store_applied
+      File.open(@applied_file, 'w') { |f| f.write(applied.to_yaml) }
+    end
+
+    private
+
+    def load_applied
+      File.exist?(@applied_file) ? YAML.load_file(@applied_file) : []
+    end
+  end
+end

data/lib/kafo/param.rb

@@ -99,7 +99,7 @@ module Kafo
     end
 
     def <=> o
-      unless KafoConfigure.config.app[:no_prefix]
+      unless @module.configuration.app[:no_prefix]
         r = self.module_name <=> o.module_name
         return r unless r == 0
       end

data/lib/kafo/param_builder.rb

@@ -10,7 +10,7 @@ module Kafo
     end
 
     def validate
-      return true if KafoConfigure.config.app[:ignore_undocumented]
+      return true if @module.configuration.app[:ignore_undocumented]
 
       parameters = @data[:parameters].sort
       docs       = @data[:docs].keys.sort

data/lib/kafo/params/password.rb

@@ -51,7 +51,7 @@ module Kafo
       end
 
       def phrase
-        KafoConfigure.config.app[:password]
+        @module.configuration.app[:password]
       end
 
     end

data/lib/kafo/puppet_command.rb

@@ -1,7 +1,8 @@
 # encoding: UTF-8
 module Kafo
   class PuppetCommand
-    def initialize(command, options = [])
+    def initialize(command, options = [], configuration = KafoConfigure.config)
+      @configuration = configuration
       @command = command
 
       # Expand the modules_path to work around the fact that Puppet doesn't
@@ -21,9 +22,9 @@ module Kafo
 
     def command
       result = [
-          "echo '$kafo_config_file=\"#{KafoConfigure.config_file}\" #{custom_answer_file} #{add_progress} #{@command}'",
+          "echo '$kafo_config_file=\"#{@configuration.config_file}\" #{custom_answer_file} #{add_progress} #{@command}'",
           '|',
-          "RUBYLIB=#{["#{KafoConfigure.gem_root}/modules", ::ENV['RUBYLIB']].join(File::PATH_SEPARATOR)}",
+          "RUBYLIB=#{["#{@configuration.gem_root}/modules", ::ENV['RUBYLIB']].join(File::PATH_SEPARATOR)}",
           "puppet apply #{@options.join(' ')} #{@suffix}",
       ].join(' ')
       @logger.debug result
@@ -39,9 +40,9 @@ module Kafo
 
     def modules_path
       [
-          KafoConfigure.modules_dir,
-          KafoConfigure.kafo_modules_dir,
-      ].join(':')
+          @configuration.module_dirs,
+          @configuration.kafo_modules_dir,
+      ].flatten.join(':')
     end
   end
 end

data/lib/kafo/puppet_module.rb

@@ -9,16 +9,23 @@ module Kafo
     PRIMARY_GROUP_NAME = 'Parameters'
 
     attr_reader :name, :identifier, :params, :dir_name, :class_name, :manifest_name, :manifest_path,
-                :groups, :params_path, :params_class_name
+                :groups, :params_path, :params_class_name, :configuration
 
-    def initialize(identifier, parser = KafoParsers::PuppetModuleParser)
+    def initialize(identifier, parser = KafoParsers::PuppetModuleParser, configuration = KafoConfigure.config)
       @identifier        = identifier
+      @configuration     = configuration
       @name              = get_name
       @dir_name          = get_dir_name
       @manifest_name     = get_manifest_name
       @class_name        = get_class_name
       @params            = []
-      @manifest_path     = File.join(KafoConfigure.modules_dir, module_manifest_path)
+      if @configuration.module_dirs.count == 1
+        module_dir       = @configuration.module_dirs.first
+      else
+        module_dir         = @configuration.module_dirs.find { |dir| File.exists?(File.join(dir, module_manifest_path)) } ||
+          warn("Manifest #{module_manifest_path} was not found in #{@configuration.module_dirs.join(', ')}")
+      end
+      @manifest_path     = File.join(module_dir, module_manifest_path)
       @parser            = parser
       @validations       = []
       @logger            = KafoConfigure.logger
@@ -28,7 +35,7 @@ module Kafo
     end
 
     def enabled?
-      @enabled.nil? ? @enabled = KafoConfigure.config.module_enabled?(self) : @enabled
+      @enabled.nil? ? @enabled = @configuration.module_enabled?(self) : @enabled
     end
 
     def disable
@@ -78,7 +85,7 @@ module Kafo
     end
 
     def <=> o
-      KafoConfigure.config.app[:low_priority_modules].each do |module_name|
+      @configuration.app[:low_priority_modules].each do |module_name|
         return 1 if self.name.include?(module_name) && !o.name.include?(module_name)
         return -1 if !self.name.include?(module_name) && o.name.include?(module_name)
         if self.name.include?(module_name) && o.name.include?(module_name)
@@ -103,7 +110,7 @@ module Kafo
 
     # mapping from configuration with stringified keys
     def mapping
-      @mapping ||= Hash[KafoConfigure.config.app[:mapping].map { |k, v| [k.to_s, v] }]
+      @mapping ||= Hash[@configuration.app[:mapping].map { |k, v| [k.to_s, v] }]
     end
 
     # custom module directory name

data/lib/kafo/scenario_manager.rb

@@ -0,0 +1,221 @@
+# encoding: UTF-8
+require 'kafo_wizards'
+
+module Kafo
+  class ScenarioManager
+    attr_reader :config_dir, :last_scenario_link, :previous_scenario
+
+    def initialize(config, last_scenario_link_name='last_scenario.yaml')
+      @config_dir = File.file?(config) ? File.dirname(config) : config
+      @last_scenario_link = File.join(config_dir, last_scenario_link_name)
+      @previous_scenario = File.realpath(last_scenario_link) if File.exists?(last_scenario_link)
+    end
+
+    def available_scenarios
+      # assume that *.yaml file in config_dir that has key :name is scenario definition
+      @available_scenarios ||= Dir.glob(File.join(config_dir, '*.yaml')).reject { |f| f =~ /#{last_scenario_link}$/ }.inject({}) do |scns, scn_file|
+        begin
+          content = YAML.load_file(scn_file)
+          if content.is_a?(Hash) && content.has_key?(:answer_file)
+            # add scenario name for legacy configs
+            content[:name] = File.basename(scn_file, '.yaml') unless content.has_key?(:name)
+            scns[scn_file] = content
+          end
+        rescue Psych::SyntaxError => e
+          warn "Warning: #{e}"
+        end
+        scns
+      end
+    end
+
+    def list_available_scenarios
+      say ::HighLine.color("Available scenarios", :info)
+      available_scenarios.each do |config_file, content|
+        scenario = File.basename(config_file, '.yaml')
+        use = (File.expand_path(config_file) == @previous_scenario ? 'INSTALLED' : "use: --scenario #{scenario}")
+        say ::HighLine.color("  #{content[:name]} ", :title)
+        say "(#{use})"
+        say "        " + content[:description] if !content[:description].nil? && !content[:description].empty?
+      end
+      say "  No available scenarios found in #{config_dir}" if available_scenarios.empty?
+      KafoConfigure.exit(0)
+    end
+
+    def scenario_selection_wizard
+      wizard = KafoWizards.wizard(:cli, 'Select installation scenario',
+        :description => "Please select one of the pre-set installation scenarios. You can customize your setup later during the installation.")
+      f = wizard.factory
+      available_scenarios.keys.each do |scn|
+        label = available_scenarios[scn][:name].to_s
+        label += ": #{available_scenarios[scn][:description]}" if available_scenarios[scn][:description]
+        wizard.entries << f.button(scn, :label => label, :default => true)
+      end
+      wizard.entries << f.button(:cancel, :label => 'Cancel Installation', :default => false)
+      wizard
+    end
+
+    def select_scenario_interactively
+      # let the user select if in interactive mode
+      if (ARGV & ['--interactive', '-i']).any?
+        res = scenario_selection_wizard.run
+        if res == :cancel
+          say 'Installation was cancelled by user'
+          KafoConfigure.exit(0)
+        end
+        res
+      end
+    end
+
+    def scenario_changed?(scenario)
+      scenario = File.realpath(scenario) if File.symlink?(scenario)
+      !!previous_scenario && scenario != previous_scenario
+    end
+
+    def configured?
+      !!(defined?(CONFIG_DIR) && CONFIG_DIR)
+    end
+
+    def scenario_from_args
+      # try scenario provided in the args via -S or --scenario
+      parsed = ARGV.join(" ").match /(--scenario|-S)(\s+|[=]?)(\S+)/
+      if parsed
+        scenario_file = File.join(config_dir, "#{parsed[3]}.yaml")
+        return scenario_file if File.exists?(scenario_file)
+        KafoConfigure.logger.fatal "Scenario (#{scenario_file}) was not found, can not continue"
+        KafoConfigure.exit(:unknown_scenario)
+      end
+    end
+
+    def select_scenario
+      scenario = scenario_from_args || previous_scenario ||
+        (available_scenarios.keys.count == 1 && available_scenarios.keys.first) ||
+        select_scenario_interactively
+      if scenario.nil?
+        fail_now("Scenario was not selected, can not continue. Use --list-scenarios to list available options.", :unknown_scenario)
+      end
+      scenario
+    end
+
+    def scenario_from_args
+      # try scenario provided in the args via -S or --scenario
+      parsed = ARGV.join(" ").match /(--scenario|-S)(\s+|[=]?)(\S+)/
+      if parsed
+        scenario_file = File.join(config_dir, "#{parsed[3]}.yaml")
+        return scenario_file if File.exists?(scenario_file)
+        fail_now("Scenario (#{scenario_file}) was not found, can not continue", :unknown_scenario)
+      end
+    end
+
+    def show_scenario_diff(prev_scenario, new_scenario)
+      say ::HighLine.color("Scenarios are being compared, that may take a while...", :info)
+      prev_conf = load_and_setup_configuration(prev_scenario)
+      new_conf = load_and_setup_configuration(new_scenario)
+      print_scenario_diff(prev_conf, new_conf)
+    end
+
+    def check_scenario_change(scenario)
+      if scenario_changed?(scenario)
+        if ARGV.include? '--compare-scenarios'
+          show_scenario_diff(@previous_scenario, scenario)
+          dump_log_and_exit(0)
+        else
+          confirm_scenario_change(scenario)
+          KafoConfigure.logger.info "Scenario #{scenario} was selected"
+        end
+      end
+    end
+
+    def confirm_scenario_change(new_scenario)
+      unless ARGV.include?('--force')
+        if (ARGV & ['--interactive', '-i']).any?
+          show_scenario_diff(@previous_scenario, new_scenario)
+
+          wizard = KafoWizards.wizard(:cli, 'Confirm installation scenario selection',
+            :description => "You are trying to replace existing installation with different scenario. This may lead to unpredictable states. Please confirm that you want to proceed.")
+          wizard.entries << wizard.factory.button(:proceed, :label => 'Proceed with selected installation scenario', :default => false)
+          wizard.entries << wizard.factory.button(:cancel, :label => 'Cancel Installation', :default => true)
+          result = wizard.run
+          if result == :cancel
+            say 'Installation was cancelled by user'
+            dump_log_and_exit(0)
+          end
+        else
+          message = "You are trying to replace existing installation with different scenario. This may lead to unpredictable states. " +
+          "Use --force to override. You can use --compare-scenarios to see the differences"
+          KafoConfigure.logger.error(message)
+          dump_log_and_exit(:scenario_error)
+        end
+      end
+    end
+
+    def print_scenario_diff(prev_conf, new_conf)
+      missing = new_conf.params_missing(prev_conf)
+      changed = new_conf.params_changed(prev_conf)
+
+      say "\n" + ::HighLine.color("Overview of modules used in the scenarios (#{prev_conf.app[:name]} -> #{new_conf.app[:name]}):", :title)
+      modules = Hash.new { |h, k| h[k] = {} }
+      modules = prev_conf.modules.inject(modules) { |mods, mod| mods[mod.name][:prev] = mod.enabled?; mods }
+      modules = new_conf.modules.inject(modules) { |mods, mod| mods[mod.name][:new] = mod.enabled?; mods }
+      printables = { "" => 'N/A', 'true' => 'ENABLED', 'false' => 'DISABLED' }
+      modules.each do |mod, status|
+        module_line = "%-50s: %-09s -> %s" % [mod, printables[status[:prev].to_s], printables[status[:new].to_s]]
+        # highlight modules that will be disabled
+        module_line = ::HighLine.color(module_line, :important) if status[:prev] == true && (status[:new] == false || status[:new].nil?)
+        say module_line
+      end
+
+      say "\n" + ::HighLine.color("Defaults that will be updated with values from previous installation:", :title)
+      if changed.empty?
+        say "  No values will be updated from previous scenario"
+      else
+        changed.each { |param| say "  #{param.module.class_name}::#{param.name}: #{param.value} -> #{prev_conf.param(param.module.class_name, param.name).value}" }
+      end
+      say "\n" + ::HighLine.color("Values from previous installation that will be lost by scenario change:", :title)
+      if missing.empty?
+        say "  No values from previous installation will be lost"
+      else
+        missing.each { |param| say "  #{param.module.class_name}::#{param.name}: #{param.value}\n" }
+      end
+    end
+
+    def link_last_scenario(config_file)
+      link_path = last_scenario_link
+      if last_scenario_link
+        File.delete(last_scenario_link) if File.exist?(last_scenario_link)
+        File.symlink(config_file, last_scenario_link)
+      end
+    end
+
+    def load_and_setup_configuration(config_file)
+      conf = load_configuration(config_file)
+      conf.preset_defaults_from_puppet
+      conf.preset_defaults_from_yaml
+      conf
+    end
+
+    def load_configuration(config_file)
+      Configuration.new(config_file)
+    end
+
+    private
+
+    def fail_now(message, exit_code)
+      say "ERROR: #{message}"
+      KafoConfigure.logger.error message
+      KafoConfigure.exit(exit_code)
+    end
+
+    def dump_log_and_exit(code)
+      if Logger.buffering? && Logger.buffer.any?
+        Logger.setup_verbose
+        KafoConfigure.verbose = true
+        if !KafoConfigure.config.nil?
+          Logger.setup
+          KafoConfigure.logger.info("Log was be written to #{KafoConfigure.config.log_file}")
+        end
+        KafoConfigure.logger.info('Logs flushed')
+      end
+      KafoConfigure.exit(code)
+    end
+  end
+end