bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/indirector/facts/memory.rb

@@ -1,9 +0,0 @@
-require 'puppet/node/facts'
-require 'puppet/indirector/memory'
-
-class Puppet::Node::Facts::Memory < Puppet::Indirector::Memory
-  desc "Keep track of facts in memory but nowhere else.  This is used for
-    one-time compiles, such as what the stand-alone `puppet` does.
-    To use this terminus, you must load it with the data you want it
-    to contain."
-end

data/vendored/puppet/lib/puppet/indirector/facts/network_device.rb

@@ -1,27 +0,0 @@
-require 'puppet/node/facts'
-require 'puppet/indirector/code'
-
-class Puppet::Node::Facts::NetworkDevice < Puppet::Indirector::Code
-  desc "Retrieve facts from a network device."
-
-  def allow_remote_requests?
-    false
-  end
-
-  # Look a device's facts up through the current device.
-  def find(request)
-    result = Puppet::Node::Facts.new(request.key, Puppet::Util::NetworkDevice.current.facts)
-
-    result.add_local_facts
-    result.sanitize
-    result
-  end
-
-  def destroy(facts)
-    raise Puppet::DevError, _("You cannot destroy facts in the code store; it is only used for getting facts from a remote device")
-  end
-
-  def save(facts)
-    raise Puppet::DevError, _("You cannot save facts to the code store; it is only used for getting facts from a remote device")
-  end
-end

data/vendored/puppet/lib/puppet/indirector/facts/rest.rb

@@ -1,21 +0,0 @@
-require 'puppet/node/facts'
-require 'puppet/indirector/rest'
-
-class Puppet::Node::Facts::Rest < Puppet::Indirector::REST
-  desc "Find and save facts about nodes over HTTP via REST."
-
-  def save(request)
-    raise ArgumentError, _("PUT does not accept options") unless request.options.empty?
-
-    response = do_request(request) do |req|
-      http_put(req, IndirectedRoutes.request_to_uri(req), req.instance.render, headers.merge({ "Content-Type" => req.instance.mime }))
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_save(content_type, body)
-    else
-      raise convert_to_http_error(response)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/indirector/facts/store_configs.rb

@@ -1,11 +0,0 @@
-require 'puppet/node/facts'
-require 'puppet/indirector/store_configs'
-
-class Puppet::Node::Facts::StoreConfigs < Puppet::Indirector::StoreConfigs
-
-  desc %q{Part of the "storeconfigs" feature. Should not be directly set by end users.}
-
-  def allow_remote_requests?
-    false
-  end
-end

data/vendored/puppet/lib/puppet/indirector/facts/yaml.rb

@@ -1,84 +0,0 @@
-require 'puppet/node/facts'
-require 'puppet/indirector/yaml'
-
-class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
-  desc "Store client facts as flat files, serialized using YAML, or
-    return deserialized facts from disk."
-
-  def search(request)
-    node_names = []
-    Dir.glob(yaml_dir_path).each do |file|
-      facts = load_file(file)
-      if facts && node_matches?(facts, request.options)
-        node_names << facts.name
-      end
-    end
-    node_names
-  end
-
-  private
-
-  # Return the path to a given node's file.
-  def yaml_dir_path
-    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
-    File.join(base, 'facts', '*.yaml')
-  end
-
-  def node_matches?(facts, options)
-    options.each do |key, value|
-      type, name, operator = key.to_s.split(".")
-      operator ||= 'eq'
-
-      return false unless node_matches_option?(type, name, operator, value, facts)
-    end
-    return true
-  end
-
-  def node_matches_option?(type, name, operator, value, facts)
-    case type
-    when "meta"
-      case name
-      when "timestamp"
-        compare_timestamp(operator, facts.timestamp, Time.parse(value))
-      end
-    when "facts"
-      compare_facts(operator, facts.values[name], value)
-    end
-  end
-
-  def compare_facts(operator, value1, value2)
-    return false unless value1
-
-    case operator
-    when "eq"
-      value1.to_s == value2.to_s
-    when "le"
-      value1.to_f <= value2.to_f
-    when "ge"
-      value1.to_f >= value2.to_f
-    when "lt"
-      value1.to_f < value2.to_f
-    when "gt"
-      value1.to_f > value2.to_f
-    when "ne"
-      value1.to_s != value2.to_s
-    end
-  end
-
-  def compare_timestamp(operator, value1, value2)
-    case operator
-    when "eq"
-      value1 == value2
-    when "le"
-      value1 <= value2
-    when "ge"
-      value1 >= value2
-    when "lt"
-      value1 < value2
-    when "gt"
-      value1 > value2
-    when "ne"
-      value1 != value2
-    end
-  end
-end

data/vendored/puppet/lib/puppet/indirector/file_bucket_file/file.rb

@@ -1,262 +0,0 @@
-require 'puppet/indirector/code'
-require 'puppet/file_bucket/file'
-require 'puppet/util/checksums'
-require 'puppet/util/diff'
-require 'fileutils'
-
-module Puppet::FileBucketFile
-  class File < Puppet::Indirector::Code
-    include Puppet::Util::Checksums
-    include Puppet::Util::Diff
-
-    desc "Store files in a directory set based on their checksums."
-
-    def find(request)
-      request.options[:bucket_path] ||= Puppet[:bucketdir]
-      # If filebucket mode is 'list'
-      if request.options[:list_all]
-        return nil unless ::File.exists?(request.options[:bucket_path])
-        return list(request)
-      end
-      checksum, files_original_path = request_to_checksum_and_path(request)
-      contents_file = path_for(request.options[:bucket_path], checksum, 'contents')
-      paths_file = path_for(request.options[:bucket_path], checksum, 'paths')
-
-      if Puppet::FileSystem.exist?(contents_file) && matches(paths_file, files_original_path)
-        if request.options[:diff_with]
-          other_contents_file = path_for(request.options[:bucket_path], request.options[:diff_with], 'contents')
-          raise _("could not find diff_with %{diff}") % { diff: request.options[:diff_with] } unless Puppet::FileSystem.exist?(other_contents_file)
-          raise _("Unable to diff on this platform") unless Puppet[:diff] != ""
-          return diff(Puppet::FileSystem.path_string(contents_file), Puppet::FileSystem.path_string(other_contents_file))
-        else
-          #TRANSLATORS "FileBucket" should not be translated
-          Puppet.info _("FileBucket read %{checksum}") % { checksum: checksum }
-          model.new(Puppet::FileSystem.binread(contents_file))
-        end
-      else
-        nil
-      end
-    end
-
-    def list(request)
-      if request.remote?
-        raise Puppet::Error, _("Listing remote file buckets is not allowed")
-      end
-
-      fromdate = request.options[:fromdate] || "0:0:0 1-1-1970"
-      todate = request.options[:todate] || Time.now.strftime("%F %T")
-      begin
-        to = Time.parse(todate)
-      rescue ArgumentError
-        raise Puppet::Error, _("Error while parsing 'todate'")
-      end
-      begin
-        from = Time.parse(fromdate)
-      rescue ArgumentError
-        raise Puppet::Error, _("Error while parsing 'fromdate'")
-      end
-      # Setting hash's default value to [], needed by the following loop
-      bucket = Hash.new {[]}
-      msg = ""
-      # Get all files with mtime between 'from' and 'to'
-      Pathname.new(request.options[:bucket_path]).find { |item|
-        if item.file? and item.basename.to_s == "paths"
-          filenames = item.read.strip.split("\n")
-          filestat = Time.parse(item.stat.mtime.to_s)
-          if from <= filestat and filestat <= to
-            filenames.each do |filename|
-              bucket[filename] += [[ item.stat.mtime , item.parent.basename ]]
-            end
-          end
-        end
-      }
-      # Sort the results
-      bucket.each { |filename, contents|
-        contents.sort_by! do |item|
-          # NOTE: Ruby 2.4 may reshuffle item order even if the keys in sequence are sorted already
-          item[0]
-        end
-      }
-      # Build the output message. Sorted by names then by dates
-      bucket.sort.each { |filename,contents|
-        contents.each { |mtime, chksum|
-          date = mtime.strftime("%F %T")
-          msg += "#{chksum} #{date} #{filename}\n"
-        }
-      }
-      return model.new(msg)
-    end
-
-    def head(request)
-      checksum, files_original_path = request_to_checksum_and_path(request)
-      contents_file = path_for(request.options[:bucket_path], checksum, 'contents')
-      paths_file = path_for(request.options[:bucket_path], checksum, 'paths')
-
-      Puppet::FileSystem.exist?(contents_file) && matches(paths_file, files_original_path)
-    end
-
-    def save(request)
-      instance = request.instance
-      _, files_original_path = request_to_checksum_and_path(request)
-      contents_file = path_for(instance.bucket_path, instance.checksum_data, 'contents')
-      paths_file = path_for(instance.bucket_path, instance.checksum_data, 'paths')
-
-      save_to_disk(instance, files_original_path, contents_file, paths_file)
-
-      # don't echo the request content back to the agent
-      model.new('')
-    end
-
-    def validate_key(request)
-      # There are no ACLs on filebucket files so validating key is not important
-    end
-
-    private
-
-    # @param paths_file [Object] Opaque file path
-    # @param files_original_path [String]
-    #
-    def matches(paths_file, files_original_path)
-      # Puppet will have already written the paths_file in the systems encoding
-      # given its possible that request.options[:bucket_path] or Puppet[:bucketdir]
-      # contained characters in an encoding that are not represented the
-      # same way when the bytes are decoded as UTF-8, continue using system encoding
-      Puppet::FileSystem.open(paths_file, 0640, 'a+:external') do |f|
-        path_match(f, files_original_path)
-      end
-    end
-
-    def path_match(file_handle, files_original_path)
-      return true unless files_original_path # if no path was provided, it's a match
-      file_handle.rewind
-      file_handle.each_line do |line|
-        return true if line.chomp == files_original_path
-      end
-      return false
-    end
-
-    # @param bucket_file [Puppet::FileBucket::File] IO object representing
-    #   content to back up
-    # @param files_original_path [String] Path to original source file on disk
-    # @param contents_file [Pathname] Opaque file path to intended backup
-    #   location
-    # @param paths_file [Pathname] Opaque file path to file containing source
-    #   file paths on disk
-    # @return [void]
-    # @raise [Puppet::FileBucket::BucketError] on possible sum collision between
-    #   existing and new backup
-    # @api private
-    def save_to_disk(bucket_file, files_original_path, contents_file, paths_file)
-      Puppet::Util.withumask(0007) do
-        unless Puppet::FileSystem.dir_exist?(paths_file)
-          Puppet::FileSystem.dir_mkpath(paths_file)
-        end
-
-        # Puppet will have already written the paths_file in the systems encoding
-        # given its possible that request.options[:bucket_path] or Puppet[:bucketdir]
-        # contained characters in an encoding that are not represented the
-        # same way when the bytes are decoded as UTF-8, continue using system encoding
-        Puppet::FileSystem.exclusive_open(paths_file, 0640, 'a+:external') do |f|
-          if Puppet::FileSystem.exist?(contents_file)
-            if verify_identical_file(contents_file, bucket_file)
-              #TRANSLATORS "FileBucket" should not be translated
-              Puppet.info _("FileBucket got a duplicate file %{file_checksum}") % { file_checksum: bucket_file.checksum }
-              # Don't touch the contents file on Windows, since we can't update the
-              # mtime of read-only files there.
-              if !Puppet::Util::Platform.windows?
-                Puppet::FileSystem.touch(contents_file)
-              end
-            elsif contents_file_matches_checksum?(contents_file, bucket_file.checksum_data, bucket_file.checksum_type)
-              # If the contents or sizes don't match, but the checksum does,
-              # then we've found a conflict (potential hash collision).
-              # Unlikely, but quite bad. Don't remove the file in case it's
-              # needed, but ask the user to validate.
-              # Note: Don't print the full path to the bucket file in the
-              # exception to avoid disclosing file system layout on server.
-              #TRANSLATORS "FileBucket" should not be translated
-              Puppet.err(_("Unable to verify existing FileBucket backup at '%{path}'.") % { path: contents_file.to_path })
-              raise Puppet::FileBucket::BucketError, _("Existing backup and new file have different content but same checksum, %{value}. Verify existing backup and remove if incorrect.") %
-                { value: bucket_file.checksum }
-            else
-              # PUP-1334 If the contents_file exists but does not match its
-              # checksum, our backup has been corrupted. Warn about overwriting
-              # it, and proceed with new backup.
-              Puppet.warning(_("Existing backup does not match its expected sum, %{sum}. Overwriting corrupted backup.") % { sum: bucket_file.checksum })
-              copy_bucket_file_to_contents_file(contents_file, bucket_file)
-            end
-          else
-            copy_bucket_file_to_contents_file(contents_file, bucket_file)
-          end
-
-          unless path_match(f, files_original_path)
-            f.seek(0, IO::SEEK_END)
-            f.puts(files_original_path)
-          end
-        end
-      end
-    end
-
-    def request_to_checksum_and_path(request)
-      checksum_type, checksum, path = request.key.split(/\//, 3)
-      if path == '' # Treat "md5/<checksum>/" like "md5/<checksum>"
-        path = nil
-      end
-      raise ArgumentError, _("Unsupported checksum type %{checksum_type}") % { checksum_type: checksum_type.inspect } if checksum_type != Puppet[:digest_algorithm]
-      expected = method(checksum_type + "_hex_length").call
-      raise _("Invalid checksum %{checksum}") % { checksum: checksum.inspect } if checksum !~ /^[0-9a-f]{#{expected}}$/
-      [checksum, path]
-    end
-
-    # @return [Object] Opaque path as constructed by the Puppet::FileSystem
-    #
-    def path_for(bucket_path, digest, subfile = nil)
-      bucket_path ||= Puppet[:bucketdir]
-
-      dir     = ::File.join(digest[0..7].split(""))
-      basedir = ::File.join(bucket_path, dir, digest)
-
-      Puppet::FileSystem.pathname(subfile ? ::File.join(basedir, subfile) : basedir)
-    end
-
-    # @param contents_file [Pathname] Opaque file path to intended backup
-    #   location
-    # @param bucket_file [Puppet::FileBucket::File] IO object representing
-    #   content to back up
-    # @return [Boolean] whether the data in contents_file is of the same size
-    #   and content as that in the bucket_file
-    # @api private
-    def verify_identical_file(contents_file, bucket_file)
-      (bucket_file.to_binary.bytesize == Puppet::FileSystem.size(contents_file)) &&
-        (bucket_file.stream() {|s| Puppet::FileSystem.compare_stream(contents_file, s) })
-    end
-
-    # @param contents_file [Pathname] Opaque file path to intended backup
-    #   location
-    # @param expected_checksum_data [String] expected value of checksum of type
-    #   checksum_type
-    # @param checksum_type [String] type of check sum of checksum_data, ie "md5"
-    # @return [Boolean] whether the checksum of the contents_file matches the
-    #   supplied checksum
-    # @api private
-    def contents_file_matches_checksum?(contents_file, expected_checksum_data, checksum_type)
-      contents_file_checksum_data = Puppet::Util::Checksums.method(:"#{checksum_type}_file").call(contents_file.to_path)
-      contents_file_checksum_data == expected_checksum_data
-    end
-
-    # @param contents_file [Pathname] Opaque file path to intended backup
-    #   location
-    # @param bucket_file [Puppet::FileBucket::File] IO object representing
-    #   content to back up
-    # @return [void]
-    # @api private
-    def copy_bucket_file_to_contents_file(contents_file, bucket_file)
-      Puppet::Util.replace_file(contents_file, 0440) do |of|
-        # PUP-1044 writes all of the contents
-        bucket_file.stream() do |src|
-          FileUtils.copy_stream(src, of)
-        end
-      end
-    end
-
-  end
-end

data/vendored/puppet/lib/puppet/indirector/file_bucket_file/rest.rb

@@ -1,8 +0,0 @@
-require 'puppet/indirector/rest'
-require 'puppet/file_bucket/file'
-
-module Puppet::FileBucketFile
-  class Rest < Puppet::Indirector::REST
-    desc "This is a REST based mechanism to send/retrieve file to/from the filebucket"
-  end
-end

data/vendored/puppet/lib/puppet/indirector/file_bucket_file/selector.rb

@@ -1,53 +0,0 @@
-require 'puppet/indirector/code'
-
-module Puppet::FileBucketFile
-  class Selector < Puppet::Indirector::Code
-    desc "Select the terminus based on the request"
-
-    def select(request)
-      if request.protocol == 'https'
-        :rest
-      else
-        :file
-      end
-    end
-
-    def get_terminus(request)
-      indirection.terminus(select(request))
-    end
-
-    def head(request)
-      get_terminus(request).head(request)
-    end
-
-    def find(request)
-      get_terminus(request).find(request)
-    end
-
-    def save(request)
-      get_terminus(request).save(request)
-    end
-
-    def search(request)
-      get_terminus(request).search(request)
-    end
-
-    def destroy(request)
-      get_terminus(request).destroy(request)
-    end
-
-    def authorized?(request)
-      terminus = get_terminus(request)
-      if terminus.respond_to?(:authorized?)
-        terminus.authorized?(request)
-      else
-        true
-      end
-    end
-
-    def validate_key(request)
-      get_terminus(request).validate(request)
-    end
-  end
-end
-