ref_arch_setup 0.0.1 → 0.5.0

data/lib/ref_arch_setup/download_helper.rb

@@ -0,0 +1,399 @@
+# rubocop:disable Metrics/ClassLength
+require "oga"
+require "net/http"
+require "json"
+
+# General namespace for RAS
+module RefArchSetup
+  # Download helper methods
+  class DownloadHelper
+    # the 'Puppet Enterprise Version History' url
+    PE_VERSIONS_URL = "https://puppet.com/misc/version-history".freeze
+
+    # the base of the URL where prod PE tarballs are hosted
+    BASE_PROD_URL = "https://s3.amazonaws.com/pe-builds/released".freeze
+
+    # the minimum prod version supported by RAS
+    MIN_PROD_VERSION = "2018.1.0".freeze
+
+    # the supported platforms for PE installation using RAS
+    PE_PLATFORMS = %w[el-6-x86_64
+                      el-7-x86_64
+                      sles-12-x86_64
+                      ubuntu-16.04-amd64
+                      ubuntu-18.04-amd64].freeze
+
+    # Initializes the instance variables to the defaults
+    # or values specified by environment variables
+    #
+    # @author Bill Claytor
+    #
+    # @example:
+    # init
+    #
+    def self.init
+      @pe_versions_url = ENV["PE_VERSIONS_URL"] ? ENV["PE_VERSIONS_URL"] : PE_VERSIONS_URL
+      @base_prod_url = ENV["BASE_PROD_URL"] ? ENV["BASE_PROD_URL"] : BASE_PROD_URL
+      @min_prod_version = ENV["MIN_PROD_VERSION"] ? ENV["MIN_PROD_VERSION"] : MIN_PROD_VERSION
+      @pe_platforms = PE_PLATFORMS
+    end
+
+    # Builds the prod tarball URL for the specified or default version of PE
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] version The desired version of PE (default = "latest")
+    # @param [string] host The target host for this PE tarball (default = "localhost")
+    # @param [string] platform The target platform for this PE tarball
+    #
+    # *** Specifying the host will determine and validate the platform for the host
+    # *** Specifying the platform will ignore the host value and only perform the validation
+    #
+    # @return [string] the prod tarball URL
+    #
+    # @example:
+    # url = build_prod_tarball_url()
+    # url = build_prod_tarball_url("2018.1.4", "master.mydomain.net", "")
+    # url = build_prod_tarball_url("2018.1.4", "value_is_ignored", "sles-12-x86_64")
+    #
+    def self.build_prod_tarball_url(version = "latest", host = "localhost", platform = "default")
+      init
+      pe_version = handle_prod_version(version)
+      pe_platform = handle_platform(host, platform)
+      url = "#{@base_prod_url}/#{pe_version}/puppet-enterprise-#{pe_version}-#{pe_platform}.tar.gz"
+      puts "URL: #{url}"
+      return url
+    end
+
+    # Retrieves the latest production PE version or verifies a user-specified version
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] version The desired version of PE
+    #
+    # @raise [RuntimeError] If the specified version is not valid
+    #
+    # @return [string] The corresponding PE version
+    #
+    # @example:
+    #   version = handle_prod_version("latest")
+    #   version = handle_prod_version("2018.1.4")
+    #
+    def self.handle_prod_version(version)
+      if version == "latest"
+        pe_version = latest_prod_version
+        puts "The latest version is #{pe_version}"
+      else
+        success = ensure_valid_prod_version(version) && ensure_supported_prod_version(version)
+        raise "Invalid version: #{version}" unless success
+
+        pe_version = version
+        puts "Proceeding with specified version: #{pe_version}"
+      end
+
+      puts
+
+      return pe_version
+    end
+
+    # Retrieves the latest production version of PE from the 'Puppet Enterprise Version History'
+    #
+    # @author Bill Claytor
+    #
+    # @return [string] The latest production version of PE
+    #
+    # @example:
+    #   latest_version = latest_prod_version
+    #
+    def self.latest_prod_version
+      result = parse_prod_versions_url("//table/tbody/tr[1]/td[1]")
+      latest_version = result.text
+      return latest_version
+    end
+
+    # Determines whether the specified version is an actual production version of PE
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] version The specified version of PE
+    #
+    # @raise [RuntimeError] If the specified version is not found
+    #
+    # @return [true, false] Whether the specified version was found
+    #
+    # @example:
+    #   result = ensure_valid_prod_version("2018.1.4")
+    #
+    def self.ensure_valid_prod_version(version)
+      puts "Verifying specified PE version: #{version}"
+
+      result = parse_prod_versions_url("//table/tbody/tr/td[contains(., '#{version}')]")
+      found = result.text == version ? true : false
+
+      puts "Specified version #{version} was found" if found
+      raise "Specified version not found: #{version}" unless found
+
+      return found
+    end
+
+    # Determines whether the specified version is supported by RAS
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] version The specified version of PE
+    #
+    # @raise [RuntimeError] If the specified version is not supported
+    #
+    # @return [true, false] Whether the specified version is supported
+    #
+    # @example:
+    #   result = ensure_supported_prod_version("2018.1.4")
+    #
+    def self.ensure_supported_prod_version(version)
+      major_version = version.split(".")[0]
+      supported_version = @min_prod_version.split(".")[0]
+
+      supported = major_version >= supported_version ? true : false
+      puts "Specified version #{version} is supported by RAS" if supported
+      puts "The minimum supported version is #{@min_prod_version}" unless supported
+
+      raise "Specified version #{version} is not supported by RAS" unless supported
+
+      return supported
+    end
+
+    # Fetches the list of production PE versions from the 'Puppet Enterprise Version History'
+    # *note: this is no longer used but has been left as an example
+    # @author Bill Claytor
+    #
+    # @return [Oga::XML::NodeSet] The versions list
+    #
+    # @example:
+    #   versions = fetch_prod_versions
+    #
+    def self.fetch_prod_versions
+      versions = parse_prod_versions_url
+      puts "Versions:"
+
+      versions.each do |version|
+        version_text = version.text
+        puts version_text
+      end
+      puts
+
+      return versions
+    end
+
+    # Parses the 'Puppet Enterprise Version History'
+    # using the specified xpath and returns the result
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] xpath The xpath to use when parsing the version history
+    #
+    # @return [Oga::XML::NodeSet] The resulting Oga NodeSet
+    #
+    # @example:
+    #   versions = parse_prod_versions_url
+    #   latest_version = parse_prod_versions_url("//table/tbody/tr[1]/td[1]")
+    #   result = parse_prod_versions_url("//table/tbody/tr/td[contains(., '#{version}')]")
+    #
+    def self.parse_prod_versions_url(xpath = "//table/tbody/tr/td[1]")
+      puts "Checking Puppet Enterprise Version History: #{@pe_versions_url}"
+
+      uri = URI.parse(@pe_versions_url)
+      response = Net::HTTP.get_response(uri)
+      validate_response(response)
+
+      document = Oga.parse_html(response.body)
+      result = document.xpath(xpath)
+      return result
+    end
+
+    # Determines whether the response is valid
+    #
+    # @author Bill Claytor
+    #
+    # @param [Net::HTTPResponse] res The HTTP response to evaluate
+    # @param [Array] valid_response_codes The list of valid response codes
+    # @param [Array] invalid_response_bodies The list of invalid response bodies
+    #
+    # @raise [RuntimeError] If the response is not valid
+    #
+    # @return [true,false] Based on whether the response is valid
+    #
+    # @example
+    #   valid = validate_response(res)
+    #   valid = validate_response(res, ["200", "123"], ["", nil])
+    #
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def self.validate_response(res, valid_response_codes = ["200"],
+                               invalid_response_bodies = ["", nil])
+      is_valid_response = false
+
+      if res.nil?
+        puts "Invalid response:"
+        puts "nil"
+        puts
+      elsif !valid_response_codes.include?(res.code) ||
+            invalid_response_bodies.include?(res.body)
+        code = res.code.nil? ? "nil" : res.code
+        body = res.body.nil? ? "nil" : res.body
+
+        puts "Invalid response:"
+        puts "code: #{code}"
+        puts "body: #{body}"
+        puts
+      else
+        is_valid_response = true
+      end
+
+      raise "Invalid response" unless is_valid_response
+
+      return is_valid_response
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    # Handles the host and platform and determines the appropriate PE platform
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] host The target host for this PE tarball (default = "localhost")
+    # @param [string] platform The target platform for this PE tarball
+    #
+    # *** Specifying the host will determine and validate the platform for the host
+    # *** Specifying the platform will ignore the host value and only perform the validation
+    #
+    # @raise [RuntimeError] If the platform is not valid
+    #
+    # @return [string] The PE platform
+    #
+    # @example:
+    #   handle_platform("my_host", "default")
+    #   handle_platform("value_is_ignored", "sles-12-x86_64")
+    #
+    def self.handle_platform(host, platform)
+      if platform == "default"
+        puts "Default platform specified; determining platform for host: #{host}"
+        pe_platform = get_host_platform(host)
+      else
+        puts "Specified platform: #{platform}"
+        pe_platform = platform
+      end
+      raise "Invalid PE platform: #{pe_platform}" unless valid_platform?(pe_platform)
+      return pe_platform
+    end
+
+    # Handles the platform for the specified host using the host's facts
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] host The target host
+    #
+    # @raise [RuntimeError] If the facts status is 'failure'
+    # @raise [RuntimeError] If the platform can't be determined
+    #
+    # @return [string] The corresponding platform for the specified host
+    #
+    # @example:
+    #   platform = get_host_platform("localhost")
+    #
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def self.get_host_platform(host)
+      facts = retrieve_facts(host)
+
+      status = facts[0]["status"]
+      raise "Facts indicate that status for host #{host} is failure" if status == "failure"
+
+      os = facts[0]["result"]["os"]
+      os_name = os["name"]
+      os_family = os["family"]
+      platform_type = nil
+
+      case os_family
+      when "RedHat"
+        platform_type = "el"
+        platform_arch = "x86_64"
+        release = os["release"]["major"]
+      when "SLES"
+        platform_type = "sles"
+        platform_arch = "x86_64"
+        release = os["release"]["major"]
+      when "Debian"
+        if os_name == "Ubuntu"
+          platform_type = "ubuntu"
+          platform_arch = "amd64"
+          release = os["release"]["full"]
+        end
+      end
+
+      raise "Unable to determine platform for host: #{host}" unless platform_type
+      platform = "#{platform_type}-#{release}-#{platform_arch}"
+      puts "Host platform: #{platform}"
+
+      return platform
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # Retrieves the facts for the specified host(s) using the facts::retrieve plan
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] hosts The host(s) from which to retrieve facts
+    #
+    # @raise [JSON::ParserError] If the output from the bolt plan can't be parsed
+    # @raise [BoltCommandError] If the bolt command is not successful or the output is nil
+    #
+    # @return [Array<Hash] The retrieved facts
+    #
+    # @example:
+    #   facts = retrieve_facts("localhost")
+    #
+    def self.retrieve_facts(hosts)
+      plan = "facts::retrieve"
+      puts "Retrieving facts for hosts: #{hosts}"
+
+      output = BoltHelper.run_forge_plan_with_bolt(plan, nil, hosts)
+
+      begin
+        facts = JSON.parse(output)
+      rescue
+        puts "Unable to parse bolt output"
+        raise
+      end
+
+      return facts
+    end
+
+    # Determines whether the specified platform is a valid PE platform
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] platform The platform
+    #
+    # @return [true,false] Based on validity of the specified platform
+    #
+    # @example:
+    #   is_valid = valid_platform?("sles-12-x86_64")
+    #
+    # TODO: validate for a specified version?
+    #
+    def self.valid_platform?(platform)
+      valid = @pe_platforms.include?(platform) ? true : false
+      puts "Platform #{platform} is valid" if valid
+      puts "Platform #{platform} is not valid" unless valid
+      puts "Valid platforms are: #{@pe_platforms}" unless valid
+      return valid
+    end
+  end
+end

data/lib/ref_arch_setup/install.rb

@@ -1,10 +1,21 @@
+require "uri"
+require "open-uri"
+
 # General namespace for RAS
 module RefArchSetup
+  # A space to use as a default location to put files on target_host
+  TMP_WORK_DIR = "/tmp/ref_arch_setup".freeze
+  DOWNLOAD_PE_TARBALL_TASK = "ref_arch_setup::download_pe_tarball".freeze
+  INSTALL_PE_TASK = "ref_arch_setup::install_pe".freeze
+
   # Installation helper
   #
   # @author Randell Pelak
   #
   # @attr [string] target_master Host to install on
+  #
+  # TODO: review the value for ClassLength
+  # rubocop:disable Metrics/ClassLength
   class Install
     # Initialize class
     #
@@ -22,22 +33,422 @@ module RefArchSetup
     # @author Randell Pelak
     #
     # @param [string] pe_conf_path Path to pe.conf
-    # @param [string] pe_tarball_path Path to pe tarball
-    # @param [string] target_master Host to install on
+    # @param [string] pe_tarball Path or URL for the pe tarball
+    #
+    # @raise [RuntimeError] Unless either a pe_tarball or pe_version is specified
+    # @raise [RuntimeError] If a valid pe_tarball is not available
+    # @raise [RuntimeError] If a RAS working directory can not be created
+    # @raise [BoltCommandError] If the bolt command is not successful or the output is nil
+    #
+    # @return [true,false] Based on exit status of the bolt task
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
+    def bootstrap(pe_conf_path, pe_tarball, pe_version)
+      if specified_option?(pe_tarball)
+        puts "Proceeding with specified pe_tarball: #{pe_tarball}"
+        @pe_tarball = pe_tarball
+      else
+        options_error = "Either a pe_version or pe_tarball must be specified"
+        raise options_error unless specified_option?(pe_version)
+        puts "Proceeding with specified pe_version: #{pe_version}"
+        @pe_tarball = RefArchSetup::DownloadHelper.build_prod_tarball_url(pe_version,
+                                                                          @target_master)
+      end
+
+      raise "Unable to create RAS working directory" unless make_tmp_work_dir
+
+      conf_path_on_master = handle_pe_conf(pe_conf_path)
+      tarball_path_on_master = handle_pe_tarball(@pe_tarball)
+
+      params = {}
+      params["pe_conf_path"] = conf_path_on_master
+      params["pe_tarball_path"] = tarball_path_on_master
+
+      output = BoltHelper.run_task_with_bolt(INSTALL_PE_TASK, params, @target_master)
+      success = output.nil? ? false : true
+      return success
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    # Determines whether the option is 'specified' (not nil and not empty)
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] value The option value to evaluate
+    #
+    # @return [true, false] Based on the evaluation of the value
+    #
+    def specified_option?(value)
+      specified = value.nil? || value.empty? ? false : true
+      return specified
+    end
+
+    # Handles user inputted pe.conf or if nil assumes it is in the CWD
+    # Validates file exists (allows just a dir to be given if pe.conf is in it)
+    # TODO Ensure it is valid once we have a reader/validator class
+    # Move it to the target_master
+    #
+    # @author Randell Pelak
+    #
+    # @param [string] pe_conf_path Path to pe.conf file or dir
+    #
+    # @raise [RuntimeError] If a pe.conf file is not found
+    # @raise [RuntimeError] If the file is not uploaded successfully
+    #
+    # @return [string] The path to the pe.conf file on the target master
+    def handle_pe_conf(pe_conf_path)
+      conf_path_on_master = "#{TMP_WORK_DIR}/pe.conf"
+      if pe_conf_path.nil?
+        file_path = Dir.pwd + "/pe.conf"
+        raise("No pe.conf file found in current working directory") unless File.exist?(file_path)
+      else
+        file_path = handle_pe_conf_path(pe_conf_path)
+      end
+      success = upload_pe_conf(file_path)
+      raise "Unable to upload pe.conf file to #{@target_master}" unless success
+
+      return conf_path_on_master
+    end
+
+    # Handles user inputted pe.conf
+    # Validates file exists (allows just a dir to be given if pe.conf is in it)
+    # Also ensures the file is named pe.conf
+    #
+    # @author Randell Pelak
+    #
+    # @param [string] pe_conf_path Path to pe.conf file or dir
+    #
+    # @raise [RuntimeError] If a directory is specified and a pe.conf file is not found
+    # @raise [RuntimeError] If the specified file is not named pe.conf
+    # @raise [RuntimeError] If the specified file is not found
+    #
+    # @return [string] The path to the pe.conf file
+    def handle_pe_conf_path(pe_conf_path)
+      file_path = File.expand_path(pe_conf_path)
+      if File.directory?(file_path)
+        full_path = file_path + "/pe.conf"
+        raise("No pe.conf file found in directory: #{file_path}") unless File.exist?(full_path)
+        file_path = full_path
+      else
+        filename = File.basename(file_path)
+        raise("Specified file is not named pe.conf #{file_path}") unless filename.eql?("pe.conf")
+        raise("pe.conf file not found #{file_path}") unless File.exist?(file_path)
+      end
+
+      return file_path
+    end
+
+    # Determines whether the specified path is a valid URL
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] pe_tarball Path to PE tarball file
+    #
+    # @return [true,false] Based on whether the path is a valid URL
+    def valid_url?(pe_tarball)
+      valid = false
+      valid = true if pe_tarball =~ /\A#{URI.regexp(%w[http https])}\z/
+      return valid
+    end
+
+    # Parses the specified URL
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] url URL for the PE tarball file
+    #
+    # @raise [RuntimeError] If the specified URL can not be parsed
+    #
+    # @return [true] Based on the validity of the URL
+    def parse_url(url)
+      begin
+        @pe_tarball_uri = URI.parse(url)
+        @pe_tarball_filename = File.basename(@pe_tarball_uri.path)
+      rescue
+        raise "Unable to parse the specified URL: #{url}"
+      end
+      return true
+    end
+
+    # Determines whether the specified path / url has a valid extension (.gz)
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] pe_tarball Path to PE tarball file
+    #
+    # @raise [RuntimeError] If the extension of the specified tarball is invalid
+    #
+    # @return [true] Based on the validity of the extension
+    def validate_tarball_extension(pe_tarball)
+      message = "Invalid extension for tarball: #{pe_tarball}; extension must be .tar or .tar.gz"
+      raise(message) unless pe_tarball =~ /.*\.(tar|tar\.gz)$/
+      return true
+    end
+
+    # Determines whether the target master is localhost
+    #
+    # @author Bill Claytor
+    #
+    # @return [true,false] Based on whether the target master is localhost
+    #
+    # TODO: (SLV-185) Improve check for localhost
+    #
+    def target_master_is_localhost?
+      is_localhost = false
+      is_localhost = true if @target_master.include?("localhost")
+      return is_localhost
+    end
+
+    # Determines whether the specified file exists on the target master
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] path Path to PE tarball file
+    #
+    # @return [true,false] Based on whether the file exists on the target master
+    #
+    # TODO: SLV-187 - combine with copy_pe_tarball_on_target_master
+    #
+    def file_exist_on_target_master?(path)
+      command = "[ -f #{path} ]"
+      exists = true
+
+      begin
+        BoltHelper.run_cmd_with_bolt(command, @target_master)
+      rescue
+        exists = false
+      end
+
+      return exists
+    end
+
+    # Runs the download_pe_tarball Bolt task
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] url The pe tarball URL
+    # @param [string] nodes Nodes where the task should be run
+    #
+    # @return [true,false] Based on exit status of the bolt task
+    #
+    # TODO: update to return the download path (SLV-186)
+    #
+    def download_pe_tarball(url, nodes)
+      puts "Attempting to download #{url} to #{nodes}"
+      puts
+
+      params = {}
+      params["url"] = url
+      params["destination"] = TMP_WORK_DIR
+
+      output = BoltHelper.run_task_with_bolt(DOWNLOAD_PE_TARBALL_TASK, params, nodes)
+      success = output.nil? ? false : true
+      return success
+    end
+
+    # Downloads the PE tarball locally and moves it to the target master
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] url The pe tarball URL
+    #
+    # @return [true,false] Based on exit status of the bolt task
+    def download_and_move_pe_tarball(url)
+      download_path = "#{TMP_WORK_DIR}/#{@pe_tarball_filename}"
+      success = download_pe_tarball(url, "localhost")
+      success = upload_pe_tarball(download_path) if success
+      return success
+    end
+
+    # Handles the specified PE tarball URL by either downloading directly to the
+    # target master or downloading locally and copying to the target master
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] url The PE tarball URL
+    #
+    # @raise [RuntimeError] If the tarball is not handled successfully
+    #
+    # @return [string] The tarball path on the target master
+    # rubocop:disable Metrics/MethodLength
+    def handle_tarball_url(url)
+      parse_url(url)
+      tarball_path_on_master = "#{TMP_WORK_DIR}/#{@pe_tarball_filename}"
+      success = false
+
+      if target_master_is_localhost?
+        success = download_pe_tarball(url, "localhost")
+        raise "Failed downloading #{url} to localhost" unless success
+      else
+        begin
+          # if downloading to the target master fails
+          success = download_pe_tarball(url, @target_master)
+        rescue
+          # try to download locally and then upload
+          puts "Unable to download the tarball directly to #{@target_master}"
+          success = download_and_move_pe_tarball(url)
+        ensure
+          raise "Failed downloading #{url} locally and moving to #{@target_master}" unless success
+        end
+
+      end
+
+      return tarball_path_on_master
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Copies the PE tarball from the specified location to the temp working directory
+    # on the target master
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] tarball_path_on_target_master The pe tarball path on the target master
+    #
+    # @return [true,false] Based on exit status of the bolt task
+    def copy_pe_tarball_on_target_master(tarball_path_on_target_master)
+      filename = File.basename(tarball_path_on_target_master)
+      success = if tarball_path_on_target_master == "#{TMP_WORK_DIR}/#{filename}"
+                  puts "Not copying the tarball as the source and destination are the same"
+                  true
+                else
+                  command = "cp #{tarball_path_on_target_master} #{TMP_WORK_DIR}"
+                  output = BoltHelper.run_cmd_with_bolt(command, @target_master)
+                  output.nil? ? false : true
+                end
+
+      return success
+    end
+
+    # Handles the specified tarball path when the target master is not localhost
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] path The pe tarball path
+    #
+    # @raise [RuntimeError] If the specified tarball is not found
+    #
+    # @return [true,false] Based on exit status of the bolt task
+    def handle_tarball_path_with_remote_target_master(path)
+      remote_flag = "#{@target_master}:"
+
+      if path.start_with?(remote_flag)
+        actual_path = path.sub!(remote_flag, "")
+        success = file_exist_on_target_master?(actual_path)
+        success = copy_pe_tarball_on_target_master(actual_path) if success
+      else
+        raise "File not found: #{path}" unless File.exist?(path)
+        success = upload_pe_tarball(path)
+      end
+
+      return success
+    end
+
+    # Handles the specified tarball path based on the target_master
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] path The PE tarball path
+    #
+    # @raise [RuntimeError] If the specified tarball is not found
+    # @raise [RuntimeError] If the specified tarball is not uploaded successfully
+    #
+    # @return [string] The tarball path on the target master
+    #
+    # TODO: improve "host to install on"? ("host where PE will be installed?")
+    def handle_tarball_path(path)
+      filename = File.basename(path)
+      tarball_path_on_master = "#{TMP_WORK_DIR}/#{filename}"
+      file_not_found_error = "File not found: #{path}"
+      upload_error = "Unable to upload tarball to the RAS working directory on #{@target_master}"
+      copy_error = "Unable to copy tarball to the RAS working directory on #{@target_master}"
+
+      if target_master_is_localhost?
+        raise file_not_found_error unless File.exist?(path)
+        success = upload_pe_tarball(path)
+        error = copy_error unless success
+      else
+        success = handle_tarball_path_with_remote_target_master(path)
+        error = upload_error unless success
+      end
+
+      raise error unless success
+
+      return tarball_path_on_master
+    end
+
+    # Handles the PE tarball based on the the path (URL / file)
+    # and target master (local / remote)
+    #
+    # @author Bill Claytor
+    #
+    # @param [string] pe_tarball Path to PE tarball file
+    #
+    # @raise [RuntimeError] If the specified tarball is not handled successfully
+    #
+    # @return [string] The tarball path on the master after copying if successful
+    def handle_pe_tarball(pe_tarball)
+      error = "Unable to handle the specified PE tarball path: #{pe_tarball}"
+      validate_tarball_extension(pe_tarball)
+      tarball_path_on_master = if valid_url?(pe_tarball)
+                                 handle_tarball_url(pe_tarball)
+                               else
+                                 handle_tarball_path(pe_tarball)
+                               end
+
+      raise error unless tarball_path_on_master
+
+      return tarball_path_on_master
+    end
+
+    # Creates a tmp work dir for ref_arch_setup on the target_host
+    # Doesn't fail if the dir is already there.
+    #
+    # @author Randell Pelak
+    #
+    # @raise [BoltCommandError] If the bolt command is not successful or the output is nil
+    #
+    # @return [true,false] Based on the output returned from the bolt command
+    def make_tmp_work_dir
+      BoltHelper.make_dir(TMP_WORK_DIR, @target_master)
+    end
+
+    # Upload the pe.conf to the target_host
+    #
+    # @author Randell Pelak
+    #
+    # @param [string] src_pe_conf_path Path to the source copy of the pe.conf file
+    # @param [string] dest_pe_conf_path Path to put the pe.conf at on the target host
+    # @param [string] target_master Host to upload to
     #
     # @return [true,false] Based on exit status of the bolt task
-    def bootstrap_mono(pe_conf_path, pe_tarball_path, target_master = @target_master)
-      env_vars = "PE_CONF_PATH=#{pe_conf_path};"
-      env_vars << "PE_TARBALL_PATH=#{pe_tarball_path};"
-      env_vars << "PE_TARGET_MASTER=#{target_master};"
-      command = env_vars.to_s + "bolt task run bogus::foo "
-      command << "--modulepath #{RAS_MODULE_PATH} --nodes #{target_master}"
-      puts "Running: #{command}"
-      output = `#{command}`
-      success = $?.success? # rubocop:disable Style/SpecialGlobalVars
-      puts "ERROR: bolt command failed!" unless success
-      puts "Exit status was: #{$?.exitstatus}" # rubocop:disable Style/SpecialGlobalVars
-      puts "Output was: #{output}"
+    def upload_pe_conf(src_pe_conf_path = "#{RAS_FIXTURES_PATH}/pe.conf",
+                       dest_pe_conf_path = "#{TMP_WORK_DIR}/pe.conf",
+                       target_master = @target_master)
+      output = BoltHelper.upload_file(src_pe_conf_path, dest_pe_conf_path, target_master)
+      success = output.nil? ? false : true
+
+      return success
+    end
+
+    # Upload the pe tarball to the target_host
+    #
+    # @author Randell Pelak
+    #
+    # @param [string] src_pe_tarball_path Path to the source copy of the tarball file
+    #
+    # @return [true,false] Based on exit status of the bolt task
+    def upload_pe_tarball(src_pe_tarball_path)
+      file_name = File.basename(src_pe_tarball_path)
+      dest_pe_tarball_path = "#{TMP_WORK_DIR}/#{file_name}"
+
+      puts "Attempting upload from #{src_pe_tarball_path} " \
+           "to #{dest_pe_tarball_path} on #{@target_master}"
+
+      output = BoltHelper.upload_file(src_pe_tarball_path, dest_pe_tarball_path, @target_master)
+      success = output.nil? ? false : true
+
       return success
     end
   end