vagrant 1.5.0 → 2.4.4

data/plugins/commands/cloud/client/client.rb

@@ -0,0 +1,257 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant_cloud"
+require "vagrant/util/downloader"
+require "vagrant/util/presence"
+
+require Vagrant.source_root.join("plugins/commands/cloud/errors")
+
+module VagrantPlugins
+  module CloudCommand
+    class Client
+      # @private
+      # Reset the cached values for scrubber. This is not considered a public
+      # API and should only be used for testing.
+      def self.reset!
+        class_variables.each(&method(:remove_class_variable))
+      end
+
+      ######################################################################
+      # Class that deals with managing users 'local' token for Vagrant Cloud
+      ######################################################################
+      APP = "app".freeze
+
+      include Util
+      include Vagrant::Util::Presence
+
+      attr_accessor :client
+      attr_accessor :username_or_email
+      attr_accessor :password
+      attr_reader :two_factor_default_delivery_method
+      attr_reader :two_factor_delivery_methods
+
+      # Initializes a login client with the given Vagrant::Environment.
+      #
+      # @param [Vagrant::Environment] env
+      def initialize(env)
+        @logger = Log4r::Logger.new("vagrant::cloud::client")
+        @env    = env
+        if !defined?(@@client)
+          @@client = VagrantCloud::Client.new(
+            access_token: token,
+            url_base: api_server_url
+          )
+        end
+        @client = @@client
+      end
+
+      # Removes the token, effectively logging the user out.
+      def clear_token
+        @logger.info("Clearing token")
+        token_path.delete if token_path.file?
+      end
+
+      # Checks if the user is logged in by verifying their authentication
+      # token.
+      #
+      # @return [Boolean]
+      def logged_in?
+        return false if !client&.access_token
+
+        Vagrant::Util::CredentialScrubber.sensitive(client.access_token)
+
+        with_error_handling do
+          client.authentication_token_validate
+          true
+        end
+      rescue Errors::Unauthorized
+        false
+      end
+
+      # Login logs a user in and returns the token for that user. The token
+      # is _not_ stored unless {#store_token} is called.
+      #
+      # @param [String] description
+      # @param [String] code
+      # @return [String] token The access token, or nil if auth failed.
+      def login(description: nil, code: nil)
+        @logger.info("Logging in '#{username_or_email}'")
+
+        Vagrant::Util::CredentialScrubber.sensitive(password)
+        with_error_handling do
+          r = client.authentication_token_create(username: username_or_email,
+            password: password, description: description, code: code)
+
+          Vagrant::Util::CredentialScrubber.sensitive(r[:token])
+          @client = VagrantCloud::Client.new(
+            access_token: r[:token],
+            url_base: api_server_url
+          )
+          r[:token]
+        end
+      end
+
+      # Requests a 2FA code
+      # @param [String] delivery_method
+      def request_code(delivery_method)
+        @env.ui.warn("Requesting 2FA code via #{delivery_method.upcase}...")
+
+        Vagrant::Util::CredentialScrubber.sensitive(password)
+        with_error_handling do
+          r = client.authentication_request_2fa_code(
+            username: username_or_email, password: password, delivery_method: delivery_method)
+
+          two_factor = r[:two_factor]
+          obfuscated_destination = two_factor[:obfuscated_destination]
+
+          @env.ui.success("2FA code sent to #{obfuscated_destination}.")
+        end
+      end
+
+      # Stores the given token locally, removing any previous tokens.
+      #
+      # @param [String] token
+      def store_token(token)
+        Vagrant::Util::CredentialScrubber.sensitive(token)
+        @logger.info("Storing token in #{token_path}")
+
+        token_path.open("w") do |f|
+          f.write(token)
+        end
+
+        # Reset after we store the token since this is now _our_ token
+        @client = VagrantCloud::Client.new(access_token: token, url_base: api_server_url)
+
+        nil
+      end
+
+      # Reads the access token if there is one. This will first read the
+      # `VAGRANT_CLOUD_TOKEN` environment variable and then fallback to the stored
+      # access token on disk.
+      #
+      # @return [String]
+      def token
+        # If the client is defined, use the client for the access token
+        # to allow proper token generation if required
+        return client.access_token if client && !client.access_token.nil?
+
+        if present?(ENV["VAGRANT_CLOUD_TOKEN"]) && token_path.exist?
+          # Only show warning if it has not been previously shown
+          if !defined?(@@double_token_warning)
+            @env.ui.warn <<-EOH.strip
+Vagrant detected both the VAGRANT_CLOUD_TOKEN environment variable and a Vagrant login
+token are present on this system. The VAGRANT_CLOUD_TOKEN environment variable takes
+precedence over the locally stored token. To remove this error, either unset
+the VAGRANT_CLOUD_TOKEN environment variable or remove the login token stored on disk:
+
+    ~/.vagrant.d/data/vagrant_login_token
+
+EOH
+            @@double_token_warning = true
+          end
+        end
+
+        if present?(ENV["VAGRANT_CLOUD_TOKEN"])
+          @logger.debug("Using authentication token from environment variable")
+          t = ENV["VAGRANT_CLOUD_TOKEN"]
+        elsif token_path.exist?
+          @logger.debug("Using authentication token from disk at #{token_path}")
+          t = token_path.read.strip
+        elsif present?(ENV["ATLAS_TOKEN"])
+          @logger.warn("ATLAS_TOKEN detected within environment. Using ATLAS_TOKEN in place of VAGRANT_CLOUD_TOKEN.")
+          t = ENV["ATLAS_TOKEN"]
+        end
+
+        if !t.nil?
+          Vagrant::Util::CredentialScrubber.sensitive(t)
+          return t
+        end
+
+        @logger.debug("No authentication token in environment or #{token_path}")
+
+        nil
+      end
+
+      protected
+
+      def with_error_handling(&block)
+        yield
+      rescue VagrantCloud::Error::ClientError => e
+        @logger.debug("vagrantcloud request error:")
+        @logger.debug(e.message)
+        @logger.debug(e.backtrace.join("\n"))
+        raise Errors::Unexpected, error: e.message
+      rescue Excon::Error::Unauthorized
+        @logger.debug("Unauthorized!")
+        raise Errors::Unauthorized
+      rescue Excon::Error::BadRequest => e
+        @logger.debug("Bad request:")
+        @logger.debug(e.message)
+        @logger.debug(e.backtrace.join("\n"))
+        parsed_response = JSON.parse(e.response.body)
+        errors = parsed_response["errors"].join("\n")
+        raise Errors::ServerError, errors: errors
+      rescue Excon::Error::NotAcceptable => e
+        @logger.debug("Got unacceptable response:")
+        @logger.debug(e.message)
+        @logger.debug(e.backtrace.join("\n"))
+
+        parsed_response = JSON.parse(e.response.body)
+
+        if two_factor = parsed_response['two_factor']
+          store_two_factor_information two_factor
+
+          if two_factor_default_delivery_method != APP
+            request_code two_factor_default_delivery_method
+          end
+
+          raise Errors::TwoFactorRequired
+        end
+
+        begin
+          errors = parsed_response["errors"].join("\n")
+          raise Errors::ServerError, errors: errors
+        rescue JSON::ParserError; end
+
+        @logger.debug("Got an unexpected error:")
+        @logger.debug(e.inspect)
+        raise Errors::Unexpected, error: e.inspect
+      rescue SocketError
+        @logger.info("Socket error")
+        raise Errors::ServerUnreachable, url: Vagrant.server_url.to_s
+      end
+
+      def token_path
+        @env.data_dir.join("vagrant_login_token")
+      end
+
+      def store_two_factor_information(two_factor)
+        @two_factor_default_delivery_method =
+          two_factor['default_delivery_method']
+
+        @two_factor_delivery_methods =
+          two_factor['delivery_methods']
+
+        @env.ui.warn "2FA is enabled for your account."
+        if two_factor_default_delivery_method == APP
+          @env.ui.info "Enter the code from your authenticator."
+        else
+          @env.ui.info "Default method is " \
+            "'#{two_factor_default_delivery_method}'."
+        end
+
+        other_delivery_methods =
+          two_factor_delivery_methods - [APP]
+
+        if other_delivery_methods.any?
+          other_delivery_methods_sentence = other_delivery_methods
+            .map { |word| "'#{word}'" }
+            .join(' or ')
+          @env.ui.info "You can also type #{other_delivery_methods_sentence} " \
+            "to request a new code."
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/errors.rb

@@ -0,0 +1,31 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module CloudCommand
+    module Errors
+      class Error < Vagrant::Errors::VagrantError
+        error_namespace("cloud_command.errors")
+      end
+
+      class ServerError < Error
+        error_key(:server_error)
+      end
+
+      class ServerUnreachable < Error
+        error_key(:server_unreachable)
+      end
+
+      class Unauthorized < Error
+        error_key(:unauthorized)
+      end
+
+      class Unexpected < Error
+        error_key(:unexpected_error)
+      end
+
+      class TwoFactorRequired < Error
+      end
+    end
+  end
+end

data/plugins/commands/cloud/list.rb

@@ -0,0 +1,54 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module Command
+      class List < Vagrant.plugin("2", :command)
+        include Util
+
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant cloud list [options] organization"
+            o.separator ""
+            o.separator "Search for boxes managed by a specific user/organization"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("-j", "--json", "Formats results in JSON") do |j|
+              options[:check] = j
+            end
+            o.on("-l", "--limit", Integer, "Max number of search results (default is 25)") do |l|
+              options[:check] = l
+            end
+            o.on("-p", "--provider", "Comma separated list of providers to filter search. Defaults to all.") do |p|
+              options[:check] = p
+            end
+            o.on("-s", "--sort-by", "Column to sort list (created, downloads, updated)") do |s|
+              options[:check] = s
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          if argv.length > 1
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          @client = client_login(@env)
+
+          # TODO: This endpoint is not implemented yet
+
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/cloud/locales/en.yml

@@ -0,0 +1,197 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+en:
+  cloud_command:
+    middleware:
+      authentication:
+        different_target: |-
+          Vagrant has detected a custom Vagrant server in use for downloading
+          box files. An authentication token is currently set which will be
+          added to the box request. If the custom Vagrant server should not
+          be receiving the authentication token, please unset it.
+
+            Known Vagrant server:  %{known_host}
+            Custom Vagrant server: %{custom_host}
+
+          Press ctrl-c to cancel...
+    publish:
+      box_save:
+        Saving box information...
+      upload_provider:
+        Uploading provider with file %{file}
+      release:
+        Releasing box...
+      complete:
+        Complete! Published %{org}/%{box_name}
+      confirm:
+        warn: |-
+          You are about to publish a box on Vagrant Cloud with the following options:
+        box: |-
+          %{org}/%{box_name}:   (v%{version}) for provider '%{provider_name}'
+        private: |-
+            Private:               true
+        release: |-
+            Automatic Release:     true
+        box_url: |-
+            Remote Box file:       %{url}
+        box_description: |-
+            Box Description:       %{description}
+        box_short_desc: |-
+            Box Short Description: %{short_description}
+        checksum_type: |-
+            Checksum Type:         %{checksum_type}
+        checksum_value: |-
+            Checksum Value:        %{checksum_value}
+        architecture: |-
+            Box Architecture:      %{architecture}
+        default_architecture: |-
+            Default Architecture:  true
+        version_desc: |-
+            Version Description:   %{version_description}
+    continue: |-
+      Do you wish to continue? [y/N]
+    box:
+      show_filter_empty: |-
+        No matches found for %{org}/%{box_name}
+        Filters applied:
+          Architectures: %{architectures}
+          Providers:     %{providers}
+          Versions:      %{versions}
+      create_success: |-
+        Created box %{org}/%{box_name}
+      delete_success: |-
+        Deleted box %{org}/%{box_name}
+      delete_warn: |-
+        This will completely remove %{box} from Vagrant Cloud. This cannot be undone.
+      update_success: |-
+        Updated box %{org}/%{box_name}
+      not_found: |-
+        Failed to locate requested box: %{org}/%{box_name}
+    search:
+      no_results: |-
+        No results found for `%{query}`
+    upload:
+      no_url: |-
+        No URL was provided to upload the provider
+        You will need to run the `vagrant cloud provider upload` command to provide a box
+    provider:
+      upload: |-
+        Uploading box file for '%{org}/%{box_name}' (v%{version}) for provider: '%{provider}'
+      upload_success: |-
+        Uploaded provider %{provider} on %{org}/%{box_name} for version %{version}
+      delete_multiple_architectures: |-
+        Multiple architectures detected for %{provider} on %{org}/%{box_name}:
+
+      delete_architectures_prompt: |-
+        Please enter the architecture name to delete:
+      delete_warn: |-
+        This will completely remove provider %{provider} with architecture %{architecture}
+        on version %{version} from %{box} on Vagrant Cloud. This cannot be undone.
+      create_success: |-
+        Created provider %{provider} with %{architecture} architecture on %{org}/%{box_name} for version %{version}
+      delete_success: |-
+        Deleted provider %{provider} with %{architecture} architecture on %{org}/%{box_name}
+        for version %{version}
+      update_success: |-
+        Updated provider %{provider} on %{org}/%{box_name} for version %{version}
+      not_found: |-
+        Failed to locate %{provider_name} provider for %{org}/%{box_name} on version %{version}
+      direct_disable: |-
+        Vagrant is automatically disabling direct upload to backend storage.
+        Uploads directly to backend storage are currently only supported for
+        files 5G in size or smaller. Box file to upload is: %{size}
+    version:
+      create_success: |-
+        Created version %{version} on %{org}/%{box_name} for version %{version}
+      delete_success: |-
+        Deleted version %{version} on %{org}/%{box_name}
+      release_success: |-
+        Released version %{version} on %{org}/%{box_name}
+      revoke_success: |-
+        Revoked version %{version} on %{org}/%{box_name}
+      update_success: |-
+        Updated version %{version} on %{org}/%{box_name}
+      revoke_warn: |-
+        This will revoke version %{version} from %{box} from Vagrant Cloud. This cannot be undone.
+      release_warn: |-
+        This will release version %{version} from %{box} to Vagrant Cloud and be available to download.
+      delete_warn: |-
+        This will completely remove version %{version} from %{box} from Vagrant Cloud. This cannot be undone.
+      not_found: |-
+        Failed to locate version %{version} for %{org}/%{box_name}
+    errors:
+      search:
+        fail: |-
+          Could not complete search request
+      publish:
+        fail: |-
+          Failed to create box %{org}/%{box_name}
+      box:
+        create_fail: |-
+          Failed to create box %{org}/%{box_name}
+        delete_fail: |-
+          Failed to delete box %{org}/%{box_name}
+        show_fail: |-
+          Could not get information about box %{org}/%{box_name}
+        update_fail: |-
+          Failed to update box %{org}/%{box_name}
+      whoami:
+        read_error: |-
+          Failed to locate account information
+      provider:
+        create_fail: |-
+          Failed to create '%{architecture}' variant of %{provider} provider for version %{version} of the %{org}/%{box_name} box
+        update_fail: |-
+          Failed to update '%{architecture}' variant of %{provider} provider for version %{version} of the %{org}/%{box_name} box
+        delete_fail: |-
+          Failed to delete '%{architecture}' variant of %{provider} provider for version %{version} of the %{org}/%{box_name} box
+        upload_fail: |-
+          Failed to upload '%{architecture}' variant of %{provider} provider for version %{version} of the %{org}/%{box_name} box
+      version:
+        create_fail: |-
+          Failed to create version %{version} on box %{org}/%{box_name}
+        delete_fail: |-
+          Failed to delete version %{version} on box %{org}/%{box_name}
+        release_fail: |-
+          Failed to release version %{version} on box %{org}/%{box_name}
+        revoke_fail: |-
+          Failed to revoke version %{version} on box %{org}/%{box_name}
+        update_fail: |-
+          Failed to update version %{version} on box %{org}/%{box_name}
+      server_error: |-
+        The Vagrant Cloud server responded with a not-OK response:
+
+        %{errors}
+      server_unreachable: |-
+        The Vagrant Cloud server is not currently accepting connections. Please check
+        your network connection and try again later.
+
+      unauthorized: |-
+        Invalid username or password. Please try again.
+      unexpected_error: |-
+        An unexpected error occurred: %{error}
+
+    check_logged_in: |-
+      You are already logged in.
+    check_not_logged_in: |-
+      You are not currently logged in. Please run `vagrant login` and provide
+      your login information to authenticate.
+    command_header: |-
+      In a moment we will ask for your username and password to HashiCorp's
+      Vagrant Cloud. After authenticating, we will store an access token locally on
+      disk. Your login details will be transmitted over a secure connection, and
+      are never stored on disk locally.
+
+      If you do not have an Vagrant Cloud account, sign up at
+      https://www.vagrantcloud.com
+    invalid_login: |-
+      Invalid username or password. Please try again.
+    invalid_token: |-
+      Invalid token. Please try again.
+    logged_in: |-
+      You are now logged in.
+    logged_out: |-
+      You are logged out.
+    token_saved: |-
+      The token was successfully saved.

data/plugins/commands/cloud/plugin.rb

@@ -0,0 +1,48 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'vagrant_cloud'
+
+require Vagrant.source_root.join("plugins/commands/cloud/util")
+require Vagrant.source_root.join("plugins/commands/cloud/client/client")
+
+module VagrantPlugins
+  module CloudCommand
+    class Plugin < Vagrant.plugin("2")
+      name "vagrant-cloud"
+      description <<-DESC
+      Provides the cloud command and internal API access to Vagrant Cloud.
+      DESC
+
+      command(:cloud) do
+        require_relative "root"
+        init!
+        Command::Root
+      end
+
+      action_hook(:cloud_authenticated_boxes, :authenticate_box_url) do |hook|
+        require_relative "auth/middleware/add_authentication"
+        hook.prepend(AddAuthentication)
+      end
+
+      action_hook(:cloud_authenticated_boxes, :authenticate_box_downloader) do |hook|
+        require_relative "auth/middleware/add_downloader_authentication"
+        hook.prepend(AddDownloaderAuthentication)
+      end
+
+      protected
+
+      def self.init!
+        # Set this to match Vagant logging level so we get
+        # desired request/response information within the
+        # logger output
+        ENV["VAGRANT_CLOUD_LOG"] = Vagrant.log_level
+        
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path("../locales/en.yml", __FILE__)
+        I18n.reload!
+        @_init = true
+      end
+    end
+  end
+end

data/plugins/commands/cloud/provider/create.rb

@@ -0,0 +1,105 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CloudCommand
+    module ProviderCommand
+      module Command
+        class Create < Vagrant.plugin("2", :command)
+          include Util
+
+          def execute
+            options = {
+              architecture: Vagrant::Util::Platform.architecture,
+            }
+
+            opts = OptionParser.new do |o|
+              o.banner = "Usage: vagrant cloud provider create [options] organization/box-name provider-name version [url]"
+              o.separator ""
+              o.separator "Creates a provider entry on Vagrant Cloud"
+              o.separator ""
+              o.separator "Options:"
+              o.separator ""
+
+              o.on("-a", "--architecture ARCH", String, "Architecture of guest box (defaults to current host architecture)") do |a|
+                options[:architecture] = a
+              end
+              o.on("-c", "--checksum CHECKSUM_VALUE", String, "Checksum of the box for this provider. --checksum-type option is required.") do |c|
+                options[:checksum] = c
+              end
+              o.on("-C", "--checksum-type TYPE", String, "Type of checksum used (md5, sha1, sha256, sha384, sha512). --checksum option is required.") do |c|
+                options[:checksum_type] = c
+              end
+              o.on("--[no-]default-architecture", "Mark as default architecture for specific provider") do |d|
+                options[:default_architecture] = d
+              end
+            end
+
+            # Parse the options
+            argv = parse_options(opts)
+            return if !argv
+            if argv.count < 3 || argv.count > 4
+              raise Vagrant::Errors::CLIInvalidUsage,
+                help: opts.help.chomp
+            end
+
+            @client = client_login(@env)
+
+            org, box_name = argv.first.split('/', 2)
+            provider_name = argv[1]
+            version = argv[2]
+            url = argv[3]
+
+            create_provider(org, box_name, version, provider_name, url, @client.token, options)
+          end
+
+          # Create a provider for the box version
+          #
+          # @param [String] org Organization name
+          # @param [String] box Box name
+          # @param [String] version Box version
+          # @param [String] provider Provider name
+          # @param [String] url Provider asset URL
+          # @param [String] access_token User Vagrant Cloud access token
+          # @param [Hash] options
+          # @option options [String] :architecture Architecture of guest box
+          # @option options [String] :checksum Checksum of the box asset
+          # @option options [String] :checksum_type Type of the checksum
+          # @option options [Boolean] :default_architecture Default architecture for named provider
+          # @return [Integer]
+          def create_provider(org, box, version, provider, url, access_token, options={})
+            if !url
+              @env.ui.warn(I18n.t("cloud_command.upload.no_url"))
+            end
+            account = VagrantCloud::Account.new(
+              custom_server: api_server_url,
+              access_token: access_token
+            )
+            with_version(account: account, org: org, box: box, version: version) do |version|
+              provider = version.add_provider(provider, options[:architecture])
+              provider.checksum = options[:checksum] if options.key?(:checksum)
+              provider.checksum_type = options[:checksum_type] if options.key?(:checksum_type)
+              provider.architecture = options[:architecture] if options.key?(:architecture)
+              provider.default_architecture = options[:default_architecture] if options.key?(:default_architecture)
+              provider.url = url if url
+
+              provider.save
+
+              @env.ui.success(I18n.t("cloud_command.provider.create_success",
+                architecture: options[:architecture], provider: provider.name, org: org, box_name: box, version: version.version))
+              format_box_results(provider, @env)
+              0
+            end
+          rescue VagrantCloud::Error => e
+            @env.ui.error(I18n.t("cloud_command.errors.provider.create_fail",
+              architecture: options[:architecture], provider: provider.name, org: org, box_name: box, version: version))
+            @env.ui.error(e.message)
+            1
+          end
+        end
+      end
+    end
+  end
+end