pdk 1.9.0 → 3.2.0

data/lib/pdk/util/windows/process.rb

@@ -0,0 +1,74 @@
+require 'pdk/util/windows'
+
+module PDK
+  module Util
+    module Windows
+      module Process
+        require 'ffi'
+        extend PDK::Util::Windows::String
+        extend FFI::Library
+
+        def environment_hash
+          env_ptr = GetEnvironmentStringsW()
+
+          contains_unicode_replacement = lambda do |string|
+            return false unless string.include?("\uFFFD")
+
+            PDK.logger.warning "Discarding environment variable #{string} which contains invalid bytes"
+            true
+          end
+
+          # pass :invalid => :replace to the Ruby String#encode to use replacement
+          # characters
+          pairs = env_ptr.read_arbitrary_wide_string_up_to(65_534, :double_null, invalid: :replace)
+                         .split(?\x00)
+                         .reject { |env_str| env_str.nil? || env_str.empty? || env_str[0] == '=' }
+                         .reject { |env_str| contains_unicode_replacement.call(env_str) }
+                         .map { |env_pair| env_pair.split('=', 2) }
+          pairs.to_h
+        ensure
+          PDK.logger.debug 'FreeEnvironmentStringsW memory leak' if env_ptr && !env_ptr.null? && (FreeEnvironmentStringsW(env_ptr) == PDK::Util::Windows::WIN32_FALSE)
+        end
+        module_function :environment_hash
+
+        def set_environment_variable(name, val)
+          raise ArgumentError, 'Environment variable name must not be nil or empty' if name.nil? || name.empty?
+
+          FFI::MemoryPointer.from_string_to_wide_string(name) do |name_ptr|
+            if val.nil?
+              raise format('Failed to remove environment variable: %{name}', name: name) if SetEnvironmentVariableW(name_ptr, FFI::MemoryPointer::NULL) == PDK::Util::Windows::WIN32_FALSE
+            else
+              FFI::MemoryPointer.from_string_to_wide_string(val) do |val_ptr|
+                raise format('Failed to set environment variaible: %{name}', name: name) if SetEnvironmentVariableW(name_ptr, val_ptr) == PDK::Util::Windows::WIN32_FALSE
+              end
+            end
+          end
+        end
+        module_function :set_environment_variable
+
+        ffi_convention :stdcall
+
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683187(v=vs.85).aspx
+        # LPTCH GetEnvironmentStrings(void);
+        ffi_lib :kernel32
+        attach_function_private :GetEnvironmentStringsW, [], :pointer
+
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683151(v=vs.85).aspx
+        # BOOL FreeEnvironmentStrings(
+        #   _In_ LPTCH lpszEnvironmentBlock
+        # );
+        ffi_lib :kernel32
+        attach_function_private :FreeEnvironmentStringsW, [:pointer], :win32_bool
+
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms686206(v=vs.85).aspx
+        # BOOL WINAPI SetEnvironmentVariableW(
+        #   _In_     LPCTSTR lpName,
+        #   _In_opt_ LPCTSTR lpValue
+        # );
+        ffi_lib :kernel32
+        attach_function_private :SetEnvironmentVariableW, [:lpcwstr, :lpcwstr],
+                                :win32_bool
+      end
+    end
+  end
+end

data/lib/pdk/util/windows/string.rb

@@ -1,16 +1,23 @@
 require 'pdk/util/windows'
 
-module PDK::Util::Windows::String
-  def wide_string(str)
-    # if given a nil string, assume caller wants to pass a nil pointer to win32
-    return nil if str.nil?
-    # ruby (< 2.1) does not respect multibyte terminators, so it is possible
-    # for a string to contain a single trailing null byte, followed by garbage
-    # causing buffer overruns.
-    #
-    # See http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?revision=41920&view=revision
-    newstr = str + "\0".encode(str.encoding)
-    newstr.encode!('UTF-16LE')
+module PDK
+  module Util
+    module Windows
+      module String
+        def wide_string(str)
+          # if given a nil string, assume caller wants to pass a nil pointer to win32
+          return if str.nil?
+
+          # ruby (< 2.1) does not respect multibyte terminators, so it is possible
+          # for a string to contain a single trailing null byte, followed by garbage
+          # causing buffer overruns.
+          #
+          # See http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?revision=41920&view=revision
+          newstr = str + "\0".encode(str.encoding)
+          newstr.encode!('UTF-16LE')
+        end
+        module_function :wide_string
+      end
+    end
   end
-  module_function :wide_string
 end

data/lib/pdk/util/windows.rb

@@ -1,12 +1,14 @@
 module PDK
   module Util
     module Windows
+      WIN32_FALSE = 0
       module File; end
 
       if Gem.win_platform?
         require 'pdk/util/windows/api_types'
         require 'pdk/util/windows/string'
         require 'pdk/util/windows/file'
+        require 'pdk/util/windows/process'
       end
     end
   end

data/lib/pdk/util.rb

@@ -1,21 +1,38 @@
-require 'tmpdir'
-require 'tempfile'
+require 'pdk'
 
-require 'pdk/util/version'
+# PDK::Util::Windows can not be lazy loaded because it conditionally requires
+# other files on Windows only. This can probably be fixed up with a later
+# refactoring.
 require 'pdk/util/windows'
-require 'pdk/util/vendored_file'
-require 'pdk/util/filesystem'
+
+autoload :Pathname, 'pathname'
 
 module PDK
   module Util
-    MODULE_FOLDERS = %w[
-      manifests
-      lib
-      tasks
-      facts.d
-      functions
-      types
-    ].freeze
+    autoload :Bundler, 'pdk/util/bundler'
+    autoload :ChangelogGenerator, 'pdk/util/changelog_generator'
+    autoload :Env, 'pdk/util/env'
+    autoload :Filesystem, 'pdk/util/filesystem'
+    autoload :Git, 'pdk/util/git'
+    autoload :JSONFinder, 'pdk/util/json_finder'
+    autoload :PuppetStrings, 'pdk/util/puppet_strings'
+    autoload :PuppetVersion, 'pdk/util/puppet_version'
+    autoload :RubyVersion, 'pdk/util/ruby_version'
+    autoload :TemplateURI, 'pdk/util/template_uri'
+    autoload :VendoredFile, 'pdk/util/vendored_file'
+    autoload :Version, 'pdk/util/version'
+
+    MODULE_FOLDERS = ['manifests', 'lib/puppet', 'lib/puppet_x', 'lib/facter', 'tasks', 'facts.d', 'functions', 'types'].freeze
+
+    # :nocov:
+    # This method just wraps core Ruby functionality and
+    # can be ignored for code coverage
+
+    # Calls Kernel.exit with an exitcode
+    def exit_process(exit_code)
+      exit exit_code
+    end
+    # :nocov:
 
     # Searches upwards from current working directory for the given target file.
     #
@@ -26,13 +43,14 @@ module PDK
     #   nil if the target file could not be found.
     def find_upwards(target, start_dir = nil)
       previous = nil
-      current  = File.expand_path(start_dir || Dir.pwd)
+      current  = PDK::Util::Filesystem.expand_path(start_dir || Dir.pwd)
 
-      until !File.directory?(current) || current == previous
+      until !PDK::Util::Filesystem.directory?(current) || current == previous
         filename = File.join(current, target)
-        return filename if File.file?(filename)
+        return filename if PDK::Util::Filesystem.file?(filename)
+
         previous = current
-        current = File.expand_path('..', current)
+        current = PDK::Util::Filesystem.expand_path('..', current)
       end
     end
     module_function :find_upwards
@@ -43,6 +61,8 @@ module PDK
     #
     # @return [String] The temporary directory path.
     def make_tmpdir_name(base)
+      require 'tmpdir'
+
       t = Time.now.strftime('%Y%m%d')
       name = "#{base}#{t}-#{Process.pid}-#{rand(0x100000000).to_s(36)}"
       File.join(Dir.tmpdir, name)
@@ -56,23 +76,26 @@ module PDK
     # @return [String] Canonical path
     def canonical_path(path)
       if Gem.win_platform?
-        unless File.exist?(path)
-          raise PDK::CLI::FatalError, _("Cannot resolve a full path to '%{path}', as it does not currently exist.") % { path: path }
-        end
+        raise PDK::CLI::FatalError, format("Cannot resolve a full path to '%{path}', as it does not currently exist.", path: path) unless PDK::Util::Filesystem.exist?(path)
+
         PDK::Util::Windows::File.get_long_pathname(path)
       else
-        File.expand_path(path)
+        PDK::Util::Filesystem.expand_path(path)
       end
     end
     module_function :canonical_path
 
     def package_install?
+      require 'pdk/util/version'
+
       !PDK::Util::Version.version_file.nil?
     end
     module_function :package_install?
 
     def development_mode?
-      (!PDK::Util::Version.git_ref.nil? || PDK::VERSION.end_with?('.pre'))
+      require 'pdk/util/version'
+
+      !PDK::Util::Version.git_ref.nil? || PDK::VERSION.end_with?('.pre')
     end
     module_function :development_mode?
 
@@ -82,7 +105,9 @@ module PDK
     module_function :gem_install?
 
     def pdk_package_basedir
-      raise PDK::CLI::FatalError, _('Package basedir requested for non-package install.') unless package_install?
+      raise PDK::CLI::FatalError, 'Package basedir requested for non-package install.' unless package_install?
+
+      require 'pdk/util/version'
 
       File.dirname(PDK::Util::Version.version_file)
     end
@@ -98,13 +123,32 @@ module PDK
     # @return [String] Fully qualified path to per-user PDK cachedir.
     def cachedir
       if Gem.win_platform?
-        File.join(ENV['LOCALAPPDATA'], 'PDK', 'cache')
+        File.join(PDK::Util::Env['LOCALAPPDATA'], 'PDK', 'cache')
       else
         File.join(Dir.home, '.pdk', 'cache')
       end
     end
     module_function :cachedir
 
+    def configdir
+      if Gem.win_platform?
+        File.join(PDK::Util::Env['LOCALAPPDATA'], 'PDK')
+      else
+        File.join(PDK::Util::Env.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config')), 'pdk')
+      end
+    end
+    module_function :configdir
+
+    def system_configdir
+      return @system_configdir unless @system_configdir.nil?
+      return @system_configdir = File.join(File::SEPARATOR, 'opt', 'puppetlabs', 'pdk', 'config') unless Gem.win_platform?
+
+      return @system_configdir = File.join(PDK::Util::Env['ProgramData'], 'PuppetLabs', 'PDK') unless PDK::Util::Env['ProgramData'].nil?
+
+      @system_configdir = File.join(PDK::Util::Env['AllUsersProfile'], 'PuppetLabs', 'PDK')
+    end
+    module_function :system_configdir
+
     # Returns path to the root of the module being worked on.
     #
     # @return [String, nil] Fully qualified base path to module, or nil if
@@ -115,19 +159,27 @@ module PDK
         File.dirname(metadata_path)
       elsif in_module_root?
         Dir.pwd
-      else
-        nil
       end
     end
     module_function :module_root
 
+    # The module's fixtures directory for spec testing
+    # @return [String] - the path to the module's fixtures directory
+    def module_fixtures_dir
+      dir = module_root
+      File.join(module_root, 'spec', 'fixtures') unless dir.nil?
+    end
+    module_function :module_fixtures_dir
+
     # Returns true or false depending on if any of the common directories in a module
-    # are found in the current directory
+    # 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 MODULE_FOLDERS are found in the current dir,
     #   false otherwise.
-    def in_module_root?
-      PDK::Util::MODULE_FOLDERS.any? { |dir| File.directory?(dir) }
+    def in_module_root?(path = Dir.pwd)
+      PDK::Util::MODULE_FOLDERS.any? { |dir| PDK::Util::Filesystem.directory?(File.join(path, dir)) } ||
+        PDK::Util::Filesystem.file?(File.join(path, 'metadata.json'))
     end
     module_function :in_module_root?
 
@@ -137,7 +189,7 @@ module PDK
     # @return [Hash, nil] subset of text as Hash of first valid JSON found, or nil if no valid
     #   JSON found in the text
     def find_first_json_in(text)
-      find_valid_json_in(text)
+      find_all_json_in(text).first
     end
     module_function :find_first_json_in
 
@@ -147,42 +199,10 @@ module PDK
     # @return [Array<Hash>] subset of text as Array of all JSON object found, empty Array if none are found
     #   JSON found in the text
     def find_all_json_in(text)
-      find_valid_json_in(text, break_on_first: false)
+      PDK::Util::JSONFinder.new(text).objects
     end
     module_function :find_all_json_in
 
-    # Iterate through possible JSON documents until we find one that is valid.
-    #
-    # @param [String] text the text in which to find a JSON document
-    # @param [Hash] opts options
-    # @option opts [Boolean] :break_on_first Whether or not to break after valid JSON is found, defaults to true
-    #
-    # @return [Hash, Array<Hash>, nil] subset of text as Hash of first valid JSON found, array of all valid JSON found, or nil if no valid
-    #   JSON found in the text
-    #
-    # @private
-    def find_valid_json_in(text, opts = {})
-      break_on_first = opts.key?(:break_on_first) ? opts[:break_on_first] : true
-
-      json_result = break_on_first ? nil : []
-
-      text.scan(%r{\{(?:[^{}]|(?:\g<0>))*\}}x) do |str|
-        begin
-          if break_on_first
-            json_result = JSON.parse(str)
-            break
-          else
-            json_result.push(JSON.parse(str))
-          end
-        rescue JSON::ParserError
-          next
-        end
-      end
-
-      json_result
-    end
-    module_function :find_valid_json_in
-
     # Returns the targets' paths relative to the working directory
     #
     # @return [Array<String>] The absolute or path to the target
@@ -197,72 +217,19 @@ module PDK
     end
     module_function :targets_relative_to_pwd
 
-    def default_template_url
-      answer_file_url = PDK.answers['template-url']
-
-      return puppetlabs_template_url if answer_file_url.nil?
-
-      # Ignore answer file template-url if the value is the old or new default.
-      return puppetlabs_template_url if answer_file_url == 'https://github.com/puppetlabs/pdk-module-template'
-      return puppetlabs_template_url if answer_file_url == puppetlabs_template_url
-
-      if File.directory?(answer_file_url)
-        # Instantiating a new TemplateDir object pointing to the directory
-        # will cause the directory contents to be validated, raising
-        # ArgumentError if it does not appear to be a valid template.
-        PDK::Module::TemplateDir.new(answer_file_url) {}
-        return answer_file_url
-      end
-
-      raise ArgumentError unless PDK::Util::Git.repo?(answer_file_url)
-
-      answer_file_url
-    rescue ArgumentError
-      PDK.logger.warn(
-        _("Unable to access the previously used template '%{template}', using the default template instead.") % {
-          template: answer_file_url,
-        },
-      )
-      PDK.answers.update!('template-url' => nil)
-      return puppetlabs_template_url
-    end
-    module_function :default_template_url
-
-    def puppetlabs_template_url
-      if package_install?
-        'file://' + File.join(package_cachedir, 'pdk-templates.git')
-      else
-        'https://github.com/puppetlabs/pdk-templates'
-      end
-    end
-    module_function :puppetlabs_template_url
-
-    def default_template_ref
-      # TODO: This should respect a --template-ref option if we add that
-      return 'origin/master' if default_template_url != puppetlabs_template_url
-
-      puppetlabs_template_ref
-    end
-    module_function :default_template_ref
-
-    def puppetlabs_template_ref
-      if PDK::Util.development_mode?
-        'origin/master'
-      else
-        PDK::TEMPLATE_REF
-      end
-    end
-    module_function :puppetlabs_template_ref
-
     # TO-DO: Refactor replacement of lib/pdk/module/build.rb:metadata to use this function instead
-    def module_metadata
-      PDK::Module::Metadata.from_file(File.join(module_root, 'metadata.json')).data
+    # @param module_path [String] The path to the root of the module. Default is determine the module root automatically
+    def module_metadata(module_path = nil)
+      require 'pdk/module/metadata'
+      module_path ||= module_root
+      PDK::Module::Metadata.from_file(File.join(module_path, 'metadata.json')).data
     end
     module_function :module_metadata
 
     # TO-DO: Refactor replacement of lib/pdk/module/build.rb:module_pdk_compatible? to use this function instead
-    def module_pdk_compatible?
-      ['pdk-version', 'template-url'].any? { |key| module_metadata.key?(key) }
+    # @param module_path [String] The path to the root of the module. Default is determine the module root automatically
+    def module_pdk_compatible?(module_path = nil)
+      ['pdk-version', 'template-url'].any? { |key| module_metadata(module_path).key?(key) }
     end
     module_function :module_pdk_compatible?
 
@@ -279,5 +246,25 @@ module PDK
       nil
     end
     module_function :module_pdk_version
+
+    # Does a deep copy instead of a shallow copy of an object.
+    #
+    # @param object [Object] The object to duplicate
+    #
+    # @return [Object] duplicate of the original object
+    #   the current working dir does not appear to be within a module.
+    def deep_duplicate(object)
+      case object
+      when Array
+        object.map { |item| deep_duplicate(item) }
+      when Hash
+        hash = object.dup
+        hash.each_pair { |key, value| hash[key] = deep_duplicate(value) }
+        hash
+      else
+        object
+      end
+    end
+    module_function :deep_duplicate
   end
 end

data/lib/pdk/validate/control_repo/control_repo_validator_group.rb

@@ -0,0 +1,23 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module ControlRepo
+      class ControlRepoValidatorGroup < ValidatorGroup
+        def name
+          'control-repo'
+        end
+
+        def valid_in_context?
+          context.is_a?(PDK::Context::ControlRepo)
+        end
+
+        def validators
+          [
+            EnvironmentConfValidator
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/pdk/validate/control_repo/environment_conf_validator.rb

@@ -0,0 +1,98 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module ControlRepo
+      class EnvironmentConfValidator < InternalRubyValidator
+        ALLOWED_SETTINGS = ['modulepath', 'manifest', 'config_version', 'environment_timeout'].freeze
+
+        def name
+          'environment-conf'
+        end
+
+        def valid_in_context?
+          context.is_a?(PDK::Context::ControlRepo)
+        end
+
+        def pattern
+          ['environment.conf']
+        end
+
+        def spinner_text
+          format('Checking Puppet Environment settings (%{patterns}).', patterns: pattern.join(' '))
+        end
+
+        def validate_target(report, target)
+          unless PDK::Util::Filesystem.readable?(target)
+            report.add_event(
+              file: target,
+              source: name,
+              state: :failure,
+              severity: 'error',
+              message: 'Could not be read.'
+            )
+            return 1
+          end
+
+          is_valid = true
+          begin
+            env_conf = PDK::ControlRepo.environment_conf_as_config(target)
+
+            env_conf.resolve.each do |setting_name, setting_value|
+              # Remove the 'environment.' setting_name prefix
+              setting_name = setting_name.slice(12..-1)
+              next if ALLOWED_SETTINGS.include?(setting_name)
+
+              # A hash indicates that the ini file has a section in it.
+              message = if setting_value.is_a?(Hash)
+                          format("Invalid section '%{name}'", name: setting_name)
+                        else
+                          format("Invalid setting '%{name}'", name: setting_name)
+                        end
+
+              report.add_event(
+                file: target,
+                source: name,
+                state: :failure,
+                severity: 'error',
+                message: message
+              )
+              is_valid = false
+            end
+
+            timeout = env_conf.fetch('environment_timeout', nil)
+            unless timeout.nil? || timeout == '0' || timeout == 'unlimited'
+              report.add_event(
+                file: target,
+                source: name,
+                state: :failure,
+                severity: 'error',
+                message: format("environment_timeout is set to '%{timeout}' but should be 0, 'unlimited' or not set.", timeout: timeout)
+              )
+              is_valid = false
+            end
+
+            return 1 unless is_valid
+
+            report.add_event(
+              file: target,
+              source: name,
+              state: :passed,
+              severity: 'ok'
+            )
+            0
+          rescue StandardError => e
+            report.add_event(
+              file: target,
+              source: name,
+              state: :failure,
+              severity: 'error',
+              message: e.message
+            )
+            1
+          end
+        end
+      end
+    end
+  end
+end