bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/indirector/ssl_file.rb

@@ -1,160 +0,0 @@
-require 'puppet/ssl'
-
-class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
-  # Specify the directory in which multiple files are stored.
-  def self.store_in(setting)
-    @directory_setting = setting
-  end
-
-  # Specify a single file location for storing just one file.
-  # This is used for things like the CRL.
-  def self.store_at(setting)
-    @file_setting = setting
-  end
-
-  class << self
-    attr_reader :directory_setting, :file_setting
-  end
-
-  # The full path to where we should store our files.
-  def self.collection_directory
-    return nil unless directory_setting
-    Puppet.settings[directory_setting]
-  end
-
-  # The full path to an individual file we would be managing.
-  def self.file_location
-    return nil unless file_setting
-    Puppet.settings[file_setting]
-  end
-
-  def initialize
-    Puppet.settings.use(:main, :ssl)
-
-    (collection_directory || file_location) or raise Puppet::DevError, _("No file or directory setting provided; terminus %{class_name} cannot function") % { class_name: self.class.name }
-  end
-
-  def path(name)
-    if name =~ Puppet::Indirector::BadNameRegexp then
-      Puppet.crit(_("directory traversal detected in %{indirection}: %{name}") % { indirection: self.class, name: name.inspect })
-      raise ArgumentError, _("invalid key")
-    end
-
-    if collection_directory
-      File.join(collection_directory, name.to_s + ".pem")
-    else
-      file_location
-    end
-  end
-
-  # Remove our file.
-  def destroy(request)
-    path = Puppet::FileSystem.pathname(path(request.key))
-    return false unless Puppet::FileSystem.exist?(path)
-
-    Puppet.notice _("Removing file %{model} %{request} at '%{path}'") % { model: model, request: request.key, path: path }
-    begin
-      Puppet::FileSystem.unlink(path)
-    rescue => detail
-      raise Puppet::Error, _("Could not remove %{request}: %{detail}") % { request: request.key, detail: detail }, detail.backtrace
-    end
-  end
-
-  # Find the file on disk, returning an instance of the model.
-  def find(request)
-    filename = rename_files_with_uppercase(path(request.key))
-
-    filename ? create_model(request.key, filename) : nil
-  end
-
-  # Save our file to disk.
-  def save(request)
-    path = path(request.key)
-    dir = File.dirname(path)
-
-    raise Puppet::Error.new(_("Cannot save %{request}; parent directory %{dir} does not exist") % { request: request.key, dir: dir }) unless FileTest.directory?(dir)
-    raise Puppet::Error.new(_("Cannot save %{request}; parent directory %{dir} is not writable") % { request: request.key, dir: dir }) unless FileTest.writable?(dir)
-
-    write(request.key, path) { |f| f.print request.instance.to_s }
-  end
-
-  # Search for more than one file.  At this point, it just returns
-  # an instance for every file in the directory.
-  def search(request)
-    dir = collection_directory
-    Dir.entries(dir).
-      select  { |file| file =~ /\.pem$/ }.
-      collect { |file| create_model(file.sub(/\.pem$/, ''), File.join(dir, file)) }.
-      compact
-  end
-
-  private
-
-  def create_model(name, path)
-    result = model.new(name)
-    # calls Puppet::SSL::Base#read for subclasses of Puppet::SSL::Base
-    # with the exception of any overrides, like Puppet::SSL::Key
-    result.read(path)
-    result
-  end
-
-  # Demeterish pointers to class info.
-  def collection_directory
-    self.class.collection_directory
-  end
-
-  def file_location
-    self.class.file_location
-  end
-
-  # A hack method to deal with files that exist with a different case.
-  # Just renames it; doesn't read it in or anything.
-  # LAK:NOTE This is a copy of the method in sslcertificates/support.rb,
-  # which we'll be EOL'ing at some point.  This method was added at 20080702
-  # and should be removed at some point.
-  def rename_files_with_uppercase(file)
-    return file if Puppet::FileSystem.exist?(file)
-
-    dir, short = File.split(file)
-    return nil unless Puppet::FileSystem.exist?(dir)
-
-    raise ArgumentError, _("Tried to fix SSL files to a file containing uppercase") unless short.downcase == short
-    real_file = Dir.entries(dir).reject { |f| f =~ /^\./ }.find do |other|
-      other.downcase == short
-    end
-
-    return nil unless real_file
-
-    full_file = File.join(dir, real_file)
-
-    Puppet.deprecation_warning _("Automatic downcasing and renaming of ssl files is deprecated; please request the file using its correct case: %{full_file}") % { full_file: full_file }
-    File.rename(full_file, file)
-
-    file
-  end
-
-  # Yield a filehandle set up appropriately, either with our settings doing
-  # the work or opening a filehandle manually.
-  def write(name, path)
-    # All types serialized to disk contain only ASCII content:
-    # * SSL::Key may be a .export(OpenSSL::Cipher::DES.new(:EDE3, :CBC), pass) or .to_pem
-    # * All other classes are translated to strings by calling .to_pem
-
-    if file_location
-      Puppet.settings.setting(self.class.file_setting).open('w:ASCII') { |f| yield f }
-    elsif setting = self.class.directory_setting
-      begin
-        Puppet.settings.setting(setting).open_file(path, 'w:ASCII') { |f| yield f }
-      rescue => detail
-        raise Puppet::Error, _("Could not write %{path} to %{setting}: %{detail}") % { path: path, setting: setting, detail: detail }, detail.backtrace
-      end
-    else
-      raise Puppet::DevError, _("You must provide a setting to determine where the files are stored")
-    end
-  end
-end
-
-# LAK:NOTE This has to be at the end, because classes like SSL::Key use this
-# class, and this require statement loads those, which results in a load loop
-# and lots of failures.
-require 'puppet/ssl/host'

data/vendored/puppet/lib/puppet/indirector/status.rb

@@ -1,3 +0,0 @@
-# A stub class, so our constants work.
-class Puppet::Indirector::Status
-end

data/vendored/puppet/lib/puppet/indirector/status/local.rb

@@ -1,12 +0,0 @@
-require 'puppet/indirector/status'
-
-class Puppet::Indirector::Status::Local < Puppet::Indirector::Code
-
-  desc "Get status locally. Only used internally."
-
-  def find( *anything )
-    status = model.new
-    status.version= Puppet.version
-    status
-  end
-end

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

@@ -1,9 +0,0 @@
-require 'puppet/indirector/status'
-require 'puppet/indirector/rest'
-
-class Puppet::Indirector::Status::Rest < Puppet::Indirector::REST
-
-  desc "Get puppet master's status via REST. Useful because it tests the health
-    of both the web server and the indirector."
-
-end

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

@@ -1,30 +0,0 @@
-class Puppet::Indirector::StoreConfigs < Puppet::Indirector::Terminus
-  def initialize
-    super
-    # This will raise if the indirection can't be found, so we can assume it
-    # is always set to a valid instance from here on in.
-    @target = indirection.terminus Puppet[:storeconfigs_backend]
-  end
-
-  attr_reader :target
-
-  def head(request)
-    target.head request
-  end
-
-  def find(request)
-    target.find request
-  end
-
-  def search(request)
-    target.search request
-  end
-
-  def save(request)
-    target.save request
-  end
-
-  def destroy(request)
-    target.save request
-  end
-end

data/vendored/puppet/lib/puppet/indirector/terminus.rb

@@ -1,169 +0,0 @@
-require 'puppet/indirector'
-require 'puppet/indirector/errors'
-require 'puppet/indirector/indirection'
-require 'puppet/util/instance_loader'
-
-# A simple class that can function as the base class for indirected types.
-class Puppet::Indirector::Terminus
-  require 'puppet/util/docs'
-  extend Puppet::Util::Docs
-
-  class << self
-    include Puppet::Util::InstanceLoader
-
-    attr_accessor :name, :terminus_type
-    attr_reader :abstract_terminus, :indirection
-
-    # Are we an abstract terminus type, rather than an instance with an
-    # associated indirection?
-    def abstract_terminus?
-      abstract_terminus
-    end
-
-    # Convert a constant to a short name.
-    def const2name(const)
-      const.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
-    end
-
-    # Look up the indirection if we were only provided a name.
-    def indirection=(name)
-      if name.is_a?(Puppet::Indirector::Indirection)
-        @indirection = name
-      elsif ind = Puppet::Indirector::Indirection.instance(name)
-        @indirection = ind
-      else
-        raise ArgumentError, _("Could not find indirection instance %{name} for %{terminus}") % { name: name, terminus: self.name }
-      end
-    end
-
-    def indirection_name
-      @indirection.name
-    end
-
-    # Register our subclass with the appropriate indirection.
-    # This follows the convention that our terminus is named after the
-    # indirection.
-    def inherited(subclass)
-      longname = subclass.to_s
-      if longname =~ /#<Class/
-        raise Puppet::DevError, _("Terminus subclasses must have associated constants")
-      end
-      names = longname.split("::")
-
-      # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.
-      name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
-
-      subclass.name = name
-
-      # Short-circuit the abstract types, which are those that directly subclass
-      # the Terminus class.
-      if self == Puppet::Indirector::Terminus
-        subclass.mark_as_abstract_terminus
-        return
-      end
-
-      # Set the terminus type to be the name of the abstract terminus type.
-      # Yay, class/instance confusion.
-      subclass.terminus_type = self.name
-
-      # This subclass is specifically associated with an indirection.
-      raise("Invalid name #{longname}") unless names.length > 0
-      processed_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }
-
-      if processed_name.empty?
-        raise Puppet::DevError, _("Could not discern indirection model from class constant")
-      end
-
-      # This will throw an exception if the indirection instance cannot be found.
-      # Do this last, because it also registers the terminus type with the indirection,
-      # which needs the above information.
-      subclass.indirection = processed_name.intern
-
-      # And add this instance to the instance hash.
-      Puppet::Indirector::Terminus.register_terminus_class(subclass)
-    end
-
-    # Mark that this instance is abstract.
-    def mark_as_abstract_terminus
-      @abstract_terminus = true
-    end
-
-    def model
-      indirection.model
-    end
-
-    # Convert a short name to a constant.
-    def name2const(name)
-      name.to_s.capitalize.sub(/_(.)/) { |i| $1.upcase }
-    end
-
-    # Register a class, probably autoloaded.
-    def register_terminus_class(klass)
-      setup_instance_loading klass.indirection_name
-      instance_hash(klass.indirection_name)[klass.name] = klass
-    end
-
-    # Return a terminus by name, using the autoloader.
-    def terminus_class(indirection_name, terminus_type)
-      setup_instance_loading indirection_name
-      loaded_instance(indirection_name, terminus_type)
-    end
-
-    # Return all terminus classes for a given indirection.
-    def terminus_classes(indirection_name)
-      setup_instance_loading indirection_name
-      instance_loader(indirection_name).files_to_load(Puppet.lookup(:current_environment)).map do |file|
-        File.basename(file).chomp(".rb").intern
-      end
-    end
-
-    private
-
-    def setup_instance_loading(type)
-      instance_load type, "puppet/indirector/#{type}" unless instance_loading?(type)
-    end
-  end
-
-  def indirection
-    self.class.indirection
-  end
-
-  def initialize
-    raise Puppet::DevError, _("Cannot create instances of abstract terminus types") if self.class.abstract_terminus?
-  end
-
-  def model
-    self.class.model
-  end
-
-  def name
-    self.class.name
-  end
-
-  def allow_remote_requests?
-    true
-  end
-
-  def terminus_type
-    self.class.terminus_type
-  end
-
-  def validate(request)
-    if request.instance
-      validate_model(request)
-      validate_key(request)
-    end
-  end
-
-  def validate_key(request)
-    unless request.key == request.instance.name
-      raise Puppet::Indirector::ValidationError, _("Instance name %{name} does not match requested key %{key}") % { name: request.instance.name.inspect, key: request.key.inspect }
-    end
-  end
-
-  def validate_model(request)
-    unless model === request.instance
-      raise Puppet::Indirector::ValidationError, _("Invalid instance type %{klass}, expected %{model_type}") % { klass: request.instance.class.inspect, model_type: model.inspect }
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-require 'puppet/indirector/terminus'
-require 'puppet/util/yaml'
-
-# The base class for YAML indirection termini.
-class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
-  # Read a given name's file in and convert it from YAML.
-  def find(request)
-    file = path(request.key)
-    return nil unless Puppet::FileSystem.exist?(file)
-
-    begin
-      return load_file(file)
-    rescue Puppet::Util::Yaml::YamlLoadError => detail
-      raise Puppet::Error, _("Could not parse YAML data for %{indirection} %{request}: %{detail}") % { indirection: indirection.name, request: request.key, detail: detail }, detail.backtrace
-    end
-  end
-
-  # Convert our object to YAML and store it to the disk.
-  def save(request)
-    raise ArgumentError.new(_("You can only save objects that respond to :name")) unless request.instance.respond_to?(:name)
-
-    file = path(request.key)
-
-    basedir = File.dirname(file)
-
-    # This is quite likely a bad idea, since we're not managing ownership or modes.
-    Dir.mkdir(basedir) unless Puppet::FileSystem.exist?(basedir)
-
-    begin
-      Puppet::Util::Yaml.dump(request.instance, file)
-    rescue TypeError => detail
-      Puppet.err _("Could not save %{indirection} %{request}: %{detail}") % { indirection: self.name, request: request.key, detail: detail }
-    end
-  end
-
-  # Return the path to a given node's file.
-  def path(name,ext='.yaml')
-    if name =~ Puppet::Indirector::BadNameRegexp then
-      Puppet.crit(_("directory traversal detected in %{indirection}: %{name}") % { indirection: self.class, name: name.inspect })
-      raise ArgumentError, _("invalid key")
-    end
-
-    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
-    File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
-  end
-
-  def destroy(request)
-    file_path = path(request.key)
-    Puppet::FileSystem.unlink(file_path) if Puppet::FileSystem.exist?(file_path)
-  end
-
-  def search(request)
-    Dir.glob(path(request.key,'')).collect do |file|
-      load_file(file)
-    end
-  end
-
-  protected
-
-  def load_file(file)
-    Puppet::Util::Yaml.safe_load_file(file, [model, Symbol])
-  end
-end