puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/network/client_request.rb

@@ -0,0 +1,29 @@
+module Puppet::Network # :nodoc:
+  # A struct-like class for passing around a client request.  It's mostly
+  # just used for validation and authorization.
+  class ClientRequest
+    attr_accessor :name, :ip, :authenticated, :handler, :method
+
+    def authenticated?
+      self.authenticated
+    end
+
+    # A common way of talking about the full call.  Individual servers
+    # are responsible for setting the values correctly, but this common
+    # format makes it possible to check rights.
+    def call
+      raise ArgumentError, "Request is not set up; cannot build call" unless handler and method
+
+      [handler, method].join(".")
+    end
+
+    def initialize(name, ip, authenticated)
+      @name, @ip, @authenticated = name, ip, authenticated
+    end
+
+    def to_s
+      "#{self.name}(#{self.ip})"
+    end
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/network/format.rb

@@ -0,0 +1,110 @@
+require 'puppet/confiner'
+
+# A simple class for modeling encoding formats for moving
+# instances around the network.
+class Puppet::Network::Format
+  include Puppet::Confiner
+
+  attr_reader :name, :mime
+  attr_accessor :intern_method, :render_method, :intern_multiple_method, :render_multiple_method, :weight, :required_methods, :extension
+
+  def init_attribute(name, default)
+    if value = @options[name]
+      @options.delete(name)
+    else
+      value = default
+    end
+    self.send(name.to_s + "=", value)
+  end
+
+  def initialize(name, options = {}, &block)
+    @name = name.to_s.downcase.intern
+
+    @options = options
+
+    # This must be done early the values can be used to set required_methods
+    define_method_names
+
+    method_list = {
+      :intern_method => "from_#{name}",
+      :intern_multiple_method => "from_multiple_#{name}",
+      :render_multiple_method => "to_multiple_#{name}",
+      :render_method => "to_#{name}"
+    }
+
+    init_attribute(:mime, "text/#{name}")
+    init_attribute(:weight, 5)
+    init_attribute(:required_methods, method_list.keys)
+    init_attribute(:extension, name.to_s)
+
+    method_list.each do |method, value|
+      init_attribute(method, value)
+    end
+
+    raise ArgumentError, "Unsupported option(s) #{@options.keys}" unless @options.empty?
+
+    @options = nil
+
+    instance_eval(&block) if block_given?
+  end
+
+  def intern(klass, text)
+    return klass.send(intern_method, text) if klass.respond_to?(intern_method)
+    raise NotImplementedError, "#{klass} does not respond to #{intern_method}; can not intern instances from #{mime}"
+  end
+
+  def intern_multiple(klass, text)
+    return klass.send(intern_multiple_method, text) if klass.respond_to?(intern_multiple_method)
+    raise NotImplementedError, "#{klass} does not respond to #{intern_multiple_method}; can not intern multiple instances from #{mime}"
+  end
+
+  def mime=(mime)
+    @mime = mime.to_s.downcase
+  end
+
+  def render(instance)
+    return instance.send(render_method) if instance.respond_to?(render_method)
+    raise NotImplementedError, "#{instance.class} does not respond to #{render_method}; can not render instances to #{mime}"
+  end
+
+  def render_multiple(instances)
+    # This method implicitly assumes that all instances are of the same type.
+    return instances[0].class.send(render_multiple_method, instances) if instances[0].class.respond_to?(render_multiple_method)
+    raise NotImplementedError, "#{instances[0].class} does not respond to #{render_multiple_method}; can not intern multiple instances to #{mime}"
+  end
+
+  def required_methods_present?(klass)
+    [:intern_method, :intern_multiple_method, :render_multiple_method].each do |name|
+      return false unless required_method_present?(name, klass, :class)
+    end
+
+    return false unless required_method_present?(:render_method, klass, :instance)
+
+    true
+  end
+
+  def supported?(klass)
+    suitable? and required_methods_present?(klass)
+  end
+
+  def to_s
+    "Puppet::Network::Format[#{name}]"
+  end
+
+  private
+
+  def define_method_names
+    @intern_method = "from_#{name}"
+    @render_method = "to_#{name}"
+    @intern_multiple_method = "from_multiple_#{name}"
+    @render_multiple_method = "to_multiple_#{name}"
+  end
+
+  def required_method_present?(name, klass, type)
+    return true unless required_methods.include?(name)
+
+    method = send(name)
+
+    return(type == :class ? klass.respond_to?(method) : klass.method_defined?(method))
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/network/format_handler.rb

@@ -0,0 +1,105 @@
+require 'yaml'
+require 'puppet/network'
+require 'puppet/network/format'
+
+module Puppet::Network::FormatHandler
+  class FormatError < Puppet::Error; end
+
+  ALL_MEDIA_TYPES = '*/*'.freeze
+
+  @formats = {}
+
+  def self.create(*args, &block)
+    instance = Puppet::Network::Format.new(*args, &block)
+
+    @formats[instance.name] = instance
+    instance
+  end
+
+  def self.create_serialized_formats(name,options = {},&block)
+    ["application/x-#{name}", "application/#{name}", "text/x-#{name}", "text/#{name}"].each { |mime_type|
+      create name, {:mime => mime_type}.update(options), &block
+    }
+  end
+
+  def self.format(name)
+    @formats[name.to_s.downcase.intern]
+  end
+
+  def self.format_for(name)
+    name = format_to_canonical_name(name)
+    format(name)
+  end
+
+  def self.format_by_extension(ext)
+    @formats.each do |name, format|
+      return format if format.extension == ext
+    end
+    nil
+  end
+
+  # Provide a list of all formats.
+  def self.formats
+    @formats.keys
+  end
+
+  # Return a format capable of handling the provided mime type.
+  def self.mime(mimetype)
+    mimetype = mimetype.to_s.downcase
+    @formats.values.find { |format| format.mime == mimetype }
+  end
+
+  # Return a format name given:
+  #  * a format name
+  #  * a mime-type
+  #  * a format instance
+  def self.format_to_canonical_name(format)
+    case format
+    when Puppet::Network::Format
+      out = format
+    when %r{\w+/\w+}
+      out = mime(format)
+    else
+      out = format(format)
+    end
+    raise ArgumentError, "No format match the given format name or mime-type (#{format})" if out.nil?
+    out.name
+  end
+
+  # Determine which of the accepted formats should be used given what is supported.
+  #
+  # @param accepted [Array<String, Symbol>] the accepted formats in a form a
+  #   that generally conforms to an HTTP Accept header. Any quality specifiers
+  #   are ignored and instead the formats are simply in strict preference order
+  #   (most preferred is first)
+  # @param supported [Array<Symbol>] the names of the supported formats (the
+  #   most preferred format is first)
+  # @return [Puppet::Network::Format, nil] the most suitable format
+  # @api private
+  def self.most_suitable_format_for(accepted, supported)
+    format_name = accepted.collect do |accepted|
+      accepted.to_s.sub(/;q=.*$/, '')
+    end.collect do |accepted|
+      if accepted == ALL_MEDIA_TYPES
+        supported.first
+      else
+        format_to_canonical_name_or_nil(accepted)
+      end
+    end.find do |accepted|
+      supported.include?(accepted)
+    end
+
+    if format_name
+      format_for(format_name)
+    end
+  end
+
+  # @api private
+  def self.format_to_canonical_name_or_nil(format)
+    format_to_canonical_name(format)
+  rescue ArgumentError
+    nil
+  end
+end
+
+require 'puppet/network/formats'

data/vendor/gems/puppet-3.7.3/lib/puppet/network/format_support.rb

@@ -0,0 +1,124 @@
+require 'puppet/network/format_handler'
+
+# Provides network serialization support when included
+# @api public
+module Puppet::Network::FormatSupport
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def convert_from(format, data)
+      get_format(format).intern(self, data)
+    rescue => err
+      raise Puppet::Network::FormatHandler::FormatError, "Could not intern from #{format}: #{err}", err.backtrace
+    end
+
+    def convert_from_multiple(format, data)
+      get_format(format).intern_multiple(self, data)
+    rescue => err
+      raise Puppet::Network::FormatHandler::FormatError, "Could not intern_multiple from #{format}: #{err}", err.backtrace
+    end
+
+    def render_multiple(format, instances)
+      get_format(format).render_multiple(instances)
+    rescue => err
+      raise Puppet::Network::FormatHandler::FormatError, "Could not render_multiple to #{format}: #{err}", err.backtrace
+    end
+
+    def default_format
+      supported_formats[0]
+    end
+
+    def support_format?(name)
+      Puppet::Network::FormatHandler.format(name).supported?(self)
+    end
+
+    def supported_formats
+      result = format_handler.formats.collect do |f|
+        format_handler.format(f)
+      end.find_all do |f|
+        f.supported?(self)
+      end.sort do |a, b|
+        # It's an inverse sort -- higher weight formats go first.
+        b.weight <=> a.weight
+      end.collect do |f|
+        f.name
+      end
+
+      result = put_preferred_format_first(result)
+
+      Puppet.debug "#{friendly_name} supports formats: #{result.join(' ')}"
+
+      result
+    end
+
+    # @api private
+    def get_format(format_name)
+      format_handler.format_for(format_name)
+    end
+
+    private
+
+    def format_handler
+      Puppet::Network::FormatHandler
+    end
+
+    def friendly_name
+      if self.respond_to? :indirection
+        indirection.name
+      else
+        self
+      end
+    end
+
+    def put_preferred_format_first(list)
+      preferred_format = Puppet.settings[:preferred_serialization_format].to_sym
+      if list.include?(preferred_format)
+        list.delete(preferred_format)
+        list.unshift(preferred_format)
+      else
+        Puppet.debug "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first})"
+      end
+      list
+    end
+  end
+
+  def to_msgpack(*args)
+    to_data_hash.to_msgpack(*args)
+  end
+
+  def to_pson(*args)
+    to_data_hash.to_pson(*args)
+  end
+
+  def render(format = nil)
+    format ||= self.class.default_format
+
+    self.class.get_format(format).render(self)
+  rescue => err
+    raise Puppet::Network::FormatHandler::FormatError, "Could not render to #{format}: #{err}", err.backtrace
+  end
+
+  def mime(format = nil)
+    format ||= self.class.default_format
+
+    self.class.get_format(format).mime
+  rescue => err
+    raise Puppet::Network::FormatHandler::FormatError, "Could not mime to #{format}: #{err}", err.backtrace
+  end
+
+  def support_format?(name)
+    self.class.support_format?(name)
+  end
+
+  # @comment Document to_data_hash here as it is called as a hook from to_msgpack if it exists
+  # @!method to_data_hash(*args)
+  # @api public
+  # @abstract
+  # This method may be implemented to return a hash object that is used for serializing.
+  # The object returned by this method should contain all the info needed to instantiate it again.
+  # If the method exists it will be called from to_msgpack and other serialization methods.
+  # @return [Hash]
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/network/formats.rb

@@ -0,0 +1,216 @@
+require 'puppet/network/format_handler'
+
+Puppet::Network::FormatHandler.create_serialized_formats(:msgpack, :weight => 20, :mime => "application/x-msgpack", :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
+
+  confine :feature => :msgpack
+
+  def intern(klass, text)
+    data = MessagePack.unpack(text)
+    return data if data.is_a?(klass)
+    klass.from_data_hash(data)
+  end
+
+  def intern_multiple(klass, text)
+    MessagePack.unpack(text).collect do |data|
+      klass.from_data_hash(data)
+    end
+  end
+
+  def render_multiple(instances)
+    instances.to_msgpack
+  end
+end
+
+Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
+  def intern(klass, text)
+    data = YAML.load(text, :safe => true, :deserialize_symbols => true)
+    data_to_instance(klass, data)
+  end
+
+  def intern_multiple(klass, text)
+    data = YAML.load(text, :safe => true, :deserialize_symbols => true)
+    unless data.respond_to?(:collect)
+      raise Puppet::Network::FormatHandler::FormatError, "Serialized YAML did not contain a collection of instances when calling intern_multiple"
+    end
+
+    data.collect do |datum|
+      data_to_instance(klass, datum)
+    end
+  end
+
+  def data_to_instance(klass, data)
+    return data if data.is_a?(klass)
+
+    unless data.is_a? Hash
+      raise Puppet::Network::FormatHandler::FormatError, "Serialized YAML did not contain a valid instance of #{klass}"
+    end
+
+    klass.from_data_hash(data)
+  end
+
+  def render(instance)
+    instance.to_yaml
+  end
+
+  # Yaml monkey-patches Array, so this works.
+  def render_multiple(instances)
+    instances.to_yaml
+  end
+
+  def supported?(klass)
+    true
+  end
+end
+
+# This is a "special" format which is used for the moment only when sending facts
+# as REST GET parameters (see Puppet::Configurer::FactHandler).
+# This format combines a yaml serialization, then zlib compression and base64 encoding.
+Puppet::Network::FormatHandler.create_serialized_formats(:b64_zlib_yaml) do
+  require 'base64'
+
+  def use_zlib?
+    Puppet.features.zlib? && Puppet[:zlib]
+  end
+
+  def requiring_zlib
+    if use_zlib?
+      yield
+    else
+      raise Puppet::Error, "the zlib library is not installed or is disabled."
+    end
+  end
+
+  def intern(klass, text)
+    requiring_zlib do
+      Puppet::Network::FormatHandler.format(:yaml).intern(klass, decode(text))
+    end
+  end
+
+  def intern_multiple(klass, text)
+    requiring_zlib do
+      Puppet::Network::FormatHandler.format(:yaml).intern_multiple(klass, decode(text))
+    end
+  end
+
+  def render(instance)
+    encode(instance.to_yaml)
+  end
+
+  def render_multiple(instances)
+    encode(instances.to_yaml)
+  end
+
+  def supported?(klass)
+    true
+  end
+
+  def decode(data)
+    Zlib::Inflate.inflate(Base64.decode64(data))
+  end
+
+  def encode(text)
+    requiring_zlib do
+      Base64.encode64(Zlib::Deflate.deflate(text, Zlib::BEST_COMPRESSION))
+    end
+  end
+end
+
+Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :extension => "txt")
+
+# A very low-weight format so it'll never get chosen automatically.
+Puppet::Network::FormatHandler.create(:raw, :mime => "application/x-raw", :weight => 1) do
+  def intern_multiple(klass, text)
+    raise NotImplementedError
+  end
+
+  def render_multiple(instances)
+    raise NotImplementedError
+  end
+
+  # LAK:NOTE The format system isn't currently flexible enough to handle
+  # what I need to support raw formats just for individual instances (rather
+  # than both individual and collections), but we don't yet have enough data
+  # to make a "correct" design.
+  #   So, we hack it so it works for singular but fail if someone tries it
+  # on plurals.
+  def supported?(klass)
+    true
+  end
+end
+
+Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
+  def intern(klass, text)
+    data_to_instance(klass, PSON.parse(text))
+  end
+
+  def intern_multiple(klass, text)
+    PSON.parse(text).collect do |data|
+      data_to_instance(klass, data)
+    end
+  end
+
+  # PSON monkey-patches Array, so this works.
+  def render_multiple(instances)
+    instances.to_pson
+  end
+
+  # If they pass class information, we want to ignore it.  By default,
+  # we'll include class information but we won't rely on it - we don't
+  # want class names to be required because we then can't change our
+  # internal class names, which is bad.
+  def data_to_instance(klass, data)
+    if data.is_a?(Hash) and d = data['data']
+      data = d
+    end
+    return data if data.is_a?(klass)
+    klass.from_data_hash(data)
+  end
+end
+
+# This is really only ever going to be used for Catalogs.
+Puppet::Network::FormatHandler.create_serialized_formats(:dot, :required_methods => [:render_method])
+
+
+Puppet::Network::FormatHandler.create(:console,
+                                      :mime   => 'text/x-console-text',
+                                      :weight => 0) do
+  def json
+    @json ||= Puppet::Network::FormatHandler.format(:pson)
+  end
+
+  def render(datum)
+    # String to String
+    return datum if datum.is_a? String
+    return datum if datum.is_a? Numeric
+
+    # Simple hash to table
+    if datum.is_a? Hash and datum.keys.all? { |x| x.is_a? String or x.is_a? Numeric }
+      output = ''
+      column_a = datum.empty? ? 2 : datum.map{ |k,v| k.to_s.length }.max + 2
+      datum.sort_by { |k,v| k.to_s } .each do |key, value|
+        output << key.to_s.ljust(column_a)
+        output << json.render(value).
+          chomp.gsub(/\n */) { |x| x + (' ' * column_a) }
+        output << "\n"
+      end
+      return output
+    end
+
+    # Print one item per line for arrays
+    if datum.is_a? Array
+      output = ''
+      datum.each do |item|
+        output << item.to_s
+        output << "\n"
+      end
+      return output
+    end
+
+    # ...or pretty-print the inspect outcome.
+    return json.render(datum)
+  end
+
+  def render_multiple(data)
+    data.collect(&:render).join("\n")
+  end
+end