vagrant-unbundled 2.2.6.0 → 2.2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f5ee7bf52fe56d658a0fcf504b6c249cfe7b44ac95ecceca6bae522ddff8059
-  data.tar.gz: ebe57eb1296b2aabb5743cdf206542b51a77b49a0da762cb543b65b086ddce38
+  metadata.gz: fc8998228365e044e5c4dae334de559593ead91cec2b40a2fb4b659068de08ed
+  data.tar.gz: a1c1681b1fcea9ad3079a71ce3a36ff13a950149d997ccb110c95bec92c7a329
 SHA512:
-  metadata.gz: e1ef1d56b65999992a07f14ffc27badda9932de46b307512ee94bb54736c9931699391d48a992ce083d3dff4f517338c8f2e9bd5d3257c7c937bcfc9a0e93309
-  data.tar.gz: b9767d4e3f0d6a5e09f9028642eb10237eca09f155d9a1dad7b29e6d18ef8db88aa80776f9992e6226dca4ccc2dbc60e91d8fd17a32a99fca981710eb4698f73
+  metadata.gz: 46388919cbbee6ce29ad5a4590ca652736076d1f951d50574ff66babd15acb22829db1e61a4bae7962af5734d27e7fbbc6c8262fc62ac147ac5d0736e560051b
+  data.tar.gz: 6ceff4e11163fe20e30415a9582c34a94b8241603c0807cc9a8cd10209fc9904ce7cd79f6ae66a2e238d179d90aef071b894792e649d8223f327b511d2c735f3

data/.hashibot.hcl

@@ -0,0 +1,14 @@
+poll "closed_issue_locker" "locker" {
+  schedule             = "0 50 1 * * *"
+  closed_for           = "720h" # 30 days
+  max_issues           = 500
+  sleep_between_issues = "5s"
+
+  no_comment_if_no_activity_for = "4320h" # 180 days
+
+  message = <<-EOF
+    I'm going to lock this issue because it has been closed for _30 days_ ⏳. This helps our maintainers find and focus on the active issues.
+
+    If you have found a problem that seems similar to this, please open a new issue and complete the issue template so we can capture all the details necessary to investigate further.
+  EOF
+}

data/CHANGELOG.md

@@ -1,3 +1,94 @@
+## 2.2.9 (May 07, 2020)
+
+BUG FIXES:
+
+- core/bundler: Properly handle plugin install with available specification [GH-11592]
+- provisioners/docker: Fix CentOS docker install and start service capabilities [GH-11581]
+- provisioners/podman: Seperate RHEL install from CentOS install [GH-11584]
+
+## 2.2.8 (May 04, 2020)
+
+FEATURES:
+
+- virtualbox/disks: Add ability to manage virtual disks for guests [GH-11349]
+
+IMPROVEMENTS:
+
+- bin/vagrant: Automatically include global options within commands [GH-11473]
+- bin/vagrant: Suppress Ruby warnings when not running pre-release version [GH-11446]
+- communicator/ssh: Add support for configuring SSH connect timeout [GH-11533]
+- core: Update childprocess gem [GH-11487]
+- core: Add cli option `--no-tty` [GH-11414]
+- core: Overhaul call stack modifications implementation for hooks and triggers [GH-11455]
+- core/bundler: Cache plugin solution sets to speed up startup times [GH-11363]
+- config/vm: Add`box_download_options` config to specify extra download options for a box [GH-11560]
+- guest/alpine: Add ansible provisioner guest support [GH-11411]
+- guest/linux: Update systemd? check to use sudo [GH-11398]
+- guest/linux: Use systemd if available to halt and reboot system [GH-11407]
+- guests/linux: Mount smb folders with `mfsymlinks` option by default [GH-11503]
+- guest/redhat: Add support for SMB [GH-11463]
+- guest/windows: Rescue all regular exceptions during reboot wait [GH-11428]
+- providers/docker: Support catching container name when using podman [GH-11356]
+- provisioners/docker: Support Centos8 [GH-11462]
+- provisioners/podman: Add Podman as a provisioner [GH-11472]
+- provisioners/salt: Allow specifying python_version [GH-11436]
+
+BUG FIXES:
+
+- communicators/winssh: Fix issues with Windows SSH communicator [GH-11430]
+- core/bundler: Activate vagrant specification when not active [GH-11445]
+- core/bundler: Properly resolve sets when Vagrant is in prerelease [GH-11571]
+- core/downloader: Always set `-q` flag as first option [GH-11366]
+- core/hooks: Update dynamic action hook implementation to prevent looping [GH-11427]
+- core/synced_folders: Validate type option if set [GH-11359]
+- guests/debian: Choose netplan renderer based on network configuration and installed tools [GH-11498]
+- host/darwin: Quote directories in /etc/exports [GH-11441]
+- host/linux: Ensure `/etc/exports` does not contain duplicate records [GH-10591]
+- host/windows: Check all interfaces for port conflict when host_ip: "0.0.0.0" [GH-11454]
+- providers/docker: Fix issue where Vagrant fails to remove image if it is in use [GH-11355]
+- providers/docker: Fix issue with getting correct docker image id from build output [GH-11461]
+- providers/hyperv: Prevent error when identity reference cannot be translated [GH-11425]
+- provider/hyperv: Use service id for manipulating vm integration services [GH-11499]
+- providers/virtualbox: Parse `list dhcpservers` output on VirtualBox 6.1 [GH-11404]
+- providers/virtualbox: Raise an error if guest IP ends in .1 [GH-11500]
+- provisioners/shell: Ensure windows shell provisioners always get an extension [GH-11517]
+- util/io: Fix encoding conversion errors [GH-11571]
+
+## 2.2.7 (January 27, 2020)
+
+IMPROVEMENTS:
+
+- guest/opensuse: Check for basename hostname prior to setting hostname [GH-11170]
+- host/linux: Check for modinfo in /sbin if it's not on PATH [GH-11178]
+- core: Show guest name in hostname error message [GH-11175]
+- provisioners/shell: Linux guests now support `reboot` option [GH-11194]
+- darwin/nfs: Put each NFS export on its own line [GH-11216]
+- contrib/bash: Add more completion flags to up command [GH-11223]
+- provider/virtualbox: Add VirtualBox provider support for version 6.1.x [GH-11250]
+- box/outdated: Allow to force check for box updates and ignore cached check [GH-11231]
+- guest/alpine: Update apk cache when installing rsync [GH-11220]
+- provider/virtualbox: Improve error message when machine folder is inaccessible [GH-11239]
+- provisioner/ansible_local: Add pip install method for arch guests [GH-11265]
+- communicators/winssh: Use Windows shell for `vagrant ssh -c` [GH-11258]
+
+BUG FIXES:
+
+- command/snapshot/save: Fix regression that prevented snapshot of all guests in environment [GH-11152]
+- core: Update UI to properly retain newlines when adding prefix [GH-11126]
+- core: Check if box update is available locally [GH-11188]
+- core: Ensure Vagrant::Errors are loaded in file_checksum util [GH-11183]
+- cloud/publish: Improve argument handling for missing arguments to command [GH-11184]
+- core: Get latest version for current provider during outdated check [GH-11192]
+- linux/nfs: avoid adding extra newlines to /etc/exports [GH-11201]
+- guest/darwin: Fix VMware synced folders on APFS [GH-11267]
+- guest/redhat: Ensure `nfs-server` is restarted when installing nfs client [GH-11212]
+- core: Do not validate checksums if options are empty string [GH-11211]
+- provider/docker: Enhance docker build method to match against buildkit output [GH-11205]
+- provisioner/ansible_local: Don't prompt for input when installing Ansible on Ubuntu and Debian [GH-11191]
+- provisioner/ansible_local: Ensure all guest caps accept all passed in arguments [GH-11265]
+- host/windows: Fix regression that prevented port collisions from being detected [GH-11244]
+- core/provisioner: Set top level provisioner name if set in a provisioner config [GH-11295]
+
 ## 2.2.6 (October 14, 2019)
 
 FEATURES:
@@ -13,7 +104,7 @@ IMPROVEMENTS:
 - guest/alt: Improve handling for using network tools when setting hostname [GH-11000]
 - guest/suse: Add ipv6 network config templates for SUSE based distributions [GH-11013]
 - guest/windows: Retry on connection timeout errors for the reboot capability [GH-11093]
-- host/bsd: Use host resolve path capability to modify local paths if requird [GH-11108]
+- host/bsd: Use host resolve path capability to modify local paths if required [GH-11108]
 - host/darwin: Add host resolve path capability to provide real paths for firmlinks [GH-11108]
 - provisioners/chef: Update pkg install flags for chef on FreeBSD guests [GH-11075]
 - provider/hyperv: Improve error message when VMMS is not running [GH-10978]
@@ -509,7 +600,7 @@ BUG FIXES:
   - core: Rescue more exceptions when checking if port is open [GH-8517]
   - guests/solaris11: Inherit from Solaris guest and keep solaris11 specific methods [GH-9034]
   - guests/windows: Split out cygwin path helper for msys2/cygwin paths and ensure cygpath exists [GH-8972]
-  - guests/windows: Specify expected shell when executing on guest (fixes winssh communicator usage) [GH-9012]
+  - guests/windows: Specify expected shell when executing on guest (fixes einssh communicator usage) [GH-9012]
   - guests/windows: Include WinSSH Communicator when using insert_public_key [GH-9105]
   - hosts/windows: Check for vagrant.exe when validating versions within WSL [GH-9107, GH-8962]
   - providers/docker: Isolate windows check within executor to handle running through VM [GH-8921]

data/README.md

@@ -2,9 +2,7 @@
 
 * Website: [https://www.vagrantup.com/](https://www.vagrantup.com/)
 * Source: [https://github.com/hashicorp/vagrant](https://github.com/hashicorp/vagrant)
-* [![Gitter chat](https://badges.gitter.im/mitchellh/vagrant.png)](https://gitter.im/mitchellh/vagrant)
-* Mailing list: [Google Groups](https://groups.google.com/group/vagrant-up)
-* IRC: #vagrant on freenode.org
+* HashiCorp Discuss: [https://discuss.hashicorp.com/c/vagrant/24](https://discuss.hashicorp.com/c/vagrant/24)
 
 Vagrant is a tool for building and distributing development environments.
 

data/bin/vagrant

@@ -94,6 +94,23 @@ begin
   # Schedule the cleanup of things
   at_exit(&Vagrant::Bundler.instance.method(:deinit))
 
+  # If this is not a pre-release disable verbose output
+  if !Vagrant.prerelease?
+    $VERBOSE = nil
+  end
+
+  # Add any option flags defined within this file here
+  # so they are automatically propagated to all commands
+  Vagrant.add_default_cli_options(proc { |o|
+    o.on("--[no-]color", "Enable or disable color output")
+    o.on("--machine-readable", "Enable machine readable output")
+    o.on("-v", "--version", "Display Vagrant version")
+    o.on("--debug", "Enable debug output")
+    o.on("--timestamp", "Enable timestamps on log output")
+    o.on("--debug-timestamp", "Enable debug output with timestamps")
+    o.on("--no-tty", "Enable non-interactive output")
+  })
+
   # Create a logger right away
   logger = Log4r::Logger.new("vagrant::bin::vagrant")
   logger.info("`vagrant` invoked: #{ARGV.inspect}")
@@ -130,6 +147,12 @@ begin
     opts[:ui_class] = Vagrant::UI::MachineReadable
   end
 
+  # Setting to enable/disable showing progress bars
+  if argv.include?("--no-tty")
+    argv.delete("--no-tty")
+    opts[:ui_class] = Vagrant::UI::NonInteractive
+  end
+
   # Default to colored output
   opts[:ui_class] ||= Vagrant::UI::Colored
 

data/contrib/bash/completion.sh

@@ -75,7 +75,19 @@ _vagrant() {
               then
                 local vm_list=$(find "${vagrant_state_file}/machines" -mindepth 1 -maxdepth 1 -type d -exec basename {} \;)
               fi
-              local up_commands="--no-provision"
+              local up_commands="\
+                --provision \
+                --no-provision \
+                --provision-with \
+                --destroy-on-error \
+                --no-destroy-on-error \
+                --parallel \
+                --no-parallel
+                --provider \
+                --install-provider \
+                --no-install-provider \
+                -h \
+                --help"
               COMPREPLY=($(compgen -W "${up_commands} ${vm_list}" -- ${cur}))
               return 0
             ;;

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"

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,9 +13,12 @@ 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 :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"
@@ -32,6 +36,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

@@ -122,6 +122,7 @@ module Vagrant
       # @return [Integer]
       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
         end
@@ -132,42 +133,162 @@ 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
 
-        # If we have action hooks, then we apply them
-        if env[:action_hooks]
-          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)
 
-          # These are the options to pass into hook application.
-          options = {}
+        # 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)
 
-          # 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
+        # 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
 
-          # Specify that we already ran, so in the future we don't repeat
-          # the prepend/append hooks.
-          env[:action_hooks_already_ran] = true
+          if triggers && !triggers.find(action, :after, machine_name, :action).empty?
+            hook.append(Vagrant::Action::Builtin::Trigger,
+              action.name, triggers, :after, :action)
+          end
+
+          # 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
+
+          if triggers && !triggers.find(action, :after, machine_name, :hook).empty?
+            hook.append(Vagrant::Action::Builtin::Trigger,
+              action.name, triggers, :after, :hook)
+          end
 
-          # Apply all the hooks to the new builder instance
-          env[:action_hooks].each do |hook|
-            hook.apply(builder, options)
+          # 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
 
-          # The stack is now the result of the new builder
-          app_stack = builder.stack.dup
+          hook.apply(self, root: item)
         end
 
-        # If we don't have a stack then default to using our own
-        app_stack ||= stack.dup
+        # Apply the hook to ourself to update the stack
+        self
+      end
 
-        # Wrap the middleware stack with the Warden to provide a consistent
-        # and predictable behavior upon exceptions.
-        Warden.new(app_stack, env)
+      # 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)
+        return self if !env[:action_name]
+        hook = Hook.new
+        machine_name = env[:machine].name if env[:machine]
+
+        # 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
+
+        # 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
+
+        # 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]
+          if !env[:triggers].find(env[:raw_action_name], :before, machine_name, :action).empty?
+            hook.prepend(Vagrant::Action::Builtin::Trigger,
+              env[:raw_action_name], env[:triggers], :before, :action)
+          end
+          if !env[:triggers].find(env[:raw_action_name], :after, machine_name, :action).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)
+            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?
+
+        # These are the options to pass into hook application.
+        options = {}
+
+        # 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
+        end
+
+        # Specify that we already ran, so in the future we don't repeat
+        # the prepend/append hooks.
+        env[:action_hooks_already_ran] = true
+
+        # Apply all the hooks to the new builder instance
+        hook.apply(self, options)
+
+        self
       end
     end
   end