pdk-akerl 1.9.1.1 → 1.14.0.1

data/lib/pdk/generate/provider.rb

@@ -72,11 +72,6 @@ module PDK
       def target_type_spec_path
         @target_type_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'type', object_name) + '_spec.rb'
       end
-
-      # transform a object name into a ruby class name
-      def self.class_name_from_object_name(object_name)
-        object_name.to_s.split('_').map(&:capitalize).join
-      end
     end
   end
 end

data/lib/pdk/generate/puppet_class.rb

@@ -4,6 +4,7 @@ module PDK
   module Generate
     class PuppetClass < PuppetObject
       OBJECT_TYPE = :class
+      PUPPET_STRINGS_TYPE = 'puppet_classes'.freeze
 
       # Prepares the data needed to render the new Puppet class template.
       #

data/lib/pdk/generate/puppet_object.rb

@@ -1,12 +1,3 @@
-require 'fileutils'
-
-require 'pdk'
-require 'pdk/logger'
-require 'pdk/module/metadata'
-require 'pdk/module/templatedir'
-require 'pdk/template_file'
-require 'pdk/util/filesystem'
-
 module PDK
   module Generate
     class PuppetObject
@@ -29,7 +20,7 @@ module PDK
       # @param options [Hash{Symbol => Object}]
       #
       # @api public
-      def initialize(module_dir, object_name, options = {})
+      def initialize(module_dir, object_name, options)
         @module_dir = module_dir
         @options = options
         @object_name = object_name
@@ -45,6 +36,10 @@ module PDK
         end
       end
 
+      def spec_only?
+        @options[:spec_only]
+      end
+
       # @abstract Subclass and implement {#template_data} to provide data to
       #   the templates during rendering. Implementations of this method should
       #   return a Hash!{Symbol => Object}.
@@ -81,6 +76,13 @@ module PDK
         nil
       end
 
+      # @abstract Subclass and implement {#target_device_path}. Implementations
+      #   of this method should return a String containing the destination path
+      #   of the device class being generated.
+      def target_device_path
+        nil
+      end
+
       # Retrieves the type of the object being generated, e.g. :class,
       # :defined_type, etc. This is specified in the subclass' OBJECT_TYPE
       # constant.
@@ -92,6 +94,37 @@ module PDK
         self.class::OBJECT_TYPE
       end
 
+      # Retrieves the type of the object being generated as represented in
+      # the JSON output of puppet-strings.
+      #
+      # @return [String] the type of the object being generated or nil if
+      #   there is no mapping.
+      #
+      # @api private
+      def self.puppet_strings_type
+        return nil unless const_defined?(:PUPPET_STRINGS_TYPE)
+
+        self::PUPPET_STRINGS_TYPE
+      end
+
+      # Returns an array of possible target path strings.
+      def targets
+        targets = [
+          target_spec_path,
+          target_type_spec_path,
+        ]
+
+        unless spec_only?
+          targets += [
+            target_object_path,
+            target_type_path,
+            target_device_path,
+          ]
+        end
+
+        targets.compact
+      end
+
       # Check preconditions of this template group. By default this only makes sure that the target files do not
       # already exist. Override this (and call super) to add your own preconditions.
       #
@@ -99,16 +132,30 @@ module PDK
       #
       # @api public
       def check_preconditions
-        [target_object_path, target_type_path, target_spec_path, target_type_spec_path].compact.each do |target_file|
-          next unless File.exist?(target_file)
+        require 'pdk/util/filesystem'
+
+        targets.each do |target_file|
+          next unless PDK::Util::Filesystem.exist?(target_file)
 
           raise PDK::CLI::ExitWithError, _("Unable to generate %{object_type}; '%{file}' already exists.") % {
             file:        target_file,
-            object_type: object_type,
+            object_type: spec_only? ? 'unit test' : object_type,
           }
         end
       end
 
+      # Check the preconditions of this template group, behaving as a
+      # predicate rather than raising an exception.
+      #
+      # @return [Boolean] true if the generator is safe to run, otherwise
+      #   false.
+      def can_run?
+        check_preconditions
+        true
+      rescue PDK::CLI::ExitWithError
+        false
+      end
+
       # Check that the templates can be rendered. Find an appropriate template
       # and create the target files from the template. This is the main entry
       # point for the class.
@@ -123,8 +170,9 @@ module PDK
         with_templates do |template_path, config_hash|
           data = template_data.merge(configs: config_hash)
 
-          render_file(target_object_path, template_path[:object], data)
+          render_file(target_object_path, template_path[:object], data) unless spec_only?
           render_file(target_type_path, template_path[:type], data) if template_path[:type]
+          render_file(target_device_path, template_path[:device], data) if template_path[:device]
           render_file(target_spec_path, template_path[:spec], data) if template_path[:spec]
           render_file(target_type_spec_path, template_path[:type_spec], data) if template_path[:type_spec]
         end
@@ -148,6 +196,8 @@ module PDK
       #
       # @api private
       def render_file(dest_path, template_path, data)
+        require 'pdk/template_file'
+
         write_file(dest_path) do
           PDK::TemplateFile.new(template_path, data).render
         end
@@ -168,12 +218,15 @@ module PDK
       #
       # @api private
       def write_file(dest_path)
+        require 'pdk/logger'
+        require 'pdk/util/filesystem'
+
         PDK.logger.info(_("Creating '%{file}' from template.") % { file: dest_path })
 
         file_content = yield
 
         begin
-          FileUtils.mkdir_p(File.dirname(dest_path))
+          PDK::Util::Filesystem.mkdir_p(File.dirname(dest_path))
         rescue SystemCallError => e
           raise PDK::CLI::FatalError, _("Unable to create directory '%{path}': %{message}") % {
             path:    File.dirname(dest_path),
@@ -204,13 +257,17 @@ module PDK
       #
       # @api private
       def with_templates
+        require 'pdk/logger'
+        require 'pdk/module/templatedir'
+        require 'pdk/util/template_uri'
+
         templates.each do |template|
-          if template[:url].nil?
-            PDK.logger.debug(_('No %{dir_type} template specified; trying next template directory.') % { dir_type: template[:type] })
+          if template[:uri].nil?
+            PDK.logger.debug(_('No %{dir_type} template found; trying next template directory.') % { dir_type: template[:type] })
             next
           end
 
-          PDK::Module::TemplateDir.new(template[:url]) do |template_dir|
+          PDK::Module::TemplateDir.new(PDK::Util::TemplateURI.new(template[:uri])) do |template_dir|
             template_paths = template_dir.object_template_for(object_type)
 
             if template_paths
@@ -219,9 +276,9 @@ module PDK
               # TODO: refactor to a search-and-execute form instead
               return # work is done # rubocop:disable Lint/NonLocalExitFromIterator
             elsif template[:allow_fallback]
-              PDK.logger.debug(_('Unable to find a %{type} template in %{url}; trying next template directory.') % { type: object_type, url: template[:url] })
+              PDK.logger.debug(_('Unable to find a %{type} template in %{url}; trying next template directory.') % { type: object_type, url: template[:uri] })
             else
-              raise PDK::CLI::FatalError, _('Unable to find the %{type} template in %{url}.') % { type: object_type, url: template[:url] }
+              raise PDK::CLI::FatalError, _('Unable to find the %{type} template in %{url}.') % { type: object_type, url: template[:uri] }
             end
           end
         end
@@ -250,38 +307,28 @@ module PDK
       #
       # @api private
       def templates
-        @templates ||= [
-          { type: 'CLI', url: @options[:'template-url'], allow_fallback: false },
-          { type: 'metadata', url: module_metadata.data['template-url'], allow_fallback: true },
-          { type: 'default', url: PDK::Util.default_template_url, allow_fallback: false },
-        ]
+        require 'pdk/util/template_uri'
+
+        @templates ||= PDK::Util::TemplateURI.templates(@options)
       end
 
       # Retrieves the name of the module (without the forge username) from the
       # module metadata.
       #
-      # @raise (see #module_metadata)
       # @return [String] The name of the module.
       #
       # @api private
       def module_name
-        @module_name ||= module_metadata.data['name'].rpartition('-').last
+        require 'pdk/util'
+
+        @module_name ||= PDK::Util.module_metadata['name'].rpartition('-').last
+      rescue ArgumentError => e
+        raise PDK::CLI::FatalError, e
       end
 
-      # Parses the metadata.json file for the module.
-      #
-      # @raise [PDK::CLI::FatalError] if the metadata.json file does not exist,
-      #   can not be read, or contains invalid metadata.
-      #
-      # @return [PDK::Module::Metadata] the parsed module metadata.
-      #
-      # @api private
-      def module_metadata
-        @module_metadata ||= begin
-          PDK::Module::Metadata.from_file(File.join(module_dir, 'metadata.json'))
-        rescue ArgumentError => e
-          raise PDK::CLI::FatalError, _("'%{dir}' does not contain valid Puppet module metadata: %{msg}") % { dir: module_dir, msg: e.message }
-        end
+      # transform a object name into a ruby class name
+      def self.class_name_from_object_name(object_name)
+        object_name.to_s.split('_').map(&:capitalize).join
       end
     end
   end

data/lib/pdk/generate/transport.rb

@@ -0,0 +1,87 @@
+require 'pdk/generate/puppet_object'
+
+module PDK
+  module Generate
+    class Transport < PuppetObject
+      OBJECT_TYPE = :transport
+
+      # Prepares the data needed to render the new defined type template.
+      #
+      # @return [Hash{Symbol => Object}] a hash of information that will be
+      # provided to the defined type and defined type spec templates during
+      # rendering.
+      def template_data
+        data = {
+          name: object_name,
+          transport_class: Transport.class_name_from_object_name(object_name),
+        }
+
+        data
+      end
+
+      def raise_precondition_error(error)
+        raise PDK::CLI::ExitWithError, _('%{error}: Creating a transport needs some local configuration in your module.' \
+          ' Please follow the docs at https://github.com/puppetlabs/puppet-resource_api#getting-started.') % { error: error }
+      end
+
+      def check_preconditions
+        super
+        # These preconditions can be removed once the pdk-templates are carrying the puppet-resource_api gem by default, and have switched
+        # the default mock_with value.
+        sync_path = PDK::Util.find_upwards('.sync.yml')
+        if sync_path.nil?
+          raise_precondition_error(_('.sync.yml not found'))
+        end
+        sync = YAML.load_file(sync_path)
+        if !sync.is_a? Hash
+          raise_precondition_error(_('.sync.yml contents is not a Hash'))
+        elsif !sync.key? 'Gemfile'
+          raise_precondition_error(_('Gemfile configuration not found'))
+        elsif !sync['Gemfile'].key? 'optional'
+          raise_precondition_error(_('Gemfile.optional configuration not found'))
+        elsif !sync['Gemfile']['optional'].key? ':development'
+          raise_precondition_error(_('Gemfile.optional.:development configuration not found'))
+        elsif sync['Gemfile']['optional'][':development'].none? { |g| g['gem'] == 'puppet-resource_api' }
+          raise_precondition_error(_('puppet-resource_api not found in the Gemfile config'))
+        elsif !sync.key? 'spec/spec_helper.rb'
+          raise_precondition_error(_('spec/spec_helper.rb configuration not found'))
+        elsif !sync['spec/spec_helper.rb'].key? 'mock_with'
+          raise_precondition_error(_('spec/spec_helper.rb.mock_with configuration not found'))
+        elsif !sync['spec/spec_helper.rb']['mock_with'] == ':rspec'
+          raise_precondition_error(_('spec/spec_helper.rb.mock_with not set to \':rspec\''))
+        end
+      end
+
+      # @return [String] the path where the new transport will be written.
+      def target_object_path
+        @target_object_path ||= File.join(module_dir, 'lib', 'puppet', 'transport', object_name) + '.rb'
+      end
+
+      # @return [String] the path where the new schema will be written.
+      def target_type_path
+        @target_type_path ||= File.join(module_dir, 'lib', 'puppet', 'transport', 'schema', object_name) + '.rb'
+      end
+
+      # @return [String] the path where the deviceshim for the transport will be written.
+      def target_device_path
+        @target_device_path ||= File.join(module_dir, 'lib', 'puppet', 'util', 'network_device', object_name, 'device.rb')
+      end
+
+      # @return [String] the path where the tests for the new transport
+      # will be written.
+      def target_spec_path
+        @target_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'transport', object_name) + '_spec.rb'
+      end
+
+      # @return [String] the path where the tests for the new schema will be written.
+      def target_type_spec_path
+        @target_type_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'transport', 'schema', object_name) + '_spec.rb'
+      end
+
+      # transform a object name into a ruby class name
+      def self.class_name_from_object_name(object_name)
+        object_name.to_s.split('_').map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/pdk/logger.rb

@@ -6,17 +6,37 @@ module PDK
   end
 
   class Logger < ::Logger
+    WRAP_COLUMN_LIMIT = 78
+
     def initialize
       super(STDERR)
+      @sent_messages = {}
 
       # TODO: Decide on output format.
       self.formatter = proc do |severity, _datetime, _progname, msg|
-        "pdk (#{severity}): #{msg}\n"
+        prefix = "pdk (#{severity}): "
+        if msg.is_a?(Hash)
+          if msg.fetch(:wrap, false)
+            wrap_pattern = %r{(.{1,#{WRAP_COLUMN_LIMIT - prefix.length}})(\s+|\Z)}
+            "#{prefix}#{msg[:text].gsub(wrap_pattern, "\\1\n#{' ' * prefix.length}")}\n"
+          else
+            "#{prefix}#{msg[:text]}\n"
+          end
+        else
+          "#{prefix}#{msg}\n"
+        end
       end
 
       self.level = ::Logger::INFO
     end
 
+    def warn_once(*args)
+      hash = args.inspect.hash
+      return if (@sent_messages[::Logger::WARN] ||= {}).key?(hash)
+      @sent_messages[::Logger::WARN][hash] = true
+      warn(*args)
+    end
+
     def enable_debug_output
       self.level = ::Logger::DEBUG
     end

data/lib/pdk/module.rb

@@ -1,5 +1,3 @@
-require 'pathspec'
-
 module PDK
   module Module
     DEFAULT_IGNORED = [
@@ -13,6 +11,8 @@ module PDK
     ].freeze
 
     def default_ignored_pathspec(ignore_dotfiles = true)
+      require 'pathspec'
+
       PathSpec.new(DEFAULT_IGNORED).tap do |ps|
         ps.add('.*') if ignore_dotfiles
       end

data/lib/pdk/module/build.rb

@@ -1,11 +1,3 @@
-require 'fileutils'
-require 'minitar'
-require 'zlib'
-require 'pathspec'
-require 'find'
-require 'pdk/module'
-require 'pdk/tests/unit'
-
 module PDK
   module Module
     class Build
@@ -26,6 +18,8 @@ module PDK
       #
       # @return [Hash{String => Object}] The hash of metadata values.
       def metadata
+        require 'pdk/module/metadata'
+
         @metadata ||= PDK::Module::Metadata.from_file(File.join(module_dir, 'metadata.json')).data
       end
 
@@ -71,6 +65,8 @@ module PDK
       #
       # If the directory already exists, remove it first.
       def create_build_dir
+        require 'fileutils'
+
         cleanup_build_dir
 
         FileUtils.mkdir_p(build_dir)
@@ -80,6 +76,8 @@ module PDK
       #
       # @return nil.
       def cleanup_build_dir
+        require 'fileutils'
+
         FileUtils.rm_rf(build_dir, secure: true)
       end
 
@@ -99,6 +97,8 @@ module PDK
       #
       # @return nil
       def stage_module_in_build_dir
+        require 'find'
+
         Find.find(module_dir) do |path|
           next if path == module_dir
 
@@ -112,6 +112,9 @@ module PDK
       #
       # @return nil.
       def stage_path(path)
+        require 'pathname'
+        require 'fileutils'
+
         relative_path = Pathname.new(path).relative_path_from(Pathname.new(module_dir))
         dest_path = File.join(build_dir, relative_path)
 
@@ -120,8 +123,14 @@ module PDK
         elsif File.symlink?(path)
           warn_symlink(path)
         else
+          validate_ustar_path!(relative_path.to_path)
           FileUtils.cp(path, dest_path, preserve: true)
         end
+      rescue ArgumentError => e
+        raise PDK::CLI::ExitWithError, _(
+          '%{message} Rename the file or exclude it from the package ' \
+          'by adding it to the .pdkignore file in your module.',
+        ) % { message: e.message }
       end
 
       # Check if the given path matches one of the patterns listed in the
@@ -143,6 +152,8 @@ module PDK
       #
       # @return nil.
       def warn_symlink(path)
+        require 'pathname'
+
         symlink_path = Pathname.new(path)
         module_path = Pathname.new(module_dir)
 
@@ -152,6 +163,58 @@ module PDK
         }
       end
 
+      # Checks if the path length will fit into the POSIX.1-1998 (ustar) tar
+      # header format.
+      #
+      # POSIX.1-2001 (which allows paths of infinite length) was adopted by GNU
+      # tar in 2004 and is supported by minitar 0.7 and above. Unfortunately
+      # much of the Puppet ecosystem still uses minitar 0.6.1.
+      #
+      # POSIX.1-1998 tar format does not allow for paths greater than 256 bytes,
+      # or paths that can't be split into a prefix of 155 bytes (max) and
+      # a suffix of 100 bytes (max).
+      #
+      # This logic was pretty much copied from the private method
+      # {Archive::Tar::Minitar::Writer#split_name}.
+      #
+      # @param path [String] the relative path to be added to the tar file.
+      #
+      # @raise [ArgumentError] if the path is too long or could not be split.
+      #
+      # @return [nil]
+      def validate_ustar_path!(path)
+        if path.bytesize > 256
+          raise ArgumentError, _("The path '%{path}' is longer than 256 bytes.") % {
+            path: path,
+          }
+        end
+
+        if path.bytesize <= 100
+          prefix = ''
+        else
+          parts = path.split(File::SEPARATOR)
+          newpath = parts.pop
+          nxt = ''
+
+          loop do
+            nxt = parts.pop || ''
+            break if newpath.bytesize + 1 + nxt.bytesize >= 100
+            newpath = File.join(nxt, newpath)
+          end
+
+          prefix = File.join(*parts, nxt)
+          path = newpath
+        end
+
+        return unless path.bytesize > 100 || prefix.bytesize > 155
+
+        raise ArgumentError, _(
+          "'%{path}' could not be split at a directory separator into two " \
+          'parts, the first having a maximum length of 155 bytes and the ' \
+          'second having a maximum length of 100 bytes.',
+        ) % { path: path }
+      end
+
       # Creates a gzip compressed tarball of the build directory.
       #
       # If the destination package already exists, it will be removed before
@@ -159,11 +222,38 @@ module PDK
       #
       # @return nil.
       def build_package
+        require 'fileutils'
+        require 'zlib'
+        require 'minitar'
+        require 'find'
+
         FileUtils.rm_f(package_file)
 
         Dir.chdir(target_dir) do
-          Zlib::GzipWriter.open(package_file) do |package_fd|
-            Minitar.pack(release_name, package_fd)
+          begin
+            gz = Zlib::GzipWriter.new(File.open(package_file, 'wb'))
+            tar = Minitar::Output.new(gz)
+            Find.find(release_name) do |entry|
+              entry_meta = {
+                name: entry,
+              }
+
+              orig_mode = File.stat(entry).mode
+              min_mode = Minitar.dir?(entry) ? 0o755 : 0o644
+
+              entry_meta[:mode] = orig_mode | min_mode
+
+              if entry_meta[:mode] != orig_mode
+                PDK.logger.debug(_('Updated permissions of packaged \'%{entry}\' to %{new_mode}') % {
+                  entry: entry,
+                  new_mode: (entry_meta[:mode] & 0o7777).to_s(8),
+                })
+              end
+
+              Minitar.pack_file(entry_meta, tar)
+            end
+          ensure
+            tar.close
           end
         end
       end
@@ -188,6 +278,9 @@ module PDK
       #
       # @return [PathSpec] The populated ignore path matcher.
       def ignored_files
+        require 'pdk/module'
+        require 'pathspec'
+
         @ignored_files ||=
           begin
             ignored = if ignore_file.nil?