vagrant 1.5.0 → 2.4.4

data/plugins/commands/box/command/list.rb

@@ -0,0 +1,82 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class List < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box list [options]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-i", "--box-info", "Displays additional information about the boxes") do |i|
+              options[:info] = i
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          boxes = @env.boxes.all
+          if boxes.empty?
+            @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), prefix: false)
+            return 0
+          end
+
+          list_boxes(boxes, options[:info])
+
+          # Success, exit status 0
+          0
+        end
+
+        private
+
+        def list_boxes(boxes, extra_info)
+          # Find the longest box name
+          longest_box = boxes.max_by { |x| x[0].length }
+          longest_box_length = longest_box[0].length
+
+          # Group boxes by name and version and start iterating
+          boxes.group_by { |b| [b[0], b[1]] }.each do |box_info, box_data|
+            name, version = box_info
+            # Now group by provider so we can collect common architectures
+            box_data.group_by { |b| b[2] }.each do |provider, data|
+              architectures = data.map { |d| d.last }.compact.sort.uniq
+              meta_info = [provider, version]
+              if !architectures.empty?
+                meta_info << "(#{architectures.join(", ")})"
+              end
+              @env.ui.info("#{name.ljust(longest_box_length)} (#{meta_info.join(", ")})")
+              data.each do |arch_info|
+                @env.ui.machine("box-name", name)
+                @env.ui.machine("box-provider", provider)
+                @env.ui.machine("box-version", version)
+                @env.ui.machine("box-architecture", arch_info.last || "n/a")
+                info_file = @env.boxes.find(name, provider, version, arch_info.last).
+                              directory.join("info.json")
+                if info_file.file?
+                  info = JSON.parse(info_file.read)
+                  info.each do |k, v|
+                    @env.ui.machine("box-info", k, v)
+
+                    if extra_info
+                      @env.ui.info("  - #{k}: #{v}", prefix: false)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/outdated.rb

@@ -0,0 +1,109 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+require_relative 'download_mixins'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Outdated < Vagrant.plugin("2", :command)
+        include DownloadMixins
+
+        def execute
+          options = {}
+          download_options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box outdated [options]"
+            o.separator ""
+            o.separator "Checks if there is a new version available for the box"
+            o.separator "that you are using. If you pass in the --global flag,"
+            o.separator "all boxes will be checked for updates."
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--global", "Check all boxes installed") do |g|
+              options[:global] = g
+            end
+
+            o.on("-f", "--force", "Force checks for latest box updates") do |f|
+              options[:force] = f
+            end
+
+            build_download_options(o, download_options)
+          end
+
+          argv = parse_options(opts)
+          return if !argv
+
+          # If we're checking the boxes globally, then do that.
+          if options[:global]
+            outdated_global(download_options)
+            return 0
+          end
+
+          with_target_vms(argv) do |machine|
+            @env.action_runner.run(Vagrant::Action.action_box_outdated, {
+              box_outdated_force: options[:force],
+              box_outdated_refresh: true,
+              box_outdated_success_ui: true,
+              machine: machine,
+            }.merge(download_options))
+          end
+          return 0
+        end
+
+        def outdated_global(download_options)
+          @env.boxes.all.reverse.each do |name, version, provider|
+            box = @env.boxes.find(name, provider, version)
+            if !box&.metadata_url
+              @env.ui.output(I18n.t(
+                "vagrant.box_outdated_no_metadata",
+                name: name,
+                provider: provider))
+              next
+            end
+
+            md = nil
+            begin
+              md = box.load_metadata(download_options)
+            rescue Vagrant::Errors::BoxMetadataDownloadError => e
+              @env.ui.error(I18n.t(
+                "vagrant.box_outdated_metadata_error",
+                name: box.name,
+                provider: box.provider,
+                message: e.extra_data[:message]))
+              next
+            end
+
+            box_versions = md.versions(provider: box.provider, architecture: box.architecture)
+
+            if box_versions.empty?
+              latest_box_version = box_versions.last.to_i
+            else
+              latest_box_version = box_versions.last
+            end
+
+            if !md.compatible_version_update?(box.version, latest_box_version, provider: box.provider, architecture: box.architecture)
+              @env.ui.success(I18n.t(
+                "vagrant.box_up_to_date",
+                name: box.name,
+                provider: box.provider,
+                version: box.version))
+            else
+              @env.ui.warn(I18n.t(
+                "vagrant.box_outdated",
+                name: box.name,
+                provider: box.provider,
+                current: box.version,
+                latest: latest_box_version.to_s,))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/prune.rb

@@ -0,0 +1,136 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Prune < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+          options[:force] = false
+          options[:dry_run] = false
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box prune [options]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-p PROVIDER", "--provider PROVIDER", String, "The specific provider type for the boxes to destroy.") do |p|
+              options[:provider] = p
+            end
+
+            o.on("-n", "--dry-run", "Only print the boxes that would be removed.") do |f|
+              options[:dry_run] = f
+            end
+
+            o.on("--name NAME", String, "The specific box name to check for outdated versions.") do |name|
+              options[:name] = name
+            end
+
+            o.on("-f", "--force", "Destroy without confirmation even when box is in use.") do |f|
+              options[:force] = f
+            end
+
+            o.on("-k", "--keep-active-boxes", "When combined with `--force`, will keep boxes still actively in use.") do |k|
+              options[:keep] = k
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          boxes = @env.boxes.all.sort
+          if boxes.empty?
+            return @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), prefix: false)
+          end
+
+          delete_oldest_boxes(boxes, options[:provider], options[:force], options[:name], options[:dry_run], options[:keep])
+
+          # Success, exit status 0
+          0
+        end
+
+        private
+
+        def delete_oldest_boxes(boxes, only_provider, skip_confirm, only_name, dry_run, keep_used_boxes)
+          # Find the longest box name
+          longest_box = boxes.max_by { |x| x[0].length }
+          longest_box_length = longest_box[0].length
+
+          # Hash map to keep track of newest versions
+          newest_boxes = Hash.new
+
+          # First find the newest version for every installed box
+          boxes.each do |name, version, provider|
+            next if only_provider and only_provider != provider.to_s
+            next if only_name and only_name != name
+
+            # Nested to make sure it works for boxes with different providers
+            if newest_boxes.has_key?(name)
+              if newest_boxes[name].has_key?(provider)
+                saved = Gem::Version.new(newest_boxes[name][provider])
+                current = Gem::Version.new(version)
+                if current > saved
+                  newest_boxes[name][provider] = version
+                end
+              else
+                newest_boxes[name][provider] = version
+              end
+            else
+              newest_boxes[name] = Hash.new
+              newest_boxes[name][provider] = version
+            end
+          end
+
+          @env.ui.info("The following boxes will be kept...");
+          newest_boxes.each do |name, providers|
+            providers.each do |provider, version|
+              @env.ui.info("#{name.ljust(longest_box_length)} (#{provider}, #{version})")
+
+              @env.ui.machine("box-name", name)
+              @env.ui.machine("box-provider", provider)
+              @env.ui.machine("box-version", version)
+            end
+          end
+
+          @env.ui.info("", prefix: false)
+          @env.ui.info("Checking for older boxes...");
+
+          # Track if we removed anything so the user can be informed
+          removed_any_box = false
+          boxes.each do |name, version, provider|
+            next if !newest_boxes.has_key?(name) or !newest_boxes[name].has_key?(provider)
+
+            current = Gem::Version.new(version)
+            saved = Gem::Version.new(newest_boxes[name][provider])
+            if current < saved
+              removed_any_box = true
+
+              # Use the remove box action
+              if dry_run
+                @env.ui.info("Would remove #{name} #{provider} #{version}")
+              else
+                @env.action_runner.run(Vagrant::Action.action_box_remove, {
+                    box_name: name,
+                    box_provider: provider,
+                    box_version: version,
+                    force_confirm_box_remove: skip_confirm,
+                    keep_used_boxes: keep_used_boxes,
+                    box_remove_all_versions: false,
+                })
+              end
+            end
+          end
+
+          if !removed_any_box
+            @env.ui.info("No old versions of boxes to remove...");
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/remove.rb

@@ -0,0 +1,83 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Remove < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+          options[:force] = false
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box remove <name>"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-f", "--force", "Remove without confirmation.") do |f|
+              options[:force] = f
+            end
+
+            o.on("-a", "--architecture ARCH", String, "The specific architecture for the box to remove") do |a|
+              options[:architecture] = a
+            end
+            o.on("--provider PROVIDER", String,
+                 "The specific provider type for the box to remove") do |p|
+              options[:provider] = p
+            end
+
+            o.on("--box-version VERSION", String,
+                 "The specific version of the box to remove") do |v|
+              options[:version] = v
+            end
+
+            o.on("--all", "Remove all available versions of the box") do |a|
+              options[:all] = a
+            end
+
+            o.on("--all-providers", "Remove all providers within a version of the box") do |a|
+              options[:all_providers] = a
+            end
+
+            o.on("--all-architectures", "Remove all architectures within a provider a version of the box") do |a|
+              options[:all_architectures] = a
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          if argv.empty? || argv.length > 2
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          if argv.length == 2
+            # @deprecated
+            @env.ui.warn("WARNING: The second argument to `vagrant box remove`")
+            @env.ui.warn("is deprecated. Please use the --provider flag. This")
+            @env.ui.warn("feature will stop working in the next version.")
+            options[:provider] = argv[1]
+          end
+
+          @env.action_runner.run(Vagrant::Action.action_box_remove, {
+            box_name:     argv[0],
+            box_architecture: options[:architecture],
+            box_provider: options[:provider],
+            box_version:  options[:version],
+            force_confirm_box_remove: options[:force],
+            box_remove_all_versions: options[:all],
+            box_remove_all_providers: options[:all_providers],
+            box_remove_all_architectures: options[:all_architectures]
+          })
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/repackage.rb

@@ -0,0 +1,46 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require 'optparse'
+require "pathname"
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Repackage < Vagrant.plugin("2", :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box repackage <name> <provider> <version>"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length != 3
+
+          box_name     = argv[0]
+          box_provider = argv[1].to_sym
+          box_version  = argv[2]
+
+          # Verify the box exists that we want to repackage
+          box = @env.boxes.find(box_name, box_provider, "= #{box_version}")
+          if !box
+            raise Vagrant::Errors::BoxNotFoundWithProviderAndVersion,
+              name: box_name,
+              provider: box_provider.to_s,
+              version: box_version
+          end
+
+          # Repackage the box
+          output_name = @env.vagrantfile.config.package.name || "package.box"
+          output_path = Pathname.new(File.expand_path(output_name, FileUtils.pwd))
+          box.repackage(output_path)
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/root.rb

@@ -0,0 +1,98 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "manages boxes: installation, removal, etc."
+        end
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:add) do
+            require File.expand_path("../add", __FILE__)
+            Add
+          end
+
+          @subcommands.register(:list) do
+            require File.expand_path("../list", __FILE__)
+            List
+          end
+
+          @subcommands.register(:outdated) do
+            require_relative "outdated"
+            Outdated
+          end
+
+          @subcommands.register(:remove) do
+            require File.expand_path("../remove", __FILE__)
+            Remove
+          end
+
+          @subcommands.register(:prune) do
+            require_relative "prune"
+            Prune
+          end
+
+          @subcommands.register(:repackage) do
+            require File.expand_path("../repackage", __FILE__)
+            Repackage
+          end
+
+          @subcommands.register(:update) do
+            require_relative "update"
+            Update
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the box commands.
+            return help
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        def help
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant box <subcommand> [<args>]"
+            if !Vagrant.server_mode?
+              opts.separator ""
+              opts.separator "Available subcommands:"
+
+              # Add the available subcommands as separators in order to print them
+              # out as well.
+              keys = []
+              @subcommands.each { |key, value| keys << key.to_s }
+
+              keys.sort.each do |key|
+                opts.separator "     #{key}"
+              end
+            end
+            opts.separator ""
+            opts.separator "For help on any individual subcommand run `vagrant box <subcommand> -h`"
+          end
+
+          @env.ui.info(opts.help, prefix: false)
+        end
+      end
+    end
+  end
+end