puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,9 @@
+require 'puppet/indirector/terminus'
+
+# A none terminus type, meant to always return nil
+class Puppet::Indirector::None < Puppet::Indirector::Terminus
+  def find(request)
+    return nil
+  end
+end
+

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

@@ -0,0 +1,9 @@
+require 'puppet/indirector/terminus'
+
+# An empty terminus type, meant to just return empty objects.
+class Puppet::Indirector::Plain < Puppet::Indirector::Terminus
+  # Just return nothing.
+  def find(request)
+    indirection.model.new(request.key)
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'puppet/indirector/terminus'
+require 'puppet/util/queue'
+require 'puppet/util'
+
+# Implements the <tt>:queue</tt> abstract indirector terminus type, for storing
+# model instances to a message queue, presumably for the purpose of out-of-process
+# handling of changes related to the model.
+#
+# Relies upon Puppet::Util::Queue for registry and client object management,
+# and specifies a default queue type of <tt>:stomp</tt>, appropriate for use with a variety of message brokers.
+#
+# It's up to the queue client type to instantiate itself correctly based on Puppet configuration information.
+#
+# A single queue client is maintained for the abstract terminus, meaning that you can only use one type
+# of queue client, one message broker solution, etc., with the indirection mechanism.
+#
+# Per-indirection queues are assumed, based on the indirection name.  If the <tt>:catalog</tt> indirection makes
+# use of this <tt>:queue</tt> terminus, queue operations work against the "catalog" queue.  It is up to the queue
+# client library to handle queue creation as necessary (for a number of popular queuing solutions, queue
+# creation is automatic and not a concern).
+class Puppet::Indirector::Queue < Puppet::Indirector::Terminus
+  extend ::Puppet::Util::Queue
+  include Puppet::Util
+
+  def initialize(*args)
+    super
+  end
+
+  # Queue has no idiomatic "find"
+  def find(request)
+    nil
+  end
+
+  # Place the request on the queue
+  def save(request)
+      result = nil
+      benchmark :info, "Queued #{indirection.name} for #{request.key}" do
+        result = client.publish_message(queue, request.instance.render(:pson))
+      end
+      result
+  rescue => detail
+      msg = "Could not write #{request.key} to queue: #{detail}\nInstance::#{request.instance}\n client : #{client}"
+      raise Puppet::Error, msg, detail.backtrace
+  end
+
+  def self.queue
+    indirection_name
+  end
+
+  def queue
+    self.class.queue
+  end
+
+  # Returns the singleton queue client object.
+  def client
+    self.class.client
+  end
+
+  # converts the _message_ from deserialized format to an actual model instance.
+  def self.intern(message)
+    result = nil
+    benchmark :info, "Loaded queued #{indirection.name}" do
+      result = model.convert_from(:pson, message)
+    end
+    result
+  end
+
+  # Provides queue subscription functionality; for a given indirection, use this method on the terminus
+  # to subscribe to the indirection-specific queue.  Your _block_ will be executed per new indirection
+  # model received from the queue, with _obj_ being the model instance.
+  def self.subscribe
+    client.subscribe(queue) do |msg|
+      begin
+        yield(self.intern(msg))
+      rescue => detail
+        Puppet.log_exception(detail, "Error occurred with subscription to queue #{queue} for indirection #{indirection_name}: #{detail}")
+      end
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/report/msgpack.rb

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

data/vendor/gems/puppet-3.7.3/lib/puppet/indirector/report/processor.rb

@@ -0,0 +1,59 @@
+require 'puppet/transaction/report'
+require 'puppet/indirector/code'
+require 'puppet/reports'
+
+class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
+  desc "Puppet's report processor.  Processes the report with each of
+    the report types listed in the 'reports' setting."
+
+  def initialize
+    Puppet.settings.use(:main, :reporting, :metrics)
+  end
+
+  def save(request)
+    process(request.instance)
+  end
+
+  def destroy(request)
+    processors do |mod|
+      mod.destroy(request.key) if mod.respond_to?(:destroy)
+    end
+  end
+
+  private
+
+  # Process the report with each of the configured report types.
+  # LAK:NOTE This isn't necessarily the best design, but it's backward
+  # compatible and that's good enough for now.
+  def process(report)
+    Puppet.debug "Received report to process from #{report.host}"
+    processors do |mod|
+      Puppet.debug "Processing report from #{report.host} with processor #{mod}"
+      # We have to use a dup because we're including a module in the
+      # report.
+      newrep = report.dup
+      begin
+        newrep.extend(mod)
+        newrep.process
+      rescue => detail
+        Puppet.log_exception(detail, "Report #{name} failed: #{detail}")
+      end
+    end
+  end
+
+  # Handle the parsing of the reports attribute.
+  def reports
+    Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
+  end
+
+  def processors(&blk)
+    return [] if Puppet[:reports] == "none"
+    reports.each do |name|
+      if mod = Puppet::Reports.report(name)
+        yield(mod)
+      else
+        Puppet.warning "No report named '#{name}'"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'puppet/indirector/rest'
+
+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)
+
+  private
+
+  def deserialize_save(content_type, body)
+    format = Puppet::Network::FormatHandler.format_for(content_type)
+    format.intern(Array, body)
+  end
+end

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

@@ -0,0 +1,317 @@
+require 'cgi'
+require 'uri'
+require 'puppet/indirector'
+require 'puppet/util/pson'
+require 'puppet/network/resolver'
+
+# 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
+  attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :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, :instance, :environment]
+
+  ::PSON.register_document_type('IndirectorRequest',self)
+
+  def self.from_data_hash(data)
+    raise ArgumentError, "No indirection name provided in data" unless indirection_name = data['type']
+    raise ArgumentError, "No method name provided in data" unless method = data['method']
+    raise ArgumentError, "No key provided in data" unless key = data['key']
+
+    request = new(indirection_name, method, key, nil, data['attributes'])
+
+    if instance = data['instance']
+      klass = Puppet::Indirector::Indirection.instance(request.indirection_name).model
+      if instance.is_a?(klass)
+        request.instance = instance
+      else
+        request.instance = klass.from_data_hash(instance)
+      end
+    end
+
+    request
+  end
+
+  def self.from_pson(json)
+    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+    self.from_data_hash(json)
+  end
+
+  def to_data_hash
+    result = {
+      'type' => indirection_name,
+      'method' => method,
+      'key' => key
+    }
+    attributes = {}
+    OPTION_ATTRIBUTES.each do |key|
+      next unless value = send(key)
+      attributes[key] = value
+    end
+
+    options.each do |opt, value|
+      attributes[opt] = value
+    end
+
+    result['attributes'] = attributes unless attributes.empty?
+    result['instance'] = instance if instance
+    result
+  end
+
+  def to_pson_data_hash
+    {
+      'document_type' => 'IndirectorRequest',
+      'data' => to_data_hash,
+    }
+  end
+
+  def to_pson(*args)
+    to_pson_data_hash.to_pson(*args)
+  end
+
+  # 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
+    elsif (current_environment = Puppet.lookup(:current_environment)).name == env
+      current_environment
+    else
+      Puppet.lookup(:environments).get!(env)
+    end
+  end
+
+  def escaped_key
+    URI.escape(key)
+  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_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_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?
+
+    # For backward compatibility with older (pre-3.3) masters,
+    # this puppet option allows serialization of query parameter
+    # arrays as yaml.  This can be removed when we remove yaml
+    # support entirely.
+    if Puppet.settings[:legacy_query_parameter_serialization]
+      replace_arrays_with_yaml
+    end
+
+    "?" + encode_params(expand_into_parameters(options.to_a))
+  end
+
+  def replace_arrays_with_yaml
+    options.each do |key, value|
+      case value
+        when Array
+          options[key] = YAML.dump(value)
+      end
+    end
+  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, Fixnum, Bignum, Float
+        params << [key, value]
+      else
+        raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
+      end
+    end
+  end
+
+  def encode_params(params)
+    params.collect do |key, value|
+      "#{key}=#{CGI.escape(value.to_s)}"
+    end.join("&")
+  end
+
+  def to_hash
+    result = options.dup
+
+    OPTION_ATTRIBUTES.each do |attribute|
+      if value = send(attribute)
+        result[attribute] = value
+      end
+    end
+    result
+  end
+
+  def to_s
+    return(uri ? uri : "/#{indirection_name}/#{key}")
+  end
+
+  def do_request(srv_service=:puppet, default_server=Puppet.settings[:server], default_port=Puppet.settings[:masterport], &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}: #{e.message}"
+        end
+      end
+    end
+
+    # ... Fall back onto the default server.
+    Puppet.debug "No more servers left, falling back to #{default_server}:#{default_port}" if Puppet.settings[:use_srv_records]
+    self.server = default_server
+    self.port   = default_port
+    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
+      uri = URI.parse(URI.escape(key))
+    rescue => detail
+      raise ArgumentError, "Could not understand URL #{key}: #{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
+
+    @protocol = uri.scheme
+
+    if uri.scheme == 'puppet'
+      @key = URI.unescape(uri.path.sub(/^\//, ''))
+      return
+    end
+
+    env, indirector, @key = URI.unescape(uri.path.sub(/^\//, '')).split('/',3)
+    @key ||= ''
+    self.environment = env unless env == ''
+  end
+end