kafo 0.0.1

data/lib/kafo/puppet_module_parser.rb

@@ -0,0 +1,65 @@
+require 'puppet'
+require 'rdoc'
+# Based on ideas from puppet-parse by Johan van den Dorpe
+class PuppetModuleParser
+  def self.parse(file)
+    content = new(file)
+
+    {
+        'parameters'  => content.parameters,
+        'docs'        => content.docs,
+        'validations' => content.validations
+    }
+  end
+
+  def initialize(file)
+    raise ModuleName, "File not found #{file}, check you answer file" unless File.exists?(file)
+    parser = Puppet::Parser::Parser.new('production')
+    values = Puppet.settings.instance_variable_get('@values')
+    values[:production][:confdir] ||= '/' # just some stubbing
+    parser.import(file)
+
+    # Find object in list of hostclasses
+    parser.environment.known_resource_types.hostclasses.each do |x|
+      @object = x.last if x.last.file == file
+    end
+    # Find object in list of definitions
+    parser.environment.known_resource_types.definitions.each do |x|
+      @object = x.last if x.last.file == file
+    end
+  end
+
+  def parameters
+    parameters = {}
+    arguments  = @object.respond_to?(:arguments) ? @object.arguments : {}
+    arguments.each { |k, v| parameters[k] = v.respond_to?(:value) ? v.value : nil }
+    parameters
+  end
+
+  def klass
+    @object.name if @object.class.respond_to?(:name)
+  end
+
+  def validations(param = nil)
+    @object.code.select { |stmt| stmt.is_a?(Puppet::Parser::AST::Function) && stmt.name =~ /^validate_/ }
+  end
+
+  def docs
+    docs = {}
+    if !@object.doc.nil?
+      rdoc  = RDoc::Markup.parse(@object.doc)
+      items = rdoc.parts.select { |part| part.respond_to?(:items) }.map(&:items).flatten
+      items.each do |item|
+        # Skip rdoc items that aren't paragraphs
+        next unless (item.parts.to_s.scan("RDoc::Markup::Paragraph") == ["RDoc::Markup::Paragraph"])
+        # RDoc (>= 4) makes label an array
+        label = item.label.is_a?(Array) ? item.label.first : item.label
+        # Documentation must be a list - if there's no label then skip
+        next if label.nil?
+        key       = label.tr('^A-Za-z0-9_-', '')
+        docs[key] = item.parts.first.parts.map!(&:strip)
+      end
+    end
+    docs
+  end
+end

data/lib/kafo/string_helper.rb

@@ -0,0 +1,19 @@
+module StringHelper
+  def dashize(string)
+    string.tr('_', '-')
+  end
+  alias :d :dashize
+
+  def underscore(string)
+    string.tr('-', '_')
+  end
+  alias :u :underscore
+
+  def with_prefix(param)
+    "#{d(param.module_name)}-#{d(param.name)}"
+  end
+
+  def parametrize(param)
+    "--#{with_prefix(param)}"
+  end
+end

data/lib/kafo/system_checker.rb

@@ -0,0 +1,31 @@
+# we require separate STDERR
+require 'open3'
+
+class SystemChecker
+  def self.check
+    new(File.join(KafoConfigure.root_dir, 'checks', '*')).check
+  end
+
+  def initialize(path)
+    @checkers = Dir.glob(path)
+  end
+
+  def logger
+    Logging::logger['checks']
+  end
+
+  def check
+    @checkers.map! do |checker|
+      logger.debug "Executing checker: #{checker}"
+      Open3.popen3(checker) { |stdin, stdout, stderr, wait_thr|
+        stdout = stdout.read
+        stderr = stderr.read
+        logger.debug stdout unless stdout.empty?
+        logger.error stderr unless stderr.empty?
+        wait_thr.value.success?
+      }
+    end
+
+    @checkers.all?
+  end
+end

data/lib/kafo/validator.rb

@@ -0,0 +1,59 @@
+class Validator
+
+  def initialize(params)
+    files = KafoConfigure.root_dir + '/modules/stdlib/lib/puppet/parser/functions/validate_*.rb'
+    Dir.glob(files).each do |file|
+      require file
+    end
+
+    @params = params
+    @logger = Logging.logger.root
+
+    @cache ||= Hash.new do |hash, key|
+      @logger.debug "Looked for #{key}"
+      param     = @params.select { |p| p.name == key.to_s }.first
+      hash[key] = param.nil? ? nil : param.value
+    end
+  end
+
+  def lookupvar(name, options = {})
+    @cache[name]
+  end
+
+  # for puppet >= 3
+  def include?(value)
+    true
+  end
+
+  # for puppet >= 3
+  def [](value, *args)
+    lookupvar(value)
+  end
+
+  def method_missing(method, *args, &block)
+    method.to_s =~ /^function_(.*)$/
+    super unless $1
+    super unless Puppet::Parser::Functions.function($1)
+    # In odd circumstances, this might not end up defined by the previous
+    # method, so we might as well be certain.
+    if engine.respond_to? method
+      @logger.debug "calling #{method.inspect} with #{args.inspect}"
+      engine.send(method, *args)
+    else
+      raise Puppet::DevError, "Function #{$1} not defined despite being loaded!"
+    end
+  rescue Puppet::ParseError => e
+    @logger.error e.message
+    return false
+  end
+
+  private
+
+  def engine
+    @engine ||= begin
+      klass = Class.new
+      klass.send :include, Puppet::Parser::Functions.environment_module
+      klass.new
+    end
+  end
+end

data/lib/kafo/version.rb

@@ -0,0 +1,3 @@
+module Kafo
+  VERSION = "0.0.1"
+end

data/lib/kafo/wizard.rb

@@ -0,0 +1,131 @@
+# encoding: UTF-8
+require 'highline/import'
+require 'yaml'
+
+class Wizard
+  def initialize
+    setup_terminal
+    setup_colors
+    @name   = 'Kafo'
+    @config = KafoConfigure.config
+  end
+
+  def run
+    message = "Welcome to the #{@name} installer!"
+    say("<%= color('#{message}', :headline) %>")
+    say("<%= color('#{'-' * message.size}', :horizontal_line) %>")
+    say(<<END)
+
+This wizard will gather all required information. You can change any parameter to your needs.
+
+END
+
+    exit 0 unless agree("\n<%= color('Ready to start?', :question) %> (y/n)", false)
+
+    main_menu
+  end
+
+  private
+
+  def main_menu
+    finished = false
+    until finished
+      say("\n<%= color('Main Config Menu', :headline) %>")
+      choose do |menu|
+        menu.prompt = 'Choose an option from the menu... '
+        @config.modules.each do |mod|
+          menu.choice "[#{mod.enabled? ? '✓' : '✗'}] Configure #{mod.name}" do
+            configure_module(mod)
+          end
+        end
+        menu.choice "Display current config" do
+          display_hash
+        end
+        menu.choice "<%= color('Save and run', :run) %>" do
+          KafoConfigure.config
+          finished = true
+        end
+        menu.choice "<%= color('Cancel run without Saving', :cancel) %>" do
+          say("Bye!"); exit 0
+        end
+      end
+    end
+  end
+
+  def display_hash
+    data = Hash[@config.modules.map { |mod| [mod.name, mod.enabled? ? mod.params_hash : false] }]
+    say "<%= color('#{YAML.dump data}', :info) %>"
+  end
+
+  def configure_module(mod)
+    go_back = false
+    until go_back
+      say("\n<%= color('Module #{mod.name} configuration', :headline) %>")
+      choose do |menu|
+        menu.prompt = 'Choose an option from the menu... '
+        menu.choice("Enable/disable #{mod.name} module, current value: <%= color('#{mod.enabled?}', :info) %>") { turn_module(mod) }
+        if mod.enabled?
+          mod.params.each do |param|
+            menu.choice "Set <%= color('#{param.name}', :important) %>, current value: <%= color('#{param.value}', :info) %>" do
+              configure(param)
+            end
+          end
+        end
+        menu.choice("Back to main menu") { go_back = true }
+      end
+    end
+  end
+
+  def configure(param)
+    say "\n<%= color('Parameter #{param.name} (of module #{param.module.name})', :headline) %>"
+    say "<%= color(\"#{param.doc.join("\n")}\", :important) %>"
+    value = param.multivalued? ? configure_multi(param) : configure_single(param)
+    value_was = param.value
+    param.value = value unless value.empty?
+
+    until param.valid?
+      param.value = value_was
+      say "\n<%= color('Invalid value for #{param.name}', :important) %>"
+      value = param.multivalued? ? configure_multi(param) : configure_single(param)
+      param.value = value unless value.empty?
+    end
+  end
+
+  def configure_single(param)
+    say "\ncurrent value: <%= color('#{param.value}', :info) %>"
+    ask("new value:")
+  end
+
+  def configure_multi(param)
+    say "<%= color('every line is a separate value, blank line to quit', :info) %>"
+    say "\ncurrent value: <%= color('#{param.value}', :info) %>"
+    ask("new value:") do |q|
+      q.gather = ""
+    end
+
+  end
+
+  def turn_module(mod)
+    agree("Enable #{mod.name} module? (y/n) ") ? mod.enable : mod.disable
+  end
+
+  def setup_terminal
+    $terminal         = HighLine.new
+    data              = HighLine::SystemExtensions.terminal_size
+    $terminal.wrap_at = data.first > 80 ? 80 : data.first
+    $terminal.page_at = data.last
+  end
+
+  # setup colour scheme for prompts
+  def setup_colors
+    HighLine.color_scheme = HighLine::ColorScheme.new do |cs|
+      cs[:headline]        = [:bold, :yellow, :on_black]
+      cs[:horizontal_line] = [:bold, :white, :on_black]
+      cs[:important]       = [:bold, :white, :on_black]
+      cs[:question]        = [:bold, :green, :on_black]
+      cs[:info]            = [:bold, :cyan, :on_black]
+      cs[:cancel]          = [:bold, :red, :on_black]
+      cs[:run]             = [:bold, :green, :on_black]
+    end
+  end
+end

data/modules/kafo_configure/lib/puppet/parser/functions/class_name.rb

@@ -0,0 +1,18 @@
+# Translates module name to proper class name
+# This is especially useful if you want to give a nice name to
+# a configuration option and still want to use some class with
+# less readable name e.g. puppetmaster -> puppet::server
+# - if the argument matches known module name, it returns corresponding class name
+# - otherwise it returns argument that was specified
+#
+module Puppet::Parser::Functions
+  newfunction(:class_name, :type => :rvalue) do |args|
+    case args[0]
+      when 'puppetmaster'
+        'puppet::server'
+    else
+      args[0]
+    end
+  end
+end
+

data/modules/kafo_configure/lib/puppet/parser/functions/dump_values.rb

@@ -0,0 +1,9 @@
+# Find default values for variables specified as args
+#
+module Puppet::Parser::Functions
+  newfunction(:dump_values) do |args|
+    data = Hash[args.map { |arg| [arg, lookupvar(arg)] }]
+    File.write('config/default_values.yaml', YAML.dump(data))
+  end
+end
+

data/modules/kafo_configure/lib/puppet/parser/functions/hash_keys.rb

@@ -0,0 +1,15 @@
+# Takes a hash to extract keys from
+# - If the first argument is not Hash, print warning and return nil
+# - Returns array of hash keys otherwise
+#
+module Puppet::Parser::Functions
+  newfunction(:hash_keys, :type => :rvalue) do |args|
+    unless args[0].is_a?(Hash)
+      Puppet.warning "hash_keys takes one argument, the input hash"
+      nil
+    else
+      args[0].keys
+    end
+  end
+end
+

data/modules/kafo_configure/lib/puppet/parser/functions/is_hash.rb

@@ -0,0 +1,22 @@
+#
+# is_hash.rb
+#
+
+module Puppet::Parser::Functions
+  newfunction(:is_hash, :type => :rvalue, :doc => <<-EOS
+Returns true if the variable passed to this function is a hash.
+    EOS
+  ) do |arguments|
+
+    raise(Puppet::ParseError, "is_hash(): Wrong number of arguments " +
+      "given (#{arguments.size} for 1)") if arguments.size != 1
+
+    type = arguments[0]
+
+    result = type.is_a?(Hash)
+
+    return result
+  end
+end
+
+# vim: set ts=2 sw=2 et :

data/modules/kafo_configure/lib/puppet/parser/functions/loadanyyaml.rb

@@ -0,0 +1,37 @@
+module Puppet::Parser::Functions
+
+  # convert nil values to :undefined recursively
+  newfunction(:convert, :type => :rvalue) do |args|
+    hash = args[0]
+    data = {}
+
+    hash.each do |key, value|
+      if value.is_a?(Hash)
+        data[key] = function_convert([value])
+      else
+        data[key] = value.nil? ? :undef : value
+      end
+    end
+
+    data
+  end
+
+  newfunction(:loadanyyaml, :type => :rvalue, :doc => <<-'ENDHEREDOC') do |args|
+    Load a YAML file containing an array, string, or hash, and return the data
+    in the corresponding native data type.
+
+    For example:
+
+        $myhash = loadanyyaml('/etc/puppet/data/myhash.yaml')
+    ENDHEREDOC
+
+    args.delete_if { |filename| not File.exist? filename }
+
+    if args.length == 0
+      raise Puppet::ParseError, ("loadanyyaml(): No files to load")
+    end
+
+    function_convert([YAML.load_file(args[0])])
+  end
+
+end

data/modules/kafo_configure/manifests/init.pp

@@ -0,0 +1,17 @@
+# This class is called from the kafo configure script
+# and expects a yaml file to exist at either:
+#   optional $answers class parameter
+#   $modulepath/config/answers.yaml
+#   /etc/kafo-configure/answers.yaml
+#
+class kafo_configure(
+  $answers = undef
+) {
+
+  $params = loadanyyaml($answers,
+                      "/etc/kafo-configure/answers.yaml",
+                      "config/answers.yaml")
+  $keys = hash_keys($params)
+
+  kafo_configure::yaml_to_class { $keys: }
+}

data/modules/kafo_configure/manifests/yaml_to_class.pp

@@ -0,0 +1,24 @@
+# Takes a key to lookup in the installation answers file
+# - If it's a hash, declare a class with those parameters
+# - If it's true or "true" declare the default parameters for that class
+# - If it's false or "false" ignore it
+# - Otherwise fail with error
+#
+define kafo_configure::yaml_to_class {
+
+  $classname = class_name($name)
+
+  if is_hash($kafo_configure::params[$name]) {
+    # The quotes around $classname seem to matter to puppet's parser...
+    $params = { "${classname}" => $kafo_configure::params[$name] }
+    create_resources( 'class', $params )
+  } elsif $kafo_configure::params[$name] == true {
+    $params = { "${classname}" => {} }
+    create_resources( 'class', $params )
+  } elsif ! $kafo_configure::params[$name] or $kafo_configure::params[$name] == "false" {
+    debug("${::hostname}: not including $name")
+  } else {
+    fail("${::hostname}: unknown type of answers data for $name")
+  }
+
+}