beaker 2.18.0 → 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,24 +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)
-            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.
@@ -58,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
         #
@@ -68,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
 
@@ -81,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?
@@ -91,17 +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"
-            pe_debug = host[:pe_debug] || opts[:pe_debug] ? " && cat #{log_file}" : ''
-            if host.is_cygwin?
-              "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}"
-            else
-              "cd #{host['working_dir']} &&  msiexec.exe /qn /L*V #{log_file} /i #{host['dist']}.msi PUPPET_MASTER_SERVER=#{master} PUPPET_AGENT_CERTNAME=#{host}#{pe_debug}"
-            end
           # 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 = []
@@ -342,6 +318,7 @@ module Beaker
         # @option opts [Boolean] :fetch_local_then_push_to_host determines whether
         #                 you use Beaker as the middleman for this (true), or curl the
         #                 file from the host (false; default behavior)
+        # @option opts [Boolean] :masterless Are we performing a masterless installation?
         #
         # @example
         #  do_install(hosts, {:type => :upgrade, :pe_dir => path, :pe_ver => version, :pe_ver_win =>  version_win})
@@ -352,8 +329,7 @@ module Beaker
         # @api private
         #
         def do_install hosts, opts = {}
-          masterless = (defined? options) ? options[:masterless] : false
-          opts[:masterless] = masterless # has to pass masterless down for answer generation awareness
+          masterless = opts[:masterless]
           opts[:type] = opts[:type] || :install
           unless masterless
             pre30database = version_is_less(opts[:pe_ver] || database['pe_ver'], '3.0')
@@ -414,18 +390,22 @@ module Beaker
           install_hosts.each do |host|
             if agent_only_check_needed && hosts_agent_only.include?(host)
               host['type'] = 'aio'
-              install_puppet_agent_pe_promoted_repo_on(host, { :puppet_agent_version => opts[:puppet_agent_version],
-                                                               :puppet_agent_sha => opts[:puppet_agent_sha],
-                                                               :pe_ver => opts[:pe_ver],
-                                                               :puppet_collection => opts[:puppet_collection] })
-              setup_defaults_and_config_helper_on(host, master, [0, 1])
+              install_puppet_agent_pe_promoted_repo_on(host, { :puppet_agent_version => host[:puppet_agent_version] || opts[:puppet_agent_version],
+                                                               :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] })
+              # 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]
@@ -436,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
 
@@ -534,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}")
@@ -550,12 +530,12 @@ 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
         #                                 only hosts on 4.0+
-        # @option opts [String] :puppet_agent_sha The sha of puppet-agent to install, defaults to puppet-agent-version.
+        # @option opts [String] :puppet_agent_sha The sha of puppet-agent to install, defaults to puppet_agent_version.
         #                                 Required for PE agent only hosts on 4.0+
         # @option opts [String] :pe_ver   The version of PE (will also use host['pe_ver']), defaults to '4.0'
         # @option opts [String] :puppet_collection   The puppet collection for puppet-agent install.
@@ -567,17 +547,22 @@ 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
-            hosts.each do |host|
+        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/
-                host['pe_ver'] = host['pe_ver'] || opts['pe_ver'] ||
-                  Beaker::Options::PEVersionScraper.load_pe_version(host[:pe_dir] || opts[:pe_dir], opts[:pe_version_file_win])
+                # we don't need the pe_version if:
+                # * master pe_ver > 4.0
+                if not (!opts[:masterless] && master[:pe_ver] && !version_is_less(master[:pe_ver], '3.99'))
+                  host['pe_ver'] ||= Beaker::Options::PEVersionScraper.load_pe_version(host[:pe_dir] || opts[:pe_dir], opts[:pe_version_file_win])
+                else
+                  # inherit the master's version
+                  host['pe_ver'] ||= master[:pe_ver]
+                end
               else
-                host['pe_ver'] = host['pe_ver'] || opts['pe_ver'] ||
-                  Beaker::Options::PEVersionScraper.load_pe_version(host[:pe_dir] || opts[:pe_dir], opts[:pe_version_file])
+                host['pe_ver'] ||= Beaker::Options::PEVersionScraper.load_pe_version(host[:pe_dir] || opts[:pe_dir], opts[:pe_version_file])
               end
             end
             do_install sorted_hosts, opts
@@ -591,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.
@@ -603,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)
 

data/lib/beaker/host/freebsd/pkg.rb

@@ -0,0 +1,18 @@
+module FreeBSD::Pkg
+  include Beaker::CommandFactory
+
+  def install_package(name, cmdline_args = nil, opts = {})
+    case self['platform']
+    when /freebsd-9/
+      cmdline_args ||= '-rF'
+      result = execute("pkg_add #{cmdline_args} #{name}", opts) { |result| result }
+    when /freebsd-10/
+      cmdline_args ||= '-y'
+      result = execute("pkg install #{cmdline_args} #{name}", opts) { |result| result }
+    else
+      raise "Package #{name} could not be installed on #{self}"
+    end
+    result.exit_code == 0
+  end
+
+end

data/lib/beaker/host/freebsd.rb

@@ -7,11 +7,13 @@ module FreeBSD
 
     [
       'exec',
+      'pkg',
     ].each do |lib|
         require "beaker/host/freebsd/#{lib}"
     end
 
     include FreeBSD::Exec
+    include FreeBSD::Pkg
 
     def platform_defaults
       h = Beaker::Options::OptionsHash.new

data/lib/beaker/host/unix/exec.rb

@@ -102,11 +102,11 @@ module Unix::Exec
     env_file = self[:ssh_env_file]
     escaped_val = Regexp.escape(val).gsub('/', '\/').gsub(';', '\;')
     #see if the key/value pair already exists
-    if exec(Beaker::Command.new("grep #{key}=.*#{escaped_val} #{env_file}"), :accept_all_exit_codes => true ).exit_code == 0
+    if exec(Beaker::Command.new("grep ^#{key}=.*#{escaped_val} #{env_file}"), :accept_all_exit_codes => true ).exit_code == 0
       return #nothing to do here, key value pair already exists
     #see if the key already exists
-    elsif exec(Beaker::Command.new("grep #{key} #{env_file}"), :accept_all_exit_codes => true ).exit_code == 0
-      exec(Beaker::SedCommand.new(self['platform'], "s/#{key}=/#{key}=#{escaped_val}:/", env_file))
+    elsif exec(Beaker::Command.new("grep ^#{key} #{env_file}"), :accept_all_exit_codes => true ).exit_code == 0
+      exec(Beaker::SedCommand.new(self['platform'], "s/^#{key}=/#{key}=#{escaped_val}:/", env_file))
     else
       exec(Beaker::Command.new("echo \"#{key}=#{val}\" >> #{env_file}"))
     end

data/lib/beaker/host/unix/pkg.rb

@@ -40,6 +40,8 @@ module Unix::Pkg
         result = execute("pkg_info #{name}", opts) { |result| result }
       when /freebsd-10/
         result = execute("pkg info #{name}", opts) { |result| result }
+      when /openbsd/
+        result = execute("pkg_info #{name}", opts) { |result| result }
       else
         raise "Package #{name} cannot be queried on #{self}"
     end
@@ -63,6 +65,11 @@ module Unix::Pkg
         execute("zypper --non-interactive in #{name}", opts)
       when /el-4/
         @logger.debug("Package installation not supported on rhel4")
+      when /fedora-22/
+        if version
+          name = "#{name}-#{version}"
+        end
+        execute("dnf -y #{cmdline_args} install #{name}", opts)
       when /cisco|fedora|centos|eos|el-/
         if version
           name = "#{name}-#{version}"
@@ -82,6 +89,32 @@ module Unix::Pkg
         execute("pkg_add -fr #{cmdline_args} #{name}", opts)
       when /freebsd-10/
         execute("pkg #{cmdline_args} install #{name}", opts)
+      when /openbsd/
+        begin
+          execute("pkg_add -I #{cmdline_args} #{name}", opts) do |command|
+            # Handles where there are multiple rubies, installs the latest one
+            if command.stderr =~ /^Ambiguous: #{name} could be (.+)$/
+              name = $1.chomp.split(' ').collect { |x|
+                x =~ /-(\d[^-p]+)/
+                [x, $1]
+              }.select { |x|
+                # Blacklist Ruby 2.2.0+ for the sake of Puppet 3.x
+                Gem::Version.new(x[1]) < Gem::Version.new('2.2.0')
+              }.sort { |a,b|
+                Gem::Version.new(b[1]) <=> Gem::Version.new(a[1])
+              }.collect { |x|
+                x[0]
+              }.first
+              raise ArgumentException
+            end
+            # If the package advises symlinks to be created, do it
+            command.stdout.split(/\n/).select { |x| x =~ /^\s+ln\s/ }.each do |ln|
+              execute(ln, opts)
+            end
+          end
+        rescue
+          retry
+        end
       else
         raise "Package #{name} cannot be installed on #{self}"
     end
@@ -93,6 +126,8 @@ module Unix::Pkg
         execute("zypper --non-interactive rm #{name}", opts)
       when /el-4/
         @logger.debug("Package uninstallation not supported on rhel4")
+      when /fedora-22/
+        execute("dnf -y #{cmdline_args} remove #{name}", opts)
       when /cisco|fedora|centos|eos|el-/
         execute("yum -y #{cmdline_args} remove #{name}", opts)
       when /ubuntu|debian|cumulus/
@@ -117,6 +152,8 @@ module Unix::Pkg
         execute("zypper --non-interactive --no-gpg-checks up #{name}", opts)
       when /el-4/
         @logger.debug("Package upgrade is not supported on rhel4")
+      when /fedora-22/
+        execute("dnf -y #{cmdline_args} update #{name}", opts)
       when /cisco|fedora|centos|eos|el-/
         execute("yum -y #{cmdline_args} update #{name}", opts)
       when /ubuntu|debian|cumulus/

data/lib/beaker/host/windows/exec.rb

@@ -3,6 +3,9 @@ module Windows::Exec
 
   def reboot
     exec(Beaker::Command.new('shutdown /r /t 0 /d p:4:1 /c "Beaker::Host reboot command issued"'), :expect_connection_failure => true)
+    # rebooting on windows is sloooooow
+    # give it some breathing room before attempting a reconnect
+    sleep(30)
   end
 
   ABS_CMD = 'c:\\\\windows\\\\system32\\\\cmd.exe'