bolt 0.0.1 → 0.5.0

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

@@ -0,0 +1,73 @@
+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 HTTPUnsupportedMediaTypeError < HTTPError
+    CODE = 415
+    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
+      super(_("Unsupported Media Type: ") + message, CODE, issue_kind)
+    end
+  end
+
+  class HTTPServerError < HTTPError
+    CODE = 500
+
+    def initialize(original_error, issue_kind = Issues::RUNTIME_ERROR)
+      super(_("Server Error: ") + original_error.message, CODE, issue_kind)
+    end
+
+    def to_json
+      JSON({:message => message, :issue_kind => @issue_kind})
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'openssl'
+require 'net/http'
+require 'puppet/util/http_proxy'
+
+# Factory for <tt>Net::HTTP</tt> objects.
+#
+# Encapsulates the logic for creating a <tt>Net::HTTP</tt> object based on the
+# specified {Puppet::Network::HTTP::Site Site} and puppet settings.
+#
+# @api private
+#
+class Puppet::Network::HTTP::Factory
+  @@openssl_initialized = false
+
+  def initialize
+    # PUP-1411, make sure that openssl is initialized before we try to connect
+    if ! @@openssl_initialized
+      OpenSSL::SSL::SSLContext.new
+      @@openssl_initialized = true
+    end
+  end
+
+  def create_connection(site)
+    Puppet.debug("Creating new connection for #{site}")
+
+    args = [site.host, site.port]
+
+    unless Puppet::Util::HttpProxy.no_proxy?(site)
+      if Puppet[:http_proxy_host] == "none"
+        args << nil << nil
+      else
+        args << Puppet[:http_proxy_host] << Puppet[:http_proxy_port]
+      end
+    end
+
+    http = Net::HTTP.new(*args)
+    http.use_ssl = site.use_ssl?
+    http.read_timeout = Puppet[:http_read_timeout]
+    http.open_timeout = Puppet[:http_connect_timeout]
+
+    if Puppet[:http_debug]
+      http.set_debug_output($stderr)
+    end
+
+    http
+  end
+end

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

@@ -0,0 +1,183 @@
+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: %{regexes}") % { 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
+
+  # The mime type is always passed to the `set_content_type` method, so
+  # it is no longer necessary to retrieve the Format's mime type.
+  #
+  # @deprecated
+  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}") % { request_method: request_method, request_path: 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 %{request} %{path}") % { request: new_request.method, path: 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)
+    log_msg = [http_e.message, *e.backtrace].join("\n")
+    Puppet.err(log_msg)
+    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 %{ip}: %{detail}") % { ip: result[:ip], detail: 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(:info), request_params.object_id))
+    end
+  end
+
+  def remove_profiler(profiler)
+    profiler.shutdown
+    Puppet::Util::Profiler.remove_profiler(profiler)
+  end
+end

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

@@ -0,0 +1,12 @@
+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
+  UNSUPPORTED_MEDIA_TYPE = :UNSUPPORTED_MEDIA_TYPE
+end

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

@@ -0,0 +1,129 @@
+# 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}") % { site: site, detail: 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
+      setsockopts(http.instance_variable_get(:@socket))
+      http
+    end
+  end
+
+  # Set useful socket option(s) which lack from default settings in Net:HTTP
+  #
+  # @api private
+  def setsockopts(netio)
+    socket = netio.io
+    socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+  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