bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/file_bucket/file.rb

@@ -1,129 +0,0 @@
-require 'puppet/file_bucket'
-require 'puppet/indirector'
-require 'puppet/util/checksums'
-require 'digest/md5'
-require 'stringio'
-
-class Puppet::FileBucket::File
-  # This class handles the abstract notion of a file in a filebucket.
-  # There are mechanisms to save and load this file locally and remotely in puppet/indirector/filebucketfile/*
-  # There is a compatibility class that emulates pre-indirector filebuckets in Puppet::FileBucket::Dipper
-  extend Puppet::Indirector
-  indirects :file_bucket_file, :terminus_class => :selector
-
-  attr :bucket_path
-
-  def self.supported_formats
-    [:binary]
-  end
-
-  def initialize(contents, options = {})
-    case contents
-    when String
-      @contents = StringContents.new(contents)
-    when Pathname
-      @contents = FileContents.new(contents)
-    else
-      raise ArgumentError.new(_("contents must be a String or Pathname, got a %{contents_class}") % { contents_class: contents.class })
-    end
-
-    @bucket_path = options.delete(:bucket_path)
-    @checksum_type = Puppet[:digest_algorithm].to_sym
-    raise ArgumentError.new(_("Unknown option(s): %{opts}") % { opts: options.keys.join(', ') }) unless options.empty?
-  end
-
-  # @return [Num] The size of the contents
-  def size
-    @contents.size()
-  end
-
-  # @return [IO] A stream that reads the contents
-  def stream(&block)
-    @contents.stream(&block)
-  end
-
-  def checksum_type
-    @checksum_type.to_s
-  end
-
-  def checksum
-    "{#{checksum_type}}#{checksum_data}"
-  end
-
-  def checksum_data
-    @checksum_data ||= @contents.checksum_data(@checksum_type)
-  end
-
-  def to_s
-    to_binary
-  end
-
-  def to_binary
-    @contents.to_binary
-  end
-
-  def contents
-    to_binary
-  end
-
-  def name
-    "#{checksum_type}/#{checksum_data}"
-  end
-
-  def self.from_binary(contents)
-    self.new(contents)
-  end
-
-  class StringContents
-    def initialize(content)
-      @contents = content;
-    end
-
-    def stream(&block)
-      s = StringIO.new(@contents)
-      begin
-        block.call(s)
-      ensure
-        s.close
-      end
-    end
-
-    def size
-      @contents.size
-    end
-
-    def checksum_data(base_method)
-      Puppet.info(_("Computing checksum on string"))
-      Puppet::Util::Checksums.method(base_method).call(@contents)
-    end
-
-    def to_binary
-      # This is not so horrible as for FileContent, but still possible to mutate the content that the
-      # checksum is based on... so semi horrible...
-      return @contents;
-    end
-  end
-
-  class FileContents
-    def initialize(path)
-      @path = path
-    end
-
-    def stream(&block)
-      Puppet::FileSystem.open(@path, nil, 'rb', &block)
-    end
-
-    def size
-      Puppet::FileSystem.size(@path)
-    end
-
-    def checksum_data(base_method)
-      Puppet.info(_("Computing checksum on file %{path}") % { path: @path })
-      Puppet::Util::Checksums.method(:"#{base_method}_file").call(@path)
-    end
-
-    def to_binary
-      Puppet::FileSystem::binread(@path)
-    end
-  end
-end

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

@@ -1,3 +0,0 @@
-# Just a stub class.
-class Puppet::FileServing # :nodoc:
-end

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

@@ -1,86 +0,0 @@
-require 'puppet/file_serving'
-require 'puppet/util'
-require 'puppet/util/methodhelper'
-
-# The base class for Content and Metadata; provides common
-# functionality like the behaviour around links.
-class Puppet::FileServing::Base
-  include Puppet::Util::MethodHelper
-
-  # This is for external consumers to store the source that was used
-  # to retrieve the metadata.
-  attr_accessor :source
-
-  # Does our file exist?
-  def exist?
-      stat
-      return true
-  rescue
-      return false
-  end
-
-  # Return the full path to our file.  Fails if there's no path set.
-  def full_path
-    if relative_path.nil? or relative_path == "" or relative_path == "."
-      full_path = path
-    else
-      full_path = File.join(path, relative_path)
-    end
-
-    if Puppet.features.microsoft_windows?
-      # Replace multiple slashes as long as they aren't at the beginning of a filename
-      full_path.gsub(%r{(./)/+}, '\1')
-    else
-      full_path.gsub(%r{//+}, '/')
-    end
-  end
-
-  def initialize(path, options = {})
-    self.path = path
-    @links = :manage
-    set_options(options)
-  end
-
-  # Determine how we deal with links.
-  attr_reader :links
-  def links=(value)
-    value = value.to_sym
-    value = :manage if value == :ignore
-    #TRANSLATORS ':link', ':manage', ':follow' should not be translated
-    raise(ArgumentError, _(":links can only be set to :manage or :follow")) unless [:manage, :follow].include?(value)
-    @links = value
-  end
-
-  # Set our base path.
-  attr_reader :path
-  def path=(path)
-    raise ArgumentError.new(_("Paths must be fully qualified")) unless Puppet::FileServing::Base.absolute?(path)
-    @path = path
-  end
-
-  # Set a relative path; this is used for recursion, and sets
-  # the file's path relative to the initial recursion point.
-  attr_reader :relative_path
-  def relative_path=(path)
-    raise ArgumentError.new(_("Relative paths must not be fully qualified")) if Puppet::FileServing::Base.absolute?(path)
-    @relative_path = path
-  end
-
-  # Stat our file, using the appropriate link-sensitive method.
-  def stat
-    @stat_method ||= self.links == :manage ? :lstat : :stat
-    Puppet::FileSystem.send(@stat_method, full_path)
-  end
-
-  def to_data_hash
-    {
-      'path'          => @path,
-      'relative_path' => @relative_path,
-      'links'         => @links.to_s
-    }
-  end
-
-  def self.absolute?(path)
-    Puppet::Util.absolute_path?(path, :posix) or (Puppet.features.microsoft_windows? and Puppet::Util.absolute_path?(path, :windows))
-  end
-end

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

@@ -1,115 +0,0 @@
-require 'puppet'
-require 'puppet/file_serving'
-require 'puppet/file_serving/mount'
-require 'puppet/file_serving/mount/file'
-require 'puppet/file_serving/mount/modules'
-require 'puppet/file_serving/mount/plugins'
-require 'puppet/file_serving/mount/locales'
-require 'puppet/file_serving/mount/pluginfacts'
-require 'puppet/file_serving/mount/tasks'
-
-class Puppet::FileServing::Configuration
-  require 'puppet/file_serving/configuration/parser'
-
-  def self.configuration
-    @configuration ||= new
-  end
-
-  Mount = Puppet::FileServing::Mount
-
-  private_class_method  :new
-
-  attr_reader :mounts
-  #private :mounts
-
-  # Find the right mount.  Does some shenanigans to support old-style module
-  # mounts.
-  def find_mount(mount_name, environment)
-    # Reparse the configuration if necessary.
-    readconfig
-    # This can be nil.
-    mounts[mount_name]
-  end
-
-  def initialize
-    @mounts = {}
-    @config_file = nil
-
-    # We don't check to see if the file is modified the first time,
-    # because we always want to parse at first.
-    readconfig(false)
-  end
-
-  # Is a given mount available?
-  def mounted?(name)
-    @mounts.include?(name)
-  end
-
-  # Split the path into the separate mount point and path.
-  def split_path(request)
-    # Reparse the configuration if necessary.
-    readconfig
-
-    mount_name, path = request.key.split(File::Separator, 2)
-
-    raise(ArgumentError, _("Cannot find file: Invalid mount '%{mount_name}'") % { mount_name: mount_name }) unless mount_name =~ %r{^[-\w]+$}
-    raise(ArgumentError, _("Cannot find file: Invalid relative path '%{path}'") % { path: path }) if path and path.split('/').include?('..')
-
-    return nil unless mount = find_mount(mount_name, request.environment)
-    if mount.name == "modules" and mount_name != "modules"
-      # yay backward-compatibility
-      path = "#{mount_name}/#{path}"
-    end
-
-    if path == ""
-      path = nil
-    elsif path
-      # Remove any double slashes that might have occurred
-      path = path.gsub(/\/+/, "/")
-    end
-
-    return mount, path
-  end
-
-  def umount(name)
-    @mounts.delete(name) if @mounts.include? name
-  end
-
-  private
-
-  def mk_default_mounts
-    @mounts["modules"] ||= Mount::Modules.new("modules")
-    @mounts["modules"].allow('*') if @mounts["modules"].empty?
-    @mounts["plugins"] ||= Mount::Plugins.new("plugins")
-    @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
-    @mounts["locales"] ||= Mount::Locales.new("locales")
-    @mounts["locales"].allow('*') if @mounts["locales"].empty?
-    @mounts["pluginfacts"] ||= Mount::PluginFacts.new("pluginfacts")
-    @mounts["pluginfacts"].allow('*') if @mounts["pluginfacts"].empty?
-    @mounts["tasks"] ||= Mount::Tasks.new("tasks")
-    @mounts["tasks"].allow('*') if @mounts["tasks"].empty?
-  end
-
-  # Read the configuration file.
-  def readconfig(check = true)
-    config = Puppet[:fileserverconfig]
-
-    return unless Puppet::FileSystem.exist?(config)
-
-    @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
-
-    return if check and ! @parser.changed?
-
-    # Don't assign the mounts hash until we're sure the parsing succeeded.
-    begin
-      newmounts = @parser.parse
-      @mounts = newmounts
-    rescue => detail
-      Puppet.log_exception(detail, _("Error parsing fileserver configuration: %{detail}; using old configuration") % { detail: detail })
-    end
-
-  ensure
-    # Make sure we've got our plugins and modules.
-    mk_default_mounts
-  end
-end

data/vendored/puppet/lib/puppet/file_serving/configuration/parser.rb

@@ -1,137 +0,0 @@
-require 'puppet/file_serving/configuration'
-require 'puppet/util/watched_file'
-
-class Puppet::FileServing::Configuration::Parser
-  Mount = Puppet::FileServing::Mount
-  MODULES = 'modules'
-
-  # Parse our configuration file.
-  def parse
-    raise(_("File server configuration %{config_file} does not exist") % { config_file: @file }) unless Puppet::FileSystem.exist?(@file)
-    raise(_("Cannot read file server configuration %{config_file}") % { config_file: @file }) unless FileTest.readable?(@file)
-
-    @mounts = {}
-    @count = 0
-
-    File.open(@file) do |f|
-      mount = nil
-      f.each_line do |line|
-        # Have the count increment at the top, in case we throw exceptions.
-        @count += 1
-
-        case line
-        when /^\s*#/; next # skip comments
-        when /^\s*$/; next # skip blank lines
-        when /\[([-\w]+)\]/
-          mount = newmount($1)
-        when /^\s*(\w+)\s+(.+?)(\s*#.*)?$/
-          var = $1
-          value = $2
-          value.strip!
-          raise(ArgumentError, _("Fileserver configuration file does not use '=' as a separator")) if value =~ /^=/
-          case var
-          when "path"
-            path(mount, value)
-          when "allow"
-            allow(mount, value)
-          when "deny"
-            deny(mount, value)
-          else
-            error_location_str = Puppet::Util::Errors.error_location(@file.filename, @count)
-            raise ArgumentError.new(_("Invalid argument '%{var}' at %{error_location}") %
-                                        { var: var, error_location: error_location_str })
-          end
-        else
-          error_location_str = Puppet::Util::Errors.error_location(@file.filename, @count)
-          raise ArgumentError.new(_("Invalid entry at %{error_location}: '%{file_text}'") %
-                                      { file_text: line.chomp, error_location: error_location_str })
-        end
-      end
-    end
-
-    validate
-
-    @mounts
-  end
-
-  def initialize(filename)
-    @file = Puppet::Util::WatchedFile.new(filename)
-  end
-
-  def changed?
-    @file.changed?
-  end
-
-  private
-
-  # Allow a given pattern access to a mount.
-  def allow(mount, value)
-    value.split(/\s*,\s*/).each { |val|
-      begin
-        mount.info _("allowing %{val} access") % { val: val }
-        mount.allow(val)
-      rescue Puppet::AuthStoreError => detail
-        error_location_str = Puppet::Util::Errors.error_location(@file, @count)
-        raise ArgumentError.new("%{detail} %{error_location}" %
-                                    { detail: detail.to_s, error_location: error_location_str })
-      end
-    }
-  end
-
-  # Deny a given pattern access to a mount.
-  def deny(mount, value)
-    value.split(/\s*,\s*/).each { |val|
-      begin
-        mount.info _("denying %{val} access") % { val: val }
-        mount.deny(val)
-      rescue Puppet::AuthStoreError => detail
-        error_location_str = Puppet::Util::Errors.error_location(@file, @count)
-        raise ArgumentError.new("%{detail} %{error_location}" %
-                                    { detail: detail.to_s, error_location: error_location_str  })
-      end
-    }
-  end
-
-  # Create a new mount.
-  def newmount(name)
-    if @mounts.include?(name)
-      error_location_str = Puppet::Util::Errors.error_location(@file, @count)
-      raise ArgumentError.new(_("%{mount} is already mounted at %{name} at %{error_location}") %
-                                  { mount: @mounts[name], name: name, error_location: error_location_str })
-    end
-    case name
-    when "modules"
-      mount = Mount::Modules.new(name)
-    when "plugins"
-      mount = Mount::Plugins.new(name)
-    when "tasks"
-      mount = Mount::Tasks.new(name)
-    when "locales"
-      mount = Mount::Locales.new(name)
-    else
-      mount = Mount::File.new(name)
-    end
-    @mounts[name] = mount
-    mount
-  end
-
-  # Set the path for a mount.
-  def path(mount, value)
-    if mount.respond_to?(:path=)
-      begin
-        mount.path = value
-      rescue ArgumentError => detail
-        Puppet.log_exception(detail, _("Removing mount \"%{mount}\": %{detail}") % { mount: mount.name, detail: detail })
-        @mounts.delete(mount.name)
-      end
-    else
-      Puppet.warning _("The '%{mount}' module can not have a path. Ignoring attempt to set it") % { mount: mount.name }
-    end
-  end
-
-  # Make sure all of our mounts are valid.  We have to do this after the fact
-  # because details are added over time as the file is parsed.
-  def validate
-    @mounts.each { |name, mount| mount.validate }
-  end
-end