bolt 0.19.1 → 0.20.0

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

@@ -1,75 +0,0 @@
-require 'puppet/indirector/terminus'
-require 'puppet/util'
-
-# The base class for JSON indirection terminus implementations.
-#
-# This should generally be preferred to the YAML base for any future
-# implementations, since it is faster and can load untrusted data safely.
-class Puppet::Indirector::JSON < Puppet::Indirector::Terminus
-  def find(request)
-    load_json_from_file(path(request.key), request.key)
-  end
-
-  def save(request)
-    filename = path(request.key)
-    FileUtils.mkdir_p(File.dirname(filename))
-
-    Puppet::Util.replace_file(filename, 0660) {|f| f.print to_json(request.instance).force_encoding(Encoding::BINARY) }
-  rescue TypeError => detail
-    Puppet.log_exception(detail, _("Could not save %{json} %{request}: %{detail}") % { json: self.name, request: request.key, detail: detail })
-  end
-
-  def destroy(request)
-    Puppet::FileSystem.unlink(path(request.key))
-  rescue => detail
-    unless detail.is_a? Errno::ENOENT
-      raise Puppet::Error, _("Could not destroy %{json} %{request}: %{detail}") % { json: self.name, request: request.key, detail: detail }, detail.backtrace
-    end
-    1                           # emulate success...
-  end
-
-  def search(request)
-    Dir.glob(path(request.key)).collect do |file|
-      load_json_from_file(file, request.key)
-    end
-  end
-
-  # Return the path to a given node's file.
-  def path(name, ext = '.json')
-    if name =~ Puppet::Indirector::BadNameRegexp then
-      Puppet.crit(_("directory traversal detected in %{json}: %{name}") % { json: self.class, name: name.inspect })
-      raise ArgumentError, _("invalid key")
-    end
-
-    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
-    File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
-  end
-
-  private
-
-  def load_json_from_file(file, key)
-    json = nil
-
-    begin
-      json = Puppet::FileSystem.read(file, :encoding => Encoding::BINARY)
-    rescue Errno::ENOENT
-      return nil
-    rescue => detail
-      raise Puppet::Error, _("Could not read JSON data for %{name} %{key}: %{detail}") % { name: indirection.name, key: key, detail: detail }, detail.backtrace
-    end
-
-    begin
-      return from_json(json)
-    rescue => detail
-      raise Puppet::Error, _("Could not parse JSON data for %{name} %{key}: %{detail}") % { name: indirection.name, key: key, detail: detail }, detail.backtrace
-    end
-  end
-
-  def from_json(text)
-    model.convert_from('json', text.force_encoding(Encoding::UTF_8))
-  end
-
-  def to_json(object)
-    object.render('json')
-  end
-end

data/vendored/puppet/lib/puppet/indirector/key/ca.rb

@@ -1,16 +0,0 @@
-require 'puppet/indirector/ssl_file'
-require 'puppet/ssl/key'
-
-class Puppet::SSL::Key::Ca < Puppet::Indirector::SslFile
-  desc "Manage the CA's private key on disk. This terminus works with the
-    CA key *only*, because that's the only key that the CA ever interacts
-    with."
-
-  store_in :privatekeydir
-
-  store_ca_at :cakey
-
-  def allow_remote_requests?
-    false
-  end
-end

data/vendored/puppet/lib/puppet/indirector/key/disabled_ca.rb

@@ -1,22 +0,0 @@
-require 'puppet/indirector/code'
-require 'puppet/ssl/key'
-
-class Puppet::SSL::Key::DisabledCa < Puppet::Indirector::Code
-  desc "Manage the CA private key, but reject any remote access
-to the SSL data store. Used when a master has an explicitly disabled CA to
-prevent clients getting confusing 'success' behaviour."
-
-  def initialize
-    @file = Puppet::SSL::Key.indirection.terminus(:file)
-  end
-
-  [:find, :head, :search, :save, :destroy].each do |name|
-    define_method(name) do |request|
-      if request.remote?
-        raise Puppet::Error, _("this master is not a CA")
-      else
-        @file.send(name, request)
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/indirector/key/file.rb

@@ -1,50 +0,0 @@
-require 'puppet/indirector/ssl_file'
-require 'puppet/ssl/key'
-
-class Puppet::SSL::Key::File < Puppet::Indirector::SslFile
-  desc "Manage SSL private and public keys on disk."
-
-  store_in :privatekeydir
-  store_ca_at :cakey
-
-  def allow_remote_requests?
-    false
-  end
-
-  # Where should we store the public key?
-  def public_key_path(name)
-    if ca?(name)
-      Puppet[:capub]
-    else
-      File.join(Puppet[:publickeydir], name.to_s + ".pem")
-    end
-  end
-
-  # Remove the public key, in addition to the private key
-  def destroy(request)
-    super
-
-    key_path = Puppet::FileSystem.pathname(public_key_path(request.key))
-    return unless Puppet::FileSystem.exist?(key_path)
-
-    begin
-      Puppet::FileSystem.unlink(key_path)
-    rescue => detail
-      raise Puppet::Error, _("Could not remove %{request} public key: %{detail}") % { request: request.key, detail: detail }, detail.backtrace
-    end
-  end
-
-  # Save the public key, in addition to the private key.
-  def save(request)
-    super
-
-    begin
-      # RFC 1421 states PEM is 7-bit ASCII https://tools.ietf.org/html/rfc1421
-      Puppet.settings.setting(:publickeydir).open_file(public_key_path(request.key), 'w:ASCII') do |f|
-        f.print request.instance.content.public_key.to_pem
-      end
-    rescue => detail
-      raise Puppet::Error, _("Could not write %{request}: %{detail}") % { request: request.key, detail: detail }, detail.backtrace
-    end
-  end
-end

data/vendored/puppet/lib/puppet/indirector/key/memory.rb

@@ -1,6 +0,0 @@
-require 'puppet/ssl/key'
-require 'puppet/indirector/memory'
-
-class Puppet::SSL::Key::Memory < Puppet::Indirector::Memory
-  desc "Store keys in memory. This is used for testing puppet."
-end

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

@@ -1,80 +0,0 @@
-require 'puppet/indirector/terminus'
-require 'puppet/util/ldap/connection'
-
-class Puppet::Indirector::Ldap < Puppet::Indirector::Terminus
-  # Perform our ldap search and process the result.
-  def find(request)
-    ldapsearch(search_filter(request.key)) { |entry| return process(entry) } || nil
-  end
-
-  # Process the found entry.  We assume that we don't just want the
-  # ldap object.
-  def process(entry)
-    raise Puppet::DevError, _("The 'process' method has not been overridden for the LDAP terminus for %{name}") % { name: self.name }
-  end
-
-  # Default to all attributes.
-  def search_attributes
-    nil
-  end
-
-  def search_base
-    Puppet[:ldapbase]
-  end
-
-  # The ldap search filter to use.
-  def search_filter(name)
-    raise Puppet::DevError, _("No search string set for LDAP terminus for %{name}") % { name: self.name }
-  end
-
-  # Find the ldap node, return the class list and parent node specially,
-  # and everything else in a parameter hash.
-  def ldapsearch(filter)
-    raise ArgumentError.new(_("You must pass a block to ldapsearch")) unless block_given?
-
-    found = false
-    count = 0
-
-    begin
-      connection.search(search_base, 2, filter, search_attributes) do |entry|
-        found = true
-        yield entry
-      end
-    rescue SystemExit,NoMemoryError
-      raise
-    rescue Exception => detail
-      if count == 0
-        # Try reconnecting to ldap if we get an exception and we haven't yet retried.
-        count += 1
-        @connection = nil
-        Puppet.warning _("Retrying LDAP connection")
-        retry
-      else
-        error = Puppet::Error.new(_("LDAP Search failed"))
-        error.set_backtrace(detail.backtrace)
-        raise error
-      end
-    end
-
-    found
-  end
-
-  # Create an ldap connection.
-  def connection
-    unless @connection
-      #TRANSLATORS "ruby/ldap libraries" are code dependencies
-      raise Puppet::Error, _("Could not set up LDAP Connection: Missing ruby/ldap libraries") unless Puppet.features.ldap?
-      begin
-        conn = Puppet::Util::Ldap::Connection.instance
-        conn.start
-        @connection = conn.connection
-      rescue => detail
-        message = _("Could not connect to LDAP: %{detail}") % { detail: detail }
-        Puppet.log_exception(detail, message)
-        raise Puppet::Error, message, detail.backtrace
-      end
-    end
-
-    @connection
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'puppet/indirector/terminus'
-
-# Manage a memory-cached list of instances.
-class Puppet::Indirector::Memory < Puppet::Indirector::Terminus
-  def initialize
-    clear
-  end
-
-  def clear
-    @instances = {}
-  end
-
-  def destroy(request)
-    raise ArgumentError.new(_("Could not find %{request} to destroy") % { request: request.key }) unless @instances.include?(request.key)
-    @instances.delete(request.key)
-  end
-
-  def find(request)
-    @instances[request.key]
-  end
-
-  def search(request)
-    found_keys = @instances.keys.find_all { |key| key.include?(request.key) }
-    found_keys.collect { |key| @instances[key] }
-  end
-
-  def head(request)
-    not find(request).nil?
-  end
-
-  def save(request)
-    @instances[request.key] = request.instance
-  end
-end

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

@@ -1,83 +0,0 @@
-require 'puppet/indirector/terminus'
-require 'puppet/util'
-
-# The base class for MessagePack indirection terminus implementations.
-#
-# This should generally be preferred to the PSON base for any future
-# implementations, since it is ~ 30 times faster
-class Puppet::Indirector::Msgpack < Puppet::Indirector::Terminus
-  def initialize(*args)
-    if ! Puppet.features.msgpack?
-      raise _("MessagePack terminus not supported without msgpack library")
-    end
-    super
-  end
-
-  def find(request)
-    load_msgpack_from_file(path(request.key), request.key)
-  end
-
-  def save(request)
-    filename = path(request.key)
-    FileUtils.mkdir_p(File.dirname(filename))
-
-    Puppet::Util.replace_file(filename, 0660) {|f| f.print to_msgpack(request.instance) }
-  rescue TypeError => detail
-    Puppet.log_exception(detail, _("Could not save %{name} %{request}: %{detail}") % { name: self.name, request: request.key, detail: detail })
-  end
-
-  def destroy(request)
-    Puppet::FileSystem.unlink(path(request.key))
-  rescue => detail
-    unless detail.is_a? Errno::ENOENT
-      raise Puppet::Error, _("Could not destroy %{name} %{request}: %{detail}") % { name: self.name, request: request.key, detail: detail }, detail.backtrace
-    end
-    1                           # emulate success...
-  end
-
-  def search(request)
-    Dir.glob(path(request.key)).collect do |file|
-      load_msgpack_from_file(file, request.key)
-    end
-  end
-
-  # Return the path to a given node's file.
-  def path(name, ext = '.msgpack')
-    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[:server_datadir] : Puppet[:client_datadir]
-    File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
-  end
-
-  private
-
-  def load_msgpack_from_file(file, key)
-    msgpack = nil
-
-    begin
-      msgpack = Puppet::FileSystem.read(file, :encoding => 'utf-8')
-    rescue Errno::ENOENT
-      return nil
-    rescue => detail
-      #TRANSLATORS "MessagePack" is a program name and should not be translated
-      raise Puppet::Error, _("Could not read MessagePack data for %{indirection} %{key}: %{detail}") % { indirection: indirection.name, key: key, detail: detail }, detail.backtrace
-    end
-
-    begin
-      return from_msgpack(msgpack)
-    rescue => detail
-      raise Puppet::Error, _("Could not parse MessagePack data for %{indirection} %{key}: %{detail}") % { indirection: indirection.name, key: key, detail: detail }, detail.backtrace
-    end
-  end
-
-  def from_msgpack(text)
-    model.convert_from('msgpack', text)
-  end
-
-  def to_msgpack(object)
-    object.render('msgpack')
-  end
-end

data/vendored/puppet/lib/puppet/indirector/node/exec.rb

@@ -1,71 +0,0 @@
-require 'puppet/node'
-require 'puppet/indirector/exec'
-
-class Puppet::Node::Exec < Puppet::Indirector::Exec
-  desc "Call an external program to get node information.  See
-  the [External Nodes](https://docs.puppetlabs.com/guides/external_nodes.html) page for more information."
-  include Puppet::Util
-
-  def command
-    command = Puppet[:external_nodes]
-    raise ArgumentError, _("You must set the 'external_nodes' parameter to use the external node terminus") unless command != _("none")
-    command.split
-  end
-
-  # Look for external node definitions.
-  def find(request)
-    output = super or return nil
-
-    # Translate the output to ruby.
-    result = translate(request.key, output)
-
-    facts = request.options[:facts].is_a?(Puppet::Node::Facts) ? request.options[:facts] : nil
-
-    # Set the requested environment if it wasn't overridden
-    # If we don't do this it gets set to the local default
-    result[:environment] ||= request.environment
-
-    create_node(request.key, result, facts)
-  end
-
-  private
-
-  # Proxy the execution, so it's easier to test.
-  def execute(command, arguments)
-    Puppet::Util::Execution.execute(command,arguments)
-  end
-
-  # Turn our outputted objects into a Puppet::Node instance.
-  def create_node(name, result, facts = nil)
-    node = Puppet::Node.new(name)
-    set = false
-    [:parameters, :classes, :environment].each do |param|
-      if value = result[param]
-        node.send(param.to_s + "=", value)
-        set = true
-      end
-    end
-
-    node.fact_merge(facts)
-    node
-  end
-
-  # Translate the yaml string into Ruby objects.
-  def translate(name, output)
-    YAML.load(output).inject({}) do |hash, data|
-      case data[0]
-      when String
-        hash[data[0].intern] = data[1]
-      when Symbol
-        hash[data[0]] = data[1]
-      else
-        raise Puppet::Error, _("key is a %{klass}, not a string or symbol") % { klass: data[0].class }
-      end
-
-      hash
-    end
-
-  rescue => detail
-      raise Puppet::Error, _("Could not load external node results for %{name}: %{detail}") % { name: name, detail: detail }, detail.backtrace
-  end
-end