bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,129 @@
+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

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

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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,137 @@
+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