puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/issues.rb

@@ -0,0 +1,11 @@
+module Puppet::Network::HTTP::Issues
+  NO_INDIRECTION_REMOTE_REQUESTS = :NO_INDIRECTION_REMOTE_REQUESTS
+  HANDLER_NOT_FOUND = :HANDLER_NOT_FOUND
+  RESOURCE_NOT_FOUND = :RESOURCE_NOT_FOUND
+  ENVIRONMENT_NOT_FOUND = :ENVIRONMENT_NOT_FOUND
+  RUNTIME_ERROR = :RUNTIME_ERROR
+  MISSING_HEADER_FIELD = :MISSING_HEADER_FIELD
+  UNSUPPORTED_FORMAT = :UNSUPPORTED_FORMAT
+  UNSUPPORTED_METHOD = :UNSUPPORTED_METHOD
+  FAILED_AUTHORIZATION = :FAILED_AUTHORIZATION
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/memory_response.rb

@@ -0,0 +1,13 @@
+class Puppet::Network::HTTP::MemoryResponse
+  attr_reader :code, :type, :body
+
+  def initialize
+    @body = ""
+  end
+
+  def respond_with(code, type, body)
+    @code = code
+    @type = type
+    @body += body
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/nocache_pool.rb

@@ -0,0 +1,21 @@
+# A pool that does not cache HTTP connections.
+#
+# @api private
+class Puppet::Network::HTTP::NoCachePool
+  def initialize(factory = Puppet::Network::HTTP::Factory.new)
+    @factory = factory
+  end
+
+  # Yields a <tt>Net::HTTP</tt> connection.
+  #
+  # @yieldparam http [Net::HTTP] An HTTP connection
+  def with_connection(site, verify, &block)
+    http = @factory.create_connection(site)
+    verify.setup_connection(http)
+    yield http
+  end
+
+  def close
+    # do nothing
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/pool.rb

@@ -0,0 +1,120 @@
+# A pool for persistent <tt>Net::HTTP</tt> connections. Connections are
+# stored in the pool indexed by their {Puppet::Network::HTTP::Site Site}.
+# Connections are borrowed from the pool, yielded to the caller, and
+# released back into the pool. If a connection is expired, it will be
+# closed either when a connection to that site is requested, or when
+# the pool is closed. The pool can store multiple connections to the
+# same site, and will be reused in MRU order.
+#
+# @api private
+#
+class Puppet::Network::HTTP::Pool
+  FIFTEEN_SECONDS = 15
+
+  attr_reader :factory
+
+  def initialize(keepalive_timeout = FIFTEEN_SECONDS)
+    @pool = {}
+    @factory = Puppet::Network::HTTP::Factory.new
+    @keepalive_timeout = keepalive_timeout
+  end
+
+  def with_connection(site, verify, &block)
+    reuse = true
+
+    http = borrow(site, verify)
+    begin
+      if http.use_ssl? && http.verify_mode != OpenSSL::SSL::VERIFY_PEER
+        reuse = false
+      end
+
+      yield http
+    rescue => detail
+      reuse = false
+      raise detail
+    ensure
+      if reuse
+        release(site, http)
+      else
+        close_connection(site, http)
+      end
+    end
+  end
+
+  def close
+    @pool.each_pair do |site, sessions|
+      sessions.each do |session|
+        close_connection(site, session.connection)
+      end
+    end
+    @pool.clear
+  end
+
+  # @api private
+  def pool
+    @pool
+  end
+
+  # Safely close a persistent connection.
+  #
+  # @api private
+  def close_connection(site, http)
+    Puppet.debug("Closing connection for #{site}")
+    http.finish
+  rescue => detail
+    Puppet.log_exception(detail, "Failed to close connection for #{site}: #{detail}")
+  end
+
+  # Borrow and take ownership of a persistent connection. If a new
+  # connection is created, it will be started prior to being returned.
+  #
+  # @api private
+  def borrow(site, verify)
+    @pool[site] = active_sessions(site)
+    session = @pool[site].shift
+    if session
+      Puppet.debug("Using cached connection for #{site}")
+      session.connection
+    else
+      http = @factory.create_connection(site)
+      verify.setup_connection(http)
+
+      Puppet.debug("Starting connection for #{site}")
+      http.start
+      http
+    end
+  end
+
+  # Release a connection back into the pool.
+  #
+  # @api private
+  def release(site, http)
+    expiration = Time.now + @keepalive_timeout
+    session = Puppet::Network::HTTP::Session.new(http, expiration)
+    Puppet.debug("Caching connection for #{site}")
+
+    sessions = @pool[site]
+    if sessions
+      sessions.unshift(session)
+    else
+      @pool[site] = [session]
+    end
+  end
+
+  # Returns an Array of sessions whose connections are not expired.
+  #
+  # @api private
+  def active_sessions(site)
+    now = Time.now
+
+    sessions = @pool[site] || []
+    sessions.select do |session|
+      if session.expired?(now)
+        close_connection(site, session.connection)
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/rack.rb

@@ -0,0 +1,33 @@
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+
+require 'puppet/network/http'
+require 'puppet/network/http/rack/rest'
+
+# An rack application, for running the Puppet HTTP Server.
+class Puppet::Network::HTTP::Rack
+  # The real rack application (which needs to respond to call).
+  # The work we need to do, roughly is:
+  # * Read request (from env) and prepare a response
+  # * Route the request to the correct handler
+  # * Return the response (in rack-format) to our caller.
+  def call(env)
+    request = Rack::Request.new(env)
+    response = Rack::Response.new
+    Puppet.debug 'Handling request: %s %s' % [request.request_method, request.fullpath]
+
+    begin
+      Puppet::Network::HTTP::RackREST.new.process(request, response)
+    rescue => detail
+      # Send a Status 500 Error on unhandled exceptions.
+      response.status = 500
+      response['Content-Type'] = 'text/plain'
+      response.write 'Internal Server Error: "%s"' % detail.message
+      # log what happened
+      Puppet.log_exception(detail, "Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"" % detail.message)
+    end
+    response.finish
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/rack/rest.rb

@@ -0,0 +1,138 @@
+require 'openssl'
+require 'cgi'
+require 'puppet/network/http/handler'
+require 'puppet/util/ssl'
+
+class Puppet::Network::HTTP::RackREST
+  include Puppet::Network::HTTP::Handler
+
+  ContentType = 'Content-Type'.freeze
+
+  CHUNK_SIZE = 8192
+
+  class RackFile
+    def initialize(file)
+      @file = file
+    end
+
+    def each
+      while chunk = @file.read(CHUNK_SIZE)
+        yield chunk
+      end
+    end
+
+    def close
+      @file.close
+    end
+  end
+
+  def initialize(args={})
+    super()
+    register([Puppet::Network::HTTP::API::V2.routes, Puppet::Network::HTTP::API::V1.routes])
+  end
+
+  def set_content_type(response, format)
+    response[ContentType] = format_to_mime(format)
+  end
+
+  # produce the body of the response
+  def set_response(response, result, status = 200)
+    response.status = status
+    unless result.is_a?(File)
+      response.write result
+    else
+      response["Content-Length"] = result.stat.size.to_s
+      response.body = RackFile.new(result)
+    end
+  end
+
+  # Retrieve all headers from the http request, as a map.
+  def headers(request)
+    headers = request.env.select {|k,v| k.start_with? 'HTTP_'}.inject({}) do |m, (k,v)|
+      m[k.sub(/^HTTP_/, '').gsub('_','-').downcase] = v
+      m
+    end
+    headers['content-type'] = request.content_type
+    headers
+  end
+
+  # Return which HTTP verb was used in this request.
+  def http_method(request)
+    request.request_method
+  end
+
+  # Return the query params for this request.
+  def params(request)
+    if request.post?
+      params = request.params
+    else
+      # rack doesn't support multi-valued query parameters,
+      # e.g. ignore, so parse them ourselves
+      params = CGI.parse(request.query_string)
+      convert_singular_arrays_to_value(params)
+    end
+    result = decode_params(params)
+    result.merge(extract_client_info(request))
+  end
+
+  # what path was requested? (this is, without any query parameters)
+  def path(request)
+    request.path
+  end
+
+  # return the request body
+  def body(request)
+    request.body.read
+  end
+
+  def client_cert(request)
+    # This environment variable is set by mod_ssl, note that it
+    # requires the `+ExportCertData` option in the `SSLOptions` directive
+    cert = request.env['SSL_CLIENT_CERT']
+    # NOTE: The SSL_CLIENT_CERT environment variable will be the empty string
+    # when Puppet agent nodes have not yet obtained a signed certificate.
+    if cert.nil? || cert.empty?
+      nil
+    else
+      cert = Puppet::SSL::Certificate.from_instance(OpenSSL::X509::Certificate.new(cert))
+      warn_if_near_expiration(cert)
+      cert
+    end
+  end
+
+  # Passenger freaks out if we finish handling the request without reading any
+  # part of the body, so make sure we have.
+  def cleanup(request)
+    request.body.read(1)
+    nil
+  end
+
+  def extract_client_info(request)
+    result = {}
+    result[:ip] = request.ip
+
+    # if we find SSL info in the headers, use them to get a hostname from the CN.
+    # try this with :ssl_client_header, which defaults should work for
+    # Apache with StdEnvVars.
+    subj_str = request.env[Puppet[:ssl_client_header]]
+    subject = Puppet::Util::SSL.subject_from_dn(subj_str || "")
+
+    if cn = Puppet::Util::SSL.cn_from_subject(subject)
+      result[:node] = cn
+      result[:authenticated] = (request.env[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
+    else
+      result[:node] = resolve_node(result)
+      result[:authenticated] = false
+    end
+
+    result
+  end
+
+  def convert_singular_arrays_to_value(hash)
+    hash.each do |key, value|
+      if value.size == 1
+        hash[key] = value.first
+      end
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/request.rb

@@ -0,0 +1,56 @@
+Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :routing_path, :client_cert, :body) do
+  def self.from_hash(hash)
+    symbol_members = members.collect(&:intern)
+    unknown = hash.keys - symbol_members
+    if unknown.empty?
+      new(hash[:headers] || {},
+          hash[:params] || {},
+          hash[:method] || "GET",
+          hash[:path],
+          hash[:routing_path] || hash[:path],
+          hash[:client_cert],
+          hash[:body])
+    else
+      raise ArgumentError, "Unknown arguments: #{unknown.collect(&:inspect).join(', ')}"
+    end
+  end
+
+  def route_into(prefix)
+    self.class.new(headers, params, method, path, routing_path.sub(prefix, ''), client_cert, body)
+  end
+
+  def format
+    if header = headers['content-type']
+      header.gsub!(/\s*;.*$/,'') # strip any charset
+      format = Puppet::Network::FormatHandler.mime(header)
+      if format.nil?
+        raise "Client sent a mime-type (#{header}) that doesn't correspond to a format we support"
+      else
+        report_if_deprecated(format)
+        return format.name.to_s if format.suitable?
+      end
+    end
+
+    raise "No Content-Type header was received, it isn't possible to unserialize the request"
+  end
+
+  def response_formatter_for(supported_formats, accepted_formats = headers['accept'])
+    formatter = Puppet::Network::FormatHandler.most_suitable_format_for(
+      accepted_formats.split(/\s*,\s*/),
+      supported_formats)
+
+      if formatter.nil?
+        raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new("No supported formats are acceptable (Accept: #{accepted_formats})", Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
+      end
+
+      report_if_deprecated(formatter)
+
+      formatter
+  end
+
+  def report_if_deprecated(format)
+    if format.name == :yaml || format.name == :b64_zlib_yaml
+      Puppet.deprecation_warning("YAML in network requests is deprecated and will be removed in a future version. See http://links.puppetlabs.com/deprecate_yaml_on_network")
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/response.rb

@@ -0,0 +1,11 @@
+class Puppet::Network::HTTP::Response
+  def initialize(handler, response)
+    @handler = handler
+    @response = response
+  end
+
+  def respond_with(code, type, body)
+    @handler.set_content_type(@response, type)
+    @handler.set_response(@response, body, code)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/http/route.rb

@@ -0,0 +1,100 @@
+class Puppet::Network::HTTP::Route
+  MethodNotAllowedHandler = lambda do |req, res|
+    raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError.new("method #{req.method} not allowed for route #{req.path}", Puppet::Network::HTTP::Issues::UNSUPPORTED_METHOD)
+  end
+
+  NO_HANDLERS = [MethodNotAllowedHandler]
+
+  attr_reader :path_matcher
+
+  def self.path(path_matcher)
+    new(path_matcher)
+  end
+
+  def initialize(path_matcher)
+    @path_matcher = path_matcher
+    @method_handlers = {
+      :GET => NO_HANDLERS,
+      :HEAD => NO_HANDLERS,
+      :OPTIONS => NO_HANDLERS,
+      :POST => NO_HANDLERS,
+      :PUT => NO_HANDLERS,
+      :DELETE => NO_HANDLERS
+    }
+    @chained = []
+  end
+
+  def get(*handlers)
+    @method_handlers[:GET] = handlers
+    return self
+  end
+
+  def head(*handlers)
+    @method_handlers[:HEAD] = handlers
+    return self
+  end
+
+  def options(*handlers)
+    @method_handlers[:OPTIONS] = handlers
+    return self
+  end
+
+  def post(*handlers)
+    @method_handlers[:POST] = handlers
+    return self
+  end
+
+  def put(*handlers)
+    @method_handlers[:PUT] = handlers
+    return self
+  end
+
+  def delete(*handlers)
+    @method_handlers[:DELETE] = handlers
+    return self
+  end
+
+  def any(*handlers)
+    @method_handlers.each do |method, registered_handlers|
+      @method_handlers[method] = handlers
+    end
+    return self
+  end
+
+  def chain(*routes)
+    @chained = routes
+    self
+  end
+
+  def matches?(request)
+    Puppet.debug("Evaluating match for #{self.inspect}")
+    if match(request.routing_path)
+      return true
+    else
+      Puppet.debug("Did not match path (#{request.routing_path.inspect})")
+    end
+    return false
+  end
+
+  def process(request, response)
+    handlers = @method_handlers[request.method.upcase.intern] || NO_HANDLERS
+    handlers.each do |handler|
+      handler.call(request, response)
+    end
+
+    subrequest = request.route_into(match(request.routing_path).to_s)
+    if chained_route = @chained.find { |route| route.matches?(subrequest) }
+      chained_route.process(subrequest, response)
+    end
+  end
+
+  def inspect
+    "Route #{@path_matcher.inspect}"
+  end
+
+  private
+
+  def match(path)
+    @path_matcher.match(path)
+  end
+end