pdk-akerl 1.9.1.1 → 1.14.0.1

data/lib/pdk/util/ruby_version.rb

@@ -1,4 +1,4 @@
-require 'pdk/util'
+require 'forwardable'
 
 module PDK
   module Util
@@ -8,6 +8,8 @@ module PDK
 
         def_delegators :instance, :gem_path, :gem_paths_raw, :gem_home, :available_puppet_versions, :bin_path
 
+        # TODO: resolve this
+        # rubocop:disable Lint/DuplicateMethods
         attr_reader :instance
 
         def instance(version = nil)
@@ -21,6 +23,7 @@ module PDK
           end
           @instance[active_ruby_version]
         end
+        # rubocop:enable Lint/DuplicateMethods
 
         def active_ruby_version
           @active_ruby_version || default_ruby_version
@@ -37,6 +40,8 @@ module PDK
         end
 
         def scan_for_packaged_rubies
+          require 'pdk/util'
+
           ruby_basedir = File.join(PDK::Util.pdk_package_basedir, 'private', 'ruby', '*')
           Dir[ruby_basedir].sort.map { |ruby_dir|
             version = File.basename(ruby_dir)
@@ -45,12 +50,22 @@ module PDK
         end
 
         def default_ruby_version
-          # For now, the packaged versions will be using default of 2.4.5
-          # FIXME: make this dynamic
-          return '2.4.5' if PDK::Util.package_install?
-
-          # TODO: may not be a safe assumption that highest available version should be default
-          latest_ruby_version
+          require 'pdk/util'
+          require 'pdk/util/puppet_version'
+
+          @default_ruby_version ||= if PDK::Util.package_install?
+                                      # Default to the ruby that supports the latest puppet gem. If you wish to default to a
+                                      # specific Puppet Gem version use the following example;
+                                      #
+                                      # PDK::Util::PuppetVersion.find_gem_for('5.5.10')[:ruby_version]
+                                      #
+                                      PDK::Util::PuppetVersion.latest_available[:ruby_version]
+                                    else
+                                      # TODO: may not be a safe assumption that highest available version should be default
+                                      # WARNING Do NOT use PDK::Util::PuppetVersion.*** methods as it can recurse into this
+                                      # method and cause Stack Level Too Deep errors.
+                                      latest_ruby_version
+                                    end
         end
 
         def latest_ruby_version
@@ -58,6 +73,8 @@ module PDK
         end
 
         def versions
+          require 'pdk/util'
+
           @versions ||= if PDK::Util.package_install?
                           scan_for_packaged_rubies
                         else
@@ -73,6 +90,8 @@ module PDK
       end
 
       def bin_path
+        require 'pdk/util'
+
         if PDK::Util.package_install?
           File.join(PDK::Util.pdk_package_basedir, 'private', 'ruby', ruby_version, 'bin')
         else
@@ -81,6 +100,8 @@ module PDK
       end
 
       def gem_paths_raw
+        require 'pdk/util'
+
         if PDK::Util.package_install?
           # Subprocesses use their own set of gems which are managed by pdk or
           # installed with the package. We also include the separate gem path
@@ -104,6 +125,8 @@ module PDK
       end
 
       def gem_home
+        require 'pdk/util'
+
         # `bundle install --path` ignores all "system" installed gems and
         # causes unnecessary package installs. `bundle install` (without
         # --path) installs into GEM_HOME, which by default is non-user

data/lib/pdk/util/template_uri.rb

@@ -0,0 +1,281 @@
+module PDK
+  module Util
+    class TemplateURI
+      SCP_PATTERN = %r{\A(?!\w+://)(?:(?<user>.+?)@)?(?<host>[^:/]+):(?<path>.+)\z}
+
+      PACKAGED_TEMPLATE_KEYWORD = 'pdk-default'.freeze
+      DEPRECATED_TEMPLATE_URL = 'https://github.com/puppetlabs/pdk-module-template'.freeze
+
+      LEGACY_PACKAGED_TEMPLATE_PATHS = {
+        'windows' => 'file:///C:/Program Files/Puppet Labs/DevelopmentKit/share/cache/pdk-templates.git',
+        'macos'   => 'file:///opt/puppetlabs/pdk/share/cache/pdk-templates.git',
+        'linux'   => 'file:///opt/puppetlabs/pdk/share/cache/pdk-templates.git',
+      }.freeze
+
+      # XXX Previously
+      # - template_uri used to get the string form of the uri when generating the module and written to pdk answers and metadata
+      # - template_path or deuri_path used for humans to see and commands to run
+      # - uri_path used only internally by the template selection code; move out
+      # - template_ref used by git checkout
+      attr_reader :uri
+
+      # input/output formats:
+      #
+      # file:///c:/foo (git clone location)
+      # c:/foo (shell paths)
+      # file:///c:/foo#master (only for metadata)
+      # c:/foo#master (only for metadata)
+      #
+      # non output formats:
+      #
+      # /c:/foo (internal use only)
+      # /c:/foo#master (internal use only)
+      #
+      def initialize(opts_or_uri)
+        require 'addressable'
+
+        # If a uri string is passed, skip the valid uri finding code.
+        @uri = if opts_or_uri.is_a?(self.class)
+                 opts_or_uri.uri
+               elsif opts_or_uri.is_a?(String)
+                 begin
+                   uri, ref = opts_or_uri.split('#', 2)
+                   if self.class.packaged_template?(uri)
+                     self.class.default_template_uri(ref).uri
+                   else
+                     Addressable::URI.parse(opts_or_uri)
+                   end
+                 rescue Addressable::URI::InvalidURIError
+                   raise PDK::CLI::FatalError, _('PDK::Util::TemplateURI attempted initialization with a non-uri string: {string}') % { string: opts_or_uri }
+                 end
+               elsif opts_or_uri.is_a?(Addressable::URI)
+                 opts_or_uri.dup
+               else
+                 self.class.first_valid_uri(self.class.templates(opts_or_uri))
+               end
+      end
+
+      def ==(other)
+        @uri == other.uri
+      end
+
+      # This is the URI represented in a format suitable for writing to
+      # metadata.
+      #
+      # @returns String
+      def metadata_format
+        if self.class.packaged_template?(git_remote)
+          self.class.human_readable("pdk-default##{git_ref}")
+        else
+          self.class.human_readable(@uri.to_s)
+        end
+      end
+      alias to_s metadata_format
+      alias to_str metadata_format
+
+      # This is the url without a fragment, suitable for git clones.
+      #
+      # @returns String
+      def git_remote
+        self.class.git_remote(@uri)
+      end
+
+      def self.git_remote(uri)
+        require 'addressable'
+
+        if uri.is_a?(Addressable::URI) && uri.fragment
+          human_readable(uri.to_s.chomp('#' + uri.fragment))
+        else
+          human_readable(uri.to_s)
+        end
+      end
+
+      # This is the path of the URI, suitable for accessing directly from the shell.
+      # @returns String
+      def shell_path
+        self.class.human_readable(@uri.path)
+      end
+
+      # @returns String
+      def git_ref
+        @uri.fragment || self.class.default_template_ref(self)
+      end
+
+      def git_ref=(ref)
+        @uri.fragment = ref
+      end
+
+      # @returns PDK::Util::TemplateURI
+      def self.default_template_uri(ref = nil)
+        require 'pdk/util'
+        require 'addressable'
+
+        if PDK::Util.package_install?
+          PDK::Util::TemplateURI.new(Addressable::URI.new(scheme: 'file', host: '', path: File.join(PDK::Util.package_cachedir, 'pdk-templates.git'), fragment: ref))
+        else
+          PDK::Util::TemplateURI.new(Addressable::URI.new(scheme: 'https', host: 'github.com', path: '/puppetlabs/pdk-templates', fragment: ref))
+        end
+      end
+
+      def default?
+        git_remote == self.class.default_template_uri.git_remote
+      end
+
+      def ref_is_tag?
+        require 'pdk/util/git'
+
+        PDK::Util::Git.git('ls-remote', '--tags', '--exit-code', git_remote, git_ref)[:exit_code].zero?
+      end
+
+      # `C:...` urls are not URI-safe. They should be of the form `/C:...` to
+      # be URI-safe. scp-like urls like `user@host:/path` are not URI-safe
+      # either and so are subsequently converted to ssh:// URIs.
+      #
+      # @returns String
+      def self.uri_safe(string)
+        url = (Gem.win_platform? && string =~ %r{^[a-zA-Z][\|:]}) ? "/#{string}" : string
+        parse_scp_url(url)
+      end
+
+      # If the passed value is a URI-safe windows path such as `/C:...` then it
+      # should be changed to a human-friendly `C:...` form. Otherwise the
+      # passed value is left alone.
+      #
+      # @returns String
+      def self.human_readable(string)
+        (Gem.win_platform? && string =~ %r{^\/[a-zA-Z][\|:]}) ? string[1..-1] : string
+      end
+
+      def self.parse_scp_url(url)
+        require 'pathname'
+        require 'addressable'
+
+        # Valid URIs to avoid catching:
+        # - absolute local paths
+        # - have :'s in paths when preceeded by a slash
+        # - have only digits following the : and preceeding a / or end-of-string that is 0-65535
+        # The last item is ambiguous in the case of scp/git paths vs. URI port
+        # numbers, but can be made unambiguous by making the form to
+        # ssh://git@github.com/1234/repo.git or
+        # ssh://git@github.com:1234/user/repo.git
+        scp_url = url.match(SCP_PATTERN)
+        return url unless Pathname.new(url).relative? && scp_url
+
+        uri = Addressable::URI.new(scheme: 'ssh', user: scp_url[:user], host: scp_url[:host], path: scp_url[:path])
+        PDK.logger.warn _('%{scp_uri} appears to be an SCP style URL; it will be converted to an RFC compliant URI: %{rfc_uri}') % {
+          scp_uri: url,
+          rfc_uri: uri.to_s,
+        }
+
+        uri.to_s
+      end
+
+      # @return [Array<Hash{Symbol => Object}>] an array of hashes. Each hash
+      #   contains 3 keys: :type contains a String that describes the template
+      #   directory, :url contains a String with the URL to the template
+      #   directory, and :allow_fallback contains a Boolean that specifies if
+      #   the lookup process should proceed to the next template directory if
+      #   the template file is not in this template directory.
+      #
+      def self.templates(opts)
+        require 'pdk/answer_file'
+        require 'pdk/util'
+        require 'addressable'
+
+        explicit_url = opts.fetch(:'template-url', nil)
+        explicit_ref = opts.fetch(:'template-ref', nil)
+
+        # 1. Get the CLI, metadata (or answers if no metadata), and default URIs
+        # 2. Construct the hash
+        if explicit_url
+          explicit_uri = Addressable::URI.parse(uri_safe(explicit_url))
+          explicit_uri.fragment = explicit_ref || default_template_ref(new(explicit_uri))
+        else
+          explicit_uri = nil
+        end
+        metadata_uri = if PDK::Util.module_root && File.file?(File.join(PDK::Util.module_root, 'metadata.json'))
+                         if PDK::Util.module_metadata['template-url']
+                           new(uri_safe(PDK::Util.module_metadata['template-url'])).uri
+                         else
+                           nil
+                         end
+                       else
+                         nil
+                       end
+        answers_uri = if [PACKAGED_TEMPLATE_KEYWORD, DEPRECATED_TEMPLATE_URL].include?(PDK.answers['template-url'])
+                        Addressable::URI.parse(default_template_uri)
+                      elsif PDK.answers['template-url']
+                        new(uri_safe(PDK.answers['template-url'])).uri
+                      else
+                        nil
+                      end
+        default_uri = default_template_uri.uri
+        default_uri.fragment = default_template_ref(default_template_uri)
+
+        ary = []
+        ary << { type: _('--template-url'), uri: explicit_uri, allow_fallback: false } if explicit_url
+        ary << { type: _('metadata.json'), uri: metadata_uri, allow_fallback: true } if metadata_uri
+        ary << { type: _('PDK answers'), uri: answers_uri, allow_fallback: true } if answers_uri
+        ary << { type: _('default'), uri: default_uri, allow_fallback: false }
+        ary
+      end
+
+      # @returns String
+      def self.default_template_ref(uri = nil)
+        require 'pdk/util'
+        require 'pdk/version'
+
+        return 'master' if PDK::Util.development_mode?
+        return PDK::TEMPLATE_REF if uri.nil?
+
+        uri = new(uri) unless uri.is_a?(self)
+        uri.default? ? PDK::TEMPLATE_REF : 'master'
+      end
+
+      # @returns Addressable::URI
+      def self.first_valid_uri(templates_array)
+        # 1. Get the four sources of URIs
+        # 2. Pick the first non-nil URI
+        # 3. Error if the URI is not a valid git repo (missing directory or http 404)
+        # 4. Leave updating answers/metadata to other code
+        found_template = templates_array.find { |t| valid_template?(t) }
+
+        raise PDK::CLI::FatalError, _('Unable to find a valid module template to use.') if found_template.nil?
+        found_template[:uri]
+      end
+
+      def self.valid_template?(template)
+        require 'addressable'
+        require 'pdk/util/git'
+        require 'pdk/module/templatedir'
+
+        return false if template.nil? || !template.is_a?(Hash)
+        return false if template[:uri].nil? || !template[:uri].is_a?(Addressable::URI)
+
+        return true if PDK::Util::Git.repo?(git_remote(template[:uri]))
+
+        path = human_readable(template[:uri].path)
+        if File.directory?(path)
+          begin
+            PDK::Module::TemplateDir.new(path) {}
+            return true
+          rescue ArgumentError
+            nil
+          end
+        end
+
+        unless template[:allow_fallback]
+          raise PDK::CLI::FatalError, _('Unable to find a valid template at %{uri}') % {
+            uri: template[:uri].to_s,
+          }
+        end
+
+        false
+      end
+
+      def self.packaged_template?(path)
+        path == PACKAGED_TEMPLATE_KEYWORD || LEGACY_PACKAGED_TEMPLATE_PATHS.value?(path)
+      end
+    end
+  end
+end

data/lib/pdk/util/vendored_file.rb

@@ -1,51 +1,50 @@
-require 'pdk/util'
-require 'net/https'
-require 'openssl'
-require 'fileutils'
-require 'pdk/util/filesystem'
-
 module PDK
   module Util
     class VendoredFile
       class DownloadError < StandardError; end
 
-      HTTP_ERRORS = [
-        EOFError,
-        Errno::ECONNRESET,
-        Errno::EINVAL,
-        Errno::ECONNREFUSED,
-        Net::HTTPBadResponse,
-        Net::HTTPHeaderSyntaxError,
-        Net::ProtocolError,
-        Timeout::Error,
-      ].freeze
-
       attr_reader :file_name
       attr_reader :url
 
-      include PDK::Util::Filesystem
-
       def initialize(file_name, url)
         @file_name = file_name
         @url = url
       end
 
       def read
-        return File.read(package_vendored_path) if PDK::Util.package_install?
-        return File.read(gem_vendored_path) if File.file?(gem_vendored_path)
+        require 'pdk/util'
+        require 'pdk/util/filesystem'
+
+        return PDK::Util::Filesystem.read_file(package_vendored_path) if PDK::Util.package_install?
+        return PDK::Util::Filesystem.read_file(gem_vendored_path) if PDK::Util::Filesystem.file?(gem_vendored_path)
 
         content = download_file
 
         # TODO: should only write if it's valid JSON
         # TODO: need a way to invalidate if out of date
-        FileUtils.mkdir_p(File.dirname(gem_vendored_path))
-        write_file(gem_vendored_path, content)
+        PDK::Util::Filesystem.mkdir_p(File.dirname(gem_vendored_path))
+        PDK::Util::Filesystem.write_file(gem_vendored_path, content)
         content
       end
 
       private
 
       def download_file
+        require 'uri'
+        require 'net/https'
+        require 'openssl'
+
+        http_errors = [
+          EOFError,
+          Errno::ECONNRESET,
+          Errno::EINVAL,
+          Errno::ECONNREFUSED,
+          Net::HTTPBadResponse,
+          Net::HTTPHeaderSyntaxError,
+          Net::ProtocolError,
+          Timeout::Error,
+        ]
+
         PDK.logger.debug _('%{file_name} was not found in the cache, downloading it from %{url}.') % {
           file_name: file_name,
           url:       url,
@@ -69,7 +68,7 @@ module PDK
         end
 
         response.body
-      rescue *HTTP_ERRORS => e
+      rescue *http_errors => e
         raise DownloadError, _('Unable to download %{url}. Check internet connectivity and try again. %{error}') % {
           url: url,
           error: e,
@@ -77,10 +76,15 @@ module PDK
       end
 
       def package_vendored_path
+        require 'pdk/util'
+
         @package_vendored_path ||= File.join(PDK::Util.package_cachedir, file_name)
       end
 
       def gem_vendored_path
+        require 'pdk/util'
+        require 'pdk/version'
+
         @gem_vendored_path ||= File.join(PDK::Util.cachedir, PDK::VERSION, file_name)
       end
     end