vagrant-unbundled 2.2.9.0 → 2.2.10.0

data/contrib/zsh/generate_zsh_completion.rb

@@ -0,0 +1,166 @@
+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/action.rb

@@ -14,6 +14,8 @@ module Vagrant
       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"
@@ -24,6 +26,7 @@ module Vagrant
       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"

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
@@ -123,8 +156,9 @@ module Vagrant
       def index(object)
         stack.each_with_index do |item, i|
           return i if item == object
-          return i if item[0] == object
-          return i if item[0].respond_to?(:name) && item[0].name == object
+          return i if item.middleware == object
+          return i if item.middleware.respond_to?(:name) &&
+            item.middleware.name == object
         end
 
         nil
@@ -252,18 +286,18 @@ module Vagrant
         # and after specific provider actions (like :up, :halt, etc) and
         # are different from true action triggers
         if env[:triggers]
-          if !env[:triggers].find(env[:raw_action_name], :before, machine_name, :action).empty?
+          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)
+              env[:raw_action_name], env[:triggers], :before, :action, all: true)
           end
-          if !env[:triggers].find(env[:raw_action_name], :after, machine_name, :action).empty?
+          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)
+              env[:raw_action_name], env[:triggers], :after, :action, all: true)
             hook.prepend(Vagrant::Action::Builtin::Delayed, builder)
           end
         end

data/lib/vagrant/action/builtin/box_add.rb

@@ -25,6 +25,7 @@ module Vagrant
         def initialize(app, env)
           @app    = app
           @logger = Log4r::Logger.new("vagrant::action::builtin::box_add")
+          @parser = URI::RFC2396_Parser.new
         end
 
         def call(env)
@@ -44,7 +45,7 @@ module Vagrant
             u = u.gsub("\\", "/")
             if Util::Platform.windows? && u =~ /^[a-z]:/i
               # On Windows, we need to be careful about drive letters
-              u = "file:///#{URI.escape(u)}"
+              u = "file:///#{@parser.escape(u)}"
             end
 
             if u =~ /^[a-z0-9]+:.*$/i && !u.start_with?("file://")
@@ -53,9 +54,9 @@ module Vagrant
             end
 
             # Expand the path and try to use that, if possible
-            p = File.expand_path(URI.unescape(u.gsub(/^file:\/\//, "")))
+            p = File.expand_path(@parser.unescape(u.gsub(/^file:\/\//, "")))
             p = Util::Platform.cygwin_windows_path(p)
-            next "file://#{URI.escape(p.gsub("\\", "/"))}" if File.file?(p)
+            next "file://#{@parser.escape(p.gsub("\\", "/"))}" if File.file?(p)
 
             u
           end
@@ -434,7 +435,7 @@ module Vagrant
           downloader_options[:ui] = env[:ui] if opts[:ui]
           downloader_options[:location_trusted] = env[:box_download_location_trusted]
           downloader_options[:box_extra_download_options] = env[:box_extra_download_options]
-          
+
           Util::Downloader.new(url, temp_path, downloader_options)
         end
 
@@ -495,7 +496,7 @@ module Vagrant
             url ||= uri.opaque
             #7570 Strip leading slash left in front of drive letter by uri.path
             Util::Platform.windows? && url.gsub!(/^\/([a-zA-Z]:)/, '\1')
-            url = URI.unescape(url)
+            url = @parser.unescape(url)
 
             begin
               File.open(url, "r") do |f|

data/lib/vagrant/action/builtin/cloud_init_setup.rb

@@ -0,0 +1,127 @@
+require 'mime'
+require 'tmpdir'
+
+module Vagrant
+  module Action
+    module Builtin
+      class CloudInitSetup
+        TEMP_PREFIX = "vagrant-cloud-init-iso-temp-".freeze
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::cloudinit::setup")
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          user_data_configs = machine.config.vm.cloud_init_configs
+                                                  .select { |c| c.type == :user_data }
+
+          if !user_data_configs.empty?
+            user_data = setup_user_data(machine, env, user_data_configs)
+            meta_data = { "instance-id" => "i-#{machine.id.split('-').join}" }
+
+            write_cfg_iso(machine, env, user_data, meta_data)
+          end
+
+          # Continue On
+          @app.call(env)
+        end
+
+        # @param [Vagrant::Machine] machine
+        # @param [Vagrant::Environment] env
+        # @param [Array<#VagrantPlugins::Kernel_V2::VagrantConfigCloudInit>] user_data_cfgs
+        # @return [MIME::Text] user_data
+        def setup_user_data(machine, env, user_data_cfgs)
+          machine.ui.info(I18n.t("vagrant.actions.vm.cloud_init_user_data_setup"))
+
+          text_cfgs = user_data_cfgs.map { |cfg| read_text_cfg(machine, cfg) }
+
+          user_data = generate_cfg_msg(machine, text_cfgs)
+          user_data
+        end
+
+        # Reads an individual cloud_init config and stores its contents and the
+        # content_type as a MIME text
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigCloudInit] cfg
+        # @return [MIME::Text] text_msg
+        def read_text_cfg(machine, cfg)
+          if cfg.path
+            text = File.read(Pathname.new(cfg.path).expand_path(machine.env.root_path))
+          else
+            text = cfg.inline
+          end
+
+          # Note: content_type must remove the leading `text/` because
+          # the MIME::Text initializer hardcodes `text/` already to the type.
+          # We assume content_type is correct due to the validation step
+          # in VagrantConfigCloudInit.
+          content_type = cfg.content_type.split('/', 2).last
+          text_msg = MIME::Text.new(text, content_type)
+
+          text_msg
+        end
+
+        # Combines all known cloud_init configs into a multipart mixed MIME text
+        # message
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Array<MIME::Text>] text_msg - One or more text configs
+        # @return [MIME::Multipart::Mixed] msg
+        def generate_cfg_msg(machine, text_cfgs)
+          msg = MIME::Multipart::Mixed.new
+          msg.headers.set("MIME-Version", "1.0")
+
+          text_cfgs.each do |c|
+            msg.add(c)
+          end
+
+          msg
+        end
+
+        # Writes the contents of the guests cloud_init config to a tmp
+        # dir and passes that source directory along to the host cap to be
+        # written to an iso
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [MIME::Multipart::Mixed] user_data
+        # @param [Hash] meta_data
+        def write_cfg_iso(machine, env, user_data, meta_data)
+          iso_path = nil
+
+          if env[:env].host.capability?(:create_iso)
+            begin
+              source_dir = Pathname.new(Dir.mktmpdir(TEMP_PREFIX))
+              File.open("#{source_dir}/user-data", 'w') { |file| file.write(user_data.to_s) }
+
+              File.open("#{source_dir}/meta-data", 'w') { |file| file.write(meta_data.to_yaml) }
+
+              iso_path = env[:env].host.capability(:create_iso,
+                                                   source_dir, volume_id: "cidata")
+              attach_disk_config(machine, env, iso_path.to_path)
+            ensure
+              FileUtils.remove_entry(source_dir)
+            end
+          else
+            raise Errors::CreateIsoHostCapNotFound
+          end
+        end
+
+        # Adds a new :dvd disk config with the given iso_path to be attached
+        # to the guest later
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Vagrant::Environment] env
+        # @param [String] iso_path
+        def attach_disk_config(machine, env, iso_path)
+          @logger.info("Adding cloud_init iso '#{iso_path}' to disk config")
+          machine.config.vm.disk :dvd, file: iso_path, name: "vagrant-cloud_init-disk"
+          machine.config.vm.disks.each { |d| d.finalize! if d.type == :dvd && d.file == iso_path }
+        end
+      end
+    end
+  end
+end