pdk 1.14.1 → 1.18.1

data/lib/pdk/config/ini_file_setting.rb

@@ -0,0 +1,39 @@
+require 'pdk'
+
+module PDK
+  class Config
+    class IniFileSetting < PDK::Config::Setting
+      # Initialises the PDK::Config::JSONSchemaSetting object.
+      #
+      # @see PDK::Config::Setting.initialize
+      def initialize(_name, namespace, initial_value = nil)
+        raise 'The IniFileSetting object can only be created within the IniFile Namespace' unless namespace.is_a?(PDK::Config::IniFile)
+        super
+        validate!(initial_value) unless initial_value.nil?
+      end
+
+      # Verifies that the new setting value is valid in an Ini File
+      #
+      # @see PDK::Config::Setting.validate!
+      def validate!(value)
+        # We're very restrictive here. Realistically Ini files only have string types
+        return if value.nil? || value.is_a?(String) || value.is_a?(Integer)
+        # The only other valid-ish type is a Hash
+        unless value.is_a?(Hash)
+          raise ArgumentError, _('The setting %{key} may only be a String or Integer, not %{class}') % {
+            key:  qualified_name,
+            class: value.class,
+          }
+        end
+        # Any hashes can only have a single String/Integer value
+        value.each do |child_name, child_value|
+          next if child_value.nil? || child_value.is_a?(String) || child_value.is_a?(Integer)
+          raise ArgumentError, _('The setting %{key} may only be a String or Integer, not %{class}') % {
+            key:   qualified_name + '.' + child_name,
+            class: child_value.class,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/pdk/config/namespace.rb

@@ -27,13 +27,14 @@ module PDK
       #   used for settings which a randomly generated, instead of being deterministic, e.g. analytics user-id
       # @param block [Proc] a block that is evaluated within the new instance.
       def initialize(name = nil, file: nil, parent: nil, persistent_defaults: false, &block)
-        @file = File.expand_path(file) unless file.nil?
+        @file = PDK::Util::Filesystem.expand_path(file) unless file.nil?
         @settings = {}
         @name = name.to_s
         @parent = parent
         @persistent_defaults = persistent_defaults
         @mounts = {}
         @loaded_from_file = false
+        @read_only = false
 
         instance_eval(&block) if block_given?
       end
@@ -48,7 +49,7 @@ module PDK
       #
       # @return [nil]
       def setting(key, &block)
-        @settings[key.to_s] ||= PDK::Config::Setting.new(key.to_s, self)
+        @settings[key.to_s] ||= default_setting_class.new(key.to_s, self)
         @settings[key.to_s].instance_eval(&block) if block_given?
       end
 
@@ -97,7 +98,8 @@ module PDK
         # Check if it's a setting, otherwise nil
         return nil if settings[key.to_s].nil?
         return settings[key.to_s].value unless settings[key.to_s].value.nil?
-        default_value = settings[key.to_s].default
+        # Duplicate arrays and hashes so that they are isolated from changes being made
+        default_value = PDK::Util.deep_duplicate(settings[key.to_s].default)
         return default_value if default_value.nil? || !@persistent_defaults
         # Persist the default value
         settings[key.to_s].value = default_value
@@ -205,8 +207,26 @@ module PDK
         child_namespace? && file.nil?
       end
 
+      # Disables the namespace, and child namespaces, from writing changes to disk.
+      # Typically this is only needed for unit testing.
+      # @api private
+      def read_only!
+        @read_only = true
+        @mounts.each { |_, child| child.read_only! }
+      end
+
       private
 
+      # Returns the object class to create settings with. Subclasses may override this to use specific setting classes
+      #
+      # @return [Class[PDK::Config::Setting]]
+      #
+      # @abstract
+      # @private
+      def default_setting_class
+        PDK::Config::Setting
+      end
+
       # Determines whether a setting name should be resolved using the filter
       #  Returns true when filter is nil.
       #  Returns true if the filter is exactly the same name as the setting.
@@ -253,7 +273,7 @@ module PDK
         # Need to use `@settings` and `@mounts` here to stop recursive calls
         return unless @mounts[key.to_s].nil?
         return unless @settings[key.to_s].nil?
-        @settings[key.to_s] = PDK::Config::Setting.new(key.to_s, self, initial_value)
+        @settings[key.to_s] = default_setting_class.new(key.to_s, self, initial_value)
       end
 
       # Set the value of the named key.
@@ -281,7 +301,7 @@ module PDK
         return if filename.nil?
         return unless PDK::Util::Filesystem.file?(filename)
 
-        PDK::Util::Filesystem.read_file(file)
+        PDK::Util::Filesystem.read_file(filename)
       rescue Errno::ENOENT => e
         raise PDK::Config::LoadError, e.message
       rescue Errno::EACCES
@@ -302,7 +322,7 @@ module PDK
       #
       # @return [nil]
       def save_data
-        return if file.nil?
+        return if file.nil? || @read_only
 
         PDK::Util::Filesystem.mkdir_p(File.dirname(file))
 

data/lib/pdk/config/setting.rb

@@ -46,8 +46,9 @@ module PDK
         [namespace.name, @name].join('.')
       end
 
-      def value # rubocop:disable Style/TrivialAccessors
-        @value
+      def value
+        # Duplicate arrays and hashes so that they are isolated from changes being made
+        PDK::Util.deep_duplicate(@value)
       end
 
       def value=(obj)

data/lib/pdk/context.rb

@@ -0,0 +1,99 @@
+require 'pdk'
+
+module PDK
+  module Context
+    autoload :None, 'pdk/context/none'
+    autoload :Module, 'pdk/context/module'
+    autoload :ControlRepo, 'pdk/context/control_repo'
+
+    # Automatically determines the PDK Context given a path. Create will continue up the directory tree until it
+    # finds a valid context
+    # @return [PDK::Context::AbstractContext] Returns a PDK::Context::None if the context could not be determined
+    def self.create(context_path)
+      return PDK::Context::None.new(context_path) unless PDK::Util::Filesystem.directory?(context_path)
+
+      previous = nil
+      current = PDK::Util::Filesystem.expand_path(context_path)
+      until !PDK::Util::Filesystem.directory?(current) || current == previous
+        # Control Repo detection
+        return PDK::Context::ControlRepo.new(current, context_path) if PDK.feature_flag?('controlrepo') && PDK::ControlRepo.control_repo_root?(current)
+
+        # Puppet Module detection
+        metadata_file = File.join(current, 'metadata.json')
+        if PDK::Util::Filesystem.file?(metadata_file) || PDK::Util.in_module_root?(context_path)
+          return PDK::Context::Module.new(current, context_path)
+        end
+
+        previous = current
+        current = PDK::Util::Filesystem.expand_path('..', current)
+      end
+      PDK::Context::None.new(context_path)
+    end
+
+    # Abstract class which all PDK Contexts will subclass from.
+    # @abstract
+    class AbstractContext
+      # The root of this context, for example the module root when inside a module. This can be different from context_path
+      # For example a Module context_path could be /path/to/module/manifests/ but the root_path will be /path/to/module as
+      # that is the root of the Module context. Defaults to the context_path if not set.
+      # @return [String]
+      def root_path
+        @root_path || @context_path
+      end
+
+      # The path used to create this context, for example the current working directory. This can be different from root_path
+      # For example a Module context_path could be /path/to/module/manifests/ but the root_path will be /path/to/module as
+      # that is the root of the Module context
+      # @return [String]
+      attr_reader :context_path
+
+      # @param context_path [String] The path where this context was created from e.g. Dir.pwd
+      def initialize(context_path)
+        @context_path = context_path
+        @root_path = nil
+      end
+
+      # Whether the current context is compatible with the PDK e.g. in a Module context, whether it has the correct metadata.json content
+      # @return [Boolean] Default is not compatible
+      def pdk_compatible?
+        false
+      end
+
+      # The friendly name to display for this context
+      # @api private
+      # @abstract
+      def display_name; end
+
+      # The context which this context is in.  For example a Module Context (/controlrepo/site/profile) can be inside of a Control Repo context (/controlrepo)
+      # The default is to search in the parent directory of this context
+      # @return [PDK::Context::AbstractContext, Nil] Returns the parent context or nil if there is no parent.
+      def parent_context
+        # Default detection is just look for the context in the parent directory of this context
+        @parent_context || PDK::Context.create(File.dirname(root_path))
+      end
+
+      # Writes the current context information, and parent contexts, to the PDK Debug Logger.
+      # This is mainly used by the PDK CLI when in debug mode to assist users to figure out why the PDK is misbehaving.
+      # @api private
+      def to_debug_log
+        current = self
+        depth = 1
+        loop do
+          PDK.logger.debug("Detected #{current.display_name} at #{current.root_path.nil? ? current.context_path : current.root_path}")
+          current = current.parent_context
+          break if current.nil?
+          depth += 1
+          # Circuit breaker in case there are circular references
+          break if depth > 20
+        end
+        nil
+      end
+
+      #:nocov: There's nothing to test here
+      def to_s
+        "#<#{self.class}:#{object_id}>#{context_path}"
+      end
+      #:nocov:
+    end
+  end
+end

data/lib/pdk/context/control_repo.rb

@@ -0,0 +1,60 @@
+require 'pdk'
+
+module PDK
+  module Context
+    # Represents a context for a directory based Control Repository
+    class ControlRepo < PDK::Context::AbstractContext
+      # @param repo_root [String] The root path for the control repo.
+      # @param context_path [String] The path where this context was created from e.g. Dir.pwd
+      # @see PDK::Context::AbstractContext
+      def initialize(repo_root, context_path)
+        super(context_path)
+        @root_path = repo_root
+        @environment_conf = nil
+      end
+
+      # @see PDK::Context::AbstractContext.pdk_compatible?
+      def pdk_compatible?
+        # Currently there is nothing to determine compatibility with the PDK for a
+        # Control Repo. For now assume everything is compatible
+        true
+      end
+
+      # The modulepath setting for this control repository as an array of strings. These paths are relative
+      # and may contain interpolation strings (e.g. $basemodulepath)
+      # @see https://puppet.com/docs/puppet/latest/config_file_environment.html#allowed-settings
+      # @return [Array[String]] The modulepath setting for this control repository
+      def module_paths
+        return @module_paths unless @module_paths.nil?
+        value = environment_conf['modulepath'] || ''
+        # We have to use a hardcoded value here because File::PATH_SEPARATOR is ';' on Windows.
+        # As the environment.conf is only used on Puppet Server, it's always ':'
+        # Based on - https://github.com/puppetlabs/puppet/blob/f3e6d7e6d87f46408943a8e2176afb82ff6ea096/lib/puppet/settings/environment_conf.rb#L98-L106
+        @module_paths = value.split(':')
+      end
+
+      # The relative module_paths that exist on disk.
+      # @see https://puppet.com/docs/puppet/latest/config_file_environment.html#allowed-settings
+      # @return [Array[String]] The relative module paths on disk
+      def actualized_module_paths
+        @actualized_module_paths ||= module_paths.reject { |path| path.start_with?('$') }
+                                                 .select { |path| PDK::Util::Filesystem.directory?(PDK::Util::Filesystem.expand_path(File.join(root_path, path))) }
+      end
+
+      #:nocov:
+      # @see PDK::Context::AbstractContext.display_name
+      def display_name
+        _('a Control Repository context')
+      end
+      #:nocov:
+
+      private
+
+      # Memoization helper to read the environment.conf file.
+      # @return [PDK::Config::IniFile]
+      def environment_conf
+        @environment_conf ||= PDK::ControlRepo.environment_conf_as_config(File.join(root_path, 'environment.conf'))
+      end
+    end
+  end
+end

data/lib/pdk/context/module.rb

@@ -0,0 +1,28 @@
+require 'pdk'
+
+module PDK
+  module Context
+    # Represents a context for a Puppet Module
+    class Module < PDK::Context::AbstractContext
+      # @param module_root [String] The root path for the module.
+      # @param context_path [String] The path where this context was created from e.g. Dir.pwd
+      # @see PDK::Context::AbstractContext
+      def initialize(module_root, context_path)
+        super(context_path)
+        @root_path = module_root
+      end
+
+      # @see PDK::Context::AbstractContext.pdk_compatible?
+      def pdk_compatible?
+        PDK::Util.module_pdk_compatible?(root_path)
+      end
+
+      #:nocov:
+      # @see PDK::Context::AbstractContext.display_name
+      def display_name
+        _('a Puppet Module context')
+      end
+      #:nocov:
+    end
+  end
+end

data/lib/pdk/context/none.rb

@@ -0,0 +1,22 @@
+require 'pdk'
+
+module PDK
+  module Context
+    # Represents a context which the PDK does not know. For example
+    # an empty directory
+    class None < PDK::Context::AbstractContext
+      #:nocov:
+      # @see PDK::Context::AbstractContext.display_name
+      def display_name
+        _('an unknown context')
+      end
+      #:nocov:
+
+      # @see PDK::Context::AbstractContext.parent_context
+      def parent_context
+        # An unknown context has no parent
+        nil
+      end
+    end
+  end
+end

data/lib/pdk/control_repo.rb

@@ -0,0 +1,90 @@
+require 'pdk'
+
+module PDK
+  module ControlRepo
+    CONTROL_REPO_FILES = %w[environment.conf Puppetfile].freeze
+
+    DEFAULT_IGNORED = [
+      '/pkg/',
+      '~*',
+      '/coverage',
+      # Strictly speaking this isn't default but if people have tricked older PDK into thinking that a
+      # Control Repo is a module, they may have recursive symlinks in spec/fixtures/modules
+      '/spec/fixtures/modules/',
+      '/vendor/',
+    ].freeze
+
+    # Returns path to the root of the Control Repo being worked on.
+    #
+    # An environment.conf is required for a PDK compatible Control Repo,
+    # whereas Puppetfile is optional.
+    #
+    # Note - A Bolt Project can also be a Control Repo.
+    #
+    # Note - Non-Directory environments can exist however directory based
+    # environments are the supported/preferred way.
+    #
+    # @see https://puppet.com/docs/pe/latest/control_repo.html
+    #
+    # @param strict_check [Boolean] When strict_check is true, only return the path
+    #   if the Control Repo is strictly _only_ a control repository. For example,
+    #   not also a Puppet Bolt project directory  Default is false.
+    #
+    # @return [String, nil] Fully qualified base path to Control Repo, or nil if
+    #   the current working dir does not appear to be within a Control Repo.
+    def find_control_repo_root(strict_check = false)
+      environment_conf_path = PDK::Util.find_upwards('environment.conf')
+      path = if environment_conf_path
+               File.dirname(environment_conf_path)
+             elsif control_repo_root?(Dir.pwd)
+               Dir.pwd
+             else
+               nil
+             end
+      return path if path.nil? || !strict_check
+      PDK::Bolt.bolt_project_root?(path) ? nil : path
+    end
+    module_function :find_control_repo_root
+
+    # Returns true or false depending on if any of the common files in a Control Repo
+    # are found in the specified directory. If a directory is not specified, the current
+    # working directory is used.
+    #
+    # @return [boolean] True if any folders from CONTROL_REPO_FILES are found in the current dir,
+    #   false otherwise.
+    def control_repo_root?(path = Dir.pwd)
+      CONTROL_REPO_FILES.any? { |file| PDK::Util::Filesystem.file?(File.join(path, file)) }
+    end
+    module_function :control_repo_root?
+
+    # Returns a PDK::Config::Namespace for the specified environment.conf file.
+    # Note there is no validation of the path.
+    #
+    # @param path [String] The path to the environment.conf file
+    #
+    # @return [PDK::Config::IniFile] The configuration file
+    def environment_conf_as_config(path)
+      PDK::Config::IniFile.new('environment', file: path) do
+        setting :modulepath do
+          # As per https://puppet.com/docs/puppet/latest/config_file_environment.html#allowed-settings
+          default_to { 'modules:$basemodulepath' }
+        end
+
+        setting :manifest do
+          # As per https://puppet.com/docs/puppet/latest/config_file_environment.html#allowed-settings
+          default_to { 'manifests/' }
+        end
+      end
+    end
+    module_function :environment_conf_as_config
+
+    def default_ignored_pathspec(ignore_dotfiles = true)
+      require 'pathspec'
+
+      PathSpec.new(DEFAULT_IGNORED).tap do |ps|
+        ps.add('.*') if ignore_dotfiles
+      end
+    end
+    module_function :default_ignored_pathspec
+  end
+end

data/lib/pdk/generate.rb

@@ -7,6 +7,7 @@ module PDK
     autoload :Provider, 'pdk/generate/provider'
     autoload :PuppetClass, 'pdk/generate/puppet_class'
     autoload :PuppetObject, 'pdk/generate/puppet_object'
+    autoload :ResourceAPIObject, 'pdk/generate/resource_api_object'
     autoload :Task, 'pdk/generate/task'
     autoload :Transport, 'pdk/generate/transport'