vagrant 1.5.0 → 2.4.4

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

@@ -0,0 +1,206 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+require_relative 'download_mixins'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Update < Vagrant.plugin("2", :command)
+        include DownloadMixins
+
+        def execute
+          options = {}
+          download_options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box update [options]"
+            o.separator ""
+            o.separator "Updates the box that is in use in the current Vagrant environment,"
+            o.separator "if there any updates available. This does not destroy/recreate the"
+            o.separator "machine, so you'll have to do that to see changes."
+            o.separator ""
+            o.separator "To update a specific box (not tied to a Vagrant environment), use the"
+            o.separator "--box flag."
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--box BOX", String, "Update a specific box") do |b|
+              options[:box] = b
+            end
+
+            o.on("--architecture ARCHITECTURE", String, "Update box with specific architecture") do |a|
+              options[:architecture] = a
+            end
+
+            o.on("--provider PROVIDER", String, "Update box with specific provider") do |p|
+              options[:provider] = p.to_sym
+            end
+
+            o.on("-f", "--force", "Overwrite an existing box if it exists") do |f|
+              options[:force] = f
+            end
+
+            build_download_options(o, download_options)
+          end
+
+          argv = parse_options(opts)
+          return if !argv
+
+          if options[:box]
+            update_specific(options[:box], options[:provider], options[:architecture], download_options, options[:force])
+          else
+            update_vms(argv, options[:provider], download_options, options[:force])
+          end
+
+          0
+        end
+
+        def update_specific(name, provider, architecture, download_options, force)
+          box_info = Vagrant::Util::HashWithIndifferentAccess.new
+          @env.boxes.all.each do |box_name, box_version, box_provider, box_architecture|
+            next if name != box_name
+            box_info[box_provider] ||= Vagrant::Util::HashWithIndifferentAccess.new
+            box_info[box_provider][box_version] ||= []
+            box_info[box_provider][box_version].push(box_architecture.to_s).uniq!
+          end
+
+          if box_info.empty?
+            raise Vagrant::Errors::BoxNotFound, name: name.to_s
+          end
+
+          if !provider
+            if box_info.size > 1
+              raise Vagrant::Errors::BoxUpdateMultiProvider,
+                name: name.to_s,
+                providers: box_info.keys.map(&:to_s).sort.join(", ")
+            end
+
+            provider = box_info.keys.first
+          elsif !box_info[provider]
+            raise Vagrant::Errors::BoxNotFoundWithProvider,
+              name: name.to_s,
+              provider: provider.to_s,
+              providers: box_info.keys.map(&:to_s).sort.join(", ")
+          end
+
+          version = box_info[provider].keys.sort_by{ |v| Gem::Version.new(v) }.last
+          architecture_list = box_info[provider][version]
+
+          if !architecture
+            if architecture_list.size > 1
+              raise Vagrant::Errors::BoxUpdateMultiArchitecture,
+                name: name.to_s,
+                provider: provider.to_s,
+                version: version.to_s,
+                architectures: architecture_list.sort.join(", ")
+            end
+
+            architecture = architecture_list.first
+          elsif !architecture_list.include?(architecture)
+            raise Vagrant::Errors::BoxNotFoundWithProviderArchitecture,
+              name: name.to_s,
+              provider: provider.to_s,
+              version: version.to_s,
+              architecture: architecture,
+              architectures: architecture_list.sort.join(", ")
+          end
+
+          # Architecture gets cast to a string when collecting information
+          # above. Convert it back to a nil if it's empty
+          architecture = nil if architecture.to_s.empty?
+
+          box = @env.boxes.find(name, provider, version, architecture)
+          box_update(box, "> #{version}", @env.ui, download_options, force)
+        end
+
+        def update_vms(argv, provider, download_options, force)
+          machines = {}
+
+          with_target_vms(argv, provider: provider) do |machine|
+            if !machine.config.vm.box
+              machine.ui.output(I18n.t(
+                "vagrant.errors.box_update_no_name"))
+              next
+            end
+
+            if !machine.box
+              collection = Vagrant::BoxCollection.new(@env.boxes_path)
+              machine.box = collection.find(machine.config.vm.box, provider || machine.provider_name || @env.default_provider, "> 0")
+              if !machine.box
+                machine.ui.output(I18n.t(
+                  "vagrant.errors.box_update_no_box",
+                  name: machine.config.vm.box))
+                next
+              end
+            end
+
+            name     = machine.box.name
+            provider = machine.box.provider
+            version  = machine.config.vm.box_version || machine.box.version
+
+            machines["#{name}_#{provider}_#{version}"] = machine
+          end
+
+          machines.each do |_, machine|
+            box = machine.box
+            version = machine.config.vm.box_version
+            # Get download options from machine configuration if not specified
+            # on the command line.
+            download_options[:ca_cert] ||= machine.config.vm.box_download_ca_cert
+            download_options[:ca_path] ||= machine.config.vm.box_download_ca_path
+            download_options[:client_cert] ||= machine.config.vm.box_download_client_cert
+            if download_options[:insecure].nil?
+              download_options[:insecure] = machine.config.vm.box_download_insecure
+            end
+
+            begin
+              box_update(box, version, machine.ui, download_options, force)
+            rescue Vagrant::Errors::BoxUpdateNoMetadata => e
+              machine.ui.warn(e)
+              next
+            end
+          end
+        end
+
+        def box_update(box, version, ui, download_options, force)
+          ui.output(I18n.t("vagrant.box_update_checking", name: box.name))
+          ui.detail("Latest installed version: #{box.version}")
+          ui.detail("Version constraints: #{version}")
+          ui.detail("Provider: #{box.provider}")
+          ui.detail("Architecture: #{box.architecture.inspect}") if box.architecture
+
+          update = box.has_update?(version, download_options: download_options)
+          if !update
+            ui.success(I18n.t(
+              "vagrant.box_up_to_date_single",
+              name: box.name, version: box.version))
+            return
+          end
+
+          ui.output(I18n.t(
+            "vagrant.box_updating",
+            name: update[0].name,
+            provider: update[2].name,
+            old: box.version,
+            new: update[1].version))
+          @env.action_runner.run(Vagrant::Action.action_box_add, {
+            box_url: box.metadata_url,
+            box_provider: update[2].name,
+            box_version: update[1].version,
+            box_architecture: update[2].architecture,
+            ui: ui,
+            box_force: force,
+            box_download_client_cert: download_options[:client_cert],
+            box_download_ca_cert: download_options[:ca_cert],
+            box_download_ca_path: download_options[:ca_path],
+            box_download_insecure: download_options[:insecure]
+          })
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/plugin.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandBox
+    class Plugin < Vagrant.plugin("2")
+      name "box command"
+      description "The `box` command gives you a way to manage boxes."
+
+      command("box") do
+        require File.expand_path("../command/root", __FILE__)
+        Command::Root
+      end
+    end
+  end
+end

data/plugins/commands/cap/command.rb

@@ -0,0 +1,83 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandCap
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "checks and executes capability"
+      end
+
+      def execute
+        options = {}
+        options[:check] = false
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant cap [options] TYPE NAME [args]"
+          o.separator ""
+          o.separator "This is an advanced command. If you don't know what this"
+          o.separator "does and you aren't explicitly trying to use it, you probably"
+          o.separator "don't want to use this."
+          o.separator ""
+          o.separator "This command checks or executes arbitrary capabilities that"
+          o.separator "Vagrant has for hosts, guests, and providers."
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("--check", "Only checks for a capability, does not execute") do |f|
+            options[:check] = f
+          end
+
+          # TODO: Rename this back to `target` to maintain api
+          o.on("-t", "--target-guest=TARGET", "Target guest to run against (if applicable)") do |t|
+            options[:target] = t
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+        if argv.length < 2
+          raise Vagrant::Errors::CLIInvalidUsage,
+            help: opts.help.chomp
+        end
+
+        type = argv.shift.to_sym
+        name = argv.shift.to_sym
+
+        # Get the proper capability host to check
+        cap_host = nil
+        if type == :host
+          cap_host = @env.host
+        else
+          with_target_vms(options[:target] || []) do |vm|
+            cap_host = case type
+                       when :provider
+                         vm.provider
+                       when :guest
+                         vm.guest
+                       else
+                         raise Vagrant::Errors::CLIInvalidUsage,
+                           help: opts.help.chomp
+                       end
+          end
+        end
+
+        # If we're just checking, then just return exit codes
+        if options[:check]
+          return 0 if cap_host.capability?(name)
+          return 1
+        end
+
+        # Otherwise, call it
+        cap_host.capability(name, *argv)
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/cap/plugin.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandCap
+    class Plugin < Vagrant.plugin("2")
+      name "cap command"
+      description <<-DESC
+      The `cap` command checks and executes arbitrary capabilities.
+      DESC
+
+      command("cap", primary: false) do
+        require_relative "command"
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/cloud/auth/login.rb

@@ -0,0 +1,90 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module AuthCommand
+      module Command
+        class Login < Vagrant.plugin("2", :command)
+          include Util
+
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud auth login [options]"
+              o.separator ""
+              o.separator "Options:"
+              o.separator ""
+              o.on("-c", "--check", "Checks if currently logged in") do |c|
+                options[:check] = c
+              end
+              o.on("-d", "--description DESCRIPTION", String, "Set description for the Vagrant Cloud token") do |d|
+                options[:description] = d
+              end
+
+              o.on("-t", "--token TOKEN", String, "Set the Vagrant Cloud token") do |t|
+                options[:token] = t
+              end
+
+              o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |l|
+                options[:login] = l
+              end
+            end
+
+            # Parse the options
+            argv = parse_options(opts)
+            return if !argv
+            if !argv.empty?
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            client = Client.new(@env)
+            client.username_or_email = options[:login]
+
+            # Determine what task we're actually taking based on flags
+            if options[:check]
+              return execute_check(client)
+            elsif options[:token]
+              return execute_token(client, options[:token])
+            else
+              if client.logged_in?
+                @env.ui.success(I18n.t("cloud_command.check_logged_in"))
+              else
+                client_login(@env, options.slice(:login, :description))
+              end
+            end
+
+            0
+          end
+
+          def execute_check(client)
+            if client.logged_in?
+              @env.ui.success(I18n.t("cloud_command.check_logged_in"))
+              return 0
+            else
+              @env.ui.error(I18n.t("cloud_command.check_not_logged_in"))
+              return 1
+            end
+          end
+
+          def execute_token(client, token)
+            client.store_token(token)
+            @env.ui.success(I18n.t("cloud_command.token_saved"))
+
+            if client.logged_in?
+              @env.ui.success(I18n.t("cloud_command.check_logged_in"))
+              return 0
+            else
+              @env.ui.error(I18n.t("cloud_command.invalid_token"))
+              return 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/auth/logout.rb

@@ -0,0 +1,37 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module AuthCommand
+      module Command
+        class Logout < Vagrant.plugin("2", :command)
+          def execute
+            options = {}
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud auth logout"
+              o.separator ""
+              o.separator "Log out of Vagrant Cloud"
+            end
+
+            # Parse the options
+            argv = parse_options(opts)
+            return if !argv
+            if !argv.empty?
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            @client = Client.new(@env)
+            @client.clear_token
+            @env.ui.success(I18n.t("cloud_command.logged_out"))
+            return 0
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/auth/middleware/add_authentication.rb

@@ -0,0 +1,116 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "cgi"
+require "uri"
+require "log4r"
+
+require Vagrant.source_root.join("plugins/commands/cloud/client/client")
+
+module VagrantPlugins
+  module CloudCommand
+    class AddAuthentication
+      REPLACEMENT_HOSTS = [
+        "app.vagrantup.com".freeze,
+        "atlas.hashicorp.com".freeze
+      ].freeze
+      TARGET_HOST = "vagrantcloud.com".freeze
+      CUSTOM_HOST_NOTIFY_WAIT = 5
+
+      def self.custom_host_notified!
+        @_host_notify = true
+      end
+
+      def self.custom_host_notified?
+        if defined?(@_host_notify)
+          @_host_notify
+        else
+          false
+        end
+      end
+
+      def initialize(app, env)
+        @app = app
+        @logger = Log4r::Logger.new("vagrant::cloud::auth::authenticate-box-url")
+        CloudCommand::Plugin.init!
+      end
+
+      def call(env)
+        if ENV["VAGRANT_SERVER_ACCESS_TOKEN_BY_URL"]
+          @logger.warn("Adding access token as GET parameter by user request")
+          client = Client.new(env[:env])
+          token  = client.token
+
+          env[:box_urls].map! do |url|
+            begin
+              u = URI.parse(url)
+              if u.host != TARGET_HOST && REPLACEMENT_HOSTS.include?(u.host)
+                u.host = TARGET_HOST
+                u.to_s
+              else
+                url
+              end
+            rescue URI::Error
+              url
+            end
+          end
+
+          server_uri = URI.parse(Vagrant.server_url.to_s)
+
+          if token && !server_uri.host.to_s.empty?
+            env[:box_urls].map! do |url|
+              begin
+                u = URI.parse(url)
+
+                if u.host == server_uri.host
+                  if server_uri.host != TARGET_HOST && !self.class.custom_host_notified?
+                    env[:ui].warn(I18n.t("cloud_command.middleware.authentication.different_target",
+                      custom_host: server_uri.host, known_host: TARGET_HOST) + "\n")
+                    sleep CUSTOM_HOST_NOTIFY_WAIT
+                    self.class.custom_host_notified!
+                  end
+
+                  q = CGI.parse(u.query || "")
+
+                  current = q["access_token"]
+                  if current && current.empty?
+                    q["access_token"] = token
+                  end
+
+                  u.query = URI.encode_www_form(q)
+                end
+
+                u.to_s
+              rescue URI::Error
+                url
+              end
+            end
+          end
+        else
+          env[:box_urls].map! do |url|
+            begin
+              u = URI.parse(url)
+              q = CGI.parse(u.query || "")
+              if !q["access_token"].empty?
+                @logger.warn("Removing access token from URL parameter.")
+                q.delete("access_token")
+                if q.empty?
+                  u.query = nil
+                else
+                  u.query = URI.encode_www_form(q)
+                end
+                u.to_s
+              else
+                @logger.warn("Authentication token not found as GET parameter.")
+                url
+              end
+            rescue URI::Error
+              url
+            end
+          end
+        end
+        @app.call(env)
+      end.freeze
+    end
+  end
+end

data/plugins/commands/cloud/auth/middleware/add_downloader_authentication.rb

@@ -0,0 +1,68 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "cgi"
+require "uri"
+require "vagrant/util/credential_scrubber"
+
+require Vagrant.source_root.join("plugins/commands/cloud/client/client")
+require_relative "./add_authentication"
+
+# Similar to AddAuthentication this middleware will add authentication for interacting
+# with Vagrant cloud. It does this by adding Authentication headers to a
+# Vagrant::Util::Downloader object.
+module VagrantPlugins
+  module CloudCommand
+    class AddDownloaderAuthentication <  AddAuthentication
+
+      def initialize(app, env)
+        super
+        @logger = Log4r::Logger.new("vagrant::cloud::auth::add-download-authentication")
+      end
+
+      def call(env)
+        if ENV["VAGRANT_SERVER_ACCESS_TOKEN_BY_URL"]
+          @logger.warn("Authentication header not added due to user requested access token URL parameter")
+        else
+          client = Client.new(env[:env])
+          token  = client.token
+          Vagrant::Util::CredentialScrubber.sensitive(token)
+
+          begin
+            target_url = URI.parse(env[:downloader].source)
+            if target_url.host != TARGET_HOST && REPLACEMENT_HOSTS.include?(target_url.host)
+              target_url.host = TARGET_HOST
+              env[:downloader].source = target_url.to_s
+            end
+          rescue URI::Error
+            # if there is an error, use current target_url
+          end
+
+          server_uri = URI.parse(Vagrant.server_url.to_s)
+          if token && !server_uri.host.to_s.empty?
+            if target_url.host == server_uri.host
+              if server_uri.host != TARGET_HOST && !self.class.custom_host_notified?
+                env[:ui].warn(I18n.t("cloud_command.middleware.authentication.different_target",
+                  custom_host: server_uri.host, known_host: TARGET_HOST) + "\n")
+                sleep CUSTOM_HOST_NOTIFY_WAIT
+                self.class.custom_host_notified!
+              end
+
+              if Array(env[:downloader].headers).any? { |h| h.include?("Authorization") }
+                @logger.info("Not adding an authentication header, one already found")
+              else
+                env[:downloader].headers << "Authorization: Bearer #{token}"
+              end
+            else
+              @logger.debug("Not adding authentication header, host mismatch #{target_url.host} != #{server_uri.host}")
+            end
+
+            env[:downloader]
+          end
+        end
+
+        @app.call(env)
+      end.freeze
+    end
+  end
+end

data/plugins/commands/cloud/auth/plugin.rb

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+
+require "vagrant"
+
+module VagrantPlugins
+  module CloudCommand
+    module AuthCommand
+      class Plugin < Vagrant.plugin("2")
+        name "vagrant cloud auth"
+        description <<-DESC
+        Authorization commands for Vagrant Cloud
+        DESC
+
+        command(:auth) do
+          require_relative "root"
+          Command::Root
+        end
+      end
+    end
+  end
+end