bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/file_serving/content.rb

@@ -1,43 +0,0 @@
-require 'puppet/indirector'
-require 'puppet/file_serving'
-require 'puppet/file_serving/base'
-
-# A class that handles retrieving file contents.
-# It only reads the file when its content is specifically
-# asked for.
-class Puppet::FileServing::Content < Puppet::FileServing::Base
-  extend Puppet::Indirector
-  indirects :file_content, :terminus_class => :selector
-
-  attr_writer :content
-
-  def self.supported_formats
-    [:binary]
-  end
-
-  def self.from_binary(content)
-    instance = new("/this/is/a/fake/path")
-    instance.content = content
-    instance
-  end
-
-  # This is no longer used, but is still called by the file server implementations when interacting
-  # with their model abstraction.
-  def collect(source_permissions = nil)
-  end
-
-  # Read the content of our file in.
-  def content
-    unless @content
-      # This stat can raise an exception, too.
-      raise(ArgumentError, _("Cannot read the contents of links unless following links")) if stat.ftype == "symlink"
-
-      @content = Puppet::FileSystem.binread(full_path)
-    end
-    @content
-  end
-
-  def to_binary
-    File.new(full_path, "rb")
-  end
-end

data/vendored/puppet/lib/puppet/file_serving/fileset.rb

@@ -1,174 +0,0 @@
-require 'find'
-require 'puppet/file_serving'
-require 'puppet/file_serving/metadata'
-
-# Operate recursively on a path, returning a set of file paths.
-class Puppet::FileServing::Fileset
-  attr_reader :path, :ignore, :links
-  attr_accessor :recurse, :recurselimit, :checksum_type
-
-  # Produce a hash of files, with merged so that earlier files
-  # with the same postfix win.  E.g., /dir1/subfile beats /dir2/subfile.
-  # It's a hash because we need to know the relative path of each file,
-  # and the base directory.
-  #   This will probably only ever be used for searching for plugins.
-  def self.merge(*filesets)
-    result = {}
-
-    filesets.each do |fileset|
-      fileset.files.each do |file|
-        result[file] ||= fileset.path
-      end
-    end
-
-    result
-  end
-
-  def initialize(path, options = {})
-    if Puppet::Util::Platform.windows?
-      # REMIND: UNC path
-      path = path.chomp(File::SEPARATOR) unless path =~ /^[A-Za-z]:\/$/
-    else
-      path = path.chomp(File::SEPARATOR) unless path == File::SEPARATOR
-    end
-    raise ArgumentError.new(_("Fileset paths must be fully qualified: %{path}") % { path: path }) unless Puppet::Util.absolute_path?(path)
-
-    @path = path
-
-    # Set our defaults.
-    self.ignore = []
-    self.links = :manage
-    @recurse = false
-    @recurselimit = :infinite
-
-    if options.is_a?(Puppet::Indirector::Request)
-      initialize_from_request(options)
-    else
-      initialize_from_hash(options)
-    end
-
-    raise ArgumentError.new(_("Fileset paths must exist")) unless valid?(path)
-    #TRANSLATORS "recurse" and "recurselimit" are parameter names and should not be translated
-    raise ArgumentError.new(_("Fileset recurse parameter must not be a number anymore, please use recurselimit")) if @recurse.is_a?(Integer)
-  end
-
-  # Return a list of all files in our fileset.  This is different from the
-  # normal definition of find in that we support specific levels
-  # of recursion, which means we need to know when we're going another
-  # level deep, which Find doesn't do.
-  def files
-    files = perform_recursion
-
-    # Now strip off the leading path, so each file becomes relative, and remove
-    # any slashes that might end up at the beginning of the path.
-    result = files.collect { |file| file.sub(%r{^#{Regexp.escape(@path)}/*}, '') }
-
-    # And add the path itself.
-    result.unshift(".")
-
-    result
-  end
-
-  def ignore=(values)
-    values = [values] unless values.is_a?(Array)
-    @ignore = values.collect(&:to_s)
-  end
-
-  def links=(links)
-    links = links.to_sym
-    #TRANSLATORS ":links" is a parameter name and should not be translated
-    raise(ArgumentError, _("Invalid :links value '%{links}'") % { links: links }) unless [:manage, :follow].include?(links)
-    @links = links
-    @stat_method = @links == :manage ? :lstat : :stat
-  end
-
-  private
-
-  def initialize_from_hash(options)
-    options.each do |option, value|
-      method = option.to_s + "="
-      begin
-        send(method, value)
-      rescue NoMethodError
-        raise ArgumentError, _("Invalid option '%{option}'") % { option: option }, $!.backtrace
-      end
-    end
-  end
-
-  def initialize_from_request(request)
-    [:links, :ignore, :recurse, :recurselimit, :checksum_type].each do |param|
-      if request.options.include?(param) # use 'include?' so the values can be false
-        value = request.options[param]
-      elsif request.options.include?(param.to_s)
-        value = request.options[param.to_s]
-      end
-      next if value.nil?
-      value = true if value == "true"
-      value = false if value == "false"
-      value = Integer(value) if value.is_a?(String) and value =~ /^\d+$/
-      send(param.to_s + "=", value)
-    end
-  end
-
-  FileSetEntry = Struct.new(:depth, :path, :ignored, :stat_method) do
-    def down_level(to)
-      FileSetEntry.new(depth + 1, File.join(path, to), ignored, stat_method)
-    end
-
-    def basename
-      File.basename(path)
-    end
-
-    def children
-      return [] unless directory?
-
-      Dir.entries(path).
-        reject { |child| ignore?(child) }.
-        collect { |child| down_level(child) }
-    end
-
-    def ignore?(child)
-      return true if child == "." || child == ".."
-      return false if ignored == [nil]
-
-      ignored.any? { |pattern| File.fnmatch?(pattern, child) }
-    end
-
-    def directory?
-      Puppet::FileSystem.send(stat_method, path).directory?
-    rescue Errno::ENOENT, Errno::EACCES
-      false
-    end
-  end
-
-  # Pull the recursion logic into one place.  It's moderately hairy, and this
-  # allows us to keep the hairiness apart from what we do with the files.
-  def perform_recursion
-    current_dirs = [FileSetEntry.new(0, @path, @ignore, @stat_method)]
-
-    result = []
-
-    while entry = current_dirs.shift
-      if continue_recursion_at?(entry.depth + 1)
-        entry.children.each do |child|
-          result << child.path
-          current_dirs << child
-        end
-      end
-    end
-
-    result
-  end
-
-  def valid?(path)
-    Puppet::FileSystem.send(@stat_method, path)
-    true
-  rescue Errno::ENOENT, Errno::EACCES
-    false
-  end
-
-  def continue_recursion_at?(depth)
-    # recurse if told to, and infinite recursion or current depth not at the limit
-    self.recurse && (self.recurselimit == :infinite || depth <= self.recurselimit)
-  end
-end

data/vendored/puppet/lib/puppet/file_serving/http_metadata.rb

@@ -1,46 +0,0 @@
-require 'puppet/file_serving/metadata'
-
-# Simplified metadata representation, suitable for the information
-# that is available from HTTP headers.
-class Puppet::FileServing::HttpMetadata < Puppet::FileServing::Metadata
-
-  def initialize(http_response, path = '/dev/null')
-    super(path)
-
-    # ignore options that do not apply to HTTP metadata
-    @owner = @group = @mode = nil
-
-    # hash available checksums for eventual collection
-    @checksums = {}
-    # use a default mtime in case there is no usable HTTP header
-    @checksums[:mtime] = "{mtime}#{Time.now}"
-
-    if checksum = http_response['content-md5']
-      # convert base64 digest to hex
-      checksum = checksum.unpack("m0").first.unpack("H*").first
-      @checksums[:md5] = "{md5}#{checksum}"
-    end
-
-    if last_modified = http_response['last-modified']
-      mtime = DateTime.httpdate(last_modified).to_time
-      @checksums[:mtime] = "{mtime}#{mtime.utc}"
-    end
-
-    @ftype = 'file'
-
-    self
-  end
-
-  # Override of the parent class method. Does not call super!
-  # We can only return metadata that was extracted from the
-  # HTTP headers during #initialize.
-  def collect
-    # Prefer the checksum_type from the indirector request options
-    # but fall back to the alternative otherwise
-    [ @checksum_type, :md5, :sha256, :sha384, :sha512, :sha224, :mtime ].each do |type|
-      @checksum_type = type
-      @checksum = @checksums[type]
-      return if @checksum
-    end
-  end
-end

data/vendored/puppet/lib/puppet/file_serving/metadata.rb

@@ -1,164 +0,0 @@
-require 'puppet'
-require 'puppet/indirector'
-require 'puppet/file_serving'
-require 'puppet/file_serving/base'
-require 'puppet/util/checksums'
-require 'uri'
-
-# A class that handles retrieving file metadata.
-class Puppet::FileServing::Metadata < Puppet::FileServing::Base
-
-  include Puppet::Util::Checksums
-
-  extend Puppet::Indirector
-  indirects :file_metadata, :terminus_class => :selector
-
-  attr_reader :path, :owner, :group, :mode, :checksum_type, :checksum, :ftype, :destination, :source_permissions, :content_uri
-
-  PARAM_ORDER = [:mode, :ftype, :owner, :group]
-
-  def checksum_type=(type)
-    raise(ArgumentError, _("Unsupported checksum type %{type}") % { type: type }) unless Puppet::Util::Checksums.respond_to?("#{type}_file")
-
-    @checksum_type = type
-  end
-
-  def source_permissions=(source_permissions)
-    raise(ArgumentError, _("Unsupported source_permission %{source_permissions}") % { source_permissions: source_permissions }) unless [:use, :use_when_creating, :ignore].include?(source_permissions.intern)
-
-    @source_permissions = source_permissions.intern
-  end
-
-  def content_uri=(path)
-    begin
-      uri = URI.parse(Puppet::Util.uri_encode(path))
-    rescue URI::InvalidURIError => detail
-      raise(ArgumentError, _("Could not understand URI %{path}: %{detail}") % { path: path, detail: detail })
-    end
-    raise(ArgumentError, _("Cannot use opaque URLs '%{path}'") % { path: path }) unless uri.hierarchical?
-    raise(ArgumentError, _("Must use URLs of type puppet as content URI")) if uri.scheme != "puppet"
-
-    @content_uri = path.encode(Encoding::UTF_8)
-  end
-
-  class MetaStat
-    extend Forwardable
-
-    def initialize(stat, source_permissions)
-      @stat = stat
-      @source_permissions_ignore = (!source_permissions || source_permissions == :ignore)
-    end
-
-    def owner
-      @source_permissions_ignore ? Process.euid : @stat.uid
-    end
-
-    def group
-      @source_permissions_ignore ? Process.egid : @stat.gid
-    end
-
-    def mode
-      @source_permissions_ignore ? 0644 : @stat.mode
-    end
-
-    def_delegators :@stat, :ftype
-  end
-
-  class WindowsStat < MetaStat
-    if Puppet::Util::Platform.windows?
-      require 'puppet/util/windows/security'
-    end
-
-    def initialize(stat, path, source_permissions)
-      super(stat, source_permissions)
-      @path = path
-      raise(ArgumentError, _("Unsupported Windows source permissions option %{source_permissions}") % { source_permissions: source_permissions }) unless @source_permissions_ignore
-    end
-
-    { :owner => 'S-1-5-32-544',
-      :group => 'S-1-0-0',
-      :mode => 0644
-    }.each do |method, default_value|
-      define_method method do
-        return default_value
-      end
-    end
-  end
-
-  def collect_stat(path)
-    stat = stat()
-
-    if Puppet::Util::Platform.windows?
-      WindowsStat.new(stat, path, @source_permissions)
-    else
-      MetaStat.new(stat, @source_permissions)
-    end
-  end
-
-  # Retrieve the attributes for this file, relative to a base directory.
-  # Note that Puppet::FileSystem.stat(path) raises Errno::ENOENT
-  # if the file is absent and this method does not catch that exception.
-  def collect(source_permissions = nil)
-    real_path = full_path
-
-    stat = collect_stat(real_path)
-    @owner = stat.owner
-    @group = stat.group
-    @ftype = stat.ftype
-
-    # We have to mask the mode, yay.
-    @mode = stat.mode & 007777
-
-    case stat.ftype
-    when "file"
-      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s
-    when "directory" # Always just timestamp the directory.
-      @checksum_type = "ctime"
-      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", path).to_s
-    when "link"
-      @destination = Puppet::FileSystem.readlink(real_path)
-      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s rescue nil
-    else
-      raise ArgumentError, _("Cannot manage files of type %{file_type}") % { file_type: stat.ftype }
-    end
-  end
-
-  def initialize(path,data={})
-    @owner       = data.delete('owner')
-    @group       = data.delete('group')
-    @mode        = data.delete('mode')
-    if checksum = data.delete('checksum')
-      @checksum_type = checksum['type']
-      @checksum      = checksum['value']
-    end
-    @checksum_type ||= Puppet[:digest_algorithm]
-    @ftype       = data.delete('type')
-    @destination = data.delete('destination')
-    @source      = data.delete('source')
-    @content_uri = data.delete('content_uri')
-
-    super(path, data.map { |k, v| [k.to_sym, v] }.to_h)
-  end
-
-  def to_data_hash
-    super.update(
-      {
-        'owner'        => owner,
-        'group'        => group,
-        'mode'         => mode,
-        'checksum'     => {
-          'type'   => checksum_type,
-          'value'  => checksum
-        },
-        'type'         => ftype,
-        'destination'  => destination,
-      }.merge(content_uri ? {'content_uri' => content_uri} : {})
-       .merge(source ? {'source' => source} : {})
-    )
-  end
-
-  def self.from_data_hash(data)
-    new(data.delete('path'), data)
-  end
-
-end

data/vendored/puppet/lib/puppet/file_serving/mount.rb

@@ -1,39 +0,0 @@
-require 'puppet/network/authstore'
-require 'puppet/util/logging'
-require 'puppet/file_serving'
-require 'puppet/file_serving/metadata'
-require 'puppet/file_serving/content'
-
-# Broker access to the filesystem, converting local URIs into metadata
-# or content objects.
-class Puppet::FileServing::Mount < Puppet::Network::AuthStore
-  include Puppet::Util::Logging
-
-  attr_reader :name
-
-  def find(path, options)
-    raise NotImplementedError
-  end
-
-  # Create our object.  It must have a name.
-  def initialize(name)
-    unless name =~ %r{^[-\w]+$}
-      raise ArgumentError, _("Invalid mount name format '%{name}'") % { name: name }
-    end
-    @name = name
-
-    super()
-  end
-
-  def search(path, options)
-    raise NotImplementedError
-  end
-
-  def to_s
-    "mount[#{@name}]"
-  end
-
-  # A noop.
-  def validate
-  end
-end