RubyGems - bolt - Versions diffs - 0.24.0 → 0.25.0 - Mend

bolt 0.24.0 → 0.25.0

Potentially problematic release.

This version of bolt might be problematic. Click here for more details.

Files changed (1155) hide show

data/vendored/puppet/lib/puppet/indirector/report/rest.rb DELETED

@@ -1,28 +0,0 @@
-require 'puppet/indirector/rest'
-require 'semantic_puppet'
-class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
-  desc "Get server report over HTTP via REST."
-  use_server_setting(:report_server)
-  use_port_setting(:report_port)
-  use_srv_service(:report)
-  def handle_response(request, response)
-    if !response.is_a?(Net::HTTPSuccess)
-      server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]
-      if server_version &&
-         SemanticPuppet::Version.parse(server_version).major < Puppet::Indirector::REST::MAJOR_VERSION_JSON_DEFAULT &&
-         Puppet[:preferred_serialization_format] != 'pson'
-        format = Puppet[:preferred_serialization_format]
-        raise Puppet::Error.new(_("Server version %{version} does not accept reports in '%{format}', use `preferred_serialization_format=pson`") % {version: server_version, format: format})
-      end
-    end
-  end
-  private
-  def deserialize_save(content_type, body)
-    format = Puppet::Network::FormatHandler.format_for(content_type)
-    format.intern(Array, body)
-  end
-end

data/vendored/puppet/lib/puppet/indirector/report/yaml.rb DELETED

@@ -1,11 +0,0 @@
-require 'puppet/transaction/report'
-require 'puppet/indirector/yaml'
-class Puppet::Transaction::Report::Yaml < Puppet::Indirector::Yaml
-  desc "Store last report as a flat file, serialized using YAML."
-  # Force report to be saved there
-  def path(name,ext='.yaml')
-    Puppet[:lastrunreport]
-  end
-end

data/vendored/puppet/lib/puppet/indirector/request.rb DELETED

@@ -1,278 +0,0 @@
-require 'cgi'
-require 'uri'
-require 'puppet/indirector'
-require 'puppet/network/resolver'
-require 'puppet/util/psych_support'
-# This class encapsulates all of the information you need to make an
-# Indirection call, and as a result also handles REST calls.  It's somewhat
-# analogous to an HTTP Request object, except tuned for our Indirector.
-class Puppet::Indirector::Request
-  include Puppet::Util::PsychSupport
-  attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_cache_save, :ignore_terminus
-  attr_accessor :server, :port, :uri, :protocol
-  attr_reader :indirection_name
-  # trusted_information is specifically left out because we can't serialize it
-  # and keep it "trusted"
-  OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :ignore_cache_save, :instance, :environment]
-  # Is this an authenticated request?
-  def authenticated?
-    # Double negative, so we just get true or false
-    ! ! authenticated
-  end
-  def environment
-    # If environment has not been set directly, we should use the application's
-    # current environment
-    @environment ||= Puppet.lookup(:current_environment)
-  end
-  def environment=(env)
-    @environment =
-    if env.is_a?(Puppet::Node::Environment)
-      env
-    else
-      Puppet.lookup(:environments).get!(env)
-    end
-  end
-  # LAK:NOTE This is a messy interface to the cache, and it's only
-  # used by the Configurer class.  I decided it was better to implement
-  # it now and refactor later, when we have a better design, than
-  # to spend another month coming up with a design now that might
-  # not be any better.
-  def ignore_cache?
-    ignore_cache
-  end
-  def ignore_cache_save?
-    ignore_cache_save
-  end
-  def ignore_terminus?
-    ignore_terminus
-  end
-  def initialize(indirection_name, method, key, instance, options = {})
-    @instance = instance
-    options ||= {}
-    self.indirection_name = indirection_name
-    self.method = method
-    options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
-    set_attributes(options)
-    @options = options
-    if key
-      # If the request key is a URI, then we need to treat it specially,
-      # because it rewrites the key.  We could otherwise strip server/port/etc
-      # info out in the REST class, but it seemed bad design for the REST
-      # class to rewrite the key.
-      if key.to_s =~ /^\w+:\// and not Puppet::Util.absolute_path?(key.to_s) # it's a URI
-        set_uri_key(key)
-      else
-        @key = key
-      end
-    end
-    @key = @instance.name if ! @key and @instance
-  end
-  # Look up the indirection based on the name provided.
-  def indirection
-    Puppet::Indirector::Indirection.instance(indirection_name)
-  end
-  def indirection_name=(name)
-    @indirection_name = name.to_sym
-  end
-  def model
-    raise ArgumentError, _("Could not find indirection '%{indirection}'") % { indirection: indirection_name } unless i = indirection
-    i.model
-  end
-  # Are we trying to interact with multiple resources, or just one?
-  def plural?
-    method == :search
-  end
-  # Create the query string, if options are present.
-  def query_string
-    return "" if options.nil? || options.empty?
-    encode_params(expand_into_parameters(options.to_a))
-  end
-  def expand_into_parameters(data)
-    data.inject([]) do |params, key_value|
-      key, value = key_value
-      expanded_value = case value
-                       when Array
-                         value.collect { |val| [key, val] }
-                       else
-                         [key_value]
-                       end
-      params.concat(expand_primitive_types_into_parameters(expanded_value))
-    end
-  end
-  def expand_primitive_types_into_parameters(data)
-    data.inject([]) do |params, key_value|
-      key, value = key_value
-      case value
-      when nil
-        params
-      when true, false, String, Symbol, Integer, Float
-        params << [key, value]
-      else
-        raise ArgumentError, _("HTTP REST queries cannot handle values of type '%{klass}'") % { klass: value.class }
-      end
-    end
-  end
-  def encode_params(params)
-    params.collect do |key, value|
-      "#{key}=#{Puppet::Util.uri_query_encode(value.to_s)}"
-    end.join("&")
-  end
-  def initialize_from_hash(hash)
-    @indirection_name = hash['indirection_name'].to_sym
-    @method = hash['method'].to_sym
-    @key = hash['key']
-    @instance = hash['instance']
-    @options = hash['options']
-  end
-  def to_data_hash
-    { 'indirection_name' => @indirection_name.to_s,
-      'method' => @method.to_s,
-      'key' => @key,
-      'instance' => @instance,
-      'options' => @options }
-  end
-  def to_hash
-    result = options.dup
-    OPTION_ATTRIBUTES.each do |attribute|
-      if value = send(attribute)
-        result[attribute] = value
-      end
-    end
-    result
-  end
-  def description
-    return(uri ? uri : "/#{indirection_name}/#{key}")
-  end
-  def do_request(srv_service=:puppet, default_server=nil, default_port=nil, &block)
-    # We were given a specific server to use, so just use that one.
-    # This happens if someone does something like specifying a file
-    # source using a puppet:// URI with a specific server.
-    return yield(self) if !self.server.nil?
-    if Puppet.settings[:use_srv_records]
-      # We may want to consider not creating a new resolver here
-      # every request eventually, to take advantage of the resolver's
-      # caching behavior.
-      resolver = Puppet::Network::Resolver.new
-      resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
-        begin
-          self.server = srv_server
-          self.port   = srv_port
-          return yield(self)
-        rescue SystemCallError => e
-          Puppet.warning _("Error connecting to %{srv_server}:%{srv_port}: %{message}") % { srv_server: srv_server, srv_port: srv_port, message: e.message }
-        end
-      end
-    end
-    # ... Fall back onto the default server.
-    bound_server = Puppet.lookup(:server) do
-      if primary_server = Puppet.settings[:server_list][0]
-        primary_server[0]
-      else
-        Puppet.settings[:server]
-      end
-    end
-    bound_port = Puppet.lookup(:serverport) do
-      if primary_server = Puppet.settings[:server_list][0]
-        primary_server[1]
-      else
-        Puppet.settings[:masterport]
-      end
-    end
-    self.server = default_server || bound_server
-    self.port   = default_port || bound_port
-    Puppet.debug "No more servers left, falling back to #{self.server}:#{self.port}" if Puppet.settings[:use_srv_records]
-    return yield(self)
-  end
-  def remote?
-    self.node or self.ip
-  end
-  private
-  def set_attributes(options)
-    OPTION_ATTRIBUTES.each do |attribute|
-      if options.include?(attribute.to_sym)
-        send(attribute.to_s + "=", options[attribute])
-        options.delete(attribute)
-      end
-    end
-  end
-  # Parse the key as a URI, setting attributes appropriately.
-  def set_uri_key(key)
-    @uri = key
-    begin
-      # calling uri_encode for UTF-8 characters will % escape them and keep them UTF-8
-      uri = URI.parse(Puppet::Util.uri_encode(key))
-    rescue => detail
-      raise ArgumentError, _("Could not understand URL %{key}: %{detail}") % { key: key, detail: detail }, detail.backtrace
-    end
-    # Just short-circuit these to full paths
-    if uri.scheme == "file"
-      @key = Puppet::Util.uri_to_path(uri)
-      return
-    end
-    @server = uri.host if uri.host
-    # If the URI class can look up the scheme, it will provide a port,
-    # otherwise it will default to '0'.
-    if uri.port.to_i == 0 and uri.scheme == "puppet"
-      @port = Puppet.settings[:masterport].to_i
-    else
-      @port = uri.port.to_i
-    end
-    # filebucket:// is only used internally to pass request details
-    # from Dipper objects to the indirector. The wire always uses HTTPS.
-    if uri.scheme == 'filebucket'
-      @protocol = 'https'
-    else
-      @protocol = uri.scheme
-    end
-    @key = URI.unescape(uri.path.sub(/^\//, ''))
-  end
-end

data/vendored/puppet/lib/puppet/indirector/resource/ral.rb DELETED

@@ -1,63 +0,0 @@
-require 'puppet/indirector/resource/validator'
-class Puppet::Resource::Ral < Puppet::Indirector::Code
-  include Puppet::Resource::Validator
-  desc "Manipulate resources with the resource abstraction layer. Only used internally."
-  def allow_remote_requests?
-    false
-  end
-  def find( request )
-    # find by name
-    res   = type(request).instances.find { |o| o.name == resource_name(request) }
-    res ||= type(request).new(:name => resource_name(request), :audit => type(request).properties.collect { |s| s.name })
-    res.to_resource
-  end
-  def search( request )
-    conditions = request.options.dup
-    conditions[:name] = resource_name(request) if resource_name(request)
-    type(request).instances.map do |res|
-      res.to_resource
-    end.find_all do |res|
-      conditions.all? {|property, value| res.to_resource[property].to_s == value.to_s}
-    end.sort do |a,b|
-      a.title <=> b.title
-    end
-  end
-  def save( request )
-    # In RAL-land, to "save" means to actually try to change machine state
-    res = request.instance
-    ral_res = res.to_ral
-    catalog = Puppet::Resource::Catalog.new(nil, request.environment)
-    catalog.add_resource ral_res
-    transaction = catalog.apply
-    [ral_res.to_resource, transaction.report]
-  end
-  private
-  # {type,resource}_name: the resource name may contain slashes:
-  # File["/etc/hosts"]. To handle, assume the type name does
-  # _not_ have any slashes in it, and split only on the first.
-  def type_name( request )
-    request.key.split('/', 2)[0]
-  end
-  def resource_name( request )
-    name = request.key.split('/', 2)[1]
-    name unless name == ""
-  end
-  def type( request )
-    Puppet::Type.type(type_name(request)) or raise Puppet::Error, _("Could not find type %{request_type}") % { request_type: type_name(request) }
-  end
-end

data/vendored/puppet/lib/puppet/indirector/resource/store_configs.rb DELETED

@@ -1,12 +0,0 @@
-require 'puppet/indirector/store_configs'
-require 'puppet/indirector/resource/validator'
-class Puppet::Resource::StoreConfigs < Puppet::Indirector::StoreConfigs
-  include Puppet::Resource::Validator
-  desc %q{Part of the "storeconfigs" feature. Should not be directly set by end users.}
-  def allow_remote_requests?
-    false
-  end
-end

data/vendored/puppet/lib/puppet/indirector/resource/validator.rb DELETED

@@ -1,8 +0,0 @@
-module Puppet::Resource::Validator
-  def validate_key(request)
-    type, title = request.key.split('/', 2)
-    unless type.downcase == request.instance.type.downcase and title == request.instance.title
-      raise Puppet::Indirector::ValidationError, _("Resource instance does not match request key")
-    end
-  end
-end

data/vendored/puppet/lib/puppet/indirector/rest.rb DELETED

@@ -1,301 +0,0 @@
-require 'net/http'
-require 'uri'
-require 'puppet/util/json'
-require 'puppet/util/connection'
-require 'semantic_puppet'
-require 'puppet/network/http'
-require 'puppet/network/http_pool'
-# Access objects via REST
-class Puppet::Indirector::REST < Puppet::Indirector::Terminus
-  include Puppet::Network::HTTP::Compression.module
-  IndirectedRoutes = Puppet::Network::HTTP::API::IndirectedRoutes
-  EXCLUDED_FORMATS = [:yaml, :b64_zlib_yaml, :dot]
-  # puppet major version where JSON is enabled by default
-  MAJOR_VERSION_JSON_DEFAULT = 5
-  class << self
-    attr_reader :server_setting, :port_setting
-  end
-  # Specify the setting that we should use to get the server name.
-  def self.use_server_setting(setting)
-    @server_setting = setting
-  end
-  # Specify the setting that we should use to get the port.
-  def self.use_port_setting(setting)
-    @port_setting = setting
-  end
-  # Specify the service to use when doing SRV record lookup
-  def self.use_srv_service(service)
-    @srv_service = service
-  end
-  def self.srv_service
-    @srv_service || :puppet
-  end
-  # Select the server to use based on the settings configuration
-  # for this indirection, taking into account the HA server list.
-  def self.server
-    Puppet::Util::Connection.determine_server(server_setting)
-  end
-  # Select the port to use based on the settings configuration
-  # for this indirection, taking into account the HA server list.
-  def self.port
-    Puppet::Util::Connection.determine_port(port_setting, server_setting)
-  end
-  # Provide appropriate headers.
-  def headers
-    # yaml is not allowed on the network
-    network_formats = model.supported_formats - EXCLUDED_FORMATS
-    mime_types = network_formats.map { |f| model.get_format(f).mime }
-    common_headers = {
-      "Accept"                                     => mime_types.join(', '),
-      Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version
-    }
-    add_accept_encoding(common_headers)
-  end
-  def add_profiling_header(headers)
-    if (Puppet[:profile])
-      headers[Puppet::Network::HTTP::HEADER_ENABLE_PROFILING] = "true"
-    end
-    headers
-  end
-  def network(request)
-    Puppet::Network::HttpPool.http_instance(request.server || self.class.server,
-                                            request.port || self.class.port)
-  end
-  def http_get(request, path, headers = nil, *args)
-    http_request(:get, request, path, add_profiling_header(headers), *args)
-  end
-  def http_post(request, path, data, headers = nil, *args)
-    http_request(:post, request, path, data, add_profiling_header(headers), *args)
-  end
-  def http_head(request, path, headers = nil, *args)
-    http_request(:head, request, path, add_profiling_header(headers), *args)
-  end
-  def http_delete(request, path, headers = nil, *args)
-    http_request(:delete, request, path, add_profiling_header(headers), *args)
-  end
-  def http_put(request, path, data, headers = nil, *args)
-    http_request(:put, request, path, data, add_profiling_header(headers), *args)
-  end
-  def http_request(method, request, *args)
-    conn = network(request)
-    conn.send(method, *args)
-  end
-  def find(request)
-    uri, body = IndirectedRoutes.request_to_uri_and_body(request)
-    uri_with_query_string = "#{uri}?#{body}"
-    response = do_request(request) do |req|
-      # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
-      # http://redmine.ruby-lang.org/issues/show/3991
-      if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
-        uri_with_env = "#{uri}?environment=#{request.environment.name}"
-        http_post(req, uri_with_env, body, headers)
-      else
-        http_get(req, uri_with_query_string, headers)
-      end
-    end
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      result = deserialize_find(content_type, body)
-      result.name = request.key if result.respond_to?(:name=)
-      result
-    elsif is_http_404?(response)
-      return nil unless request.options[:fail_on_404]
-      # 404 can get special treatment as the indirector API can not produce a meaningful
-      # reason to why something is not found - it may not be the thing the user is
-      # expecting to find that is missing, but something else (like the environment).
-      # While this way of handling the issue is not perfect, there is at least an error
-      # that makes a user aware of the reason for the failure.
-      #
-      _, body = parse_response(response)
-      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(uri_with_query_string, 100), body: body }
-      raise Puppet::Error, msg
-    else
-      nil
-    end
-  end
-  def head(request)
-    response = do_request(request) do |req|
-      http_head(req, IndirectedRoutes.request_to_uri(req), headers)
-    end
-    if is_http_200?(response)
-      true
-    else
-      false
-    end
-  end
-  def search(request)
-    response = do_request(request) do |req|
-      http_get(req, IndirectedRoutes.request_to_uri(req), headers)
-    end
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_search(content_type, body) || []
-    else
-      []
-    end
-  end
-  def destroy(request)
-    raise ArgumentError, _("DELETE does not accept options") unless request.options.empty?
-    response = do_request(request) do |req|
-      http_delete(req, IndirectedRoutes.request_to_uri(req), headers)
-    end
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_destroy(content_type, body)
-    else
-      nil
-    end
-  end
-  def save(request)
-    raise ArgumentError, _("PUT does not accept options") unless request.options.empty?
-    response = do_request(request) do |req|
-      http_put(req, IndirectedRoutes.request_to_uri(req), req.instance.render, headers.merge({ "Content-Type" => req.instance.mime }))
-    end
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_save(content_type, body)
-    else
-      nil
-    end
-  end
-  # Encapsulate call to request.do_request with the arguments from this class
-  # Then yield to the code block that was called in
-  # We certainly could have retained the full request.do_request(...) { |r| ... }
-  # but this makes the code much cleaner and we only then actually make the call
-  # to request.do_request from here, thus if we change what we pass or how we
-  # get it, we only need to change it here.
-  def do_request(request)
-    response = request.do_request(self.class.srv_service, self.class.server, self.class.port) { |req| yield(req) }
-    handle_response(request, response) if response
-    response
-  end
-  def handle_response(request, response)
-    server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]
-    if server_version
-      Puppet.lookup(:server_agent_version) do
-        Puppet.push_context(:server_agent_version => server_version)
-      end
-      if SemanticPuppet::Version.parse(server_version).major < MAJOR_VERSION_JSON_DEFAULT &&
-          Puppet[:preferred_serialization_format] != 'pson'
-        #TRANSLATORS "PSON" should not be translated
-        Puppet.warning(_("Downgrading to PSON for future requests"))
-        Puppet[:preferred_serialization_format] = 'pson'
-      end
-    end
-  end
-  def validate_key(request)
-    # Validation happens on the remote end
-  end
-  private
-  def is_http_200?(response)
-    case response.code
-    when "404"
-      false
-    when /^2/
-      true
-    else
-      # Raise the http error if we didn't get a 'success' of some kind.
-      raise convert_to_http_error(response)
-    end
-  end
-  def is_http_404?(response)
-    response.code == "404"
-  end
-  def convert_to_http_error(response)
-    if response.body.to_s.empty? && response.respond_to?(:message)
-      returned_message = response.message
-    elsif response['content-type'].is_a?(String)
-      content_type, body = parse_response(response)
-      if content_type =~ /[pj]son/
-        returned_message = Puppet::Util::Json.load(body)["message"]
-      else
-        returned_message = uncompress_body(response)
-      end
-    else
-      returned_message = uncompress_body(response)
-    end
-    message = _("Error %{code} on SERVER: %{returned_message}") % { code: response.code, returned_message: returned_message }
-    Net::HTTPError.new(message, response)
-  end
-  # Returns the content_type, stripping any appended charset, and the
-  # body, decompressed if necessary (content-encoding is checked inside
-  # uncompress_body)
-  def parse_response(response)
-    if response['content-type']
-      [ response['content-type'].gsub(/\s*;.*$/,''), uncompress_body(response) ]
-    else
-      raise _("No content type in http response; cannot parse")
-    end
-  end
-  def deserialize_find(content_type, body)
-    model.convert_from(content_type, body)
-  end
-  def deserialize_search(content_type, body)
-    model.convert_from_multiple(content_type, body)
-  end
-  def deserialize_destroy(content_type, body)
-    model.convert_from(content_type, body)
-  end
-  def deserialize_save(content_type, body)
-    nil
-  end
-  def elide(string, length)
-    if Puppet::Util::Log.level == :debug || string.length <= length
-      string
-    else
-      string[0, length - 3] + "..."
-    end
-  end
-end