beaker-answers 0.4.3 → 0.5.0

data/lib/beaker-answers.rb

@@ -1,6 +1,11 @@
 module BeakerAnswers
   require 'stringify-hash'
   require 'require_all'
+  require 'beaker-answers/helpers'
   require 'beaker-answers/answers'
   require 'beaker-answers/version'
+  require 'json'
+  require 'hocon'
+  require 'hocon/config_value_factory'
+  require 'hocon/parser/config_document_factory'
 end

data/lib/beaker-answers/answers.rb

@@ -3,13 +3,18 @@ module BeakerAnswers
   # information.
   class Answers
 
+    # This is a temporary default for deciding which configuration file format
+    # to fall back to in 2016.2.0.  Once we have cutover to MEEP, it should be
+    # removed.
+    DEFAULT_FORMAT = :bash
     DEFAULT_ANSWERS =  StringifyHash.new.merge({
+      :q_install                                     => 'y',
       :q_puppet_enterpriseconsole_auth_user_email    => 'admin@example.com',
       :q_puppet_enterpriseconsole_auth_password      => '~!@#$%^*-/ aZ',
       :q_puppet_enterpriseconsole_smtp_port          => 25,
       :q_puppet_enterpriseconsole_smtp_use_tls       => 'n',
       :q_verify_packages                             => 'y',
-      :q_puppetdb_password                           => '~!@#$%^*-/ aZ',
+      :q_puppetdb_database_password                  => '~!@#$%^*-/ aZ',
       :q_puppetmaster_enterpriseconsole_port         => 443,
       :q_puppet_enterpriseconsole_auth_database_name => 'console_auth',
       :q_puppet_enterpriseconsole_auth_database_user => 'mYu7hu3r',
@@ -25,8 +30,8 @@ module BeakerAnswers
       :q_puppetdb_database_user                      => 'mYpdBu3r',
       :q_database_port                               => 5432,
       :q_puppetdb_port                               => 8081,
+      :q_classifier_database_name                    => 'pe-classifier',
       :q_classifier_database_user                    => 'DFGhjlkj',
-      :q_database_name                               => 'pe-classifier',
       :q_classifier_database_password                => '~!@#$%^*-/ aZ',
       :q_activity_database_user                      => 'adsfglkj',
       :q_activity_database_name                      => 'pe-activity',
@@ -40,6 +45,27 @@ module BeakerAnswers
       :q_pe_check_for_updates                        => 'n',
     })
 
+    DEFAULT_HIERA_ANSWERS = StringifyHash.new.merge(flatten_keys_to_joined_string({
+      'console_admin_password' => DEFAULT_ANSWERS[:q_puppet_enterpriseconsole_auth_password],
+      'puppet_enterprise' => {
+        'puppetdb_database_name'         => DEFAULT_ANSWERS[:q_puppetdb_database_name],
+        'puppetdb_database_user'         => DEFAULT_ANSWERS[:q_puppetdb_database_user],
+        'puppetdb_database_password'     => DEFAULT_ANSWERS[:q_puppetdb_database_password],
+        'classifier_database_name'       => DEFAULT_ANSWERS[:q_classifier_database_name],
+        'classifier_database_user'       => DEFAULT_ANSWERS[:q_classifier_database_user],
+        'classifier_database_password'   => DEFAULT_ANSWERS[:q_classifier_database_password],
+        'activity_database_name'         => DEFAULT_ANSWERS[:q_activity_database_name],
+        'activity_database_user'         => DEFAULT_ANSWERS[:q_activity_database_user],
+        'activity_database_password'     => DEFAULT_ANSWERS[:q_activity_database_password],
+        'rbac_database_name'             => DEFAULT_ANSWERS[:q_rbac_database_name],
+        'rbac_database_user'             => DEFAULT_ANSWERS[:q_rbac_database_user],
+        'rbac_database_password'         => DEFAULT_ANSWERS[:q_rbac_database_password],
+        'orchestrator_database_name'     => DEFAULT_ANSWERS[:q_orchestrator_database_name],
+        'orchestrator_database_user'     => DEFAULT_ANSWERS[:q_orchestrator_database_user],
+        'orchestrator_database_password' => DEFAULT_ANSWERS[:q_orchestrator_database_password],
+        'use_application_services'       => true,
+      }
+    }))
 
     # Determine the list of supported PE versions, return as an array
     # @return [Array<String>] An array of the supported versions
@@ -47,6 +73,12 @@ module BeakerAnswers
       BeakerAnswers.constants.select {|c| BeakerAnswers.const_get(c).is_a?(Class) && BeakerAnswers.const_get(c).respond_to?(:pe_version_matcher)}
     end
 
+    # Determine the list of supported upgrade PE versions, return as an array
+    # @return [Array<String>] An array of the supported versions
+    def self.supported_upgrade_versions
+      BeakerAnswers.constants.select {|c| BeakerAnswers.const_get(c).is_a?(Class) && BeakerAnswers.const_get(c).respond_to?(:upgrade_version_matcher)}
+    end
+
     # When given a Puppet Enterprise version, a list of hosts and other
     # qualifying data this method will return the appropriate object that can be used
     # to generate answer file data.
@@ -58,6 +90,15 @@ module BeakerAnswers
     # @return [Hash] A hash (keyed from hosts) containing hashes of answer file
     #   data.
     def self.create version, hosts, options
+      # if :upgrade is detected, then we return the simpler upgrade answers
+      if options[:type] == :upgrade
+        self.supported_upgrade_versions.each do |upgrade_version_class|
+          if BeakerAnswers.const_get(upgrade_version_class).send(:upgrade_version_matcher) =~ version
+            return BeakerAnswers.const_get(upgrade_version_class).send(:new, version, hosts, options)
+          end
+        end
+        warn 'Only upgrades to version 3.8.x generate specific upgrade answers. Defaulting to full answers.'
+      end
 
       # finds all potential version classes
       # discovers new version classes as they are added, no more crazy case statement
@@ -71,16 +112,30 @@ module BeakerAnswers
       raise NotImplementedError, "Don't know how to generate answers for #{version}"
     end
 
-    # The answer value for a provided question.  Use the user answer when available, otherwise return the default
+    # The answer value for a provided question.  Use the user answer when
+    # available, otherwise return the default.
+    #
     # @param [Hash] options options for answer file
-    # @option options [Symbol] :answer Contains a hash of user provided question name and answer value pairs.
-    # @param [String] default Should there be no user value for the provided question name return this default
+    # @option options [Symbol] :answers Contains a hash of user provided
+    #   question name and answer value pairs.
+    # @param [String] default Should there be no user value for the provided
+    #   question name return this default
     # @return [String] The answer value
     def answer_for(options, q, default = nil)
-      answer = DEFAULT_ANSWERS[q]
+      case @format
+      when :bash
+        answer = DEFAULT_ANSWERS[q]
+        answers = options[:answers]
+      when :hiera
+        answer = DEFAULT_HIERA_ANSWERS[q]
+        answers = flatten_keys_to_joined_string(options[:answers]) if options[:answers]
+      else
+        raise NotImplementedError, "Don't know how to determine answers for #{@format}"
+      end
+
       # check to see if there is a value for this in the provided options
-      if options[:answers] && options[:answers][q]
-        answer = options[:answers][q]
+      if answers && answers[q]
+        answer = answers[q]
       end
       # use the default if we don't have anything
       if not answer
@@ -89,6 +144,16 @@ module BeakerAnswers
       answer
     end
 
+    def get_defaults_or_answers(defaults_to_set)
+      config = {}
+
+      defaults_to_set.each do |key|
+          config[key] = answer_for(@options, key)
+      end
+
+      return config
+    end
+
     # When given a Puppet Enterprise version, a list of hosts and other
     # qualifying data this method will return a hash (keyed from the hosts)
     # of default Puppet Enterprise answer file data hashes.
@@ -97,12 +162,17 @@ module BeakerAnswers
     # @param [Array<Beaker::Host>] hosts An array of host objects.
     # @param [Hash] options options for answer files
     # @option options [Symbol] :type Should be one of :upgrade or :install.
+    # @option options [Symbol] :format Should be one of :bash or :hiera. This
+    #   is a temporary setting which only has an impact on version201620 answers.
+    #   Setting :bash will result in the "classic" PE answer file being generated
+    #   Setting :hiera will generate the new PE hiera config file format
     # @return [Hash] A hash (keyed from hosts) containing hashes of answer file
     #   data.
     def initialize(version, hosts, options)
       @version = version
       @hosts = hosts
       @options = options
+      @format = (options[:format] || DEFAULT_FORMAT).to_sym
     end
 
     # Generate the answers hash based upon version, host and option information
@@ -132,6 +202,14 @@ module BeakerAnswers
       answers[host.name].map { |k,v| "#{k}=#{v}" }.join("\n")
     end
 
+    def answer_hiera
+      raise(NotImplementedError, "Hiera configuration is not available in this version of PE (#{self.class})")
+    end
+
+    def installer_configuration_string(host)
+      answer_string(host)
+    end
+
     #Find a single host with the role provided.  Raise an error if more than one host is found to have the
     #provided role.
     #
@@ -147,7 +225,6 @@ module BeakerAnswers
       end
       found_hosts.first
     end
-
   end
 
   # pull in all the available answer versions

data/lib/beaker-answers/helpers.rb

@@ -0,0 +1,14 @@
+def flatten_keys_to_joined_string(h, key_delim='::')
+  flat = {}
+  h.each_pair do |k, v|
+    if v.respond_to?(:keys)
+      flatten_keys_to_joined_string(v, key_delim).each_pair do |k2, v2|
+        flat.merge!({[k.to_s, k2.to_s].join(key_delim) => v2})
+      end
+    else
+      flat.merge!({ k.to_s => v })
+    end
+  end
+
+  flat
+end

data/lib/beaker-answers/version.rb

@@ -1,5 +1,5 @@
 module BeakerAnswers
   module Version
-    STRING = '0.4.3'
+    STRING = '0.5.0'
   end
 end

data/lib/beaker-answers/versions/upgrade.rb

@@ -0,0 +1,18 @@
+module BeakerAnswers
+  # In the case of upgrades, we only start with the answer for installation
+  class Upgrade < Answers
+
+    def default_upgrade_answers
+      {:q_install => answer_for(@options, :q_install)}
+    end
+
+    def generate_answers
+      the_answers = {}
+      @hosts.each do |host|
+        the_answers[host.name] = default_upgrade_answers
+      end
+      the_answers
+    end
+
+  end
+end

data/lib/beaker-answers/versions/upgrade38.rb

@@ -0,0 +1,79 @@
+module BeakerAnswers
+  # In the case of upgrades, we lay down only necessary answers
+  class Upgrade38 < Upgrade
+
+    def self.upgrade_version_matcher
+      /\A3\.8/
+    end
+
+    def generate_answers
+      the_answers = super
+      dashboard = only_host_with_role(@hosts, 'dashboard')
+      master = only_host_with_role(@hosts, 'master')
+      database = only_host_with_role(@hosts, 'database')
+      @hosts.each do |host|
+        # Both the dashboard and database need shared answers about the new console services
+        if host == dashboard || host == database
+          the_answers[host.name][:q_rbac_database_name] = answer_for(@options, :q_rbac_database_name)
+          the_answers[host.name][:q_rbac_database_user] = answer_for(@options, :q_rbac_database_user)
+          the_answers[host.name][:q_rbac_database_password] = "'#{answer_for(@options, :q_rbac_database_password)}'"
+          the_answers[host.name][:q_activity_database_name] = answer_for(@options, :q_activity_database_name)
+          the_answers[host.name][:q_activity_database_user] = answer_for(@options, :q_activity_database_user)
+          the_answers[host.name][:q_activity_database_password] = "'#{answer_for(@options, :q_activity_database_password)}'"
+          the_answers[host.name][:q_classifier_database_name] = answer_for(@options, :q_classifier_database_name)
+          the_answers[host.name][:q_classifier_database_user] = answer_for(@options, :q_classifier_database_user)
+          the_answers[host.name][:q_classifier_database_password] = "'#{answer_for(@options, :q_classifier_database_password)}'"
+          the_answers[host.name][:q_puppetmaster_certname] = answer_for(@options, :q_puppetmaster_certname)
+          # The dashboard also needs additional answers about puppetdb on the remote host
+          if host == dashboard
+            the_answers[host.name][:q_puppet_enterpriseconsole_auth_password] = "'#{answer_for(@options, :q_puppet_enterpriseconsole_auth_password)}'"
+            the_answers[host.name][:q_puppetdb_hostname] = answer_for(@options, :q_puppetdb_hostname, database.reachable_name)
+            the_answers[host.name][:q_puppetdb_database_password] = "'#{answer_for(@options, :q_puppetdb_database_password)}'"
+            the_answers[host.name][:q_puppetdb_database_name] = answer_for(@options, :q_puppetdb_database_name)
+            the_answers[host.name][:q_puppetdb_database_user] = answer_for(@options, :q_puppetdb_database_user)
+            the_answers[host.name][:q_puppetdb_port] = answer_for(@options, :q_puppetdb_port)
+          end
+        end
+        # merge custom host answers if available
+        the_answers[host.name] = the_answers[host.name].merge(host[:custom_answers]) if host[:custom_answers]
+      end
+
+      the_answers.map do |hostname, answers|
+        # First check to see if there is a host option for this setting
+        # and skip to the next object if it is already defined.
+        if the_answers[hostname][:q_enable_future_parser]
+          next
+        # Check now if it was set in the global options.
+        elsif @options[:answers] && @options[:answers][:q_enable_future_parser]
+          the_answers[hostname][:q_enable_future_parser] = @options[:answers][:q_enable_future_parser]
+          next
+        # If we didn't set it on a per host or global option basis, set it to
+        # 'y' here. We could have possibly set it in the DEFAULT_ANSWERS, but it
+        # is unclear what kind of effect that might have on all the other answers
+        # that rely on it defaulting to 'n'.
+        else
+          the_answers[hostname][:q_enable_future_parser] = 'y'
+        end
+      end
+
+      the_answers.map do |hostname, answers|
+        # First check to see if there is a host option for this setting
+        # and skip to the next object if it is already defined.
+        if the_answers[hostname][:q_exit_for_nc_migrate]
+          next
+        # Check now if it was set in the global options.
+        elsif @options[:answers] && @options[:answers][:q_exit_for_nc_migrate]
+          the_answers[hostname][:q_exit_for_nc_migrate] = @options[:answers][:q_exit_for_nc_migrate]
+          next
+        # If we didn't set it on a per host or global option basis, set it to
+        # 'n' here. We could have possibly set it in the DEFAULT_ANSWERS, but it
+        # is unclear what kind of effect that might have on all the other answers
+        # that rely on it defaulting to 'n'.
+        else
+          the_answers[hostname][:q_exit_for_nc_migrate] = 'n'
+        end
+      end
+      the_answers
+    end
+  end
+end

data/lib/beaker-answers/versions/version20162.rb

@@ -14,6 +14,18 @@ module BeakerAnswers
       the_answers = super
 
       return the_answers if @options[:masterless]
+
+      case @format
+      when :bash
+        return generate_bash_answers(the_answers)
+      when :hiera
+        return generate_hiera_config
+      else
+        raise NotImplementedError, "Don't know how to generate answers for #{@format}"
+      end
+    end
+
+    def generate_bash_answers(answers)
       console = only_host_with_role(@hosts, 'dashboard')
 
       # To allow SSL cert based auth in the new installer while maintaining the legacy
@@ -24,9 +36,101 @@ module BeakerAnswers
         :q_orchestrator_database_user     => answer_for(@options, :q_orchestrator_database_user),
       }
 
-      the_answers[console.name].merge!(orchestrator_db)
+      answers[console.name].merge!(orchestrator_db)
+
+      return answers
+    end
+
+    def generate_hiera_config
+      # The hiera answer file format will get all answers, regardless of role
+      # it is being installed on
+      hiera_hash = {}
+
+      # Add the correct host values for this beaker configuration
+      hiera_hash.merge!(hiera_host_config)
+
+      hiera_hash.merge!(get_defaults_or_answers([
+        "console_admin_password",
+        "puppet_enterprise::use_application_services",
+      ]))
+
+      hiera_hash.merge!(hiera_db_config)
+
+      # Override with any values provided in the :answers key hash
+      if @options[:answers]
+        if @options[:answers].keys.any? { |k| k.to_s.start_with?('q_') }
+          raise(TypeError, "q_ answers are not supported when using the hiera answers format")
+        else
+          hiera_hash.merge!(flatten_keys_to_joined_string(@options[:answers]))
+        end
+      end
+
+      return hiera_hash
+    end
+
+    def hiera_host_config
+      config = {}
+      ns = "puppet_enterprise"
+
+      master = only_host_with_role(@hosts, 'master')
+      puppetdb = only_host_with_role(@hosts, 'database')
+      console = only_host_with_role(@hosts, 'dashboard')
+
+      config["#{ns}::certificate_authority_host"] = answer_for(@options, "#{ns}::certificate_authority_host", master.hostname)
+      config["#{ns}::puppet_master_host"] = answer_for(@options, "#{ns}::puppet_master_host", master.hostname)
+      config["#{ns}::console_host"] = answer_for(@options, "#{ns}::console_host", console.hostname)
+      config["#{ns}::puppetdb_host"] = answer_for(@options, "#{ns}::puppetdb_host", puppetdb.hostname)
+      config["#{ns}::database_host"] = answer_for(@options, "#{ns}::database_host", puppetdb.hostname)
+      config["#{ns}::pcp_broker_host"] = answer_for(@options, "#{ns}::pcp_broker_host", master.hostname)
+      config["#{ns}::mcollective_middleware_hosts"] = [answer_for(@options, "#{ns}::mcollective_middleware_hosts", master.hostname)]
+
+      return config
+    end
+
+    def hiera_db_config
+      ns = "puppet_enterprise"
+      defaults_to_set = []
+
+      # Set database users only if we are upgrading from < 2016.2.0; necessary
+      # because BeakerAnswers sets database user to non-default values in
+      # earlier versions.
+      if @options[:include_legacy_database_defaults]
+        # Database names/users. Required for password and cert-based auth
+        defaults_to_set += [
+          "#{ns}::puppetdb_database_user",
+          "#{ns}::classifier_database_user",
+          "#{ns}::activity_database_user",
+          "#{ns}::rbac_database_user",
+          "#{ns}::orchestrator_database_user",
+        ]
+      end
+
+      get_defaults_or_answers(defaults_to_set)
+    end
+
+    # This converts a data hash provided by answers, and returns a Puppet
+    # Enterprise compatible hiera config file ready for use.
+    #
+    # @return [String] a string of parseable hocon
+    # @example Generating an answer file for a series of hosts
+    #   hosts.each do |host|
+    #     answers = Beaker::Answers.new("2.0", hosts, "master")
+    #     create_remote_file host, "/mypath/answer", answers.answer_hiera
+    #  end
+    def answer_hiera
+      # Render pretty JSON, because it is a subset of HOCON
+      json = JSON.pretty_generate(answers)
+      hocon = Hocon::Parser::ConfigDocumentFactory.parse_string(json)
+      hocon.render
+    end
 
-      the_answers
+    def installer_configuration_string(host)
+      case @format
+        when :bash then answer_string(host)
+        when :hiera then answer_hiera
+        else
+          raise NotImplementedError, "Don't know how to generate for configuration #{@format}"
+      end
     end
   end
 end

data/lib/beaker-answers/versions/version30.rb

@@ -73,7 +73,7 @@ module BeakerAnswers
         console_auth_password = "'#{answer_for(options, :q_puppet_enterpriseconsole_auth_password)}'"
         puppetdb_database_name = answer_for(options, :q_puppetdb_database_name, 'pe-puppetdb')
         puppetdb_database_user = answer_for(options, :q_puppetdb_database_user, 'mYpdBu3r')
-        puppetdb_database_password = answer_for(options, :q_puppetdb_database_password, "'#{answer_for(options, :q_puppetdb_password)}'")
+        puppetdb_database_password = "'#{answer_for(options, :q_puppetdb_database_password)}'"
         console_auth_database_name = answer_for(options, :q_puppet_enterpriseconsole_auth_database_name, 'console_auth')
         console_auth_database_user = answer_for(options, :q_puppet_enterpriseconsole_auth_database_user, 'mYu7hu3r')
         console_auth_database_password = answer_for(options, :q_puppet_enterpriseconsole_auth_database_password, console_auth_password)

data/lib/beaker-answers/versions/version34.rb

@@ -20,7 +20,7 @@ module BeakerAnswers
       the_answers = super
 
       classifier_database_user     = answer_for(@options, :q_classifier_database_user, 'DFGhjlkj')
-      classifier_database_name     = answer_for(@options, :q_database_name, 'pe-classifier')
+      classifier_database_name     = answer_for(@options, :q_classifier_database_name, 'pe-classifier')
       classifier_database_password = "'#{answer_for(@options, :q_classifier_database_password)}'"
       activity_database_user       = answer_for(@options, :q_activity_database_user, 'adsfglkj')
       activity_database_name       = answer_for(@options, :q_activity_database_name, 'pe-activity')