openvox 8.19.0

data/lib/puppet/network/formats.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/network/format_handler'
+require_relative '../../puppet/util/json'
+
+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 allowed_yaml_classes
+    @allowed_yaml_classes ||= [
+      Puppet::Node::Facts,
+      Puppet::Node,
+      Puppet::Transaction::Report,
+      Puppet::Resource,
+      Puppet::Resource::Catalog
+    ]
+  end
+
+  def intern(klass, text)
+    data = Puppet::Util::Yaml.safe_load(text, allowed_yaml_classes)
+    data_to_instance(klass, data)
+  rescue Puppet::Util::Yaml::YamlLoadError => e
+    raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}: %{message}") % { klass: klass, message: e.message }
+  end
+
+  def intern_multiple(klass, text)
+    data = Puppet::Util::Yaml.safe_load(text, allowed_yaml_classes)
+    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
+  rescue Puppet::Util::Yaml::YamlLoadError => e
+    raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}: %{message}") % { klass: klass, message: e.message }
+  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}") % { klass: 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
+
+Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :charset => Encoding::UTF_8, :extension => "txt")
+
+# By default, to_binary is called to render and from_binary called to intern. Note unlike
+# text-based formats (json, yaml, etc), we don't use to_data_hash for binary.
+Puppet::Network::FormatHandler.create(:binary, :mime => "application/octet-stream", :weight => 1,
+                                               :required_methods => [:render_method, :intern_method]) do
+end
+
+# PSON is deprecated
+Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
+  confine :feature => :pson
+
+  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.
+  # This is required for compatibility with Puppet 3.x
+  def data_to_instance(klass, data)
+    d = data['data'] if data.is_a?(Hash)
+    if d
+      data = d
+    end
+    return data if data.is_a?(klass)
+
+    klass.from_data_hash(data)
+  end
+end
+
+Puppet::Network::FormatHandler.create_serialized_formats(:json, :mime => 'application/json', :charset => Encoding::UTF_8, :weight => 15, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
+  def intern(klass, text)
+    data_to_instance(klass, Puppet::Util::Json.load(text))
+  end
+
+  def intern_multiple(klass, text)
+    Puppet::Util::Json.load(text).collect do |data|
+      data_to_instance(klass, data)
+    end
+  end
+
+  def render_multiple(instances)
+    Puppet::Util::Json.dump(instances)
+  end
+
+  # Unlike PSON, we do not need to unwrap the data envelope, because legacy 3.x agents
+  # have never supported JSON
+  def data_to_instance(klass, data)
+    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(:json)
+  end
+
+  def render(datum)
+    return datum if datum.is_a?(String) || datum.is_a?(Numeric)
+
+    # Simple hash to table
+    if datum.is_a?(Hash) && datum.keys.all? { |x| x.is_a?(String) || x.is_a?(Numeric) }
+      output = ''.dup
+      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 = ''.dup
+      datum.each do |item|
+        output << item.to_s
+        output << "\n"
+      end
+      return output
+    end
+
+    # ...or pretty-print the inspect outcome.
+    Puppet::Util::Json.dump(datum, :pretty => true, :quirks_mode => true)
+  end
+
+  def render_multiple(data)
+    data.collect(&:render).join("\n")
+  end
+end
+
+Puppet::Network::FormatHandler.create(:flat,
+                                      :mime => 'text/x-flat-text',
+                                      :weight => 0) do
+  def flatten_hash(hash)
+    hash.each_with_object({}) do |(k, v), h|
+      case v
+      when Hash
+        flatten_hash(v).map do |h_k, h_v|
+          h["#{k}.#{h_k}"] = h_v
+        end
+      when Array
+        v.each_with_index do |el, i|
+          if el.is_a? Hash
+            flatten_hash(el).map do |el_k, el_v|
+              h["#{k}.#{i}.#{el_k}"] = el_v
+            end
+          else
+            h["#{k}.#{i}"] = el
+          end
+        end
+      else
+        h[k] = v
+      end
+    end
+  end
+
+  def flatten_array(array)
+    a = {}
+    array.each_with_index do |el, i|
+      if el.is_a? Hash
+        flatten_hash(el).map do |el_k, el_v|
+          a["#{i}.#{el_k}"] = el_v
+        end
+      else
+        a[i.to_s] = el
+      end
+    end
+    a
+  end
+
+  def construct_output(data)
+    output = ''.dup
+    data.each do |key, value|
+      output << "#{key}=#{value}"
+      output << "\n"
+    end
+    output
+  end
+
+  def render(datum)
+    return datum if datum.is_a?(String) || datum.is_a?(Numeric)
+
+    # Simple hash
+    case datum
+    when Hash
+      data = flatten_hash(datum)
+      return construct_output(data)
+    when Array
+      data = flatten_array(datum)
+      return construct_output(data)
+    end
+    Puppet::Util::Json.dump(datum, :pretty => true, :quirks_mode => true)
+  end
+
+  def render_multiple(data)
+    data.collect(&:render).join("\n")
+  end
+end
+
+Puppet::Network::FormatHandler.create(:rich_data_json, mime: 'application/vnd.puppet.rich+json', charset: Encoding::UTF_8, weight: 30) do
+  def intern(klass, text)
+    Puppet.override({ :rich_data => true }) do
+      data_to_instance(klass, Puppet::Util::Json.load(text))
+    end
+  end
+
+  def intern_multiple(klass, text)
+    Puppet.override({ :rich_data => true }) do
+      Puppet::Util::Json.load(text).collect do |data|
+        data_to_instance(klass, data)
+      end
+    end
+  end
+
+  def render(instance)
+    Puppet.override({ :rich_data => true }) do
+      instance.to_json
+    end
+  end
+
+  def render_multiple(instances)
+    Puppet.override({ :rich_data => true }) do
+      Puppet::Util::Json.dump(instances)
+    end
+  end
+
+  def data_to_instance(klass, data)
+    Puppet.override({ :rich_data => true }) do
+      return data if data.is_a?(klass)
+
+      klass.from_data_hash(data)
+    end
+  end
+
+  def supported?(klass)
+    klass == Puppet::Resource::Catalog &&
+      Puppet.lookup(:current_environment).rich_data?
+  end
+end
+
+Puppet::Network::FormatHandler.create_serialized_formats(:rich_data_msgpack, mime: "application/vnd.puppet.rich+msgpack", weight: 35) do
+  confine :feature => :msgpack
+
+  def intern(klass, text)
+    Puppet.override(rich_data: true) do
+      data = MessagePack.unpack(text)
+      return data if data.is_a?(klass)
+
+      klass.from_data_hash(data)
+    end
+  end
+
+  def intern_multiple(klass, text)
+    Puppet.override(rich_data: true) do
+      MessagePack.unpack(text).collect do |data|
+        klass.from_data_hash(data)
+      end
+    end
+  end
+
+  def render_multiple(instances)
+    Puppet.override(rich_data: true) do
+      instances.to_msgpack
+    end
+  end
+
+  def render(instance)
+    Puppet.override(rich_data: true) do
+      instance.to_msgpack
+    end
+  end
+
+  def supported?(klass)
+    suitable? &&
+      klass == Puppet::Resource::Catalog &&
+      Puppet.lookup(:current_environment).rich_data?
+  end
+end

data/lib/puppet/network/http/api/indirected_routes.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require_relative '../../../../puppet/network/http/api/indirection_type'
+
+class Puppet::Network::HTTP::API::IndirectedRoutes
+  # How we map http methods and the indirection name in the URI
+  # to an indirection method.
+  METHOD_MAP = {
+    "GET" => {
+      :plural => :search,
+      :singular => :find
+    },
+    "POST" => {
+      :singular => :find,
+    },
+    "PUT" => {
+      :singular => :save
+    },
+    "DELETE" => {
+      :singular => :destroy
+    },
+    "HEAD" => {
+      :singular => :head
+    }
+  }
+
+  IndirectionType = Puppet::Network::HTTP::API::IndirectionType
+
+  def self.routes
+    Puppet::Network::HTTP::Route.path(/.*/).any(new)
+  end
+
+  # Handle an HTTP request. The request has already been authenticated prior
+  # to calling this method.
+  def call(request, response)
+    indirection, method, key, params = uri2indirection(request.method, request.path, request.params)
+    certificate = request.client_cert
+
+    unless indirection.allow_remote_requests?
+      # TODO: should we tell the user we found an indirection but it doesn't
+      # allow remote requests, or just pretend there's no handler at all? what
+      # are the security implications for the former?
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("No handler for %{indirection}") % { indirection: indirection.name }, :NO_INDIRECTION_REMOTE_REQUESTS)
+    end
+
+    overrides = {
+      trusted_information: Puppet::Context::TrustedInformation.remote(params[:authenticated], params[:node], certificate),
+    }
+    if params[:environment]
+      overrides[:current_environment] = params[:environment]
+    end
+
+    Puppet.override(overrides) do
+      send("do_#{method}", indirection, key, params, request, response)
+    end
+  end
+
+  def uri2indirection(http_method, uri, params)
+    # the first field is always nil because of the leading slash,
+    indirection_type, version, indirection_name, key = uri.split("/", 5)[1..]
+    url_prefix = "/#{indirection_type}/#{version}"
+    environment = params.delete(:environment)
+
+    if indirection_name !~ /^\w+$/
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("The indirection name must be purely alphanumeric, not '%{indirection_name}'") % { indirection_name: indirection_name }
+    end
+
+    # this also depluralizes the indirection_name if it is a search
+    method = indirection_method(http_method, indirection_name)
+
+    # check whether this indirection matches the prefix and version in the
+    # request
+    if url_prefix != IndirectionType.url_prefix_for(indirection_name)
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("Indirection '%{indirection_name}' does not match url prefix '%{url_prefix}'") % { indirection_name: indirection_name, url_prefix: url_prefix }
+    end
+
+    indirection = Puppet::Indirector::Indirection.instance(indirection_name.to_sym)
+    unless indirection
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
+        _("Could not find indirection '%{indirection_name}'") % { indirection_name: indirection_name },
+        Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND
+      )
+    end
+
+    unless environment
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("An environment parameter must be specified")
+    end
+
+    unless Puppet::Node::Environment.valid_name?(environment)
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("The environment must be purely alphanumeric, not '%{environment}'") % { environment: environment }
+    end
+
+    configured_environment = Puppet.lookup(:environments).get(environment)
+    unless configured_environment.nil?
+      configured_environment = configured_environment.override_from_commandline(Puppet.settings)
+      params[:environment] = configured_environment
+    end
+
+    if configured_environment.nil? && indirection.terminus.require_environment?
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError, _("Could not find environment '%{environment}'") % { environment: environment }
+    end
+
+    params.delete(:bucket_path)
+
+    if key == "" or key.nil?
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("No request key specified in %{uri}") % { uri: uri }
+    end
+
+    [indirection, method, key, params]
+  end
+
+  private
+
+  # Execute our find.
+  def do_find(indirection, key, params, request, response)
+    result = indirection.find(key, params)
+    unless result
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("Could not find %{value0} %{key}") % { value0: indirection.name, key: key }, Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+    end
+
+    rendered_result = result
+
+    rendered_format = first_response_formatter_for(indirection.model, request, key) do |format|
+      if result.respond_to?(:render)
+        Puppet::Util::Profiler.profile(_("Rendered result in %{format}") % { format: format }, [:http, :v3_render, format]) do
+          rendered_result = result.render(format)
+        end
+      end
+    end
+
+    Puppet::Util::Profiler.profile(_("Sent response"), [:http, :v3_response]) do
+      response.respond_with(200, rendered_format, rendered_result)
+    end
+  end
+
+  # Execute our head.
+  def do_head(indirection, key, params, request, response)
+    unless indirection.head(key, params)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("Could not find %{indirection} %{key}") % { indirection: indirection.name, key: key }, Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+    end
+
+    # No need to set a response because no response is expected from a
+    # HEAD request.  All we need to do is not die.
+  end
+
+  # Execute our search.
+  def do_search(indirection, key, params, request, response)
+    result = indirection.search(key, params)
+
+    if result.nil?
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("Could not find instances in %{indirection} with '%{key}'") % { indirection: indirection.name, key: key }, Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+    end
+
+    rendered_result = nil
+
+    rendered_format = first_response_formatter_for(indirection.model, request, key) do |format|
+      rendered_result = indirection.model.render_multiple(format, result)
+    end
+
+    response.respond_with(200, rendered_format, rendered_result)
+  end
+
+  # Execute our destroy.
+  def do_destroy(indirection, key, params, request, response)
+    formatter = accepted_response_formatter_or_json_for(indirection.model, request)
+
+    result = indirection.destroy(key, params)
+
+    response.respond_with(200, formatter, formatter.render(result))
+  end
+
+  # Execute our save.
+  def do_save(indirection, key, params, request, response)
+    formatter = accepted_response_formatter_or_json_for(indirection.model, request)
+    sent_object = read_body_into_model(indirection.model, request)
+
+    result = indirection.save(sent_object, key)
+
+    response.respond_with(200, formatter, formatter.render(result))
+  end
+
+  # Return the first response formatter that didn't cause the yielded
+  # block to raise a FormatError.
+  def first_response_formatter_for(model, request, key, &block)
+    formats = accepted_response_formatters_for(model, request)
+    formatter = formats.find do |format|
+      yield format
+      true
+    rescue Puppet::Network::FormatHandler::FormatError => err
+      msg = _("Failed to serialize %{model} for '%{key}': %{detail}") %
+            { model: model, key: key, detail: err }
+      if Puppet[:allow_pson_serialization]
+        Puppet.warning(msg)
+      else
+        raise Puppet::Network::FormatHandler::FormatError, msg
+      end
+      false
+    end
+
+    return formatter if formatter
+
+    raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new(
+      _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: formats.map(&:mime).join(', ') },
+      Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT
+    )
+  end
+
+  # Return an array of response formatters that the client accepts and
+  # the server supports.
+  def accepted_response_formatters_for(model_class, request)
+    request.response_formatters_for(model_class.supported_formats)
+  end
+
+  # Return the first response formatter that the client accepts and
+  # the server supports, or default to 'application/json'.
+  def accepted_response_formatter_or_json_for(model_class, request)
+    request.response_formatters_for(model_class.supported_formats, "application/json").first
+  end
+
+  def read_body_into_model(model_class, request)
+    data = request.body.to_s
+    formatter = request.formatter
+
+    if formatter.supported?(model_class)
+      begin
+        return model_class.convert_from(formatter.name.to_s, data)
+      rescue => e
+        raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("The request body is invalid: %{message}") % { message: e.message }
+      end
+    end
+
+    # TRANSLATORS "mime-type" is a keyword and should not be translated
+    raise Puppet::Network::HTTP::Error::HTTPUnsupportedMediaTypeError.new(
+      _("Client sent a mime-type (%{header}) that doesn't correspond to a format we support") % { header: request.headers['content-type'] },
+      Puppet::Network::HTTP::Issues::UNSUPPORTED_MEDIA_TYPE
+    )
+  end
+
+  def indirection_method(http_method, indirection)
+    raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError, _("No support for http method %{http_method}") % { http_method: http_method } unless METHOD_MAP[http_method]
+
+    method = METHOD_MAP[http_method][plurality(indirection)]
+    unless method
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError, _("No support for plurality %{indirection} for %{http_method} operations") % { indirection: plurality(indirection), http_method: http_method }
+    end
+
+    method
+  end
+
+  def self.pluralize(indirection)
+    (indirection == "status" ? "statuses" : indirection + "s")
+  end
+  private_class_method :pluralize
+
+  def plurality(indirection)
+    # NOTE These specific hooks for paths are ridiculous, but it's a *many*-line
+    # fix to not need this, and our goal is to move away from the complication
+    # that leads to the fix being too long.
+    return :singular if indirection == "facts"
+    return :singular if indirection == "status"
+    return :singular if indirection == "certificate_status"
+
+    result = (indirection =~ /s$|_search$/) ? :plural : :singular
+
+    indirection.sub!(/s$|_search$/, '')
+    indirection.sub!(/statuse$/, 'status')
+
+    result
+  end
+end

data/lib/puppet/network/http/api/indirection_type.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Puppet::Network::HTTP::API::IndirectionType
+  INDIRECTION_TYPE_MAP = {
+    "certificate" => :ca,
+    "certificate_request" => :ca,
+    "certificate_revocation_list" => :ca,
+    "certificate_status" => :ca
+  }
+
+  def self.master_url_prefix
+    "#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3"
+  end
+
+  def self.ca_url_prefix
+    "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v1"
+  end
+
+  def self.type_for(indirection)
+    INDIRECTION_TYPE_MAP[indirection] || :master
+  end
+
+  def self.url_prefix_for(indirection_name)
+    case type_for(indirection_name)
+    when :ca
+      ca_url_prefix
+    when :master
+      master_url_prefix
+    else
+      raise ArgumentError, _("Not a valid indirection type")
+    end
+  end
+end

data/lib/puppet/network/http/api/master/v3/environments.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../../puppet/network/http/api/master'
+require_relative '../../../../../../puppet/network/http/api/server/v3/environments'

data/lib/puppet/network/http/api/master/v3.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../puppet/network/http/api/master'
+require_relative '../../../../../puppet/network/http/api/server/v3'

data/lib/puppet/network/http/api/master.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative '../../../../puppet/network/http/api/server'
+
+Puppet::Network::HTTP::API::Master = Puppet::Network::HTTP::API::Server