puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/indirector/key/file.rb

@@ -1,49 +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.key} public key: #{detail}", detail.backtrace
-    end
-  end
-
-  # Save the public key, in addition to the private key.
-  def save(request)
-    super
-
-    begin
-      Puppet.settings.setting(:publickeydir).open_file(public_key_path(request.key), 'w') do |f|
-        f.print request.instance.content.public_key.to_pem
-      end
-    rescue => detail
-      raise Puppet::Error, "Could not write #{request.key}: #{detail}", detail.backtrace
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/indirector/request.rb

@@ -1,256 +0,0 @@
-require 'cgi'
-require 'uri'
-require 'puppet/indirector'
-require 'puppet/network/resolver'
-require 'puppet/util/psych_support'
-
-# This class encapsulates all of the information you need to make an
-# Indirection call, and as a result also handles REST calls.  It's somewhat
-# analogous to an HTTP Request object, except tuned for our Indirector.
-class Puppet::Indirector::Request
-  include Puppet::Util::PsychSupport
-
-  attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
-
-  attr_accessor :server, :port, :uri, :protocol
-
-  attr_reader :indirection_name
-
-  # trusted_information is specifically left out because we can't serialize it
-  # and keep it "trusted"
-  OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
-
-  # Is this an authenticated request?
-  def authenticated?
-    # Double negative, so we just get true or false
-    ! ! authenticated
-  end
-
-  def environment
-    # If environment has not been set directly, we should use the application's
-    # current environment
-    @environment ||= Puppet.lookup(:current_environment)
-  end
-
-  def environment=(env)
-    @environment =
-    if env.is_a?(Puppet::Node::Environment)
-      env
-    else
-      Puppet.lookup(:environments).get!(env)
-    end
-  end
-
-  def escaped_key
-    URI.escape(key)
-  end
-
-  # LAK:NOTE This is a messy interface to the cache, and it's only
-  # used by the Configurer class.  I decided it was better to implement
-  # it now and refactor later, when we have a better design, than
-  # to spend another month coming up with a design now that might
-  # not be any better.
-  def ignore_cache?
-    ignore_cache
-  end
-
-  def ignore_terminus?
-    ignore_terminus
-  end
-
-  def initialize(indirection_name, method, key, instance, options = {})
-    @instance = instance
-    options ||= {}
-
-    self.indirection_name = indirection_name
-    self.method = method
-
-    options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
-
-    set_attributes(options)
-
-    @options = options
-
-    if key
-      # If the request key is a URI, then we need to treat it specially,
-      # because it rewrites the key.  We could otherwise strip server/port/etc
-      # info out in the REST class, but it seemed bad design for the REST
-      # class to rewrite the key.
-
-      if key.to_s =~ /^\w+:\// and not Puppet::Util.absolute_path?(key.to_s) # it's a URI
-        set_uri_key(key)
-      else
-        @key = key
-      end
-    end
-
-    @key = @instance.name if ! @key and @instance
-  end
-
-  # Look up the indirection based on the name provided.
-  def indirection
-    Puppet::Indirector::Indirection.instance(indirection_name)
-  end
-
-  def indirection_name=(name)
-    @indirection_name = name.to_sym
-  end
-
-  def model
-    raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless i = indirection
-    i.model
-  end
-
-  # Are we trying to interact with multiple resources, or just one?
-  def plural?
-    method == :search
-  end
-
-  # Create the query string, if options are present.
-  def query_string
-    return "" if options.nil? || options.empty?
-    encode_params(expand_into_parameters(options.to_a))
-  end
-
-  def expand_into_parameters(data)
-    data.inject([]) do |params, key_value|
-      key, value = key_value
-
-      expanded_value = case value
-                       when Array
-                         value.collect { |val| [key, val] }
-                       else
-                         [key_value]
-                       end
-
-      params.concat(expand_primitive_types_into_parameters(expanded_value))
-    end
-  end
-
-  def expand_primitive_types_into_parameters(data)
-    data.inject([]) do |params, key_value|
-      key, value = key_value
-      case value
-      when nil
-        params
-      when true, false, String, Symbol, Fixnum, Bignum, Float
-        params << [key, value]
-      else
-        raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
-      end
-    end
-  end
-
-  def encode_params(params)
-    params.collect do |key, value|
-      "#{key}=#{CGI.escape(value.to_s)}"
-    end.join("&")
-  end
-
-  def initialize_from_hash(hash)
-    @indirection_name = hash['indirection_name'].to_sym
-    @method = hash['method'].to_sym
-    @key = hash['key']
-    @instance = hash['instance']
-    @options = hash['options']
-  end
-
-  def to_data_hash
-    { 'indirection_name' => @indirection_name.to_s,
-      'method' => @method.to_s,
-      'key' => @key,
-      'instance' => @instance,
-      'options' => @options }
-  end
-
-  def to_hash
-    result = options.dup
-
-    OPTION_ATTRIBUTES.each do |attribute|
-      if value = send(attribute)
-        result[attribute] = value
-      end
-    end
-    result
-  end
-
-  def description
-    return(uri ? uri : "/#{indirection_name}/#{key}")
-  end
-
-  def do_request(srv_service=:puppet, default_server=Puppet.settings[:server], default_port=Puppet.settings[:masterport], &block)
-    # We were given a specific server to use, so just use that one.
-    # This happens if someone does something like specifying a file
-    # source using a puppet:// URI with a specific server.
-    return yield(self) if !self.server.nil?
-
-    if Puppet.settings[:use_srv_records]
-      Puppet::Network::Resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
-        begin
-          self.server = srv_server
-          self.port   = srv_port
-          return yield(self)
-        rescue SystemCallError => e
-          Puppet.warning "Error connecting to #{srv_server}:#{srv_port}: #{e.message}"
-        end
-      end
-    end
-
-    # ... Fall back onto the default server.
-    Puppet.debug "No more servers left, falling back to #{default_server}:#{default_port}" if Puppet.settings[:use_srv_records]
-    self.server = default_server
-    self.port   = default_port
-    return yield(self)
-  end
-
-  def remote?
-    self.node or self.ip
-  end
-
-  private
-
-  def set_attributes(options)
-    OPTION_ATTRIBUTES.each do |attribute|
-      if options.include?(attribute.to_sym)
-        send(attribute.to_s + "=", options[attribute])
-        options.delete(attribute)
-      end
-    end
-  end
-
-  # Parse the key as a URI, setting attributes appropriately.
-  def set_uri_key(key)
-    @uri = key
-    begin
-      uri = URI.parse(URI.escape(key))
-    rescue => detail
-      raise ArgumentError, "Could not understand URL #{key}: #{detail}", detail.backtrace
-    end
-
-    # Just short-circuit these to full paths
-    if uri.scheme == "file"
-      @key = Puppet::Util.uri_to_path(uri)
-      return
-    end
-
-    @server = uri.host if uri.host
-
-    # If the URI class can look up the scheme, it will provide a port,
-    # otherwise it will default to '0'.
-    if uri.port.to_i == 0 and uri.scheme == "puppet"
-      @port = Puppet.settings[:masterport].to_i
-    else
-      @port = uri.port.to_i
-    end
-
-    # filebucket:// is only used internally to pass request details
-    # from Dipper objects to the indirector. The wire always uses HTTPS.
-    if uri.scheme == 'filebucket'
-      @protocol = 'https'
-    else
-      @protocol = uri.scheme
-    end
-
-    @key = URI.unescape(uri.path.sub(/^\//, ''))
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/indirector/rest.rb

@@ -1,260 +0,0 @@
-require 'net/http'
-require 'uri'
-
-require 'puppet/network/http'
-require 'puppet/network/http_pool'
-
-# Access objects via REST
-class Puppet::Indirector::REST < Puppet::Indirector::Terminus
-  include Puppet::Network::HTTP::Compression.module
-
-  IndirectedRoutes = Puppet::Network::HTTP::API::IndirectedRoutes
-
-  class << self
-    attr_reader :server_setting, :port_setting
-  end
-
-  # Specify the setting that we should use to get the server name.
-  def self.use_server_setting(setting)
-    @server_setting = setting
-  end
-
-  # Specify the setting that we should use to get the port.
-  def self.use_port_setting(setting)
-    @port_setting = setting
-  end
-
-  # Specify the service to use when doing SRV record lookup
-  def self.use_srv_service(service)
-    @srv_service = service
-  end
-
-  def self.srv_service
-    @srv_service || :puppet
-  end
-
-  def self.server
-    Puppet.settings[server_setting || :server]
-  end
-
-  def self.port
-    Puppet.settings[port_setting || :masterport].to_i
-  end
-
-  # Provide appropriate headers.
-  def headers
-    # yaml is not allowed on the network
-    network_formats = model.supported_formats.reject do |format|
-      [:yaml, :b64_zlib_yaml].include?(format)
-    end
-    common_headers = {
-      "Accept"                                     => network_formats.join(", "),
-      Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version
-    }
-
-    add_accept_encoding(common_headers)
-  end
-
-  def add_profiling_header(headers)
-    if (Puppet[:profile])
-      headers[Puppet::Network::HTTP::HEADER_ENABLE_PROFILING] = "true"
-    end
-    headers
-  end
-
-  def network(request)
-    Puppet::Network::HttpPool.http_instance(request.server || self.class.server,
-                                            request.port || self.class.port)
-  end
-
-  def http_get(request, path, headers = nil, *args)
-    http_request(:get, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_post(request, path, data, headers = nil, *args)
-    http_request(:post, request, path, data, add_profiling_header(headers), *args)
-  end
-
-  def http_head(request, path, headers = nil, *args)
-    http_request(:head, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_delete(request, path, headers = nil, *args)
-    http_request(:delete, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_put(request, path, data, headers = nil, *args)
-    http_request(:put, request, path, data, add_profiling_header(headers), *args)
-  end
-
-  def http_request(method, request, *args)
-    conn = network(request)
-    conn.send(method, *args)
-  end
-
-  def find(request)
-    uri, body = IndirectedRoutes.request_to_uri_and_body(request)
-    uri_with_query_string = "#{uri}?#{body}"
-
-    response = do_request(request) do |req|
-      # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
-      # http://redmine.ruby-lang.org/issues/show/3991
-      if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
-        uri_with_env = "#{uri}?environment=#{request.environment.name}"
-        http_post(req, uri_with_env, body, headers)
-      else
-        http_get(req, uri_with_query_string, headers)
-      end
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      result = deserialize_find(content_type, body)
-      result.name = request.key if result.respond_to?(:name=)
-      result
-
-    elsif is_http_404?(response)
-      return nil unless request.options[:fail_on_404]
-
-      # 404 can get special treatment as the indirector API can not produce a meaningful
-      # reason to why something is not found - it may not be the thing the user is
-      # expecting to find that is missing, but something else (like the environment).
-      # While this way of handling the issue is not perfect, there is at least an error
-      # that makes a user aware of the reason for the failure.
-      #
-      content_type, body = parse_response(response)
-      msg = "Find #{elide(uri_with_query_string, 100)} resulted in 404 with the message: #{body}"
-      raise Puppet::Error, msg
-    else
-      nil
-    end
-  end
-
-  def head(request)
-    response = do_request(request) do |req|
-      http_head(req, IndirectedRoutes.request_to_uri(req), headers)
-    end
-
-    if is_http_200?(response)
-      true
-    else
-      false
-    end
-  end
-
-  def search(request)
-    response = do_request(request) do |req|
-      http_get(req, IndirectedRoutes.request_to_uri(req), headers)
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_search(content_type, body) || []
-    else
-      []
-    end
-  end
-
-  def destroy(request)
-    raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
-
-    response = do_request(request) do |req|
-      http_delete(req, IndirectedRoutes.request_to_uri(req), headers)
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_destroy(content_type, body)
-    else
-      nil
-    end
-  end
-
-  def save(request)
-    raise ArgumentError, "PUT does not accept options" unless request.options.empty?
-
-    response = do_request(request) do |req|
-      http_put(req, IndirectedRoutes.request_to_uri(req), req.instance.render, headers.merge({ "Content-Type" => req.instance.mime }))
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_save(content_type, body)
-    else
-      nil
-    end
-  end
-
-  # Encapsulate call to request.do_request with the arguments from this class
-  # Then yield to the code block that was called in
-  # We certainly could have retained the full request.do_request(...) { |r| ... }
-  # but this makes the code much cleaner and we only then actually make the call
-  # to request.do_request from here, thus if we change what we pass or how we
-  # get it, we only need to change it here.
-  def do_request(request)
-    request.do_request(self.class.srv_service, self.class.server, self.class.port) { |req| yield(req) }
-  end
-
-  def validate_key(request)
-    # Validation happens on the remote end
-  end
-
-  private
-
-  def is_http_200?(response)
-    case response.code
-    when "404"
-      false
-    when /^2/
-      true
-    else
-      # Raise the http error if we didn't get a 'success' of some kind.
-      raise convert_to_http_error(response)
-    end
-  end
-
-  def is_http_404?(response)
-    response.code == "404"
-  end
-
-  def convert_to_http_error(response)
-    message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
-    Net::HTTPError.new(message, response)
-  end
-
-  # Returns the content_type, stripping any appended charset, and the
-  # body, decompressed if necessary (content-encoding is checked inside
-  # uncompress_body)
-  def parse_response(response)
-    if response['content-type']
-      [ response['content-type'].gsub(/\s*;.*$/,''),
-        body = uncompress_body(response) ]
-    else
-      raise "No content type in http response; cannot parse"
-    end
-  end
-
-  def deserialize_find(content_type, body)
-    model.convert_from(content_type, body)
-  end
-
-  def deserialize_search(content_type, body)
-    model.convert_from_multiple(content_type, body)
-  end
-
-  def deserialize_destroy(content_type, body)
-    model.convert_from(content_type, body)
-  end
-
-  def deserialize_save(content_type, body)
-    nil
-  end
-
-  def elide(string, length)
-    if Puppet::Util::Log.level == :debug || string.length <= length
-      string
-    else
-      string[0, length - 3] + "..."
-    end
-  end
-end