vagrant-unbundled 2.2.10.0 → 2.2.14.0

data/lib/vagrant/machine.rb

@@ -231,15 +231,18 @@ module Vagrant
     # @param [Proc] callable
     # @param [Hash] extra_env Extra env for the action env.
     # @return [Hash] The resulting env
-    def action_raw(name, callable, extra_env=nil)
+    def action_raw(name, callable, extra_env={})
+      if !extra_env.is_a?(Hash)
+        extra_env = {}
+      end
+
       # Run the action with the action runner on the environment
-      env = {
+      env = {ui: @ui}.merge(extra_env).merge(
         raw_action_name: name,
         action_name: "machine_action_#{name}".to_sym,
         machine: self,
-        machine_action: name,
-        ui: @ui,
-      }.merge(extra_env || {})
+        machine_action: name
+      )
       @env.action_runner.run(callable, env)
     end
 

data/lib/vagrant/machine_index.rb

@@ -263,6 +263,7 @@ module Vagrant
     #
     # @return [Hash]
     def find_by_prefix(prefix)
+      return if !prefix
       @machines.each do |uuid, data|
         return data.merge("id" => uuid) if uuid.start_with?(prefix)
       end

data/lib/vagrant/plugin/v2/command.rb

@@ -230,7 +230,8 @@ module Vagrant
           color_index = 0
 
           machines.each do |machine|
-            if machine.state && machine.state.id != :not_created && !@env.machine_index.include?(machine.index_uuid)
+            if (machine.state && machine.state.id != :not_created && 
+                !machine.index_uuid.nil? && !@env.machine_index.include?(machine.index_uuid))
               machine.recover_machine(machine.state.id)
             end
 

data/lib/vagrant/shared_helpers.rb

@@ -125,6 +125,14 @@ module Vagrant
     Gem::Version.new(Vagrant::VERSION).prerelease?
   end
 
+  # This returns true/false if the Vagrant should allow prerelease
+  # versions when resolving plugin dependency constraints
+  #
+  # @return [Boolean]
+  def self.allow_prerelease_dependencies?
+    !!ENV["VAGRANT_ALLOW_PRERELEASE"]
+  end
+
   # This allows control over dependency resolution when installing
   # plugins into vagrant. When true, dependency libraries that Vagrant
   # core relies upon will be hard constraints.

data/lib/vagrant/util/downloader.rb

@@ -29,8 +29,9 @@ module Vagrant
         "vagrantup.com".freeze
       ].freeze
 
-      attr_reader :source
+      attr_accessor :source
       attr_reader :destination
+      attr_accessor :headers
 
       def initialize(source, destination, options=nil)
         options     ||= {}
@@ -58,7 +59,7 @@ module Vagrant
         @ca_cert     = options[:ca_cert]
         @ca_path     = options[:ca_path]
         @continue    = options[:continue]
-        @headers     = options[:headers]
+        @headers     = Array(options[:headers])
         @insecure    = options[:insecure]
         @ui          = options[:ui]
         @client_cert = options[:client_cert]

data/lib/vagrant/util/is_port_open.rb

@@ -17,7 +17,7 @@ module Vagrant
           Socket.tcp(host, port, connect_timeout: 0.1).close
           true
         rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, \
-            Errno::ENETUNREACH, Errno::EACCES, Errno::ENOTCONN
+            Errno::ENETUNREACH, Errno::EACCES, Errno::ENOTCONN, Errno::EALREADY
           false
         end
       end

data/lib/vagrant/util/mime.rb

@@ -0,0 +1,92 @@
+require 'mime/types'
+require 'securerandom'
+
+module Vagrant
+  module Util
+    module Mime
+      class Multipart
+
+        # @return [Array<String>] collection of content part of the multipart mime
+        attr_accessor :content
+
+        # @return [String] type of the content
+        attr_accessor :content_type
+
+        # @return [Hash] headers for the mime
+        attr_accessor :headers
+
+        # @param [String] (optional) mime content type
+        # @param [String] (optional) mime version
+        def initialize(content_type="multipart/mixed")
+          @content_id = "#{Time.now.to_i}@#{SecureRandom.alphanumeric(24)}.local"
+          @boundary = "Boundary_#{SecureRandom.alphanumeric(24)}"
+          @content_type = MIME::Types[content_type].first
+          @content = []
+          @headers = {
+            "Content-ID"=> "<#{@content_id}>",
+            "Content-Type"=> "#{content_type}; boundary=#{@boundary}",
+          }
+        end
+
+        # Add an entry to the multipart mime
+        #
+        # @param entry to add
+        def add(entry)
+          content << entry
+        end
+
+        # Output MimeEntity as a string
+        #
+        # @return [String] mime data
+        def to_s
+          output_string = ""
+          headers.each do |k, v|
+            output_string += "#{k}: #{v}\n"
+          end
+          output_string += "\n--#{@boundary}\n"
+          @content.each do |entry|
+            output_string += entry.to_s
+            output_string += "\n--#{@boundary}\n"
+          end
+          output_string
+        end
+      end
+
+      class Entity
+
+        # @return [String] entity content 
+        attr_reader :content
+
+        # @return [String] type of the entity content
+        attr_reader :content_type
+
+        # @return [String] content disposition
+        attr_accessor :disposition
+
+        # @param [String] entity content
+        # @param [String] type of the entity content
+        def initialize(content, content_type)
+          if !MIME::Types.include?(content_type)
+            MIME::Types.add(MIME::Type.new(content_type))
+          end
+          @content = content
+          @content_type = MIME::Types[content_type].first
+          @content_id = "#{Time.now.to_i}@#{SecureRandom.alphanumeric(24)}.local"
+        end
+
+        # Output MimeEntity as a string
+        #
+        # @return [String] mime data
+        def to_s
+          output_string = "Content-ID: <#{@content_id}>\n"
+          output_string += "Content-Type: #{@content_type}\n"
+          if disposition
+            output_string += "Content-Disposition: #{@disposition}\n"
+          end
+          output_string += "\n#{content}"
+          output_string
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/platform.rb

@@ -554,6 +554,7 @@ module Vagrant
         # Get list of local mount paths that are DrvFs file systems
         #
         # @return [Array<String>]
+        # @todo(chrisroberts): Constantize types for check
         def wsl_drvfs_mounts
           if !defined?(@_wsl_drvfs_mounts)
             @_wsl_drvfs_mounts = []
@@ -561,7 +562,7 @@ module Vagrant
               result = Util::Subprocess.execute("mount")
               result.stdout.each_line do |line|
                 info = line.match(MOUNT_PATTERN)
-                if info && info[:type] == "drvfs"
+                if info && (info[:type] == "drvfs" || info[:type] == "9p")
                   @_wsl_drvfs_mounts << info[:mount]
                 end
               end

data/lib/vagrant/util/template_renderer.rb

@@ -1,7 +1,7 @@
 require 'ostruct'
 require "pathname"
 
-require 'erubis'
+require 'erubi'
 
 module Vagrant
   module Util
@@ -73,7 +73,7 @@ module Vagrant
       #
       # @return [String]
       def render_string
-        Erubis::Eruby.new(template, trim: true).result(binding)
+        binding.eval(Erubi::Engine.new(template, trim: true).src)
       end
 
       # Returns the full path to the template, taking into account the gem directory

data/lib/vagrant/util/uploader.rb

@@ -13,9 +13,11 @@ module Vagrant
     # a hand-rolled Ruby library, so we defer to its expertise.
     class Uploader
 
-      # @param [String] destination - valid URL to upload file to
-      # @param [String] file - location of file to upload on disk
-      # @param [Hash]   options
+      # @param [String] destination Valid URL to upload file to
+      # @param [String] file Location of file to upload on disk
+      # @param [Hash] options
+      # @option options [Vagrant::UI] :ui UI interface for output
+      # @option options [String, Symbol] :method Request method for upload
       def initialize(destination, file, options=nil)
         options ||= {}
         @logger         = Log4r::Logger.new("vagrant::util::uploader")
@@ -27,6 +29,7 @@ module Vagrant
         if !@request_method
           @request_method = "PUT"
         end
+        @request_method = @request_method.to_s.upcase
       end
 
       def upload!
@@ -51,7 +54,7 @@ module Vagrant
       protected
 
       def build_options
-        options = [@destination, "--request", @request_method, "--upload-file", @file]
+        options = [@destination, "--request", @request_method, "--upload-file", @file, "--fail"]
         return options
       end
 

data/plugins/commands/cap/command.rb

@@ -27,6 +27,10 @@ module VagrantPlugins
           o.on("--check", "Only checks for a capability, does not execute") do |f|
             options[:check] = f
           end
+
+          o.on("-t", "--target=TARGET", "Target guest to run against (if applicable)") do |t|
+            options[:target] = t
+          end
         end
 
         # Parse the options
@@ -45,7 +49,7 @@ module VagrantPlugins
         if type == :host
           cap_host = @env.host
         else
-          with_target_vms([]) do |vm|
+          with_target_vms(options[:target] || []) do |vm|
             cap_host = case type
                        when :provider
                          vm.provider

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

@@ -5,6 +5,8 @@ module VagrantPlugins
     module AuthCommand
       module Command
         class Login < Vagrant.plugin("2", :command)
+          include Util
+
           def execute
             options = {}
 
@@ -16,15 +18,10 @@ module VagrantPlugins
               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("-k", "--logout", "Logout from Vagrant Cloud") do |k|
-                options[:logout] = k
-              end
-
               o.on("-t", "--token TOKEN", String, "Set the Vagrant Cloud token") do |t|
                 options[:token] = t
               end
@@ -37,26 +34,32 @@ module VagrantPlugins
             # 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]
+            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
-            elsif options[:logout]
-              return execute_logout
+              return execute_check(client)
             elsif options[:token]
-              return execute_token(options[:token])
+              return execute_token(client, options[:token])
             else
-              @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options)
+              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
-            if @client.logged_in?
+          def execute_check(client)
+            if client.logged_in?
               @env.ui.success(I18n.t("cloud_command.check_logged_in"))
               return 0
             else
@@ -65,17 +68,11 @@ module VagrantPlugins
             end
           end
 
-          def execute_logout
-            @client.clear_token
-            @env.ui.success(I18n.t("cloud_command.logged_out"))
-            return 0
-          end
-
-          def execute_token(token)
-            @client.store_token(token)
+          def execute_token(client, token)
+            client.store_token(token)
             @env.ui.success(I18n.t("cloud_command.token_saved"))
 
-            if @client.logged_in?
+            if client.logged_in?
               @env.ui.success(I18n.t("cloud_command.check_logged_in"))
               return 0
             else

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

@@ -9,15 +9,9 @@ module VagrantPlugins
             options = {}
 
             opts = OptionParser.new do |o|
-              o.banner = "Usage: vagrant cloud auth logout [options]"
+              o.banner = "Usage: vagrant cloud auth logout"
               o.separator ""
               o.separator "Log out of Vagrant Cloud"
-              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,9 +22,7 @@ module VagrantPlugins
                 help: opts.help.chomp
             end
 
-            # Initializes client and deletes token on disk
-            @client = VagrantPlugins::CloudCommand::Util.client_login(@env, options[:username])
-
+            @client = Client.new(@env)
             @client.clear_token
             @env.ui.success(I18n.t("cloud_command.logged_out"))
             return 0

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

@@ -0,0 +1,57 @@
+require "cgi"
+require "uri"
+
+require "vagrant/util/credential_scrubber"
+require_relative "./add_authentication"
+
+require Vagrant.source_root.join("plugins/commands/cloud/client/client")
+
+# 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
+
+      @@logger = Log4r::Logger.new("vagrant::clout::add_download_authentication")
+
+      def call(env)
+        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
+          end
+
+          env[:downloader]
+        end
+
+        @app.call(env)
+      end.freeze
+    end
+  end
+end

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