kafo 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13fc7c4d5d0d30aa719d2af9047ed92bf5a6c93c
-  data.tar.gz: cc7e5c57c7e3f5e888c8db5e963d43bdb505dc01
+  metadata.gz: 873ad76a8a766b68a73ad74b34ae17b2d9c48272
+  data.tar.gz: 72adff8cb4533c7292a286c0706a87fe574797cb
 SHA512:
-  metadata.gz: 0065c3f73debd2dc8056185c91bc5a48c822b5baaa31e47f84d9758e59ceca260c735953060bc5628188ecb14d9ece380709c695483faaa32954e21cc45eef6d
-  data.tar.gz: c58bf1204a85e7bd5c9273baec1a93e5f6f5a8ced3bbc2bfc027f54840d42930cb891720a9e182fd5e57a17c0020f1f10d471893f27d3b8af54c645147bfc2c9
+  metadata.gz: 293954125bbd2feb79cb7ba396459d8fb32e9ef9e61d1d38027d4ff2c79980c5c7a8f339d424347c84c06b63ecb6f64d6b88cff5b7465a5a58ae8853b45cb0b3
+  data.tar.gz: a5763aeefec19555ef5c1315f5bc7961f06cd49cb0f0b672a64fc878310b5f0290e123c130f318abba0b841427cc32c5d3c9fd000a259836a9a3f16e3e1d1c55

data/README.md

@@ -158,6 +158,14 @@ As you may have noticed there are several ways how to specify arguments. Here's
   * values specified on CLI
   * interactive mode arguments
 
+## Requirements
+
+Kafo is supported with Puppet versions 3 and 4. Puppet 2 is no longer supported
+in current versions, use an older version of Kafo or update Puppet.
+
+Puppet may be installed as a gem (add it to Gemfile) or through a package,
+including official AIO packages.
+
 ## How do I report bugs or contribute?
 
 You can find our redmine issue tracker [here](http://projects.theforeman.org/projects/kafo),
@@ -971,6 +979,36 @@ configure it in config/kafo.yaml with:
 The cache will be skipped if the file modification time of the manifest is
 greater than the mtime recorded in the cache.
 
+## Configuring Hiera
+
+Kafo uses Hiera to include classes and pass parameters to classes using data
+binding, but this can be extended so parameters can be set for classes not
+being managed by Kafo. Set a custom Hiera config file in Kafo's config with:
+
+```yaml
+:hiera_config: /usr/share/kafo/hiera.yaml
+```
+
+The contents of this file are as per the [hiera.yaml docs](https://docs.puppet.com/hiera/latest/configuring.html),
+but hierarchy should contain the item `kafo_answers` and the `yaml` backend
+should be enabled. Kafo will add these if they're missing.
+
+When running Puppet, Kafo will copy the Hiera config and YAML data directory to
+a temporary location to include its data. The file `kafo_answers.yaml` will be
+generated containing _all_ default and overriden values for parameters managed
+by Kafo. This may change in the future to allow a more complex hierarchy. As an
+example, a hierarchy could be set up with:
+
+```yaml
+:hierarchy:
+  - kafo_answers
+  - "%{::osfamily}"
+  - common
+```
+
+This would give precedence to all Kafo-managed parameter values, but for any
+others, would check for values per OS family, followed by a `common.yaml` file.
+
 ## Exit code
 
 Kafo can terminate either before or after puppet is run. If it is run with

data/config/kafo.yaml.example

@@ -42,6 +42,7 @@
 # :log_group: root
 # :config_header_file:
 # :dont_save_answers:
+# :hiera_config: /usr/share/kafo/hiera.yaml
 
 ## Hooks - hooks in these extra directories will be loaded,
 # by default they are loaded from $installer_dir/hooks/$type

data/lib/kafo/configuration.rb

@@ -225,10 +225,6 @@ module Kafo
       end
     end
 
-    def temp_config_file
-      @temp_config_file ||= "/tmp/kafo_answers_#{rand(1_000_000)}.yaml"
-    end
-
     def log_file
       File.join(app[:log_dir], app[:log_name])
     end
@@ -251,6 +247,7 @@ module Kafo
         migrations.store_applied
         @logger.info("#{migrations.migrations.count} migration/s were applied. Updated configuration was saved.")
       end
+      migrations.migrations.count
     end
 
     def migrations_dir

data/lib/kafo/hiera_configurer.rb

@@ -0,0 +1,83 @@
+require 'fileutils'
+require 'tmpdir'
+
+module Kafo
+  class HieraConfigurer
+    attr_reader :temp_dir, :config_path, :data_dir, :logger
+
+    def initialize(user_config_path, modules, modules_order)
+      @user_config_path = user_config_path
+      @modules = modules
+      @modules_order = modules_order
+      @logger = KafoConfigure.logger
+    end
+
+    def write_configs
+      @temp_dir = Dir.mktmpdir('kafo_hiera')
+      @config_path = File.join(temp_dir, 'hiera.conf')
+      @data_dir = File.join(temp_dir, 'data')
+
+      if @user_config_path
+        logger.debug("Merging existing Hiera config file from #{@user_config_path}")
+        user_config = YAML.load(File.read(@user_config_path))
+        user_data_dir = user_config[:yaml][:datadir] if user_config[:yaml]
+      else
+        user_config = {}
+        user_data_dir = false
+      end
+      logger.debug("Writing Hiera config file to #{config_path}")
+      File.open(config_path, 'w') do |f|
+        # merge required config changes into the user's Hiera config
+        f.write(format_yaml_symbols(generate_config(user_config).to_yaml))
+      end
+
+      if user_data_dir
+        logger.debug("Copying Hiera data files from #{user_data_dir} to #{data_dir}")
+        FileUtils.cp_r(user_data_dir, data_dir)
+      else
+        logger.debug("Creating Hiera data files in #{data_dir}")
+        FileUtils.mkdir(data_dir)
+      end
+
+      File.open(File.join(data_dir, 'kafo_answers.yaml'), 'w') do |f|
+        f.write(format_yaml_symbols(generate_data(@modules).to_yaml))
+      end
+    end
+
+    def generate_config(config = {})
+      config ||= {}
+
+      # ensure YAML is enabled
+      config[:backends] ||= []
+      config[:backends] << 'yaml' unless config[:backends].include?('yaml')
+
+      # ensure kafo_answers is present and most specific
+      config[:hierarchy] ||= []
+      config[:hierarchy].unshift('kafo_answers') unless config[:hierarchy].include?('kafo_answers')
+
+      # use our copy of the data dir
+      config[:yaml] ||= {}
+      config[:yaml][:datadir] = data_dir
+
+      config
+    end
+
+    def generate_data(modules)
+      classes = []
+      data = modules.select(&:enabled?).inject({}) do |config, mod|
+        classes << mod.class_name
+        config.update(Hash[mod.params_hash.map { |k, v| ["#{mod.class_name}::#{k}", v] }])
+      end
+      data['classes'] = @modules_order ? sort_modules(classes, @modules_order) : classes
+      data
+    end
+
+    def sort_modules(modules, order)
+      (order & modules) + (modules - order)
+    end
+
+    def format_yaml_symbols(data)
+      data.gsub('!ruby/sym ', ':')
+    end
+  end
+end

data/lib/kafo/kafo_configure.rb

@@ -24,13 +24,14 @@ require 'kafo/progress_bar'
 require 'kafo/hooking'
 require 'kafo/exit_handler'
 require 'kafo/scenario_manager'
+require 'kafo/hiera_configurer'
 
 module Kafo
   class KafoConfigure < Clamp::Command
     include StringHelper
 
     class << self
-      attr_accessor :config, :root_dir, :config_file, :gem_root, :temp_config_file,
+      attr_accessor :config, :root_dir, :config_file, :gem_root,
                     :module_dirs, :kafo_modules_dir, :verbose, :app_options, :logger,
                     :check_dirs, :exit_handler, :scenario_manager
       attr_writer :hooking
@@ -57,9 +58,9 @@ module Kafo
       setup_config(config_file)
 
       self.class.hooking.execute(:pre_migrations)
-
-      # run migrations
-      self.class.config.run_migrations
+      reload_config
+      applied_total = self.class.config.run_migrations
+      @config_reload_requested = true if applied_total > 0
 
       if ARGV.include?('--migrations-only')
         self.class.verbose = (ARGV.include?('--verbose') || ARGV.include?('-v'))
@@ -68,13 +69,7 @@ module Kafo
         self.class.exit(0)
       end
 
-      # reload config
-      if @config_reload_requested
-        scenario_manager = setup_scenario_manager
-        self.class.scenario_manager = scenario_manager
-        setup_config(self.class.config_file)
-        self.class.logger.info('Installer configuration was reloaded')
-      end
+      reload_config
 
       if scenario_manager.configured?
         scenario_manager.check_scenario_change(self.class.config_file)
@@ -139,10 +134,7 @@ module Kafo
       end
 
       self.class.hooking.execute(:pre_commit)
-      if dont_save_answers? || noop?
-        self.class.temp_config_file = self.class.config.temp_config_file
-        store_params(self.class.config.temp_config_file)
-      else
+      unless dont_save_answers? || noop?
         store_params
         self.class.scenario_manager.link_last_scenario(self.class.config_file) if self.class.scenario_manager.configured?
       end
@@ -241,6 +233,16 @@ module Kafo
       self.class.hooking.kafo     = self
     end
 
+    def reload_config
+      if @config_reload_requested
+        scenario_manager = setup_scenario_manager
+        self.class.scenario_manager = scenario_manager
+        setup_config(self.class.config_file)
+        self.class.logger.info('Installer configuration was reloaded')
+        @config_reload_requestd = false
+      end
+    end
+
     def setup_scenario_manager
       ScenarioManager.new((defined?(CONFIG_DIR) && CONFIG_DIR) || (defined?(CONFIG_FILE) && CONFIG_FILE))
     end
@@ -376,6 +378,11 @@ module Kafo
 
     def run_installation
       self.class.hooking.execute(:pre)
+
+      hiera = HieraConfigurer.new(config.app[:hiera_config], config.modules, config.app[:order])
+      hiera.write_configs
+      self.class.exit_handler.register_cleanup_path(hiera.temp_dir)
+
       exit_code   = 0
       exit_status = nil
       options     = [
@@ -386,6 +393,7 @@ module Kafo
           '--show_diff',
           '--detailed-exitcodes',
           '--reports=',
+          "--hiera_config=#{hiera.config_path}",
       ]
       options.push '--noop' if noop?
       options.push '--profile' if profile?
@@ -413,7 +421,6 @@ module Kafo
       end
       @progress_bar.close if @progress_bar
       logger.info "Puppet has finished, bye!"
-      FileUtils.rm(self.class.config.temp_config_file, :force => true)
       self.class.exit(exit_code) do
         self.class.hooking.execute(:post)
       end

data/lib/kafo/puppet_command.rb

@@ -12,17 +12,13 @@ module Kafo
       @logger  = KafoConfigure.logger
     end
 
-    def custom_answer_file
-      KafoConfigure.temp_config_file.nil? ? '' : "$kafo_answer_file=\"#{KafoConfigure.temp_config_file}\""
-    end
-
     def add_progress
       KafoConfigure.verbose ? '' : "$kafo_add_progress=true"
     end
 
     def command
       result = [
-          "echo '$kafo_config_file=\"#{@configuration.config_file}\" #{custom_answer_file} #{add_progress} #{@command}'",
+          "echo '$kafo_config_file=\"#{@configuration.config_file}\" #{add_progress} #{@command}'",
           '|',
           "RUBYLIB=#{[@configuration.kafo_modules_dir, ::ENV['RUBYLIB']].join(File::PATH_SEPARATOR)}",
           "#{puppet_path} apply #{@options.join(' ')} #{@suffix}",

data/lib/kafo/version.rb

@@ -1,4 +1,4 @@
 # encoding: UTF-8
 module Kafo
-  VERSION = "0.8.2"
+  VERSION = "0.9.0"
 end

data/modules/kafo_configure/manifests/init.pp

@@ -11,8 +11,5 @@ class kafo_configure {
   }
 
   $password = load_kafo_password()
-  $params   = loadanyyaml(load_kafo_answer_file())
-  $keys     = kafo_ordered(hash_keys($params))
-
-  kafo_configure::yaml_to_class { $keys: }
+  hiera_include('classes')
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kafo
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Marek Hulan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-03 00:00:00.000000000 Z
+date: 2016-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -226,6 +226,7 @@ files:
 - lib/kafo/help_builders/advanced.rb
 - lib/kafo/help_builders/base.rb
 - lib/kafo/help_builders/basic.rb
+- lib/kafo/hiera_configurer.rb
 - lib/kafo/hook_context.rb
 - lib/kafo/hooking.rb
 - lib/kafo/kafo_configure.rb
@@ -255,28 +256,12 @@ files:
 - lib/kafo/validator.rb
 - lib/kafo/version.rb
 - lib/kafo/wizard.rb
-- modules/create_resources/Gemfile
-- modules/create_resources/LICENSE
-- modules/create_resources/Modulefile
-- modules/create_resources/README.md
-- modules/create_resources/Rakefile
-- modules/create_resources/lib/puppet/parser/functions/create_resources.rb
-- modules/create_resources/spec/spec_helper.rb
-- modules/create_resources/spec/unit/puppet/parser/functions/create_resources_spec.rb
-- modules/create_resources/tests/users.pp
 - modules/kafo_configure/lib/kafo/puppet/report_wrapper.rb
 - modules/kafo_configure/lib/puppet/parser/functions/add_progress.rb
-- modules/kafo_configure/lib/puppet/parser/functions/class_name.rb
 - modules/kafo_configure/lib/puppet/parser/functions/decrypt.rb
 - modules/kafo_configure/lib/puppet/parser/functions/dump_values.rb
-- modules/kafo_configure/lib/puppet/parser/functions/hash_keys.rb
-- modules/kafo_configure/lib/puppet/parser/functions/is_hash.rb
-- modules/kafo_configure/lib/puppet/parser/functions/kafo_ordered.rb
-- modules/kafo_configure/lib/puppet/parser/functions/load_kafo_answer_file.rb
 - modules/kafo_configure/lib/puppet/parser/functions/load_kafo_password.rb
-- modules/kafo_configure/lib/puppet/parser/functions/loadanyyaml.rb
 - modules/kafo_configure/manifests/init.pp
-- modules/kafo_configure/manifests/yaml_to_class.pp
 homepage: https://github.com/theforeman/kafo
 licenses:
 - GPLv3+

data/modules/create_resources/Gemfile

@@ -1,11 +0,0 @@
-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

@@ -1,202 +0,0 @@
-                                 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

@@ -1,11 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

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

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

@@ -1,75 +0,0 @@
-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

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

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

@@ -1,116 +0,0 @@
-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

@@ -1,48 +0,0 @@
-$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

@@ -1,15 +0,0 @@
-# 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|
-    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].gsub('/', '::')}"
-  end
-end
-

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

@@ -1,15 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-#
-# 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/kafo_ordered.rb

@@ -1,21 +0,0 @@
-# Orders modules names according to kafo.yaml
-#
-# if order was specified we take all modules in this order, if there are
-# other modules that were not ordered, we put them at the end in non-specified
-# order
-module Puppet::Parser::Functions
-  newfunction(:kafo_ordered, :type => :rvalue) do |args|
-    order = YAML.load_file(lookupvar('kafo_config_file'))[:order]
-    if order.nil?
-      args[0]
-    else
-      result = []
-      base = args[0].clone
-      order.each do |name|
-        result<< base.delete(name)
-      end
-      (result + base).compact
-    end
-  end
-end
-

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

@@ -1,13 +0,0 @@
-# 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 != :undefined && !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/loadanyyaml.rb

@@ -1,37 +0,0 @@
-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 unless value.nil?
-      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/yaml_to_class.pp

@@ -1,24 +0,0 @@
-# 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")
-  }
-
-}