kafo 5.0.1 → 6.1.2

data/lib/kafo/logger.rb

@@ -1,138 +1,28 @@
 # encoding: UTF-8
-require 'fileutils'
-require 'logging'
+require 'kafo/logging'
 
 module Kafo
   class Logger
-    class << self
-      attr_writer :loggers
 
-      def loggers
-        @loggers ||= []
-      end
-
-      def buffer
-        @buffer ||= []
-      end
-
-      def error_buffer
-        @error_buffer ||= []
-      end
-    end
-
-    PATTERN = "[%5l %d %c] %m\n"
-    Logging.color_scheme('bright',
-                         :levels => {
-                             :info  => :green,
-                             :warn  => :yellow,
-                             :error => :red,
-                             :fatal => [:white, :on_red]
-                         },
-                         :date   => :blue,
-                         :logger => :cyan,
-                         :line   => :yellow,
-                         :file   => :yellow,
-                         :method => :yellow
-    )
-    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)
-      rescue Errno::EACCES
-        puts "No permissions to create log dir #{KafoConfigure.config.app[:log_dir]}"
-      end
-
-      logger   = Logging.logger['main']
-      filename = KafoConfigure.config.log_file
-      begin
-        logger.appenders = ::Logging.appenders.rolling_file('configure',
-                                                            :filename => filename,
-                                                            :layout   => NOCOLOR_LAYOUT,
-                                                            :truncate => true
-        )
-        # set owner and group (it's ignored if attribute is nil)
-        FileUtils.chown KafoConfigure.config.app[:log_owner], KafoConfigure.config.app[:log_group], filename
-      rescue ArgumentError
-        puts "File #{filename} not writeable, won't log anything to file!"
-      end
-
-      logger.level = KafoConfigure.config.app[:log_level]
-      self.loggers << 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 && KafoConfigure.config.app[:verbose_log_level]) || :info
-      layout           = color_layout
-      logger.appenders = [::Logging.appenders.stdout(:layout => layout)]
-      self.loggers<< logger
-    end
+    attr_reader :logger, :name
 
-    def self.buffering?
-      KafoConfigure.verbose.nil? || ((KafoConfigure.verbose && !loggers.detect {|l| l.name == 'verbose'}) || self.loggers.empty?)
+    def initialize(name = 'root')
+      @name = name
+      @logger = (name == 'root') ? Logging.root_logger : Logging.add_logger(name)
     end
 
-    def self.dump_needed?
-      !self.buffer.empty?
-    end
-
-    def self.to_buffer(buffer, *args)
-      buffer << args
-    end
-
-    def self.dump_errors
-      setup_fatal_logger(color_layout) if loggers.empty?
-      unless self.error_buffer.empty?
-        loggers.each { |logger| logger.error 'Errors encountered during run:' }
-        self.dump_buffer(self.error_buffer)
-      end
-    end
-
-    def dump_errors
-      self.class.dump_errors
-    end
-
-    def self.dump_buffer(buffer)
-      buffer.each do |log|
-        self.loggers.each { |logger| logger.send log[0], *([log[1]].flatten(1)), &log[2] }
-      end
-      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)
+    def log(level, *args, &block)
+      if Logging.buffering?
+        Logging.to_buffer(@name, level, args, &block)
       else
-        self.class.dump_buffer(self.class.buffer) if self.class.dump_needed?
-        self.class.loggers.each { |logger| logger.send name, *args, &block }
-      end
-    end
-
-    %w(warn info debug).each do |name|
-      define_method(name) do |*args, &block|
-        self.log(name, *args, &block)
+        Logging.dump_buffer if Logging.dump_needed?
+        @logger.send(level, *args, &block)
       end
     end
 
-    %w(fatal error).each do |name|
-      define_method(name) do |*args, &block|
-        self.class.to_buffer(self.class.error_buffer, name, *args, &block)
-        self.log(name, *args, &block)
+    Logging::LOG_LEVELS.each do |level|
+      define_method(level) do |*args, &block|
+        log(level, *args, &block)
       end
     end
   end

data/lib/kafo/logging.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+
+require 'fileutils'
+require 'logging'
+
+module Kafo
+  class Logging
+
+    LOG_LEVELS = [:debug, :info, :notice, :warn, :error, :fatal]
+
+    if ::Logging::LEVELS.keys.map(&:to_symbol) != LOG_LEVELS
+      ::Logging.init(:debug, :info, :notice, :warn, :error, :fatal)
+    end
+
+    class << self
+      def root_logger
+        @root_logger ||= ::Logging.logger.root
+      end
+
+      def setup(verbose: false)
+        set_color_scheme
+
+        level = KafoConfigure.config.app[:log_level]
+
+        setup_file_logging(
+          level,
+          KafoConfigure.config.app[:log_dir],
+          KafoConfigure.config.app[:log_owner],
+          KafoConfigure.config.app[:log_group]
+        )
+        setup_verbose(level: KafoConfigure.config.app[:verbose_log_level] || level) if verbose
+      end
+
+      def setup_file_logging(log_level, log_dir, log_owner, log_group)
+        filename = KafoConfigure.config.log_file
+
+        begin
+          FileUtils.mkdir_p(log_dir, :mode => 0750)
+        rescue Errno::EACCES
+          puts "No permissions to create log dir #{log_dir}"
+        end
+
+        begin
+          root_logger.appenders = ::Logging.appenders.rolling_file(
+            'configure',
+            level: log_level,
+            filename: filename,
+            layout: layout(color: false),
+            truncate: true,
+            roll_by: 'date'
+          )
+
+          FileUtils.chown(
+            log_owner,
+            log_group,
+            filename
+          )
+        rescue ArgumentError
+          puts "File #{filename} not writeable, won't log anything to file!"
+        end
+      end
+
+      def set_color_scheme
+        ::Logging.color_scheme(
+          'bright',
+          :levels => {
+            :info => :cyan,
+            :notice => :green,
+            :warn  => :yellow,
+            :error => :red,
+            :fatal => [:white, :on_red]
+          },
+          :date   => :blue,
+          :logger => :cyan,
+          :line   => :yellow,
+          :file   => :yellow,
+          :method => :yellow
+        )
+      end
+
+      def layout(color: false)
+        ::Logging::Layouts::Pattern.new(
+          pattern: "%d [%-6l] [%c] %m\n",
+          color_scheme: color ? 'bright' : nil,
+          date_pattern: '%Y-%m-%d %H:%M:%S'
+        )
+      end
+
+      def add_logger(name)
+        ::Logging.logger[name]
+      end
+
+      def setup_verbose(level: :notice)
+        root_logger.add_appenders(
+          ::Logging.appenders.stdout(
+            'verbose',
+            layout: layout(color: KafoConfigure.use_colors?),
+            level: level
+          )
+        )
+      end
+
+      def buffer
+        @buffer ||= []
+      end
+
+      def buffering?
+        root_logger.appenders.empty?
+      end
+
+      def dump_needed?
+        !buffer.empty?
+      end
+
+      def to_buffer(*args)
+        buffer << args
+      end
+
+      def dump_buffer
+        @buffer.each do |log|
+          ::Logging.logger[log[0]].send(log[1], *([log[2]].flatten(2)), &log[3])
+        end
+        @buffer.clear
+      end
+    end
+
+  end
+end

data/lib/kafo/param.rb

@@ -123,12 +123,12 @@ module Kafo
       @type.multivalued?
     end
 
-    def <=> o
+    def <=>(other)
       unless @module.configuration.app[:no_prefix]
-        r = self.module_name <=> o.module_name
+        r = self.module_name <=> other.module_name
         return r unless r == 0
       end
-      self.name <=> o.name
+      self.name <=> other.name
     end
 
     def visible?(context = [])

data/lib/kafo/puppet_command.rb

@@ -43,8 +43,15 @@ module Kafo
       File.join([bin_path, bin_name].compact)
     end
 
+    def self.is_aio_puppet?
+      puppet_command = search_puppet_path('puppet')
+      File.realpath(puppet_command).start_with?('/opt/puppetlabs')
+    rescue Errno::ENOENT
+      false
+    end
+
     def self.format_command(command)
-      if search_puppet_path('puppet').start_with?('/opt/puppetlabs')
+      if is_aio_puppet?
         [clean_env_vars, command, :unsetenv_others => true]
       else
         [::ENV, command, :unsetenv_others => false]

data/lib/kafo/puppet_log_parser.rb

@@ -8,18 +8,24 @@ module Kafo
       method, message = case
                           when line =~ /^Error:(.*)/i || line =~ /^Err:(.*)/i
                             [:error, $1]
-                          when line =~ /^Warning:(.*)/i || line =~ /^Notice:(.*)/i
-                            [:warn, $1]
-                          when line =~ /^Info:(.*)/i
+                          when line =~ /^Notice:(.*)/i
                             [:info, $1]
-                          when line =~ /^Debug:(.*)/i
+                          when line =~ /^Warning:(.*)/i || line =~ /^Debug:(.*)/i || line =~ /^Info:(.*)/i
                             [:debug, $1]
                           else
                             [@last_level.nil? ? :info : @last_level, line]
                         end
 
+      if message.include?('Loading facts') && method != :error
+        method = :debug
+      end
+
+      if message.include?('Applying configuration version')
+        method = :debug
+      end
+
       @last_level = method
-      return [method, message.chomp]
+      return [method, message.chomp.strip]
     end
   end
 end

data/lib/kafo/puppet_module.rb

@@ -96,16 +96,16 @@ module Kafo
       Hash[params.map { |param| [param.name, param.value] }]
     end
 
-    def <=> o
+    def <=>(other)
       @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)
-          return self.name.sub(/.*#{module_name}/, '') <=> o.name.sub(/.*#{module_name}/, '')
+        return 1 if self.name.include?(module_name) && !other.name.include?(module_name)
+        return -1 if !self.name.include?(module_name) && other.name.include?(module_name)
+        if self.name.include?(module_name) && other.name.include?(module_name)
+          return self.name.sub(/.*#{module_name}/, '') <=> other.name.sub(/.*#{module_name}/, '')
         end
       end
 
-      self.name <=> o.name
+      self.name <=> other.name
     end
 
     private

data/lib/kafo/scenario_manager.rb

@@ -6,7 +6,8 @@ module Kafo
   class ScenarioManager
     attr_reader :config_dir, :last_scenario_link, :previous_scenario
 
-    def initialize(config, last_scenario_link_name='last_scenario.yaml')
+    def initialize(config, last_scenario_link_name = 'last_scenario.yaml')
+      @logger = Logger.new('scenario_manager')
       @config_dir = File.file?(config) ? File.dirname(config) : config
       @last_scenario_link = File.join(config_dir, last_scenario_link_name)
       @previous_scenario = File.exist?(last_scenario_link) ? Pathname.new(last_scenario_link).realpath.to_s : nil
@@ -76,7 +77,7 @@ module Kafo
       !!(defined?(CONFIG_DIR) && CONFIG_DIR)
     end
 
-    def scenario_from_args(arg_name='--scenario|-S')
+    def scenario_from_args(arg_name = '--scenario|-S')
       # try scenario provided in the args via -S or --scenario
       ARGV.each_with_index do |arg, index|
         parsed = arg.match(/^(#{arg_name})($|=(?<scenario>\S+))/)
@@ -123,7 +124,7 @@ module Kafo
           dump_log_and_exit(0)
         else
           confirm_scenario_change(scenario)
-          KafoConfigure.logger.info "Scenario #{scenario} was selected"
+          @logger.notice "Scenario #{scenario} was selected"
         end
       end
     end
@@ -166,7 +167,7 @@ module Kafo
       elsif !ARGV.include?('--force') && !KafoConfigure.in_help_mode?
         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)
+        @logger.error(message)
         dump_log_and_exit(:scenario_error)
       end
       true
@@ -225,19 +226,17 @@ module Kafo
 
     def fail_now(message, exit_code)
       $stderr.puts "ERROR: #{message}"
-      KafoConfigure.logger.error message
+      @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 Logging.buffering? && Logging.buffer.any?
         if !KafoConfigure.config.nil?
-          Logger.setup
-          KafoConfigure.logger.info("Log was be written to #{KafoConfigure.config.log_file}")
+          Logging.setup(verbose: true)
+          @logger.notice("Log was be written to #{KafoConfigure.config.log_file}")
         end
-        KafoConfigure.logger.info('Logs flushed')
+        @logger.notice('Logs flushed')
       end
       KafoConfigure.exit(code)
     end

data/lib/kafo/store.rb

@@ -4,7 +4,7 @@ module Kafo
   class Store
     attr_accessor :data
 
-    def initialize(path=nil)
+    def initialize(path = nil)
       @data = {}
       load_path(path) if path
     end

data/lib/kafo/string_helper.rb

@@ -18,7 +18,7 @@ module Kafo
       "#{prefix}#{d(param.name)}"
     end
 
-    def parametrize(param, prefix='')
+    def parametrize(param, prefix = '')
       "--#{prefix}#{with_prefix(param)}"
     end
   end