kafo 0.0.6 → 0.0.7

data/README.md

@@ -251,7 +251,7 @@ file. Also we want to name our module as puppetmaster. We add following mapping
 to kafo.yaml
 
 ```yaml
-:mapping
+:mapping:
   :puppetmaster:                # a module name, so we'll have puppetmaster: true in answer file
     :dir_name: 'puppet'         # the subdirectory in modules/
     :manifest_name: 'server'    # manifest filename without .pp extension

data/bin/kafo-configure

@@ -5,4 +5,4 @@
 
 $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'kafo'))
 require 'kafo_configure'
-KafoConfigure.run
+exit KafoConfigure.run.exit_code

data/bin/kafofy

@@ -23,6 +23,7 @@ if ARGV.size > 0
 #!/usr/bin/env ruby
 require 'rubygems'
 require 'kafo'
+CONFIG_FILE = "/etc/#{script_name}/#{script_name}"
 KafoConfigure.run
 EOS
   File.open(script_name, 'w') { |file| file.write(content) }
@@ -32,6 +33,6 @@ 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 "  1. upload your puppet modules to modules directory (you can use librarian-puppet project)"
+puts "  2. create default config/answers.yaml or modify config/kafo.yaml to laod another answer file"
 puts "  3. run #{script_name}"

data/config/kafo.yaml

@@ -0,0 +1,7 @@
+--- 
+  !ruby/sym log_dir: /var/log/kafo
+  !ruby/sym log_level: !ruby/sym debug
+  !ruby/sym no_prefix: false
+  !ruby/sym mapping: {}
+  !ruby/sym password: ibZ9oHb0CC6joJHhmOzIvDD8tjwa3jX5hGU6mEdYHcM
+  !ruby/sym answer_file: /home/ares/z/kafotest/config/answers.yaml

data/config/kafo.yaml.example

@@ -1,16 +1,27 @@
 # kafo main configuration file example
 # you can rename it to kafo.yaml so it overwrite default kafo settings
-# note current configuration is written tokafo.yaml every time kafo is run
+# note current configuration is written to kafo.yaml every time kafo is run
 
-## Useful for development, e.g. when you want to move log files to local directory
-# :log_dir: '/var/log/kafo'
-# :log_level: :info
+## Installer configuration
+# Path to answer file, if the file does not exist a $pwd/config/answers.yaml is used as a fallback
+# :answer_file: /etc/kafo/kafo.yaml
+# Uncomment if you want to load puppet modules from a specific path, $pwd/modules is used by default
+# :installer_dir: /usr/share/kafo/
 
 ## Kafo tuning, customization of core functionality
 # :no_prefix: false
 # :mapping: {}
 # :order:
 
+## Useful for development, e.g. when you want to move log files to local directory
+# :log_dir: /var/log/kafo
+# :log_level: :info
+
+# Change if you want to debug default answers for you modules, this directory holds default answers
+# :default_values_dir: /tmp
+
 ## Advanced configuration - if not set it's ignored
 # :log_owner: root
 # :log_group: root
+# :config_header_file:
+# :dont_save_answers:

data/lib/kafo/configuration.rb

@@ -3,52 +3,56 @@ require 'kafo/puppet_module'
 require 'kafo/password_manager'
 
 class Configuration
-  attr_reader :config_file
+  attr_reader :config_file, :answer_file
+
+  DEFAULT = {
+      :log_dir            => '/var/log/kafo',
+      :log_level          => :info,
+      :no_prefix          => false,
+      :mapping            => {},
+      :answer_file        => '/etc/kafo/kafo.yaml',
+      :installer_dir      => '.',
+      :default_values_dir => '/tmp'
+  }
 
-  def self.application_config_file
-    File.join(Dir.pwd, 'config/kafo.yaml')
-  end
-
-  def self.save_configuration(configuration)
-    File.open(application_config_file, 'w') { |file| file.write(YAML.dump(configuration)) }
-  end
+  def initialize(file)
+    @config_file = file
+    configure_application
+    @logger = Logging.logger.root
 
-  def self.configure_application
+    @answer_file = app[:answer_file]
     begin
-      configuration = YAML.load_file(application_config_file)
-    rescue => e
-      configuration = {}
+      @data        = YAML.load_file(@answer_file)
+    rescue Errno::ENOENT => e
+      puts "No answers file at #{@answer_file} found, can not continue"
+      exit(:no_answer_file)
     end
 
-    default           = {
-      :log_dir   => '/var/log/kafo',
-      :log_level => :info,
-      :no_prefix => false,
-      :mapping   => {}
-    }
-    
-    result            = default.merge(configuration || {})
-    result[:password] ||= PasswordManager.new.password
-    save_configuration(result)
+    @config_dir  = File.dirname(@config_file)
+  end
 
-    result
+  def save_configuration(configuration)
+    File.open(@config_file, 'w') { |file| file.write(YAML.dump(configuration)) }
   end
 
-  KAFO = configure_application
+  def configure_application
+    result = app
+    save_configuration(result)
+    result
+  end
 
-  def initialize(file)
-    @logger = Logging.logger.root
-    @logger.info "Loading config file #{file}"
+  def app
+    @app ||= begin
+      begin
+        configuration = YAML.load_file(@config_file)
+      rescue => e
+        configuration = {}
+      end
 
-    begin
-      @data        = YAML.load_file(file)
-    rescue Errno::ENOENT => e
-      puts "No answers file at #{file} found, can not continue"
-      exit(23)
+      result            = DEFAULT.merge(configuration || {})
+      result[:password] ||= PasswordManager.new.password
+      result
     end
-
-    @config_file = file
-    @config_dir  = File.join(Dir.pwd, 'config')
   end
 
   def modules
@@ -58,12 +62,11 @@ class Configuration
   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`
+      command = PuppetCommand.new("#{includes} dump_values(#{params})").append('2>&1').command
+      @logger.debug `#{command}`
       unless $?.exitstatus == 0
         @logger.error "Could not get default values, cannot continue"
-        exit(25)
+        exit(:default_error)
       end
       @logger.info "... finished"
       YAML.load_file(File.join(@config_dir, 'default_values.yaml'))
@@ -83,15 +86,16 @@ class Configuration
   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__), '../../')
+    files = [ app[:config_header_file], File.join(KafoConfigure.gem_root, '/config/config_header.txt') ].compact
+    file = files.select { |f| File.exists?(f) }.first
+    @config_header ||= file.nil? ? '' : File.read(file)
   end
 
-  def store(data)
-    File.open(config_file, 'w') { |file| file.write(config_header + YAML.dump(data)) }
+  def store(data, file = nil)
+    filename = file || answer_file
+    FileUtils.touch filename
+    File.chmod 0600, filename
+    File.open(filename, 'w') { |file| file.write(config_header + YAML.dump(data)) }
   end
 
   private

data/lib/kafo/kafo_configure.rb

@@ -6,22 +6,23 @@ require 'kafo/logger'
 require 'kafo/string_helper'
 require 'kafo/wizard'
 require 'kafo/system_checker'
+require 'kafo/puppet_command'
 
 class KafoConfigure < Clamp::Command
   include StringHelper
   attr_reader :logger
 
   class << self
-    attr_accessor :config, :root_dir
+    attr_accessor :config, :root_dir, :config_file, :gem_root, :temp_config_file
   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
+    self.class.config_file = config_file
+    self.class.config      = Configuration.new(self.class.config_file)
+    self.class.root_dir    = File.expand_path(self.class.config.app[:installer_dir])
+    self.class.gem_root    = File.join(File.dirname(__FILE__), '../../')
+    Logger.setup
+    @logger = Logging.logger.root
     set_env
     super
     set_parameters
@@ -33,38 +34,85 @@ class KafoConfigure < Clamp::Command
   end
 
   def execute
-    parse_cli_arguments
+    catch :exit do
+      parse_cli_arguments
 
-    if verbose?
-      logger.appenders = logger.appenders << ::Logging.appenders.stdout(:layout => COLOR_LAYOUT)
+      if verbose?
+        logger.appenders = logger.appenders << ::Logging.appenders.stdout(:layout => Logger::COLOR_LAYOUT)
+      end
+
+      unless SystemChecker.check
+        puts "Your system does not meet configuration criteria"
+        exit(:invalid_system)
+      end
+
+      if interactive?
+        wizard = Wizard.new
+        wizard.run
+      else
+        unless validate_all
+          puts "Error during configuration, exiting"
+          exit(:invalid_values)
+        end
+      end
+
+      if dont_save_answers?
+        self.class.temp_config_file = temp_config_file
+        store_params(temp_config_file)
+      else
+        store_params
+      end
+      run_installation
     end
+    return self
+  end
 
-    unless SystemChecker.check
-      puts "Your system does not meet configuration criteria"
-      exit(20)
+  def self.run
+    catch :exit do
+      return super
     end
+    Kernel.exit(self.exit_code) # fail in initialize
+  end
+
+  def exit_code
+    self.class.exit_code
+  end
 
-    if interactive?
-      wizard = Wizard.new
-      wizard.run
+  def self.exit(code)
+    @exit_code = translate_exit_code(code)
+    throw :exit
+  end
+
+  def self.exit_code
+    @exit_code ||= 0
+  end
+
+  def self.translate_exit_code(code)
+    return code if code.is_a? Fixnum
+    error_codes = { :invalid_system => 20,
+                    :invalid_values => 21,
+                    :manifest_error => 22,
+                    :no_answer_file => 23,
+                    :unknown_module => 24,
+                    :defaults_error => 25 }
+    if error_codes.has_key? code
+      return error_codes[code]
     else
-      unless validate_all
-        puts "Error during configuration, exiting"
-        exit(21)
-      end
+      raise "Unknown code #{code}"
     end
-
-    store_params unless dont_save_answers?
-    run_installation
   end
 
   private
 
+  def exit(code)
+    self.class.exit(code)
+  end
+
   def params
     @params ||= config.modules.map(&:params).flatten
   rescue ModuleName => e
     puts e
-    exit(24)
+    exit(:unknown_module)
   end
 
   def set_parameters
@@ -81,7 +129,7 @@ class KafoConfigure < Clamp::Command
     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
     self.class.option ['-d', '--dont-save-answers'], :flag, 'Skip saving answers to answers.yaml?',
-                      :default => false
+                      :default => !!config.app[:dont_save_answers]
 
     config.modules.each do |mod|
       self.class.option d("--[no-]enable-#{mod.name}"),
@@ -110,9 +158,9 @@ class KafoConfigure < Clamp::Command
     end
   end
 
-  def store_params
+  def store_params(file = nil)
     data = Hash[config.modules.map { |mod| [mod.name, mod.enabled? ? mod.params_hash : false] }]
-    config.store(data)
+    config.store(data, file)
   end
 
   def validate_all(logging = true)
@@ -127,9 +175,7 @@ class KafoConfigure < Clamp::Command
 
   def run_installation
     exit_code = 0
-    modules_path = "modules:#{File.join(File.dirname(__FILE__), '../../modules')}"
     options = [
-        "--modulepath #{modules_path}",
         '--verbose',
         '--debug',
         '--color=false',
@@ -138,7 +184,8 @@ class KafoConfigure < Clamp::Command
     ]
     options.push '--noop' if noop?
     begin
-      PTY.spawn("echo 'include kafo_configure' | puppet apply #{options.join(' ')}") do |stdin, stdout, pid|
+      command = PuppetCommand.new('include kafo_configure', options).command
+      PTY.spawn(command) do |stdin, stdout, pid|
         begin
           stdin.each { |line| puppet_log(line) }
         rescue Errno::EIO
@@ -154,6 +201,7 @@ class KafoConfigure < Clamp::Command
       exit_code = e.status.exitstatus
     end
     logger.info "Puppet has finished, bye!"
+    FileUtils.rm(temp_config_file, :force => true)
     exit(exit_code)
   end
 
@@ -185,4 +233,13 @@ class KafoConfigure < Clamp::Command
     ENV['FACTER_fqdn'] = facter_hostname
   end
 
+  def config_file
+    return CONFIG_FILE if defined?(CONFIG_FILE) && File.exists?(CONFIG_FILE)
+    return '/etc/kafo/kafo.yaml' if File.exists?('/etc/kafo/kafo.yaml')
+    File.join(Dir.pwd, 'config', 'kafo.yaml')
+  end
+
+  def temp_config_file
+    @temp_config_file ||= "/tmp/kafo_answers_#{rand(1_000_000)}.yaml"
+  end
 end

data/lib/kafo/logger.rb

@@ -1,41 +1,46 @@
 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)
+class Logger
+  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
+  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
   )
-  # 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]
+  def self.setup
+    begin
+      FileUtils.mkdir_p(KafoConfigure.config.app[:log_dir], :mode => 0750)
+    rescue Errno::EACCES => e
+      puts "No permissions to create log dir #{KafoConfigure.config.app[:log_dir]}"
+    end
+
+    logger   = Logging.logger.root
+    filename = "#{KafoConfigure.config.app[: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 KafoConfigure.config.app[:log_owner], KafoConfigure.config.app[:log_group], filename
+    rescue ArgumentError => e
+      puts "File #{filename} not writeable, won't log anything to file!"
+    end
+
+    logger.level = KafoConfigure.config.app[:log_level]
+  end
+end

data/lib/kafo/params/password.rb

@@ -43,7 +43,7 @@ module Params
     end
 
     def phrase
-      Configuration::KAFO[:password]
+      KafoConfigure.config.app[:password]
     end
 
   end

data/lib/kafo/puppet_command.rb

@@ -0,0 +1,37 @@
+class PuppetCommand
+  def initialize(command, options = [])
+    @command = command
+    @options = options.push("--modulepath #{modules_path}")
+    @logger  = Logging.logger.root
+  end
+
+  def command
+    custom_answer_file = if KafoConfigure.temp_config_file.nil?
+      ''
+    else
+      "$kafo_answer_file=\"#{KafoConfigure.temp_config_file}\""
+    end
+
+    result = [
+        "echo '$kafo_config_file=\"#{KafoConfigure.config_file}\" #{custom_answer_file} #{@command}'",
+        " | ",
+        "puppet apply #{@options.join(' ')} #{@suffix}"
+    ].join
+    @logger.debug result
+    result
+  end
+
+  def append(suffix)
+    @suffix = suffix
+    self
+  end
+
+  private
+
+  def modules_path
+    [
+        KafoConfigure.config.app[:installer_dir] + '/modules',
+        File.join(KafoConfigure.gem_root, 'modules')
+    ].join(':')
+  end
+end

data/lib/kafo/puppet_module.rb

@@ -43,7 +43,7 @@ class PuppetModule
   rescue ConfigurationException => e
     puts "Unable to continue because of:"
     puts e.message
-    exit(22)
+    KafoConfigure.exit(:manifest_error)
   end
 
   def validations(param = nil)
@@ -64,7 +64,7 @@ class PuppetModule
 
   # mapping from configuration with stringified keys
   def mapping
-    @mapping ||= Hash[Configuration::KAFO[:mapping].map { |k, v| [k.to_s, v] }]
+    @mapping ||= Hash[KafoConfigure.config.app[:mapping].map { |k, v| [k.to_s, v] }]
   end
 
   # custom module directory name

data/lib/kafo/puppet_module_parser.rb

@@ -29,6 +29,7 @@ class PuppetModuleParser
     end
   end
 
+  # TODO - store parsed object type (Puppet::Parser::AST::Variable must be dumped later)
   def parameters
     parameters = {}
     arguments  = @object.respond_to?(:arguments) ? @object.arguments : {}

data/lib/kafo/string_helper.rb

@@ -10,7 +10,7 @@ module StringHelper
   alias :u :underscore
 
   def with_prefix(param)
-    prefix = Configuration::KAFO[:no_prefix] ? '' : "#{d(param.module_name)}-"
+    prefix = KafoConfigure.config.app[:no_prefix] ? '' : "#{d(param.module_name)}-"
     "#{prefix}#{d(param.name)}"
   end
 

data/lib/kafo/version.rb

@@ -1,3 +1,3 @@
 module Kafo
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/modules/create_resources/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+group :development, :test do
+  gem 'puppetlabs_spec_helper', :require => false
+end
+
+if puppetversion = ENV['PUPPET_GEM_VERSION']
+  gem 'puppet', puppetversion, :require => false
+else
+  gem 'puppet', :require => false
+end

data/modules/create_resources/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

data/modules/create_resources/Modulefile

@@ -0,0 +1,11 @@
+name    'puppetlabs-create_resources'
+version '0.0.1'
+source 'git://github.com/puppetlabs/puppetlabs-create_resources.git'
+author 'puppetlabs'
+license 'Apache Version 2.0'
+summary 'Function to dynamically create resources from hashes'
+description 'Function to dynamically create resources from hashes'
+project_page 'https://github.com/puppetlabs/puppetlabs-create_resources'
+
+## Add dependencies, if any:
+# dependency 'username/name', '>= 1.2.0'

data/modules/create_resources/README.md

@@ -0,0 +1,37 @@
+build status of unit tests:
+
+[![Build Status](https://travis-ci.org/puppetlabs/puppetlabs-create_resources.png?branch=master)](https://travis-ci.org/puppetlabs/puppetlabs-create_resources)
+
+
+- License - Apache Version 2.0
+- Copyright - Puppetlabs 2011
+
+*NOTE* - this has exists in 2.7.x core, it has been published seperately
+so that it can be used with 2.6.x
+
+This module contains a custom function for puppet that can be used to dynamically add resources to the catalog.
+
+I wrote this to use with an external node classifier that consumes YAML.
+
+The yaml specifies classes and passes hashes to those classes as parameters
+
+    classes:
+      webserver::instances:
+        instances:
+          instance1:
+            foo: bar
+          instance2:
+            foo: blah
+
+    Then puppet code can consume the hash parameters and convert then into resources
+
+    class webserver::instances (
+      $instances = {}
+    ) {
+      create_resources('webserver::instance', $instances)
+    }
+
+Now I can dynamically determine how webserver instances are deployed to nodes
+by updating the YAML files.
+
+

data/modules/create_resources/Rakefile

@@ -0,0 +1 @@
+require 'puppetlabs_spec_helper/rake_tasks'

data/modules/create_resources/lib/puppet/parser/functions/create_resources.rb

@@ -0,0 +1,75 @@
+Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC') do |args|
+    Converts a hash into a set of resources and adds them to the catalog.
+
+    This function takes two mandatory arguments: a resource type, and a hash describing
+    a set of resources. The hash should be in the form `{title => {parameters} }`:
+
+        # A hash of user resources:
+        $myusers = {
+          'nick' => { uid    => '1330',
+                      group  => allstaff,
+                      groups => ['developers', 'operations', 'release'], }
+          'dan'  => { uid    => '1308',
+                      group  => allstaff,
+                      groups => ['developers', 'prosvc', 'release'], }
+        }
+
+        create_resources(user, $myusers)
+
+    A third, optional parameter may be given, also as a hash:
+
+        $defaults = {
+          'ensure'   => present,
+          'provider' => 'ldap',
+        }
+
+        create_resources(user, $myusers, $defaults)
+
+    The values given on the third argument are added to the parameters of each resource
+    present in the set given on the second argument. If a parameter is present on both
+    the second and third arguments, the one on the second argument takes precedence.
+
+    This function can be used to create defined resources and classes, as well
+    as native resources.
+  ENDHEREDOC
+  raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2 or 3)") if args.length < 2 || args.length > 3
+
+  # figure out what kind of resource we are
+  type_of_resource = nil
+  type_name = args[0].downcase
+  if type_name == 'class'
+    type_of_resource = :class
+  else
+    if resource = Puppet::Type.type(type_name.to_sym)
+      type_of_resource = :type
+    elsif resource = find_definition(type_name.downcase)
+      type_of_resource = :define
+    else
+      raise ArgumentError, "could not create resource of unknown type #{type_name}"
+    end
+  end
+  # iterate through the resources to create
+  defaults = args[2] || {}
+  args[1].each do |title, params|
+    params = Puppet::Util.symbolizehash(defaults.merge(params))
+    raise ArgumentError, 'params should not contain title' if(params[:title])
+    case type_of_resource
+    # JJM The only difference between a type and a define is the call to instantiate_resource
+    # for a defined type.
+    when :type, :define
+      p_resource = Puppet::Parser::Resource.new(type_name, title, :scope => self, :source => resource)
+      {:name => title}.merge(params).each do |k,v|
+        p_resource.set_parameter(k,v)
+      end
+      if type_of_resource == :define then
+        resource.instantiate_resource(self, p_resource)
+      end
+      compiler.add_resource(self, p_resource)
+    when :class
+      klass = find_hostclass(title)
+      raise ArgumentError, "could not find hostclass #{title}" unless klass
+      klass.ensure_in_catalog(self, params)
+      compiler.catalog.add_class(title)
+    end
+  end
+end

data/modules/create_resources/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'puppetlabs_spec_helper/module_spec_helper'

data/modules/create_resources/spec/unit/puppet/parser/functions/create_resources_spec.rb

@@ -0,0 +1,116 @@
+require 'puppet'
+require 'spec_helper'
+
+describe 'function for dynamically creating resources' do
+
+  def setup_scope
+    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
+    if Puppet.version =~ /^3\./
+      @scope = Puppet::Parser::Scope.new(@compiler)
+    else
+      @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+    end
+    @topscope = @topscope
+    @scope.parent = @topscope
+    Puppet::Parser::Functions.function(:create_resources)
+  end
+
+  describe 'basic tests' do
+
+    before :each do
+      setup_scope
+    end
+
+    it "should exist" do
+      Puppet::Parser::Functions.function(:create_resources).should == "function_create_resources"
+    end
+    it 'should require two arguments' do
+      lambda { @scope.function_create_resources(['foo']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (1; must be 2 or 3)')
+    end
+  end
+
+  describe 'when creating native types' do
+    before :each do
+      Puppet[:code]=
+'
+class t {}
+notify{test:}
+'
+      setup_scope
+    end
+    it 'empty hash should not cause resources to be added' do
+
+      @scope.function_create_resources(['file', {}])
+      @compiler.catalog.resources.size == 1
+    end
+    it 'should be able to add' do
+      @scope.function_create_resources(['file', {'/etc/foo'=>{'ensure'=>'present'}}])
+      @compiler.catalog.resource(:file, "/etc/foo")['ensure'].should == 'present'
+    end
+    it 'should accept multiple types' do
+      type_hash = {}
+      type_hash['notify'] = {'message' => 'one'}
+      type_hash['user']   = {'home' => true}
+      @scope.function_create_resources(['notify', type_hash])
+      @compiler.catalog.resource(:notify, "notify")['message'].should == 'one'
+      @compiler.catalog.resource(:notify, "user")['home'].should == true
+    end
+    it 'should fail to add non-existing type' do
+      lambda {
+        @scope.function_create_resources(['fooper', {}]) }.should raise_error(ArgumentError, 'could not create resource of unknown type fooper')
+    end
+    before :each do
+      Puppet[:code]=
+'
+class t {}
+define foo($one){notify{$name: message => $one}}
+notify{test:}
+'
+      setup_scope
+      Puppet::Parser::Functions.function(:create_resources)
+    end
+    it 'should be able to create defined resoure types' do
+      @scope.function_create_resources(['foo', {'blah'=>{'one'=>'two'}}])
+      # still have to compile for this to work...
+      # I am not sure if this constraint ruins the tests
+      @scope.compiler.compile
+      @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
+    end
+    it 'should fail if defines are missing params' do
+      @scope.function_create_resources(['foo', {'blah'=>{}}])
+      lambda { @scope.compiler.compile }.should raise_error(Puppet::ParseError, /Must pass one/)
+    end
+    it 'should be able to add multiple defines' do
+      hash = {}
+      hash['blah'] = {'one' => 'two'}
+      hash['blaz'] = {'one' => 'three'}
+      @scope.function_create_resources(['foo', hash])
+      # still have to compile for this to work...
+      # I am not sure if this constraint ruins the tests
+      @scope.compiler.compile
+      @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
+      @compiler.catalog.resource(:notify, "blaz")['message'].should == 'three'
+    end
+  end
+  describe 'when creating classes' do
+    before :each do
+      Puppet[:code]=
+'
+class t {}
+class bar($one){notify{test: message => $one}}
+notify{tester:}
+'
+      setup_scope
+      Puppet::Parser::Functions.function(:create_resources)
+    end
+    it 'should be able to create classes' do
+      @scope.function_create_resources(['class', {'bar'=>{'one'=>'two'}}])
+      @scope.compiler.compile
+      @compiler.catalog.resource(:notify, "test")['message'].should == 'two'
+      @compiler.catalog.resource(:class, "bar").should_not be_nil#['message'].should == 'two'
+    end
+    it 'should fail to create non-existing classes' do
+      lambda { @scope.function_create_resources(['class', {'blah'=>{'one'=>'two'}}]) }.should raise_error(ArgumentError ,'could not find hostclass blah')
+    end
+  end
+end

data/modules/create_resources/tests/users.pp

@@ -0,0 +1,48 @@
+$users3 = {
+ 'dannyboy454' => {
+   'user_name'=>'dlfjdslkf',
+   'ensure'=>present,
+   'require' => 'User[foobar]',
+   'before' => 'User[sally-mae]'
+  },
+ 'bobby-joe' => {'ensure'=>present}
+}
+create_resources('create_resources::user', $users3)
+
+# TODO - types are not applied in main stage
+$users = {
+  'sally-mae' => 
+  {'ensure' => 'present',
+   'require' => 'User[bobby-joe]'
+  }
+} 
+create_resources('user', $users)
+
+user { 'foobar':
+  ensure => present,
+  require => User['bobby-joe']
+}
+
+$classes = {
+  'create_resources' => {
+    'ensure' => 'present'
+  } 
+}
+
+create_resources('class', $classes)
+
+class create_resources(
+ $ensure,
+ $user_name=$name
+){
+ user{$name: ensure => $ensure}
+ notify{$user_name:}
+}
+
+define create_resources::user(
+ $ensure,
+ $user_name=$operatingsystem
+){
+  user{$name: ensure => $ensure}
+  notify{$user_name:}
+}

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

@@ -7,12 +7,9 @@
 #
 module Puppet::Parser::Functions
   newfunction(:class_name, :type => :rvalue) do |args|
-    case args[0]
-      when 'puppetmaster'
-        'puppet::server'
-    else
-      args[0]
-    end
+    mapping = YAML.load_file(lookupvar('kafo_config_file'))[:mapping]
+    mod = args[0].to_sym
+    mapping[mod].nil? ? mod : "#{mapping[mod][:dir_name]}::#{mapping[mod][:manifest_name]}"
   end
 end
 

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

@@ -3,7 +3,7 @@
 module Puppet::Parser::Functions
   newfunction(:dump_values) do |args|
     data = Hash[args.map { |arg| [arg, lookupvar(arg)] }]
-    File.open('config/default_values.yaml', 'w') { |file| file.write(YAML.dump(data)) }
+    dump_dir = YAML.load_file(lookupvar('kafo_config_file'))[:default_values_dir]
+    File.open("#{dump_dir}/default_values.yaml", 'w') { |file| file.write(YAML.dump(data)) }
   end
 end
-

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

@@ -5,7 +5,7 @@
 # order
 module Puppet::Parser::Functions
   newfunction(:kafo_ordered, :type => :rvalue) do |args|
-    order = YAML.load_file('config/kafo.yaml')[:order]
+    order = YAML.load_file(lookupvar('kafo_config_file'))[:order]
     if order.nil?
       args[0]
     else

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

@@ -0,0 +1,13 @@
+# Loads a answer file
+#
+# it can be specified either as a $kafo_answer_file variable or it's read from config file
+module Puppet::Parser::Functions
+  newfunction(:load_kafo_answer_file, :type => :rvalue) do |args|
+    answer_file = lookupvar('kafo_answer_file')
+    if answer_file && !answer_file.empty?
+      answer_file
+    else
+      YAML.load_file(lookupvar('kafo_config_file'))[:answer_file]
+    end
+  end
+end

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

@@ -2,7 +2,7 @@
 #
 module Puppet::Parser::Functions
   newfunction(:load_kafo_password, :type => :rvalue) do |args|
-    YAML.load_file('config/kafo.yaml')[:password]
+    YAML.load_file(lookupvar('kafo_config_file'))[:password]
   end
 end
 

data/modules/kafo_configure/manifests/init.pp

@@ -4,14 +4,10 @@
 #   $modulepath/config/answers.yaml
 #   /etc/kafo-configure/answers.yaml
 #
-class kafo_configure(
-  $answers = undef
-) {
+class kafo_configure {
 
   $password = load_kafo_password()
-  $params   = loadanyyaml($answers,
-                      "/etc/kafo-configure/answers.yaml",
-                      "config/answers.yaml")
+  $params   = loadanyyaml(load_kafo_answer_file())
   $keys     = kafo_ordered(hash_keys($params))
 
   kafo_configure::yaml_to_class { $keys: }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kafo
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-29 00:00:00.000000000 Z
+date: 2013-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -134,6 +134,7 @@ extra_rdoc_files: []
 files:
 - bin/kafo-configure
 - bin/kafofy
+- config/kafo.yaml
 - config/kafo.yaml.example
 - config/config_header.txt
 - lib/kafo/puppet_module.rb
@@ -143,6 +144,7 @@ files:
 - lib/kafo/validator.rb
 - lib/kafo/exceptions.rb
 - lib/kafo/system_checker.rb
+- lib/kafo/puppet_command.rb
 - lib/kafo/wizard.rb
 - lib/kafo/params/password.rb
 - lib/kafo/params/string.rb
@@ -158,6 +160,7 @@ files:
 - lib/kafo.rb
 - modules/kafo_configure/lib/puppet/parser/functions/decrypt.rb
 - modules/kafo_configure/lib/puppet/parser/functions/is_hash.rb
+- modules/kafo_configure/lib/puppet/parser/functions/load_kafo_answer_file.rb
 - modules/kafo_configure/lib/puppet/parser/functions/class_name.rb
 - modules/kafo_configure/lib/puppet/parser/functions/dump_values.rb
 - modules/kafo_configure/lib/puppet/parser/functions/load_kafo_password.rb
@@ -166,6 +169,15 @@ files:
 - modules/kafo_configure/lib/puppet/parser/functions/loadanyyaml.rb
 - modules/kafo_configure/manifests/yaml_to_class.pp
 - modules/kafo_configure/manifests/init.pp
+- modules/create_resources/README.md
+- modules/create_resources/Modulefile
+- modules/create_resources/tests/users.pp
+- modules/create_resources/Gemfile
+- modules/create_resources/Rakefile
+- modules/create_resources/lib/puppet/parser/functions/create_resources.rb
+- modules/create_resources/LICENSE
+- modules/create_resources/spec/unit/puppet/parser/functions/create_resources_spec.rb
+- modules/create_resources/spec/spec_helper.rb
 - LICENSE.txt
 - Rakefile
 - README.md