bolt 2.29.0 → 2.33.2

data/lib/bolt/project_migrator/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'bolt/error'
+
+module Bolt
+  class ProjectMigrator
+    class Base
+      def initialize(outputter)
+        @outputter = outputter
+      end
+
+      protected def backup_file(origin_path, backup_dir)
+        unless File.exist?(origin_path)
+          @outputter.print_action_step(
+            "Could not find file #{origin_path}, skipping backup."
+          )
+          return
+        end
+
+        date = Time.new.strftime("%Y%m%d_%H%M%S%L")
+        FileUtils.mkdir_p(backup_dir)
+
+        filename = File.basename(origin_path)
+        backup_path = File.join(backup_dir, "#{filename}.#{date}.bak")
+
+        @outputter.print_action_step(
+          "Backing up #{filename} from #{origin_path} to #{backup_path}"
+        )
+
+        begin
+          FileUtils.cp(origin_path, backup_path)
+        rescue StandardError => e
+          raise Bolt::FileError.new("#{e.message}; unable to create backup of #{filename}.", origin_path)
+        end
+      end
+    end
+  end
+end

data/lib/bolt/project_migrator/config.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'bolt/project_migrator/base'
+
+module Bolt
+  class ProjectMigrator
+    class Config < Base
+      def migrate(config_file, project_file, inventory_file, backup_dir)
+        bolt_yaml_to_bolt_project(config_file, project_file, inventory_file, backup_dir)
+      end
+
+      private def bolt_yaml_to_bolt_project(config_file, project_file, inventory_file, backup_dir)
+        if File.exist?(project_file)
+          return true
+        end
+
+        unless File.exist?(config_file)
+          return true
+        end
+
+        @outputter.print_message "Migrating project configuration\n\n"
+
+        config_data = Bolt::Util.read_optional_yaml_hash(config_file, 'config')
+        transport_data, project_data = config_data.partition do |k, _|
+          Bolt::Config::INVENTORY_OPTIONS.keys.include?(k)
+        end.map(&:to_h)
+
+        if transport_data.any?
+          if File.exist?(inventory_file)
+            inventory_data = Bolt::Util.read_yaml_hash(inventory_file, 'inventory')
+            merged = Bolt::Util.deep_merge(transport_data, inventory_data['config'] || {})
+            inventory_data['config'] = merged
+            backup_file(inventory_file, backup_dir)
+          else
+            FileUtils.touch(inventory_file)
+            inventory_data = { 'config' => transport_data }
+          end
+
+          backup_file(config_file, backup_dir)
+
+          begin
+            @outputter.print_action_step(
+              "Moving transportation configuration options '#{transport_data.keys.join(', ')}' "\
+              "from bolt.yaml to inventory.yaml"
+            )
+
+            File.write(inventory_file, inventory_data.to_yaml)
+            File.write(config_file, project_data.to_yaml)
+          rescue StandardError => e
+            raise Bolt::FileError.new("#{e.message}; unable to write inventory.", inventory_file)
+          end
+        end
+
+        @outputter.print_action_step("Renaming bolt.yaml to bolt-project.yaml")
+        FileUtils.mv(config_file, project_file)
+
+        @outputter.print_action_step(
+          "Successfully migrated config. Please add a 'name' key to bolt-project.yaml "\
+          "to use project-level tasks and plans. Learn more about projects by running "\
+          "'bolt guide project'."
+        )
+
+        true
+      end
+    end
+  end
+end

data/lib/bolt/project_migrator/inventory.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'bolt/project_migrator/base'
+
+module Bolt
+  class ProjectMigrator
+    class Inventory < Base
+      def migrate(inventory_file, backup_dir)
+        inventory_1_to_2(inventory_file, backup_dir)
+      end
+
+      # Migrates an inventory v1 file to inventory v2.
+      #
+      private def inventory_1_to_2(inventory_file, backup_dir)
+        unless File.exist?(inventory_file)
+          return true
+        end
+
+        data = Bolt::Util.read_yaml_hash(inventory_file, 'inventory')
+        data.delete('version') if data['version'] != 2
+        migrated = migrate_group(data)
+
+        return true unless migrated
+
+        @outputter.print_message "Migrating inventory\n\n"
+
+        backup_file(inventory_file, backup_dir)
+
+        begin
+          File.write(inventory_file, data.to_yaml)
+          @outputter.print_action_step(
+            "Successfully migrated Bolt inventory to the latest version."
+          )
+          true
+        rescue StandardError => e
+          raise Bolt::FileError.new(
+            "Unable to write to #{inventory_file}: #{e.message}. See "\
+            "http://pup.pt/bolt-inventory to manually update.",
+            inventory_file
+          )
+        end
+      end
+
+      # Walks an inventory hash and replaces all 'nodes' keys with 'targets'
+      # keys and all 'name' keys nested in a 'targets' hash with 'uri' keys.
+      # Data is modified in place.
+      #
+      private def migrate_group(group)
+        migrated = false
+        if group.key?('nodes')
+          migrated = true
+          targets = group['nodes'].map do |target|
+            target['uri'] = target.delete('name') if target.is_a?(Hash)
+            target
+          end
+          group.delete('nodes')
+          group['targets'] = targets
+        end
+        (group['groups'] || []).each do |subgroup|
+          migrated_group = migrate_group(subgroup)
+          migrated ||= migrated_group
+        end
+        migrated
+      end
+    end
+  end
+end

data/lib/bolt/project_migrator/modules.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'bolt/project_migrator/base'
+
+module Bolt
+  class ProjectMigrator
+    class Modules < Base
+      def migrate(project, configured_modulepath)
+        return true unless project.modules.nil?
+
+        @outputter.print_message "Migrating project modules\n\n"
+
+        config            = project.project_file
+        puppetfile        = project.puppetfile
+        managed_moduledir = project.managed_moduledir
+        modulepath        = [(project.path + 'modules').to_s,
+                             (project.path + 'site-modules').to_s,
+                             (project.path + 'site').to_s]
+
+        # Notify user to manually migrate modules if using non-default modulepath
+        if configured_modulepath != modulepath
+          @outputter.print_action_step(
+            "Project has a non-default configured modulepath, unable to automatically "\
+            "migrate project modules. To migrate project modules manually, see "\
+            "http://pup.pt/bolt-modules"
+          )
+          true
+        # Migrate modules from Puppetfile
+        elsif File.exist?(puppetfile)
+          migrate_modules_from_puppetfile(config, puppetfile, managed_moduledir, modulepath)
+        # Migrate modules to updated modulepath
+        else
+          consolidate_modules(modulepath)
+          update_project_config([], config)
+        end
+      end
+
+      # Migrates modules by reading a Puppetfile and prompting the user for
+      # which ones are direct dependencies for the project. Once the user has
+      # selected the direct dependencies, this will resolve the modules, write a
+      # new Puppetfile, install the modules, and then move any remaining modules
+      # to the new moduledir.
+      #
+      private def migrate_modules_from_puppetfile(config, puppetfile_path, managed_moduledir, modulepath)
+        require 'bolt/module_installer/installer'
+        require 'bolt/module_installer/puppetfile'
+        require 'bolt/module_installer/resolver'
+        require 'bolt/module_installer/specs'
+
+        begin
+          @outputter.print_action_step("Parsing Puppetfile at #{puppetfile_path}")
+          puppetfile = Bolt::ModuleInstaller::Puppetfile.parse(puppetfile_path, skip_unsupported_modules: true)
+        rescue Bolt::Error => e
+          @outputter.print_action_error("#{e.message}\nSkipping module migration.")
+          return false
+        end
+
+        # Prompt for direct dependencies
+        modules = select_modules(puppetfile.modules)
+
+        # Create specs to resolve from
+        specs = Bolt::ModuleInstaller::Specs.new(modules.map(&:to_hash))
+
+        # Attempt to resolve dependencies
+        begin
+          @outputter.print_message('')
+          @outputter.print_action_step("Resolving module dependencies, this may take a moment")
+          puppetfile = Bolt::ModuleInstaller::Resolver.new.resolve(specs)
+        rescue Bolt::Error => e
+          @outputter.print_action_error("#{e.message}\nSkipping module migration.")
+          return false
+        end
+
+        migrate_managed_modules(puppetfile, puppetfile_path, managed_moduledir)
+
+        # Move remaining modules to 'modules'
+        consolidate_modules(modulepath)
+
+        # Delete old modules that are now managed
+        delete_modules(modulepath.first, puppetfile.modules)
+
+        # Add modules to project
+        update_project_config(modules.map(&:to_hash), config)
+      end
+
+      # Migrates the managed modules. If modules were selected to be managed,
+      # the Puppetfile is rewritten and modules are installed. If no modules
+      # were selected, the Puppetfile is deleted.
+      #
+      private def migrate_managed_modules(puppetfile, puppetfile_path, managed_moduledir)
+        if puppetfile.modules.any?
+          # Show the new Puppetfile content
+          message  = "Generated new Puppetfile content:\n\n"
+          message += puppetfile.modules.map(&:to_spec).join("\n").to_s
+          @outputter.print_action_step(message)
+
+          # Write Puppetfile
+          @outputter.print_action_step("Updating Puppetfile at #{puppetfile_path}")
+          puppetfile.write(puppetfile_path, managed_moduledir)
+
+          # Install Puppetfile
+          @outputter.print_action_step("Syncing modules from #{puppetfile_path} to #{managed_moduledir}")
+          Bolt::ModuleInstaller::Installer.new.install(puppetfile_path, managed_moduledir)
+        else
+          @outputter.print_action_step(
+            "Project does not include any managed modules, deleting Puppetfile "\
+            "at #{puppetfile_path}"
+          )
+          FileUtils.rm(puppetfile_path)
+        end
+      end
+
+      # Prompts the user to select modules, returning a list of
+      # the selected modules.
+      #
+      private def select_modules(modules)
+        @outputter.print_action_step(
+          "Select modules that are direct dependencies of your project. Bolt will "\
+          "automatically manage dependencies for each module selected, so do not "\
+          "select a module's dependencies unless you use content from it directly "\
+          "in your project."
+        )
+
+        all = Bolt::Util.prompt_yes_no("Select all modules?", @outputter)
+        return modules if all
+
+        modules.select do |mod|
+          Bolt::Util.prompt_yes_no("Select #{mod.full_name}?", @outputter)
+        end
+      end
+
+      # Consolidates all modules on the modulepath to 'modules'.
+      #
+      private def consolidate_modules(modulepath)
+        moduledir, *sources = modulepath
+
+        sources.select! { |source| Dir.exist?(source) }
+
+        if sources.any?
+          @outputter.print_action_step(
+            "Moving modules from #{sources.join(', ')} to #{moduledir}"
+          )
+
+          FileUtils.mkdir_p(moduledir)
+          move_modules(moduledir, sources)
+        end
+      end
+
+      # Moves modules from a list of source directories to the specified
+      # moduledir, deleting the source directory after it's done.
+      #
+      private def move_modules(moduledir, sources)
+        moduledir = Pathname.new(moduledir)
+
+        sources.each do |source|
+          source = Pathname.new(source)
+
+          source.each_child do |mod|
+            next unless mod.directory?
+            next if (moduledir + mod.basename).directory?
+            FileUtils.mv(mod, moduledir)
+          end
+
+          FileUtils.rm_r(source)
+        end
+      end
+
+      # Deletes modules from a specified directory.
+      #
+      private def delete_modules(moduledir, modules)
+        @outputter.print_action_step("Cleaning up #{moduledir}")
+        moduledir = Pathname.new(moduledir)
+
+        modules.each do |mod|
+          path = moduledir + mod.name
+          FileUtils.rm_r(path) if path.directory?
+        end
+      end
+
+      # Adds a list of modules to the project configuration file.
+      #
+      private def update_project_config(modules, config_file)
+        @outputter.print_action_step("Updating project configuration at #{config_file}")
+        data = Bolt::Util.read_optional_yaml_hash(config_file, 'project')
+        data.merge!('modules' => modules)
+        data.delete('modulepath')
+
+        begin
+          File.write(config_file, data.to_yaml)
+          true
+        rescue StandardError => e
+          raise Bolt::FileError.new(
+            "Unable to write to #{config_file}: #{e.message}",
+            config_file
+          )
+        end
+      end
+    end
+  end
+end

data/lib/bolt/result.rb

@@ -7,47 +7,58 @@ module Bolt
   class Result
     attr_reader :target, :value, :action, :object
 
-    def self.from_exception(target, exception, action: 'action')
+    def self.from_exception(target, exception, action: 'action', position: [])
+      details = create_details(position)
       if exception.is_a?(Bolt::Error)
-        error = exception.to_h
+        error = Bolt::Util.deep_merge({ 'details' => details }, exception.to_h)
       else
+        details['class'] = exception.class.to_s
         error = {
           'kind' => 'puppetlabs.tasks/exception-error',
           'issue_code' => 'EXCEPTION',
           'msg' => exception.message,
-          'details' => { 'class' => exception.class.to_s }
+          'details' => details
         }
         error['details']['stack_trace'] = exception.backtrace.join('\n') if exception.backtrace
       end
       Result.new(target, error: error, action: action)
     end
 
-    def self.for_command(target, stdout, stderr, exit_code, action, command)
+    def self.create_details(position)
+      %w[file line].zip(position).to_h.compact
+    end
+
+    def self.for_command(target, stdout, stderr, exit_code, action, command, position)
       value = {
         'stdout' => stdout,
         'stderr' => stderr,
         'exit_code' => exit_code
       }
+
+      details = create_details(position)
       unless exit_code == 0
+        details['exit_code'] = exit_code
         value['_error'] = {
           'kind' => 'puppetlabs.tasks/command-error',
           'issue_code' => 'COMMAND_ERROR',
           'msg' => "The command failed with exit code #{exit_code}",
-          'details' => { 'exit_code' => exit_code }
+          'details' => details
         }
       end
       new(target, value: value, action: action, object: command)
     end
 
-    def self.for_task(target, stdout, stderr, exit_code, task)
+    def self.for_task(target, stdout, stderr, exit_code, task, position)
       stdout.force_encoding('utf-8') unless stdout.encoding == Encoding::UTF_8
+
+      details = create_details(position)
       value = if stdout.valid_encoding?
                 parse_hash(stdout) || { '_output' => stdout }
               else
                 { '_error' => { 'kind' => 'puppetlabs.tasks/task-error',
                                 'issue_code' => 'TASK_ERROR',
                                 'msg' => 'The task result contained invalid UTF-8 on stdout',
-                                'details' => {} } }
+                                'details' => details } }
               end
 
       if exit_code != 0 && value['_error'].nil?
@@ -60,24 +71,26 @@ module Bolt
               else
                 "The task failed with exit code #{exit_code}"
               end
+        details['exit_code'] = exit_code
         value['_error'] = { 'kind' => 'puppetlabs.tasks/task-error',
                             'issue_code' => 'TASK_ERROR',
                             'msg' => msg,
-                            'details' => { 'exit_code' => exit_code } }
+                            'details' => details }
       end
 
       if value.key?('_error')
         unless value['_error'].is_a?(Hash) && value['_error'].key?('msg')
+          details['original_error'] = value['_error']
           value['_error'] = {
             'msg'     => "Invalid error returned from task #{task}: #{value['_error'].inspect}. Error "\
                          "must be an object with a msg key.",
             'kind'    => 'bolt/invalid-task-error',
-            'details' => { 'original_error' => value['_error'] }
+            'details' => details
           }
         end
 
         value['_error']['kind']    ||= 'bolt/error'
-        value['_error']['details'] ||= {}
+        value['_error']['details'] ||= details
       end
 
       if value.key?('_sensitive')
@@ -221,7 +234,6 @@ module Bolt
     def error
       if error_hash
         Puppet::DataTypes::Error.from_asserted_hash(error_hash)
-
       end
     end