akerl-r10k 3.14.2.1

data/lib/r10k/tarball.rb

@@ -0,0 +1,183 @@
+require 'fileutils'
+require 'find'
+require 'minitar'
+require 'tempfile'
+require 'uri'
+require 'zlib'
+require 'r10k/settings'
+require 'r10k/settings/mixin'
+require 'r10k/util/platform'
+require 'r10k/util/cacheable'
+require 'r10k/util/downloader'
+
+module R10K
+  class Tarball
+
+    include R10K::Settings::Mixin
+    include R10K::Util::Cacheable
+    include R10K::Util::Downloader
+
+    def_setting_attr :proxy      # Defaults to global proxy setting
+    def_setting_attr :cache_root, R10K::Util::Cacheable.default_cachedir
+
+    # @!attribute [rw] name
+    #   @return [String] The tarball's name
+    attr_accessor :name
+
+    # @!attribute [rw] source
+    #   @return [String] The tarball's source
+    attr_accessor :source
+
+    # @!attribute [rw] checksum
+    #   @return [String] The tarball's expected sha256 digest
+    attr_accessor :checksum
+
+    # @param name [String] The name of the tarball content
+    # @param source [String] The source for the tarball content
+    # @param checksum [String] The sha256 digest of the tarball content
+    def initialize(name, source, checksum: nil)
+      @name = name
+      @source = source
+      @checksum = checksum
+
+      # At this time, the only checksum type supported is sha256. In the future,
+      # we may decide to support other algorithms if a use case arises. TBD.
+      checksum_algorithm = :SHA256
+    end
+
+    # @return [String] Directory. Where the cache_basename file will be created.
+    def cache_dirname
+      File.join(settings[:cache_root], 'tarball')
+    end
+
+    # The final cache_path should match one of the templates:
+    #
+    #   - {cachedir}/{checksum}.tar.gz
+    #   - {cachedir}/{source}.tar.gz
+    #
+    # @return [String] File. The full file path the tarball will be cached to.
+    def cache_path
+      File.join(cache_dirname, cache_basename)
+    end
+
+    # @return [String] The basename of the tarball cache file.
+    def cache_basename
+      if checksum.nil?
+        sanitized_dirname(source) + '.tar.gz'
+      else
+        checksum + '.tar.gz'
+      end
+    end
+
+    # Extract the cached tarball to the target directory.
+    #
+    # @param target_dir [String] Where to unpack the tarball
+    def unpack(target_dir)
+      file = File.open(cache_path, 'rb')
+      reader = Zlib::GzipReader.new(file)
+      begin
+        Minitar.unpack(reader, target_dir)
+      ensure
+        reader.close
+      end
+    end
+
+    # @param target_dir [String] The directory to check if is in sync with the
+    #        tarball content
+    # @param ignore_untracked_files [Boolean] If true, consider the target
+    #        dir to be in sync as long as all tracked content matches.
+    #
+    # @return [Boolean]
+    def insync?(target_dir, ignore_untracked_files: false)
+      target_tree_entries = Find.find(target_dir).map(&:to_s) - [target_dir]
+      each_tarball_entry do |entry|
+        found = target_tree_entries.delete(File.join(target_dir, entry.full_name.chomp('/')))
+        return false if found.nil?
+        next if entry.directory?
+        return false unless file_digest(found) == reader_digest(entry)
+      end
+
+      if ignore_untracked_files
+        # We wouldn't have gotten this far if there were discrepancies in
+        # tracked content
+        true
+      else
+        # If there are still files in target_tree_entries, then there is
+        # untracked content present in the target tree. If not, we're in sync.
+        target_tree_entries.empty?
+      end
+    end
+
+    # Download the tarball from @source to @cache_path
+    def get
+      Tempfile.open(cache_basename) do |tempfile|
+        tempfile.binmode
+        src_uri = URI.parse(source)
+
+        temp_digest = case src_uri.scheme
+                      when 'file', nil
+                        copy(src_uri.path, tempfile)
+                      when %r{^[a-z]$} # Windows drive letter
+                        copy(src_uri.to_s, tempfile)
+                      when %r{^https?$}
+                        download(src_uri, tempfile)
+                      else
+                        raise "Unexpected source scheme #{src_uri.scheme}"
+                      end
+
+        # Verify the download
+        unless (checksum == temp_digest) || checksum.nil?
+          raise 'Downloaded file does not match checksum'
+        end
+
+        # Move the download to cache_path
+        FileUtils::mkdir_p(cache_dirname)
+        begin
+          FileUtils.mv(tempfile.path, cache_path)
+        rescue Errno::EACCES
+          # It may be the case that permissions don't permit moving the file
+          # into place, but do permit overwriting an existing in-place file.
+          FileUtils.cp(tempfile.path, cache_path)
+        end
+      end
+    end
+
+    # Checks the cached tarball's digest against the expected checksum. Returns
+    # false if no cached file is present. If the tarball has no expected
+    # checksum, any cached file is assumed to be valid.
+    #
+    # @return [Boolean]
+    def cache_valid?
+      return false unless File.exist?(cache_path)
+      return true if checksum.nil?
+      checksum == file_digest(cache_path)
+    end
+
+    # List all of the files contained in the tarball and their paths. This is
+    # useful for implementing R10K::Purgable
+    #
+    # @return [Array] A normalized list of file paths contained in the archive
+    def paths
+      names = Array.new
+      each_tarball_entry { |entry| names << Pathname.new(entry).cleanpath.to_s }
+      names - ['.']
+    end
+
+    def cache_checksum
+      raise R10K::Error, _("Cache not present at %{path}") % {path: cache_path} unless File.exist?(cache_path)
+      file_digest(cache_path)
+    end
+
+    private
+
+    def each_tarball_entry(&block)
+      File.open(cache_path, 'rb') do |file|
+        Zlib::GzipReader.wrap(file) do |reader|
+          Archive::Tar::Minitar::Input.each_entry(reader) do |entry|
+            yield entry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r10k/util/attempt.rb

@@ -0,0 +1,84 @@
+require 'r10k/logging'
+require 'r10k/errors/formatting'
+require 'r10k/util/setopts'
+require 'colored2'
+
+module R10K
+  module Util
+
+    # Attempt a series of dependent nested tasks and cleanly handle errors.
+    #
+    # @api private
+    class Attempt
+
+      include R10K::Logging
+      include R10K::Util::Setopts
+
+      # @!attribute [r] status
+      #   @return [Symbol] The status of this task
+      attr_reader :status
+
+      def initialize(initial, opts = {})
+        @initial = initial
+        @tries = []
+        @status = :notrun
+        setopts(opts, {:trace => :self})
+      end
+
+      # Run this attempt to completion.
+      #
+      # @todo determine the structure of the ret
+      # @return [Object] The aggregate result of all work performed.
+      def run
+        @status = :running
+        result = apply(@initial, @tries)
+        @status = :ok if @status == :running
+        result
+      end
+
+      # Add another action to take for this attempt
+      #
+      # @yieldparam [Object] The result of the previous action.
+      # @yieldreturn [Object, Array<Object>, NilClass] The result of this action.
+      #   If the value is an object, it will be passed to the next attempt. If
+      #   the value is an Array then each element will be individually passed
+      #   to the next try. If the value is false or nil then no further action
+      #   will be taken.
+      def try(&block)
+        @tries << block
+        self
+      end
+
+      def ok?
+        @status == :ok
+      end
+
+      private
+
+      def apply(input, tries)
+        return input if tries.empty?
+
+        case input
+        when Array
+          apply_all(input, tries)
+        when NilClass, FalseClass
+          input
+        else
+          apply_one(input, tries)
+        end
+      end
+
+      def apply_all(values, tries)
+        values.map { |v| apply_one(v, tries) }
+      end
+
+      def apply_one(value, tries)
+        apply(tries.first.call(value), tries.drop(1))
+      rescue => e
+        @status = :failed
+        logger.error R10K::Errors::Formatting.format_exception(e, @trace)
+        e
+      end
+    end
+  end
+end

data/lib/r10k/util/basedir.rb

@@ -0,0 +1,65 @@
+require 'r10k/deployment'
+require 'r10k/logging'
+require 'r10k/util/purgeable'
+
+module R10K
+  module Util
+
+    # Represents a directory that can purge unmanaged contents
+    #
+    # @todo pick a better name than basedir. Expect this class to be renamed.
+    #
+    # @api private
+    class Basedir
+
+      include R10K::Util::Purgeable
+      include R10K::Logging
+
+      # Create a new Basedir by selecting sources from a deployment that match
+      # the specified path.
+      #
+      # @param path [String]
+      # @param deployment [R10K::Deployment]
+      #
+      # @return [R10K::Util::Basedir]
+      def self.from_deployment(path, deployment)
+        sources = deployment.sources.select { |source| source.managed_directory == path }
+        new(path, sources)
+      end
+
+      # @param path [String] The path to the directory to manage
+      # @param sources [Array<#desired_contents>] A list of objects that may create filesystem entries
+      def initialize(path, sources)
+        if sources.is_a? R10K::Deployment
+          raise ArgumentError, _("Expected Array<#desired_contents>, got R10K::Deployment")
+        end
+        @path    = path
+        @sources = sources
+      end
+
+      # Return the path of the basedir
+      # @note This implements a required method for the Purgeable mixin
+      # @return [Array]
+      def managed_directories
+        [@path]
+      end
+
+      # List all environments that should exist in this basedir
+      # @note This implements a required method for the Purgeable mixin
+      # @return [Array<String>]
+      def desired_contents
+        @sources.flat_map do |src|
+          src.desired_contents.collect { |env| File.join(@path, env) }
+        end
+      end
+
+      def purge!
+        @sources.each do |source|
+          logger.debug1 _("Source %{source_name} in %{path} manages contents %{contents}") % {source_name: source.name, path: @path, contents: source.desired_contents.inspect}
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/r10k/util/cacheable.rb

@@ -0,0 +1,31 @@
+module R10K
+  module Util
+
+    # Utility mixin for classes that need to implement caches
+    #
+    # @abstract Classes using this mixin need to implement {#managed_directory} and
+    #   {#desired_contents}
+    module Cacheable
+
+      # Provide a default cachedir location. This is consumed by R10K::Settings
+      # for appropriate global default values.
+      #
+      # @return [String] Path to the default cache directory
+      def self.default_cachedir(basename = 'cache')
+        if R10K::Util::Platform.windows?
+          File.join(ENV['LOCALAPPDATA'], 'r10k', basename)
+        else
+          File.join(ENV['HOME'] || '/root', '.r10k', basename)
+        end
+      end
+
+      # Reformat a string into something that can be used as a directory
+      #
+      # @param string [String] An identifier to create a sanitized dirname for
+      # @return [String] A sanitized dirname for the given string
+      def sanitized_dirname(string)
+        string.gsub(/(\w+:\/\/)(.*)(@)/, '\1').gsub(/[^@\w\.-]/, '-')
+      end
+    end
+  end
+end

data/lib/r10k/util/cleaner.rb

@@ -0,0 +1,21 @@
+require 'r10k/logging'
+require 'r10k/util/purgeable'
+
+module R10K
+  module Util
+    class Cleaner
+
+      include R10K::Logging
+      include R10K::Util::Purgeable
+
+      attr_reader :managed_directories, :desired_contents, :purge_exclusions
+
+      def initialize(managed_directories, desired_contents, purge_exclusions = [])
+        @managed_directories = managed_directories
+        @desired_contents    = desired_contents
+        @purge_exclusions    = purge_exclusions
+      end
+
+    end
+  end
+end

data/lib/r10k/util/commands.rb

@@ -0,0 +1,31 @@
+module R10K
+  module Util
+    module Commands
+      module_function
+
+      # Find the full path of a shell command.
+      #
+      # On POSIX platforms, the PATHEXT environment variable will be unset, so
+      # the first command named 'cmd' will be returned.
+      #
+      # On Windows platforms, the PATHEXT environment variable will contain a
+      # semicolon delimited list of executable file extensions, so the first
+      # command with a matching path extension will be returned.
+      #
+      # @param cmd [String] The name of the command to search for
+      # @return [String, nil] The path to the file if found, nil otherwise
+      def which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
+          exts.each do |ext|
+            path = File.join(dir, "#{cmd}#{ext}")
+            if File.executable?(path) && File.file?(path)
+              return path
+            end
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/r10k/util/downloader.rb

@@ -0,0 +1,134 @@
+require 'digest'
+require 'net/http'
+
+module R10K
+  module Util
+
+    # Utility mixin for classes that need to download files
+    module Downloader
+
+      # Downloader objects need to checksum downloaded or saved content. The
+      # algorithm used to perform this checksumming (and therefore the kinds of
+      # checksums returned by various methods) is reported by this method.
+      #
+      # @return [Symbol] The checksum algorithm the downloader uses
+      def checksum_algorithm
+        @checksum_algorithm ||= :SHA256
+      end
+
+      private
+
+      # Set the checksum algorithm the downloader should use. It should be a
+      # symbol, and a valid Ruby 'digest' library algorithm. The default is
+      # :SHA256.
+      #
+      # @param algorithm [Symbol] The checksum algorithm the downloader should use
+      def checksum_algorithm=(algorithm)
+        @checksum_algorithm = algorithm
+      end
+
+      CHUNK_SIZE = 64 * 1024 # 64 kb
+
+      # @param src_uri [URI] The URI to download from
+      # @param dst_file [String] The file or path to save to
+      # @return [String] The downloaded file's hex digest
+      def download(src_uri, dst_file)
+        digest = Digest(checksum_algorithm).new
+        http_get(src_uri) do |resp|
+          File.open(dst_file, 'wb') do |output_stream|
+            resp.read_body do |chunk|
+              output_stream.write(chunk)
+              digest.update(chunk)
+            end
+          end
+        end
+
+        digest.hexdigest
+      end
+
+      # @param src_file The file or path to copy from
+      # @param dst_file The file or path to copy to
+      # @return [String] The copied file's sha256 hex digest
+      def copy(src_file, dst_file)
+        digest = Digest(checksum_algorithm).new
+        File.open(src_file, 'rb') do |input_stream|
+          File.open(dst_file, 'wb') do |output_stream|
+            until input_stream.eof?
+              chunk = input_stream.read(CHUNK_SIZE)
+              output_stream.write(chunk)
+              digest.update(chunk)
+            end
+          end
+        end
+
+        digest.hexdigest
+      end
+
+      # Start a Net::HTTP::Get connection, then yield the Net::HTTPSuccess object
+      # to the caller's block. Follow redirects if Net::HTTPRedirection responses
+      # are encountered, and use a proxy if directed.
+      #
+      # @param uri [URI] The URI to download the file from
+      # @param redirect_limit [Integer] How many redirects to permit before failing
+      # @param proxy [URI, String] The URI to use as a proxy
+      def http_get(uri, redirect_limit: 10, proxy: nil, &block)
+        raise "HTTP redirect too deep" if redirect_limit.zero?
+
+        session = Net::HTTP.new(uri.host, uri.port, *proxy_to_array(proxy))
+        session.use_ssl = true if uri.scheme == 'https'
+        session.start
+
+        begin
+          session.request_get(uri) do |response|
+            case response
+            when Net::HTTPRedirection
+              redirect = response['location']
+              session.finish
+              return http_get(URI.parse(redirect), redirect_limit: redirect_limit - 1, proxy: proxy, &block)
+            when Net::HTTPSuccess
+              yield response
+            else
+              raise "Unexpected response code #{response.code}: #{response}"
+            end
+          end
+        ensure
+          session.finish if session.active?
+        end
+      end
+
+      # Helper method to translate a proxy URI to array arguments for
+      # Net::HTTP#new. A nil argument returns nil array elements.
+      def proxy_to_array(proxy_uri)
+        if proxy_uri
+          px = proxy_uri.is_a?(URI) ? proxy_uri : URI.parse(proxy_uri)
+          [px.host, px.port, px.user, px.password]
+        else
+          [nil, nil, nil, nil]
+        end
+      end
+
+      # Return the sha256 digest of the file at the given path
+      #
+      # @param path [String] The path to the file
+      # @return [String] The file's sha256 hex digest
+      def file_digest(path)
+        File.open(path) do |file|
+          reader_digest(file)
+        end
+      end
+
+      # Return the sha256 digest of the readable data
+      #
+      # @param reader [String] An object that responds to #read
+      # @return [String] The read data's sha256 hex digest
+      def reader_digest(reader)
+        digest = Digest(checksum_algorithm).new
+        while chunk = reader.read(CHUNK_SIZE)
+          digest.update(chunk)
+        end
+
+        digest.hexdigest
+      end
+    end
+  end
+end

data/lib/r10k/util/exec_env.rb

@@ -0,0 +1,36 @@
+module R10K
+  module Util
+
+    # Utility methods for dealing with environment variables
+    module ExecEnv
+      module_function
+
+      # Swap out all environment settings
+      #
+      # @param env [Hash] The new environment to use
+      # @return [void]
+      def reset(env)
+        env.each_pair do |key, value|
+          ENV[key] = value
+        end
+
+        (ENV.keys - env.keys).each do |key|
+          ENV.delete(key)
+        end
+      end
+
+      # Add the specified settings to the env for the supplied block
+      #
+      # @param env [Hash] The values to add to the environment
+      # @param block [Proc] The code to call with the modified environnment
+      # @return [void]
+      def withenv(env, &block)
+        original = ENV.to_hash
+        reset(original.merge(env))
+        block.call
+      ensure
+        reset(original)
+      end
+    end
+  end
+end

data/lib/r10k/util/license.rb

@@ -0,0 +1,24 @@
+require 'r10k/errors'
+require 'r10k/features'
+
+module R10K
+  module Util
+    module License
+      extend R10K::Logging
+
+      def self.load
+        if R10K::Features.available?(:pe_license)
+          logger.debug2 _("pe_license feature is available, loading PE license key")
+          begin
+            return PELicense.load_license_key
+          rescue PELicense::InvalidLicenseError => e
+            raise R10K::Error.wrap(e, _("Invalid PE license detected: %{error_msg}") % {error_msg: e.message} )
+          end
+        else
+          logger.debug2 _("pe_license feature is not available, PE only Puppet modules will not be downloadable.")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/r10k/util/platform.rb

@@ -0,0 +1,42 @@
+require 'rbconfig'
+
+module R10K
+  module Util
+    module Platform
+      FIPS_FILE = "/proc/sys/crypto/fips_enabled"
+
+      def self.platform
+        # Test JRuby first to handle JRuby on Windows as well.
+        if self.jruby?
+          :jruby
+        elsif self.windows?
+          :windows
+        else
+          :posix
+        end
+      end
+
+      # We currently only suport FIPS mode on redhat 7, where it is
+      # toggled via a file.
+      def self.fips?
+        if File.exist?(FIPS_FILE)
+          File.read(FIPS_FILE).chomp == "1"
+        else
+          false
+        end
+      end
+
+      def self.windows?
+        RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i
+      end
+
+      def self.jruby?
+        RUBY_PLATFORM == "java"
+      end
+
+      def self.posix?
+        !windows? && !jruby?
+      end
+    end
+  end
+end