bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/resource/type_collection.rb

@@ -1,263 +0,0 @@
-require 'puppet/parser/type_loader'
-require 'puppet/util/file_watcher'
-require 'puppet/util/warnings'
-
-# @api private
-class Puppet::Resource::TypeCollection
-  attr_reader :environment
-  attr_accessor :parse_failed
-
-  include Puppet::Util::Warnings
-
-  def clear
-    @hostclasses.clear
-    @definitions.clear
-    @applications.clear
-    @nodes.clear
-    @notfound.clear
-    @capability_mappings.clear
-    @sites.clear
-  end
-
-  def initialize(env)
-    @environment = env
-    @hostclasses = {}
-    @definitions = {}
-    @capability_mappings = {}
-    @applications = {}
-    @nodes = {}
-    @notfound = {}
-    @sites = []
-
-    # So we can keep a list and match the first-defined regex
-    @node_list = []
-  end
-
-  def import_ast(ast, modname)
-    ast.instantiate(modname).each do |instance|
-      add(instance)
-    end
-  end
-
-  def inspect
-    "TypeCollection" + {
-      :hostclasses => @hostclasses.keys,
-      :definitions => @definitions.keys,
-      :nodes => @nodes.keys,
-      :capability_mappings => @capability_mappings.keys,
-      :applications => @applications.keys,
-      :site => @sites[0] # todo, could be just a binary, this dumps the entire body (good while developing)
-    }.inspect
-  end
-
-  # @api private
-  def <<(thing)
-    add(thing)
-    self
-  end
-
-  def add(instance)
-    # return a merged instance, or the given
-    catch(:merged) {
-      send("add_#{instance.type}", instance)
-      instance.resource_type_collection = self
-      instance
-    }
-  end
-
-  def add_hostclass(instance)
-    handle_hostclass_merge(instance)
-    dupe_check(instance, @hostclasses) { |dupe| _("Class '%{klass}' is already defined%{error}; cannot redefine") % { klass: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @definitions) { |dupe| _("Definition '%{klass}' is already defined%{error}; cannot be redefined as a class") % { klass: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @applications) { |dupe| _("Application '%{klass}' is already defined%{error}; cannot be redefined as a class") % { klass: instance.name, error: dupe.error_context } }
-
-    @hostclasses[instance.name] = instance
-    instance
-  end
-
-  def handle_hostclass_merge(instance)
-    # Only main class (named '') can be merged (for purpose of merging top-scopes).
-    return instance unless instance.name == ''
-    if instance.type == :hostclass && (other = @hostclasses[instance.name]) && other.type == :hostclass
-      other.merge(instance)
-      # throw is used to signal merge - avoids dupe checks and adding it to hostclasses
-      throw :merged, other
-    end
-  end
-
-  # Replaces the known settings with a new instance (that must be named 'settings').
-  # This is primarily needed for testing purposes. Also see PUP-5954 as it makes 
-  # it illegal to merge classes other than the '' (main) class. Prior to this change
-  # settings where always merged rather than being defined from scratch for many testing scenarios
-  # not having a complete side effect free setup for compilation.
-  # 
-  def replace_settings(instance)
-    @hostclasses['settings'] = instance
-  end
-
-  def hostclass(name)
-    @hostclasses[munge_name(name)]
-  end
-
-  def add_node(instance)
-    dupe_check(instance, @nodes) { |dupe| _("Node '%{name}' is already defined%{error}; cannot redefine") % { name: instance.name, error: dupe.error_context } }
-
-    @node_list << instance
-    @nodes[instance.name] = instance
-    instance
-  end
-
-  def add_site(instance)
-    dupe_check_singleton(instance, @sites) { |dupe| _("Site is already defined%{error}; cannot redefine") % { error: dupe.error_context } }
-    @sites << instance
-    instance
-  end
-
-  def site(_)
-    @sites[0]
-  end
-
-  def loader
-    @loader ||= Puppet::Parser::TypeLoader.new(environment)
-  end
-
-  def node(name)
-    name = munge_name(name)
-
-    if node = @nodes[name]
-      return node
-    end
-
-    @node_list.each do |n|
-      next unless n.name_is_regex?
-      return n if n.match(name)
-    end
-    nil
-  end
-
-  def node_exists?(name)
-    @nodes[munge_name(name)]
-  end
-
-  def nodes?
-    @nodes.length > 0
-  end
-
-  def add_definition(instance)
-    dupe_check(instance, @hostclasses) { |dupe| _("'%{name}' is already defined%{error} as a class; cannot redefine as a definition") % { name: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @definitions) { |dupe| _("Definition '%{name}' is already defined%{error}; cannot be redefined") % { name: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @applications) { |dupe| _("'%{name}' is already defined%{error} as an application; cannot be redefined") % { name: instance.name, error: dupe.error_context } }
-    @definitions[instance.name] = instance
-  end
-
-  def add_capability_mapping(instance)
-    dupe_check(instance, @capability_mappings) { |dupe| _("'%{name}' is already defined%{error} as a class; cannot redefine as a mapping") % { name: instance.name, error: dupe.error_context } }
-    @capability_mappings[instance.name] = instance
-  end
-
-  def definition(name)
-    @definitions[munge_name(name)]
-  end
-
-  def add_application(instance)
-    dupe_check(instance, @hostclasses) { |dupe| _("'%{name}' is already defined%{error} as a class; cannot redefine as an application") % { name: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @definitions) { |dupe| _("'%{name}' is already defined%{error} as a definition; cannot redefine as an application") % { name: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @applications) { |dupe| _("'%{name}' is already defined%{error} as an application; cannot be redefined") % { name: instance.name, error: dupe.error_context } }
-    @applications[instance.name] = instance
-  end
-
-  def application(name)
-    @applications[munge_name(name)]
-  end
-
-  def find_node(name)
-    @nodes[munge_name(name)]
-  end
-
-  def find_site()
-    @sites[0]
-  end
-
-  def find_hostclass(name)
-    find_or_load(name, :hostclass)
-  end
-
-  def find_definition(name)
-    find_or_load(name, :definition)
-  end
-
-  def find_application(name)
-    find_or_load(name, :application)
-  end
-
-  # TODO: This implementation is wasteful as it creates a copy on each request
-  #
-  [:hostclasses, :nodes, :definitions, :capability_mappings,
-   :applications].each do |m|
-    define_method(m) do
-      instance_variable_get("@#{m}").dup
-    end
-  end
-
-  def parse_failed?
-    @parse_failed
-  end
-
-  def version
-    if !defined?(@version)
-      if environment.config_version.nil? || environment.config_version == ""
-        @version = Time.now.to_i
-      else
-        @version = Puppet::Util::Execution.execute([environment.config_version]).to_s.strip
-      end
-    end
-
-    @version
-  rescue Puppet::ExecutionFailure => e
-    raise Puppet::ParseError, _("Execution of config_version command `%{cmd}` failed: %{message}") % { cmd: environment.config_version, message: e.message }, e.backtrace
-  end
-
-  private
-
-  COLON_COLON = "::".freeze
-
-  # Resolve namespaces and find the given object.  Autoload it if
-  # necessary.
-  def find_or_load(name, type)
-    # Name is always absolute, but may start with :: which must be removed
-    fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
-
-    result = send(type, fqname)
-    unless result
-      if @notfound[ fqname ] && Puppet[ :ignoremissingtypes ]
-        # do not try to autoload if we already tried and it wasn't conclusive
-        # as this is a time consuming operation. Warn the user.
-        # Check first if debugging is on since the call to debug_once is expensive
-        if Puppet[:debug]
-          debug_once _("Not attempting to load %{type} %{fqname} as this object was missing during a prior compilation") % { type: type, fqname: fqname }
-        end
-      else
-        fqname = munge_name(fqname)
-        result = loader.try_load_fqname(type, fqname)
-        @notfound[ fqname ] = result.nil?
-      end
-    end
-    result
-  end
-
-  def munge_name(name)
-    name.to_s.downcase
-  end
-
-  def dupe_check(instance, hash)
-    return unless dupe = hash[instance.name]
-    message = yield dupe
-    instance.fail Puppet::ParseError, message
-  end
-
-  def dupe_check_singleton(instance, set)
-    return if set.empty?
-    message = yield set[0]
-    instance.fail Puppet::ParseError, message
-  end
-end

data/vendored/puppet/lib/puppet/rest/client.rb

@@ -1,83 +0,0 @@
-require 'httpclient'
-
-require 'puppet'
-require 'puppet/rest/response'
-require 'puppet/rest/errors'
-require 'puppet/util/ssl'
-
-module Puppet::Rest
-  class Client
-    attr_reader :dns_resolver
-
-    # Create a new HTTP client for querying the given API.
-    # @param [Puppet::Rest::SSLContext] ssl_context the SSL configuration for this client
-    # @param [Integer] receive_timeout how long in seconds this client will wait
-    #                  for a response after making a request
-    # @param [HTTPClient] client the third-party HTTP client wrapped by this
-    #                     class. This param is only used for testing.
-    def initialize(ssl_context:,
-                   receive_timeout: Puppet[:http_read_timeout],
-                   client: HTTPClient.new(agent_name: nil,
-                                          default_header: {
-                                            'User-Agent' => Puppet[:http_user_agent],
-                                            'X-PUPPET-VERSION' => Puppet::PUPPETVERSION
-                                          }))
-      @client = client
-      @client.tcp_keepalive = true
-      @client.connect_timeout = Puppet[:http_connect_timeout]
-      @client.receive_timeout = receive_timeout
-      @client.transparent_gzip_decompression = true
-
-      if Puppet[:http_debug]
-        @client.debug_dev = $stderr
-      end
-
-      @ca_path = Puppet[:ssl_client_ca_auth] || Puppet[:localcacert]
-      @verifier = Puppet::SSL::Validator::DefaultValidator.new(@ca_path)
-      configure_verify_mode(ssl_context)
-
-      @dns_resolver = Puppet::Network::Resolver.new
-    end
-
-    # Make a GET request to the specified URL with the specified params.
-    # @param [URI::HTTPS] url the full path to query
-    # @param [Hash] query any URL params to add to send to the endpoint
-    # @param [Hash] header any additional entries to add to the default header
-    # @yields [String] chunks of the response body
-    # @raise [Puppet::Rest::ResponseError] if the response status is not OK
-    def get(url, query: nil, header: nil, &block)
-      begin
-        @client.get_content(url.to_s, { query: query, header: header }) do |chunk|
-          block.call(chunk)
-        end
-      rescue HTTPClient::BadResponseError => e
-        raise Puppet::Rest::ResponseError.new(e.message, Puppet::Rest::Response.new(e.res))
-      rescue OpenSSL::OpenSSLError => e
-        Puppet::Util::SSL.handle_connection_error(e, @verifier, url.host)
-      end
-    end
-
-    # Make a PUT request to the specified URL with the specified params.
-    # @param [URI::HTTPS] url the full path to query
-    # @param [String/Hash] body the contents of the PUT request
-    # @param [Hash] query any URL params to add to send to the endpoint
-    # @param [Hash] header any additional entries to add to the default header
-    # @return [Puppet::Rest::Response]
-    def put(url, body:, query: nil, header: nil)
-      begin
-        response = @client.put(url.to_s, body: body, query: query, header: header)
-        Puppet::Rest::Response.new(response)
-      rescue OpenSSL::OpenSSLError => e
-        Puppet::Util::SSL.handle_connection_error(e, @verifier, url.host)
-      end
-    end
-
-    private
-
-    def configure_verify_mode(ssl_context)
-      @client.ssl_config.verify_callback = @verifier
-      @client.ssl_config.cert_store = ssl_context.cert_store
-      @client.ssl_config.verify_mode = ssl_context.verify_mode
-    end
-  end
-end

data/vendored/puppet/lib/puppet/rest/errors.rb

@@ -1,14 +0,0 @@
-module Puppet::Rest
-  class ResponseError < Puppet::Error
-    attr_reader :response
-
-    # Error thrown when request status is not OK.
-    # @param [String] msg the error message
-    # @param [Puppet::Rest::Response] response the response from the failed
-    #                                 request
-    def initialize(msg, response = nil)
-      super(msg)
-      @response = response
-    end
-  end
-end

data/vendored/puppet/lib/puppet/rest/response.rb

@@ -1,34 +0,0 @@
-module Puppet::Rest
-  # This is a wrapper for the HTTP::Message class of the HTTPClient
-  # gem. It is designed to wrap a message sent as an HTTP response.
-  class Response
-    def initialize(message)
-      @message = message
-    end
-
-    def body
-      @message.body
-    end
-
-    def content_type
-      @message.content_type
-    end
-
-    def content_encoding
-      @message.headers['Content-Encoding']
-    end
-
-    def status_code
-      @message.status
-    end
-
-    def ok?
-      @message.ok?
-    end
-
-    def to_exception
-      message = _("Error %{code} on SERVER: %{returned_message}") % { code: status_code, returned_message: body }
-      Puppet::Rest::ResponseError.new(message, self)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/rest/route.rb

@@ -1,84 +0,0 @@
-require 'uri'
-require 'puppet/util/connection'
-
-module Puppet::Rest
-  class Route
-    attr_reader :server
-
-    # Create a Route containing information for querying the given API,
-    # hosted at a server determined either by SRV service or by the
-    # fallback server on the fallback port.
-    # @param [String] api the path leading to the root of the API. Must
-    #                 contain a trailing slash for proper endpoint path
-    #                 construction
-    # @param [Symbol] server_setting the setting to check for special
-    #                 server configuration
-    # @param [Symbol] port_setting the setting to check for speical
-    #                  port configuration
-    # @param [Symbol] srv_service the name of the service when using SRV
-    #                 records
-    def initialize(api:, server_setting: :server, port_setting: :masterport, srv_service: :puppet)
-      @api = api
-      @default_server = Puppet::Util::Connection.determine_server(server_setting)
-      @default_port = Puppet::Util::Connection.determine_port(port_setting, server_setting)
-      @srv_service = srv_service
-    end
-
-    # Select a server and port to create a base URL for the API specified by this
-    # route. If the connection fails and SRV records are in use, the next suitable
-    # server will be tried. If SRV records are not in use or no successful connection
-    # could be made, fall back to the configured server and port for this API, taking
-    # into account failover settings.
-    # @parma [Puppet::Network::Resolver] dns_resolver the DNS resolver to use to check
-    #                                    SRV records
-    # @yield [URI] supply a base URL to make a request with
-    # @raise [Puppet::Error] if connection to selected server and port fails, and SRV
-    #                        records are not in use
-    def with_base_url(dns_resolver)
-      if @server && @port
-        # First try connecting to the previously selected server and port.
-        begin
-          return yield(base_url)
-        rescue SystemCallError => e
-          if Puppet[:use_srv_records]
-            Puppet.debug "Connection to cached server and port #{@server}:#{@port} failed, reselecting."
-          else
-            raise Puppet::Error, _("Connection to cached server and port %{server}:%{port} failed: %{message}") %
-              { server: @server, port: @port, message: e.message }
-          end
-        end
-      end
-
-      if Puppet[:use_srv_records]
-        dns_resolver.each_srv_record(@srv_service) do |srv_server, srv_port|
-          # Try each of the servers for this service in weighted order
-          # until a working one is found.
-          begin
-            @server = srv_server
-            @port = srv_port
-            return yield(base_url)
-          rescue SystemCallError
-            Puppet.debug "Connection to selected server and port #{@server}:#{@port} failed. Trying next cached SRV record."
-            @server = nil
-            @port = nil
-          end
-        end
-      end
-
-      # If not using SRV records, fall back to the defaults calculated above
-      @server = @default_server
-      @port = @default_port
-
-      Puppet.debug "No more servers in SRV record, falling back to #{@server}:#{@port}" if Puppet[:use_srv_records]
-      return yield(base_url)
-    end
-
-    private
-
-    # Returns a URI built from the information stored by this route,
-    # e.g. 'https://myserver.com:555/myapi/v1/'
-    def base_url
-      URI::HTTPS.build(host: @server, port: @port, path: @api)
-    end
-  end
-end