puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/resource/active_record.rb

@@ -0,0 +1,104 @@
+require 'puppet/indirector/active_record'
+require 'puppet/indirector/resource/validator'
+
+class Puppet::Resource::ActiveRecord < Puppet::Indirector::ActiveRecord
+  include Puppet::Resource::Validator
+
+  desc "A component of ActiveRecord storeconfigs. ActiveRecord-based storeconfigs
+    and inventory are deprecated. See http://links.puppetlabs.com/activerecord-deprecation"
+
+  def initialize
+    Puppet.deprecation_warning "ActiveRecord-based storeconfigs and inventory are deprecated. See http://links.puppetlabs.com/activerecord-deprecation"
+    super
+  end
+
+  def search(request)
+    type   = request_to_type_name(request)
+    host   = request.options[:host]
+    filter = request.options[:filter]
+
+    if filter and filter[1] =~ /^(and|or)$/i then
+      raise Puppet::Error, "Complex search on StoreConfigs resources is not supported"
+    end
+
+    query = build_active_record_query(type, host, filter)
+    Puppet::Rails::Resource.find(:all, query)
+  end
+
+  private
+  def request_to_type_name(request)
+    request.key.split('/', 2)[0] or
+      raise "No key found in the request, failing: #{request.inspect}"
+  end
+
+  def filter_to_active_record(filter)
+    # Don't call me if you don't have a filter, please.
+    filter.is_a?(Array) or raise ArgumentError, "active record filters must be arrays"
+    a, op, b = filter
+
+    case op
+    when /^(and|or)$/i then
+      extra = []
+      first, args = filter_to_active_record a
+      extra += args
+
+      second, args = filter_to_active_record b
+      extra += args
+
+      return "(#{first}) #{op.upcase} (#{second})", extra
+
+    when "==", "!=" then
+      op = '=' if op == '=='    # SQL, yayz!
+      case a
+      when "title" then
+        return "title #{op} ?", [b]
+
+      when "tag" then
+        return "puppet_tags.name #{op} ?", [b]
+
+      else
+        return "param_names.name = ? AND param_values.value #{op} ?", [a, b]
+      end
+
+    else
+      raise ArgumentError, "unknown operator #{op.inspect} in #{filter.inspect}"
+    end
+  end
+
+  def build_active_record_query(type, host, filter)
+    raise Puppet::DevError, "Cannot collect resources for a nil host" unless host
+
+    search = "(exported=? AND restype=?)"
+    arguments = [true, type]
+
+    if filter then
+      sql, values = filter_to_active_record(filter)
+      search    += " AND #{sql}"
+      arguments += values
+    end
+
+    # note: we're not eagerly including any relations here because it can
+    # create large numbers of objects that we will just throw out later.  We
+    # used to eagerly include param_names/values but the way the search filter
+    # is built ruined those efforts and we were eagerly loading only the
+    # searched parameter and not the other ones.
+    query = {}
+    case search
+    when /puppet_tags/
+      query = { :joins => { :resource_tags => :puppet_tag } }
+    when /param_name/
+      query = { :joins => { :param_values => :param_name } }
+    end
+
+    # We're going to collect objects from rails, but we don't want any
+    # objects from this host.
+    if host = Puppet::Rails::Host.find_by_name(host)
+      search += " AND (host_id != ?)"
+      arguments << host.id
+    end
+
+    query[:conditions] = [search, *arguments]
+
+    query
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/resource/ral.rb

@@ -0,0 +1,64 @@
+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?
+    Puppet.deprecation_warning("Accessing resources on the network is deprecated. See http://links.puppetlabs.com/deprecate-networked-resource")
+    super
+  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 #{type_name(request)}"
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/resource/rest.rb

@@ -0,0 +1,17 @@
+require 'puppet/indirector/status'
+require 'puppet/indirector/rest'
+
+# @deprecated
+class Puppet::Resource::Rest < Puppet::Indirector::REST
+
+  desc "Maniuplate resources remotely? Undocumented."
+
+  private
+
+  def deserialize_save(content_type, body)
+    # Body is [ral_res.to_resource, transaction.report]
+    format = Puppet::Network::FormatHandler.format_for(content_type)
+    ary = format.intern(Array, body)
+    [Puppet::Resource.from_data_hash(ary[0]), Puppet::Transaction::Report.from_data_hash(ary[1])]
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/resource/store_configs.rb

@@ -0,0 +1,13 @@
+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?
+    Puppet.deprecation_warning("Accessing resources on the network is deprecated. See http://links.puppetlabs.com/deprecate-networked-resource")
+    super
+  end
+end

data/vendor/gems/puppet-3.7.3/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/vendor/gems/puppet-3.7.3/lib/puppet/indirector/resource_type.rb

@@ -0,0 +1,5 @@
+require 'puppet/resource/type'
+
+# A stub class, so our constants work.
+class Puppet::Indirector::ResourceType # :nodoc:
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/resource_type/parser.rb

@@ -0,0 +1,101 @@
+require 'puppet/resource/type'
+require 'puppet/indirector/code'
+require 'puppet/indirector/resource_type'
+
+# The main terminus for Puppet::Resource::Type
+#
+# This exposes the known resource types from within Puppet. Only find
+# and search are supported. When a request is received, Puppet will
+# attempt to load all resource types (by parsing manifests and modules) and
+# returns a description of the resource types found. The format of these
+# objects is documented at {Puppet::Resource::Type}.
+#
+# @api public
+class Puppet::Indirector::ResourceType::Parser < Puppet::Indirector::Code
+  desc "Return the data-form of a resource type."
+
+  # Find will return the first resource_type with the given name. It is
+  # not possible to specify the kind of the resource type.
+  #
+  # @param request [Puppet::Indirector::Request] The request object.
+  #   The only parameters used from the request are `environment` and
+  #   `key`, which corresponds to the resource type's `name` field.
+  # @return [Puppet::Resource::Type, nil]
+  # @api public
+  def find(request)
+    Puppet.override(:squelch_parse_errors => true) do
+      krt = resource_types_in(request.environment)
+
+      # This is a bit ugly.
+      [:hostclass, :definition, :node].each do |type|
+        # We have to us 'find_<type>' here because it will
+        # load any missing types from disk, whereas the plain
+        # '<type>' method only returns from memory.
+        if r = krt.send("find_#{type}", [""], request.key)
+          return r
+        end
+      end
+      nil
+    end
+  end
+
+  # Search for resource types using a regular expression. Unlike `find`, this
+  # allows you to filter the results by the "kind" of the resource type
+  # ("class", "defined_type", or "node"). All three are searched if no
+  # `kind` filter is given. This also accepts the special string "`*`"
+  # to return all resource type objects.
+  #
+  # @param request [Puppet::Indirector::Request] The request object. The
+  #   `key` field holds the regular expression used to search, and
+  #   `options[:kind]` holds the kind query parameter to filter the
+  #   result as described above. The `environment` field specifies the
+  #   environment used to load resources.
+  #
+  # @return [Array<Puppet::Resource::Type>, nil]
+  #
+  # @api public
+  def search(request)
+    Puppet.override(:squelch_parse_errors => true) do
+
+      krt = resource_types_in(request.environment)
+      # Make sure we've got all of the types loaded.
+      krt.loader.import_all
+
+      result_candidates = case request.options[:kind]
+          when "class"
+            krt.hostclasses.values
+          when "defined_type"
+            krt.definitions.values
+          when "node"
+            krt.nodes.values
+          when nil
+            result_candidates = [krt.hostclasses.values, krt.definitions.values, krt.nodes.values]
+          else
+            raise ArgumentError, "Unrecognized kind filter: " +
+                      "'#{request.options[:kind]}', expected one " +
+                      " of 'class', 'defined_type', or 'node'."
+        end
+
+      result = result_candidates.flatten.reject { |t| t.name == "" }
+      return nil if result.empty?
+      return result if request.key == "*"
+
+      # Strip the regex of any wrapping slashes that might exist
+      key = request.key.sub(/^\//, '').sub(/\/$/, '')
+      begin
+        regex = Regexp.new(key)
+      rescue => detail
+        raise ArgumentError, "Invalid regex '#{request.key}': #{detail}", detail.backtrace
+      end
+
+      result.reject! { |t| t.name.to_s !~ regex }
+      return nil if result.empty?
+      result
+    end
+  end
+
+  def resource_types_in(environment)
+    environment.check_for_reparse
+    environment.known_resource_types
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/resource_type/rest.rb

@@ -0,0 +1,7 @@
+require 'puppet/resource/type'
+require 'puppet/indirector/rest'
+require 'puppet/indirector/resource_type'
+
+class Puppet::Indirector::ResourceType::Rest < Puppet::Indirector::REST
+  desc "Retrieve resource types via a REST HTTP interface."
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/rest.rb

@@ -0,0 +1,267 @@
+require 'net/http'
+require 'uri'
+
+require 'puppet/network/http'
+require 'puppet/network/http_pool'
+require 'puppet/network/http/api/v1'
+require 'puppet/network/http/compression'
+
+# Access objects via REST
+class Puppet::Indirector::REST < Puppet::Indirector::Terminus
+  include Puppet::Network::HTTP::Compression.module
+
+  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
+
+  def self.server
+    Puppet.settings[server_setting || :server]
+  end
+
+  def self.port
+    Puppet.settings[port_setting || :masterport].to_i
+  end
+
+  # Provide appropriate headers.
+  def headers
+    add_accept_encoding({"Accept" => model.supported_formats.join(", ")})
+  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 = Puppet::Network::HTTP::API::V1.request_to_uri_and_body(request)
+    uri_with_query_string = "#{uri}?#{body}"
+
+    response = do_request(request) do |request|
+      # 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
+        http_post(request, uri, body, headers)
+      else
+        http_get(request, uri_with_query_string, headers)
+      end
+    end
+
+    if is_http_200?(response)
+      check_master_version(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.
+      #
+      content_type, body = parse_response(response)
+      msg = "Find #{elide(uri_with_query_string, 100)} resulted in 404 with the message: #{body}"
+      raise Puppet::Error, msg
+    else
+      nil
+    end
+  end
+
+  def head(request)
+    response = do_request(request) do |request|
+      http_head(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
+    end
+
+    if is_http_200?(response)
+      check_master_version(response)
+      true
+    else
+      false
+    end
+  end
+
+  def search(request)
+    response = do_request(request) do |request|
+      http_get(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
+    end
+
+    if is_http_200?(response)
+      check_master_version(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 |request|
+      http_delete(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
+    end
+
+    if is_http_200?(response)
+      check_master_version(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 |request|
+      http_put(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+    end
+
+    if is_http_200?(response)
+      check_master_version(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)
+    request.do_request(self.class.srv_service, self.class.server, self.class.port) { |request| yield(request) }
+  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)
+    message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
+    Net::HTTPError.new(message, response)
+  end
+
+  def check_master_version response
+    if !response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION] &&
+       (Puppet[:legacy_query_parameter_serialization] == false || Puppet[:report_serialization_format] != "yaml")
+      Puppet.notice "Using less secure serialization of reports and query parameters for compatibility"
+      Puppet.notice "with older puppet master. To remove this notice, please upgrade your master(s) "
+      Puppet.notice "to Puppet 3.3 or newer."
+      Puppet.notice "See http://links.puppetlabs.com/deprecate_yaml_on_network for more information."
+      Puppet[:legacy_query_parameter_serialization] = true
+      Puppet[:report_serialization_format] = "yaml"
+    end
+  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*;.*$/,''),
+        body = 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