bolt 0.24.0 → 0.25.0

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

data/vendored/puppet/lib/puppet/network/http_pool.rb

@@ -1,61 +0,0 @@
-require 'puppet/network/http/connection'
-
-module Puppet::Network; end
-
-# This module contains the factory methods that should be used for getting a
-# {Puppet::Network::HTTP::Connection} instance. The pool may return a new
-# connection or a persistent cached connection, depending on the underlying
-# pool implementation in use.
-#
-# @api public
-#
-module Puppet::Network::HttpPool
-
-  @http_client_class = Puppet::Network::HTTP::Connection
-
-  def self.http_client_class
-    @http_client_class
-  end
-  def self.http_client_class=(klass)
-    @http_client_class = klass
-  end
-
-  # Retrieve a connection for the given host and port.
-  #
-  # @param host [String] The hostname to connect to
-  # @param port [Integer] The port on the host to connect to
-  # @param use_ssl [Boolean] Whether to use an SSL connection
-  # @param verify_peer [Boolean] Whether to verify the peer credentials, if possible. Verification will not take place if the CA certificate is missing.
-  # @return [Puppet::Network::HTTP::Connection]
-  #
-  # @api public
-  #
-  def self.http_instance(host, port, use_ssl = true, verify_peer = true)
-    verifier = if verify_peer
-                 Puppet::SSL::Validator.default_validator()
-               else
-                 Puppet::SSL::Validator.no_validator()
-               end
-
-    http_client_class.new(host, port,
-                            :use_ssl => use_ssl,
-                            :verify => verifier)
-  end
-
-  # Get an http connection that will be secured with SSL and have the
-  # connection verified with the given verifier
-  #
-  # @param host [String] the DNS name to connect to
-  # @param port [Integer] the port to connect to
-  # @param verifier [#setup_connection, #peer_certs, #verify_errors] An object that will setup the appropriate
-  #   verification on a Net::HTTP instance and report any errors and the certificates used.
-  # @return [Puppet::Network::HTTP::Connection]
-  #
-  # @api public
-  #
-  def self.http_ssl_instance(host, port, verifier = Puppet::SSL::Validator.default_validator())
-    http_client_class.new(host, port,
-                            :use_ssl => true,
-                            :verify => verifier)
-  end
-end

data/vendored/puppet/lib/puppet/network/resolver.rb

@@ -1,158 +0,0 @@
-require 'resolv'
-
-module Puppet::Network
-  class Resolver
-
-    class CacheEntry
-      attr_reader :records, :ttl, :resolution_time
-
-      def initialize(records)
-        @records = records
-        @resolution_time = Time.now
-        @ttl = choose_lowest_ttl(records)
-      end
-
-      def choose_lowest_ttl(records)
-        ttl = records.first.ttl
-        records.each do |rec|
-          if rec.ttl < ttl
-            ttl = rec.ttl
-          end
-        end
-        ttl
-      end
-    end
-
-    def initialize
-      @resolver = Resolv::DNS.new
-
-      # Stores DNS records per service, along with their TTL
-      # and the time at which they were resolved, for cache
-      # eviction.
-      @record_cache = {}
-    end
-
-    # Iterate through the list of records for this service
-    # and yield each server and port pair. Records are only fetched
-    # via DNS query the first time and cached for the duration of their
-    # service's TTL thereafter.
-    # @param [String] domain the domain to search for
-    # @param [Symbol] service_name the key of the service we are querying
-    # @yields [String, Integer] server and port of selected record
-    def each_srv_record(domain, service_name = :puppet, &block)
-      if (domain.nil? or domain.empty?)
-        Puppet.debug "Domain not known; skipping SRV lookup"
-        return
-      end
-
-      Puppet.debug "Searching for SRV records for domain: #{domain}"
-
-      case service_name
-        when :puppet then service = '_x-puppet'
-        when :file   then service = '_x-puppet-fileserver'
-        else              service = "_x-puppet-#{service_name.to_s}"
-      end
-      record_name = "#{service}._tcp.#{domain}"
-
-      if @record_cache.has_key?(service_name) && !expired?(service_name)
-        records = @record_cache[service_name].records
-        Puppet.debug "Using cached record for #{record_name}"
-      else
-        records = @resolver.getresources(record_name, Resolv::DNS::Resource::IN::SRV)
-        if records.size > 0
-          @record_cache[service_name] = CacheEntry.new(records)
-        end
-        Puppet.debug "Found #{records.size} SRV records for: #{record_name}"
-      end
-
-      if records.size == 0 && service_name != :puppet
-        # Try the generic :puppet service if no SRV records were found
-        # for the specific service.
-        each_srv_record(domain, :puppet, &block)
-      else
-        each_priority(records) do |recs|
-          while next_rr = recs.delete(find_weighted_server(recs))
-            Puppet.debug "Yielding next server of #{next_rr.target.to_s}:#{next_rr.port}"
-            yield next_rr.target.to_s, next_rr.port
-          end
-        end
-      end
-    end
-
-    # Given a list of records of the same priority, chooses a random one
-    # from among them, favoring those with higher weights.
-    # @param [[Resolv::DNS::Resource::IN::SRV]] records a list of records
-    #        of the same priority
-    # @return [Resolv::DNS::Resource::IN:SRV] the chosen record
-    def find_weighted_server(records)
-      return nil if records.nil? || records.empty?
-      return records.first if records.size == 1
-
-      # Calculate the sum of all weights in the list of resource records,
-      # This is used to then select hosts until the weight exceeds what
-      # random number we selected.  For example, if we have weights of 1 8 and 3:
-      #
-      # |-|--------|---|
-      #        ^
-      # We generate a random number 5, and iterate through the records, adding
-      # the current record's weight to the accumulator until the weight of the
-      # current record plus previous records is greater than the random number.
-      total_weight = records.inject(0) { |sum,record|
-        sum + weight(record)
-      }
-      current_weight = 0
-      chosen_weight  = 1 + Kernel.rand(total_weight)
-
-      records.each do |record|
-        current_weight += weight(record)
-        return record if current_weight >= chosen_weight
-      end
-    end
-
-    def weight(record)
-      record.weight == 0 ? 1 : record.weight * 10
-    end
-
-    # Returns TTL for the cached records for this service.
-    # @param [String] service_name the service whose TTL we want
-    # @return [Integer] the TTL for this service, in seconds
-    def ttl(service_name)
-      return @record_cache[service_name].ttl
-    end
-
-    # Checks if the cached entry for the given service has expired.
-    # @param [String] service_name the name of the service to check
-    # @return [Boolean] true if the entry has expired, false otherwise.
-    #                  Always returns true if the record had no TTL.
-    def expired?(service_name)
-      if entry = @record_cache[service_name]
-        return Time.now > (entry.resolution_time + entry.ttl)
-      else
-        return true
-      end
-    end
-
-    private
-
-    # Groups the records by their priority and yields the groups
-    # in order of highest to lowest priority (lowest to highest numbers),
-    # one at a time.
-    # { 1 => [records], 2 => [records], etc. }
-    #
-    # @param [[Resolv::DNS::Resource::IN::SRV]] records the list of
-    #        records for a given service
-    # @yields [[Resolv::DNS::Resource::IN::SRV]] a group of records of
-    #         the same priority
-    def each_priority(records)
-      pri_hash = records.inject({}) do |groups, element|
-        groups[element.priority] ||= []
-        groups[element.priority] << element
-        groups
-      end
-
-      pri_hash.keys.sort.each do |key|
-        yield pri_hash[key]
-      end
-    end
-  end
-end