bolt 0.0.1 → 0.5.0

data/vendored/puppet/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/vendored/puppet/lib/puppet/network/http/rack/rest.rb

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

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

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

@@ -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

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

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

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