pdk-akerl 1.8.0.1

data/lib/pdk/cli.rb

@@ -0,0 +1,113 @@
+require 'cri'
+
+require 'pdk/cli/errors'
+require 'pdk/cli/util'
+require 'pdk/cli/util/command_redirector'
+require 'pdk/cli/util/option_normalizer'
+require 'pdk/cli/util/option_validator'
+require 'pdk/cli/exec_group'
+require 'pdk/generate/module'
+require 'pdk/i18n'
+require 'pdk/logger'
+require 'pdk/report'
+require 'pdk/util/version'
+require 'pdk/util/puppet_version'
+
+module PDK::CLI
+  def self.run(args)
+    @base_cmd.run(args)
+  rescue PDK::CLI::ExitWithError => e
+    PDK.logger.send(e.log_level, e.message)
+
+    exit e.exit_code
+  rescue PDK::CLI::FatalError => e
+    PDK.logger.fatal(e.message) if e.message
+
+    # If FatalError was raised as the result of another exception, send the
+    # details of that exception to the debug log. If there was no cause
+    # (FatalError raised on its own outside a rescue block), send the details
+    # of the FatalError exception to the debug log.
+    cause = e.cause
+    if cause.nil?
+      e.backtrace.each { |line| PDK.logger.debug(line) }
+    else
+      PDK.logger.debug("#{cause.class}: #{cause.message}")
+      cause.backtrace.each { |line| PDK.logger.debug(line) }
+    end
+
+    exit e.exit_code
+  end
+
+  def self.template_url_option(dsl)
+    desc = _('Specifies the URL to the template to use when creating new modules or classes. (default: %{default_url})') % { default_url: PDK::Util.default_template_url }
+
+    dsl.option nil, 'template-url', desc, argument: :required
+  end
+
+  def self.skip_interview_option(dsl)
+    dsl.option nil, 'skip-interview', _('When specified, skips interactive querying of metadata.')
+  end
+
+  def self.full_interview_option(dsl)
+    dsl.option nil, 'full-interview', _('When specified, interactive querying of metadata will include all optional questions.')
+  end
+
+  def self.puppet_version_options(dsl)
+    dsl.option nil, 'puppet-version', _('Puppet version to run tests or validations against.'), argument: :required
+    dsl.option nil, 'pe-version', _('Puppet Enterprise version to run tests or validations against.'), argument: :required
+  end
+
+  def self.puppet_dev_option(dsl)
+    dsl.option nil,
+               'puppet-dev',
+               _('When specified, PDK will validate or test against the current Puppet source from github.com. To use this option, you must have network access to https://github.com.')
+  end
+
+  @base_cmd = Cri::Command.define do
+    name 'pdk'
+    usage _('pdk command [options]')
+    summary _('Puppet Development Kit')
+    description _('The shortest path to better modules.')
+    default_subcommand 'help'
+
+    flag nil, :version, _('Show version of pdk.') do |_, _|
+      puts PDK::Util::Version.version_string
+      exit 0
+    end
+
+    flag :h, :help, _('Show help for this command.') do |_, c|
+      puts c.help
+      exit 0
+    end
+
+    format_desc = _(
+      "Specify desired output format. Valid formats are '%{available_formats}'. " \
+      'You may also specify a file to which the formatted output is sent, ' \
+      "for example: '--format=junit:report.xml'. This option may be specified " \
+      'multiple times if each option specifies a distinct target file.',
+    ) % { available_formats: PDK::Report.formats.join("', '") }
+
+    option :f, :format, format_desc, argument: :required, multiple: true do |values|
+      PDK::CLI::Util::OptionNormalizer.report_formats(values.compact)
+    end
+
+    flag :d, :debug, _('Enable debug output.') do |_, _|
+      PDK.logger.enable_debug_output
+    end
+
+    option nil, 'answer-file', _('Path to an answer file.'), argument: :required, hidden: true do |value|
+      PDK.answer_file = value
+    end
+  end
+
+  require 'pdk/cli/bundle'
+  require 'pdk/cli/build'
+  require 'pdk/cli/convert'
+  require 'pdk/cli/new'
+  require 'pdk/cli/test'
+  require 'pdk/cli/update'
+  require 'pdk/cli/validate'
+  require 'pdk/cli/module'
+
+  @base_cmd.add_command Cri::Command.new_basic_help
+end

data/lib/pdk/cli/build.rb

@@ -0,0 +1,76 @@
+require 'pdk/cli/util'
+
+module PDK::CLI
+  @build_cmd = @base_cmd.define_command do
+    name 'build'
+    usage _('build [options]')
+    summary _('Builds a package from the module that can be published to the Puppet Forge.')
+
+    option nil, 'target-dir',
+           _('The target directory where you want PDK to write the package.'),
+           argument: :required, default: File.join(Dir.pwd, 'pkg')
+
+    option nil, 'force', _('Skips the prompts and builds the module package.')
+
+    run do |opts, _args, _cmd|
+      require 'pdk/module/build'
+
+      # Make sure build is being run in a valid module directory with a metadata.json
+      PDK::CLI::Util.ensure_in_module!(
+        message:   _('`pdk build` can only be run from inside a valid module with a metadata.json.'),
+        log_level: :info,
+      )
+
+      module_metadata = PDK::Module::Metadata.from_file('metadata.json')
+
+      # TODO: Ensure forge metadata has been set, or call out to interview
+      #       to set it.
+      #
+      unless module_metadata.forge_ready?
+        if opts[:force]
+          PDK.logger.error _('This module is missing required fields in the metadata.json. Re-run the build command without --force to add this information.')
+          exit 1
+        else
+          module_metadata.interview_for_forge!
+          module_metadata.write!('metadata.json')
+        end
+      end
+
+      builder = PDK::Module::Build.new(opts)
+
+      unless opts[:force]
+        if builder.package_already_exists?
+          PDK.logger.info _("The file '%{package}' already exists.") % { package: builder.package_file }
+
+          unless PDK::CLI::Util.prompt_for_yes(_('Overwrite?'), default: false)
+            PDK.logger.info _('Build cancelled; exiting.')
+            exit 0
+          end
+        end
+
+        unless builder.module_pdk_compatible?
+          PDK.logger.info _('This module is not compatible with PDK, so PDK can not validate or test this build. ' \
+                            'Unvalidated modules may have errors when uploading to the Forge. ' \
+                            'To make this module PDK compatible and use validate features, cancel the build and run `pdk convert`.')
+
+          unless PDK::CLI::Util.prompt_for_yes(_('Continue build without converting?'))
+            PDK.logger.info _('Build cancelled; exiting.')
+            exit 0
+          end
+        end
+      end
+
+      PDK.logger.info _('Building %{module_name} version %{module_version}') % {
+        module_name:    module_metadata.data['name'],
+        module_version: module_metadata.data['version'],
+      }
+
+      builder.build
+
+      PDK.logger.info _('Build of %{package_name} has completed successfully. Built package can be found here: %{package_path}') % {
+        package_name: module_metadata.data['name'],
+        package_path: builder.package_file,
+      }
+    end
+  end
+end

data/lib/pdk/cli/bundle.rb

@@ -0,0 +1,42 @@
+
+module PDK::CLI
+  @bundle_cmd = @base_cmd.define_command do
+    name 'bundle'
+    usage _('bundle [bundler_options]')
+    summary _('(Experimental) Command pass-through to bundler')
+    description _(<<-EOF
+[experimental] For advanced users, pdk bundle runs arbitrary commands in the bundler environment that pdk manages.
+Careless use of this command can lead to errors that pdk can't help recover from.
+
+Note that for PowerShell the '--' needs to be escaped using a backtick: '`--' to avoid it being parsed by the shell.
+EOF
+                 )
+    skip_option_parsing
+
+    run do |_opts, args, _cmd|
+      PDK::CLI::Util.ensure_in_module!(
+        message: _('`pdk bundle` can only be run from inside a valid module directory.'),
+      )
+
+      PDK::CLI::Util.validate_puppet_version_opts({})
+
+      # Ensure that the correct Ruby is activated before running commend.
+      puppet_env = PDK::CLI::Util.puppet_from_opts_or_env({})
+      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
+
+      gemfile_env = PDK::Util::Bundler::BundleHelper.gemfile_env(puppet_env[:gemset])
+
+      command = PDK::CLI::Exec::Command.new(PDK::CLI::Exec.bundle_bin, *args).tap do |c|
+        c.context = :module
+        c.update_environment(gemfile_env)
+      end
+
+      result = command.execute!
+
+      $stderr.puts result[:stdout]
+      $stderr.puts result[:stderr]
+
+      exit result[:exit_code]
+    end
+  end
+end

data/lib/pdk/cli/convert.rb

@@ -0,0 +1,41 @@
+require 'pdk/cli/util'
+
+module PDK::CLI
+  @convert_cmd = @base_cmd.define_command do
+    name 'convert'
+    usage _('convert [options]')
+    summary _('Convert an existing module to be compatible with the PDK.')
+
+    PDK::CLI.template_url_option(self)
+    PDK::CLI.skip_interview_option(self)
+    PDK::CLI.full_interview_option(self)
+    flag nil, :noop, _('Do not convert the module, just output what would be done.')
+    flag nil, :force, _('Convert the module automatically, with no prompts.')
+
+    run do |opts, _args, _cmd|
+      require 'pdk/module/convert'
+
+      PDK::CLI::Util.ensure_in_module!(
+        check_module_layout: true,
+        message:             _('`pdk convert` can only be run from inside a valid module directory.'),
+        log_level:           :info,
+      )
+
+      if opts[:noop] && opts[:force]
+        raise PDK::CLI::ExitWithError, _('You can not specify --noop and --force when converting a module')
+      end
+
+      if opts[:'skip-interview'] && opts[:'full-interview']
+        PDK.logger.info _('Ignoring --full-interview and continuing with --skip-interview.')
+        opts[:'full-interview'] = false
+      end
+
+      if opts[:force] && opts[:'full-interview']
+        PDK.logger.info _('Ignoring --full-interview and continuing with --force.')
+        opts[:'full-interview'] = false
+      end
+
+      PDK::Module::Convert.invoke(opts)
+    end
+  end
+end

data/lib/pdk/cli/errors.rb

@@ -0,0 +1,23 @@
+module PDK
+  module CLI
+    class FatalError < StandardError
+      attr_reader :exit_code
+
+      def initialize(msg = _('An unexpected error has occurred. Try running the command again with --debug'), opts = {})
+        @exit_code = opts.fetch(:exit_code, 1)
+        super(msg)
+      end
+    end
+
+    class ExitWithError < StandardError
+      attr_reader :exit_code
+      attr_reader :log_level
+
+      def initialize(msg, opts = {})
+        @exit_code = opts.fetch(:exit_code, 1)
+        @log_level = opts.fetch(:log_level, :error)
+        super(msg)
+      end
+    end
+  end
+end

data/lib/pdk/cli/exec.rb

@@ -0,0 +1,246 @@
+require 'bundler'
+require 'childprocess'
+require 'tempfile'
+require 'tty-spinner'
+require 'tty-which'
+
+require 'pdk/util'
+require 'pdk/util/git'
+require 'pdk/util/ruby_version'
+
+module PDK
+  module CLI
+    module Exec
+      def self.execute(*cmd)
+        Command.new(*cmd).execute!
+      end
+
+      def self.execute_with_env(env, *cmd)
+        Command.new(*cmd).tap { |c| c.environment = env }.execute!
+      end
+
+      def self.ensure_bin_present!(bin_path, bin_name)
+        message = _('Unable to find `%{name}`. Check that it is installed and try again.') % {
+          name: bin_name,
+        }
+
+        raise PDK::CLI::FatalError, message unless TTY::Which.exist?(bin_path)
+      end
+
+      def self.bundle(*args)
+        ensure_bin_present!(bundle_bin, 'bundler')
+
+        execute(bundle_bin, *args)
+      end
+
+      def self.bundle_bin
+        bundle_bin = Gem.win_platform? ? 'bundle.bat' : 'bundle'
+        vendored_bin_path = File.join('private', 'ruby', PDK::Util::RubyVersion.active_ruby_version, 'bin', bundle_bin)
+
+        try_vendored_bin(vendored_bin_path, bundle_bin)
+      end
+
+      def self.try_vendored_bin(vendored_bin_path, fallback)
+        unless PDK::Util.package_install?
+          PDK.logger.debug(_("PDK package installation not found. Trying '%{fallback}' from the system PATH instead.") % {
+            fallback: fallback,
+          })
+          return fallback
+        end
+
+        vendored_bin_full_path = File.join(PDK::Util.pdk_package_basedir, vendored_bin_path)
+
+        unless File.exist?(vendored_bin_full_path)
+          PDK.logger.debug(_("Could not find '%{vendored_bin}' in PDK package. Trying '%{fallback}' from the system PATH instead.") % {
+            fallback: fallback,
+            vendored_bin: vendored_bin_full_path,
+          })
+          return fallback
+        end
+
+        PDK.logger.debug(_("Using '%{vendored_bin}' from PDK package.") % { vendored_bin: vendored_bin_full_path })
+        vendored_bin_full_path
+      end
+
+      # TODO: decide how/when to connect stdin to child process for things like pry
+      # TODO: need a way to set callbacks on new stdout/stderr data
+      class Command
+        attr_reader :argv
+        attr_reader :context
+        attr_accessor :timeout
+        attr_accessor :environment
+        attr_writer :exec_group
+
+        def initialize(*argv)
+          @argv = argv
+
+          @process = ChildProcess.build(*@argv)
+          @process.leader = true
+
+          @stdout = Tempfile.new('stdout').tap { |io| io.sync = true }
+          @stderr = Tempfile.new('stderr').tap { |io| io.sync = true }
+
+          @process.io.stdout = @stdout
+          @process.io.stderr = @stderr
+
+          # Default to running things in the system context.
+          @context = :system
+
+          # Extra environment vars to add to base set.
+          @environment = {}
+
+          # Register the ExecGroup when running in parallel
+          @exec_group = nil
+        end
+
+        def context=(new_context)
+          unless [:system, :module].include?(new_context)
+            raise ArgumentError, _("Expected execution context to be :system or :module but got '%{context}'.") % { context: new_context }
+          end
+
+          @context = new_context
+        end
+
+        def register_spinner(spinner, opts = {})
+          return unless PDK::CLI::Util.interactive?
+          @success_message = opts.delete(:success)
+          @failure_message = opts.delete(:failure)
+
+          @spinner = spinner
+        end
+
+        def add_spinner(message, opts = {})
+          return unless PDK::CLI::Util.interactive?
+          @success_message = opts.delete(:success)
+          @failure_message = opts.delete(:failure)
+
+          @spinner = TTY::Spinner.new("[:spinner] #{message}", opts.merge(PDK::CLI::Util.spinner_opts_for_platform))
+        end
+
+        def update_environment(additional_env)
+          @environment.merge!(additional_env)
+        end
+
+        def execute!
+          # Start spinning if configured.
+          @spinner.auto_spin if @spinner
+
+          # Add custom env vars.
+          @environment.each do |k, v|
+            @process.environment[k] = v
+          end
+
+          @process.environment['BUNDLE_IGNORE_CONFIG'] = '1'
+
+          if context == :module
+            @process.environment['GEM_HOME'] = PDK::Util::RubyVersion.gem_home
+            @process.environment['GEM_PATH'] = PDK::Util::RubyVersion.gem_path
+
+            # Make sure invocation of Ruby prefers our private installation.
+            package_binpath = PDK::Util.package_install? ? File.join(PDK::Util.pdk_package_basedir, 'bin') : nil
+            @process.environment['PATH'] = [
+              PDK::Util::RubyVersion.bin_path,
+              File.join(@process.environment['GEM_HOME'], 'bin'),
+              PDK::Util::RubyVersion.gem_paths_raw.map { |gem_path| File.join(gem_path, 'bin') },
+              package_binpath,
+              ENV['PATH'],
+              PDK::Util.package_install? ? PDK::Util::Git.git_paths : nil,
+            ].compact.flatten.join(File::PATH_SEPARATOR)
+
+            mod_root = PDK::Util.module_root
+
+            unless mod_root
+              @spinner.error if @spinner
+
+              raise PDK::CLI::FatalError, _('Current working directory is not part of a module. (No metadata.json was found.)')
+            end
+
+            if Dir.pwd == mod_root
+              run_process_in_clean_env!
+            else
+              Dir.chdir(mod_root) do
+                run_process_in_clean_env!
+              end
+            end
+          else
+            run_process!
+          end
+
+          # Stop spinning when done (if configured).
+          stop_spinner
+
+          @stdout.rewind
+          @stderr.rewind
+
+          process_data = {
+            stdout: @stdout.read,
+            stderr: @stderr.read,
+            exit_code: @process.exit_code,
+            duration: @duration,
+          }
+
+          return process_data
+        ensure
+          @stdout.close
+          @stderr.close
+        end
+
+        protected
+
+        def stop_spinner
+          return unless @spinner
+
+          # If it is a single spinner, we need to send it a success/error message
+          if @process.exit_code.zero?
+            @spinner.success(@success_message || '')
+          else
+            @spinner.error(@failure_message || '')
+          end
+        end
+
+        def run_process_in_clean_env!
+          ::Bundler.with_clean_env do
+            run_process!
+          end
+        end
+
+        def run_process!
+          command_string = argv.join(' ')
+
+          PDK.logger.debug(_("Executing '%{command}'") % { command: command_string })
+
+          if context == :module
+            PDK.logger.debug(_('Command environment:'))
+            @process.environment.each do |var, val|
+              PDK.logger.debug("  #{var}: #{val}")
+            end
+          end
+
+          start_time = Time.now
+
+          begin
+            @process.start
+          rescue ChildProcess::LaunchError => e
+            raise PDK::CLI::FatalError, _("Failed to execute '%{command}': %{message}") % { command: command_string, message: e.message }
+          end
+
+          if timeout
+            begin
+              @process.poll_for_exit(timeout)
+            rescue ChildProcess::TimeoutError
+              @process.stop # tries increasingly harsher methods to kill the process.
+            end
+          else
+            # Wait indfinitely if no timeout set.
+            @process.wait
+          end
+
+          @duration = Time.now - start_time
+
+          PDK.logger.debug(_("Execution of '%{command}' complete (duration: %{duration_in_seconds}s; exit code: %{exit_code})") %
+            { command: command_string, duration_in_seconds: @duration, exit_code: @process.exit_code })
+        end
+      end
+    end
+  end
+end