openvox 8.19.0

data/lib/puppet/module_tool.rb

@@ -0,0 +1,194 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Load standard libraries
+require 'pathname'
+require 'fileutils'
+require_relative '../puppet/util/colors'
+
+module Puppet
+  module ModuleTool
+    require_relative 'module_tool/tar'
+    extend Puppet::Util::Colors
+
+    # Directory and names that should not be checksummed.
+    ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
+    FULL_MODULE_NAME_PATTERN = %r{\A([^-/|.]+)[-|/](.+)\z}
+    REPOSITORY_URL = Puppet.settings[:module_repository]
+
+    # Is this a directory that shouldn't be checksummed?
+    #
+    # TODO: Should this be part of Checksums?
+    # TODO: Rename this method to reflect its purpose?
+    # TODO: Shouldn't this be used when building packages too?
+    def self.artifact?(path)
+      case File.basename(path)
+      when *ARTIFACTS
+        true
+      else
+        false
+      end
+    end
+
+    # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
+    # ArgumentError if the argument isn't parseable.
+    def self.username_and_modname_from(full_module_name)
+      matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
+      if matcher
+        matcher.captures
+      else
+        raise ArgumentError, _("Not a valid full name: %{full_module_name}") % { full_module_name: full_module_name }
+      end
+    end
+
+    # Find the module root when given a path by checking each directory up from
+    # its current location until it finds one that satisfies is_module_root?
+    #
+    # @param path [Pathname, String] path to start from
+    # @return [Pathname, nil] the root path of the module directory or nil if
+    #   we cannot find one
+    def self.find_module_root(path)
+      path = Pathname.new(path) if path.instance_of?(String)
+
+      path.expand_path.ascend do |p|
+        return p if is_module_root?(p)
+      end
+
+      nil
+    end
+
+    # Analyse path to see if it is a module root directory by detecting a
+    # file named 'metadata.json'
+    #
+    # @param path [Pathname, String] path to analyse
+    # @return [Boolean] true if the path is a module root, false otherwise
+    def self.is_module_root?(path)
+      path = Pathname.new(path) if path.instance_of?(String)
+
+      FileTest.file?(path + 'metadata.json')
+    end
+
+    # Builds a formatted tree from a list of node hashes containing +:text+
+    # and +:dependencies+ keys.
+    def self.format_tree(nodes, level = 0)
+      str = ''.dup
+      nodes.each_with_index do |node, i|
+        last_node = nodes.length - 1 == i
+        deps = node[:dependencies] || []
+
+        str << (indent = "  " * level)
+        str << (last_node ? "└" : "├")
+        str << "─"
+        str << (deps.empty? ? "─" : "┬")
+        str << " #{node[:text]}\n"
+
+        branch = format_tree(deps, level + 1)
+        branch.gsub!(/^#{indent} /, indent + '│') unless last_node
+        str << branch
+      end
+
+      str
+    end
+
+    def self.build_tree(mods, dir)
+      mods.each do |mod|
+        version_string = mod[:version].to_s.sub(/^(?!v)/, 'v')
+
+        if mod[:action] == :upgrade
+          previous_version = mod[:previous_version].to_s.sub(/^(?!v)/, 'v')
+          version_string = "#{previous_version} -> #{version_string}"
+        end
+
+        mod[:text] = "#{mod[:name]} (#{colorize(:cyan, version_string)})"
+        mod[:text] += " [#{mod[:path]}]" unless mod[:path].to_s == dir.to_s
+
+        deps = mod[:dependencies] || []
+        deps.sort_by! { |a| a[:name] }
+        build_tree(deps, dir)
+      end
+    end
+
+    # @param options [Hash<Symbol,String>] This hash will contain any
+    #   command-line arguments that are not Settings, as those will have already
+    #   been extracted by the underlying application code.
+    #
+    # @note Unfortunately the whole point of this method is the side effect of
+    # modifying the options parameter.  This same hash is referenced both
+    # when_invoked and when_rendering.  For this reason, we are not returning
+    # a duplicate.
+    # @todo Validate the above note...
+    #
+    # An :environment_instance and a :target_dir are added/updated in the
+    # options parameter.
+    #
+    # @api private
+    def self.set_option_defaults(options)
+      current_environment = environment_from_options(options)
+
+      modulepath = [options[:target_dir]] + current_environment.full_modulepath
+
+      face_environment = current_environment.override_with(:modulepath => modulepath.compact)
+
+      options[:environment_instance] = face_environment
+
+      # Note: environment will have expanded the path
+      options[:target_dir] = face_environment.full_modulepath.first
+    end
+
+    # Given a hash of options, we should discover or create a
+    # {Puppet::Node::Environment} instance that reflects the provided options.
+    #
+    # Generally speaking, the `:modulepath` parameter should supersede all
+    # others, the `:environment` parameter should follow after that, and we
+    # should default to Puppet's current environment.
+    #
+    # @param options [{Symbol => Object}] the options to derive environment from
+    # @return [Puppet::Node::Environment] the environment described by the options
+    def self.environment_from_options(options)
+      if options[:modulepath]
+        path = options[:modulepath].split(File::PATH_SEPARATOR)
+        Puppet::Node::Environment.create(:anonymous, path, '')
+      elsif options[:environment].is_a?(Puppet::Node::Environment)
+        options[:environment]
+      elsif options[:environment]
+        # This use of looking up an environment is correct since it honours
+        # a request to get a particular environment via environment name.
+        Puppet.lookup(:environments).get!(options[:environment])
+      else
+        Puppet.lookup(:current_environment)
+      end
+    end
+
+    # Handles parsing of module dependency expressions into proper
+    # {SemanticPuppet::VersionRange}s, including reasonable error handling.
+    #
+    # @param where [String] a description of the thing we're parsing the
+    #        dependency expression for
+    # @param dep [Hash] the dependency description to parse
+    # @return [Array(String, SemanticPuppet::VersionRange, String)] a tuple of the
+    #         dependent module's name, the version range dependency, and the
+    #         unparsed range expression.
+    def self.parse_module_dependency(where, dep)
+      dep_name = dep['name'].tr('/', '-')
+      range = dep['version_requirement'] || '>= 0.0.0'
+
+      begin
+        parsed_range = Module.parse_range(range)
+      rescue ArgumentError => e
+        Puppet.debug "Error in #{where} parsing dependency #{dep_name} (#{e.message}); using empty range."
+        parsed_range = SemanticPuppet::VersionRange::EMPTY_RANGE
+      end
+
+      [dep_name, parsed_range, range]
+    end
+  end
+end
+
+# Load remaining libraries
+require_relative 'module_tool/errors'
+require_relative 'module_tool/applications'
+require_relative 'module_tool/checksums'
+require_relative 'module_tool/dependency'
+require_relative 'module_tool/metadata'
+require_relative '../puppet/forge/cache'
+require_relative '../puppet/forge'

data/lib/puppet/network/authconfig.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Puppet
+  class Network::AuthConfig
+    def self.authprovider_class=(_)
+      # legacy auth is not supported, ignore
+    end
+  end
+end

data/lib/puppet/network/authorization.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Puppet::Network
+  module Authorization
+    class << self
+      # This method is deprecated and will be removed in a future release.
+      def authconfigloader_class=(klass)
+        @authconfigloader_class = klass
+      end
+
+      # Verify something external to puppet is authorizing REST requests, so
+      # we don't fail insecurely due to misconfiguration.
+      def check_external_authorization(method, path)
+        if @authconfigloader_class.nil?
+          message = "Forbidden request: #{path} (method #{method})"
+          raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError.new(message, Puppet::Network::HTTP::Issues::FAILED_AUTHORIZATION)
+        end
+      end
+    end
+  end
+end

data/lib/puppet/network/client_request.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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?
+      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 = name
+      @ip = ip
+      @authenticated = authenticated
+    end
+
+    def to_s
+      "#{name}(#{ip})"
+    end
+  end
+end

data/lib/puppet/network/format.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative '../../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, :charset
+
+  def init_attribute(name, default)
+    value = @options.delete(name)
+    value = default if value.nil?
+
+    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)
+    init_attribute(:charset, nil)
+
+    method_list.each do |method, value|
+      init_attribute(method, value)
+    end
+
+    raise ArgumentError, _("Unsupported option(s) %{options_list}") % { options_list: @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, _("%{klass} does not respond to %{method}; can not render multiple instances to %{mime}") %
+                               { klass: instances[0].class, method: render_multiple_method, mime: 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)
+
+    (type == :class ? klass.respond_to?(method) : klass.method_defined?(method))
+  end
+end

data/lib/puppet/network/format_handler.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative '../../puppet/network'
+require_relative '../../puppet/network/format'
+
+module Puppet::Network::FormatHandler
+  class FormatError < Puppet::Error; end
+
+  ALL_MEDIA_TYPES = '*/*'
+
+  @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
+
+    if out.nil?
+      raise ArgumentError, _("No format matches the given format name or mime-type (%{format})") % { format: format }
+    end
+
+    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 [Array<Puppet::Network::Format>] the most suitable formats that
+  #   are both accepted and supported
+  # @api private
+  def self.most_suitable_formats_for(accepted, supported)
+    accepted.collect do |format|
+      format.to_s.sub(/;q=.*$/, '')
+    end.filter_map do |format|
+      if format == ALL_MEDIA_TYPES
+        supported.first
+      else
+        format_to_canonical_name_or_nil(format)
+      end
+    end.find_all do |format|
+      supported.include?(format)
+    end.collect do |format|
+      format_for(format)
+    end
+  end
+
+  # @api private
+  def self.format_to_canonical_name_or_nil(format)
+    format_to_canonical_name(format)
+  rescue ArgumentError
+    nil
+  end
+end
+
+require_relative '../../puppet/network/formats'

data/lib/puppet/network/format_support.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative '../../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
+      # TRANSLATORS "intern" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not intern from %{format}: %{err}") % { format: format, err: err }, err.backtrace
+    end
+
+    def convert_from_multiple(format, data)
+      get_format(format).intern_multiple(self, data)
+    rescue => err
+      # TRANSLATORS "intern_multiple" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not intern_multiple from %{format}: %{err}") % { format: format, err: err }, err.backtrace
+    end
+
+    def render_multiple(format, instances)
+      get_format(format).render_multiple(instances)
+    rescue => err
+      # TRANSLATORS "render_multiple" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not render_multiple to %{format}: %{err}") % { format: format, err: 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
+
+      result = put_preferred_format_first(result).map(&:name)
+
+      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 respond_to? :indirection
+        indirection.name
+      else
+        self
+      end
+    end
+
+    def put_preferred_format_first(list)
+      preferred_format = Puppet.settings[:preferred_serialization_format].to_s
+
+      preferred = list.select { |format|
+        format.mime.end_with?(preferred_format)
+      }
+
+      if preferred.empty?
+        Puppet.debug { "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first.name})" }
+      else
+        list = preferred + list.reject { |format|
+          format.mime.end_with?(preferred_format)
+        }
+      end
+
+      list
+    end
+  end
+
+  def to_msgpack(*args)
+    to_data_hash.to_msgpack(*args)
+  end
+
+  # @deprecated, use to_json
+  def to_pson(*args)
+    to_data_hash.to_pson(*args)
+  end
+
+  def to_json(*args)
+    Puppet::Util::Json.dump(to_data_hash, *args)
+  end
+
+  def render(format = nil)
+    format ||= self.class.default_format
+
+    self.class.get_format(format).render(self)
+  rescue => err
+    # TRANSLATORS "render" is a function name and should not be translated
+    raise Puppet::Network::FormatHandler::FormatError, _("Could not render to %{format}: %{err}") % { format: format, err: err }, err.backtrace
+  end
+
+  def mime(format = nil)
+    format ||= self.class.default_format
+
+    self.class.get_format(format).mime
+  rescue => err
+    # TRANSLATORS "mime" is a function name and should not be translated
+    raise Puppet::Network::FormatHandler::FormatError, _("Could not mime to %{format}: %{err}") % { format: format, err: 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