vagrant-unbundled 2.2.7.0 → 2.2.16.0

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
@@ -168,8 +179,26 @@ module Vagrant
         result
       rescue Gem::GemNotFoundException
         raise Errors::PluginGemNotFound, name: name
-      rescue Gem::Exception => e
-        raise Errors::BundlerError, message: e.to_s
+      rescue Gem::Exception => err
+        @logger.warn("Failed to install plugin: #{err}")
+        @logger.debug("#{err.class}: #{err}\n#{err.backtrace.join("\n")}")
+        # Try and determine a cause for the failure
+        case err.message
+        when /install development tools first/
+          raise Errors::PluginNeedsDeveloperTools
+        when /library not found in default locations/
+          lib = err.message.match(/(\w+) library not found in default locations/)
+          if lib.nil?
+            raise Errors::BundlerError, message: err.message
+          end
+          raise Errors::PluginMissingLibrary,
+            library: lib.captures.first,
+            name: name
+        when /find header files for ruby/
+          raise Errors::PluginMissingRubyDev
+        else
+          raise Errors::BundlerError, message: err.message
+        end
       end
 
       # Uninstalls the plugin with the given name.

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
@@ -61,7 +61,7 @@ module Vagrant
 
           opts.parse!(argv)
           return argv
-        rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+        rescue OptionParser::InvalidOption, OptionParser::MissingArgument, OptionParser::AmbiguousOption
           raise Errors::CLIInvalidOptions, help: opts.help.chomp
         end
 
@@ -230,6 +230,11 @@ module Vagrant
           color_index = 0
 
           machines.each do |machine|
+            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
+
             # Set the machine color
             machine.ui.opts[:color] = color_order[color_index % color_order.length]
             color_index += 1

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

@@ -64,6 +64,11 @@ module Vagrant
         # @return [Registry<Symbol, Array<Class, Integer>>]
         attr_reader :synced_folders
 
+        # This contains all the registered synced folder capabilities.
+        #
+        # @return [Hash<Symbol, Registry>]
+        attr_reader :synced_folder_capabilities
+
         def initialize
           # The action hooks hash defaults to []
           @action_hooks = Hash.new { |h, k| h[k] = [] }
@@ -78,6 +83,7 @@ module Vagrant
           @provider_capabilities = Hash.new { |h, k| h[k] = Registry.new }
           @pushes = Registry.new
           @synced_folders = Registry.new
+          @synced_folder_capabilities = Hash.new { |h, k| h[k] = Registry.new }
         end
       end
     end

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>>]
@@ -204,7 +257,21 @@ module Vagrant
             end
           end
         end
+        
+        # This returns all the registered synced folder capabilities.
+        #
+        # @return [Hash]
+        def synced_folder_capabilities
+          results = Hash.new { |h, k| h[k] = Registry.new }
 
+          @registered.each do |plugin|
+            plugin.components.synced_folder_capabilities.each do |synced_folder, caps|
+              results[synced_folder].merge!(caps)
+            end
+          end
+
+          results
+        end
         # This registers a plugin. This should _NEVER_ be called by the public
         # and should only be called from within Vagrant. Vagrant will
         # automatically register V2 plugins when a name is set on the

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
@@ -246,6 +247,18 @@ module Vagrant
           nil
         end
 
+        # Defines a capability for the given synced folder. The block should return
+        # a class/module that has a method with the capability name, ready
+        # to be executed. This means that if it is an instance method,
+        # the block should return an instance of the class.
+        #
+        # @param [String] synced_folder The name of the synced folder
+        # @param [String] cap The name of the capability
+        def self.synced_folder_capability(synced_folder, cap, &block)
+          components.synced_folder_capabilities[synced_folder.to_sym].register(cap.to_sym, &block)
+          nil
+        end
+
         # Returns the internal data associated with this plugin. This
         # should NOT be called by the general public.
         #

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

@@ -3,6 +3,49 @@ module Vagrant
     module V2
       # This is the base class for a synced folder implementation.
       class SyncedFolder
+        class Collection < Hash
+
+          # @return [Array<Symbol>] names of synced folder types
+          def types
+            keys
+          end
+
+          # Fetch the synced plugin folder of the given type
+          #
+          # @param [Symbol] t Synced folder type
+          # @return [Vagrant::Plugin::V2::SyncedFolder]
+          def type(t)
+            f = detect { |k, _| k.to_sym == t.to_sym }.last
+            raise KeyError, "Unknown synced folder type" if !f
+            f.values.first[:plugin]
+          end
+
+          # Converts to a regular Hash and removes
+          # plugin instances so the result is ready
+          # for serialization
+          #
+          # @return [Hash]
+          def to_h
+            c = lambda do |h|
+              h.keys.each do |k|
+                if h[k].is_a?(Hash)
+                  h[k] = c.call(h[k].to_h.clone)
+                end
+              end
+              h
+            end
+            h = c.call(super)
+            h.values.each do |f|
+              f.values.each do |g|
+                g.delete(:plugin)
+              end
+            end
+            h
+          end
+        end
+
+        include CapabilityHost
+
         # This is called early when the synced folder is set to determine
         # if this implementation can be used for this machine. This should
         # return true or false.
@@ -54,6 +97,13 @@ module Vagrant
         # @param [Hash] opts
         def cleanup(machine, opts)
         end
+
+        def _initialize(machine, synced_folder_type)
+          plugins = Vagrant.plugin("2").manager.synced_folders
+          capabilities = Vagrant.plugin("2").manager.synced_folder_capabilities
+          initialize_capabilities!(synced_folder_type, plugins, capabilities, machine)
+          self
+        end
       end
     end
   end

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

@@ -30,58 +30,98 @@ 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, all: false)
           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, all: all)
+
+          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, all: false)
+          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))
+              (all && t.command.respond_to?(:to_sym) && t.command.to_sym == :all && !t.ignore.include?(name.to_sym)) ||
+                (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))
+              (all && t.command.respond_to?(:to_sym) && t.command.to_sym == :all && !t.ignore.include?(name.to_sym)) ||
+                (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
+              type: type,
+              guest_name: guest
           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)
-          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 +173,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}...")