puppet 6.29.0-universal-darwin → 7.0.0-universal-darwin

data/lib/puppet/facter_impl.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-#
-# @api private
-# Default Facter implementation that delegates to Facter API
-#
-
-module Puppet
-  class FacterImpl
-    def initialize
-      require 'facter'
-
-      setup_logging
-    end
-
-    def value(fact_name)
-      ::Facter.value(fact_name)
-    end
-
-    def add(name, &block)
-      ::Facter.add(name, &block)
-    end
-
-    def to_hash
-      ::Facter.to_hash
-    end
-
-    def clear
-      ::Facter.clear
-    end
-
-    def reset
-      ::Facter.reset
-    end
-
-    def resolve(options)
-      ::Facter.resolve(options)
-    end
-
-    def search_external(dirs)
-      ::Facter.search_external(dirs)
-    end
-
-    def search(*dirs)
-      ::Facter.search(*dirs)
-    end
-
-    def trace(value)
-      ::Facter.trace(value) if ::Facter.respond_to? :trace
-    end
-
-    def debugging(value)
-      ::Facter.debugging(value) if ::Facter.respond_to?(:debugging)
-    end
-
-    def load_external?
-      ::Facter.respond_to?(:load_external)
-    end
-
-    def load_external(value)
-      ::Facter.load_external(value) if self.load_external?
-    end
-
-    private
-
-    def setup_logging
-      return unless ::Facter.respond_to? :on_message
-
-      ::Facter.on_message do |level, message|
-        case level
-        when :trace, :debug
-          level = :debug
-        when :info
-          # Same as Puppet
-        when :warn
-          level = :warning
-        when :error
-          level = :err
-        when :fatal
-          level = :crit
-        else
-          next
-        end
-
-        Puppet::Util::Log.create(
-          {
-            :level => level,
-            :source => 'Facter',
-            :message => message
-          }
-        )
-        nil
-      end
-    end
-  end
-end

data/lib/puppet/ffi/posix/constants.rb

@@ -1,14 +0,0 @@
-require 'puppet/ffi/posix'
-
-module Puppet::FFI::POSIX
-  module Constants
-    extend FFI::Library
-  
-    # Maximum number of supplementary groups (groups
-    # that a user can be in plus its primary group)
-    # (64 + 1 primary group)
-    # Chosen a reasonable middle number from the list
-    # https://www.j3e.de/ngroups.html
-    MAXIMUM_NUMBER_OF_GROUPS = 65
-  end
-end

data/lib/puppet/ffi/posix/functions.rb

@@ -1,24 +0,0 @@
-require 'puppet/ffi/posix'
-
-module Puppet::FFI::POSIX
-  module Functions
-
-    extend FFI::Library
-
-    ffi_convention :stdcall
-
-    # https://man7.org/linux/man-pages/man3/getgrouplist.3.html
-    # int getgrouplist (
-    #   const char *user,
-    #   gid_t group,
-    #   gid_t *groups,
-    #   int *ngroups
-    # );
-    begin
-      ffi_lib FFI::Library::LIBC
-      attach_function :getgrouplist, [:string, :uint, :pointer, :pointer], :int
-    rescue FFI::NotFoundError
-      # Do nothing
-    end
-  end
-end

data/lib/puppet/ffi/posix.rb

@@ -1,10 +0,0 @@
-require 'ffi'
-
-module Puppet
-  module FFI
-    module POSIX
-      require 'puppet/ffi/posix/functions'
-      require 'puppet/ffi/posix/constants'
-    end
-  end
-end

data/lib/puppet/file_serving/mount/scripts.rb

@@ -1,24 +0,0 @@
-require 'puppet/file_serving/mount'
-
-class Puppet::FileServing::Mount::Scripts < Puppet::FileServing::Mount
-  # Return an instance of the appropriate class.
-  def find(path, request)
-    raise _("No module specified") if path.to_s.empty?
-    module_name, relative_path = path.split("/", 2)
-    mod = request.environment.module(module_name)
-    return nil unless mod
-
-    mod.script(relative_path)
-  end
-
-  def search(path, request)
-    result = find(path, request)
-    if result
-      [result]
-    end
-  end
-
-  def valid?
-    true
-  end
-end

data/lib/puppet/indirector/certificate/file.rb

@@ -1,9 +0,0 @@
-require 'puppet/indirector/ssl_file'
-require 'puppet/ssl/certificate'
-
-# @deprecated
-class Puppet::SSL::Certificate::File < Puppet::Indirector::SslFile
-  desc "Manage SSL certificates on disk."
-
-  store_in :certdir
-end

data/lib/puppet/indirector/certificate/rest.rb

@@ -1,18 +0,0 @@
-require 'puppet/ssl/certificate'
-require 'puppet/indirector/rest'
-
-# @deprecated
-class Puppet::SSL::Certificate::Rest < Puppet::Indirector::REST
-  desc "Find certificates over HTTP via REST."
-
-  use_server_setting(:ca_server)
-  use_port_setting(:ca_port)
-  use_srv_service(:ca)
-
-  def find(request)
-    result = super
-    return nil unless result
-    result.name = request.key unless result.name == request.key
-    result
-  end
-end

data/lib/puppet/indirector/certificate_request/file.rb

@@ -1,9 +0,0 @@
-require 'puppet/indirector/ssl_file'
-require 'puppet/ssl/certificate_request'
-
-# @deprecated
-class Puppet::SSL::CertificateRequest::File < Puppet::Indirector::SslFile
-  desc "Manage the collection of certificate requests on disk."
-
-  store_in :requestdir
-end

data/lib/puppet/indirector/certificate_request/memory.rb

@@ -1,7 +0,0 @@
-require 'puppet/ssl/certificate_request'
-require 'puppet/indirector/memory'
-
-# @deprecated
-class Puppet::SSL::CertificateRequest::Memory < Puppet::Indirector::Memory
-  desc "Store certificate requests in memory. This is used for testing puppet."
-end

data/lib/puppet/indirector/certificate_request/rest.rb

@@ -1,11 +0,0 @@
-require 'puppet/ssl/certificate_request'
-require 'puppet/indirector/rest'
-
-# @deprecated
-class Puppet::SSL::CertificateRequest::Rest < Puppet::Indirector::REST
-  desc "Find and save certificate requests over HTTP via REST."
-
-  use_server_setting(:ca_server)
-  use_port_setting(:ca_port)
-  use_srv_service(:ca)
-end

data/lib/puppet/indirector/file_content/http.rb

@@ -1,22 +0,0 @@
-require 'puppet/file_serving/metadata'
-require 'puppet/indirector/generic_http'
-require 'puppet/network/http'
-
-class Puppet::Indirector::FileContent::Http < Puppet::Indirector::GenericHttp
-  desc "Retrieve file contents from a remote HTTP server."
-
-  include Puppet::FileServing::TerminusHelper
-  include Puppet::Network::HTTP::Compression.module
-
-  @http_method = :get
-
-  def initialize
-    Puppet.deprecation_warning(_("Puppet::Indirector::FileContent::Http is deprecated. Use Puppet::HTTP::Client instead."))
-    super
-  end
-
-  def find(request)
-    response = super
-    model.from_binary(uncompress_body(response))
-  end
-end

data/lib/puppet/indirector/key/file.rb

@@ -1,46 +0,0 @@
-require 'puppet/indirector/ssl_file'
-require 'puppet/ssl/key'
-
-# @deprecated
-class Puppet::SSL::Key::File < Puppet::Indirector::SslFile
-  desc "Manage SSL private and public keys on disk."
-
-  store_in :privatekeydir
-
-  def allow_remote_requests?
-    false
-  end
-
-  # Where should we store the public key?
-  def public_key_path(name)
-    File.join(Puppet[:publickeydir], name.to_s + ".pem")
-  end
-
-  # Remove the public key, in addition to the private key
-  def destroy(request)
-    super
-
-    key_path = Puppet::FileSystem.pathname(public_key_path(request.key))
-    return unless Puppet::FileSystem.exist?(key_path)
-
-    begin
-      Puppet::FileSystem.unlink(key_path)
-    rescue => detail
-      raise Puppet::Error, _("Could not remove %{request} public key: %{detail}") % { request: request.key, detail: detail }, detail.backtrace
-    end
-  end
-
-  # Save the public key, in addition to the private key.
-  def save(request)
-    super
-
-    begin
-      # RFC 1421 states PEM is 7-bit ASCII https://tools.ietf.org/html/rfc1421
-      Puppet.settings.setting(:publickeydir).open_file(public_key_path(request.key), 'w:ASCII') do |f|
-        f.print request.instance.content.public_key.to_pem
-      end
-    rescue => detail
-      raise Puppet::Error, _("Could not write %{request}: %{detail}") % { request: request.key, detail: detail }, detail.backtrace
-    end
-  end
-end

data/lib/puppet/indirector/key/memory.rb

@@ -1,7 +0,0 @@
-require 'puppet/ssl/key'
-require 'puppet/indirector/memory'
-
-# @deprecated
-class Puppet::SSL::Key::Memory < Puppet::Indirector::Memory
-  desc "Store keys in memory. This is used for testing puppet."
-end

data/lib/puppet/indirector/ssl_file.rb

@@ -1,162 +0,0 @@
-require 'puppet/ssl'
-
-class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
-  # Specify the directory in which multiple files are stored.
-  def self.store_in(setting)
-    @directory_setting = setting
-  end
-
-  # Specify a single file location for storing just one file.
-  # This is used for things like the CRL.
-  def self.store_at(setting)
-    @file_setting = setting
-  end
-
-  class << self
-    attr_reader :directory_setting, :file_setting
-  end
-
-  # The full path to where we should store our files.
-  def self.collection_directory
-    return nil unless directory_setting
-    Puppet.settings[directory_setting]
-  end
-
-  # The full path to an individual file we would be managing.
-  def self.file_location
-    return nil unless file_setting
-    Puppet.settings[file_setting]
-  end
-
-  def initialize
-    Puppet.settings.use(:main, :ssl)
-
-    (collection_directory || file_location) or raise Puppet::DevError, _("No file or directory setting provided; terminus %{class_name} cannot function") % { class_name: self.class.name }
-  end
-
-  def path(name)
-    if name =~ Puppet::Indirector::BadNameRegexp then
-      Puppet.crit(_("directory traversal detected in %{indirection}: %{name}") % { indirection: self.class, name: name.inspect })
-      raise ArgumentError, _("invalid key")
-    end
-
-    if collection_directory
-      File.join(collection_directory, name.to_s + ".pem")
-    else
-      file_location
-    end
-  end
-
-  # Remove our file.
-  def destroy(request)
-    path = Puppet::FileSystem.pathname(path(request.key))
-    return false unless Puppet::FileSystem.exist?(path)
-
-    Puppet.notice _("Removing file %{model} %{request} at '%{path}'") % { model: model, request: request.key, path: path }
-    begin
-      Puppet::FileSystem.unlink(path)
-    rescue => detail
-      raise Puppet::Error, _("Could not remove %{request}: %{detail}") % { request: request.key, detail: detail }, detail.backtrace
-    end
-  end
-
-  # Find the file on disk, returning an instance of the model.
-  def find(request)
-    filename = rename_files_with_uppercase(path(request.key))
-
-    filename ? create_model(request.key, filename) : nil
-  end
-
-  # Save our file to disk.
-  def save(request)
-    path = path(request.key)
-    dir = File.dirname(path)
-
-    raise Puppet::Error.new(_("Cannot save %{request}; parent directory %{dir} does not exist") % { request: request.key, dir: dir }) unless FileTest.directory?(dir)
-    raise Puppet::Error.new(_("Cannot save %{request}; parent directory %{dir} is not writable") % { request: request.key, dir: dir }) unless FileTest.writable?(dir)
-
-    write(request.key, path) { |f| f.print request.instance.to_s }
-  end
-
-  # Search for more than one file.  At this point, it just returns
-  # an instance for every file in the directory.
-  def search(request)
-    dir = collection_directory
-    Dir.entries(dir).
-      select  { |file| file =~ /\.pem$/ }.
-      collect { |file| create_model(file.sub(/\.pem$/, ''), File.join(dir, file)) }.
-      compact
-  end
-
-  private
-
-  def create_model(name, path)
-    result = model.new(name)
-    # calls Puppet::SSL::Base#read for subclasses of Puppet::SSL::Base
-    # with the exception of any overrides, like Puppet::SSL::Key
-    result.read(path)
-    result
-  end
-
-  # Demeterish pointers to class info.
-  def collection_directory
-    self.class.collection_directory
-  end
-
-  def file_location
-    self.class.file_location
-  end
-
-  # A hack method to deal with files that exist with a different case.
-  # Just renames it; doesn't read it in or anything.
-  # LAK:NOTE This is a copy of the method in sslcertificates/support.rb,
-  # which we'll be EOL'ing at some point.  This method was added at 20080702
-  # and should be removed at some point.
-  def rename_files_with_uppercase(file)
-    return file if Puppet::FileSystem.exist?(file)
-
-    dir, short = File.split(file)
-    return nil unless Puppet::FileSystem.exist?(dir)
-
-    raise ArgumentError, _("Tried to fix SSL files to a file containing uppercase") unless short.downcase == short
-    real_file = Dir.entries(dir).reject { |f| f =~ /^\./ }.find do |other|
-      other.downcase == short
-    end
-
-    return nil unless real_file
-
-    full_file = File.join(dir, real_file)
-
-    Puppet.deprecation_warning _("Automatic downcasing and renaming of ssl files is deprecated; please request the file using its correct case: %{full_file}") % { full_file: full_file }
-    File.rename(full_file, file)
-
-    file
-  end
-
-  # Yield a filehandle set up appropriately, either with our settings doing
-  # the work or opening a filehandle manually.
-  def write(name, path)
-    # All types serialized to disk contain only ASCII content:
-    # * SSL::Key may be a .export(OpenSSL::Cipher::DES.new(:EDE3, :CBC), pass) or .to_pem
-    # * All other classes are translated to strings by calling .to_pem
-    if file_location
-      Puppet.settings.setting(self.class.file_setting).open('w:ASCII') { |f| yield f }
-    else
-      setting = self.class.directory_setting
-      if setting
-        begin
-          Puppet.settings.setting(setting).open_file(path, 'w:ASCII') { |f| yield f }
-        rescue => detail
-          raise Puppet::Error, _("Could not write %{path} to %{setting}: %{detail}") % { path: path, setting: setting, detail: detail }, detail.backtrace
-        end
-      else
-        raise Puppet::DevError, _("You must provide a setting to determine where the files are stored")
-      end
-    end
-  end
-end
-
-# LAK:NOTE This has to be at the end, because classes like SSL::Key use this
-# class, and this require statement loads those, which results in a load loop
-# and lots of failures.
-require 'puppet/ssl/host'

data/lib/puppet/indirector/status/local.rb

@@ -1,12 +0,0 @@
-require 'puppet/indirector/status'
-
-class Puppet::Indirector::Status::Local < Puppet::Indirector::Code
-
-  desc "Get status locally. Only used internally."
-
-  def find( *anything )
-    status = model.new
-    status.version= Puppet.version
-    status
-  end
-end

data/lib/puppet/indirector/status/rest.rb

@@ -1,27 +0,0 @@
-require 'puppet/indirector/status'
-require 'puppet/indirector/rest'
-
-class Puppet::Indirector::Status::Rest < Puppet::Indirector::REST
-
-  desc "Get puppet master's status via REST. Useful because it tests the health
-    of both the web server and the indirector."
-
-  def find(request)
-    return super unless use_http_client?
-
-    session = Puppet.lookup(:http_session)
-    api = session.route_to(:puppet)
-    _, status = api.get_status(request.key)
-    status
-  rescue Puppet::HTTP::ResponseError => e
-    if e.response.code == 404
-      return nil unless request.options[:fail_on_404]
-
-      _, body = parse_response(e.response.nethttp)
-      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(e.response.url.path, 100), body: body }
-      raise Puppet::Error, msg
-    else
-      raise convert_to_http_error(e.response.nethttp)
-    end
-  end
-end

data/lib/puppet/indirector/status.rb

@@ -1,3 +0,0 @@
-# A stub class, so our constants work.
-class Puppet::Indirector::Status
-end

data/lib/puppet/module_tool/applications/searcher.rb

@@ -1,29 +0,0 @@
-module Puppet::ModuleTool
-  module Applications
-    class Searcher < Application
-      include Puppet::Forge::Errors
-
-      def initialize(term, forge, options = {})
-        @term = term
-        @forge = forge
-        super(options)
-      end
-
-      def run
-        results = {}
-        begin
-          Puppet.notice _("Searching %{host} ...") % { host: @forge.host }
-          results[:answers] = @forge.search(@term)
-          results[:result] = :success
-        rescue ForgeError => e
-          results[:result] = :failure
-          results[:error] = {
-            :oneline   => e.message,
-            :multiline => e.multiline,
-          }
-        end
-        results
-      end
-    end
-  end
-end

data/lib/puppet/network/auth_config_parser.rb

@@ -1,90 +0,0 @@
-require 'puppet/network/rights'
-
-module Puppet::Network
-class AuthConfigParser
-
-  def self.new_from_file(file)
-    self.new(Puppet::FileSystem.read(file, :encoding => 'utf-8'))
-  end
-
-  def initialize(string)
-    @string = string
-  end
-
-  def parse
-    Puppet::Network::AuthConfig.new(parse_rights)
-  end
-
-  def parse_rights
-    rights = Puppet::Network::Rights.new
-    right = nil
-    count = 1
-    @string.each_line { |line|
-      case line.chomp
-      when /^\s*#/, /^\s*$/
-        # skip comments and blank lines
-      when /^path\s+((?:~\s+)?[^ ]+)\s*$/ # "path /path" or "path ~ regex"
-        name = $1.chomp
-        right = rights.newright(name, count, @file)
-      when /^\s*(allow(?:_ip)?|deny(?:_ip)?|method|environment|auth(?:enticated)?)\s+(.+?)(\s*#.*)?$/
-        if right.nil?
-          #TRANSLATORS "path" is a configuration file entry and should not be translated
-          raise Puppet::ConfigurationError, _("Missing or invalid 'path' before right directive at %{error_location}") %
-              { error_location: Puppet::Util::Errors.error_location(@file, count) }
-        end
-        parse_right_directive(right, $1, $2, count)
-      else
-        error_location_str = Puppet::Util::Errors.error_location(nil, count)
-        raise Puppet::ConfigurationError, _("Invalid entry at %{error_location}: %{file_text}") %
-            { error_location: error_location_str, file_text: line }
-      end
-      count += 1
-    }
-
-    # Verify each of the rights are valid.
-    # We let the check raise an error, so that it can raise an error
-    # pointing to the specific problem.
-    rights.each { |name, r|
-      r.valid?
-    }
-    rights
-  end
-
-  def parse_right_directive(right, var, value, count)
-    value.strip!
-    case var
-    when "allow"
-      modify_right(right, :allow, value, _("allowing %{value} access"), count)
-    when "deny"
-      modify_right(right, :deny, value, _("denying %{value} access"), count)
-    when "allow_ip"
-      modify_right(right, :allow_ip, value, _("allowing IP %{value} access"), count)
-    when "deny_ip"
-      modify_right(right, :deny_ip, value, _("denying IP %{value} access"), count)
-    when "method"
-      modify_right(right, :restrict_method, value, _("allowing 'method' %{value}"), count)
-    when "environment"
-      modify_right(right, :restrict_environment, value, _("adding environment %{value}"), count)
-    when /auth(?:enticated)?/
-      modify_right(right, :restrict_authenticated, value, _("adding authentication %{value}"), count)
-    else
-      error_location_str = Puppet::Util::Errors.error_location(nil, count)
-      raise Puppet::ConfigurationError, _("Invalid argument '%{var}' at %{error_location}") %
-          { var: var, error_location: error_location_str }
-    end
-  end
-
-  def modify_right(right, method, value, msg, count)
-    value.split(/\s*,\s*/).each do |val|
-      begin
-        val.strip!
-        right.info msg % { value: val }
-        right.send(method, val)
-      rescue Puppet::AuthStoreError => detail
-        error_location_str = Puppet::Util::Errors.error_location(@file, count)
-        raise Puppet::ConfigurationError, "#{detail} #{error_location_str}", detail.backtrace
-      end
-    end
-  end
-end
-end