bolt 2.25.0 → 2.30.0

data/lib/bolt/project_migrator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'bolt/project_migrator/config'
+require 'bolt/project_migrator/inventory'
+require 'bolt/project_migrator/modules'
+
+module Bolt
+  class ProjectMigrator
+    def initialize(config, outputter)
+      @config    = config
+      @outputter = outputter
+    end
+
+    def migrate
+      unless $stdin.tty?
+        raise Bolt::Error.new(
+          "stdin is not a tty, unable to migrate project",
+          'bolt/stdin-not-a-tty-error'
+        )
+      end
+
+      @outputter.print_message("Migrating project #{@config.project.path}\n\n")
+
+      @outputter.print_migrate_step(
+        "Migrating a Bolt project may make irreversible changes to the project's "\
+        "configuration and inventory files. Before continuing, make sure the "\
+        "project has a backup or uses a version control system."
+      )
+
+      return 0 unless Bolt::Util.prompt_yes_no("Continue with project migration?", @outputter)
+
+      @outputter.print_message('')
+
+      ok = migrate_inventory && migrate_config && migrate_modules
+
+      if ok
+        @outputter.print_message("Project successfully migrated")
+      else
+        @outputter.print_error("Project could not be migrated completely")
+      end
+
+      ok ? 0 : 1
+    end
+
+    # Migrates the project-level configuration file to the latest version.
+    #
+    private def migrate_config
+      migrator = Bolt::ProjectMigrator::Config.new(@outputter)
+
+      migrator.migrate(
+        @config.project.config_file,
+        @config.project.project_file,
+        @config.inventoryfile || @config.project.inventory_file,
+        @config.project.backup_dir
+      )
+    end
+
+    # Migrates the inventory file to the latest version.
+    #
+    private def migrate_inventory
+      migrator = Bolt::ProjectMigrator::Inventory.new(@outputter)
+
+      migrator.migrate(
+        @config.inventoryfile || @config.project.inventory_file,
+        @config.project.backup_dir
+      )
+    end
+
+    # Migrates the project's modules to use current best practices.
+    #
+    private def migrate_modules
+      migrator = Bolt::ProjectMigrator::Modules.new(@outputter)
+
+      migrator.migrate(
+        @config.project,
+        @config.modulepath
+      )
+    end
+  end
+end

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_migrate_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_migrate_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_migrate_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_migrate_step("Renaming bolt.yaml to bolt-project.yaml")
+        FileUtils.mv(config_file, project_file)
+
+        @outputter.print_migrate_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_migrate_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,198 @@
+# 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_migrate_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/puppetfile'
+        require 'bolt/puppetfile/installer'
+
+        begin
+          @outputter.print_migrate_step("Parsing Puppetfile at #{puppetfile_path}")
+          puppetfile = Bolt::Puppetfile.parse(puppetfile_path, skip_unsupported_modules: true)
+        rescue Bolt::Error => e
+          @outputter.print_migrate_error("#{e.message}\nSkipping module migration.")
+          return false
+        end
+
+        # Prompt for direct dependencies
+        modules = select_modules(puppetfile.modules)
+
+        # Create new Puppetfile object
+        puppetfile = Bolt::Puppetfile.new(modules)
+
+        # Attempt to resolve dependencies
+        begin
+          @outputter.print_message('')
+          @outputter.print_migrate_step("Resolving module dependencies, this may take a moment")
+          puppetfile.resolve
+        rescue Bolt::Error => e
+          @outputter.print_migrate_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_migrate_step(message)
+
+          # Write Puppetfile
+          @outputter.print_migrate_step("Updating Puppetfile at #{puppetfile_path}")
+          puppetfile.write(puppetfile_path, managed_moduledir)
+
+          # Install Puppetfile
+          @outputter.print_migrate_step("Syncing modules from #{puppetfile_path} to #{managed_moduledir}")
+          Bolt::Puppetfile::Installer.new({}).install(puppetfile_path, managed_moduledir)
+        else
+          @outputter.print_migrate_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_migrate_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.title}?", @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_migrate_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_migrate_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_migrate_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