beaker-puppet 1.29.0 → 2.0.0

data/lib/beaker-puppet/install_utils/module_utils.rb

@@ -12,24 +12,23 @@ module Beaker
       #   {Beaker::Host}'s interface to act upon
       # * the module {Beaker::DSL::Wrappers} the provides convenience methods for {Beaker::DSL::Command} creation
       module ModuleUtils
-
         # 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', '/.svn', '/junit', '/pkg', '/example', '/tmp']
+                                        '/bundle', '/spec', '/tests', '/log', '/.svn', '/junit', '/pkg', '/example', '/tmp',]
 
         # 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 )
+        def install_dev_puppet_module_on(host, opts)
           if options[:forge_host]
-            install_puppet_module_via_pmt_on( host, opts )
+            install_puppet_module_via_pmt_on(host, opts)
           else
-            copy_module_to( host, opts )
+            copy_module_to(host, opts)
           end
         end
-        alias :puppet_module_install_on :install_dev_puppet_module_on
+        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
@@ -48,21 +47,21 @@ module Beaker
         #
         # @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 ) }
+        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
+        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 = {} )
+        def install_puppet_module_via_pmt_on(host, opts = {})
           block_on host do |h|
-            version_info = opts[:version] ? "-v #{opts[:version]}" : ""
+            version_info = opts[:version] ? "-v #{opts[:version]}" : ''
             if opts[:source]
-              author_name, module_name = parse_for_modulename( opts[:source] )
+              author_name, module_name = parse_for_modulename(opts[:source])
               modname = "#{author_name}-#{module_name}"
             else
               modname = opts[:module_name]
@@ -70,15 +69,15 @@ module Beaker
 
             puppet_opts = {}
             if host[:default_module_install_opts].respond_to? :merge
-              puppet_opts = host[:default_module_install_opts].merge( puppet_opts )
+              puppet_opts = host[:default_module_install_opts].merge(puppet_opts)
             end
 
             if options[:forge_host]
-              if options[:forge_host] =~ /^http/
-                puppet_opts[:module_repository] = options[:forge_host]
-              else
-                puppet_opts[:module_repository] = "https://#{options[:forge_host]}"
-              end
+              puppet_opts[:module_repository] = if options[:forge_host] =~ /^http/
+                                                  options[:forge_host]
+                                                else
+                                                  "https://#{options[:forge_host]}"
+                                                end
             end
 
             on h, puppet("module install #{modname} #{version_info}", puppet_opts)
@@ -87,7 +86,7 @@ module Beaker
 
         # 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 = {} )
+        def install_puppet_module_via_pmt(opts = {})
           install_puppet_module_via_pmt_on(hosts, opts)
         end
 
@@ -113,103 +112,97 @@ module Beaker
         #
         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)
+            opts = { source: './',
+                     target_module_path: host['distmoduledir'],
+                     ignore_list: PUPPET_MODULE_INSTALL_IGNORE, }.merge(opts)
 
             ignore_list = build_ignore_list(opts)
             target_module_dir = get_target_module_path(host, opts[:target_module_path])
-            source_path = File.expand_path( opts[:source] )
+            source_path = File.expand_path(opts[:source])
             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 )
+              _, module_name = parse_for_modulename(source_path)
             end
 
             target_path = File.join(target_module_dir, module_name)
-            if host.is_powershell? #make sure our slashes are correct
-              target_path = target_path.gsub(/\//,'\\')
-            end
+            target_path = target_path.gsub(%r{/}, '\\') if host.is_powershell? # make sure our slashes are correct
 
             opts[:protocol] ||= 'scp'
             case opts[:protocol]
             when 'scp'
-              #move to the host
+              # move to the host
               logger.debug "Using scp to transfer #{source_path} to #{target_path}"
-              scp_to host, source_path, target_module_dir, {:ignore => ignore_list}
+              scp_to host, source_path, target_module_dir, { ignore: ignore_list }
 
-              #rename to the selected module name, if not correct
+              # rename to the selected module name, if not correct
               cur_path = File.join(target_module_dir, source_name)
-              if host.is_powershell? #make sure our slashes are correct
-                cur_path = cur_path.gsub(/\//,'\\')
-              end
+              cur_path = cur_path.gsub(%r{/}, '\\') if host.is_powershell? # make sure our slashes are correct
               host.mv cur_path, target_path unless cur_path == target_path
             when 'rsync'
               logger.debug "Using rsync to transfer #{source_path} to #{target_path}"
-              rsync_to host, source_path, target_path, {:ignore => ignore_list}
+              rsync_to host, source_path, target_path, { ignore: ignore_list }
             else
-              logger.debug "Unsupported transfer protocol, returning nil"
+              logger.debug 'Unsupported transfer protocol, returning nil'
               nil
             end
           end
         end
-        alias :copy_root_module_to :copy_module_to
+        alias copy_root_module_to copy_module_to
 
-        def get_target_module_path(host, path=nil)
+        def get_target_module_path(host, path = nil)
           if path
-            on( host, "echo #{path}" ).stdout.chomp
+            on(host, "echo #{path}").stdout.chomp
           else
             path = host.puppet['basemodulepath'].split(':').first
             raise ArgumentError, 'Unable to find target module path to copy to' unless path
+
             path
           end
         end
 
-        #Recursive method for finding the module root
+        # 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")
+          if File.exist?("#{possible_module_directory}/Modulefile") || File.exist?("#{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,'..'))
+            parse_for_moduleroot File.expand_path(File.join(possible_module_directory, '..'))
           end
         end
 
-        #Parse root directory of a module for module name
+        # 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
+          author_name = nil
+          module_name = nil
+          if File.exist?("#{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"))
+            author_name, module_name = get_module_name(module_json['name']) if module_json.has_key?('name')
           end
-          if !module_name && File.exists?("#{root_module_dir}/Modulefile")
-            logger.debug "Attempting to parse Modulename from Modulefile"
+          if !module_name && File.exist?("#{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
+          logger.debug 'Unable to determine name, returning null' if !module_name && !author_name
+          [author_name, module_name]
         end
 
-        #Parse modulename from the pattern 'Auther-ModuleName'
+        # Parse modulename from the pattern 'Auther-ModuleName'
         #
         # @param [String] author_module_name <Author>-<ModuleName> pattern
         #
@@ -217,23 +210,21 @@ module Beaker
         #
         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
+          return unless split_name
+
+          [split_name[:author], split_name[:module]]
         end
 
-        #Split the Author-Name into a hash
+        # 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
+          return unless result
+
+          { author: result[1], module: result[2] }
         end
 
         # Build an array list of files/directories to ignore when pushing to remote host
@@ -244,16 +235,13 @@ module Beaker
         # @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
+          raise ArgumentError 'Ignore list must be an Array' if !ignore_list.is_a?(Array) || ignore_list.nil?
+
           ignore_list << '.' unless ignore_list.include? '.'
           ignore_list << '..' unless ignore_list.include? '..'
           ignore_list
         end
-
       end
     end
-
   end
 end

data/lib/beaker-puppet/install_utils/puppet5.rb

@@ -16,15 +16,13 @@ module Beaker
         #
         # @return [Hash{String=>String}] build json parsed into a ruby hash
         def fetch_build_details(sha_yaml_url)
-          dst_folder          = Dir.mktmpdir
+          dst_folder = Dir.mktmpdir
 
           at_exit do
-            if $!.nil? || ($!.is_a?(SystemExit) && $!.success?)
-              if File.directory?(dst_folder)
-                require 'fileutils'
+            if ($!.nil? || ($!.is_a?(SystemExit) && $!.success?)) && File.directory?(dst_folder)
+              require 'fileutils'
 
-                FileUtils.rm_rf(dst_folder)
-              end
+              FileUtils.rm_rf(dst_folder)
             end
           end
 
@@ -34,7 +32,7 @@ module Beaker
           sha_yaml_file_local_path = fetch_http_file(
             sha_yaml_folder_url,
             sha_yaml_filename,
-            dst_folder
+            dst_folder,
           )
 
           file_hash = YAML.load_file(sha_yaml_file_local_path)
@@ -52,7 +50,7 @@ module Beaker
             fail_test(message)
           end
 
-          return sha_yaml_folder_url, file_hash[:platform_data]
+          [sha_yaml_folder_url, file_hash[:platform_data]]
         end
 
         # Get the host's packaging platform, based on beaker-hostgenerator's
@@ -66,7 +64,7 @@ module Beaker
         def host_packaging_platform(host)
           packaging_platform = host[:packaging_platform]
           if ENV['BEAKER_PACKAGING_PLATFORMS']
-            overrides = Hash[ENV['BEAKER_PACKAGING_PLATFORMS'].split(',').map { |e| e.split('=') }]
+            overrides = ENV['BEAKER_PACKAGING_PLATFORMS'].split(',').map { |e| e.split('=') }.to_h
             logger.debug("Found packaging platform overrides: #{overrides}")
             if overrides[host[:platform]]
               platform = overrides[host[:platform]]
@@ -91,23 +89,23 @@ module Beaker
             message = <<-EOF
               :packaging_platform not provided for host '#{host}', platform '#{host[:platform]}'
               :packaging_platform should be the platform-specific key from this list:
-                #{ build_details.keys }
+                #{build_details.keys}
             EOF
-            fail_test( message )
+            fail_test(message)
           end
 
-          logger.debug("Platforms available for this build:")
-          logger.debug("#{ build_details.keys }")
+          logger.debug('Platforms available for this build:')
+          logger.debug("#{build_details.keys}")
           logger.debug("PLATFORM SPECIFIC INFO for #{host} (packaging name '#{packaging_platform}'):")
           packaging_data = build_details[packaging_platform]
-          logger.debug("- #{ packaging_data }, isnil? #{ packaging_data.nil? }")
+          logger.debug("- #{packaging_data}, isnil? #{packaging_data.nil?}")
           if packaging_data.nil?
             message = <<-EOF
               :packaging_platform '#{packaging_platform}' for host '#{host}' not in build details
               :packaging_platform should be the platform-specific key from this list:
-                #{ build_details.keys }
+                #{build_details.keys}
             EOF
-            fail_test( message )
+            fail_test(message)
           end
 
           artifact_buildserver_path   = packaging_data[:artifact]
@@ -116,11 +114,11 @@ module Beaker
 
           artifact_url    = "#{build_url}/#{artifact_buildserver_path}"
           repoconfig_url  = "#{build_url}/#{repoconfig_buildserver_path}" unless repoconfig_buildserver_path.nil?
-          artifact_url_correct = link_exists?( artifact_url )
+          artifact_url_correct = link_exists?(artifact_url)
           logger.debug("- artifact url: '#{artifact_url}'. Exists? #{artifact_url_correct}")
-          fail_test('artifact url built incorrectly') if !artifact_url_correct
+          fail_test('artifact url built incorrectly') unless artifact_url_correct
 
-          return artifact_url, repoconfig_url
+          [artifact_url, repoconfig_url]
         end
 
         # install build artifact on the given host
@@ -131,12 +129,12 @@ module Beaker
         #
         # @return nil
         def install_artifact_on(host, artifact_url, project_name)
-          variant, version, _, _ = host[:platform].to_array
+          variant, version, = host[:platform].to_array
           case variant
           when 'eos'
             host.get_remote_file(artifact_url)
             onhost_package_file = File.basename(artifact_url)
-            # TODO Will be refactored into {Beaker::Host#install_local_package}
+            # TODO: Will be refactored into {Beaker::Host#install_local_package}
             #   immediately following this work. The release timing makes it
             #   necessary to have this here separately for a short while
             host.install_from_file(onhost_package_file)
@@ -166,14 +164,12 @@ module Beaker
             scp_to host, artifact_filename, onhost_package_dir
             onhost_package_file = "#{onhost_package_dir}/#{artifact_filename}"
 
-            # TODO Will be refactored into {Beaker::Host#install_local_package}
+            # TODO: Will be refactored into {Beaker::Host#install_local_package}
             #   immediately following this work. The release timing makes it
             #   necessary to have this here seperately for a short while
             # NOTE: the AIX 7.1 package will only install on 7.2 with
             # --ignoreos. This is a bug in package building on AIX 7.1's RPM
-            if version == "7.2"
-              aix_72_ignoreos_hack = "--ignoreos"
-            end
+            aix_72_ignoreos_hack = '--ignoreos' if version == '7.2'
             on host, "rpm -ivh #{aix_72_ignoreos_hack} #{onhost_package_file}"
           else
             host.install_package(artifact_url)
@@ -192,7 +188,7 @@ module Beaker
             return
           end
 
-          install_repo_configs_from_url( host, repoconfig_url )
+          install_repo_configs_from_url(host, repoconfig_url)
         end
 
         # Installs a specified puppet project on all hosts. Gets build information
@@ -208,26 +204,26 @@ module Beaker
         #
         # @return nil
         def install_from_build_data_url(project_name, sha_yaml_url, local_hosts = nil)
-          if !link_exists?( sha_yaml_url )
+          unless link_exists?(sha_yaml_url)
             message = <<-EOF
               Unable to locate a downloadable build of #{project_name} (tried #{sha_yaml_url})
             EOF
-            fail_test( message )
+            fail_test(message)
           end
 
-          base_url, build_details = fetch_build_details( sha_yaml_url )
+          base_url, build_details = fetch_build_details(sha_yaml_url)
 
           install_targets = local_hosts.nil? ? hosts : Array(local_hosts)
 
           install_targets.each do |host|
-            artifact_url, repoconfig_url = host_urls( host, build_details, base_url )
+            artifact_url, repoconfig_url = host_urls(host, build_details, base_url)
             if repoconfig_url.nil?
-              install_artifact_on( host, artifact_url, project_name )
+              install_artifact_on(host, artifact_url, project_name)
             else
-              install_repo_configs_on( host, repoconfig_url )
-              host.install_package( project_name )
+              install_repo_configs_on(host, repoconfig_url)
+              host.install_package(project_name)
             end
-            configure_type_defaults_on( host )
+            configure_type_defaults_on(host)
           end
         end
 
@@ -248,4 +244,3 @@ module Beaker
     end
   end
 end
-