puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/network/http/api/master/v3.rb

@@ -1,28 +0,0 @@
-class Puppet::Network::HTTP::API::Master::V3
-  require 'puppet/network/http/api/master/v3/authorization'
-  require 'puppet/network/http/api/master/v3/environments'
-  require 'puppet/network/http/api/master/v3/environment'
-  require 'puppet/network/http/api/indirected_routes'
-
-  AUTHZ = Authorization.new
-
-  INDIRECTED = Puppet::Network::HTTP::Route.
-      path(/.*/).
-      any(Puppet::Network::HTTP::API::IndirectedRoutes.new)
-
-  ENVIRONMENTS = Puppet::Network::HTTP::Route.
-      path(%r{^/environments$}).get(AUTHZ.wrap do
-    Environments.new(Puppet.lookup(:environments))
-  end)
-
-  ENVIRONMENT = Puppet::Network::HTTP::Route.
-      path(%r{/environment/[^/]+$}).get(AUTHZ.wrap do
-    Environment.new
-  end)
-
-  def self.routes
-    Puppet::Network::HTTP::Route.path(%r{v3}).
-        any.
-        chain(ENVIRONMENTS, ENVIRONMENT, INDIRECTED)
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/network/http/compression.rb

@@ -1,116 +0,0 @@
-require 'puppet/network/http'
-
-module Puppet::Network::HTTP::Compression
-  # from https://github.com/ruby/ruby/blob/v2_1_3/lib/net/http/generic_request.rb#L40
-  ACCEPT_ENCODING = "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"
-
-  # this module function allows to use the right underlying
-  # methods depending on zlib presence
-  def module
-    return(Puppet.features.zlib? ? Active : None)
-  end
-  module_function :module
-
-  module Active
-    require 'zlib'
-    require 'stringio'
-
-    # return an uncompressed body if the response has been
-    # compressed
-    def uncompress_body(response)
-      case response['content-encoding']
-      when 'gzip'
-        return Zlib::GzipReader.new(StringIO.new(response.body)).read
-      when 'deflate'
-        return Zlib::Inflate.new.inflate(response.body)
-      when nil, 'identity'
-        return response.body
-      else
-        raise Net::HTTPError.new("Unknown content encoding - #{response['content-encoding']}", response)
-      end
-    end
-
-    def uncompress(response)
-      raise Net::HTTPError.new("No block passed") unless block_given?
-
-      case response['content-encoding']
-      when 'gzip','deflate'
-        uncompressor = ZlibAdapter.new
-      when nil, 'identity'
-        uncompressor = IdentityAdapter.new
-      else
-        raise Net::HTTPError.new("Unknown content encoding - #{response['content-encoding']}", response)
-      end
-
-      yield uncompressor
-
-      uncompressor.close
-    end
-
-    def add_accept_encoding(headers={})
-      headers['accept-encoding'] = Puppet::Network::HTTP::Compression::ACCEPT_ENCODING
-      headers
-    end
-
-    # This adapters knows how to uncompress both 'zlib' stream (the deflate algorithm from Content-Encoding)
-    # and GZip streams.
-    class ZlibAdapter
-      def initialize
-        # Create an inflater that knows to parse GZip streams and zlib streams.
-        # This uses a property of the C Zlib library, documented as follow:
-        #   windowBits can also be greater than 15 for optional gzip decoding. Add
-        #   32 to windowBits to enable zlib and gzip decoding with automatic header
-        #   detection, or add 16 to decode only the gzip format (the zlib format will
-        #   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
-        #   a crc32 instead of an adler32.
-        @uncompressor = Zlib::Inflate.new(15 + 32)
-        @first = true
-      end
-
-      def uncompress(chunk)
-        out = @uncompressor.inflate(chunk)
-        @first = false
-        return out
-      rescue Zlib::DataError
-        # it can happen that we receive a raw deflate stream
-        # which might make our inflate throw a data error.
-        # in this case, we try with a verbatim (no header)
-        # deflater.
-        @uncompressor = Zlib::Inflate.new
-        if @first then
-          @first = false
-          retry
-        end
-        raise
-      end
-
-      def close
-        @uncompressor.finish
-        @uncompressor.close
-      end
-    end
-  end
-
-  module None
-    def uncompress_body(response)
-      response.body
-    end
-
-    def add_accept_encoding(headers)
-      headers
-    end
-
-    def uncompress(response)
-      yield IdentityAdapter.new
-    end
-  end
-
-  class IdentityAdapter
-    def uncompress(chunk)
-      chunk
-    end
-
-    def close
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/network/http/connection.rb

@@ -1,233 +0,0 @@
-require 'net/https'
-require 'puppet/ssl/host'
-require 'puppet/ssl/configuration'
-require 'puppet/ssl/validator'
-require 'puppet/network/http'
-require 'uri'
-
-module Puppet::Network::HTTP
-
-  # This will be raised if too many redirects happen for a given HTTP request
-  class RedirectionLimitExceededException < Puppet::Error ; end
-
-  # This class provides simple methods for issuing various types of HTTP
-  # requests.  It's interface is intended to mirror Ruby's Net::HTTP
-  # object, but it provides a few important bits of additional
-  # functionality.  Notably:
-  #
-  # * Any HTTPS requests made using this class will use Puppet's SSL
-  #   certificate configuration for their authentication, and
-  # * Provides some useful error handling for any SSL errors that occur
-  #   during a request.
-  # @api public
-  class Connection
-
-    OPTION_DEFAULTS = {
-      :use_ssl => true,
-      :verify => nil,
-      :redirect_limit => 10,
-    }
-
-    # Creates a new HTTP client connection to `host`:`port`.
-    # @param host [String] the host to which this client will connect to
-    # @param port [Fixnum] the port to which this client will connect to
-    # @param options [Hash] options influencing the properties of the created
-    #   connection,
-    # @option options [Boolean] :use_ssl true to connect with SSL, false
-    #   otherwise, defaults to true
-    # @option options [#setup_connection] :verify An object that will configure
-    #   any verification to do on the connection
-    # @option options [Fixnum] :redirect_limit the number of allowed
-    #   redirections, defaults to 10 passing any other option in the options
-    #   hash results in a Puppet::Error exception
-    #
-    # @note the HTTP connection itself happens lazily only when {#request}, or
-    #   one of the {#get}, {#post}, {#delete}, {#head} or {#put} is called
-    # @note The correct way to obtain a connection is to use one of the factory
-    #   methods on {Puppet::Network::HttpPool}
-    # @api private
-    def initialize(host, port, options = {})
-      @host = host
-      @port = port
-
-      unknown_options = options.keys - OPTION_DEFAULTS.keys
-      raise Puppet::Error, "Unrecognized option(s): #{unknown_options.map(&:inspect).sort.join(', ')}" unless unknown_options.empty?
-
-      options = OPTION_DEFAULTS.merge(options)
-      @use_ssl = options[:use_ssl]
-      @verify = options[:verify]
-      @redirect_limit = options[:redirect_limit]
-      @site = Puppet::Network::HTTP::Site.new(@use_ssl ? 'https' : 'http', host, port)
-      @pool = Puppet.lookup(:http_pool)
-    end
-
-    # @!macro [new] common_options
-    #   @param options [Hash] options influencing the request made
-    #   @option options [Hash{Symbol => String}] :basic_auth The basic auth
-    #     :username and :password to use for the request
-
-    # @param path [String]
-    # @param headers [Hash{String => String}]
-    # @!macro common_options
-    # @api public
-    def get(path, headers = {}, options = {})
-      request_with_redirects(Net::HTTP::Get.new(path, headers), options)
-    end
-
-    # @param path [String]
-    # @param data [String]
-    # @param headers [Hash{String => String}]
-    # @!macro common_options
-    # @api public
-    def post(path, data, headers = nil, options = {})
-      request = Net::HTTP::Post.new(path, headers)
-      request.body = data
-      request_with_redirects(request, options)
-    end
-
-    # @param path [String]
-    # @param headers [Hash{String => String}]
-    # @!macro common_options
-    # @api public
-    def head(path, headers = {}, options = {})
-      request_with_redirects(Net::HTTP::Head.new(path, headers), options)
-    end
-
-    # @param path [String]
-    # @param headers [Hash{String => String}]
-    # @!macro common_options
-    # @api public
-    def delete(path, headers = {'Depth' => 'Infinity'}, options = {})
-      request_with_redirects(Net::HTTP::Delete.new(path, headers), options)
-    end
-
-    # @param path [String]
-    # @param data [String]
-    # @param headers [Hash{String => String}]
-    # @!macro common_options
-    # @api public
-    def put(path, data, headers = nil, options = {})
-      request = Net::HTTP::Put.new(path, headers)
-      request.body = data
-      request_with_redirects(request, options)
-    end
-
-    def request(method, *args)
-      self.send(method, *args)
-    end
-
-    # TODO: These are proxies for the Net::HTTP#request_* methods, which are
-    # almost the same as the "get", "post", etc. methods that we've ported above,
-    # but they are able to accept a code block and will yield to it, which is
-    # necessary to stream responses, e.g. file content.  For now
-    # we're not funneling these proxy implementations through our #request
-    # method above, so they will not inherit the same error handling.  In the
-    # future we may want to refactor these so that they are funneled through
-    # that method and do inherit the error handling.
-    def request_get(*args, &block)
-      with_connection(@site) do |connection|
-        connection.request_get(*args, &block)
-      end
-    end
-
-    def request_head(*args, &block)
-      with_connection(@site) do |connection|
-        connection.request_head(*args, &block)
-      end
-    end
-
-    def request_post(*args, &block)
-      with_connection(@site) do |connection|
-        connection.request_post(*args, &block)
-      end
-    end
-    # end of Net::HTTP#request_* proxies
-
-    # The address to connect to.
-    def address
-      @site.host
-    end
-
-    # The port to connect to.
-    def port
-      @site.port
-    end
-
-    # Whether to use ssl
-    def use_ssl?
-      @site.use_ssl?
-    end
-
-    private
-
-    def request_with_redirects(request, options)
-      current_request = request
-      current_site = @site
-      response = nil
-
-      0.upto(@redirect_limit) do |redirection|
-        return response if response
-
-        with_connection(current_site) do |connection|
-          apply_options_to(current_request, options)
-
-          current_response = execute_request(connection, current_request)
-
-          if [301, 302, 307].include?(current_response.code.to_i)
-
-            # handle the redirection
-            location = URI.parse(current_response['location'])
-            current_site = current_site.move_to(location)
-
-            # update to the current request path
-            current_request = current_request.class.new(location.path)
-            current_request.body = request.body
-            request.each do |header, value|
-              current_request[header] = value
-            end
-          else
-            response = current_response
-          end
-        end
-
-        # and try again...
-      end
-
-      raise RedirectionLimitExceededException, "Too many HTTP redirections for #{@host}:#{@port}"
-    end
-
-    def apply_options_to(request, options)
-      if options[:basic_auth]
-        request.basic_auth(options[:basic_auth][:user], options[:basic_auth][:password])
-      end
-    end
-
-    def execute_request(connection, request)
-      connection.request(request)
-    end
-
-    def with_connection(site, &block)
-      response = nil
-      @pool.with_connection(site, @verify) do |conn|
-        response = yield conn
-      end
-      response
-    rescue OpenSSL::SSL::SSLError => error
-      if error.message.include? "certificate verify failed"
-        msg = error.message
-        msg << ": [" + @verify.verify_errors.join('; ') + "]"
-        raise Puppet::Error, msg, error.backtrace
-      elsif error.message =~ /hostname.*not match.*server certificate/
-        leaf_ssl_cert = @verify.peer_certs.last
-
-        valid_certnames = [leaf_ssl_cert.name, *leaf_ssl_cert.subject_alt_names].uniq
-        msg = valid_certnames.length > 1 ? "one of #{valid_certnames.join(', ')}" : valid_certnames.first
-        msg = "Server hostname '#{site.host}' did not match server certificate; expected #{msg}"
-
-        raise Puppet::Error, msg, error.backtrace
-      else
-        raise
-      end
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/network/http/error.rb

@@ -1,69 +0,0 @@
-require 'json'
-
-module Puppet::Network::HTTP::Error
-  Issues = Puppet::Network::HTTP::Issues
-
-  class HTTPError < Exception
-    attr_reader :status, :issue_kind
-
-    def initialize(message, status, issue_kind)
-      super(message)
-      @status = status
-      @issue_kind = issue_kind
-    end
-
-    def to_json
-      JSON({:message => message, :issue_kind => @issue_kind})
-    end
-  end
-
-  class HTTPNotAcceptableError < HTTPError
-    CODE = 406
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Not Acceptable: " + message, CODE, issue_kind)
-    end
-  end
-
-  class HTTPNotFoundError < HTTPError
-    CODE = 404
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Not Found: " + message, CODE, issue_kind)
-    end
-  end
-
-  class HTTPNotAuthorizedError < HTTPError
-    CODE = 403
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Not Authorized: " + message, CODE, issue_kind)
-    end
-  end
-
-  class HTTPBadRequestError < HTTPError
-    CODE = 400
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Bad Request: " + message, CODE, issue_kind)
-    end
-  end
-
-  class HTTPMethodNotAllowedError < HTTPError
-    CODE = 405
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Method Not Allowed: " + message, CODE, issue_kind)
-    end
-  end
-
-  class HTTPServerError < HTTPError
-    CODE = 500
-
-    attr_reader :backtrace
-
-    def initialize(original_error, issue_kind = Issues::RUNTIME_ERROR)
-      super("Server Error: " + original_error.message, CODE, issue_kind)
-      @backtrace = original_error.backtrace
-    end
-
-    def to_json
-      JSON({:message => message, :issue_kind => @issue_kind, :stacktrace => self.backtrace})
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/network/http/handler.rb

@@ -1,178 +0,0 @@
-module Puppet::Network::HTTP
-end
-
-require 'puppet/network/http'
-require 'puppet/network/rights'
-require 'puppet/util/profiler'
-require 'puppet/util/profiler/aggregate'
-require 'resolv'
-
-module Puppet::Network::HTTP::Handler
-  include Puppet::Network::HTTP::Issues
-
-  # These shouldn't be allowed to be set by clients
-  # in the query string, for security reasons.
-  DISALLOWED_KEYS = ["node", "ip"]
-
-  def register(routes)
-    # There's got to be a simpler way to do this, right?
-    dupes = {}
-    routes.each { |r| dupes[r.path_matcher] = (dupes[r.path_matcher] || 0) + 1 }
-    dupes = dupes.collect { |pm, count| pm if count > 1 }.compact
-    if dupes.count > 0
-      raise ArgumentError, "Given multiple routes with identical path regexes: #{dupes.map{ |rgx| rgx.inspect }.join(', ')}"
-    end
-
-    @routes = routes
-    Puppet.debug("Routes Registered:")
-    @routes.each do |route|
-      Puppet.debug(route.inspect)
-    end
-  end
-
-  # Retrieve all headers from the http request, as a hash with the header names
-  # (lower-cased) as the keys
-  def headers(request)
-    raise NotImplementedError
-  end
-
-  def format_to_mime(format)
-    format.is_a?(Puppet::Network::Format) ? format.mime : format
-  end
-
-  # handle an HTTP request
-  def process(request, response)
-    new_response = Puppet::Network::HTTP::Response.new(self, response)
-
-    request_headers = headers(request)
-    request_params = params(request)
-    request_method = http_method(request)
-    request_path = path(request)
-
-    new_request = Puppet::Network::HTTP::Request.new(request_headers, request_params, request_method, request_path, request_path, client_cert(request), body(request))
-
-    response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION] = Puppet.version
-
-    profiler = configure_profiler(request_headers, request_params)
-
-    Puppet::Util::Profiler.profile("Processed request #{request_method} #{request_path}", [:http, request_method, request_path]) do
-      if route = @routes.find { |r| r.matches?(new_request) }
-        route.process(new_request, new_response)
-      else
-        raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("No route for #{new_request.method} #{new_request.path}", HANDLER_NOT_FOUND)
-      end
-    end
-
-  rescue Puppet::Network::HTTP::Error::HTTPError => e
-    Puppet.info(e.message)
-    new_response.respond_with(e.status, "application/json", e.to_json)
-  rescue StandardError => e
-    http_e = Puppet::Network::HTTP::Error::HTTPServerError.new(e)
-    Puppet.err(http_e.message)
-    new_response.respond_with(http_e.status, "application/json", http_e.to_json)
-  ensure
-    if profiler
-      remove_profiler(profiler)
-    end
-    cleanup(request)
-  end
-
-  # Set the response up, with the body and status.
-  def set_response(response, body, status = 200)
-    raise NotImplementedError
-  end
-
-  # Set the specified format as the content type of the response.
-  def set_content_type(response, format)
-    raise NotImplementedError
-  end
-
-  # resolve node name from peer's ip address
-  # this is used when the request is unauthenticated
-  def resolve_node(result)
-    begin
-      return Resolv.getname(result[:ip])
-    rescue => detail
-      Puppet.err "Could not resolve #{result[:ip]}: #{detail}"
-    end
-    result[:ip]
-  end
-
-  private
-
-  # methods to be overridden by the including web server class
-
-  def http_method(request)
-    raise NotImplementedError
-  end
-
-  def path(request)
-    raise NotImplementedError
-  end
-
-  def request_key(request)
-    raise NotImplementedError
-  end
-
-  def body(request)
-    raise NotImplementedError
-  end
-
-  def params(request)
-    raise NotImplementedError
-  end
-
-  def client_cert(request)
-    raise NotImplementedError
-  end
-
-  def cleanup(request)
-    # By default, there is nothing to cleanup.
-  end
-
-  def decode_params(params)
-    params.select { |key, _| allowed_parameter?(key) }.inject({}) do |result, ary|
-      param, value = ary
-      result[param.to_sym] = parse_parameter_value(param, value)
-      result
-    end
-  end
-
-  def allowed_parameter?(name)
-    not (name.nil? || name.empty? || DISALLOWED_KEYS.include?(name))
-  end
-
-  def parse_parameter_value(param, value)
-    if value.is_a?(Array)
-      value.collect { |v| parse_primitive_parameter_value(v) }
-    else
-      parse_primitive_parameter_value(value)
-    end
-  end
-
-  def parse_primitive_parameter_value(value)
-    case value
-    when "true"
-      true
-    when "false"
-      false
-    when /^\d+$/
-      Integer(value)
-    when /^\d+\.\d+$/
-      value.to_f
-    else
-      value
-    end
-  end
-
-  def configure_profiler(request_headers, request_params)
-    if (request_headers.has_key?(Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase) or Puppet[:profile])
-      Puppet::Util::Profiler.add_profiler(Puppet::Util::Profiler::Aggregate.new(Puppet.method(:debug), request_params.object_id))
-    end
-  end
-
-  def remove_profiler(profiler)
-    profiler.shutdown
-    Puppet::Util::Profiler.remove_profiler(profiler)
-  end
-end