vagrant-unbundled 2.2.6.0 → 2.2.9.0

data/lib/vagrant/cli.rb

@@ -62,9 +62,11 @@ module Vagrant
       # Initialize and execute the command class, returning the exit status.
       result = 0
       begin
-        @triggers.fire_triggers(@sub_command.to_sym, :before, nil, :command) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
+        @triggers.fire(@sub_command, :before, nil, :command) if
+          Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
         result = command_class.new(@sub_args, @env).execute
-        @triggers.fire_triggers(@sub_command.to_sym, :after, nil, :command) if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
+        @triggers.fire(@sub_command, :after, nil, :command) if
+          Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
       rescue Interrupt
         @env.ui.info(I18n.t("vagrant.cli_interrupt"))
         result = 1

data/lib/vagrant/errors.rb

@@ -248,6 +248,10 @@ module Vagrant
       error_key(:bundler_error)
     end
 
+    class SourceSpecNotFound < BundlerError
+      error_key(:source_spec_not_found)
+    end
+
     class CantReadMACAddresses < VagrantError
       error_key(:cant_read_mac_addresses)
     end
@@ -396,6 +400,10 @@ module Vagrant
       error_key(:auto_empty, "vagrant.actions.vm.forward_ports")
     end
 
+    class ForwardPortHostIPNotFound < VagrantError
+      error_key(:host_ip_not_found, "vagrant.actions.vm.forward_ports")
+    end
+
     class ForwardPortCollision < VagrantError
       error_key(:collision_error, "vagrant.actions.vm.forward_ports")
     end
@@ -436,6 +444,10 @@ module Vagrant
       error_key(:machine_action_locked)
     end
 
+    class MachineFolderNotAccessible < VagrantError
+      error_key(:machine_folder_not_accessible)
+    end
+
     class MachineGuestNotReady < VagrantError
       error_key(:machine_guest_not_ready)
     end
@@ -456,6 +468,10 @@ module Vagrant
       error_key(:multi_vm_target_required)
     end
 
+    class NetplanNoAvailableRenderers < VagrantError
+      error_key(:netplan_no_available_renderers)
+    end
+
     class NetSSHException < VagrantError
       error_key(:net_ssh_exception)
     end
@@ -612,6 +628,10 @@ module Vagrant
       error_key(:plugin_install_license_not_found)
     end
 
+    class PluginInstallFailed < VagrantError
+      error_key(:plugin_install_failed)
+    end
+
     class PluginInstallSpace < VagrantError
       error_key(:plugin_install_space)
     end
@@ -900,6 +920,10 @@ module Vagrant
       error_key(:virtualbox_broken_version_040214)
     end
 
+    class VirtualBoxDisksDefinedExceedLimit < VagrantError
+      error_key(:virtualbox_disks_defined_exceed_limit)
+    end
+
     class VirtualBoxGuestPropertyNotFound < VagrantError
       error_key(:virtualbox_guest_property_not_found)
     end

data/lib/vagrant/machine.rb

@@ -62,6 +62,11 @@ module Vagrant
     # @return [Hash]
     attr_reader :provider_options
 
+    # The triggers with machine specific configuration applied
+    #
+    # @return [Vagrant::Plugin::V2::Trigger]
+    attr_reader :triggers
+
     # The UI for outputting in the scope of this machine.
     #
     # @return [UI]
@@ -160,8 +165,6 @@ module Vagrant
     #   as extra data set on the environment hash for the middleware
     #   runner.
     def action(name, opts=nil)
-      @triggers.fire_triggers(name, :before, @name.to_s, :action)
-
       @logger.info("Calling action: #{name} on provider #{@provider}")
 
       opts ||= {}
@@ -210,8 +213,6 @@ module Vagrant
         ui.machine("action", name.to_s, "end")
         action_result
       end
-
-      @triggers.fire_triggers(name, :after, @name.to_s, :action)
       # preserve returning environment after machine action runs
       return return_env
     rescue Errors::EnvironmentLockedError
@@ -230,6 +231,7 @@ module Vagrant
     def action_raw(name, callable, extra_env=nil)
       # Run the action with the action runner on the environment
       env = {
+        raw_action_name: name,
         action_name: "machine_action_#{name}".to_sym,
         machine: self,
         machine_action: name,
@@ -476,8 +478,9 @@ module Vagrant
 
       # We also set some fields that are purely controlled by Vagrant
       info[:forward_agent] = @config.ssh.forward_agent
-      info[:forward_x11]   = @config.ssh.forward_x11
-      info[:forward_env]   = @config.ssh.forward_env
+      info[:forward_x11] = @config.ssh.forward_x11
+      info[:forward_env] = @config.ssh.forward_env
+      info[:connect_timeout] = @config.ssh.connect_timeout
 
       info[:ssh_command] = @config.ssh.ssh_command if @config.ssh.ssh_command
 

data/lib/vagrant/plugin/manager.rb

@@ -51,7 +51,7 @@ module Vagrant
         @globalized = true
         @logger.debug("Enabling globalized plugins")
         plugins = installed_plugins
-        bundler_init(plugins)
+        bundler_init(plugins, global: user_file.path)
         plugins
       end
 
@@ -66,7 +66,7 @@ module Vagrant
           @local_file = StateFile.new(env.local_data_path.join("plugins.json"))
           Vagrant::Bundler.instance.environment_path = env.local_data_path
           plugins = local_file.installed_plugins
-          bundler_init(plugins)
+          bundler_init(plugins, local: local_file.path)
           plugins
         end
       end
@@ -80,7 +80,7 @@ module Vagrant
       #
       # @param [Hash] plugins List of plugins
       # @return [nil]
-      def bundler_init(plugins)
+      def bundler_init(plugins, **opts)
         if !Vagrant.plugins_init?
           @logger.warn("Plugin initialization is disabled")
           return nil
@@ -99,7 +99,7 @@ module Vagrant
           )
         end
         begin
-          Vagrant::Bundler.instance.init!(plugins)
+          Vagrant::Bundler.instance.init!(plugins, **opts)
         rescue StandardError, ScriptError => err
           @logger.error("Plugin initialization error - #{err.class}: #{err}")
           err.backtrace.each do |backtrace_line|
@@ -150,17 +150,28 @@ module Vagrant
         else
           result = local_spec
         end
-        # Add the plugin to the state file
-        plugin_file = opts[:env_local] ? @local_file : @user_file
-        plugin_file.add_plugin(
-          result.name,
-          version: opts[:version],
-          require: opts[:require],
-          sources: opts[:sources],
-          env_local: !!opts[:env_local],
-          installed_gem_version: result.version.to_s
-        )
 
+        if result
+          # Add the plugin to the state file
+          plugin_file = opts[:env_local] ? @local_file : @user_file
+          plugin_file.add_plugin(
+            result.name,
+            version: opts[:version],
+            require: opts[:require],
+            sources: opts[:sources],
+            env_local: !!opts[:env_local],
+            installed_gem_version: result.version.to_s
+          )
+        else
+          r = Gem::Dependency.new(name, opts[:version])
+          result = Gem::Specification.find { |s|
+            s.satisfies_requirement?(r) &&
+              s.activated?
+          }
+          raise Errors::PluginInstallFailed,
+            name: name if result.nil?
+          @logger.warn("Plugin install returned no result as no new plugins were installed.")
+        end
         # After install clean plugin gems to remove any cruft. This is useful
         # for removing outdated dependencies or other versions of an installed
         # plugin if the plugin is upgraded/downgraded

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

@@ -51,7 +51,7 @@ module Vagrant
           argv = @argv.dup
 
           # Default opts to a blank optionparser if none is given
-          opts ||= OptionParser.new
+          opts ||= Vagrant::OptionParser.new
 
           # Add the help option, which must be on every command.
           opts.on_tail("-h", "--help", "Print this help") do

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

@@ -28,6 +28,59 @@ module Vagrant
           result
         end
 
+        # Find all hooks that are applicable for the given key. This
+        # lookup does not include hooks which are defined for ALL_ACTIONS.
+        # Key lookups will match on either string or symbol values. The
+        # provided keys is broken down into multiple parts for lookups,
+        # which allows defining hooks with an entire namespaced name,
+        # or a short suffx. For example:
+        #
+        #  Assume we are given an action class
+        #    key = Vagrant::Action::Builtin::SyncedFolders
+        #
+        #  The list of keys that will be checked for hooks:
+        #    ["Vagrant::Action::Builtin::SyncedFolders", "vagrant_action_builtin_synced_folders",
+        #     "Action::Builtin::SyncedFolders", "action_builtin_synced_folders",
+        #     "Builtin::SyncedFolders", "builtin_synced_folders",
+        #     "SyncedFolders", "synced_folders"]
+        #
+        # @param key [Class, String] key Key for hook lookups
+        # @return [Array<Proc>]
+        def find_action_hooks(key)
+          result = []
+
+          generate_hook_keys(key).each do |k|
+            @registered.each do |plugin|
+              result += plugin.components.action_hooks[k]
+              result += plugin.components.action_hooks[k.to_sym]
+            end
+          end
+
+          result
+        end
+
+        # Generate all valid lookup keys for given key
+        #
+        # @param [Class, String] key Base key for generation
+        # @return [Array<String>] all valid keys
+        def generate_hook_keys(key)
+          if key.is_a?(Class)
+            key = key.name.to_s
+          else
+            key = key.to_s
+          end
+          parts = key.split("::")
+          [].tap do |keys|
+            until parts.empty?
+              x = parts.join("::")
+              keys << x
+              y = x.gsub(/([a-z])([A-Z])/, '\1_\2').gsub('::', '_').downcase
+              keys << y if x != y
+              parts.shift
+            end
+          end
+        end
+
         # This returns all the registered commands.
         #
         # @return [Registry<Symbol, Array<Proc, Hash>>]

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

@@ -71,6 +71,7 @@ module Vagrant
         # @return [Array] List of the hooks for the given action.
         def self.action_hook(name, hook_name=nil, &block)
           # The name is currently not used but we want it for the future.
+          hook_name = hook_name.to_s if hook_name
 
           hook_name ||= ALL_ACTIONS
           components.action_hooks[hook_name.to_sym] << block

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

@@ -30,58 +30,97 @@ module Vagrant
           @logger = Log4r::Logger.new("vagrant::trigger::#{self.class.to_s.downcase}")
         end
 
-        # Fires all triggers, if any are defined for the action and guest. Returns early
+        # Fires all triggers, if any are defined for the named type and guest. Returns early
         # and logs a warning if the community plugin `vagrant-triggers` is installed
         #
-        # @param [Symbol] action Vagrant command to fire trigger on
+        # @param [Symbol] name Name of `type` thing to fire trigger on
         # @param [Symbol] stage :before or :after
-        # @param [String] guest_name The guest that invoked firing the triggers
-        def fire_triggers(action, stage, guest_name, type)
+        # @param [String] guest The guest that invoked firing the triggers
+        # @param [Symbol] type Type of trigger to fire (:action, :hook, :command)
+        def fire(name, stage, guest, type)
           if community_plugin_detected?
             @logger.warn("Community plugin `vagrant-triggers detected, so core triggers will not fire")
             return
           end
 
-          if !action
-            @logger.warn("Action given is nil, no triggers will fire")
-            return
-          else
-            action = action.to_sym
-          end
+          return @logger.warn("Name given is nil, no triggers will fire") if !name
+          return @logger.warn("Name given cannot be symbolized, no triggers will fire") if
+            !name.respond_to?(:to_sym)
+
+          name = name.to_sym
 
           # get all triggers matching action
-          triggers = []
+          triggers = find(name, stage, guest, type)
+
+          if !triggers.empty?
+            @logger.info("Firing trigger for #{type} #{name} on guest #{guest}")
+            @ui.info(I18n.t("vagrant.trigger.start", type: type, stage: stage, name: name))
+            execute(triggers)
+          end
+        end
+
+        # Find all triggers defined for the named type and guest.
+        #
+        # @param [Symbol] name Name of `type` thing to fire trigger on
+        # @param [Symbol] stage :before or :after
+        # @param [String] guest The guest that invoked firing the triggers
+        # @param [Symbol] type Type of trigger to fire
+        # @return [Array]
+        def find(name, stage, guest, type)
+          triggers = nil
+          name = nameify(name)
+
           if stage == :before
             triggers = config.before_triggers.select do |t|
-              t.command == action || (t.command == :all && !t.ignore.include?(action))
+              (t.command == :all && !t.ignore.include?(name)) ||
+                (type == :hook && matched_hook?(t.command, name)) ||
+                nameify(t.command) == name
             end
           elsif stage == :after
             triggers = config.after_triggers.select do |t|
-              t.command == action || (t.command == :all && !t.ignore.include?(action))
+              (t.command == :all && !t.ignore.include?(name)) ||
+                (type == :hook && matched_hook?(t.command, name)) ||
+                nameify(t.command) == name
             end
           else
             raise Errors::TriggersNoStageGiven,
-              action: action,
+              name: name,
               stage: stage,
-              guest_name: guest_name
-          end
-
-          triggers = filter_triggers(triggers, guest_name, type)
-
-          if !triggers.empty?
-            @logger.info("Firing trigger for action #{action} on guest #{guest_name}")
-            @ui.info(I18n.t("vagrant.trigger.start", type: type, stage: stage, action: action))
-            fire(triggers, guest_name)
+              type: type,
+              guest_name: guest
           end
+          filter_triggers(triggers, guest, type)
         end
 
         protected
 
+        # Convert object into name
+        #
+        # @param [Object, Class] object Object to name
+        # @return [String]
+        def nameify(object)
+          if object.is_a?(Class)
+            object.name.to_s
+          else
+            object.to_s
+          end
+        end
 
         #-------------------------------------------------------------------
         # Internal methods, don't call these.
         #-------------------------------------------------------------------
 
+        # Generate all valid lookup keys for given action key
+        #
+        # @param [Class, String] key Base key for generation
+        # @return [Array<String>] all valid keys
+        def matched_hook?(key, subject)
+          subject = nameify(subject)
+          Vagrant.plugin("2").manager.generate_hook_keys(key).any? do |k|
+            k == subject
+          end
+        end
+
         # Looks up if the community plugin `vagrant-triggers` is installed
         # and also caches the result
         #
@@ -133,12 +172,11 @@ module Vagrant
           return triggers
         end
 
-        # Fires off all triggers in the given array
+        # Execute all triggers in the given array
         #
         # @param [Array] triggers An array of triggers to be fired
-        def fire(triggers, guest_name)
+        def execute(triggers)
           # ensure on_error is respected by exiting or continuing
-
           triggers.each do |trigger|
             @logger.debug("Running trigger #{trigger.id}...")
 

data/lib/vagrant/shared_helpers.rb

@@ -186,4 +186,32 @@ module Vagrant
     end
     @_global_logger
   end
+
+  # Add a new block of default CLI options which
+  # should be automatically added to all commands
+  #
+  # @param [Proc] block Proc instance containing OptParser configuration
+  # @return [nil]
+  def self.add_default_cli_options(block)
+    if !block.is_a?(Proc)
+      raise TypeError,
+        "Expecting type `Proc` but received `#{block.class}`"
+    end
+    if block.arity != 1 && block.arity != -1
+      raise ArgumentError,
+        "Proc must accept OptionParser argument"
+    end
+    @_default_cli_options = [] if !@_default_cli_options
+    @_default_cli_options << block
+    nil
+  end
+
+  # Array of default CLI options to automatically
+  # add to commands.
+  #
+  # @return [Array<Proc>] Default optparse options
+  def self.default_cli_options
+    @_default_cli_options = [] if !@_default_cli_options
+    @_default_cli_options.dup
+  end
 end

data/lib/vagrant/ui.rb

@@ -75,6 +75,13 @@ module Vagrant
       def machine(type, *data)
         @logger.info("Machine: #{type} #{data.inspect}")
       end
+
+      # Yields self (UI)
+      # Provides a way for selectively displaying or not displaying
+      # updating content like download progress.
+      def rewriting
+        yield self
+      end
     end
 
     # This is a UI implementation that does nothing.
@@ -252,6 +259,31 @@ module Vagrant
       end
     end
 
+
+    class NonInteractive < Basic
+      def initialize
+        super
+      end
+
+      def rewriting
+        # no-op
+      end
+
+      def report_progress(progress, total, show_parts=true)
+        # no-op
+      end
+
+      def clear_line
+        @logger.warn("Using `clear line` in a non interactive ui")
+        say(:info, "\n", opts)
+      end
+
+      def ask(*args)
+        # Non interactive can't ask for input
+        raise Errors::UIExpectsTTY
+      end
+    end
+
     # Prefixed wraps an existing UI and adds a prefix to it.
     class Prefixed < Interface
       # The prefix for `output` messages.
@@ -290,7 +322,9 @@ module Vagrant
 
       [:clear_line, :report_progress].each do |method|
         # By default do nothing, these aren't formatted
-        define_method(method) { |*args| @ui.send(method, *args) }
+        define_method(method) do |*args|
+          @ui.send(method, *args)
+        end
       end
 
       # For machine-readable output, set the prefix in the
@@ -329,16 +363,28 @@ module Vagrant
         target = opts[:target] if opts.key?(:target)
         target = "#{target}:" if target != ""
 
-        # Get the lines. The first default is because if the message
-        # is an empty string, then we want to still use the empty string.
         lines = [message]
-        lines = message.split("\n") if message != ""
+        if message != ""
+          lines = [].tap do |l|
+            message.scan(/(.*?)(\n|$)/).each do |m|
+              l << m.first if m.first != "" || (m.first == "" && m.last == "\n")
+            end
+          end
+          lines << "" if message.end_with?("\n")
+        end
 
         # Otherwise, make sure to prefix every line properly
         lines.map do |line|
           "#{prefix}#{target} #{line}"
         end.join("\n")
       end
+
+      def rewriting
+        @ui.rewriting do |ui|
+          yield ui
+        end
+      end
+
     end
 
     # This is a UI implementation that outputs color for various types