bolt 0.24.0 → 0.25.0

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

@@ -1,73 +0,0 @@
-require 'puppet/util/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
-      Puppet::Util::Json.dump({: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}") % { message: message }, CODE, issue_kind)
-    end
-  end
-
-  class HTTPNotFoundError < HTTPError
-    CODE = 404
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Not Found: %{message}") % { message: message }, CODE, issue_kind)
-    end
-  end
-
-  class HTTPNotAuthorizedError < HTTPError
-    CODE = 403
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Not Authorized: %{message}") % { message: message }, CODE, issue_kind)
-    end
-  end
-
-  class HTTPBadRequestError < HTTPError
-    CODE = 400
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Bad Request: %{message}") % { message: message }, CODE, issue_kind)
-    end
-  end
-
-  class HTTPMethodNotAllowedError < HTTPError
-    CODE = 405
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Method Not Allowed: %{message}") % { message: message }, CODE, issue_kind)
-    end
-  end
-
-  class HTTPUnsupportedMediaTypeError < HTTPError
-    CODE = 415
-    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Unsupported Media Type: %{message}") % { message: message }, CODE, issue_kind)
-    end
-  end
-
-  class HTTPServerError < HTTPError
-    CODE = 500
-
-    def initialize(original_error, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Server Error: %{message}") % { message: original_error.message }, CODE, issue_kind)
-    end
-
-    def to_json
-      Puppet::Util::Json.dump({:message => message, :issue_kind => @issue_kind})
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-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
-
-  KEEP_ALIVE_TIMEOUT = 2**31 - 1
-
-  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]
-    http.keep_alive_timeout = KEEP_ALIVE_TIMEOUT if http.respond_to?(:keep_alive_timeout=)
-
-    if Puppet[:sourceaddress]
-      Puppet.debug("Using source IP #{Puppet[:sourceaddress]}")
-      http.local_host = Puppet[:sourceaddress]
-    end
-
-    if Puppet[:http_debug]
-      http.set_debug_output($stderr)
-    end
-
-    http
-  end
-end

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

@@ -1,215 +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: %{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
-
-  # Create a generic puppet request from the implementation-specific request
-  # created by the web server
-  def make_generic_request(request)
-    request_path = path(request)
-
-    Puppet::Network::HTTP::Request.new(
-      headers(request),
-      params(request),
-      http_method(request),
-      request_path, # path
-      request_path, # routing_path
-      client_cert(request),
-      body(request)
-    )
-  end
-
-  def with_request_profiling(request)
-    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
-      yield
-    end
-  ensure
-    remove_profiler(profiler) if profiler
-  end
-
-  # handle an HTTP request
-  def process(external_request, response)
-    # The response_wrapper stores the response and modifies it as a side effect.
-    # The caller will use the original response
-    response_wrapper = Puppet::Network::HTTP::Response.new(self, response)
-    request = make_generic_request(external_request)
-
-    set_puppet_version_header(response)
-
-    respond_to_errors(response_wrapper) do
-      with_request_profiling(request) do
-        find_route_or_raise(request).process(request, response_wrapper)
-      end
-    end
-  end
-
-  def respond_to_errors(response)
-    yield
-  rescue Puppet::Network::HTTP::Error::HTTPError => e
-    Puppet.info(e.message)
-    respond_with_http_error(response, e)
-  rescue StandardError => e
-    http_e = Puppet::Network::HTTP::Error::HTTPServerError.new(e)
-    Puppet.err([http_e.message, *e.backtrace].join("\n"))
-    respond_with_http_error(response, http_e)
-  end
-
-  def respond_with_http_error(response, exception)
-    response.respond_with(exception.status, "application/json", exception.to_json)
-  end
-
-  def find_route_or_raise(request)
-    if route = @routes.find { |r| r.matches?(request) }
-      return route
-    else
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
-              _("No route for %{request} %{path}") % { request: request.method, path: request.path },
-              HANDLER_NOT_FOUND)
-    end
-  end
-
-  def set_puppet_version_header(response)
-    response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION] = Puppet.version
-  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 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

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

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

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

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