beaker 2.7.1 → 2.8.0

data/lib/beaker/dsl/helpers/tk_helpers.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+require 'hocon'
+require 'hocon/config_error'
+require 'inifile'
+
+module Beaker
+  module DSL
+    module Helpers
+      # Convenience methods for modifying and reading TrapperKeeper configs
+      module TKHelpers
+
+        # @!macro common_opts
+        #   @param [Hash{Symbol=>String}] opts Options to alter execution.
+        #   @option opts [Boolean] :silent (false) Do not produce log output
+        #   @option opts [Array<Fixnum>] :acceptable_exit_codes ([0]) An array
+        #     (or range) of integer exit codes that should be considered
+        #     acceptable.  An error will be thrown if the exit code does not
+        #     match one of the values in this list.
+        #   @option opts [Hash{String=>String}] :environment ({}) These will be
+        #     treated as extra environment variables that should be set before
+        #     running the command.
+        #
+
+        # Modify the given TrapperKeeper config file.
+        #
+        # @param [Host] host  A host object
+        # @param [OptionsHash] options_hash  New hash which will be merged into
+        #                                    the given TrapperKeeper config.
+        # @param [String] config_file_path  Path to the TrapperKeeper config on
+        #                                   the given host which is to be
+        #                                   modified.
+        # @param [Bool] replace  If set true, instead of updating the existing
+        #                        TrapperKeeper configuration, replace it entirely
+        #                        with the contents of the given hash.
+        #
+        # @note TrapperKeeper config files can be HOCON, JSON, or Ini. We don't
+        # particularly care which of these the file named by `config_file_path` on
+        # the SUT actually is, just that the contents can be parsed into a map.
+        #
+        def modify_tk_config(host, config_file_path, options_hash, replace=false)
+          if options_hash.empty?
+            return nil
+          end
+
+          new_hash = Beaker::Options::OptionsHash.new
+
+          if replace
+            new_hash.merge!(options_hash)
+          else
+            if not host.file_exist?( config_file_path )
+              raise "Error: #{config_file_path} does not exist on #{host}"
+            end
+            file_string = host.exec( Command.new( "cat #{config_file_path}" )).stdout
+
+            begin
+              tk_conf_hash = read_tk_config_string(file_string)
+            rescue RuntimeError
+              raise "Error reading trapperkeeper config: #{config_file_path} at host: #{host}"
+            end
+
+            new_hash.merge!(tk_conf_hash)
+            new_hash.merge!(options_hash)
+          end
+
+          file_string = JSON.dump(new_hash)
+          create_remote_file host, config_file_path, file_string
+        end
+
+        # The Trapperkeeper config service will accept HOCON (aka typesafe), JSON,
+        # or Ini configuration files which means we need to safely handle the the
+        # exceptions that might come from parsing the given string with the wrong
+        # parser and fall back to the next valid parser in turn. We finally raise
+        # a RuntimeException if none of the parsers succeed.
+        #
+        # @!visibility private
+        def read_tk_config_string( string )
+            begin
+              return Hocon.parse(string)
+            rescue Hocon::ConfigError
+              nil
+            end
+
+            begin
+              return JSON.parse(string)
+            rescue JSON::JSONError
+              nil
+            end
+
+            begin
+              return IniFile.new(string)
+            rescue IniFile::Error
+              nil
+            end
+
+            raise "Failed to read TrapperKeeper config!"
+        end
+      end
+
+    end
+  end
+end

data/lib/beaker/dsl/helpers/web_helpers.rb

@@ -0,0 +1,115 @@
+module Beaker
+  module DSL
+    module Helpers
+      # Convenience methods for checking links and moving web content to hosts
+      module WebHelpers
+
+        # @!macro common_opts
+        #   @param [Hash{Symbol=>String}] opts Options to alter execution.
+        #   @option opts [Boolean] :silent (false) Do not produce log output
+        #   @option opts [Array<Fixnum>] :acceptable_exit_codes ([0]) An array
+        #     (or range) of integer exit codes that should be considered
+        #     acceptable.  An error will be thrown if the exit code does not
+        #     match one of the values in this list.
+        #   @option opts [Hash{String=>String}] :environment ({}) These will be
+        #     treated as extra environment variables that should be set before
+        #     running the command.
+        #
+
+        # Blocks until the port is open on the host specified, returns false
+        # on failure
+        def port_open_within?( host, port = 8140, seconds = 120 )
+          repeat_for( seconds ) do
+            host.port_open?( port )
+          end
+        end
+
+        #Determine is a given URL is accessible
+        #@param [String] link The URL to examine
+        #@return [Boolean] true if the URL has a '200' HTTP response code, false otherwise
+        #@example
+        #  extension = link_exists?("#{URL}.tar.gz") ? ".tar.gz" : ".tar"
+        def link_exists?(link)
+          require "net/http"
+          require "net/https"
+          require "open-uri"
+          url = URI.parse(link)
+          http = Net::HTTP.new(url.host, url.port)
+          http.use_ssl = (url.scheme == 'https')
+          http.start do |http|
+            return http.head(url.request_uri).code == "200"
+          end
+        end
+
+        # Fetch file_name from the given base_url into dst_dir.
+        #
+        # @param [String] base_url The base url from which to recursively download
+        #                          files.
+        # @param [String] file_name The trailing name compnent of both the source url
+        #                           and the destination file.
+        # @param [String] dst_dir The local destination directory.
+        #
+        # @return [String] dst The name of the newly-created file.
+        #
+        # @!visibility private
+        def fetch_http_file(base_url, file_name, dst_dir)
+          FileUtils.makedirs(dst_dir)
+          src = "#{base_url}/#{file_name}"
+          dst = File.join(dst_dir, file_name)
+          if File.exists?(dst)
+            logger.notify "Already fetched #{dst}"
+          else
+            logger.notify "Fetching: #{src}"
+            logger.notify "  and saving to #{dst}"
+            open(src) do |remote|
+              File.open(dst, "w") do |file|
+                FileUtils.copy_stream(remote, file)
+              end
+            end
+          end
+          return dst
+        end
+
+        # Recursively fetch the contents of the given http url, ignoring
+        # `index.html` and `*.gif` files.
+        #
+        # @param [String] url The base http url from which to recursively download
+        #                     files.
+        # @param [String] dst_dir The local destination directory.
+        #
+        # @return [String] dst The name of the newly-created subdirectory of
+        #                      dst_dir.
+        #
+        # @!visibility private
+        def fetch_http_dir(url, dst_dir)
+          logger.notify "fetch_http_dir (url: #{url}, dst_dir #{dst_dir})"
+          if url[-1, 1] !~ /\//
+            url += '/'
+          end
+          url = URI.parse(url)
+          chunks = url.path.split('/')
+          dst = File.join(dst_dir, chunks.last)
+          #determine directory structure to cut
+          #only want to keep the last directory, thus cut total number of dirs - 2 (hostname + last dir name)
+          cut = chunks.length - 2
+          wget_command = "wget -nv -P #{dst_dir} --reject \"index.html*\",\"*.gif\" --cut-dirs=#{cut} -np -nH --no-check-certificate -r #{url}"
+
+          logger.notify "Fetching remote directory: #{url}"
+          logger.notify "  and saving to #{dst}"
+          logger.notify "  using command: #{wget_command}"
+
+          #in ruby 1.9+ we can upgrade this to popen3 to gain access to the subprocess pid
+          result = `#{wget_command} 2>&1`
+          result.each_line do |line|
+            logger.debug(line)
+          end
+          if $?.to_i != 0
+            raise "Failed to fetch_remote_dir '#{url}' (exit code #{$?}"
+          end
+          dst
+        end
+
+      end
+    end
+  end
+end

data/lib/beaker/dsl/install_utils.rb

@@ -1,1577 +1,15 @@
-require 'pathname'
+[ 'pe', 'puppet', 'ezbake', 'module' ].each do |lib|
+    require "beaker/dsl/install_utils/#{lib}_utils"
+end
 
 module Beaker
   module DSL
-    #
-    # This module contains methods to help cloning, extracting git info,
-    # ordering of Puppet packages, and installing ruby projects that
-    # contain an `install.rb` script.
-    #
-    # To mix this is into a class you need the following:
-    # * a method *hosts* that yields any hosts implementing
-    #   {Beaker::Host}'s interface to act upon.
-    # * a method *options* that provides an options hash, see {Beaker::Options::OptionsHash}
-    # * the module {Beaker::DSL::Roles} that provides access to the various hosts implementing
-    #   {Beaker::Host}'s interface to act upon
-    # * the module {Beaker::DSL::Wrappers} the provides convenience methods for {Beaker::DSL::Command} creation
+    # Collection of installation methods and support
     module InstallUtils
-
-      # The default install path
-      SourcePath  = "/opt/puppet-git-repos"
-
-      # A regex to know if the uri passed is pointing to a git repo
-      GitURI       = %r{^(git|https?|file)://|^git@|^gitmirror@}
-
-      # Github's ssh signature for cloning via ssh
-      GitHubSig   = 'github.com,207.97.227.239 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ=='
-
-      # The directories in the module directory that will not be scp-ed to the test system when using `copy_module_to`
-      PUPPET_MODULE_INSTALL_IGNORE = ['.bundle', '.git', '.idea', '.vagrant', '.vendor', 'vendor', 'acceptance', 'bundle', 'spec', 'tests', 'log']
-
-      # @param [String] uri A uri in the format of <git uri>#<revision>
-      #                     the `git://`, `http://`, `https://`, and ssh
-      #                     (if cloning as the remote git user) protocols
-      #                     are valid for <git uri>
-      #
-      # @example Usage
-      #     project = extract_repo_info_from 'git@github.com:puppetlabs/SuperSecretSauce#what_is_justin_doing'
-      #
-      #     puts project[:name]
-      #     #=> 'SuperSecretSauce'
-      #
-      #     puts project[:rev]
-      #     #=> 'what_is_justin_doing'
-      #
-      # @return [Hash{Symbol=>String}] Returns a hash containing the project
-      #                                name, repository path, and revision
-      #                                (defaults to HEAD)
-      #
-      # @api dsl
-      def extract_repo_info_from uri
-        project = {}
-        repo, rev = uri.split('#', 2)
-        project[:name] = Pathname.new(repo).basename('.git').to_s
-        project[:path] = repo
-        project[:rev]  = rev || 'HEAD'
-        return project
-      end
-
-      # Takes an array of package info hashes (like that returned from
-      # {#extract_repo_info_from}) and sorts the `puppet`, `facter`, `hiera`
-      # packages so that puppet's dependencies will be installed first.
-      #
-      # @!visibility private
-      def order_packages packages_array
-        puppet = packages_array.select {|e| e[:name] == 'puppet' }
-        puppet_depends_on = packages_array.select do |e|
-          e[:name] == 'hiera' or e[:name] == 'facter'
-        end
-        depends_on_puppet = (packages_array - puppet) - puppet_depends_on
-        [puppet_depends_on, puppet, depends_on_puppet].flatten
-      end
-
-      # @param [Host] host An object implementing {Beaker::Hosts}'s
-      #                    interface.
-      # @param [String] path The path on the remote [host] to the repository
-      # @param [Hash{Symbol=>String}] repository A hash representing repo
-      #                                          info like that emitted by
-      #                                          {#extract_repo_info_from}
-      #
-      # @example Getting multiple project versions
-      #     versions = [puppet_repo, facter_repo, hiera_repo].inject({}) do |vers, repo_info|
-      #       vers.merge(find_git_repo_versions(host, '/opt/git-puppet-repos', repo_info) )
-      #     end
-      # @return [Hash] Executes git describe on [host] and returns a Hash
-      #                with the key of [repository[:name]] and value of
-      #                the output from git describe.
-      #
-      # @note This requires the helper methods:
-      #       * {Beaker::DSL::Structure#step}
-      #       * {Beaker::DSL::Helpers#on}
-      #
-      # @api dsl
-      def find_git_repo_versions host, path, repository
-        version = {}
-        step "Grab version for #{repository[:name]}" do
-          on host, "cd #{path}/#{repository[:name]} && " +
-                    "git describe || true" do
-            version[repository[:name]] = stdout.chomp
-          end
-        end
-        version
-      end
-
-      #
-      # @see #find_git_repo_versions
-      def install_from_git host, path, repository
-        name          = repository[:name]
-        repo          = repository[:path]
-        rev           = repository[:rev]
-        depth         = repository[:depth]
-        depth_branch  = repository[:depth_branch]
-        target        = "#{path}/#{name}"
-
-        if (depth_branch.nil?)
-          depth_branch = rev
-        end
-
-        clone_cmd = "git clone #{repo} #{target}"
-        if (depth)
-          clone_cmd = "git clone --branch #{depth_branch} --depth #{depth} #{repo} #{target}"
-        end
-
-        step "Clone #{repo} if needed" do
-          on host, "test -d #{path} || mkdir -p #{path}"
-          on host, "test -d #{target} || #{clone_cmd}"
-        end
-
-        step "Update #{name} and check out revision #{rev}" do
-          commands = ["cd #{target}",
-                      "remote rm origin",
-                      "remote add origin #{repo}",
-                      "fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/*",
-                      "clean -fdx",
-                      "checkout -f #{rev}"]
-          on host, commands.join(" && git ")
-        end
-
-        step "Install #{name} on the system" do
-          # The solaris ruby IPS package has bindir set to /usr/ruby/1.8/bin.
-          # However, this is not the path to which we want to deliver our
-          # binaries. So if we are using solaris, we have to pass the bin and
-          # sbin directories to the install.rb
-          install_opts = ''
-          install_opts = '--bindir=/usr/bin --sbindir=/usr/sbin' if
-            host['platform'].include? 'solaris'
-
-            on host,  "cd #{target} && " +
-                      "if [ -f install.rb ]; then " +
-                      "ruby ./install.rb #{install_opts}; " +
-                      "else true; fi"
-        end
-      end
-
-      #Create the PE install command string based upon the host and options settings
-      # @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?
-      # @example
-      #      on host, "#{installer_cmd(host, opts)} -a #{host['working_dir']}/answers"
-      # @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')
-          # 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 = []
-          if host.has_key?('frictionless_options') and !  version_is_less(version, '3.4.0')
-            # since we have options to pass in, we need to tell the bash script
-            host['frictionless_options'].each do |section, settings|
-              settings.each do |key, value|
-                frictionless_install_opts << "#{section}:#{key}=#{value}"
-              end
-            end
-          end
-
-          pe_debug = host[:pe_debug] || opts[:pe_debug] ? ' -x' : ''
-          "cd #{host['working_dir']} && curl --tlsv1 -kO https://#{master}:8140/packages/#{version}/install.bash && bash#{pe_debug} install.bash #{frictionless_install_opts.join(' ')}".strip
-        elsif host['platform'] =~ /osx/
-          version = host['pe_ver'] || opts[:pe_ver]
-          pe_debug = host[:pe_debug] || opts[:pe_debug] ? ' -verboseR' : ''
-          "cd #{host['working_dir']} && hdiutil attach #{host['dist']}.dmg && installer#{pe_debug} -pkg /Volumes/puppet-enterprise-#{version}/puppet-enterprise-installer-#{version}.pkg -target /"
-        elsif host['platform'] =~ /eos/
-          commands = ['enable', "extension puppet-enterprise-#{version}-#{host['platform']}.swix"]
-          command = commands.join("\n")
-          "Cli -c '#{command}'"
-        else
-          pe_debug = host[:pe_debug] || opts[:pe_debug]  ? ' -D' : ''
-          "cd #{host['working_dir']}/#{host['dist']} && ./#{host['pe_installer']}#{pe_debug} -a #{host['working_dir']}/answers"
-        end
-      end
-
-      #Create the Higgs install command string based upon the host and options settings.  Installation command will be run as a
-      #background process.  The output of the command will be stored in the provided host['higgs_file'].
-      # @param [Host] host The host that Higgs is to be installed on
-      #                    The host object must have the 'working_dir', 'dist' and 'pe_installer' field set correctly.
-      # @api private
-      def higgs_installer_cmd host
-
-        "cd #{host['working_dir']}/#{host['dist']} ; nohup ./#{host['pe_installer']} <<<Y > #{host['higgs_file']} 2>&1 &"
-
-      end
-
-      #Determine is a given URL is accessible
-      #@param [String] link The URL to examine
-      #@return [Boolean] true if the URL has a '200' HTTP response code, false otherwise
-      #@example
-      #  extension = link_exists?("#{URL}.tar.gz") ? ".tar.gz" : ".tar"
-      # @api private
-      def link_exists?(link)
-        require "net/http"
-        require "net/https"
-        require "open-uri"
-        url = URI.parse(link)
-        http = Net::HTTP.new(url.host, url.port)
-        http.use_ssl = (url.scheme == 'https')
-        http.start do |http|
-          return http.head(url.request_uri).code == "200"
-        end
-      end
-
-      # Fetch file_name from the given base_url into dst_dir.
-      #
-      # @param [String] base_url The base url from which to recursively download
-      #                          files.
-      # @param [String] file_name The trailing name compnent of both the source url
-      #                           and the destination file.
-      # @param [String] dst_dir The local destination directory.
-      #
-      # @return [String] dst The name of the newly-created file.
-      #
-      # @!visibility private
-      def fetch_http_file(base_url, file_name, dst_dir)
-        FileUtils.makedirs(dst_dir)
-        src = "#{base_url}/#{file_name}"
-        dst = File.join(dst_dir, file_name)
-        if File.exists?(dst)
-          logger.notify "Already fetched #{dst}"
-        else
-          logger.notify "Fetching: #{src}"
-          logger.notify "  and saving to #{dst}"
-          open(src) do |remote|
-            File.open(dst, "w") do |file|
-              FileUtils.copy_stream(remote, file)
-            end
-          end
-        end
-        return dst
-      end
-
-      # Recursively fetch the contents of the given http url, ignoring
-      # `index.html` and `*.gif` files.
-      #
-      # @param [String] url The base http url from which to recursively download
-      #                     files.
-      # @param [String] dst_dir The local destination directory.
-      #
-      # @return [String] dst The name of the newly-created subdirectory of
-      #                      dst_dir.
-      #
-      # @!visibility private
-      def fetch_http_dir(url, dst_dir)
-        logger.notify "fetch_http_dir (url: #{url}, dst_dir #{dst_dir})"
-        if url[-1, 1] !~ /\//
-          url += '/'
-        end
-        url = URI.parse(url)
-        chunks = url.path.split('/')
-        dst = File.join(dst_dir, chunks.last)
-        #determine directory structure to cut
-        #only want to keep the last directory, thus cut total number of dirs - 2 (hostname + last dir name)
-        cut = chunks.length - 2
-        wget_command = "wget -nv -P #{dst_dir} --reject \"index.html*\",\"*.gif\" --cut-dirs=#{cut} -np -nH --no-check-certificate -r #{url}"
-
-        logger.notify "Fetching remote directory: #{url}"
-        logger.notify "  and saving to #{dst}"
-        logger.notify "  using command: #{wget_command}"
-
-        #in ruby 1.9+ we can upgrade this to popen3 to gain access to the subprocess pid
-        result = `#{wget_command} 2>&1`
-        result.each_line do |line|
-          logger.debug(line)
-        end
-        if $?.to_i != 0
-          raise "Failed to fetch_remote_dir '#{url}' (exit code #{$?}"
-        end
-        dst
-      end
-
-      #Determine the PE package to download/upload on a mac host, download/upload that package onto the host.
-      # Assumed file name format: puppet-enterprise-3.3.0-rc1-559-g97f0833-osx-10.9-x86_64.dmg.
-      # @param [Host] host The mac host to download/upload and unpack PE onto
-      # @param  [Hash{Symbol=>Symbol, String}] opts The options
-      # @option opts [String] :pe_dir Default directory or URL to pull PE package from
-      #                  (Otherwise uses individual hosts pe_dir)
-      # @api private
-      def fetch_puppet_on_mac(host, opts)
-        path = host['pe_dir'] || opts[:pe_dir]
-        local = File.directory?(path)
-        filename = "#{host['dist']}"
-        extension = ".dmg"
-        if local
-          if not File.exists?("#{path}/#{filename}#{extension}")
-            raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
-          end
-          scp_to host, "#{path}/#{filename}#{extension}", "#{host['working_dir']}/#{filename}#{extension}"
-        else
-          if not link_exists?("#{path}/#{filename}#{extension}")
-            raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
-          end
-          on host, "cd #{host['working_dir']}; curl -O #{path}/#{filename}#{extension}"
-        end
-      end
-
-      #Determine the PE package to download/upload on a windows host, download/upload that package onto the host.
-      #Assumed file name format: puppet-enterprise-3.3.0-rc1-559-g97f0833.msi
-      # @param [Host] host The windows host to download/upload and unpack PE onto
-      # @param  [Hash{Symbol=>Symbol, String}] opts The options
-      # @option opts [String] :pe_dir Default directory or URL to pull PE package from
-      #                  (Otherwise uses individual hosts pe_dir)
-      # @option opts [String] :pe_ver_win Default PE version to install or upgrade to
-      #                  (Otherwise uses individual hosts pe_ver)
-      # @api private
-      def fetch_puppet_on_windows(host, opts)
-        path = host['pe_dir'] || opts[:pe_dir]
-        local = File.directory?(path)
-        version = host['pe_ver'] || opts[:pe_ver_win]
-        filename = "#{host['dist']}"
-        extension = ".msi"
-        if local
-          if not File.exists?("#{path}/#{filename}#{extension}")
-            raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
-          end
-          scp_to host, "#{path}/#{filename}#{extension}", "#{host['working_dir']}/#{filename}#{extension}"
-        else
-          if not link_exists?("#{path}/#{filename}#{extension}")
-            raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
-          end
-          if host.is_cygwin?
-            on host, "cd #{host['working_dir']}; curl -O #{path}/#{filename}#{extension}"
-          else
-            on host, powershell("$webclient = New-Object System.Net.WebClient;  $webclient.DownloadFile('#{path}/#{filename}#{extension}','#{host['working_dir']}\\#{filename}#{extension}')")
-          end
-        end
-      end
-
-      #Determine the PE package to download/upload on a unix style host, download/upload that package onto the host
-      #and unpack it.
-      # @param [Host] host The unix style host to download/upload and unpack PE onto
-      # @param  [Hash{Symbol=>Symbol, String}] opts The options
-      # @option opts [String] :pe_dir Default directory or URL to pull PE package from
-      #                  (Otherwise uses individual hosts pe_dir)
-      # @api private
-      def fetch_puppet_on_unix(host, opts)
-        path = host['pe_dir'] || opts[:pe_dir]
-        local = File.directory?(path)
-        filename = "#{host['dist']}"
-        if local
-          extension = File.exists?("#{path}/#{filename}.tar.gz") ? ".tar.gz" : ".tar"
-          if not File.exists?("#{path}/#{filename}#{extension}")
-            raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
-          end
-          scp_to host, "#{path}/#{filename}#{extension}", "#{host['working_dir']}/#{filename}#{extension}"
-          if extension =~ /gz/
-            on host, "cd #{host['working_dir']}; gunzip #{filename}#{extension}"
-          end
-          if extension =~ /tar/
-            on host, "cd #{host['working_dir']}; tar -xvf #{filename}.tar"
-          end
-        else
-          if host['platform'] =~ /eos/
-            extension = '.swix'
-          else
-            extension = link_exists?("#{path}/#{filename}.tar.gz") ? ".tar.gz" : ".tar"
-          end
-          if not link_exists?("#{path}/#{filename}#{extension}")
-            raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
-          end
-
-          if host['platform'] =~ /eos/
-            commands = ['enable', "copy #{path}/#{filename}#{extension} extension:"]
-            command = commands.join("\n")
-            on host, "Cli -c '#{command}'"
-          else
-            unpack = 'tar -xvf -'
-            unpack = extension =~ /gz/ ? 'gunzip | ' + unpack  : unpack
-            on host, "cd #{host['working_dir']}; curl #{path}/#{filename}#{extension} | #{unpack}"
-          end
-        end
-      end
-
-      #Determine the PE package to download/upload per-host, download/upload that package onto the host
-      #and unpack it.
-      # @param [Array<Host>] hosts The hosts to download/upload and unpack PE onto
-      # @param  [Hash{Symbol=>Symbol, String}] opts The options
-      # @option opts [String] :pe_dir Default directory or URL to pull PE package from
-      #                  (Otherwise uses individual hosts pe_dir)
-      # @option opts [String] :pe_ver Default PE version to install or upgrade to
-      #                  (Otherwise uses individual hosts pe_ver)
-      # @option opts [String] :pe_ver_win Default PE version to install or upgrade to on Windows hosts
-      #                  (Otherwise uses individual Windows hosts pe_ver)
-      # @api private
-      def fetch_puppet(hosts, opts)
-        hosts.each do |host|
-          # We install Puppet from the master for frictionless installs, so we don't need to *fetch* anything
-          next if host['roles'].include?('frictionless') && (! version_is_less(opts[:pe_ver] || host['pe_ver'], '3.2.0'))
-
-          if host['platform'] =~ /windows/
-            fetch_puppet_on_windows(host, opts)
-          elsif host['platform'] =~ /osx/
-            fetch_puppet_on_mac(host, opts)
-          else
-            fetch_puppet_on_unix(host, opts)
-          end
-        end
-      end
-
-      #Classify the master so that it can deploy frictionless packages for a given host.
-      # @param [Host] host The host to install pacakges for
-      # @api private
-      def deploy_frictionless_to_master(host)
-        klass = host['platform'].gsub(/-/, '_').gsub(/\./,'')
-        klass = "pe_repo::platform::#{klass}"
-        on dashboard, "cd /opt/puppet/share/puppet-dashboard && /opt/puppet/bin/bundle exec /opt/puppet/bin/rake nodeclass:add[#{klass},skip]"
-        on dashboard, "cd /opt/puppet/share/puppet-dashboard && /opt/puppet/bin/bundle exec /opt/puppet/bin/rake node:add[#{master},,,skip]"
-        on dashboard, "cd /opt/puppet/share/puppet-dashboard && /opt/puppet/bin/bundle exec /opt/puppet/bin/rake node:addclass[#{master},#{klass}]"
-        on master, puppet("agent -t"), :acceptable_exit_codes => [0,2]
-      end
-
-      #Perform a Puppet Enterprise upgrade or install
-      # @param [Array<Host>] hosts The hosts to install or upgrade PE on
-      # @param  [Hash{Symbol=>Symbol, String}] opts The options
-      # @option opts [String] :pe_dir Default directory or URL to pull PE package from
-      #                  (Otherwise uses individual hosts pe_dir)
-      # @option opts [String] :pe_ver Default PE version to install or upgrade to
-      #                  (Otherwise uses individual hosts pe_ver)
-      # @option opts [String] :pe_ver_win Default PE version to install or upgrade to on Windows hosts
-      #                  (Otherwise uses individual Windows hosts pe_ver)
-      # @option opts [Symbol] :type (:install) One of :upgrade or :install
-      # @option opts [Boolean] :set_console_password Should we set the PE console password in the answers file?  Used during upgrade only.
-      # @option opts [Hash<String>] :answers Pre-set answers based upon ENV vars and defaults
-      #                             (See {Beaker::Options::Presets.env_vars})
-      #
-      # @example
-      #  do_install(hosts, {:type => :upgrade, :pe_dir => path, :pe_ver => version, :pe_ver_win =>  version_win})
-      #
-      # @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
-        opts[:type] = opts[:type] || :install
-        unless masterless
-          pre30database = version_is_less(opts[:pe_ver] || database['pe_ver'], '3.0')
-          pre30master = version_is_less(opts[:pe_ver] || master['pe_ver'], '3.0')
-
-          unless version_is_less(opts[:pe_ver] || master['pe_ver'], '3.4')
-            master['puppetservice'] = 'pe-puppetserver'
-          end
-        end
-
-        # Set PE distribution for all the hosts, create working dir
-        use_all_tar = ENV['PE_USE_ALL_TAR'] == 'true'
-        hosts.each do |host|
-          host['pe_installer'] ||= 'puppet-enterprise-installer'
-          if host['platform'] !~ /windows|osx/
-            platform = use_all_tar ? 'all' : host['platform']
-            version = host['pe_ver'] || opts[:pe_ver]
-            host['dist'] = "puppet-enterprise-#{version}-#{platform}"
-          elsif host['platform'] =~ /osx/
-            version = host['pe_ver'] || opts[:pe_ver]
-            host['dist'] = "puppet-enterprise-#{version}-#{host['platform']}"
-          elsif host['platform'] =~ /windows/
-            version = host[:pe_ver] || opts['pe_ver_win']
-            should_install_64bit = !(version_is_less(version, '3.4')) && host.is_x86_64? && !host['install_32'] && !opts['install_32']
-            #only install 64bit builds if
-            # - we are on pe version 3.4+
-            # - we do not have install_32 set on host
-            # - we do not have install_32 set globally
-            if !(version_is_less(version, '4.0'))
-              if should_install_64bit
-                host['dist'] = "puppet-agent-#{version}-x64"
-              else
-                host['dist'] = "puppet-agent-#{version}-x86"
-              end
-            elsif should_install_64bit
-              host['dist'] = "puppet-enterprise-#{version}-x64"
-            else
-              host['dist'] = "puppet-enterprise-#{version}"
-            end
-          end
-          host['working_dir'] = host.tmpdir(Time.new.strftime("%Y-%m-%d_%H.%M.%S"))
-        end
-
-        fetch_puppet(hosts, opts)
-
-        install_hosts = hosts.dup
-        unless masterless
-          # If we're installing a database version less than 3.0, ignore the database host
-          install_hosts.delete(database) if pre30database and database != master and database != dashboard
-        end
-
-        install_hosts.each do |host|
-          if host['platform'] =~ /windows/
-            on host, installer_cmd(host, opts)
-            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
-          else
-            # We only need answers if we're using the classic installer
-            version = host['pe_ver'] || opts[:pe_ver]
-            if host['roles'].include?('frictionless') &&  (! version_is_less(version, '3.2.0'))
-              # If We're *not* running the classic installer, we want
-              # to make sure the master has packages for us.
-              deploy_frictionless_to_master(host)
-              on host, installer_cmd(host, opts)
-            elsif host['platform'] =~ /osx|eos/
-              # If we're not frictionless, we need to run the OSX special-case
-              on host, installer_cmd(host, opts)
-              #set the certname and master
-              on host, puppet("config set server #{master}")
-              on host, puppet("config set certname #{host}")
-              #run once to request cert
-              acceptable_codes = host['platform'] =~ /osx/ ? [1] : [0, 1]
-              on host, puppet_agent('-t'), :acceptable_exit_codes => acceptable_codes
-            else
-              answers = Beaker::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)
-            end
-          end
-
-          # On each agent, we ensure the certificate is signed then shut down the agent
-          sign_certificate_for(host) unless masterless
-          stop_agent_on(host)
-        end
-
-        unless masterless
-          # Wait for PuppetDB to be totally up and running (post 3.0 version of pe only)
-          sleep_until_puppetdb_started(database) unless pre30database
-
-          # Run the agent once to ensure everything is in the dashboard
-          install_hosts.each do |host|
-            on host, puppet_agent('-t'), :acceptable_exit_codes => [0,2]
-
-            # Workaround for PE-1105 when deploying 3.0.0
-            # The installer did not respect our database host answers in 3.0.0,
-            # and would cause puppetdb to be bounced by the agent run. By sleeping
-            # again here, we ensure that if that bounce happens during an upgrade
-            # test we won't fail early in the install process.
-            if host['pe_ver'] == '3.0.0' and host == database
-              sleep_until_puppetdb_started(database)
-            end
-          end
-
-          install_hosts.each do |host|
-            wait_for_host_in_dashboard(host)
-          end
-
-          if pre30master
-            task = 'nodegroup:add_all_nodes group=default'
-          else
-            task = 'defaultgroup:ensure_default_group'
-          end
-          on dashboard, "/opt/puppet/bin/rake -sf /opt/puppet/share/puppet-dashboard/Rakefile #{task} RAILS_ENV=production"
-
-          # Now that all hosts are in the dashbaord, run puppet one more
-          # time to configure mcollective
-          on install_hosts, puppet_agent('-t'), :acceptable_exit_codes => [0,2]
-        end
-      end
-
-      #Perform a Puppet Enterprise Higgs install up until web browser interaction is required, runs on linux hosts only.
-      # @param [Host] host The host to install higgs on
-      # @param  [Hash{Symbol=>Symbol, String}] opts The options
-      # @option opts [String] :pe_dir Default directory or URL to pull PE package from
-      #                  (Otherwise uses individual hosts pe_dir)
-      # @option opts [String] :pe_ver Default PE version to install
-      #                  (Otherwise uses individual hosts pe_ver)
-      # @raise [StandardError] When installation times out
-      #
-      # @example
-      #  do_higgs_install(master, {:pe_dir => path, :pe_ver => version})
-      #
-      # @api private
-      #
-      def do_higgs_install host, opts
-        use_all_tar = ENV['PE_USE_ALL_TAR'] == 'true'
-        platform = use_all_tar ? 'all' : host['platform']
-        version = host['pe_ver'] || opts[:pe_ver]
-        host['dist'] = "puppet-enterprise-#{version}-#{platform}"
-
-        use_all_tar = ENV['PE_USE_ALL_TAR'] == 'true'
-        host['pe_installer'] ||= 'puppet-enterprise-installer'
-        host['working_dir'] = host.tmpdir(Time.new.strftime("%Y-%m-%d_%H.%M.%S"))
-
-        fetch_puppet([host], opts)
-
-        host['higgs_file'] = "higgs_#{File.basename(host['working_dir'])}.log"
-        on host, higgs_installer_cmd(host), opts
-
-        #wait for output to host['higgs_file']
-        #we're all done when we find this line in the PE installation log
-        higgs_re = /Please\s+go\s+to\s+https:\/\/.*\s+in\s+your\s+browser\s+to\s+continue\s+installation/m
-        res = Result.new(host, 'tmp cmd')
-        tries = 10
-        attempts = 0
-        prev_sleep = 0
-        cur_sleep = 1
-        while (res.stdout !~ higgs_re) and (attempts < tries)
-          res = on host, "cd #{host['working_dir']}/#{host['dist']} && cat #{host['higgs_file']}", :acceptable_exit_codes => (0..255)
-          attempts += 1
-          sleep( cur_sleep )
-          prev_sleep = cur_sleep
-          cur_sleep = cur_sleep + prev_sleep
-        end
-
-        if attempts >= tries
-          raise "Failed to kick off PE (Higgs) web installation"
-        end
-
-      end
-
-      #Sort array of hosts so that it has the correct order for PE installation based upon each host's role
-      # @example
-      #  h = sorted_hosts
-      #
-      # @note Order for installation should be
-      #        First : master
-      #        Second: database host (if not same as master)
-      #        Third:  dashboard (if not same as master or database)
-      #        Fourth: everything else
-      #
-      # @!visibility private
-      def sorted_hosts
-        special_nodes = []
-        [master, database, dashboard].uniq.each do |host|
-          special_nodes << host if host != nil
-        end
-        real_agents = agents - special_nodes
-        special_nodes + real_agents
-      end
-
-      #Install FOSS based upon host configuration and options
-      # @example will install puppet 3.6.1 from native puppetlabs provided packages wherever possible and will fail over to gem installation when impossible
-      #  install_puppet({
-      #    :version          => '3.6.1',
-      #    :facter_version   => '2.0.1',
-      #    :hiera_version    => '1.3.3',
-      #    :default_action   => 'gem_install',
-      #
-      #   })
-      #
-      #
-      # @example Will install latest packages on Enterprise Linux and Debian based distros and fail hard on all othere platforms.
-      #  install_puppet()
-      #
-      # @note This will attempt to add a repository for apt.puppetlabs.com on
-      #       Debian, Ubuntu, or Cumulus machines, or yum.puppetlabs.com on EL or Fedora
-      #       machines, then install the package 'puppet'.
-      # @param [Hash{Symbol=>String}] opts
-      # @option opts [String] :version Version of puppet to download
-      # @option opts [String] :mac_download_url Url to download msi pattern of %url%/puppet-%version%.msi
-      # @option opts [String] :win_download_url Url to download dmg  pattern of %url%/(puppet|hiera|facter)-%version%.msi
-      #
-      # @api dsl
-      # @return nil
-      # @raise [StandardError] When encountering an unsupported platform by default, or if gem cannot be found when default_action => 'gem_install'
-      # @raise [FailTest] When error occurs during the actual installation process
-      def install_puppet(opts = {})
-        default_download_url = 'http://downloads.puppetlabs.com'
-        opts = {:win_download_url => "#{default_download_url}/windows",
-                :mac_download_url => "#{default_download_url}/mac"}.merge(opts)
-        hosts.each do |host|
-          if host['platform'] =~ /el-(5|6|7)/
-            relver = $1
-            install_puppet_from_rpm host, opts.merge(:release => relver, :family => 'el')
-          elsif host['platform'] =~ /fedora-(\d+)/
-            relver = $1
-            install_puppet_from_rpm host, opts.merge(:release => relver, :family => 'fedora')
-          elsif host['platform'] =~ /(ubuntu|debian|cumulus)/
-            install_puppet_from_deb host, opts
-          elsif host['platform'] =~ /windows/
-            relver = opts[:version]
-            install_puppet_from_msi host, opts
-          elsif host['platform'] =~ /osx/
-            install_puppet_from_dmg host, opts
-          else
-            if opts[:default_action] == 'gem_install'
-              install_puppet_from_gem host, opts
-            else
-              raise "install_puppet() called for unsupported platform '#{host['platform']}' on '#{host.name}'"
-            end
-          end
-
-          # Certain install paths may not create the config dirs/files needed
-          on host, "mkdir -p #{host['puppetpath']}" unless host[:type] =~ /aio/
-          on host, "echo '' >> #{host.puppet['hiera_config']}"
-        end
-        nil
-      end
-
-      # Configure a host entry on the give host
-      # @example: will add a host entry for forge.puppetlabs.com
-      #   add_system32_hosts_entry(host, { :ip => '23.251.154.122', :name => 'forge.puppetlabs.com' })
-      #
-      # @api dsl
-      # @return nil
-      def add_system32_hosts_entry(host, opts = {})
-        if host['platform'] =~ /windows/
-          hosts_file = "C:\\Windows\\System32\\Drivers\\etc\\hosts"
-          host_entry = "#{opts['ip']}`t`t#{opts['name']}"
-          on host, powershell("\$text = \\\"#{host_entry}\\\"; Add-Content -path '#{hosts_file}' -value \$text")
-        else
-          raise "nothing to do for #{host.name} on #{host['platform']}"
-        end
-      end
-
-      # Configure puppet.conf for all hosts based upon a provided Hash
-      # @param [Hash{Symbol=>String}] opts
-      # @option opts [Hash{String=>String}] :main configure the main section of puppet.conf
-      # @option opts [Hash{String=>String}] :agent configure the agent section of puppet.conf
-      #
-      # @api dsl
-      # @return nil
-      def configure_puppet(opts={})
-        hosts.each do |host|
-          configure_puppet_on(host,opts)
-        end
-      end
-
-      # Configure puppet.conf on the given host based upon a provided hash
-      # @param [Host] host The host to configure puppet.conf on
-      # @param [Hash{Symbol=>String}] opts
-      # @option opts [Hash{String=>String}] :main configure the main section of puppet.conf
-      # @option opts [Hash{String=>String}] :agent configure the agent section of puppet.conf
-      #
-      # @example will configure /etc/puppet.conf on the puppet master.
-      #   config = {
-      #     'main' => {
-      #       'server'   => 'testbox.test.local',
-      #       'certname' => 'testbox.test.local',
-      #       'logdir'   => '/var/log/puppet',
-      #       'vardir'   => '/var/lib/puppet',
-      #       'ssldir'   => '/var/lib/puppet/ssl',
-      #       'rundir'   => '/var/run/puppet'
-      #     },
-      #     'agent' => {
-      #       'environment' => 'dev'
-      #     }
-      #   }
-      #   configure_puppet(master, config)
-      #
-      # @api dsl
-      # @return nil
-      def configure_puppet_on(host, opts = {})
-        if host['platform'] =~ /windows/
-          puppet_conf = host.puppet['config']
-          conf_data = ''
-          opts.each do |section,options|
-            conf_data << "[#{section}]`n"
-            options.each do |option,value|
-              conf_data << "#{option}=#{value}`n"
-            end
-            conf_data << "`n"
-          end
-          on host, powershell("\$text = \\\"#{conf_data}\\\"; Set-Content -path '#{puppet_conf}' -value \$text")
-        else
-          puppet_conf = host.puppet['config']
-          conf_data = ''
-          opts.each do |section,options|
-            conf_data << "[#{section}]\n"
-            options.each do |option,value|
-              conf_data << "#{option}=#{value}\n"
-            end
-            conf_data << "\n"
-          end
-          on host, "echo \"#{conf_data}\" > #{puppet_conf}"
-        end
-      end
-
-      # Installs Puppet and dependencies using rpm
-      #
-      # @param [Host] host The host to install packages on
-      # @param [Hash{Symbol=>String}] opts An options hash
-      # @option opts [String] :version The version of Puppet to install, if nil installs latest version
-      # @option opts [String] :facter_version The version of Facter to install, if nil installs latest version
-      # @option opts [String] :hiera_version The version of Hiera to install, if nil installs latest version
-      # @option opts [String] :default_action What to do if we don't know how to install native packages on host.
-      #                                       Valid value is 'gem_install' or nil. If nil raises an exception when
-      #                                       on an unsupported platform. When 'gem_install' attempts to install
-      #                                       Puppet via gem.
-      # @option opts [String] :release The major release of the OS
-      # @option opts [String] :family The OS family (one of 'el' or 'fedora')
-      #
-      # @return nil
-      # @api private
-      def install_puppet_from_rpm( host, opts )
-        release_package_string = "http://yum.puppetlabs.com/puppetlabs-release-#{opts[:family]}-#{opts[:release]}.noarch.rpm"
-
-        on host, "rpm -q --quiet puppetlabs-release || rpm -ivh #{release_package_string}"
-
-        if opts[:facter_version]
-          on host, "yum install -y facter-#{opts[:facter_version]}"
-        end
-
-        if opts[:hiera_version]
-          on host, "yum install -y hiera-#{opts[:hiera_version]}"
-        end
-
-        puppet_pkg = opts[:version] ? "puppet-#{opts[:version]}" : 'puppet'
-        on host, "yum install -y #{puppet_pkg}"
-      end
-
-      # Installs Puppet and dependencies from deb
-      #
-      # @param [Host] host The host to install packages on
-      # @param [Hash{Symbol=>String}] opts An options hash
-      # @option opts [String] :version The version of Puppet to install, if nil installs latest version
-      # @option opts [String] :facter_version The version of Facter to install, if nil installs latest version
-      # @option opts [String] :hiera_version The version of Hiera to install, if nil installs latest version
-      #
-      # @return nil
-      # @api private
-      def install_puppet_from_deb( host, opts )
-        if ! host.check_for_package 'lsb-release'
-          host.install_package('lsb-release')
-        end
-
-        if ! host.check_for_command 'curl'
-          on host, 'apt-get install -y curl'
-        end
-
-        on host, 'curl -O http://apt.puppetlabs.com/puppetlabs-release-$(lsb_release -c -s).deb'
-        on host, 'dpkg -i puppetlabs-release-$(lsb_release -c -s).deb'
-        on host, 'apt-get update'
-
-        if opts[:facter_version]
-          on host, "apt-get install -y facter=#{opts[:facter_version]}-1puppetlabs1"
-        end
-
-        if opts[:hiera_version]
-          on host, "apt-get install -y hiera=#{opts[:hiera_version]}-1puppetlabs1"
-        end
-
-        if opts[:version]
-          on host, "apt-get install -y puppet-common=#{opts[:version]}-1puppetlabs1"
-          on host, "apt-get install -y puppet=#{opts[:version]}-1puppetlabs1"
-        else
-          on host, 'apt-get install -y puppet'
-        end
-      end
-
-      # Installs Puppet and dependencies from msi
-      #
-      # @param [Host] host The host to install packages on
-      # @param [Hash{Symbol=>String}] opts An options hash
-      # @option opts [String] :version The version of Puppet to install, required
-      # @option opts [String] :win_download_url The url to download puppet from
-      def install_puppet_from_msi( host, opts )
-        #only install 64bit builds if
-        # - we are on puppet version 3.7+
-        # - we do not have install_32 set on host
-        # - we do not have install_32 set globally
-        version = opts[:version]
-        if !(version_is_less(version, '3.7')) and host.is_x86_64? and not host['install_32'] and not opts['install_32']
-          host['dist'] = "puppet-#{version}-x64"
-        else
-          host['dist'] = "puppet-#{version}"
-        end
-        link = "#{opts[:win_download_url]}/#{host['dist']}.msi"
-        if not link_exists?( link )
-          raise "Puppet #{version} at #{link} does not exist!"
-        end
-
-        if host.is_cygwin?
-          dest = "#{host['dist']}.msi"
-          on host, "curl -O #{link}"
-
-          #Because the msi installer doesn't add Puppet to the environment path
-          #Add both potential paths for simplicity
-          #NOTE - this is unnecessary if the host has been correctly identified as 'foss' during set up
-          puppetbin_path = "\"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/bin\":\"/cygdrive/c/Program Files/Puppet Labs/Puppet/bin\""
-          on host, %Q{ echo 'export PATH=$PATH:#{puppetbin_path}' > /etc/bash.bashrc }
-        else
-          dest = "C:\\Windows\\Temp\\#{host['dist']}.msi"
-
-          on host, "set PATH=\"%PATH%;#{host['puppetbindir']}\""
-          on host, "setx PATH \"%PATH%;#{host['puppetbindir']}\""
-
-          on host, powershell("$webclient = New-Object System.Net.WebClient;  $webclient.DownloadFile('#{link}','#{dest}')")
-
-          on host, "if not exist #{host['distmoduledir']} (md #{host['distmoduledir']})"
-        end
-
-        on host, "cmd /C 'start /w msiexec.exe /qn /i #{dest}'"
-      end
-
-      # Installs Puppet and dependencies from dmg
-      #
-      # @param [Host] host The host to install packages on
-      # @param [Hash{Symbol=>String}] opts An options hash
-      # @option opts [String] :version The version of Puppet to install, required
-      # @option opts [String] :facter_version The version of Facter to install, required
-      # @option opts [String] :hiera_version The version of Hiera to install, required
-      # @option opts [String] :mac_download_url Url to download msi pattern of %url%/puppet-%version%.msi
-      #
-      # @return nil
-      # @api private
-      def install_puppet_from_dmg( host, opts )
-
-        puppet_ver = opts[:version]
-        facter_ver = opts[:facter_version]
-        hiera_ver = opts[:hiera_version]
-
-        if [puppet_ver, facter_ver, hiera_ver].include?(nil)
-          raise "You need to specify versions for OSX host\n eg. install_puppet({:version => '3.6.2',:facter_version => '2.1.0',:hiera_version  => '1.3.4',})"
-        end
-
-        on host, "curl -O #{opts[:mac_download_url]}/puppet-#{puppet_ver}.dmg"
-        on host, "curl -O #{opts[:mac_download_url]}/facter-#{facter_ver}.dmg"
-        on host, "curl -O #{opts[:mac_download_url]}/hiera-#{hiera_ver}.dmg"
-
-        on host, "hdiutil attach puppet-#{puppet_ver}.dmg"
-        on host, "hdiutil attach facter-#{facter_ver}.dmg"
-        on host, "hdiutil attach hiera-#{hiera_ver}.dmg"
-
-        on host, "installer -pkg /Volumes/puppet-#{puppet_ver}/puppet-#{puppet_ver}.pkg -target /"
-        on host, "installer -pkg /Volumes/facter-#{facter_ver}/facter-#{facter_ver}.pkg -target /"
-        on host, "installer -pkg /Volumes/hiera-#{hiera_ver}/hiera-#{hiera_ver}.pkg -target /"
-      end
-
-      # Installs Puppet and dependencies from gem
-      #
-      # @param [Host] host The host to install packages on
-      # @param [Hash{Symbol=>String}] opts An options hash
-      # @option opts [String] :version The version of Puppet to install, if nil installs latest
-      # @option opts [String] :facter_version The version of Facter to install, if nil installs latest
-      # @option opts [String] :hiera_version The version of Hiera to install, if nil installs latest
-      #
-      # @return nil
-      # @raise [StandardError] if gem does not exist on target host
-      # @api private
-      def install_puppet_from_gem( host, opts )
-        # There are a lot of special things to do for Solaris and Solaris 10.
-        # This is easier than checking host['platform'] every time.
-        is_solaris10 = host['platform'] =~ /solaris-10/
-        is_solaris = host['platform'] =~ /solaris/
-
-        # Hosts may be provisioned with csw but pkgutil won't be in the
-        # PATH by default to avoid changing the behavior for Puppet's tests
-        if is_solaris10
-          on host, 'ln -s /opt/csw/bin/pkgutil /usr/bin/pkgutil'
-        end
-
-        # Solaris doesn't necessarily have this, but gem needs it
-        if is_solaris
-          on host, 'mkdir -p /var/lib'
-        end
-
-        unless host.check_for_command( 'gem' )
-          gempkg = case host['platform']
-                   when /solaris-11/                            then 'ruby-18'
-                   when /ubuntu-14/                             then 'ruby'
-                   when /solaris-10|ubuntu|debian|el-|cumulus/  then 'rubygems'
-                   else
-                     raise "install_puppet() called with default_action " +
-                           "'gem_install' but program `gem' is " +
-                           "not installed on #{host.name}"
-                   end
-
-          host.install_package gempkg
-        end
-
-        # Link 'gem' to /usr/bin instead of adding /opt/csw/bin to PATH.
-        if is_solaris10
-          on host, 'ln -s /opt/csw/bin/gem /usr/bin/gem'
-        end
-
-        if host['platform'] =~ /debian|ubuntu|solaris|cumulus/
-          gem_env = YAML.load( on( host, 'gem environment' ).stdout )
-          gem_paths_array = gem_env['RubyGems Environment'].find {|h| h['GEM PATHS'] != nil }['GEM PATHS']
-          path_with_gem = 'export PATH=' + gem_paths_array.join(':') + ':${PATH}'
-          on host, "echo '#{path_with_gem}' >> ~/.bashrc"
-        end
-
-        if opts[:facter_version]
-          on host, "gem install facter -v#{opts[:facter_version]} --no-ri --no-rdoc"
-        end
-
-        if opts[:hiera_version]
-          on host, "gem install hiera -v#{opts[:hiera_version]} --no-ri --no-rdoc"
-        end
-
-        ver_cmd = opts[:version] ? "-v#{opts[:version]}" : ''
-        on host, "gem install puppet #{ver_cmd} --no-ri --no-rdoc"
-
-        # Similar to the treatment of 'gem' above.
-        # This avoids adding /opt/csw/bin to PATH.
-        if is_solaris
-          gem_env = YAML.load( on( host, 'gem environment' ).stdout )
-          # This is the section we want - this has the dir where gem executables go.
-          env_sect = 'EXECUTABLE DIRECTORY'
-          # Get the directory where 'gem' installs executables.
-          # On Solaris 10 this is usually /opt/csw/bin
-          gem_exec_dir = gem_env['RubyGems Environment'].find {|h| h[env_sect] != nil }[env_sect]
-
-          on host, "ln -s #{gem_exec_dir}/hiera /usr/bin/hiera"
-          on host, "ln -s #{gem_exec_dir}/facter /usr/bin/facter"
-          on host, "ln -s #{gem_exec_dir}/puppet /usr/bin/puppet"
-        end
-      end
-
-
-      #Install PE based upon host configuration and options
-      # @example
-      #  install_pe
-      #
-      # @note Either pe_ver and pe_dir should be set in the ENV or each host should have pe_ver and pe_dir set individually.
-      #       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.
-      #
-      # @api dsl
-      def install_pe
-        #process the version files if necessary
-        hosts.each do |host|
-          host['pe_dir'] ||= options[:pe_dir]
-          if host['platform'] =~ /windows/
-            host['pe_ver'] = host['pe_ver'] || options['pe_ver'] ||
-              Beaker::Options::PEVersionScraper.load_pe_version(host[:pe_dir] || options[:pe_dir], options[:pe_version_file_win])
-          else
-            host['pe_ver'] = host['pe_ver'] || options['pe_ver'] ||
-              Beaker::Options::PEVersionScraper.load_pe_version(host[:pe_dir] || options[:pe_dir], options[:pe_version_file])
-          end
-        end
-        #send in the global options hash
-        do_install sorted_hosts, options
-      end
-
-      #Upgrade PE based upon host configuration and options
-      # @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.
-      #                      This is ignored if a pe_upgrade_ver and pe_upgrade_dir are specified
-      #                      in the host configuration file.
-      # @example
-      #  upgrade_pe("http://neptune.puppetlabs.lan/3.0/ci-ready/")
-      #
-      # @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.
-      # @api dsl
-      def upgrade_pe path=nil
-        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)
-          set_console_password = true
-        end
-        # get new version information
-        hosts.each do |host|
-          host['pe_dir'] = host['pe_upgrade_dir'] || path
-          if host['platform'] =~ /windows/
-            host['pe_ver'] = host['pe_upgrade_ver'] || options['pe_upgrade_ver'] ||
-              Options::PEVersionScraper.load_pe_version(host['pe_dir'], options[:pe_version_file_win])
-          else
-            host['pe_ver'] = host['pe_upgrade_ver'] || options['pe_upgrade_ver'] ||
-              Options::PEVersionScraper.load_pe_version(host['pe_dir'], options[:pe_version_file])
-          end
-          if version_is_less(host['pe_ver'], '3.0')
-            host['pe_installer'] ||= 'puppet-enterprise-upgrader'
-          end
-        end
-        # send in the global options hash
-        do_install(sorted_hosts, options.merge({:type => :upgrade, :set_console_password => set_console_password}))
-        options['upgrade'] = true
-      end
-
-      # Install official puppetlabs release repository configuration on host.
-      #
-      # @param [Host] host An object implementing {Beaker::Hosts}'s
-      #                    interface.
-      #
-      # @note This method only works on redhat-like and debian-like hosts.
-      #
-      def install_puppetlabs_release_repo ( host )
-        variant, version, arch, codename = host['platform'].to_array
-
-        case variant
-        when /^(fedora|el|centos)$/
-          variant = (($1 == 'centos') ? 'el' : $1)
-
-          rpm = options[:release_yum_repo_url] +
-            "/puppetlabs-release-%s-%s.noarch.rpm" % [variant, version]
-
-          on host, "rpm -ivh #{rpm}"
-
-        when /^(debian|ubuntu|cumulus)$/
-          deb = URI.join(options[:release_apt_repo_url],  "puppetlabs-release-%s.deb" % codename)
-
-          on host, "wget -O /tmp/puppet.deb #{deb}"
-          on host, "dpkg -i --force-all /tmp/puppet.deb"
-          on host, "apt-get update"
-        else
-          raise "No repository installation step for #{variant} yet..."
-        end
-      end
-
-      # Install development repository on the given host. This method pushes all
-      # repository information including package files for the specified
-      # package_name to the host and modifies the repository configuration file
-      # to point at the new repository. This is particularly useful for
-      # installing development packages on hosts that can't access the builds
-      # server.
-      #
-      # @param [Host] host An object implementing {Beaker::Hosts}'s
-      #                    interface.
-      # @param [String] package_name The name of the package whose repository is
-      #                              being installed.
-      # @param [String] build_version A string identifying the output of a
-      #                               packaging job for use in looking up
-      #                               repository directory information
-      # @param [String] repo_configs_dir A local directory where repository files will be
-      #                                  stored as an intermediate step before
-      #                                  pushing them to the given host.
-      #
-      # @note This method only works on redhat-like and debian-like hosts.
-      #
-      def install_puppetlabs_dev_repo ( host, package_name, build_version,
-                                repo_configs_dir = 'tmp/repo_configs' )
-        variant, version, arch, codename = host['platform'].to_array
-        platform_configs_dir = File.join(repo_configs_dir, variant)
-
-        # some of the uses of dev_builds_url below can't include protocol info,
-        # pluse this opens up possibility of switching the behavior on provided
-        # url type
-        _, protocol, hostname = options[:dev_builds_url].partition /.*:\/\//
-        dev_builds_url = protocol + hostname
-
-        on host, "mkdir -p /root/#{package_name}"
-
-        case variant
-        when /^(fedora|el|centos)$/
-          variant = (($1 == 'centos') ? 'el' : $1)
-          fedora_prefix = ((variant == 'fedora') ? 'f' : '')
-
-          if host.is_pe?
-            pattern = "pl-%s-%s-repos-pe-%s-%s%s-%s.repo"
-          else
-            pattern = "pl-%s-%s-%s-%s%s-%s.repo"
-          end
-
-          repo_filename = pattern % [
-            package_name,
-            build_version,
-            variant,
-            fedora_prefix,
-            version,
-            arch
-          ]
-
-          repo = fetch_http_file( "%s/%s/%s/repo_configs/rpm/" %
-                       [ dev_builds_url, package_name, build_version ],
-                        repo_filename,
-                        platform_configs_dir)
-
-          link = "%s/%s/%s/repos/%s/%s%s/products/%s/" %
-            [ dev_builds_url, package_name, build_version, variant,
-              fedora_prefix, version, arch ]
-
-          if not link_exists?( link )
-            link = "%s/%s/%s/repos/%s/%s%s/devel/%s/" %
-              [ dev_builds_url, package_name, build_version, variant,
-                fedora_prefix, version, arch ]
-          end
-
-          if not link_exists?( link )
-            raise "Unable to reach a repo directory at #{link}"
-          end
-
-          repo_dir = fetch_http_dir( link, platform_configs_dir )
-
-          config_dir = '/etc/yum.repos.d/'
-          scp_to host, repo, config_dir
-          scp_to host, repo_dir, "/root/#{package_name}"
-
-          search = "baseurl\\s*=\\s*http:\\/\\/#{hostname}.*$"
-          replace = "baseurl=file:\\/\\/\\/root\\/#{package_name}\\/#{arch}"
-          sed_command = "sed -i 's/#{search}/#{replace}/'"
-          find_and_sed = "find #{config_dir} -name \"*.repo\" -exec #{sed_command} {} \\;"
-
-          on host, find_and_sed
-
-        when /^(debian|ubuntu|cumulus)$/
-          list = fetch_http_file( "%s/%s/%s/repo_configs/deb/" %
-                         [ dev_builds_url, package_name, build_version ],
-                        "pl-%s-%s-%s.list" %
-                         [ package_name, build_version, codename ],
-                        platform_configs_dir )
-
-          repo_dir = fetch_http_dir( "%s/%s/%s/repos/apt/%s" %
-                                      [ dev_builds_url, package_name,
-                                        build_version, codename ],
-                                       platform_configs_dir )
-
-          config_dir = '/etc/apt/sources.list.d'
-          scp_to host, list, config_dir
-          scp_to host, repo_dir, "/root/#{package_name}"
-
-          search = "deb\\s\\+http:\\/\\/#{hostname}.*$"
-          replace = "deb file:\\/\\/\\/root\\/#{package_name}\\/#{codename} #{codename} main"
-          sed_command = "sed -i 's/#{search}/#{replace}/'"
-          find_and_sed = "find #{config_dir} -name \"*.list\" -exec #{sed_command} {} \\;"
-
-          on host, find_and_sed
-          on host, "apt-get update"
-
-        else
-          raise "No repository installation step for #{variant} yet..."
-        end
-      end
-
-      # Installs packages from the local development repository on the given host
-      #
-      # @param [Host] host An object implementing {Beaker::Hosts}'s
-      #                    interface.
-      # @param [Regexp] package_name The name of the package whose repository is
-      #                              being installed.
-      #
-      # @note This method only works on redhat-like and debian-like hosts.
-      # @note This method is paired to be run directly after {#install_puppetlabs_dev_repo}
-      #
-      def install_packages_from_local_dev_repo( host, package_name )
-        if host['platform'] =~ /debian|ubuntu|cumulus/
-          find_filename = '*.deb'
-          find_command  = 'dpkg -i'
-        elsif host['platform'] =~ /fedora|el|centos/
-          find_filename = '*.rpm'
-          find_command  = 'rpm -ivh'
-        else
-          raise "No repository installation step for #{host['platform']} yet..."
-        end
-        find_command = "find /root/#{package_name} -type f -name '#{find_filename}' -exec #{find_command} {} \\;"
-        on host, find_command
-      end
-
-      # Install development repo of the puppet-agent on the given host
-      #
-      # @param [Host] host An object implementing {Beaker::Hosts}'s interface
-      # @param [Hash{Symbol=>String}] opts An options hash
-      # @option opts [String] :version The version of puppet-agent to install
-      # @option opts [String] :copy_base_local Directory where puppet-agent artifact
-      #                       will be stored locally
-      #                       (default: 'tmp/repo_configs')
-      # @option opts [String] :copy_dir_external Directory where puppet-agent
-      #                       artifact will be pushed to on the external machine
-      #                       (default: '/root')
-      # @return nil
-      def install_puppetagent_dev_repo( host, opts )
-        opts[:copy_base_local]    ||= File.join('tmp', 'repo_configs')
-        opts[:copy_dir_external]  ||= File.join('/', 'root')
-        variant, version, arch, codename = host['platform'].to_array
-        release_path = "#{options[:dev_builds_url]}/puppet-agent/#{opts[:version]}/artifacts/"
-        copy_dir_local = File.join(opts[:copy_base_local], variant)
-        onhost_copy_base = opts[:copy_dir_external]
-
-        case variant
-        when /^(fedora|el|centos)$/
-          release_path << "el/#{version}/products/#{arch}"
-          release_file = "puppet-agent-#{opts[:version]}-1.#{arch}.rpm"
-        when /^(debian|ubuntu|cumulus)$/
-          release_path << "deb/#{codename}"
-          release_file = "puppet-agent_#{opts[:version]}-1_#{arch}.deb"
-        when /^windows$/
-          release_path << 'windows'
-          onhost_copy_base = '`cygpath -smF 35`/'
-          arch_suffix = arch =~ /64/ ? '64' : '86'
-          release_file = "puppet-agent-x#{arch_suffix}.msi"
-        else
-          raise "No repository installation step for #{variant} yet..."
-        end
-
-        onhost_copied_file = File.join(onhost_copy_base, release_file)
-        fetch_http_file( release_path, release_file, copy_dir_local)
-        scp_to host, File.join(copy_dir_local, release_file), onhost_copy_base
-
-        case variant
-        when /^(fedora|el|centos)$/
-          on host, "rpm -ivh #{onhost_copied_file}"
-        when /^(debian|ubuntu|cumulus)$/
-          on host, "dpkg -i --force-all #{onhost_copied_file}"
-          on host, "apt-get update"
-        when /^windows$/
-          result = on host, "echo #{onhost_copied_file}"
-          onhost_copied_file = result.raw_output.chomp
-          on host, Command.new("start /w #{onhost_copied_file}", [], { :cmdexe => true })
-        end
-      end
-
-      #Install Higgs up till the point where you need to continue installation in a web browser, defaults to execution
-      #on the master node.
-      #@param [Host] higgs_host The host to install Higgs on (supported on linux platform only)
-      # @example
-      #  install_higgs
-      #
-      # @note Either pe_ver and pe_dir should be set in the ENV or each host should have pe_ver and pe_dir set individually.
-      #       Install file names are assumed to be of the format puppet-enterprise-VERSION-PLATFORM.(tar)|(tar.gz).
-      #
-      # @api dsl
-      def install_higgs( higgs_host = master )
-        #process the version files if necessary
-        master['pe_dir'] ||= options[:pe_dir]
-        master['pe_ver'] = master['pe_ver'] || options['pe_ver'] ||
-          Beaker::Options::PEVersionScraper.load_pe_version(master[:pe_dir] || options[:pe_dir], options[:pe_version_file])
-        if higgs_host['platform'] =~ /osx|windows/
-          raise "Attempting higgs installation on host #{higgs_host.name} with unsupported platform #{higgs_host['platform']}"
-        end
-        #send in the global options hash
-        do_higgs_install higgs_host, options
-      end
-
-      # Install the desired module on all hosts using either the PMT or a
-      #   staging forge
-      #
-      # @see install_dev_puppet_module
-      def install_dev_puppet_module_on( host, opts )
-        if options[:forge_host]
-          with_forge_stubbed_on( host ) do
-            install_puppet_module_via_pmt_on( host, opts )
-          end
-        else
-          copy_module_to( host, opts )
-        end
-      end
-      alias :puppet_module_install_on :install_dev_puppet_module_on
-
-      # Install the desired module on all hosts using either the PMT or a
-      #   staging forge
-      #
-      # Passes options through to either `install_puppet_module_via_pmt_on`
-      #   or `copy_module_to`
-      #
-      # @param opts [Hash]
-      #
-      # @example Installing a module from the local directory
-      #   install_dev_puppet_module( :source => './', :module_name => 'concat' )
-      #
-      # @example Installing a module from a staging forge
-      #   options[:forge_host] = 'my-forge-api.example.com'
-      #   install_dev_puppet_module( :source => './', :module_name => 'concat' )
-      #
-      # @see install_puppet_module_via_pmt
-      # @see copy_module_to
-      def install_dev_puppet_module( opts )
-        block_on( hosts ) {|h| install_dev_puppet_module_on( h, opts ) }
-      end
-      alias :puppet_module_install :install_dev_puppet_module
-
-      # Install the desired module with the PMT on a given host
-      #
-      # @param opts [Hash]
-      # @option opts [String] :module_name The short name of the module to be installed
-      # @option opts [String] :version The version of the module to be installed
-      def install_puppet_module_via_pmt_on( host, opts = {} )
-        block_on host do |h|
-          version_info = opts[:version] ? "-v #{opts[:version]}" : ""
-          if opts[:source]
-            author_name, module_name = parse_for_modulename( opts[:source] )
-            modname = "#{author_name}-#{module_name}"
-          else
-            modname = opts[:module_name]
-          end
-
-          puppet_opts = {}
-          if host[:default_module_install_opts].respond_to? :merge
-            puppet_opts = host[:default_module_install_opts].merge( puppet_opts )
-          end
-
-          on h, puppet("module install #{modname} #{version_info}", puppet_opts)
-        end
-      end
-
-      # Install the desired module with the PMT on all known hosts
-      # @see #install_puppet_module_via_pmt_on
-      def install_puppet_module_via_pmt( opts = {} )
-        install_puppet_module_via_pmt_on(hosts, opts)
-      end
-
-      # Install local module for acceptance testing
-      # should be used as a presuite to ensure local module is copied to the hosts you want, particularly masters
-      # @api dsl
-      # @param [Host, Array<Host>, String, Symbol] one_or_more_hosts
-      #                   One or more hosts to act upon,
-      #                   or a role (String or Symbol) that identifies one or more hosts.
-      # @option opts [String] :source ('./')
-      #                   The current directory where the module sits, otherwise will try
-      #                         and walk the tree to figure out
-      # @option opts [String] :module_name (nil)
-      #                   Name which the module should be installed under, please do not include author,
-      #                     if none is provided it will attempt to parse the metadata.json and then the Modulefile to determine
-      #                     the name of the module
-      # @option opts [String] :target_module_path (host['distmoduledir']/modules)
-      #                   Location where the module should be installed, will default
-      #                    to host['distmoduledir']/modules
-      # @option opts [Array] :ignore_list
-      # @option opts [String] :protocol
-      #                   Name of the underlying transfer method. Valid options are 'scp' or 'rsync'.
-      # @raise [ArgumentError] if not host is provided or module_name is not provided and can not be found in Modulefile
-      #
-      def copy_module_to(one_or_more_hosts, opts = {})
-        block_on one_or_more_hosts do |host|
-          opts = {:source => './',
-                  :target_module_path => host['distmoduledir'],
-                  :ignore_list => PUPPET_MODULE_INSTALL_IGNORE}.merge(opts)
-          ignore_list = build_ignore_list(opts)
-          target_module_dir = on( host, "echo #{opts[:target_module_path]}" ).stdout.chomp
-          source_path = File.expand_path( opts[:source] )
-          source_dir = File.dirname(source_path)
-          source_name = File.basename(source_path)
-          if opts.has_key?(:module_name)
-            module_name = opts[:module_name]
-          else
-            _, module_name = parse_for_modulename( source_path )
-          end
-
-          opts[:protocol] ||= 'scp'
-          case opts[:protocol]
-            when 'scp'
-              #move to the host
-              scp_to host, source_path, target_module_dir, {:ignore => ignore_list}
-              #rename to the selected module name, if not correct
-              cur_path = File.join(target_module_dir, source_name)
-              new_path = File.join(target_module_dir, module_name)
-              if cur_path != new_path
-                # NOTE: this will need to be updated to handle powershell only windows SUTs
-                on host, "mv #{cur_path} #{new_path}"
-              end
-            when 'rsync'
-              rsync_to host, source, File.join(target_module_dir, module_name), {:ignore => ignore_list}
-            else
-              logger.debug "Unsupported transfer protocol, returning nil"
-              nil
-          end
-        end
-      end
-      alias :copy_root_module_to :copy_module_to
-
-      # Install a package on a host
-      #
-      # @param [Host] host             A host object
-      # @param [String] package_name   Name of the package to install
-      #
-      # @return [Result]   An object representing the outcome of *install command*.
-      def install_package host, package_name, package_version = nil
-        host.install_package package_name, '', package_version
-      end
-
-      # Check to see if a package is installed on a remote host
-      #
-      # @param [Host] host             A host object
-      # @param [String] package_name   Name of the package to check for.
-      #
-      # @return [Boolean] true/false if the package is found
-      def check_for_package host, package_name
-        host.check_for_package package_name
-      end
-
-      # Upgrade a package on a host. The package must already be installed
-      #
-      # @param [Host] host             A host object
-      # @param [String] package_name   Name of the package to install
-      #
-      # @return [Result]   An object representing the outcome of *upgrade command*.
-      def upgrade_package host, package_name
-        host.upgrade_package package_name
-      end
-
-      #Recursive method for finding the module root
-      # Assumes that a Modulefile exists
-      # @param [String] possible_module_directory
-      #                   will look for Modulefile and if none found go up one level and try again until root is reached
-      #
-      # @return [String,nil]
-      def parse_for_moduleroot(possible_module_directory)
-        if File.exists?("#{possible_module_directory}/Modulefile") || File.exists?("#{possible_module_directory}/metadata.json")
-          possible_module_directory
-        elsif possible_module_directory === '/'
-          logger.error "At root, can't parse for another directory"
-          nil
-        else
-          logger.debug "No Modulefile or metadata.json found at #{possible_module_directory}, moving up"
-          parse_for_moduleroot File.expand_path(File.join(possible_module_directory,'..'))
-        end
-      end
-
-      #Parse root directory of a module for module name
-      # Searches for metadata.json and then if none found, Modulefile and parses for the Name attribute
-      # @param [String] root_module_dir
-      # @return [String] module name
-      def parse_for_modulename(root_module_dir)
-        author_name, module_name = nil, nil
-        if File.exists?("#{root_module_dir}/metadata.json")
-          logger.debug "Attempting to parse Modulename from metadata.json"
-          module_json = JSON.parse(File.read "#{root_module_dir}/metadata.json")
-          if(module_json.has_key?('name'))
-            author_name, module_name = get_module_name(module_json['name'])
-          end
-        end
-        if !module_name && File.exists?("#{root_module_dir}/Modulefile")
-          logger.debug "Attempting to parse Modulename from Modulefile"
-          if /^name\s+'?(\w+-\w+)'?\s*$/i.match(File.read("#{root_module_dir}/Modulefile"))
-            author_name, module_name = get_module_name(Regexp.last_match[1])
-          end
-        end
-        if !module_name && !author_name
-          logger.debug "Unable to determine name, returning null"
-        end
-        return author_name, module_name
-      end
-
-      #Parse modulename from the pattern 'Auther-ModuleName'
-      #
-      # @param [String] author_module_name <Author>-<ModuleName> pattern
-      #
-      # @return [String,nil]
-      #
-      def get_module_name(author_module_name)
-        split_name = split_author_modulename(author_module_name)
-        if split_name
-          return split_name[:author], split_name[:module]
-        end
-      end
-
-      #Split the Author-Name into a hash
-      # @param [String] author_module_attr
-      #
-      # @return [Hash<Symbol,String>,nil] :author and :module symbols will be returned
-      #
-      def split_author_modulename(author_module_attr)
-        result = /(\w+)-(\w+)/.match(author_module_attr)
-        if result
-          {:author => result[1], :module => result[2]}
-        else
-          nil
-        end
-      end
-
-      # Build an array list of files/directories to ignore when pushing to remote host
-      # Automatically adds '..' and '.' to array.  If not opts of :ignore list is provided
-      # it will use the static variable PUPPET_MODULE_INSTALL_IGNORE
-      #
-      # @param opts [Hash]
-      # @option opts [Array] :ignore_list A list of files/directories to ignore
-      def build_ignore_list(opts = {})
-        ignore_list = opts[:ignore_list] || PUPPET_MODULE_INSTALL_IGNORE
-        if !ignore_list.kind_of?(Array) || ignore_list.nil?
-          raise ArgumentError "Ignore list must be an Array"
-        end
-        ignore_list << '.' unless ignore_list.include? '.'
-        ignore_list << '..' unless ignore_list.include? '..'
-        ignore_list
-      end
+      include DSL::InstallUtils::PEUtils
+      include DSL::InstallUtils::PuppetUtils
+      include DSL::InstallUtils::ModuleUtils
+      include DSL::InstallUtils::EZBakeUtils
     end
   end
 end