pdk 1.14.1 → 1.18.1

data/lib/pdk/module/metadata.rb

@@ -5,8 +5,6 @@ module PDK
     class Metadata
       attr_accessor :data
 
-      include PDK::Util::Filesystem
-
       OPERATING_SYSTEMS = {
         'RedHat based Linux' => [
           {
@@ -127,7 +125,7 @@ module PDK
       end
 
       def write!(path)
-        write_file(path, to_json)
+        PDK::Util::Filesystem.write_file(path, to_json)
       end
 
       def forge_ready?

data/lib/pdk/module/release.rb

@@ -0,0 +1,254 @@
+require 'pdk'
+
+module PDK
+  module Module
+    class Release
+      def self.invoke(module_path, options = {})
+        new(module_path, options).run
+      end
+
+      attr_reader :options
+
+      attr_reader :module_path
+
+      def initialize(module_path, options = {})
+        @options = options
+
+        # TODO: Currently the release process can ONLY be run if the working directory IS the module root. However, in the future
+        # this WILL change, so we have the API arguments for it, but only accept `nil` for the first parameter
+        raise PDK::CLI::ExitWithError, _('Running the release process outside of the working directory is not supported') unless module_path.nil?
+
+        if module_path.nil?
+          module_path = PDK::Util.module_root
+          raise PDK::CLI::ExitWithError, _('The module release process requires a valid module path') % { module_path: module_path } if module_path.nil?
+        end
+        raise PDK::CLI::ExitWithError, _('%{module_path} is not a valid module') % { module_path: module_path } unless PDK::Util.in_module_root?(module_path)
+        @module_path = module_path
+      end
+
+      def run
+        # Pre-release checks
+        unless force?
+          raise PDK::CLI::ExitWithError, _('The module is not PDK compatible') if requires_pdk_compatibility? && !pdk_compatible?
+          raise PDK::CLI::ExitWithError, _('The module is not Forge compatible') if requires_forge_compatibility? && !forge_compatible?
+        end
+
+        # Note that these checks are duplicated in the run_publish method, however it's a much better
+        # experience to fail early, than going through the whole process, only to error at the end knowing full well
+        # it'll fail anyway.
+        validate_publish_options!
+
+        run_validations(options) unless skip_validation?
+
+        PDK.logger.info _('Releasing %{module_name} - from version %{module_version}') % {
+          module_name:    module_metadata.data['name'],
+          module_version: module_metadata.data['version'],
+        }
+
+        PDK::Util::ChangelogGenerator.generate_changelog unless skip_changelog?
+
+        # Calculate the new module version
+        new_version = specified_version
+        if new_version.nil? && !skip_changelog?
+          new_version = PDK::Util::ChangelogGenerator.compute_next_version(module_metadata.data['version'])
+        end
+        new_version = module_metadata.data['version'] if new_version.nil?
+
+        if new_version != module_metadata.data['version']
+          PDK.logger.info _('Updating version to %{module_version}') % {
+            module_version: new_version,
+          }
+
+          # Set the new version in metadata file
+          module_metadata.data['version'] = new_version
+          write_module_metadata!
+
+          # Update the changelog with the correct version
+          PDK::Util::ChangelogGenerator.generate_changelog unless skip_changelog?
+        end
+
+        run_documentation(options) unless skip_documentation?
+
+        run_dependency_checker(options) unless skip_dependency?
+
+        if skip_build?
+          # Even if we're skipping the build, we still need the name of the tarball
+          # Use the specified package path if set
+          package_file = specified_package if package_file.nil?
+          # Use the default as a last resort
+          package_file = default_package_filename if package_file.nil?
+        else
+          package_file = run_build(options)
+        end
+
+        run_publish(options.dup, package_file) unless skip_publish?
+      end
+
+      def module_metadata
+        @module_metada ||= PDK::Module::Metadata.from_file(File.join(module_path, 'metadata.json'))
+      end
+
+      def write_module_metadata!
+        module_metadata.write!(File.join(module_path, 'metadata.json'))
+        clear_cached_data
+      end
+
+      def default_package_filename
+        return @default_tarball_filename unless @default_tarball_filename.nil?
+        builder = PDK::Module::Build.new(module_dir: module_path)
+        @default_tarball_filename = builder.package_file
+      end
+
+      def run_validations(opts)
+        # TODO: Surely I can use a pre-existing class for this?
+        PDK::CLI::Util.validate_puppet_version_opts(opts)
+
+        PDK::CLI::Util.module_version_check
+
+        puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
+        PDK::Util::PuppetVersion.fetch_puppet_dev if opts[:'puppet-dev']
+        PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
+
+        PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
+
+        validator_exit_code, = PDK::Validate.invoke_validators_by_name(PDK.context, PDK::Validate.validator_names, false, options)
+        raise PDK::CLI::ExitWithError, _('An error occured during validation') unless validator_exit_code.zero?
+      end
+
+      def run_documentation(_opts)
+        PDK.logger.info _('Updating documentation using puppet strings')
+        docs_command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, 'exec', 'puppet', 'strings', 'generate', '--format', 'markdown', '--out', 'REFERENCE.md')
+        docs_command.context = :module
+        result = docs_command.execute!
+        raise PDK::CLI::ExitWithError, _('An error occured generating the module documentation: %{stdout}') % { stdout: result[:stdout] } unless result[:exit_code].zero?
+      end
+
+      def run_dependency_checker(_opts)
+        # run dependency-checker and output dependent modules list
+        PDK.logger.info _('Running dependency checks')
+
+        dep_command = PDK::CLI::Exec::Command.new('dependency-checker', 'metadata.json')
+        dep_command.context = :module
+        result = dep_command.execute!
+
+        raise PDK::CLI::ExitWithError, _('An error occured checking the module dependencies: %{stdout}') % { stdout: result[:stdout] } unless result[:exit_code].zero?
+      end
+
+      # @return [String] Path to the built tarball
+      def run_build(opts)
+        PDK::Module::Build.invoke(opts.dup)
+      end
+
+      def run_publish(_opts, tarball_path)
+        validate_publish_options!
+        raise PDK::CLI::ExitWithError, _('Module tarball %{tarball_path} does not exist') % { tarball_path: tarball_path } unless PDK::Util::Filesystem.file?(tarball_path)
+
+        # TODO: Replace this code when the upload functionality is added to the forge ruby gem
+        require 'base64'
+        file_data = Base64.encode64(PDK::Util::Filesystem.read_file(tarball_path, open_args: 'rb'))
+
+        PDK.logger.info _('Uploading tarball to puppet forge...')
+        uri = URI(forge_upload_url)
+        require 'net/http'
+        request = Net::HTTP::Post.new(uri.path)
+        request['Authorization'] = 'Bearer ' + forge_token
+        request['Content-Type'] = 'application/json'
+        data = { file: file_data }
+
+        request.body = data.to_json
+
+        require 'openssl'
+        use_ssl = uri.class == URI::HTTPS
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http|
+          http.request(request)
+        end
+
+        raise PDK::CLI::ExitWithError, _('Error uploading to Puppet Forge: %{result}') % { result: response } unless response.is_a?(Net::HTTPSuccess)
+        PDK.logger.info _('Publish to Forge was successful')
+      end
+
+      def validate_publish_options!
+        return if skip_publish?
+        raise PDK::CLI::ExitWithError, _('Missing forge-upload-url option') unless forge_upload_url
+        raise PDK::CLI::ExitWithError, _('Missing forge-token option') unless forge_token
+      end
+
+      def force?
+        options[:force]
+      end
+
+      def skip_build?
+        options[:'skip-build']
+      end
+
+      def skip_changelog?
+        options[:'skip-changelog']
+      end
+
+      def skip_dependency?
+        options[:'skip-dependency']
+      end
+
+      def skip_documentation?
+        options[:'skip-documentation']
+      end
+
+      def skip_publish?
+        options[:'skip-publish']
+      end
+
+      def skip_validation?
+        options[:'skip-validation']
+      end
+
+      def specified_version
+        options[:version]
+      end
+
+      def specified_package
+        options[:file]
+      end
+
+      def forge_token
+        options[:'forge-token']
+      end
+
+      def forge_upload_url
+        options[:'forge-upload-url']
+      end
+
+      def requires_pdk_compatibility?
+        # Validation, Changelog and Dependency checks require the
+        # module to be PDK Compatible
+        !(skip_validation? && skip_changelog? && skip_dependency?)
+      end
+
+      def requires_forge_compatibility?
+        # Pushing to the for requires the metadata to be forge compatible
+        !skip_publish?
+      end
+
+      #:nocov:
+      # These are just convenience methods and are tested elsewhere
+      def forge_compatible?
+        module_metadata.forge_ready?
+      end
+
+      def pdk_compatible?
+        return @pdk_compatible unless @pdk_compatible.nil?
+
+        builder = PDK::Module::Build.new(module_dir: module_path)
+        @pdk_compatible = builder.module_pdk_compatible?
+      end
+      #:nocov:
+
+      private
+
+      def clear_cached_data
+        @module_metadata = nil
+        @pdk_compatible = nil
+        @default_tarball_filename = nil
+      end
+    end
+  end
+end

data/lib/pdk/module/update.rb

@@ -6,7 +6,7 @@ module PDK
       GIT_DESCRIBE_PATTERN = %r{\A(?<base>.+?)-(?<additional_commits>\d+)-g(?<sha>.+)\Z}
 
       def run
-        template_uri.git_ref = new_template_version
+        template_uri.uri_fragment = new_template_version
 
         stage_changes!
 
@@ -33,25 +33,21 @@ module PDK
           return unless PDK::CLI::Util.prompt_for_yes(message)
         end
 
-        # Remove these files straight away as these changes are not something that the user needs to review.
-        if needs_bundle_update?
-          update_manager.unlink_file('Gemfile.lock')
-          update_manager.unlink_file(File.join('.bundle', 'config'))
-        end
+        # Remove these files straight away as these changes are not something
+        # that the user needs to review.
+        update_manager.unlink_file('Gemfile.lock')
+        update_manager.unlink_file(File.join('.bundle', 'config'))
 
         update_manager.sync_changes!
 
-        if needs_bundle_update?
-          require 'pdk/util/bundler'
-
-          PDK::Util::Bundler.ensure_bundle!
-        end
+        require 'pdk/util/bundler'
+        PDK::Util::Bundler.ensure_bundle!
 
         print_result 'Update completed'
       end
 
       def module_metadata
-        @module_metadata ||= PDK::Module::Metadata.from_file('metadata.json')
+        @module_metadata ||= PDK::Module::Metadata.from_file(File.join(module_dir, 'metadata.json'))
       rescue ArgumentError => e
         raise PDK::CLI::ExitWithError, e.message
       end
@@ -71,15 +67,27 @@ module PDK
       def new_template_version
         return options[:'template-ref'] if options[:'template-ref']
 
-        if template_uri.default? && template_uri.ref_is_tag? && PDK::Util.package_install?
+        if template_uri.default? && PDK::Util::Git.tag?(template_uri.bare_uri, template_uri.uri_fragment) && PDK::Util.package_install?
           PDK::Util::TemplateURI.default_template_ref
         else
-          template_uri.git_ref
+          template_uri.uri_fragment
         end
       end
 
+      def pinned_to_puppetlabs_template_tag?
+        return false unless template_uri.puppetlabs_template?
+        return false unless PDK::Util::Git.tag?(template_uri.bare_uri, template_uri.uri_fragment)
+        return false if latest_template?
+
+        template_uri.uri_fragment == new_template_version
+      end
+
       private
 
+      def latest_template?
+        [PDK::TEMPLATE_REF, 'master'].include?(template_uri.uri_fragment)
+      end
+
       def current_template_version
         @current_template_version ||= module_metadata.data['template-ref']
       end
@@ -101,7 +109,7 @@ module PDK
         return template_ref if template_ref == PDK::TEMPLATE_REF
 
         sha_length = GIT_DESCRIBE_PATTERN.match(current_template_version)[:sha].length - 1
-        "#{template_ref}@#{PDK::Util::Git.ls_remote(template_uri.git_remote, template_ref)[0..sha_length]}"
+        "#{template_ref}@#{PDK::Util::Git.ls_remote(template_uri.bare_uri, template_ref)[0..sha_length]}"
       end
 
       def update_message
@@ -113,7 +121,7 @@ module PDK
 
         format_string % {
           module_name:     module_metadata.data['name'],
-          template_url:    template_uri.git_remote,
+          template_url:    template_uri.bare_uri,
           current_version: current_version,
           new_version:     new_version,
         }

data/lib/pdk/module/update_manager.rb

@@ -75,6 +75,13 @@ module PDK
           changes[:modified].key?(path)
       end
 
+      def clear!
+        @modified_files.clear
+        @added_files.clear
+        @removed_files.clear
+        nil
+      end
+
       # Apply any pending changes stored in the UpdateManager to the module.
       #
       # @raise (see #calculate_diffs)
@@ -186,7 +193,7 @@ module PDK
 
         require 'diff/lcs/hunk'
 
-        file_mtime = File.stat(path).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+        file_mtime = PDK::Util::Filesystem.stat(path).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
         now = Time.now.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
 
         output << "--- #{path}\t#{file_mtime}"

data/lib/pdk/report.rb

@@ -51,9 +51,6 @@ module PDK
       require 'time'
       require 'socket'
 
-      # Open a File Object for IO if target is a string containing a filename or path
-      target = File.open(target, 'w') if target.is_a? String
-
       document = REXML::Document.new
       document << REXML::XMLDecl.new
       testsuites = REXML::Element.new('testsuites')
@@ -81,9 +78,14 @@ module PDK
       end
 
       document.elements << testsuites
-      document.write(target, 2)
-    ensure
-      target.close if target.is_a? File
+      report = ''
+      document.write(report, 2)
+
+      if target.is_a?(String)
+        PDK::Util::Filesystem.write_file(target, report)
+      else
+        target << report
+      end
     end
 
     # Renders the report as plain text.
@@ -94,22 +96,26 @@ module PDK
     # @param target [#write] an IO object that the report will be written to.
     #   Defaults to PDK::Report.default_target.
     def write_text(target = self.class.default_target)
-      # Open a File Object for IO if target is a string containing a filename or path
-      target = File.open(target, 'w') if target.is_a? String
       coverage_report = nil
+      report = []
 
       events.each do |_tool, tool_events|
         tool_events.each do |event|
           if event.rspec_puppet_coverage?
             coverage_report = event.to_text
           else
-            target.puts(event.to_text) unless event.pass?
+            report << event.to_text unless event.pass?
           end
         end
       end
-    ensure
-      target.puts "\n#{coverage_report}" if coverage_report
-      target.close if target.is_a? File
+
+      report << "\n#{coverage_report}" if coverage_report
+
+      if target.is_a?(String)
+        PDK::Util::Filesystem.write_file(target, report.join("\n"))
+      else
+        target << report.join("\n")
+      end
     end
   end
 end

data/lib/pdk/report/event.rb

@@ -98,7 +98,7 @@ module PDK
       #   results.
       def rspec_puppet_coverage?
         @rspec_puppet_coverage_pattern ||= File.join('**', 'lib', 'rspec-puppet', 'coverage.rb')
-        source == 'rspec' && File.fnmatch?(@rspec_puppet_coverage_pattern, File.expand_path(file))
+        source == 'rspec' && PDK::Util::Filesystem.fnmatch?(@rspec_puppet_coverage_pattern, PDK::Util::Filesystem.expand_path(file))
       end
 
       # Renders the event in a clang style text format.
@@ -346,10 +346,13 @@ module PDK
       def context_lines(max_num_lines = 5)
         return if file.nil? || line.nil?
 
-        file_path = [file, File.join(PDK::Util.module_root, file)].find { |r| File.file?(r) }
+        file_path = [file, File.join(PDK::Util.module_root, file)].find do |path|
+          PDK::Util::Filesystem.file?(path)
+        end
+
         return if file_path.nil?
 
-        file_content = File.read(file_path).split("\n")
+        file_content = PDK::Util::Filesystem.read_file(file_path).split("\n")
         delta = (max_num_lines - 1) / 2
         min = [0, (line - 1) - delta].max
         max = [(line - 1) + delta, file_content.length].min