bolt 0.20.0 → 0.20.2

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

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

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

@@ -0,0 +1,278 @@
+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]
+      Puppet::Network::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.
+    begin
+      bound_server = Puppet.lookup(:server)
+    rescue
+      if primary_server = Puppet.settings[:server_list][0]
+        bound_server = primary_server[0]
+      else
+        bound_server = Puppet.settings[:server]
+      end
+    end
+
+    begin
+      bound_port = Puppet.lookup(:serverport)
+    rescue
+      if primary_server = Puppet.settings[:server_list][0]
+        bound_port = primary_server[1]
+      else
+        bound_port = 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

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

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

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

@@ -0,0 +1,350 @@
+require 'net/http'
+require 'uri'
+require 'json'
+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
+
+  # The logic for server and port is kind of gross. In summary:
+  # IF an endpoint-specific setting is requested AND that setting has been set by the user
+  #    Use that setting.
+  #         The defaults for these settings are the "normal" server/masterport settings, so
+  #         when they are unset we instead want to "fall back" to the failover-selected
+  #         host/port pair.
+  # ELSE IF we have a failover-selected host/port
+  #    Use what the failover logic came up with
+  # ELSE IF the server_list setting is in use
+  #    Use the first entry - failover hasn't happened yet, but that
+  #    setting is still authoritative
+  # ELSE
+  #    Go for the legacy server/masterport settings, and hope for the best
+  def self.server
+    setting = server_setting()
+    if setting && setting != :server && Puppet.settings.set_by_config?(setting)
+      Puppet.settings[setting]
+    else
+      begin
+        Puppet.lookup(:server)
+      rescue
+        if primary_server = Puppet.settings[:server_list][0]
+          Puppet.debug "Dynamically-bound server lookup failed; using first entry"
+          primary_server[0]
+        else
+          setting ||= :server
+          Puppet.debug "Dynamically-bound server lookup failed, falling back to #{setting} setting"
+          Puppet.settings[setting]
+        end
+      end
+    end
+  end
+
+  # For port there's a little bit of an extra snag: setting a specific
+  # server setting and relying on the default port for that server is
+  # common, so we also want to check if the assocaited SERVER setting
+  # has been set by the user. If either of those are set we ignore the
+  # failover-selected port.
+  def self.port
+    setting = port_setting()
+    srv_setting = server_setting()
+    if (setting && setting != :masterport && Puppet.settings.set_by_config?(setting)) ||
+       (srv_setting && srv_setting != :server && Puppet.settings.set_by_config?(srv_setting))
+      Puppet.settings[setting].to_i
+    else
+      begin
+        Puppet.lookup(:serverport).to_i
+      rescue
+        if primary_server = Puppet.settings[:server_list][0]
+          Puppet.debug "Dynamically-bound port lookup failed; using first entry"
+
+          # Port might not be set, so we want to fallback in that
+          # case. We know we don't need to use `setting` here, since
+          # the default value of every port setting is `masterport`
+          (primary_server[1] || Puppet.settings[:masterport]).to_i
+        else
+          setting ||= :masterport
+          Puppet.debug "Dynamically-bound port lookup failed; falling back to #{setting} setting"
+          Puppet.settings[setting].to_i
+        end
+      end
+    end
+  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.push_context({:server_agent_version => server_version})
+      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 = JSON.parse(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