vagrant-unbundled 2.2.7.0 → 2.2.16.0

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

@@ -5,19 +5,15 @@ module VagrantPlugins
     module AuthCommand
       module Command
         class Whoami < Vagrant.plugin("2", :command)
+          include Util
+
           def execute
             options = {}
 
             opts = OptionParser.new do |o|
-              o.banner = "Usage: vagrant cloud auth whoami [options] [token]"
+              o.banner = "Usage: vagrant cloud auth whoami [token]"
               o.separator ""
               o.separator "Display currently logged in user"
-              o.separator ""
-              o.separator "Options:"
-              o.separator ""
-              o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |l|
-                options[:login] = l
-              end
             end
 
             # Parse the options
@@ -28,28 +24,30 @@ module VagrantPlugins
                 help: opts.help.chomp
             end
 
-            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:login])
-
             if argv.first
               token = argv.first
             else
-              token = @client.token
+              client = Client.new(@env)
+              token = client.token
             end
 
-            whoami(token, options[:username])
+            whoami(token)
           end
 
-          def whoami(access_token, username)
-            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
-            account = VagrantPlugins::CloudCommand::Util.account(username, access_token, server_url)
-
+          def whoami(access_token)
+            if access_token.to_s.empty?
+              @env.ui.error(I18n.t("cloud_command.check_not_logged_in"))
+              return 1
+            end
             begin
-              success = account.validate_token
-              user = success["user"]["username"]
-              @env.ui.success("Currently logged in as #{user}")
+              account = VagrantCloud::Account.new(
+                custom_server: api_server_url,
+                access_token: access_token
+              )
+              @env.ui.success("Currently logged in as #{account.username}")
               return 0
-            rescue VagrantCloud::ClientError => e
-              @env.ui.error(I18n.t("cloud_command.errors.whoami.read_error", org: username))
+            rescue VagrantCloud::Error::ClientError => e
+              @env.ui.error(I18n.t("cloud_command.errors.whoami.read_error"))
               @env.ui.error(e)
               return 1
             end

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

@@ -5,6 +5,8 @@ module VagrantPlugins
     module BoxCommand
       module Command
         class Create < Vagrant.plugin("2", :command)
+          include Util
+
           def execute
             options = {}
 
@@ -19,13 +21,10 @@ module VagrantPlugins
               o.on("-d", "--description DESCRIPTION", String, "Full description of the box") do |d|
                 options[:description] = d
               end
-              o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |u|
-                options[:username] = u
-              end
               o.on("-s", "--short-description DESCRIPTION", String, "Short description of the box") do |s|
                 options[:short] = s
               end
-              o.on("-p", "--private", "Makes box private") do |p|
+              o.on("-p", "--[no-]private", "Makes box private") do |p|
                 options[:private] = p
               end
             end
@@ -38,35 +37,40 @@ module VagrantPlugins
                 help: opts.help.chomp
             end
 
-            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+            @client = client_login(@env)
 
-            box = argv.first.split('/', 2)
-            org = box[0]
-            box_name = box[1]
-            create_box(org, box_name, options, @client.token)
+            org, box_name = argv.first.split('/', 2)
+            create_box(org, box_name, @client.token, options.slice(:description, :short, :private))
           end
 
-          # @param [String] - org
-          # @param [String] - box_name
-          # @param [Hash] - options
-          def create_box(org, box_name, options, access_token)
-            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
-            account = VagrantPlugins::CloudCommand::Util.account(org, access_token, server_url)
-            box = VagrantCloud::Box.new(account, box_name, nil, options[:short], options[:description], access_token)
-
-            begin
-              success = box.create
-              @env.ui.success(I18n.t("cloud_command.box.create_success", org: org, box_name: box_name))
-              success = success.delete_if { |_, v| v.nil? }
-              VagrantPlugins::CloudCommand::Util.format_box_results(success, @env)
-              return 0
-            rescue VagrantCloud::ClientError => e
-              @env.ui.error(I18n.t("cloud_command.errors.box.create_fail", org: org, box_name: box_name))
-              @env.ui.error(e)
-              return 1
-            end
+          # Create a new box
+          #
+          # @param [String] org Organization name of box
+          # @param [String] box_name Name of box
+          # @param [String] access_token User access token
+          # @param [Hash] options Options for box filtering
+          # @option options [String] :short Short description of box
+          # @option options [String] :description Full description of box
+          # @option options [Boolean] :private Set box visibility as private
+          # @return [Integer]
+          def create_box(org, box_name, access_token, options={})
+            account = VagrantCloud::Account.new(
+              custom_server: api_server_url,
+              access_token: access_token
+            )
+            box = account.organization(name: org).add_box(box_name)
+            box.short_description = options[:short] if options.key?(:short)
+            box.description = options[:description] if options.key?(:description)
+            box.private = options[:private] if options.key?(:private)
+            box.save
 
-            return 1
+            @env.ui.success(I18n.t("cloud_command.box.create_success", org: org, box_name: box_name))
+            format_box_results(box, @env)
+            0
+          rescue VagrantCloud::Error => e
+            @env.ui.error(I18n.t("cloud_command.errors.box.create_fail", org: org, box_name: box_name))
+            @env.ui.error(e.message)
+            1
           end
         end
       end

data/plugins/commands/cloud/box/delete.rb

@@ -5,6 +5,8 @@ module VagrantPlugins
     module BoxCommand
       module Command
         class Delete < Vagrant.plugin("2", :command)
+          include Util
+
           def execute
             options = {}
 
@@ -16,8 +18,8 @@ module VagrantPlugins
               o.separator "Options:"
               o.separator ""
 
-              o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |u|
-                options[:username] = u
+              o.on("-f", "--[no-]force", "Do not prompt for deletion confirmation") do |f|
+                options[:force] = f
               end
             end
 
@@ -29,34 +31,38 @@ module VagrantPlugins
                 help: opts.help.chomp
             end
 
-            @env.ui.warn(I18n.t("cloud_command.box.delete_warn", box: argv.first))
-            cont = @env.ui.ask(I18n.t("cloud_command.continue"))
-            return 1 if cont.strip.downcase != "y"
+            if !options[:force]
+              @env.ui.warn(I18n.t("cloud_command.box.delete_warn", box: argv.first))
+              cont = @env.ui.ask(I18n.t("cloud_command.continue"))
+              return 1 if cont.strip.downcase != "y"
+            end
 
-            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
+            @client = client_login(@env)
 
-            box = argv.first.split('/', 2)
-            org = box[0]
-            box_name = box[1]
-            delete_box(org, box_name, options[:username], @client.token)
+            org, box_name = argv.first.split('/', 2)
+            delete_box(org, box_name, @client.token)
           end
 
-          def delete_box(org, box_name, username, access_token)
-            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
-            account = VagrantPlugins::CloudCommand::Util.account(username, access_token, server_url)
-            box = VagrantCloud::Box.new(account, box_name, nil, nil, nil, access_token)
-
-            begin
-              success = box.delete(org, box_name)
+          # Delete the requested box
+          #
+          # @param [String] org Organization name of box
+          # @param [String] box_name Name of box
+          # @param [String] access_token User access token
+          # @return [Integer]
+          def delete_box(org, box_name, access_token)
+            account = VagrantCloud::Account.new(
+              custom_server: api_server_url,
+              access_token: access_token
+            )
+            with_box(account: account, org: org, box: box_name) do |box|
+              box.delete
               @env.ui.success(I18n.t("cloud_command.box.delete_success", org: org, box_name: box_name))
-              return 0
-            rescue VagrantCloud::ClientError => e
-              @env.ui.error(I18n.t("cloud_command.errors.box.delete_fail", org: org, box_name: box_name))
-              @env.ui.error(e)
-              return 1
+              0
             end
-
-            return 1
+          rescue VagrantCloud::Error => e
+            @env.ui.error(I18n.t("cloud_command.errors.box.delete_fail", org: org, box_name: box_name))
+            @env.ui.error(e.message)
+            1
           end
         end
       end

data/plugins/commands/cloud/box/show.rb

@@ -5,8 +5,10 @@ module VagrantPlugins
     module BoxCommand
       module Command
         class Show < Vagrant.plugin("2", :command)
+          include Util
+
           def execute
-            options = {}
+            options = {quiet: true, versions: []}
 
             opts = OptionParser.new do |o|
               o.banner = "Usage: vagrant cloud box show [options] organization/box-name"
@@ -16,11 +18,11 @@ module VagrantPlugins
               o.separator "Options:"
               o.separator ""
 
-              o.on("-u", "--username USERNAME_OR_EMAIL", String, "Vagrant Cloud username or email address") do |u|
-                options[:username] = u
+              o.on("--versions VERSION", String, "Display box information for a specific version (can be defined multiple times)") do |v|
+                options[:versions] << v
               end
-              o.on("--versions VERSION", String, "Display box information for a specific version") do |v|
-                options[:version] = v
+              o.on("--[no-]auth", "Authenticate with Vagrant Cloud if required before searching") do |l|
+                options[:quiet] = !l
               end
             end
 
@@ -32,40 +34,48 @@ module VagrantPlugins
                 help: opts.help.chomp
             end
 
-            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
-            box = argv.first.split('/', 2)
+            @client = client_login(@env, options.slice(:quiet))
+            org, box_name = argv.first.split('/', 2)
 
-            show_box(box[0], box[1], options, @client.token)
+            show_box(org, box_name, @client&.token, options.slice(:versions))
           end
 
-          def show_box(org, box_name, options, access_token)
-            username = options[:username]
-
-            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
-            account = VagrantPlugins::CloudCommand::Util.account(username, access_token, server_url)
-            box = VagrantCloud::Box.new(account, box_name, nil, nil, nil, access_token)
-
-            begin
-              success = box.read(org, box_name)
+          # Display the requested box to the user
+          #
+          # @param [String] org Organization name of box
+          # @param [String] box_name Name of box
+          # @param [String] access_token User access token
+          # @param [Hash] options Options for box filtering
+          # @option options [String] :versions Specific verisons of box
+          # @return [Integer]
+          def show_box(org, box_name, access_token, options={})
+            account = VagrantCloud::Account.new(
+              custom_server: api_server_url,
+              access_token: access_token
+            )
+            with_box(account: account, org: org, box: box_name) do |box|
+              if box && !Array(options[:versions]).empty?
+                box = box.versions.find_all{ |v| options[:versions].include?(v.version) }
+              else
+                box = [box]
+              end
 
-              if options[:version]
-                # show *this* version only
-                results = success["versions"].select{ |v| v if v["version"] == options[:version] }.first
-                if !results
-                  @env.ui.warn(I18n.t("cloud_command.box.show_filter_empty", version: options[:version], org: org, box_name: box_name))
-                  return 0
+              if !box.empty?
+                box.each do |b|
+                  format_box_results(b, @env)
+                  @env.ui.output("")
                 end
+                0
               else
-                results = success
+                @env.ui.warn(I18n.t("cloud_command.box.show_filter_empty",
+                  version: options[:version], org: org, box_name: box_name))
+                1
               end
-              results = results.delete_if { |_, v| v.nil? }
-              VagrantPlugins::CloudCommand::Util.format_box_results(results, @env)
-              return 0
-            rescue VagrantCloud::ClientError => e
-              @env.ui.error(I18n.t("cloud_command.errors.box.show_fail", org: org,box_name:box_name))
-              @env.ui.error(e)
-              return 1
             end
+          rescue VagrantCloud::Error => e
+            @env.ui.error(I18n.t("cloud_command.errors.box.show_fail", org: org,box_name:box_name))
+            @env.ui.error(e.message)
+            1
           end
         end
       end

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

@@ -5,6 +5,8 @@ module VagrantPlugins
     module BoxCommand
       module Command
         class Update < Vagrant.plugin("2", :command)
+          include Util
+
           def execute
             options = {}
 
@@ -19,13 +21,10 @@ module VagrantPlugins
               o.on("-d", "--description DESCRIPTION", "Full description of the box") do |d|
                 options[:description] = d
               end
-              o.on("-u", "--username", "The username of the organization that will own the box") do |u|
-                options[:username] = u
-              end
               o.on("-s", "--short-description DESCRIPTION", "Short description of the box") do |s|
-                options[:short_description] = s
+                options[:short] = s
               end
-              o.on("-p", "--private", "Makes box private") do |p|
+              o.on("-p", "--[no-]private", "Makes box private") do |p|
                 options[:private] = p
               end
             end
@@ -33,36 +32,45 @@ module VagrantPlugins
             # Parse the options
             argv = parse_options(opts)
             return if !argv
-            if argv.empty? || argv.length > 1 || options.length == 0
+            if argv.empty? || argv.length > 1 || options.slice(:description, :short, :private).length == 0
               raise Vagrant::Errors::CLIInvalidUsage,
                 help: opts.help.chomp
             end
 
-            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
-            box = argv.first.split('/', 2)
+            @client = client_login(@env)
+            org, box_name = argv.first.split('/', 2)
 
-            update_box(box[0], box[1], options, @client.token)
+            update_box(org, box_name, @client.token, options.slice(:short, :description, :private))
           end
 
-          def update_box(org, box_name, options, access_token)
-            server_url = VagrantPlugins::CloudCommand::Util.api_server_url
-            account = VagrantPlugins::CloudCommand::Util.account(options[:username], access_token, server_url)
-            box = VagrantCloud::Box.new(account, box_name, nil, nil, nil, access_token)
-
-            options[:organization] = org
-            options[:name] = box_name
-            begin
-              success = box.update(options)
+          # Update an existing box
+          #
+          # @param [String] org Organization name of box
+          # @param [String] box_name Name of box
+          # @param [String] access_token User access token
+          # @param [Hash] options Options for box filtering
+          # @option options [String] :short Short description of box
+          # @option options [String] :description Full description of box
+          # @option options [Boolean] :private Set box visibility as private
+          # @return [Integer]
+          def update_box(org, box_name, access_token, options={})
+            account = VagrantCloud::Account.new(
+              custom_server: api_server_url,
+              access_token: access_token
+            )
+            with_box(account: account, org: org, box: box_name) do |box|
+              box.short_description = options[:short] if options.key?(:short)
+              box.description = options[:description] if options.key?(:description)
+              box.private = options[:private] if options.key?(:private)
+              box.save
               @env.ui.success(I18n.t("cloud_command.box.update_success", org: org, box_name: box_name))
-              success = success.delete_if{|_, v|v.nil?}
-              VagrantPlugins::CloudCommand::Util.format_box_results(success, @env)
-              return 0
-            rescue VagrantCloud::ClientError => e
-              @env.ui.error(I18n.t("cloud_command.errors.box.update_fail", org: org, box_name: box_name))
-              @env.ui.error(e)
-              return 1
+              format_box_results(box, @env)
+              0
             end
-            return 1
+          rescue VagrantCloud::Error => e
+            @env.ui.error(I18n.t("cloud_command.errors.box.update_fail", org: org, box_name: box_name))
+            @env.ui.error(e.message)
+            1
           end
         end
       end

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

@@ -1,4 +1,3 @@
-require "rest_client"
 require "vagrant_cloud"
 require "vagrant/util/downloader"
 require "vagrant/util/presence"
@@ -7,13 +6,22 @@ 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
@@ -25,6 +33,10 @@ module VagrantPlugins
       def initialize(env)
         @logger = Log4r::Logger.new("vagrant::cloud::client")
         @env    = env
+        @client = VagrantCloud::Client.new(
+          access_token: token,
+          url_base: api_server_url
+        )
       end
 
       # Removes the token, effectively logging the user out.
@@ -38,14 +50,11 @@ module VagrantPlugins
       #
       # @return [Boolean]
       def logged_in?
-        token = self.token
-        return false if !token
-        Vagrant::Util::CredentialScrubber.sensitive(token)
+        return false if !client.access_token
+        Vagrant::Util::CredentialScrubber.sensitive(client.access_token)
 
         with_error_handling do
-          url = "#{Vagrant.server_url}/api/v1/authenticate" +
-            "?access_token=#{token}"
-          RestClient.get(url, content_type: :json)
+          client.authentication_token_validate
           true
         end
       rescue Errors::Unauthorized
@@ -62,23 +71,17 @@ module VagrantPlugins
         @logger.info("Logging in '#{username_or_email}'")
 
         Vagrant::Util::CredentialScrubber.sensitive(password)
-        response = post(
-          "/api/v1/authenticate", {
-            user: {
-              login: username_or_email,
-              password: password
-            },
-            token: {
-              description: description
-            },
-            two_factor: {
-              code: code
-            }
-          }
-        )
+        with_error_handling do
+          r = client.authentication_token_create(username: username_or_email,
+            password: password, description: description, code: code)
 
-        Vagrant::Util::CredentialScrubber.sensitive(response["token"])
-        response["token"]
+          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
@@ -87,50 +90,14 @@ module VagrantPlugins
         @env.ui.warn("Requesting 2FA code via #{delivery_method.upcase}...")
 
         Vagrant::Util::CredentialScrubber.sensitive(password)
-        response = post(
-          "/api/v1/two-factor/request-code", {
-            user: {
-              login: username_or_email,
-              password: password
-            },
-            two_factor: {
-              delivery_method: delivery_method.downcase
-            }
-          }
-        )
-
-        two_factor = response['two_factor']
-        obfuscated_destination = two_factor['obfuscated_destination']
-
-        @env.ui.success("2FA code sent to #{obfuscated_destination}.")
-      end
-
-      # Issues a post to a Vagrant Cloud path with the given payload.
-      # @param [String] path
-      # @param [Hash] payload
-      # @return [Hash] response data
-      def post(path, payload)
         with_error_handling do
-          url = File.join(Vagrant.server_url, path)
-
-          proxy   = nil
-          proxy ||= ENV["HTTPS_PROXY"] || ENV["https_proxy"]
-          proxy ||= ENV["HTTP_PROXY"]  || ENV["http_proxy"]
-          RestClient.proxy = proxy
-
-          response = RestClient::Request.execute(
-            method: :post,
-            url: url,
-            payload: JSON.dump(payload),
-            proxy: proxy,
-            headers: {
-              accept: :json,
-              content_type: :json,
-              user_agent: Vagrant::Util::Downloader::USER_AGENT,
-            },
-          )
+          r = client.authentication_request_2fa_code(
+            username: username_or_email, password: password, delivery_method: delivery_method)
 
-          JSON.load(response.to_s)
+          two_factor = r[:two_factor]
+          obfuscated_destination = two_factor[:obfuscated_destination]
+
+          @env.ui.success("2FA code sent to #{obfuscated_destination}.")
         end
       end
 
@@ -138,12 +105,16 @@ module VagrantPlugins
       #
       # @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
 
@@ -154,7 +125,9 @@ module VagrantPlugins
       # @return [String]
       def token
         if present?(ENV["VAGRANT_CLOUD_TOKEN"]) && token_path.exist?
-          @env.ui.warn <<-EOH.strip
+          # 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
@@ -163,21 +136,24 @@ the VAGRANT_CLOUD_TOKEN environment variable or remove the login token stored on
     ~/.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")
-          return ENV["VAGRANT_CLOUD_TOKEN"]
-        end
-
-        if token_path.exist?
+          t = ENV["VAGRANT_CLOUD_TOKEN"]
+        elsif token_path.exist?
           @logger.debug("Using authentication token from disk at #{token_path}")
-          return token_path.read.strip
+          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 present?(ENV["ATLAS_TOKEN"])
-          @logger.warn("ATLAS_TOKEN detected within environment. Using ATLAS_TOKEN in place of VAGRANT_CLOUD_TOKEN.")
-          return ENV["ATLAS_TOKEN"]
+        if !t.nil?
+          Vagrant::Util::CredentialScrubber.sensitive(t)
+          return t
         end
 
         @logger.debug("No authentication token in environment or #{token_path}")
@@ -189,22 +165,22 @@ EOH
 
       def with_error_handling(&block)
         yield
-      rescue RestClient::Unauthorized
+      rescue Excon::Error::Unauthorized
         @logger.debug("Unauthorized!")
         raise Errors::Unauthorized
-      rescue RestClient::BadRequest => e
+      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)
+        parsed_response = JSON.parse(e.response.body)
         errors = parsed_response["errors"].join("\n")
         raise Errors::ServerError, errors: errors
-      rescue RestClient::NotAcceptable => e
+      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)
+        parsed_response = JSON.parse(e.response.body)
 
         if two_factor = parsed_response['two_factor']
           store_two_factor_information two_factor