kafo 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kafo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,11 @@
+This program and entire repository is free software: you can redistribute it 
+and/or modify it under the terms of the GNU General Public License as 
+published by the Free Software Foundation, either version 3 of the License, 
+or any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT 
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with 
+this program. If not, see http://www.gnu.org/licenses/.

data/README.md

@@ -0,0 +1,269 @@
+# Kafo
+
+A puppet based installer and configurer (not-only) for Foreman and Katello
+projects. Kafo is a ruby gem that allows you to create fancy user interfaces for
+puppet modules. It's some kind of a nice frontend to a
+
+```bash
+echo "include some_modules" | puppet apply
+```
+## Why should I care?
+
+Suppose you work on a software which you want to distribute to a machine in
+infrastructure managed by puppet. You write a puppet module for your app.
+But you also want to be able to distribute this app to a machine outside of
+puppet infrastructure (e.g. install it to your clients) or you want to install
+it in order to create a puppet infrastructure itself (e.g. foreman or
+foreman-proxy).
+
+With kafo you can reuse your puppet modules for creating an installer. Even
+better after the installation you can easily modify you configuration. All
+using the very same puppet modules.
+
+## What it does, how does it work?
+
+Kafo reads a config file to find out which modules should it use. Then it
+loads parameters from puppet manifests and gives you a way to customize them.
+
+There are three ways how you can set parameters. You can
+ * predefine them in configuration file
+ * specify them as CLI arguments
+ * you can use interactive mode which will ask you for all required parameters
+
+Note that your answers (gathered from any mode) are saved for the next run
+so you don't have to specify them again. Kafo also support default values of
+parameters so you can set only those you want to change. Also you can combine
+akk modes so you can create an answer file with default values easily
+and then use it for unattended installs.
+
+## How do I use it?
+
+First install kafo gem.
+
+Using bundler - add kafo gem to your Gemfile and run
+```bash
+bundle install
+```
+
+or without bundler
+```bash
+gem install kafo
+```
+
+Create a directory for your installer. Let's say we want to create
+foreman-installer.
+
+```bash
+mkdir foreman-installer
+cd foreman-installer
+```
+
+Now we run +kafofy+ script which will prepare directory structure and
+optionally create a bin script according to first parameter.
+
+```bash
+kafofy foreman-installer
+```
+
+You can see that it created modules directory where your puppet modules
+should live. It also created config and bin directories. If you specified
+argument (foreman-installer in this case) a script in bin was created.
+It's the script you can use to run installer. If you did not specify any
+you can run your installer by +kafo-configure+ which is provided by the gem.
+All configuration related files are to be found in config directory.
+
+So for example to install foreman you want to
+```bash
+cd foreman-installer/modules
+git clone https://github.com/theforeman/puppet-foreman/ foreman
+```
+Currently you must also download any dependant modules.
+Then you need to tell kafo it's going to use foreman module.
+```bash
+cd ..
+echo "foreman: true" > config/answers.yaml
+```
+Fire it with -h
+```bash
+bin/foreman-installer -h
+```
+
+You will see all arguments that you can pass to kafo. Note that underscored
+puppet parameters are automatically converted to dashed arguments. You can
+also see a documentation extracted from foreman puppet module and default
+value.
+
+Now run it without -h argument. It will print you the puppet apply command
+to execute. This will be automatized later. Look at config/answers.yaml, it
+was populated with default values. To change those options you can use
+arguments like this
+
+```bash
+bin/foreman-installer --foreman-enc=false --foreman-db-type=sqlite
+```
+
+or you can run interactive mode
+
+```bash
+bin/foreman-installer --interactive
+```
+
+Also every change made to config/answers.yaml persists and becomes new default
+value for next run.
+
+As you noticed there are several ways how to specify arguments. Here's the list
+the lower the item is the higher precedence it has:
+  * default values from puppet modules
+  * values from answers.yaml
+  * values specified on CLI
+  * interactive mode arguments
+
+# Advanced topics
+
+## Testing aka noop
+
+You'll probably want to tweak your installer before so you may find --noop
+argument handy. This will run puppet in noop so no change will be done to your
+system. Default value is false!
+
+## Documentation
+
+Every parameter that can be set by kafo *must* be documented. This means that
+you must add documentation to your puppet class in init.pp. It's basically
+rdoc formatted documentation that must be above class definitions. There can
+be no space between doc block and class definition.
+
+Example:
+```puppet
+# Manage your foreman server
+#
+# This class ...
+# ... does what it does.
+#
+# === Parameters:
+#
+# $foreman_url::            URL on which foreman is going to run
+#
+# $enc::                    Should foreman act as an external node classifier (manage puppet class
+#                           assignments)
+#                           type:boolean
+class foreman (
+  $foreman_url            = $foreman::params::foreman_url,
+  $enc                    = $foreman::params::enc
+) {
+  class { 'foreman::install': }
+}
+```
+
+## Argument types
+
+By default all arguments that are parsed from puppet are treated as string.
+If you want to indicate that a parameter has a particular type you can do it
+in puppet manifest documentation like this
+
+```puppet
+# $param::        Some documentation for param
+                  type:boolean
+```
+
+Supported types are: string, boolean, integer, array
+
+Note that all arguments that are nil (have no value in answers.yaml or you
+set them UNDEF (see below) are translated to ```undef``` in puppet.
+
+## Array arguments
+
+Some arguments may be Arrays. If you want to specify array values you can
+specify CLI argument multiple times e.g.
+```bash
+bin/foreman-installer --puppetmaster-environments=development --puppetmaster-environments=production
+```
+
+In interactive mode you'll be prompted for another value until you specify
+blank line.
+
+## Validations
+
+If you specify validations of parameters in you init.pp manifest they
+will be executed for your values even before puppet is run. In order to do this
+you must follow few rules however:
+
+* you must use standard validation functions (e.g. validate_array, validate_re, ...)
+* you must have stdlib in modules directory
+
+## Enabling or disabling module
+
+You can enable or disable module specified in answers.yaml file. Every module
+automatically adds two options to foreman-installer script. For module foreman
+you have two flag options ```--enable-foreman``` and ```--no-enable-foreman```.
+
+When you disable a module all its answers will be removed and module will be
+set to false. When you reenable the module you'll end up with default values.
+
+## Special values for arguments
+
+Sometimes you may want to enforce ```undef``` value for a particular parameter.
+You can set this value by specifying UNDEF string e.g.
+
+```bash
+bin/foreman-installer --foreman-db-password=UNDEF
+```
+
+It also works in interactive mode.
+
+## Changing of log directory and user/group
+
+By default kafo logs every run to a separate file in /var/log/kafo.
+You probably want to put your installation logs alongside with other logs of
+your application. That's why kafo has its own configuration file in which you
+can tune details like this.
+
+In order to do that create a configuration file in config/kafo.yaml. You can
+use config/kafo.yaml.example as a template. If config/kafo.yaml does not exist
+default values will be used.
+
+As a developer you can appreciate more verbose log. You can set debug level
+in config/kafo.yml. Also you can change a user or group that will own the
+log file. This is usefull if your installer requires to be run under root
+but you want the logs to be readable by specific users.
+
+## System checks
+
+When you want to make sure that user has some software installed or has the
+right version you can write a simple script and put it into checks directory.
+All files found there will be ran and if any has non-zero exit code, kafo
+wont execute puppet.
+
+Everything on STDOUT is logged in debug level, everything on STDERR is logged
+in error level.
+
+Example shell script which checks java version
+
+```bash
+#!/bin/sh
+java -version 2>&1 | grep OpenJDK
+exit $?
+```
+
+## Exit code
+
+Kafo can terminate either before or after puppet is ran. Puppet is ran with
+--detailed-exitcodes and Kafo returns the same exit code as puppet does. If
+kafo terminates after puppet run exit codes are:
+* '2' means there were changes,
+* '4' means there were failures during the transaction,
+* '6' means there were both changes and failures.
+
+Other exit codes that can be returned:
+* '0' means everything went fine no changes were made
+* '20' means your system does not meet configuration criteria (system checks failed)
+* '21' means your answer file contains invalid values
+* '22' means that puppet modules contains some error (e.g. missing documentation)
+* '23' means that you have no answer file
+* '24' means that your answer file asks for puppet module that you did not provide
+* '25' means that kafo could not get default values from puppet
+
+
+# License
+
+This project is licensed under the GPLv3+.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/kafo-configure

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# TODO cover with tests
+# TODO validations: "puppet master --compile <fqdn>" compiles a catalog for a given host but it uses the global manifest/modules rather than stdin.. but by specifying --manifestdir you could get it to read a site.pp that contains the "include kafo_configure"
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'kafo'))
+require 'kafo_configure'
+KafoConfigure.run

data/bin/kafofy

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+# Create directory structure
+%w(bin config modules).each do |dir|
+  FileUtils.mkdir_p dir
+end
+
+# Copy config files
+src = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+%w(config_header.txt kafo.yaml.example).each do |file|
+  FileUtils.cp src + "/config/#{file}", 'config/'
+end
+
+script_name = "kafo-configure"
+# Optional configure script
+if ARGV.size > 0
+  name = ARGV[0]
+  script_name = "bin/#{name}"
+  puts "... creating #{script_name}"
+  content = <<EOS
+#!/usr/bin/env ruby
+require 'kafo'
+KafoConfigure.run
+EOS
+  File.write script_name, content
+  FileUtils.chmod 0755, script_name
+end
+
+puts "Your directory was kafofied"
+
+puts "Now you should:"
+puts "  1. upload your puppet modules to modules directory"
+puts "  2. create default config/answers.yaml"
+puts "  3. run #{script_name}"

data/config/config_header.txt

@@ -0,0 +1,8 @@
+# Format:
+# <classname>: false - don't include this class
+# <classname>: true - include and use the defaults
+# <classname>:
+#   <param>: <value> - include and override the default(s)
+#
+# See params.pp in each class for what options are available
+

data/config/kafo.yaml.example

@@ -0,0 +1,11 @@
+# kafo main configuration file example
+# you can rename it to kafo.yaml so it overwrite default kafo settings
+# useful for development, e.g. when you want to move log files to local directory
+
+# :log_dir: '/var/log/kafo'
+# :log_level: :info
+
+# Advanced configuration - if not set it's ignored
+# :log_owner: root
+# :log_group: root
+

data/kafo.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift(lib + '/kafo')
+$LOAD_PATH.unshift(lib + '/kafo/params')
+require 'kafo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kafo"
+  spec.version       = Kafo::VERSION
+  spec.authors       = ["Marek Hulan"]
+  spec.email         = ["ares@igloonet.cz"]
+  spec.description   = %q{A gem for making installations based on puppet user friendly}
+  spec.summary       = %q{If you write puppet modules for installing your software, you can use kafo to create powerful installer}
+  spec.homepage      = "https://github.com/theforeman/kafo-configure"
+  spec.license       = "GPLv3+"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  # puppet manifests parsing
+  spec.add_dependency 'puppet'
+  spec.add_dependency 'rdoc', '~> 3.0'
+  # better logging
+  spec.add_dependency 'logging'
+  # CLI interface
+  spec.add_dependency 'clamp'
+  # interactive mode
+  spec.add_dependency 'highline'
+
+end

data/lib/kafo.rb

@@ -0,0 +1,2 @@
+require 'kafo/version'
+require 'kafo/kafo_configure'

data/lib/kafo/configuration.rb

@@ -0,0 +1,87 @@
+require 'yaml'
+require 'kafo/puppet_module'
+
+class Configuration
+  attr_reader :config_file
+
+
+  begin
+    default_hash = YAML.load_file(File.join(Dir.pwd, 'config/kafo.yaml'))
+  rescue => e
+    default_hash = {}
+  end
+  KAFO = {
+      :log_dir   => '/var/log/kafo',
+      :log_level => :info,
+  }.merge(default_hash || {})
+
+  def initialize(file)
+    @logger = Logging.logger.root
+    @logger.info "Loading config file #{file}"
+
+    begin
+      @data        = YAML.load_file file
+    rescue Errno::ENOENT => e
+      puts "No answers file at #{file} found, can not continue"
+      exit(23)
+    end
+
+    @config_file = file
+    @config_dir  = File.join(Dir.pwd, 'config')
+  end
+
+  def modules
+    @modules ||= @data.keys.map { |mod| PuppetModule.new(mod).parse }
+  end
+
+  def params_default_values
+    @params_default_values ||= begin
+      @logger.info "Parsing default values from puppet modules..."
+      # TODO not dry, kafo_configure.rb does similar thing
+      modules_path = "modules:#{File.join(gem_root_path, '../../modules')}"
+      @logger.debug `echo '#{includes} dump_values(#{params})' | puppet apply --modulepath #{modules_path} 2>&1`
+      unless $?.exitstatus == 0
+        @logger.error "Could not get default values, cannot continue"
+        exit(25)
+      end
+      @logger.info "... finished"
+      YAML.load_file(File.join(@config_dir, 'default_values.yaml'))
+    end
+  end
+
+  # if a value is a true we return empty hash because we have no specific options for a
+  # particular puppet module
+  def [](key)
+    value = @data[key]
+    value.is_a?(Hash) ? value : {}
+  end
+
+  def module_enabled?(mod)
+    value = @data[mod.name]
+    !!value || value.is_a?(Hash)
+  end
+
+  def config_header
+    @config_header ||= File.read(File.join(gem_root_path, '/config/config_header.txt'))
+  end
+
+  def gem_root_path
+    @gem_root_path ||= File.join(File.dirname(__FILE__), '../../')
+  end
+
+  def store(data)
+    File.write(config_file, config_header + YAML.dump(data))
+  end
+
+  private
+
+  def includes
+    modules.map { |mod| "include #{mod.dir_name}::params" }.join(' ')
+  end
+
+  def params
+    params = modules.map(&:params).flatten
+    params = params.select { |p| p.default != 'UNSET' }
+    params.map { |param| "#{param.default}" }.join(',')
+  end
+end