pdk 3.0.1 → 3.3.0

data/lib/pdk/module/build.rb

@@ -1,302 +0,0 @@
-require 'pdk'
-
-module PDK
-  module Module
-    class Build
-      def self.invoke(options = {})
-        new(options).build
-      end
-
-      attr_reader :module_dir, :target_dir
-
-      def initialize(options = {})
-        @module_dir = PDK::Util::Filesystem.expand_path(options[:module_dir] || Dir.pwd)
-        @target_dir = PDK::Util::Filesystem.expand_path(options[:'target-dir'] || File.join(module_dir, 'pkg'))
-      end
-
-      # Read and parse the values from metadata.json for the module that is
-      # being built.
-      #
-      # @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
-
-      # Return the path where the built package file will be written to.
-      def package_file
-        @package_file ||= File.join(target_dir, "#{release_name}.tar.gz")
-      end
-
-      # Build a module package from a module directory.
-      #
-      # @return [String] The path to the built package file.
-      def build
-        create_build_dir
-
-        stage_module_in_build_dir
-        build_package
-
-        package_file
-      ensure
-        cleanup_build_dir
-      end
-
-      # Verify if there is an existing package in the target directory and prompts
-      # the user if they want to overwrite it.
-      def package_already_exists?
-        PDK::Util::Filesystem.exist?(package_file)
-      end
-
-      # Check if the module is PDK Compatible. If not, then prompt the user if
-      # they want to run PDK Convert.
-      def module_pdk_compatible?
-        ['pdk-version', 'template-url'].any? { |key| metadata.key?(key) }
-      end
-
-      # Return the path to the temporary build directory, which will be placed
-      # inside the target directory and match the release name (see #release_name).
-      def build_dir
-        @build_dir ||= File.join(target_dir, release_name)
-      end
-
-      # Create a temporary build directory where the files to be included in
-      # the package will be staged before building the tarball.
-      #
-      # If the directory already exists, remove it first.
-      def create_build_dir
-        cleanup_build_dir
-
-        PDK::Util::Filesystem.mkdir_p(build_dir)
-      end
-
-      # Remove the temporary build directory and all its contents from disk.
-      #
-      # @return nil.
-      def cleanup_build_dir
-        PDK::Util::Filesystem.rm_rf(build_dir, secure: true)
-      end
-
-      # Combine the module name and version into a Forge-compatible dash
-      # separated string.
-      #
-      # @return [String] The module name and version, joined by a dash.
-      def release_name
-        @release_name ||= [
-          metadata['name'],
-          metadata['version']
-        ].join('-')
-      end
-
-      # Iterate through all the files and directories in the module and stage
-      # them into the temporary build directory (unless ignored).
-      #
-      # @return nil
-      def stage_module_in_build_dir
-        require 'find'
-
-        Find.find(module_dir) do |path|
-          next if path == module_dir
-
-          ignored_path?(path) ? Find.prune : stage_path(path)
-        end
-      end
-
-      # Stage a file or directory from the module into the build directory.
-      #
-      # @param path [String] The path to the file or directory.
-      #
-      # @return nil.
-      def stage_path(path)
-        require 'pathname'
-
-        relative_path = Pathname.new(path).relative_path_from(Pathname.new(module_dir))
-        dest_path = File.join(build_dir, relative_path)
-
-        validate_path_encoding!(relative_path.to_path)
-
-        if PDK::Util::Filesystem.directory?(path)
-          PDK::Util::Filesystem.mkdir_p(dest_path, mode: PDK::Util::Filesystem.stat(path).mode)
-        elsif PDK::Util::Filesystem.symlink?(path)
-          warn_symlink(path)
-        else
-          validate_ustar_path!(relative_path.to_path)
-          PDK::Util::Filesystem.cp(path, dest_path, preserve: true)
-        end
-      rescue ArgumentError => e
-        raise PDK::CLI::ExitWithError, format('%{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
-      # ignore file.
-      #
-      # @param path [String] The path to be checked.
-      #
-      # @return [Boolean] true if the path matches and should be ignored.
-      def ignored_path?(path)
-        path = "#{path}/" if PDK::Util::Filesystem.directory?(path)
-
-        !ignored_files.match_paths([path], module_dir).empty?
-      end
-
-      # Warn the user about a symlink that would have been included in the
-      # built package.
-      #
-      # @param path [String] The relative or absolute path to the symlink.
-      #
-      # @return nil.
-      def warn_symlink(path)
-        require 'pathname'
-
-        symlink_path = Pathname.new(path)
-        module_path = Pathname.new(module_dir)
-
-        PDK.logger.warn format('Symlinks in modules are not supported and will not be included in the package. Please investigate symlink %{from} -> %{to}.',
-                               from: symlink_path.relative_path_from(module_path), to: symlink_path.realpath.relative_path_from(module_path))
-      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)
-        raise ArgumentError, format("The path '%{path}' is longer than 256 bytes.", path: path) if path.bytesize > 256
-
-        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,
-              format("'%{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
-
-      # Checks if the path contains any non-ASCII characters.
-      #
-      # Java will throw an error when it encounters a path containing
-      # characters that are not supported by the hosts locale. In order to
-      # maximise compatibility we limit the paths to contain only ASCII
-      # characters, which should be part of any locale character set.
-      #
-      # @param path [String] the relative path to be added to the tar file.
-      #
-      # @raise [ArgumentError] if the path contains non-ASCII characters.
-      #
-      # @return [nil]
-      def validate_path_encoding!(path)
-        return unless /[^\x00-\x7F]/.match?(path)
-
-        raise ArgumentError, format("'%{path}' can only include ASCII characters in its path or " \
-                                    'filename in order to be compatible with a wide range of hosts.', path: path)
-      end
-
-      # Creates a gzip compressed tarball of the build directory.
-      #
-      # If the destination package already exists, it will be removed before
-      # creating the new tarball.
-      #
-      # @return nil.
-      def build_package
-        require 'zlib'
-        require 'minitar'
-        require 'find'
-
-        PDK::Util::Filesystem.rm_f(package_file)
-
-        Dir.chdir(target_dir) do
-          gz = Zlib::GzipWriter.new(File.open(package_file, 'wb')) # rubocop:disable PDK/FileOpen
-          tar = Minitar::Output.new(gz)
-          Find.find(release_name) do |entry|
-            entry_meta = {
-              name: entry
-            }
-
-            orig_mode = PDK::Util::Filesystem.stat(entry).mode
-            min_mode = Minitar.dir?(entry) ? 0o755 : 0o644
-
-            entry_meta[:mode] = orig_mode | min_mode
-
-            PDK.logger.debug(format('Updated permissions of packaged \'%{entry}\' to %{new_mode}', entry: entry, new_mode: (entry_meta[:mode] & 0o7777).to_s(8))) if entry_meta[:mode] != orig_mode
-
-            Minitar.pack_file(entry_meta, tar)
-          end
-        ensure
-          tar.close
-        end
-      end
-
-      # Select the most appropriate ignore file in the module directory.
-      #
-      # In order of preference, we first try `.pdkignore`, then `.pmtignore`
-      # and finally `.gitignore`.
-      #
-      # @return [String] The path to the file containing the patterns of file
-      #   paths to ignore.
-      def ignore_file
-        @ignore_file ||= [
-          File.join(module_dir, '.pdkignore'),
-          File.join(module_dir, '.pmtignore'),
-          File.join(module_dir, '.gitignore')
-        ].find { |file| PDK::Util::Filesystem.file?(file) && PDK::Util::Filesystem.readable?(file) }
-      end
-
-      # Instantiate a new PathSpec class and populate it with the pattern(s) of
-      # files to be ignored.
-      #
-      # @return [PathSpec] The populated ignore path matcher.
-      def ignored_files
-        require 'pdk/module'
-        require 'pathspec'
-
-        @ignored_files ||=
-          begin
-            ignored = if ignore_file.nil?
-                        PathSpec.new
-                      else
-                        PathSpec.new(PDK::Util::Filesystem.read_file(ignore_file, open_args: 'rb:UTF-8'))
-                      end
-
-            ignored = ignored.add("/#{File.basename(target_dir)}/") if File.realdirpath(target_dir).start_with?(File.realdirpath(module_dir))
-
-            PDK::Module::DEFAULT_IGNORED.each { |r| ignored.add(r) }
-
-            ignored
-          end
-      end
-    end
-  end
-end

data/lib/pdk/monkey_patches.rb

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-
-module OS
-  # Os detection: Are we on Windows?
-  def self.windows?
-    (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
-  end
-end
-
-# Patch childprocess so that it is Ruby 3 compliant.
-# This could be removed if the following PR is ever merged
-# and released:
-# https://github.com/enkessler/childprocess/pull/185
-module ChildProcess
-  class << self
-    def build(*args)
-      case os
-      when :macosx, :linux, :solaris, :bsd, :cygwin, :aix
-        if posix_spawn?
-          Unix::PosixSpawnProcess.new(*args)
-        elsif jruby?
-          JRuby::Process.new(*args)
-        else
-          Unix::ForkExecProcess.new(*args)
-        end
-      when :windows
-        Windows::Process.new(*args)
-      else
-        raise Error, "unsupported platform #{platform_name.inspect}"
-      end
-    end
-  end
-
-  class AbstractProcess
-    def initialize(*args)
-      raise ArgumentError, "all arguments must be String: #{args.inspect}" unless args.all?(String)
-
-      @args        = args
-      @started     = false
-      @exit_code   = nil
-      @io          = nil
-      @cwd         = nil
-      @detach      = false
-      @duplex      = false
-      @leader      = false
-      @environment = {}
-    end
-  end
-
-  if OS.windows?
-    module Windows
-      module Lib
-        extend FFI::Library
-        def self.msvcrt_name
-          RbConfig::CONFIG['RUBY_SO_NAME'][/msvc\w+/] || 'ucrtbase'
-        end
-
-        ffi_lib 'kernel32', msvcrt_name
-        ffi_convention :stdcall
-
-        # We have to redefine the function declarations so that they are available
-        # with the patched ffi_lib.
-        enum :wait_status, [
-          :wait_object_0,  0, # rubocop:disable Naming/VariableNumber
-          :wait_timeout,   0x102,
-          :wait_abandoned, 0x80,
-          :wait_failed,    0xFFFFFFFF
-        ]
-
-        #
-        # BOOL WINAPI CreateProcess(
-        #   __in_opt     LPCTSTR lpApplicationName,
-        #   __inout_opt  LPTSTR lpCommandLine,
-        #   __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
-        #   __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
-        #   __in         BOOL bInheritHandles,
-        #   __in         DWORD dwCreationFlags,
-        #   __in_opt     LPVOID lpEnvironment,
-        #   __in_opt     LPCTSTR lpCurrentDirectory,
-        #   __in         LPSTARTUPINFO lpStartupInfo,
-        #   __out        LPPROCESS_INFORMATION lpProcessInformation
-        # );
-        #
-
-        attach_function :create_process, :CreateProcessW, [
-          :pointer,
-          :buffer_inout,
-          :pointer,
-          :pointer,
-          :bool,
-          :ulong,
-          :pointer,
-          :pointer,
-          :pointer,
-          :pointer
-        ], :bool
-
-        #
-        #   DWORD WINAPI FormatMessage(
-        #   __in      DWORD dwFlags,
-        #   __in_opt  LPCVOID lpSource,
-        #   __in      DWORD dwMessageId,
-        #   __in      DWORD dwLanguageId,
-        #   __out     LPTSTR lpBuffer,
-        #   __in      DWORD nSize,
-        #   __in_opt  va_list *Arguments
-        # );
-        #
-
-        attach_function :format_message, :FormatMessageA, [
-          :ulong,
-          :pointer,
-          :ulong,
-          :ulong,
-          :pointer,
-          :ulong,
-          :pointer
-        ], :ulong
-
-        attach_function :close_handle, :CloseHandle, [:pointer], :bool
-
-        #
-        # HANDLE WINAPI OpenProcess(
-        #   __in  DWORD dwDesiredAccess,
-        #   __in  BOOL bInheritHandle,
-        #   __in  DWORD dwProcessId
-        # );
-        #
-
-        attach_function :open_process, :OpenProcess, [:ulong, :bool, :ulong], :pointer
-
-        #
-        # HANDLE WINAPI CreateJobObject(
-        #   _In_opt_  LPSECURITY_ATTRIBUTES lpJobAttributes,
-        #   _In_opt_  LPCTSTR lpName
-        # );
-        #
-
-        attach_function :create_job_object, :CreateJobObjectA, [:pointer, :pointer], :pointer
-
-        #
-        # BOOL WINAPI AssignProcessToJobObject(
-        #   _In_  HANDLE hJob,
-        #   _In_  HANDLE hProcess
-        # );
-
-        attach_function :assign_process_to_job_object, :AssignProcessToJobObject, [:pointer, :pointer], :bool
-
-        #
-        # BOOL WINAPI SetInformationJobObject(
-        #   _In_  HANDLE hJob,
-        #   _In_  JOBOBJECTINFOCLASS JobObjectInfoClass,
-        #   _In_  LPVOID lpJobObjectInfo,
-        #   _In_  DWORD cbJobObjectInfoLength
-        # );
-        #
-
-        attach_function :set_information_job_object, :SetInformationJobObject, [:pointer, :int, :pointer, :ulong], :bool
-
-        #
-        #
-        # DWORD WINAPI WaitForSingleObject(
-        #   __in  HANDLE hHandle,
-        #   __in  DWORD dwMilliseconds
-        # );
-        #
-
-        attach_function :wait_for_single_object, :WaitForSingleObject, [:pointer, :ulong], :wait_status, blocking: true
-
-        #
-        # BOOL WINAPI GetExitCodeProcess(
-        #   __in   HANDLE hProcess,
-        #   __out  LPDWORD lpExitCode
-        # );
-        #
-
-        attach_function :get_exit_code, :GetExitCodeProcess, [:pointer, :pointer], :bool
-
-        #
-        # BOOL WINAPI GenerateConsoleCtrlEvent(
-        #   __in  DWORD dwCtrlEvent,
-        #   __in  DWORD dwProcessGroupId
-        # );
-        #
-
-        attach_function :generate_console_ctrl_event, :GenerateConsoleCtrlEvent, [:ulong, :ulong], :bool
-
-        #
-        # BOOL WINAPI TerminateProcess(
-        #   __in  HANDLE hProcess,
-        #   __in  UINT uExitCode
-        # );
-        #
-
-        attach_function :terminate_process, :TerminateProcess, [:pointer, :uint], :bool
-
-        #
-        # intptr_t _get_osfhandle(
-        #    int fd
-        # );
-        #
-
-        attach_function :get_osfhandle, :_get_osfhandle, [:int], :intptr_t
-
-        #
-        # int _open_osfhandle (
-        #    intptr_t osfhandle,
-        #    int flags
-        # );
-        #
-
-        attach_function :open_osfhandle, :_open_osfhandle, [:pointer, :int], :int
-
-        # BOOL WINAPI SetHandleInformation(
-        #   __in  HANDLE hObject,
-        #   __in  DWORD dwMask,
-        #   __in  DWORD dwFlags
-        # );
-
-        attach_function :set_handle_information, :SetHandleInformation, [:pointer, :ulong, :ulong], :bool
-
-        # BOOL WINAPI GetHandleInformation(
-        #   __in   HANDLE hObject,
-        #   __out  LPDWORD lpdwFlags
-        # );
-
-        attach_function :get_handle_information, :GetHandleInformation, [:pointer, :pointer], :bool
-
-        # BOOL WINAPI CreatePipe(
-        #   __out     PHANDLE hReadPipe,
-        #   __out     PHANDLE hWritePipe,
-        #   __in_opt  LPSECURITY_ATTRIBUTES lpPipeAttributes,
-        #   __in      DWORD nSize
-        # );
-
-        attach_function :create_pipe, :CreatePipe, [:pointer, :pointer, :pointer, :ulong], :bool
-
-        #
-        # HANDLE WINAPI GetCurrentProcess(void);
-        #
-
-        attach_function :current_process, :GetCurrentProcess, [], :pointer
-
-        #
-        # BOOL WINAPI DuplicateHandle(
-        #   __in   HANDLE hSourceProcessHandle,
-        #   __in   HANDLE hSourceHandle,
-        #   __in   HANDLE hTargetProcessHandle,
-        #   __out  LPHANDLE lpTargetHandle,
-        #   __in   DWORD dwDesiredAccess,
-        #   __in   BOOL bInheritHandle,
-        #   __in   DWORD dwOptions
-        # );
-        #
-
-        attach_function :_duplicate_handle, :DuplicateHandle, [
-          :pointer,
-          :pointer,
-          :pointer,
-          :pointer,
-          :ulong,
-          :bool,
-          :ulong
-        ], :bool
-      end
-    end
-  end
-end