bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/network/http/rack.rb

@@ -1,33 +0,0 @@
-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: \"%{message}\"") % { message: detail.message }
-      # log what happened
-      Puppet.log_exception(detail, _("Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%{message}\"") % { message: detail.message })
-    end
-    response.finish
-  end
-end
-

data/vendored/puppet/lib/puppet/network/http/rack/rest.rb

@@ -1,162 +0,0 @@
-require 'openssl'
-require 'cgi'
-require 'puppet/network/http/handler'
-require 'puppet/util/ssl'
-require 'uri'
-
-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.master_routes,
-              Puppet::Network::HTTP::API.ca_routes,
-              Puppet::Network::HTTP::API.not_found_upgrade])
-  end
-
-  def set_content_type(response, format)
-    response[ContentType] = 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)
-    # The value that Passenger provides for 'path' is escaped
-    # (URL percent-encoded), see
-    # https://github.com/phusion/passenger/blob/release-5.0.26/src/apache2_module/Hooks.cpp#L885
-    # for the implementation as hooked up to an Apache web server.  Code
-    # in the indirector / HTTP layer which consumes this path, however, assumes
-    # that it has already been unescaped, so it is unescaped here.
-    if request.path
-      # don't use CGI.unescape which mangles space handling
-      URI.unescape(request.path.encode(Encoding::UTF_8))
-    end
-  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?
-      # When running with unicorn, the SSL_CLIENT_CERT variable is not available
-      # in the environment, therefore we have to pass a header: 'X-SSL-Client-Cert'
-      cert = request.env['HTTP_X_SSL_CLIENT_CERT']
-      if cert.nil? || cert.empty?
-        nil
-      else
-        # in contrast to the environment variable, the client cert is passed in
-        # as single string, therefore restore the certificate to a valid pem
-        # encoded certificate
-        cert.gsub!(/ /, "\n")
-        cert.gsub!(/BEGIN\nCERT/, "BEGIN CERT")
-        cert.gsub!(/END\nCERT/, "END CERT")
-        cert = Puppet::SSL::Certificate.from_instance(OpenSSL::X509::Certificate.new(cert))
-        cert
-      end
-    else
-      Puppet::SSL::Certificate.from_instance(OpenSSL::X509::Certificate.new(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/vendored/puppet/lib/puppet/network/http/request.rb

@@ -1,70 +0,0 @@
-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: %{args}") % { args: 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 formatter
-    if header = headers['content-type']
-      header.gsub!(/\s*;.*$/,'') # strip any charset
-      format = Puppet::Network::FormatHandler.mime(header)
-
-      return format if valid_network_format?(format)
-
-      #TRANSLATORS "mime-type" is a keyword and should not be translated
-      raise Puppet::Network::HTTP::Error::HTTPUnsupportedMediaTypeError.new(
-              _("Client sent a mime-type (%{header}) that doesn't correspond to a format we support") % { header: headers['content-type'] },
-              Puppet::Network::HTTP::Issues::UNSUPPORTED_MEDIA_TYPE)
-    end
-
-    raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-            _("No Content-Type header was received, it isn't possible to unserialize the request"),
-            Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
-  end
-
-  def response_formatters_for(supported_formats, default_accepted_formats = nil)
-    accepted_formats = headers['accept'] || default_accepted_formats
-
-    if accepted_formats.nil?
-      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(_("Missing required Accept header"), Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
-    end
-
-    formats = Puppet::Network::FormatHandler.most_suitable_formats_for(
-      accepted_formats.split(/\s*,\s*/),
-      supported_formats)
-
-    formats.find_all do |format|
-      # we are only passed supported_formats that are suitable
-      # and whose klass implements the required_methods
-      valid_network_format?(format)
-    end
-
-    return formats unless formats.empty?
-
-    raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new(
-      _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: accepted_formats },
-      Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
-  end
-
-  private
-
-  def valid_network_format?(format)
-    # YAML in network requests is not supported. See http://links.puppet.com/deprecate_yaml_on_network
-    format != nil && format.name != :yaml && format.name != :b64_zlib_yaml
-  end
-end

data/vendored/puppet/lib/puppet/network/http/response.rb

@@ -1,23 +0,0 @@
-class Puppet::Network::HTTP::Response
-  def initialize(handler, response)
-    @handler = handler
-    @response = response
-  end
-
-  def respond_with(code, type, body)
-    format = Puppet::Network::FormatHandler.format_for(type)
-    mime = format.mime
-    charset = format.charset
-
-    if charset
-      if body.is_a?(String) && body.encoding != charset
-        body.encode!(charset)
-      end
-
-      mime += "; charset=#{charset.name.downcase}"
-    end
-
-    @handler.set_content_type(@response, mime)
-    @handler.set_response(@response, body, code)
-  end
-end

data/vendored/puppet/lib/puppet/network/http/route.rb

@@ -1,100 +0,0 @@
-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

data/vendored/puppet/lib/puppet/network/http/session.rb

@@ -1,17 +0,0 @@
-# An HTTP session that references a persistent HTTP connection and
-# an expiration time for the connection.
-#
-# @api private
-#
-class Puppet::Network::HTTP::Session
-  attr_reader :connection
-
-  def initialize(connection, expiration_time)
-    @connection = connection
-    @expiration_time = expiration_time
-  end
-
-  def expired?(now)
-    @expiration_time <= now
-  end
-end

data/vendored/puppet/lib/puppet/network/http/site.rb

@@ -1,39 +0,0 @@
-# Represents a site to which HTTP connections are made. It is a value
-# object, and is suitable for use in a hash. If two sites are equal,
-# then a persistent connection made to the first site, can be re-used
-# for the second.
-#
-# @api private
-#
-class Puppet::Network::HTTP::Site
-  attr_reader :scheme, :host, :port
-
-  def initialize(scheme, host, port)
-    @scheme = scheme
-    @host = host
-    @port = port.to_i
-  end
-
-  def addr
-    "#{@scheme}://#{@host}:#{@port.to_s}"
-  end
-  alias to_s addr
-
-  def ==(rhs)
-    (@scheme == rhs.scheme) && (@host == rhs.host) && (@port == rhs.port)
-  end
-
-  alias eql? ==
-
-  def hash
-    [@scheme, @host, @port].hash
-  end
-
-  def use_ssl?
-    @scheme == 'https'
-  end
-
-  def move_to(uri)
-    self.class.new(uri.scheme, uri.host, uri.port)
-  end
-end