vagrant 1.5.0 → 2.4.4

data/plugins/commands/init/plugin.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandInit
+    class Plugin < Vagrant.plugin("2")
+      name "init command"
+      description <<-DESC
+      The `init` command sets up your working directory to be a
+      Vagrant-managed environment.
+      DESC
+
+      command("init") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "optparse"
+
+module VagrantPlugins
+  module CommandListCommands
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "outputs all available Vagrant subcommands, even non-primary ones"
+      end
+
+      def execute
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant list-commands"
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+
+        # Add the available subcommands as separators in order to print them
+        # out as well.
+        commands = {}
+        longest = 0
+        Vagrant.plugin("2").manager.commands.each do |key, data|
+          key           = key.to_s
+          klass         = data[0].call
+          commands[key] = klass.synopsis
+          longest       = key.length if key.length > longest
+        end
+
+        command_output = []
+        commands.keys.sort.each do |key|
+          command_output << "#{key.ljust(longest+2)} #{commands[key]}"
+          @env.ui.machine("cli-command", key.dup)
+        end
+
+        @env.ui.info(
+          I18n.t("vagrant.list_commands", list: command_output.join("\n")))
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/list-commands/plugin.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandListCommands
+    class Plugin < Vagrant.plugin("2")
+      name "list-commands command"
+      description <<-DESC
+      The `list-commands` command will list all commands that Vagrant
+      understands, even hidden ones.
+      DESC
+
+      command("list-commands", primary: false) do
+        require_relative "command"
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/login/plugin.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module LoginCommand
+    class Plugin < Vagrant.plugin("2")
+      name "vagrant-login"
+      description <<-DESC
+      Provides the login command and internal API access to Vagrant Cloud.
+      DESC
+
+      command(:login) do
+        require File.expand_path("../../cloud/auth/login", __FILE__)
+        VagrantPlugins::CloudCommand::AuthCommand::Command::Login
+      end
+    end
+  end
+end

data/plugins/commands/package/command.rb

@@ -0,0 +1,104 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+require 'securerandom'
+
+module VagrantPlugins
+  module CommandPackage
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "packages a running vagrant environment into a box"
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant package [options] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("--base NAME", "Name of a VM in VirtualBox to package as a base box (VirtualBox Only)") do |b|
+            options[:base] = b
+          end
+
+          o.on("--output NAME", "Name of the file to output") do |output|
+            options[:output] = output
+          end
+
+          o.on("--include FILE,FILE..", Array, "Comma separated additional files to package with the box") do |i|
+            options[:include] = i
+          end
+
+          o.on("--info FILE", "Path to a custom info.json file containing additional box information") do |info|
+            options[:info] = info
+          end
+
+          o.on("--vagrantfile FILE", "Vagrantfile to package with the box") do |v|
+            options[:vagrantfile] = v
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("package options: #{options.inspect}")
+        if options[:base]
+          package_base(options)
+        else
+          package_target(argv[0], options)
+        end
+
+        # Success, exit status 0
+        0
+      end
+
+      protected
+
+      def package_base(options)
+        # XXX: This whole thing is hardcoded and very temporary. The whole
+        # `vagrant package --base` process is deprecated for something much
+        # better in the future. We just hardcode this to keep VirtualBox working
+        # for now.
+        provider = Vagrant.plugin("2").manager.providers[:virtualbox]
+        tmp_data_directory = File.join(@env.tmp_path, SecureRandom.uuid)
+        FileUtils.mkdir_p(tmp_data_directory)
+        begin
+          vm = Vagrant::Machine.new(
+            options[:base],
+            :virtualbox, provider[0], nil, provider[1],
+            @env.vagrantfile.config,
+            Pathname.new(tmp_data_directory), nil,
+            @env, @env.vagrantfile, true)
+          @logger.debug("Packaging base VM: #{vm.name}")
+          package_vm(vm, options)
+        ensure
+          FileUtils.rm_rf(tmp_data_directory)
+        end
+      end
+
+      def package_target(name, options)
+        with_target_vms(name, single_target: true) do |vm|
+          @logger.debug("Packaging VM: #{vm.name}")
+          package_vm(vm, options)
+        end
+      end
+
+      def package_vm(vm, options)
+        opts = options.inject({}) do |acc, data|
+          k,v = data
+          acc["package.#{k}"] = v
+          acc
+        end
+
+        env = vm.action(:package, opts)
+        temp_dir = env["export.temp_dir"]
+      ensure
+        FileUtils.rm_rf(temp_dir) if temp_dir
+      end
+    end
+  end
+end

data/plugins/commands/package/plugin.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandPackage
+    class Plugin < Vagrant.plugin("2")
+      name "package command"
+      description <<-DESC
+      The `package` command will take a previously existing Vagrant
+      environment and package it into a box file.
+      DESC
+
+      command("package") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/expunge_plugins.rb

@@ -0,0 +1,77 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/plugin/manager"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware removes user installed plugins by
+      # removing:
+      #   * ~/.vagrant.d/plugins.json
+      #   * ~/.vagrant.d/gems
+      # Usage should be restricted to when a repair is
+      # unsuccessful and the only reasonable option remaining
+      # is to re-install all plugins
+      class ExpungePlugins
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if !env[:force]
+
+            result = nil
+            attempts = 0
+            while attempts < 5 && result.nil?
+              attempts += 1
+              result = env[:ui].ask(
+                I18n.t("vagrant.commands.plugin.expunge_confirm") +
+                  " [N]: "
+              )
+              result = result.to_s.downcase.strip
+              result = "n" if result.empty?
+              if !["y", "yes", "n", "no"].include?(result)
+                result = nil
+                env[:ui].error("Please answer Y or N")
+              else
+                result = result[0,1]
+              end
+            end
+
+            if result != 'y'
+              abort_action = true
+            end
+          end
+
+          if !abort_action
+            files = []
+            dirs = []
+
+            # Do not include global paths if local only
+            if !env[:env_local_only] || env[:global_only]
+              files << Vagrant::Plugin::Manager.instance.user_file.path
+              dirs << Vagrant::Bundler.instance.plugin_gem_path
+            end
+
+            # Add local paths if they exist
+            if Vagrant::Plugin::Manager.instance.local_file && (env[:env_local_only] || !env[:global_only])
+              files << Vagrant::Plugin::Manager.instance.local_file.path
+              dirs << Vagrant::Bundler.instance.env_plugin_gem_path
+            end
+
+            # Expunge files and directories
+            files.find_all(&:exist?).map(&:delete)
+            dirs.find_all(&:exist?).map(&:rmtree)
+
+            env[:ui].info(I18n.t("vagrant.commands.plugin.expunge_complete"))
+
+            @app.call(env)
+          else
+            env[:ui].info(I18n.t("vagrant.commands.plugin.expunge_aborted"))
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/install_gem.rb

@@ -0,0 +1,80 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This action takes the `:plugin_name` variable in the environment
+      # and installs it using the RubyGems API.
+      class InstallGem
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::installgem")
+        end
+
+        def call(env)
+          entrypoint  = env[:plugin_entry_point]
+          plugin_name = env[:plugin_name]
+          sources     = env[:plugin_sources]
+          version     = env[:plugin_version]
+          env_local   = env[:plugin_env_local]
+
+          # Install the gem
+          plugin_name_label = plugin_name
+          plugin_name_label += " --version '#{version}'" if version
+          env[:ui].info(I18n.t("vagrant.commands.plugin.installing",
+                               name: plugin_name_label))
+
+          manager = Vagrant::Plugin::Manager.instance
+          plugin_spec = manager.install_plugin(
+            plugin_name,
+            version:   version,
+            require:   entrypoint,
+            sources:   sources,
+            verbose:   !!env[:plugin_verbose],
+            env_local: env_local
+          )
+
+          # Record it so we can uninstall if something goes wrong
+          @installed_plugin_name = plugin_spec.name
+
+          # Tell the user
+          env[:ui].success(I18n.t("vagrant.commands.plugin.installed",
+                                  name: plugin_spec.name,
+                                  version: plugin_spec.version.to_s))
+
+          # If the plugin's spec includes a post-install message display it
+          post_install_message = plugin_spec.post_install_message
+          if post_install_message
+            if post_install_message.is_a?(Array)
+              post_install_message = post_install_message.join(" ")
+            end
+
+            env[:ui].info(I18n.t("vagrant.commands.plugin.post_install",
+                                 name: plugin_spec.name,
+                                 message: post_install_message.to_s))
+          end
+
+          # Continue
+          @app.call(env)
+        end
+
+        def recover(env)
+          # If any error happens, we uninstall it and remove it from
+          # the state file. We can only do this if we successfully installed
+          # the gem in the first place.
+          if @installed_plugin_name
+            new_env = env.dup
+            new_env.delete(:interrupted)
+            new_env[:plugin_name] = @installed_plugin_name
+            new_env[:action_runner].run(Action.action_uninstall, new_env)
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/license_plugin.rb

@@ -0,0 +1,48 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "fileutils"
+require "pathname"
+require "rubygems"
+require "set"
+
+require "log4r"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware licenses a plugin by copying the license file to
+      # the proper place.
+      class LicensePlugin
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::license")
+        end
+
+        def call(env)
+          # Verify the license file exists
+          license_file = Pathname.new(env[:plugin_license_path])
+          if !license_file.file?
+            raise Vagrant::Errors::PluginInstallLicenseNotFound,
+              name: env[:plugin_name],
+              path: license_file.to_s
+          end
+
+          # Copy it in.
+          final_path = env[:home_path].join("license-#{env[:plugin_name]}.lic")
+          @logger.info("Copying license from: #{license_file}")
+          @logger.info("Copying license to: #{final_path}")
+          env[:ui].info(I18n.t("vagrant.commands.plugin.installing_license",
+                               name: env[:plugin_name]))
+          FileUtils.cp(license_file, final_path)
+
+          # Installed!
+          env[:ui].success(I18n.t("vagrant.commands.plugin.installed_license",
+                                 name: env[:plugin_name]))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/list_plugins.rb

@@ -0,0 +1,79 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/plugin/manager"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware lists all the installed plugins.
+      #
+      # This is a bit more complicated than simply listing installed
+      # gems or what is in the state file as installed. Instead, this
+      # actually compares installed gems with what the state file claims
+      # is installed, and outputs the appropriate truly installed
+      # plugins.
+      class ListPlugins
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          manager = Vagrant::Plugin::Manager.instance
+          plugins = manager.installed_plugins
+          specs   = Hash[
+            manager.installed_specs.map do |spec|
+              [spec.name, spec]
+            end
+          ]
+
+          # Output!
+          if specs.empty?
+            env[:ui].info(I18n.t("vagrant.commands.plugin.no_plugins"))
+            return @app.call(env)
+          end
+
+          plugins.each do |plugin_name, plugin|
+
+            spec = specs[plugin_name]
+            next if spec.nil?
+
+            meta = ", global"
+            if plugin
+              meta = ", system" if plugin["system"]
+              meta = ", local" if plugin["env_local"]
+            end
+            env[:ui].info "#{spec.name} (#{spec.version}#{meta})"
+            env[:ui].machine("plugin-name", spec.name)
+            env[:ui].machine(
+              "plugin-version",
+              "#{spec.version}#{meta}",
+              target: spec.name)
+
+            if plugin["gem_version"] && plugin["gem_version"] != ""
+              env[:ui].info(I18n.t(
+                "vagrant.commands.plugin.plugin_version",
+                version: plugin["gem_version"]))
+              env[:ui].machine(
+                "plugin-version-constraint",
+                plugin["gem_version"],
+                target: spec.name)
+            end
+
+            if plugin["require"] && plugin["require"] != ""
+              env[:ui].info(I18n.t(
+                "vagrant.commands.plugin.plugin_require",
+                require: plugin["require"]))
+              env[:ui].machine(
+                "plugin-custom-entrypoint",
+                plugin["require"],
+                target: spec.name)
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/plugin_exists_check.rb

@@ -0,0 +1,28 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/plugin/manager"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This class checks to see if the plugin is installed already, and
+      # if so, raises an exception/error to output to the user.
+      class PluginExistsCheck
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          installed = Vagrant::Plugin::Manager.instance.installed_plugins
+          if !installed.key?(env[:plugin_name])
+            raise Vagrant::Errors::PluginNotInstalled,
+              name: env[:plugin_name]
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/repair_plugins.rb

@@ -0,0 +1,67 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/plugin/manager"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware attempts to repair installed plugins.
+      #
+      # In general, if plugins are failing to properly load the
+      # core issue will likely be one of two issues:
+      #   1. manual modifications within ~/.vagrant.d/
+      #   2. vagrant upgrade
+      # Running an install on configured plugin set will most
+      # likely fix these issues, which is all this action does.
+      class RepairPlugins
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::repair")
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant.commands.plugin.repairing"))
+          plugins = Vagrant::Plugin::Manager.instance.globalize!
+          begin
+            ENV["VAGRANT_DISABLE_PLUGIN_INIT"] = nil
+            Vagrant::Bundler.instance.init!(plugins, :repair)
+            ENV["VAGRANT_DISABLE_PLUGIN_INIT"] = "1"
+            env[:ui].info(I18n.t("vagrant.commands.plugin.repair_complete"))
+          rescue => e
+            @logger.error("Failed to repair user installed plugins: #{e.class} - #{e}")
+            e.backtrace.each do |backtrace_line|
+              @logger.debug(backtrace_line)
+            end
+            env[:ui].error(I18n.t("vagrant.commands.plugin.repair_failed", message: e.message))
+          end
+          # Continue
+          @app.call(env)
+        end
+      end
+
+      class RepairPluginsLocal
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::repair_local")
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant.commands.plugin.repairing_local"))
+          Vagrant::Plugin::Manager.instance.localize!(env[:env]).each_pair do |pname, pinfo|
+            env[:env].action_runner.run(Action.action_install,
+              plugin_name: pname,
+              plugin_entry_point: pinfo["require"],
+              plugin_sources: pinfo["sources"],
+              plugin_version: pinfo["gem_version"],
+              plugin_env_local: true
+            )
+          end
+          env[:ui].info(I18n.t("vagrant.commands.plugin.repair_local_complete"))
+          # Continue
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/uninstall_plugin.rb

@@ -0,0 +1,28 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware uninstalls a plugin by simply removing it from
+      # the state file. Running a {PruneGems} after should properly remove
+      # it from the gem index.
+      class UninstallPlugin
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Remove it!
+          env[:ui].info(I18n.t("vagrant.commands.plugin.uninstalling",
+                               name: env[:plugin_name]))
+
+          manager = Vagrant::Plugin::Manager.instance
+          manager.uninstall_plugin(env[:plugin_name], env_local: env[:env_local])
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end