vagrant-unbundled 2.2.6.2 → 2.2.14.0

data/contrib/zsh/generate_zsh_completion.rb

@@ -0,0 +1,165 @@
+require 'open3'
+
+HEAD = """#compdef _vagrant vagrant
+
+# ZSH completion for Vagrant
+#
+# To use this completion add this to ~/.zshrc
+# fpath=(/path/to/this/dir $fpath)
+# compinit
+#
+# For development reload the function after making changes
+# unfunction _vagrant && autoload -U _vagrant 
+"""
+
+BOX_LIST_FUNCTION = """
+__box_list ()
+{
+    _wanted application expl 'command' compadd $(command vagrant box list | awk '{print $1}' )
+}
+"""
+
+PLUGIN_LIST_FUNCTION = """
+__plugin_list ()
+{
+    _wanted application expl 'command' compadd $(command vagrant plugin list | awk '{print $1}')
+}
+"""
+
+ADD_FEATURE_FLAGS = ["remove", "repackage", "update", "repair", "uninstall"]
+VAGRANT_COMMAND = "vagrant"  
+
+FLAG_REGEX = /--(\S)*/
+CMDS_REGEX = /^(\s){1,}(\w)(\S)*/
+
+def make_string_script_safe(s)
+  s.gsub("[","(").gsub("]",")").gsub("-","_").gsub("'", "")
+end
+
+def remove_square_brakets(s)
+  s.gsub("[","(").gsub("]",")")
+end
+
+def format_flags(group_name, flags)
+  group_name = make_string_script_safe(group_name)
+  opts_str = "local -a #{group_name} && #{group_name}=(\n"
+  flags.each do |flag, desc|
+    opts_str = opts_str + "    '#{remove_square_brakets(flag)}=[#{make_string_script_safe(desc)}]'\n"
+  end
+  opts_str + ")"
+end
+
+def format_subcommand(group_name, cmds)
+  opts_str = "local -a #{group_name} && #{group_name}=(\n"
+  cmds.each do |cmd, desc|
+    opts_str = opts_str + "    '#{cmd}:#{desc}'\n"
+  end
+  opts_str + ")"
+end
+
+def format_case(group_name, cmds, cmd_list, feature_string)
+  case_str = """case $state in 
+  (command)
+    _describe -t commands 'command' #{group_name}
+    return
+  ;;
+
+  (options)
+    case $line[1] in
+"""
+
+  cmds.each do |cmd, desc|
+    if cmd_list.include?(cmd)
+      case_append = """  #{cmd})
+    _arguments -s -S : $#{make_string_script_safe(cmd)}_arguments #{feature_string if ADD_FEATURE_FLAGS.include?(cmd)} ;;
+"""
+    else
+      case_append = """  #{cmd})
+    __vagrant-#{cmd} ;;
+"""
+    end
+    case_str = case_str + case_append
+  end
+
+  case_str = case_str + """esac
+  ;;
+esac
+"""
+end
+
+def extract_flags(top_level_commands)
+  flags = top_level_commands.map { |c| [c.match(FLAG_REGEX)[0], c.split("  ")[-1].strip] if c.strip.start_with?("--") }.compact
+end
+
+def extract_subcommand(top_level_commands)
+  cmds = top_level_commands.map { |c| [c.match(CMDS_REGEX)[0].strip, c.split("  ")[-1].strip] if c.match(CMDS_REGEX) }.compact
+end
+
+def get_top_level_commands(root_command, cmd_list)
+  stdout, stderr, status = Open3.capture3("vagrant #{root_command} -h")
+  top_level_commands = stdout.split("\n")
+  
+  root_subcommand = extract_subcommand(top_level_commands)
+  commands = format_subcommand("sub_commands", root_subcommand)
+  if root_command == "box"
+    feature_string = "':feature:__box_list'"
+  elsif root_command == "plugin"
+    feature_string = "':feature:__plugin_list'"
+  else
+    feature_string = ""
+  end
+  case_string = format_case("sub_commands", root_subcommand, cmd_list, feature_string)
+
+  flags_def = ""
+  root_subcommand.each do |cmd, desc|
+    next if !cmd_list.include?(cmd)
+    stdout, stderr, status = Open3.capture3("vagrant #{root_command} #{cmd} -h")
+    cmd_help = stdout.split("\n")
+    flags_def = flags_def + format_flags("#{cmd}_arguments", extract_flags(cmd_help)) + "\n\n"
+  end
+
+  return commands, flags_def, case_string
+end
+
+def format_script(root_command, subcommands, funciton_name)
+  top_level_commands, top_level_args, state_case = get_top_level_commands(root_command, subcommands)
+  
+  script = """
+function #{funciton_name} () {
+
+  #{top_level_commands}
+
+  #{top_level_args}
+
+  _arguments -C ':command:->command' '*::options:->options'
+
+#{state_case}
+}
+"""
+end
+
+def generate_script
+  subcommand_list = {
+    "" => ["cloud", "destroy", "global-status", "halt", "help", "login", "init", "package", "port", "powershell", "provision", "push", "rdp", "reload", "resume", "ssh", "ssh-config", "status", "suspend", "up", "upload", "validate", "version", "winrm", "winrm-config"],
+    "box" => ["add", "list", "outdated", "prune", "remove", "repackage", "update"],
+    "snapshot" => ["delete", "list", "pop", "push", "restore", "save"],
+    "plugin" => ["install", "expunge", "license", "list", "repair", "uninstall", "update"],
+  }
+  
+  script = """#{HEAD}
+#{BOX_LIST_FUNCTION}
+#{PLUGIN_LIST_FUNCTION}
+"""
+
+  subcommand_list.each do |cmd, opts|
+    if cmd != ""
+      function_name = "__vagrant-#{cmd}"
+    else
+      function_name = "_vagrant"
+    end
+    script = script + format_script(cmd, opts, function_name)
+  end
+  script
+end
+
+puts generate_script

data/lib/vagrant.rb

@@ -9,6 +9,31 @@ class Log4r::BasicFormatter
   end
 end
 
+
+require "optparse"
+
+module Vagrant
+  # This is a customized OptionParser for Vagrant plugins. It
+  # will automatically add any default CLI options defined
+  # outside of command implementations to the local option
+  # parser instances in use
+  class OptionParser < ::OptionParser
+    def initialize(*_)
+      super
+      Vagrant.default_cli_options.each do |opt_proc|
+        opt_proc.call(self)
+      end
+    end
+  end
+end
+
+# Inject the option parser into the vagrant plugins
+# module so it is automatically used when defining
+# command options
+module VagrantPlugins
+  OptionParser = Vagrant::OptionParser
+end
+
 require "vagrant/shared_helpers"
 require "rubygems"
 require "vagrant/util"
@@ -68,10 +93,6 @@ if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != ""
         date_pattern: "%F %T"
       )
     end
-    # Vagrant Cloud gem uses RestClient to make HTTP requests, so
-    # log them if debug is enabled and use Vagrants logger
-    require 'rest_client'
-    RestClient.log = logger
 
     Log4r::Outputter.stderr.formatter = Vagrant::Util::LoggingFormatter.new(base_formatter)
     logger = nil

data/lib/vagrant/action.rb

@@ -2,6 +2,7 @@ require 'vagrant/action/builder'
 
 module Vagrant
   module Action
+    autoload :Hook,        'vagrant/action/hook'
     autoload :Runner,      'vagrant/action/runner'
     autoload :Warden,      'vagrant/action/warden'
 
@@ -12,14 +13,20 @@ module Vagrant
       autoload :BoxCheckOutdated, "vagrant/action/builtin/box_check_outdated"
       autoload :BoxRemove, "vagrant/action/builtin/box_remove"
       autoload :Call,    "vagrant/action/builtin/call"
+      autoload :CleanupDisks, "vagrant/action/builtin/cleanup_disks"
+      autoload :CloudInitSetup, "vagrant/action/builtin/cloud_init_setup"
+      autoload :CloudInitWait, "vagrant/action/builtin/cloud_init_wait"
       autoload :Confirm, "vagrant/action/builtin/confirm"
       autoload :ConfigValidate, "vagrant/action/builtin/config_validate"
+      autoload :Delayed, "vagrant/action/builtin/delayed"
       autoload :DestroyConfirm, "vagrant/action/builtin/destroy_confirm"
+      autoload :Disk, "vagrant/action/builtin/disk"
       autoload :EnvSet,  "vagrant/action/builtin/env_set"
       autoload :GracefulHalt, "vagrant/action/builtin/graceful_halt"
       autoload :HandleBox, "vagrant/action/builtin/handle_box"
       autoload :HandleBoxUrl, "vagrant/action/builtin/handle_box_url"
       autoload :HandleForwardedPortCollisions, "vagrant/action/builtin/handle_forwarded_port_collisions"
+      autoload :HasProvisioner, "vagrant/action/builtin/has_provisioner"
       autoload :IsEnvSet, "vagrant/action/builtin/is_env_set"
       autoload :IsState, "vagrant/action/builtin/is_state"
       autoload :Lock, "vagrant/action/builtin/lock"
@@ -32,6 +39,7 @@ module Vagrant
       autoload :SSHRun,  "vagrant/action/builtin/ssh_run"
       autoload :SyncedFolders, "vagrant/action/builtin/synced_folders"
       autoload :SyncedFolderCleanup, "vagrant/action/builtin/synced_folder_cleanup"
+      autoload :Trigger, "vagrant/action/builtin/trigger"
       autoload :WaitForCommunicator, "vagrant/action/builtin/wait_for_communicator"
     end
 

data/lib/vagrant/action/builder.rb

@@ -17,6 +17,11 @@ module Vagrant
     #     Vagrant::Action.run(app)
     #
     class Builder
+      # Container for Action arguments
+      MiddlewareArguments = Struct.new(:parameters, :block, :keywords, keyword_init: true)
+      # Item within the stack
+      StackItem = Struct.new(:middleware, :arguments, keyword_init: true)
+
       # This is the stack of middlewares added. This should NOT be used
       # directly.
       #
@@ -28,8 +33,8 @@ module Vagrant
       # see {#use} instead.
       #
       # @return [Builder]
-      def self.build(middleware, *args, &block)
-        new.use(middleware, *args, &block)
+      def self.build(middleware, *args, **keywords, &block)
+        new.use(middleware, *args, **keywords, &block)
       end
 
       def initialize
@@ -58,12 +63,21 @@ module Vagrant
       # of the middleware.
       #
       # @param [Class] middleware The middleware class
-      def use(middleware, *args, &block)
+      def use(middleware, *args, **keywords, &block)
+        item = StackItem.new(
+          middleware: middleware,
+          arguments: MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+
         if middleware.kind_of?(Builder)
           # Merge in the other builder's stack into our own
           self.stack.concat(middleware.stack)
         else
-          self.stack << [middleware, args, block]
+          self.stack << item
         end
 
         self
@@ -71,8 +85,22 @@ module Vagrant
 
       # Inserts a middleware at the given index or directly before the
       # given middleware object.
-      def insert(index, middleware, *args, &block)
-        index = self.index(index) unless index.is_a?(Integer)
+      def insert(idx_or_item, middleware, *args, **keywords, &block)
+        item = StackItem.new(
+          middleware: middleware,
+          arguments: MiddlewareArguments.new(
+            parameters: args,
+            keywords: keywords,
+            block: block
+          )
+        )
+
+        if idx_or_item.is_a?(Integer)
+          index = idx_or_item
+        else
+          index = self.index(idx_or_item)
+        end
+
         raise "no such middleware to insert before: #{index.inspect}" unless index
 
         if middleware.kind_of?(Builder)
@@ -80,27 +108,32 @@ module Vagrant
             stack.insert(index, stack_item)
           end
         else
-          stack.insert(index, [middleware, args, block])
+          stack.insert(index, item)
         end
       end
 
       alias_method :insert_before, :insert
 
       # Inserts a middleware after the given index or middleware object.
-      def insert_after(index, middleware, *args, &block)
-        index = self.index(index) unless index.is_a?(Integer)
+      def insert_after(idx_or_item, middleware, *args, **keywords, &block)
+        if idx_or_item.is_a?(Integer)
+          index = idx_or_item
+        else
+          index = self.index(idx_or_item)
+        end
+
         raise "no such middleware to insert after: #{index.inspect}" unless index
         insert(index + 1, middleware, *args, &block)
       end
 
       # Replaces the given middlware object or index with the new
       # middleware.
-      def replace(index, middleware, *args, &block)
+      def replace(index, middleware, *args, **keywords, &block)
         if index.is_a?(Integer)
           delete(index)
-          insert(index, middleware, *args, &block)
+          insert(index, middleware, *args, **keywords, &block)
         else
-          insert_before(index, middleware, *args, &block)
+          insert_before(index, middleware, *args, **keywords, &block)
           delete(index)
         end
       end
@@ -122,8 +155,10 @@ module Vagrant
       # @return [Integer]
       def index(object)
         stack.each_with_index do |item, i|
-          return i if item[0] == object
-          return i if item[0].respond_to?(:name) && item[0].name == object
+          return i if item == object
+          return i if item.middleware == object
+          return i if item.middleware.respond_to?(:name) &&
+            item.middleware.name == object
         end
 
         nil
@@ -132,42 +167,153 @@ module Vagrant
       # Converts the builder stack to a runnable action sequence.
       #
       # @param [Hash] env The action environment hash
-      # @return [Object] A callable object
+      # @return [Warden] A callable object
       def to_app(env)
-        app_stack = nil
+        # Start with a duplicate of ourself which can
+        # be modified
+        builder = self.dup
+
+        # Apply all dynamic modifications of the stack. This
+        # will generate dynamic hooks for all actions within
+        # the stack, load any triggers for action classes, and
+        # apply them to the builder's stack
+        builder.apply_dynamic_updates(env)
+
+        # Now that the stack is fully expanded, apply any
+        # action hooks that may be defined so they are on
+        # the outermost locations of the stack
+        builder.apply_action_name(env)
+
+        # Wrap the middleware stack with the Warden to provide a consistent
+        # and predictable behavior upon exceptions.
+        Warden.new(builder.stack.dup, env)
+      end
+
+      # Find any action hooks or triggers which have been defined
+      # for items within the stack. Update the stack with any
+      # hooks or triggers found.
+      #
+      # @param [Hash] env Call environment
+      # @return [Builder] self
+      def apply_dynamic_updates(env)
+        if Vagrant::Util::Experimental.feature_enabled?("typed_triggers")
+          triggers = env[:triggers]
+        end
+
+        # Use a Hook as a convenient interface for injecting
+        # any applicable trigger actions within the stack
+        machine_name = env[:machine].name if env[:machine]
+
+        # Iterate over all items in the stack and apply new items
+        # into the hook as they are found. Must be sure to dup the
+        # stack here since we are modifying the stack in the loop.
+        stack.dup.each do |item|
+          hook = Hook.new
+
+          action = item.first
+          next if action.is_a?(Proc)
+
+          # Start with adding any action triggers that may be defined
+          if triggers && !triggers.find(action, :before, machine_name, :action).empty?
+            hook.prepend(Vagrant::Action::Builtin::Trigger,
+              action.name, triggers, :before, :action)
+          end
+
+          if triggers && !triggers.find(action, :after, machine_name, :action).empty?
+            hook.append(Vagrant::Action::Builtin::Trigger,
+              action.name, triggers, :after, :action)
+          end
 
-        # If we have action hooks, then we apply them
-        if env[:action_hooks]
-          builder = self.dup
+          # Next look for any hook triggers that may be defined against
+          # the dynamically generated action class hooks
+          if triggers && !triggers.find(action, :before, machine_name, :hook).empty?
+            hook.prepend(Vagrant::Action::Builtin::Trigger,
+              action.name, triggers, :before, :hook)
+          end
 
-          # These are the options to pass into hook application.
-          options = {}
+          if triggers && !triggers.find(action, :after, machine_name, :hook).empty?
+            hook.append(Vagrant::Action::Builtin::Trigger,
+              action.name, triggers, :after, :hook)
+          end
 
-          # If we already ran through once and did append/prepends,
-          # then don't do it again.
-          if env[:action_hooks_already_ran]
-            options[:no_prepend_or_append] = true
+          # Finally load any registered hooks for dynamically generated
+          # action class based hooks
+          Vagrant.plugin("2").manager.find_action_hooks(action).each do |hook_proc|
+            hook_proc.call(hook)
           end
 
-          # Specify that we already ran, so in the future we don't repeat
-          # the prepend/append hooks.
-          env[:action_hooks_already_ran] = true
+          hook.apply(self, root: item)
+        end
+
+        # Apply the hook to ourself to update the stack
+        self
+      end
+
+      # If action hooks have not already been set, this method
+      # will perform three tasks:
+      #   1. Load any hook triggers defined for the action_name
+      #   2. Load any action_hooks defined from plugins
+      #   3. Load any action triggers based on machine action called (not action classes)
+      #
+      # @param [Hash] env Call environment
+      # @return [Builder]
+      def apply_action_name(env)
+        env[:builder_raw_applied] ||= []
+        return self if !env[:action_name]
+
+        hook = Hook.new
+        machine_name = env[:machine].name if env[:machine]
 
-          # Apply all the hooks to the new builder instance
-          env[:action_hooks].each do |hook|
-            hook.apply(builder, options)
+        # Start with loading any hook triggers if applicable
+        if Vagrant::Util::Experimental.feature_enabled?("typed_triggers") && env[:triggers]
+          if !env[:triggers].find(env[:action_name], :before, machine_name, :hook).empty?
+            hook.prepend(Vagrant::Action::Builtin::Trigger,
+              env[:action_name], env[:triggers], :before, :hook)
+          end
+          if !env[:triggers].find(env[:action_name], :after, machine_name, :hook).empty?
+            hook.append(Vagrant::Action::Builtin::Trigger,
+              env[:action_name], env[:triggers], :after, :hook)
           end
+        end
 
-          # The stack is now the result of the new builder
-          app_stack = builder.stack.dup
+        # Next we load up all the action hooks that plugins may
+        # have defined
+        action_hooks = Vagrant.plugin("2").manager.action_hooks(env[:action_name])
+        action_hooks.each do |hook_proc|
+          hook_proc.call(hook)
         end
 
-        # If we don't have a stack then default to using our own
-        app_stack ||= stack.dup
+        # Finally load any action triggers defined. The action triggers
+        # are the originally implemented trigger style. They run before
+        # and after specific provider actions (like :up, :halt, etc) and
+        # are different from true action triggers
+        if env[:triggers] && !env[:builder_raw_applied].include?(env[:raw_action_name])
+          env[:builder_raw_applied] << env[:raw_action_name]
 
-        # Wrap the middleware stack with the Warden to provide a consistent
-        # and predictable behavior upon exceptions.
-        Warden.new(app_stack, env)
+          if !env[:triggers].find(env[:raw_action_name], :before, machine_name, :action, all: true).empty?
+            hook.prepend(Vagrant::Action::Builtin::Trigger,
+              env[:raw_action_name], env[:triggers], :before, :action, all: true)
+          end
+          if !env[:triggers].find(env[:raw_action_name], :after, machine_name, :action, all: true).empty?
+            # NOTE: These after triggers need to be delayed before running to
+            #       allow the rest of the call stack to complete before being
+            #       run. The delayed action is prepended to the stack (not appended)
+            #       to ensure it is called first, which results in it properly
+            #       waiting for everything to finish before itself completing.
+            builder = self.class.build(Vagrant::Action::Builtin::Trigger,
+              env[:raw_action_name], env[:triggers], :after, :action, all: true)
+            hook.prepend(Vagrant::Action::Builtin::Delayed, builder)
+          end
+        end
+
+        # If the hooks are empty, then there was nothing to apply and
+        # we can just send ourself back
+        return self if hook.empty?
+
+        # Apply all the hooks to the new builder instance
+        hook.apply(self)
+
+        self
       end
     end
   end