bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,201 @@
+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
+
+  # Specify where a specific ca file should be stored.
+  def self.store_ca_at(setting)
+    @ca_setting = setting
+  end
+
+  class << self
+    attr_reader :directory_setting, :file_setting, :ca_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
+
+  # The full path to a ca file we would be managing.
+  def self.ca_location
+    return nil unless ca_setting
+    Puppet.settings[ca_setting]
+  end
+
+  # We assume that all files named 'ca' are pointing to individual ca files,
+  # rather than normal host files.  It's a bit hackish, but all the other
+  # solutions seemed even more hackish.
+  def ca?(name)
+    name == Puppet::SSL::Host.ca_name
+  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 ca?(name) and ca_location
+      ca_location
+    elsif 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
+
+  def ca_location
+    self.class.ca_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
+
+    # Serialization of:
+    # Puppet::SSL::Certificate by Puppet::SSL::Certificate::Ca, Puppet::SSL::Certificate::File
+    # -----BEGIN CERTIFICATE-----
+    # Puppet::SSL::Key by Puppet::SSL::Key::Ca, Puppet::SSL::Key::File
+    # -----BEGIN RSA PRIVATE KEY-----
+    if ca?(name) and ca_location
+      Puppet.settings.setting(self.class.ca_setting).open('w:ASCII') { |f| yield f }
+    # Serialization of:
+    # Puppet::SSL::CertificateRevocationList by Puppet::SSL::CertificateRevocationList::Ca, Puppet::SSL::CertificateRevocationList::File
+    # -----BEGIN X509 CRL-----
+    elsif file_location
+      Puppet.settings.setting(self.class.file_setting).open('w:ASCII') { |f| yield f }
+    # Serialization of:
+    # Puppet::SSL::Certificate by Puppet::SSL::Certificate::Ca, Puppet::SSL::Certificate::File
+    # -----BEGIN CERTIFICATE-----
+    # Puppet::SSL::CertificateRequest by Puppet::SSL::CertificateRequest::Ca, Puppet::SSL::CertificateRequest::File
+    # -----BEGIN CERTIFICATE REQUEST-----
+    # Puppet::SSL::Key by Puppet::SSL::Key::Ca, Puppet::SSL::Key::File
+    # -----BEGIN RSA PRIVATE KEY-----
+    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

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

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

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

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

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

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

@@ -0,0 +1,63 @@
+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 fix(Puppet::Util::Yaml.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|
+      fix(Puppet::Util::Yaml.load_file(file))
+    end
+  end
+
+  protected
+
+  def fix(object)
+    object
+  end
+end