beaker 2.18.3 → 2.19.0

data/lib/beaker/dsl/install_utils/pe_utils.rb

@@ -1,6 +1,7 @@
-[ 'aio_defaults', 'pe_defaults', 'puppet_utils' ].each do |lib|
+[ 'aio_defaults', 'pe_defaults', 'puppet_utils', 'windows_utils' ].each do |lib|
     require "beaker/dsl/install_utils/#{lib}"
 end
+require "beaker-answers"
 module Beaker
   module DSL
     module InstallUtils
@@ -18,26 +19,7 @@ module Beaker
         include AIODefaults
         include PEDefaults
         include PuppetUtils
-
-        # Set defaults and PATH for these hosts to be either pe or aio, have host['type'] == aio for aio settings, defaults
-        # to pe.
-        #
-        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
-        #                            or a role (String or Symbol) that identifies one or more hosts.
-        def configure_pe_defaults_on( hosts )
-          block_on hosts do |host|
-            if host[:pe_ver] && aio_version?(host) or (host['type'] && host['type'] =~ /aio/)
-              add_aio_defaults_on(host)
-              # provide a sane default here for puppetservice
-              host['puppetservice'] ||= 'pe-puppetserver'
-            else
-              add_pe_defaults_on(host)
-            end
-            # add pathing env
-            add_puppet_paths_on(host)
-          end
-        end
-
+        include WindowsUtils
 
         # @!macro [new] common_opts
         #   @param [Hash{Symbol=>String}] opts Options to alter execution.
@@ -60,6 +42,7 @@ module Beaker
         #     running the command.
 
         #Sort array of hosts so that it has the correct order for PE installation based upon each host's role
+        #@param subset [Array<Host>] An array of hosts to sort, defaults to global 'hosts' object
         # @example
         #  h = sorted_hosts
         #
@@ -70,12 +53,13 @@ module Beaker
         #        Fourth: everything else
         #
         # @!visibility private
-        def sorted_hosts
+        def sorted_hosts subset = hosts
           special_nodes = []
           [master, database, dashboard].uniq.each do |host|
-            special_nodes << host if host != nil
+            special_nodes << host if host != nil && subset.include?(host)
           end
           real_agents = agents - special_nodes
+          real_agents = real_agents.delete_if{ |host| !subset.include?(host) }
           special_nodes + real_agents
         end
 
@@ -83,8 +67,6 @@ module Beaker
         # @param [Host] host The host that PE is to be installed on
         #                    For UNIX machines using the full PE installer, the host object must have the 'pe_installer' field set correctly.
         # @param [Hash{Symbol=>String}] opts The options
-        # @option opts [String] :pe_ver_win Default PE version to install or upgrade to on Windows hosts
-        #                          (Othersie uses individual Windows hosts pe_ver)
         # @option opts [String]  :pe_ver Default PE version to install or upgrade to
         #                          (Otherwise uses individual hosts pe_ver)
         # @option opts [Boolean] :pe_debug (false) Should we run the installer in debug mode?
@@ -93,16 +75,9 @@ module Beaker
         # @api private
         def installer_cmd(host, opts)
           version = host['pe_ver'] || opts[:pe_ver]
-          if host['platform'] =~ /windows/
-            log_file = "#{File.basename(host['working_dir'])}.log"
-            # cat may not be available with strictly Windows environments
-            # Prefer `type` as an alternative to `cat` if non-cygwin
-            win_cat = host.is_cygwin? ? "cat" : "type"
-            pe_debug = host[:pe_debug] || opts[:pe_debug] ? " && #{win_cat} #{log_file}" : ''
-            "cd #{host['working_dir']} && cmd /C 'start /w msiexec.exe /qn /L*V #{log_file} /i #{host['dist']}.msi PUPPET_MASTER_SERVER=#{master} PUPPET_AGENT_CERTNAME=#{host}'#{pe_debug}"
           # Frictionless install didn't exist pre-3.2.0, so in that case we fall
           # through and do a regular install.
-          elsif host['roles'].include? 'frictionless' and ! version_is_less(version, '3.2.0')
+          if host['roles'].include? 'frictionless' and ! version_is_less(version, '3.2.0')
             # PE 3.4 introduced the ability to pass in config options to the bash script in the form
             # of <section>:<key>=<value>
             frictionless_install_opts = []
@@ -419,14 +394,18 @@ module Beaker
                                                                :puppet_agent_sha => host[:puppet_agent_sha] || opts[:puppet_agent_sha],
                                                                :pe_ver => host[:pe_ver] || opts[:pe_ver],
                                                                :puppet_collection => host[:puppet_collection] || opts[:puppet_collection] })
-              setup_defaults_and_config_helper_on(host, master, [0, 1])
+              # 1 since no certificate found and waitforcert disabled
+              acceptable_exit_codes = [0, 1]
+              acceptable_exit_codes << 2 if opts[:type] == :upgrade
+              setup_defaults_and_config_helper_on(host, master, acceptable_exit_codes)
             elsif host['platform'] =~ /windows/
-              on host, installer_cmd(host, opts)
-              configure_pe_defaults_on(host)
-              if not host.is_cygwin?
-                # HACK: for some reason, post install we need to refresh the connection to make puppet available for execution
-                host.close
-              end
+              opts = { :debug => host[:pe_debug] || opts[:pe_debug] }
+              msi_path = "#{host['working_dir']}\\#{host['dist']}.msi"
+              install_msi_on(host, msi_path, {}, opts)
+
+              # 1 since no certificate found and waitforcert disabled
+              acceptable_exit_codes = 1
+              setup_defaults_and_config_helper_on(host, master, acceptable_exit_codes)
             else
               # We only need answers if we're using the classic installer
               version = host['pe_ver'] || opts[:pe_ver]
@@ -437,17 +416,17 @@ module Beaker
                   deploy_frictionless_to_master(host)
                 end
                 on host, installer_cmd(host, opts)
-                configure_pe_defaults_on(host)
+                configure_type_defaults_on(host)
               elsif host['platform'] =~ /osx|eos/
                 # If we're not frictionless, we need to run the OSX special-case
                 on host, installer_cmd(host, opts)
                 acceptable_codes = host['platform'] =~ /osx/ ? [1] : [0, 1]
                 setup_defaults_and_config_helper_on(host, master, acceptable_codes)
               else
-                answers = Beaker::Answers.create(opts[:pe_ver] || host['pe_ver'], hosts, opts)
+                answers = BeakerAnswers::Answers.create(opts[:pe_ver] || host['pe_ver'], hosts, opts)
                 create_remote_file host, "#{host['working_dir']}/answers", answers.answer_string(host)
                 on host, installer_cmd(host, opts)
-                configure_pe_defaults_on(host)
+                configure_type_defaults_on(host)
               end
             end
 
@@ -535,7 +514,7 @@ module Beaker
         # @return nil
         # @api private
         def setup_defaults_and_config_helper_on(host, master, acceptable_exit_codes=nil)
-          configure_pe_defaults_on(host)
+          configure_type_defaults_on(host)
           #set the certname and master
           on host, puppet("config set server #{master}")
           on host, puppet("config set certname #{host}")
@@ -551,8 +530,7 @@ module Beaker
 
         #Install PE based upon host configuration and options
         #
-        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
-        #                            or a role (String or Symbol) that identifies one or more hosts.
+        # @param [Host, Array<Host>] install_hosts    One or more hosts to act upon
         # @!macro common_opts
         # @option opts [Boolean] :masterless Are we performing a masterless installation?
         # @option opts [String] :puppet_agent_version  Version of puppet-agent to install. Required for PE agent
@@ -569,10 +547,10 @@ module Beaker
         #       Install file names are assumed to be of the format puppet-enterprise-VERSION-PLATFORM.(tar)|(tar.gz)
         #       for Unix like systems and puppet-enterprise-VERSION.msi for Windows systems.
         #
-        def install_pe_on(hosts, opts)
-          #process the version files if necessary
-          confine_block(:to, {}, hosts) do
+        def install_pe_on(install_hosts, opts)
+          confine_block(:to, {}, install_hosts) do
             sorted_hosts.each do |host|
+              #process the version files if necessary
               host['pe_dir'] ||= opts[:pe_dir]
               if host['platform'] =~ /windows/
                 # we don't need the pe_version if:
@@ -598,8 +576,7 @@ module Beaker
         end
 
         #Upgrade PE based upon host configuration and options
-        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
-        #                            or a role (String or Symbol) that identifies one or more hosts.
+        # @param [Host, Array<Host>]  upgrade_hosts   One or more hosts to act upon
         # @!macro common_opts
         # @param [String] path A path (either local directory or a URL to a listing of PE builds).
         #                      Will contain a LATEST file indicating the latest build to install.
@@ -610,8 +587,8 @@ module Beaker
         #
         # @note Install file names are assumed to be of the format puppet-enterprise-VERSION-PLATFORM.(tar)|(tar.gz)
         #       for Unix like systems and puppet-enterprise-VERSION.msi for Windows systems.
-        def upgrade_pe_on hosts, opts, path=nil
-          confine_block(:to, {}, hosts) do
+        def upgrade_pe_on upgrade_hosts, opts, path=nil
+          confine_block(:to, {}, upgrade_hosts) do
             set_console_password = false
             # if we are upgrading from something lower than 3.4 then we need to set the pe console password
             if (dashboard[:pe_ver] ? version_is_less(dashboard[:pe_ver], "3.4.0") : true)

data/lib/beaker/dsl/install_utils/puppet_utils.rb

@@ -65,6 +65,46 @@ module Beaker
           end
         end
 
+        # Configure the provided hosts to be of their host[:type], it host[type] == nil do nothing
+        def configure_type_defaults_on( hosts )
+          block_on hosts do |host|
+            has_defaults = false
+            if host[:type]
+              host_type = host[:type]
+              # clean up the naming conventions here (some teams use foss-package, git-whatever, we need
+              # to correctly handle that
+              # don't worry about aio, that happens in the aio_version? check
+              host_type = case host_type
+                          when /(\A|-)(git)|(foss)(\Z|-)/
+                            'foss'
+                          when /(\A|-)pe(\Z|-)/
+                            'pe'
+                          else
+                            nil
+                          end
+              if host_type
+                add_method = "add_#{host_type}_defaults_on"
+                if self.respond_to?(add_method, host)
+                  self.send(add_method, host)
+                else
+                  raise "cannot add defaults of type #{host_type} for host #{host.name} (#{add_method} not present)"
+                end
+                has_defaults = true
+              end
+            end
+            if aio_version?(host)
+              add_aio_defaults_on(host)
+              has_defaults = true
+            end
+            # add pathing env
+            if has_defaults
+              add_puppet_paths_on(host)
+            end
+          end
+        end
+        alias_method :configure_foss_defaults_on, :configure_type_defaults_on
+        alias_method :configure_pe_defaults_on, :configure_type_defaults_on
+
         #If the host is associated with a type remove all defaults and environment associated with that type.
         # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
         #                            or a role (String or Symbol) that identifies one or more hosts.
@@ -78,6 +118,9 @@ module Beaker
               else
                 raise "cannot remove defaults of type #{host['type']} associated with host #{host.name} (#{remove_method} not present)"
               end
+              if aio_version?(host)
+                remove_aio_defaults_on(host)
+              end
             end
           end
         end

data/lib/beaker/dsl/install_utils/windows_utils.rb

@@ -0,0 +1,144 @@
+module Beaker
+  module DSL
+    module InstallUtils
+      #
+      # This module contains methods useful for Windows installs
+      #
+      module WindowsUtils
+
+        # Given a host, returns it's system TEMP path
+        # @param [Host] host An object implementing {Beaker::Hosts}'s interface.
+        def get_temp_path(host)
+          # under CYGWIN %TEMP% may not be set
+          tmp_path = on(host, Command.new('ECHO %SYSTEMROOT%', [], { :cmdexe => true }))
+          tmp_path.output.gsub(/\n/, '') + '\\TEMP'
+        end
+
+        # Generates commands to be inserted into a Windows batch file to launch an MSI install
+        # @param [String] msi_path The path of the MSI - can be a local Windows style file path like
+        #                   c:\temp\puppet.msi OR a url like https://download.com/puppet.msi or file://c:\temp\puppet.msi
+        # @param  [Hash{String=>String}] msi_opts MSI installer options
+        #                   See https://docs.puppetlabs.com/guides/install_puppet/install_windows.html#msi-properties
+        # @param [String] log_path The path to write the MSI log - must be a local Windows style file path
+        #
+        # @api private
+        def msi_install_script(msi_path, msi_opts, log_path)
+          # msiexec requires backslashes in file paths launched under cmd.exe start /w
+          url_pattern = /^(https?|file):\/\//
+          msi_path = msi_path.gsub(/\//, "\\") if msi_path !~ url_pattern
+
+          msi_params = msi_opts.map{|k, v| "#{k}=#{v}"}.join(' ')
+
+          # msiexec requires quotes around paths with backslashes - c:\ or file://c:\
+          # not strictly needed for http:// but it simplifies this code
+          batch_contents = <<-BATCH
+start /w msiexec.exe /i \"#{msi_path}\" /qn /L*V #{log_path} #{msi_params}
+exit /B %errorlevel%
+          BATCH
+        end
+
+        # Given a host, path to MSI and MSI options, will create a batch file
+        #   on the host, returning the path to the randomized batch file and
+        #   the randomized log file
+        # @param [Host] host An object implementing {Beaker::Hosts}'s interface.
+        # @param [String] msi_path The path of the MSI - can be a local Windows style file path like
+        #                   c:\temp\puppet.msi OR a url like https://download.com/puppet.msi or file://c:\temp\puppet.msi
+        # @param  [Hash{String=>String}] msi_opts MSI installer options
+        #                   See https://docs.puppetlabs.com/guides/install_puppet/install_windows.html#msi-properties
+        # @api private
+        def create_install_msi_batch_on(host, msi_path, msi_opts)
+          timestamp = Time.new.strftime('%Y-%m-%d_%H.%M.%S')
+          tmp_path = get_temp_path(host)
+
+          batch_name = "install-puppet-msi-#{timestamp}.bat"
+          batch_path = "#{tmp_path}\\#{batch_name}"
+
+          log_path = "#{tmp_path}\\install-puppet-#{timestamp}.log"
+
+          Tempfile.open(batch_name) do |tmp_file|
+            batch_contents = msi_install_script(msi_path, msi_opts, log_path)
+
+            File.open(tmp_file.path, 'w') { |file| file.puts(batch_contents) }
+            host.do_scp_to(tmp_file.path, batch_path, {})
+          end
+
+          return batch_path, log_path
+        end
+
+        # Given hosts construct a PATH that includes puppetbindir, facterbindir and hierabindir
+        # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
+        #                            or a role (String or Symbol) that identifies one or more hosts.
+        # @param [String] msi_path The path of the MSI - can be a local Windows style file path like
+        #                   c:\temp\puppet.msi OR a url like https://download.com/puppet.msi or file://c:\temp\puppet.msi
+        # @param  [Hash{String=>String}] msi_opts MSI installer options
+        #                   See https://docs.puppetlabs.com/guides/install_puppet/install_windows.html#msi-properties
+        # @option msi_opts [String] INSTALLIDIR Where Puppet and its dependencies should be installed.
+        #                  (Defaults vary based on operating system and intaller architecture)
+        #                  Requires Puppet 2.7.12 / PE 2.5.0
+        # @option msi_opts [String] PUPPET_MASTER_SERVER The hostname where the puppet master server can be reached.
+        #                  (Defaults to puppet)
+        #                  Requires Puppet 2.7.12 / PE 2.5.0
+        # @option msi_opts [String] PUPPET_CA_SERVER The hostname where the CA puppet master server can be reached, if you are using multiple masters and only one of them is acting as the CA.
+        #                  (Defaults the value of PUPPET_MASTER_SERVER)
+        #                  Requires Puppet 2.7.12 / PE 2.5.0
+        # @option msi_opts [String] PUPPET_AGENT_CERTNAME The node’s certificate name, and the name it uses when requesting catalogs. This will set a value for
+        #                  (Defaults to the node's fqdn as discovered by facter fqdn)
+        #                  Requires Puppet 2.7.12 / PE 2.5.0
+        # @option msi_opts [String] PUPPET_AGENT_ENVIRONMENT The node’s environment.
+        #                  (Defaults to production)
+        #                  Requires Puppet 3.3.1 / PE 3.1.0
+        # @option msi_opts [String] PUPPET_AGENT_STARTUP_MODE Whether the puppet agent service should run (or be allowed to run)
+        #                  (Defaults to Manual - valid values are Automatic, Manual or Disabled)
+        #                  Requires Puppet 3.4.0 / PE 3.2.0
+        # @option msi_opts [String] PUPPET_AGENT_ACCOUNT_USER Whether the puppet agent service should run (or be allowed to run)
+        #                  (Defaults to LocalSystem)
+        #                  Requires Puppet 3.4.0 / PE 3.2.0
+        # @option msi_opts [String] PUPPET_AGENT_ACCOUNT_PASSWORD The password to use for puppet agent’s user account
+        #                  (No default)
+        #                  Requires Puppet 3.4.0 / PE 3.2.0
+        # @option msi_opts [String] PUPPET_AGENT_ACCOUNT_DOMAIN The domain of puppet agent’s user account.
+        #                  (Defaults to .)
+        #                  Requires Puppet 3.4.0 / PE 3.2.0
+        # @option opts [Boolean] :debug output the MSI installation log when set to true
+        #                 otherwise do not output log (false; default behavior)
+        #
+        # @example
+        #  install_msi_on(hosts, 'c:\puppet.msi', {:debug => true})
+        #
+        # @api private
+        def install_msi_on(hosts, msi_path, msi_opts = {}, opts = {})
+          block_on hosts do | host |
+            msi_opts['PUPPET_AGENT_STARTUP_MODE'] ||= 'Manual'
+            batch_path, log_file = create_install_msi_batch_on(host, msi_path, msi_opts)
+
+            # begin / rescue here so that we can reuse existing error msg propagation
+            begin
+              # 1641 = ERROR_SUCCESS_REBOOT_INITIATED
+              # 3010 = ERROR_SUCCESS_REBOOT_REQUIRED
+              on host, Command.new("\"#{batch_path}\"", [], { :cmdexe => true }), :acceptable_exit_codes => [0, 1641, 3010]
+            rescue
+              on host, Command.new("type \"#{log_file}\"", [], { :cmdexe => true })
+              raise
+            end
+
+            if opts[:debug]
+              on host, Command.new("type \"#{log_file}\"", [], { :cmdexe => true })
+            end
+
+            if !host.is_cygwin?
+              # HACK: for some reason, post install we need to refresh the connection to make puppet available for execution
+              host.close
+            end
+
+            # verify service status post install
+            # if puppet service exists, then pe-puppet is not queried
+            # if puppet service does not exist, pe-puppet is queried and that exit code is used
+            # therefore, this command will always exit 0 if either service is installed
+            on host, Command.new("sc query puppet || sc query pe-puppet", [], { :cmdexe => true })
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/beaker/dsl/roles.rb

@@ -119,16 +119,25 @@ module Beaker
           host['roles'].length == 1 && host['roles'].include?('agent')
       end
 
-      # Determine whether a host has an AIO version or not. If a host :pe_ver
+      # Determine whether a host has an AIO version or not. If a host :pe_ver or :version
       # is not specified, then it is open-ended, and as such, can be an AIO
       # version depending on the context.
       #
+      # True when any of the following cases are true
+      #   * has PE version (:pe_ver) >= 4.0
+      #   * has FOSS version (:version) >= 4.0
+      #   * host has role 'aio'
+      #   * host as the type 'aio'
+      #
       # @note aio version is just a base-line condition.  If you want to check
       #   that a host is an aio agent, refer to {#aio_agent?}.
       #
       # @return [Boolean] whether or not a host is AIO-capable
       def aio_version?(host)
-        return !( host[:pe_ver] && version_is_less(host[:pe_ver], '4.0') )
+        return (( host[:pe_ver] && !version_is_less(host[:pe_ver], '4.0') ) ||
+               ( host[:version] && !version_is_less(host[:version], '4.0') ) ||
+               ( host[:roles] && host[:roles].include?('aio')) ||
+               ( host[:type] && !!(host[:type] =~ /(\A|-)aio(\Z|-)/ ))) == true
       end
 
       # Determine if the host is an AIO agent
@@ -140,6 +149,14 @@ module Beaker
         aio_version?(host) && agent_only(host)
       end
 
+      # Add the provided role to the host
+      #
+      # @param [Host] host Host to add role to
+      # @param [String] role The role to add to host
+      def add_role(host, role)
+        host[:roles] = host[:roles] | [role]
+      end
+
       #Create a new role method for a given arbitrary role name.  Makes it possible to be able to run
       #commands without having to refer to role by String or Symbol.  Will not add a new method 
       #definition if the name is already in use.
@@ -156,7 +173,7 @@ module Beaker
         else
           if not respond_to? role
             if role !~ /\A[[:alpha:]]+[a-zA-Z0-9_]*[!?=]?\Z/
-              raise "Role name format error for '#{role}'.  Allowed characters are: \na-Z\n0-9 (as long as not at the beginning of name)\n'_'\n'?', '!' and '=' (only as individual last character at end of name)"
+              raise ArgumentError, "Role name format error for '#{role}'.  Allowed characters are: \na-Z\n0-9 (as long as not at the beginning of name)\n'_'\n'?', '!' and '=' (only as individual last character at end of name)"
             end
             self.class.send :define_method, role.to_s do
               hosts_with_role = hosts_as role.to_sym

data/lib/beaker/dsl/structure.rb

@@ -167,18 +167,29 @@ module Beaker
       # @example Confining to an already defined subset of hosts
       #     confine :to, {}, agents
       #
+      # @example Confining from  an already defined subset of hosts
+      #     confine :except, {}, agents
+      #
+      #
       # @return [Array<Host>] Returns an array of hosts that are still valid
       #   targets for this tests case.
       # @raise [SkipTest] Raises skip test if there are no valid hosts for
       #   this test case after confinement.
       def confine(type, criteria, host_array = nil, &block)
-        hosts_to_modify = host_array || hosts
+        hosts_to_modify = Array( host_array || hosts )
         case type
         when :except
-          hosts_to_modify = hosts_to_modify - select_hosts(criteria, hosts_to_modify, &block)
+          if criteria and ( not criteria.empty? )
+            hosts_to_modify = hosts_to_modify - select_hosts(criteria, hosts_to_modify, &block)
+          else
+            # confining to all hosts *except* provided array of hosts
+            hosts_to_modify = hosts - host_array
+          end
         when :to
           if criteria and ( not criteria.empty? )
             hosts_to_modify = select_hosts(criteria, hosts_to_modify, &block)
+          else
+            # confining to only hosts in provided array of hosts
           end
         else
           raise "Unknown option #{type}"
@@ -198,7 +209,7 @@ module Beaker
       # @see #confine
       def confine_block(type, criteria, host_array = nil, &block)
         begin
-          host_array ||= hosts
+          host_array = Array( host_array || hosts )
           original_hosts = self.hosts.dup
           confine(type, criteria, host_array)