kafo 0.0.1

data/lib/kafo/exceptions.rb

@@ -0,0 +1,5 @@
+class ConfigurationException < StandardError
+end
+
+class ModuleName < StandardError
+end

data/lib/kafo/kafo_configure.rb

@@ -0,0 +1,180 @@
+require 'pty'
+require 'clamp'
+require 'kafo/exceptions'
+require 'kafo/configuration'
+require 'kafo/logger'
+require 'kafo/string_helper'
+require 'kafo/wizard'
+require 'kafo/system_checker'
+
+class KafoConfigure < Clamp::Command
+  include StringHelper
+  attr_reader :logger
+
+  class << self
+    attr_accessor :config, :root_dir
+  end
+
+  def initialize(*args)
+    root_dir            = Dir.pwd
+    @logger             = Logging.logger.root
+    # TODO read also file from different places (aka foreman_install puppet)
+    config_file         = File.join(root_dir, 'config', 'answers.yaml')
+    self.class.config   = Configuration.new(config_file)
+    self.class.root_dir = root_dir
+    set_env
+    super
+    set_parameters
+    set_options
+  end
+
+  def config
+    self.class.config
+  end
+
+  def execute
+    parse_cli_arguments
+
+    if verbose?
+      logger.appenders = logger.appenders << ::Logging.appenders.stdout(:layout => COLOR_LAYOUT)
+    end
+
+    unless SystemChecker.check
+      puts "Your system does not meet configuration criteria"
+      exit(20)
+    end
+
+    if interactive?
+      wizard = Wizard.new
+      wizard.run
+    else
+      unless validate_all
+        puts "Error during configuration, exiting"
+        exit(21)
+      end
+    end
+
+    store_params
+    run_installation
+  end
+
+  private
+
+  def params
+    @params ||= config.modules.map(&:params).flatten
+  rescue ModuleName => e
+    puts e
+    exit(24)
+  end
+
+  def set_parameters
+    params.each do |param|
+      # set values based on default_values
+      param.set_default(config.params_default_values)
+      # set values based on YAML
+      param.set_value_by_config(config)
+    end
+  end
+
+  def set_options
+    self.class.option ['-i', '--interactive'], :flag, 'Run in interactive mode?'
+    self.class.option ['-v', '--verbose'], :flag, 'Display log on STDOUT instead of progressbar?'
+    self.class.option ['-n', '--noop'], :flag, 'Run puppet in noop mode?', :default => false
+
+    config.modules.each do |mod|
+      self.class.option d("--[no-]enable-#{mod.name}"),
+                        :flag,
+                        "Enable puppet module #{mod.name}?",
+                        :default => mod.enabled?
+    end
+
+    params.each do |param|
+      doc = param.doc.nil? ? 'UNDOCUMENTED' : param.doc.join("\n")
+      self.class.option parametrize(param), '', doc,
+                        :default => param.value, :multivalued => param.multivalued?
+    end
+  end
+
+  def parse_cli_arguments
+    # enable/disable modules according to CLI
+    config.modules.each { |mod| send("enable_#{mod.name}?") ? mod.enable : mod.disable }
+
+    # set values coming from CLI arguments
+    params.each do |param|
+      variable_name = u(with_prefix(param))
+      variable_name += '_list' if param.multivalued?
+      cli_value = instance_variable_get("@#{variable_name}")
+      param.value = cli_value unless cli_value.nil?
+    end
+  end
+
+  def store_params
+    data = Hash[config.modules.map { |mod| [mod.name, mod.enabled? ? mod.params_hash : false] }]
+    config.store(data)
+  end
+
+  def validate_all(logging = true)
+    logger.info 'Running validation checks'
+    results = params.map do |param|
+      result = param.valid?
+      logger.error "Parameter #{param.name} invalid" if logging && !result
+      result
+    end
+    results.all?
+  end
+
+  def run_installation
+    exit_code = 0
+    modules_path = "modules:#{File.join(File.dirname(__FILE__), '../../modules')}"
+    options = [
+        "--modulepath #{modules_path}",
+        '--verbose',
+        '--debug',
+        '--color=false',
+        '--show_diff',
+        '--detailed-exitcodes',
+    ]
+    options.push '--noop' if noop?
+    begin
+      PTY.spawn("echo include kafo_configure | puppet apply #{options.join(' ')}") do |stdin, stdout, pid|
+        begin
+          stdin.each { |line| puppet_log(line) }
+        rescue Errno::EIO
+          exit_code = PTY.check(pid).exitstatus
+        end
+      end
+    rescue PTY::ChildExited
+    end
+    logger.info "Puppet has finished, bye!"
+    exit(exit_code)
+  end
+
+  def puppet_log(line)
+    method, message = case
+                        when line =~ /^Error:(.*)/i
+                          [:error, $1]
+                        when line =~ /^Warning:(.*)/i
+                          [:warn, $1]
+                        when line =~ /^Notice:(.*)/i
+                          [:warn, $1]
+                        when line =~ /^Info:(.*)/i
+                          [:info, $1]
+                        when line =~ /^Debug:(.*)/i
+                          [:debug, $1]
+                        else
+                          [:info, line]
+                      end
+    Logging.logger['puppet'].send(method, message.chomp)
+  end
+
+  def unset
+    params.select { |p| p.module.enabled? && p.value_set.nil? }
+  end
+
+  def set_env
+    # Puppet tries to determine FQDN from /etc/resolv.conf and we do NOT want this behavior
+    facter_hostname = Socket.gethostname
+    ENV['FACTER_fqdn'] = facter_hostname
+  end
+
+end

data/lib/kafo/logger.rb

@@ -0,0 +1,41 @@
+require 'fileutils'
+require 'logging'
+
+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
+)
+pattern        = "[%5l %d %c] %m\n"
+COLOR_LAYOUT   = Logging::Layouts::Pattern.new(:pattern => pattern, :color_scheme => 'bright')
+NOCOLOR_LAYOUT = Logging::Layouts::Pattern.new(:pattern => pattern, :color_scheme => nil)
+
+begin
+  FileUtils.mkdir_p(Configuration::KAFO[:log_dir], :mode => 0750)
+rescue Errno::EACCES => e
+  puts "No permissions to create log dir #{Configuration::KAFO[:log_dir]}"
+end
+
+logger   = Logging.logger.root
+filename = "#{Configuration::KAFO[:log_dir]}/configure.log"
+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 Configuration::KAFO[:log_owner], Configuration::KAFO[:log_group], filename
+rescue ArgumentError => e
+  puts "File #{filename} not writeable, won't log anything to file!"
+end
+
+logger.level = Configuration::KAFO[:log_level]

data/lib/kafo/param.rb

@@ -0,0 +1,65 @@
+class Param
+  attr_reader :name, :module
+  attr_accessor :default, :doc, :value_set
+
+  def initialize(builder, name)
+    @name = name
+    @module = builder
+  end
+
+  # we use @value_set flag because even nil can be valid value
+  def value
+    @value_set ? @value : default
+  end
+
+  def value=(value)
+    @value_set = true
+    @value = value == 'UNDEF' ? nil : value
+  end
+
+  def module_name
+    self.module.name
+  end
+
+  def to_s
+    "#<#{self.class}:#{self.object_id} @name=#{name.inspect} @default=#{default.inspect} @value=#{value.inspect}>"
+  end
+
+  def set_default(defaults)
+    if default == 'UNSET'
+      self.value = nil
+    else
+      self.value = (value = defaults[default]) == :undef ? nil : value
+    end
+  end
+
+  def set_value_by_config(config)
+    base = config[module_name]
+    self.value = base[name] if base.has_key?(name)
+  end
+
+  def valid?
+    validations = self.module.validations(self)
+    # we get validations that can also run on other arguments, we need to take only current param
+    # also we want to clone validations so we don't interfere
+    validations.map! do |v|
+      v = v.clone
+      args = v.arguments.select { |a| a.to_s == "$#{self.name}" }
+      v.arguments = Puppet::Parser::AST::ASTArray.new :children => args
+      v
+    end
+
+    validator = Validator.new([self])
+    validations.map { |v| v.evaluate(validator) }.all?
+  end
+
+  # To be overwritten in children
+  def multivalued?
+    false
+  end
+end
+
+require 'kafo/params/boolean'
+require 'kafo/params/string'
+require 'kafo/params/array'
+require 'kafo/params/integer'

data/lib/kafo/param_builder.rb

@@ -0,0 +1,59 @@
+class ParamBuilder
+  ATTRIBUTE_RE = /^(type):(.*)/
+
+  def initialize(mod, data)
+    @data   = data
+    @module = mod
+  end
+
+  def validate
+    parameters = @data['parameters'].keys.sort
+    docs       = @data['docs'].keys.sort
+    if parameters == docs
+      return true
+    else
+      undocumented = parameters - docs
+      raise ConfigurationException, "undocumented parameters in #{@module.name}: #{undocumented.join(', ')}" unless undocumented.empty?
+      deleted = docs - parameters
+      raise ConfigurationException, "documentation mentioned unknown parameters in #{@module.name}: #{deleted.join(', ')}" unless deleted.empty?
+      raise ConfigurationException, "unknown error in configuration in #{@module.name}"
+    end
+  end
+
+  def build_params
+    @data['parameters'].keys.map do |param_name|
+      build(param_name, @data['parameters'][param_name], @data['docs'][param_name])
+    end
+  end
+
+  def build(name, default, docs)
+    param         = get_type(docs).new(@module, name)
+    param.default = default
+    param.doc     = get_documentation(docs)
+    param
+  end
+
+  private
+
+  def get_documentation(docs)
+    return nil if docs.nil?
+    docs.select { |line| line !~ ATTRIBUTE_RE }
+  end
+
+  def get_type(docs)
+    type = (get_attributes(docs)[:type] || '').capitalize
+    type.empty? || !Params.const_defined?(type) ? Params::String : Params.const_get(type, false)
+  end
+
+  def get_attributes(docs)
+    data = {}
+    return data if docs.nil?
+
+    docs.each do |line|
+      if line =~ ATTRIBUTE_RE
+        data[$1.to_sym] = $2
+      end
+    end
+    data
+  end
+end

data/lib/kafo/params/array.rb

@@ -0,0 +1,18 @@
+module Params
+  class Array < Param
+    def value=(value)
+      super
+      @value = typecast(@value)
+    end
+
+    def multivalued?
+      true
+    end
+
+    private
+
+    def typecast(value)
+      value.nil? ? nil : [value].flatten
+    end
+  end
+end

data/lib/kafo/params/boolean.rb

@@ -0,0 +1,21 @@
+module Params
+  class Boolean < Param
+    def value=(value)
+      super
+      @value = typecast(@value)
+    end
+
+    private
+
+    def typecast(value)
+      case value
+        when '0', 'false', 'f', false
+          false
+        when '1', 'true', 't', true
+          true
+        else
+          value
+      end
+    end
+  end
+end

data/lib/kafo/params/integer.rb

@@ -0,0 +1,14 @@
+module Params
+  class Integer < Param
+    def value=(value)
+      super
+      @value = typecast(@value)
+    end
+
+    private
+
+    def typecast(value)
+      value.nil? ? nil : value.to_i
+    end
+  end
+end

data/lib/kafo/params/string.rb

@@ -0,0 +1,3 @@
+module Params
+  class String < Param; end
+end

data/lib/kafo/puppet_module.rb

@@ -0,0 +1,93 @@
+require 'kafo/param'
+require 'kafo/param_builder'
+require 'kafo/puppet_module_parser'
+require 'kafo/validator'
+
+class PuppetModule
+  attr_reader :name, :params, :dir_name, :class_name, :manifest_name, :manifest_path
+
+  def initialize(name, parser = PuppetModuleParser)
+    @name          = name
+    @dir_name      = get_dir_name
+    @manifest_name = get_manifest_name
+    @class_name    = get_class_name
+    @params        = []
+    @manifest_path = File.join(KafoConfigure.root_dir, '/modules/', module_manifest_path)
+    @parser        = parser
+    @validations   = []
+    @logger        = Logging.logger.root
+  end
+
+  def enabled?
+    @enabled.nil? ? @enabled = KafoConfigure.config.module_enabled?(self) : @enabled
+  end
+
+  def disable
+    @enabled = false
+  end
+
+  def enable
+    @enabled = true
+  end
+
+  def parse(builder_klass = ParamBuilder)
+    @params      = []
+    raw_data     = @parser.parse(manifest_path)
+    builder      = builder_klass.new(self, raw_data)
+    @validations = raw_data['validations']
+
+    builder.validate
+    @params      = builder.build_params
+
+    self
+  rescue ConfigurationException => e
+    puts "Unable to continue because of:"
+    puts e.message
+    exit(22)
+  end
+
+  def validations(param = nil)
+    if param.nil?
+      @validations
+    else
+      @validations.select do |validation|
+        validation.arguments.map(&:to_s).include?("$#{param.name}")
+      end
+    end
+  end
+
+  def params_hash
+    Hash[params.map { |param| [param.name, param.value] }]
+  end
+
+  private
+
+  # customer module directory name
+  def get_dir_name
+    case name
+      when 'puppetmaster'
+        'puppet'
+      else
+        name
+    end
+  end
+
+  # custom manifest filename without .pp extension
+  def get_manifest_name
+    case name
+      when 'puppetmaster'
+        'server'
+      else
+        'init'
+    end
+  end
+
+  def get_class_name
+    manifest_name == 'init' ? name : "#{dir_name}::#{manifest_name}"
+  end
+
+  def module_manifest_path
+    "#{dir_name}/manifests/#{manifest_name}.pp"
+  end
+
+end