vagrant-unbundled 2.2.9.0 → 2.2.10.0

data/plugins/kernel_v2/config/vm_trigger.rb

@@ -114,7 +114,11 @@ module VagrantPlugins
 
         # Internal options
         @id = SecureRandom.uuid
-        @command = command.to_s
+        if command.respond_to?(:to_sym)
+          @command = command.to_sym
+        else
+          @command = command
+        end
         @ruby_block = UNSET_VALUE
 
         @logger.debug("Trigger defined for: #{command}")

data/plugins/providers/docker/action.rb

@@ -66,14 +66,8 @@ module VagrantPlugins
                 next
               end
 
-              b3.use Call, HasSSH do |env3, b4|
-                if env3[:result]
-                  b4.use Provision
-                else
-                  b4.use Message,
-                    I18n.t("docker_provider.messages.provision_no_ssh"),
-                    post: true
-                end
+              b3.use Call, HasProvisioner do |env3, b4|
+                b4.use Provision
               end
             end
           end
@@ -216,14 +210,8 @@ module VagrantPlugins
         Vagrant::Action::Builder.new.tap do |b|
           b.use Call, IsState, :running do |env, b2|
             if env[:machine_action] != :run_command
-              b2.use Call, HasSSH do |env2, b3|
-                if env2[:result]
-                  b3.use Provision
-                else
-                  b3.use Message,
-                    I18n.t("docker_provider.messages.provision_no_ssh"),
-                    post: true
-                end
+              b2.use Call, HasProvisioner do |env2, b3|
+                b3.use Provision
               end
             end
 
@@ -251,14 +239,16 @@ module VagrantPlugins
             if env[:machine_action] != :run_command
               # If the container is NOT created yet, then do some setup steps
               # necessary for creating it.
+
               b2.use Call, IsState, :preparing do |env2, b3|
                 if env2[:result]
                   b3.use EnvSet, port_collision_repair: true
                   b3.use HostMachinePortWarning
                   b3.use HostMachinePortChecker
+                  b3.use ForwardedPorts # This action converts the `ports` param into proper network configs
+                  b3.use PrepareForwardedPortCollisionParams
                   b3.use HandleForwardedPortCollisions
                   b3.use SyncedFolders
-                  b3.use ForwardedPorts
                   b3.use Pull
                   b3.use Create
                   b3.use WaitForRunning
@@ -313,6 +303,7 @@ module VagrantPlugins
       autoload :IsBuild, action_root.join("is_build")
       autoload :IsHostMachineCreated, action_root.join("is_host_machine_created")
       autoload :Login, action_root.join("login")
+      autoload :PrepareForwardedPortCollisionParams, action_root.join("prepare_forwarded_port_collision_params")
       autoload :PrepareNetworks, action_root.join("prepare_networks")
       autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
       autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")

data/plugins/providers/docker/action/forwarded_ports.rb

@@ -6,6 +6,8 @@ module VagrantPlugins
           @app = app
         end
 
+        # Converts the `ports` docker provider param into proper network configs
+        # of type :forwarded_port
         def call(env)
           env[:machine].provider_config.ports.each do |p|
             host_ip = nil

data/plugins/providers/docker/action/prepare_forwarded_port_collision_params.rb

@@ -0,0 +1,61 @@
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class PrepareForwardedPortCollisionParams
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          # Get the forwarded ports used by other containers and
+          # consider those in use as well.
+          other_used_ports = machine.provider.driver.read_used_ports
+          env[:port_collision_extra_in_use] = other_used_ports
+
+          # Build the remap for any existing collision detections
+          #
+          # Note: This remap might not be required yet (as it is with the virtualbox provider)
+          # so for now we leave the remap hash empty.
+          remap = {}
+          env[:port_collision_remap] = remap
+
+          # This port checker method calls the custom port_check method
+          # defined below. If its false, it will go ahead and use the built-in
+          # port_check method to see if there are any live containers with bound
+          # ports
+          docker_port_check = proc { |host_ip, host_port|
+                                      result = port_check(env, host_port)
+                                      if !result
+                                        result = Vagrant::Action::Builtin::HandleForwardedPortCollisions.port_check(machine, host_ip, host_port)
+                                      end
+                                      result}
+          env[:port_collision_port_check] = docker_port_check
+
+          @app.call(env)
+        end
+
+        protected
+
+        # This check is required the docker provider. Containers
+        # can bind ports but be halted. We don't want new containers to
+        # grab these bound ports, so this check is here for that since
+        # the checks above won't detect it
+        #
+        # @param [Vagrant::Environment] env
+        # @param [String] host_port
+        # @returns [Bool]
+        def port_check(env, host_port)
+          extra_in_use = env[:port_collision_extra_in_use]
+
+          if extra_in_use
+            return extra_in_use.include?(host_port.to_s)
+          else
+            return false
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/cap/has_communicator.rb

@@ -0,0 +1,11 @@
+module VagrantPlugins
+  module DockerProvider
+    module Cap
+      module HasCommunicator
+        def self.has_communicator(machine)
+          return machine.provider_config.has_ssh
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/communicator.rb

@@ -151,7 +151,7 @@ module VagrantPlugins
           "-i #{path}"
         end
 
-        # Use ad-hoc SSH options for the hop on the docker proxy 
+        # Use ad-hoc SSH options for the hop on the docker proxy
         if info[:forward_agent]
           ssh_args << "-o ForwardAgent=yes"
         end

data/plugins/providers/docker/driver.rb

@@ -126,6 +126,41 @@ module VagrantPlugins
         result =~ /^#{Regexp.escape(id)}$/
       end
 
+      # Reads all current docker containers and determines what ports
+      # are currently registered to be forwarded
+      # {2222=>#<Set: {"127.0.0.1"}>, 8080=>#<Set: {"*"}>, 9090=>#<Set: {"*"}>}
+      #
+      # Note: This is this format because of what the builtin action for resolving colliding
+      # port forwards expects.
+      #
+      # @return [Hash[Set]] used_ports - {forward_port: #<Set: {"host ip address"}>}
+      def read_used_ports
+        used_ports = Hash.new{|hash,key| hash[key] = Set.new}
+
+        all_containers.each do |c|
+          container_info = inspect_container(c)
+
+          if container_info["HostConfig"]["PortBindings"]
+            port_bindings = container_info["HostConfig"]["PortBindings"]
+            next if port_bindings.empty? # Nothing defined, but not nil either
+
+            port_bindings.each do |guest_port,host_mapping|
+              host_mapping.each do |h|
+                if h["HostIp"] == ""
+                  hostip = "*"
+                else
+                  hostip = h["HostIp"]
+                end
+                hostport = h["HostPort"]
+                used_ports[hostport].add(hostip)
+              end
+            end
+          end
+        end
+
+        used_ports
+      end
+
       def running?(cid)
         result = execute('docker', 'ps', '-q', '--no-trunc')
         result =~ /^#{Regexp.escape cid}$/m

data/plugins/providers/docker/plugin.rb

@@ -67,6 +67,11 @@ module VagrantPlugins
         Cap::ProxyMachine
       end
 
+      provider_capability("docker", "has_communicator") do
+        require_relative "cap/has_communicator"
+        Cap::HasCommunicator
+      end
+
       protected
 
       def self.init!

data/plugins/providers/hyperv/action.rb

@@ -149,6 +149,8 @@ module VagrantPlugins
                   b3.use NetSetMac
                 end
 
+                b3.use CleanupDisks
+                b3.use Disk
                 b3.use StartInstance
                 b3.use WaitForIPAddress
                 b3.use WaitForCommunicator, [:running]

data/plugins/providers/hyperv/action/configure.rb

@@ -97,6 +97,14 @@ module VagrantPlugins
               env[:machine].provider_config.vm_integration_services)
           end
 
+          if env[:machine].provider_config.enable_enhanced_session_mode
+            env[:ui].detail(I18n.t("vagrant.hyperv_enable_enhanced_session"))
+            env[:machine].provider.driver.set_enhanced_session_transport_type("HvSocket")
+          else
+            env[:ui].detail(I18n.t("vagrant.hyperv_disable_enhanced_session"))
+            env[:machine].provider.driver.set_enhanced_session_transport_type("VMBus")
+          end
+
           @app.call(env)
         end
       end

data/plugins/providers/hyperv/cap/cleanup_disks.rb

@@ -0,0 +1,54 @@
+require "log4r"
+require "vagrant/util/experimental"
+
+module VagrantPlugins
+  module HyperV
+    module Cap
+      module CleanupDisks
+        LOGGER = Log4r::Logger.new("vagrant::plugins::hyperv::cleanup_disks")
+
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
+        # @param [Hash] disk_meta_file - A hash of all the previously defined disks from the last configure_disk action
+        def self.cleanup_disks(machine, defined_disks, disk_meta_file)
+          return if disk_meta_file.values.flatten.empty?
+
+          return if !Vagrant::Util::Experimental.feature_enabled?("disks")
+
+          handle_cleanup_disk(machine, defined_disks, disk_meta_file["disk"])
+          # TODO: Floppy and DVD disks
+        end
+
+        protected
+
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
+        # @param [Hash] disk_meta - A hash of all the previously defined disks from the last configure_disk action
+        def self.handle_cleanup_disk(machine, defined_disks, disk_meta)
+          all_disks = machine.provider.driver.list_hdds
+
+          disk_meta.each do |d|
+            # look at Path instead of Name or UUID
+            disk_name  = File.basename(d["Path"], '.*')
+            dsk = defined_disks.select { |dk| dk.name == disk_name }
+
+            if !dsk.empty? || d["primary"] == true
+              next
+            else
+              LOGGER.warn("Found disk not in Vagrantfile config: '#{d["Name"]}'. Removing disk from guest #{machine.name}")
+
+              machine.ui.warn(I18n.t("vagrant.cap.cleanup_disks.disk_cleanup", name: d["Name"]), prefix: true)
+
+              disk_actual = all_disks.select { |a| File.realdirpath(a["Path"]) == File.realdirpath(d["Path"]) }.first
+              if !disk_actual
+                machine.ui.warn(I18n.t("vagrant.cap.cleanup_disks.disk_not_found", name: d["Name"]), prefix: true)
+              else
+                machine.provider.driver.remove_disk(disk_actual["ControllerType"], disk_actual["ControllerNumber"], disk_actual["ControllerLocation"], disk_actual["Path"])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/providers/hyperv/cap/configure_disks.rb

@@ -0,0 +1,200 @@
+require "log4r"
+require "fileutils"
+require "vagrant/util/numeric"
+require "vagrant/util/experimental"
+
+module VagrantPlugins
+  module HyperV
+    module Cap
+      module ConfigureDisks
+        LOGGER = Log4r::Logger.new("vagrant::plugins::hyperv::configure_disks")
+
+        # @param [Vagrant::Machine] machine
+        # @param [VagrantPlugins::Kernel_V2::VagrantConfigDisk] defined_disks
+        # @return [Hash] configured_disks - A hash of all the current configured disks
+        def self.configure_disks(machine, defined_disks)
+          return {} if defined_disks.empty?
+
+          return {} if !Vagrant::Util::Experimental.feature_enabled?("disks")
+
+          machine.ui.info(I18n.t("vagrant.cap.configure_disks.start"))
+
+          current_disks = machine.provider.driver.list_hdds
+
+          configured_disks = {disk: [], floppy: [], dvd: []}
+
+          defined_disks.each do |disk|
+            if disk.type == :disk
+              disk_data = handle_configure_disk(machine, disk, current_disks)
+              configured_disks[:disk] << disk_data unless disk_data.empty?
+            elsif disk.type == :floppy
+              # TODO: Write me
+              machine.ui.info(I18n.t("vagrant.cap.configure_disks.floppy_not_supported", name: disk.name))
+            elsif disk.type == :dvd
+              # TODO: Write me
+              machine.ui.info(I18n.t("vagrant.cap.configure_disks.dvd_not_supported", name: disk.name))
+            end
+          end
+
+          configured_disks
+        end
+
+        protected
+
+        # @param [Vagrant::Machine] machine - the current machine
+        # @param [Config::Disk] disk - the current disk to configure
+        # @param [Array] all_disks - A list of all currently defined disks in VirtualBox
+        # @return [Hash] current_disk - Returns the current disk. Returns nil if it doesn't exist
+        def self.get_current_disk(machine, disk, all_disks)
+          current_disk = nil
+          if disk.primary
+            # Ensure we grab the proper primary disk
+            # We can't rely on the order of `all_disks`, as they will not
+            # always come in port order, but primary should always be Location 0 Number 0.
+
+            current_disk = all_disks.detect { |d| d["ControllerLocation"] == 0 && d["ControllerNumber"] == 0 }
+
+            # Need to get actual disk info to obtain UUID instead of what's returned
+            #
+            # This is not required for newly created disks, as its metadata is
+            # set when creating and attaching the disk. This is only for the primary
+            # disk, since it already exists.
+            current_disk = machine.provider.driver.get_disk(current_disk["Path"])
+          else
+            # Hyper-V disk names aren't the actual names of the disk, so we have
+            # to grab the name from the file path instead
+            current_disk = all_disks.detect { |d| File.basename(d["Path"], '.*') == disk.name}
+          end
+
+          current_disk
+        end
+
+        # Handles all disk configs of type `:disk`
+        #
+        # @param [Vagrant::Machine] machine - the current machine
+        # @param [Config::Disk] disk - the current disk to configure
+        # @param [Array] all_disks - A list of all currently defined disks in VirtualBox
+        # @return [Hash] - disk_metadata
+        def self.handle_configure_disk(machine, disk, all_disks)
+          disk_metadata = {}
+
+          # Grab the existing configured disk, if it exists
+          current_disk = get_current_disk(machine, disk, all_disks)
+
+          # Configure current disk
+          if !current_disk
+            # create new disk and attach
+            disk_metadata = create_disk(machine, disk)
+          elsif compare_disk_size(machine, disk, current_disk)
+            disk_metadata = resize_disk(machine, disk, current_disk)
+          else
+            disk_metadata = {UUID: current_disk["DiskIdentifier"], Name: disk.name, Path: current_disk["Path"]}
+            if disk.primary
+              disk_metadata[:primary] = true
+            end
+          end
+
+          disk_metadata
+        end
+
+        # Check to see if current disk is configured based on defined_disks
+        #
+        # @param [Kernel_V2::VagrantConfigDisk] disk_config
+        # @param [Hash] defined_disk
+        # @return [Boolean]
+        def self.compare_disk_size(machine, disk_config, defined_disk)
+          # Hyper-V returns disk size in bytes
+          requested_disk_size = disk_config.size
+          disk_actual = machine.provider.driver.get_disk(defined_disk["Path"])
+          defined_disk_size = disk_actual["Size"]
+
+          if defined_disk_size > requested_disk_size
+            if File.extname(disk_actual["Path"]) == ".vhdx"
+              # VHDX formats can be shrunk
+              return true
+            else
+              machine.ui.warn(I18n.t("vagrant.cap.configure_disks.shrink_size_not_supported", name: disk_config.name))
+              return false
+            end
+          elsif defined_disk_size < requested_disk_size
+            return true
+          else
+            return false
+          end
+        end
+
+        # Creates and attaches a disk to a machine
+        #
+        # @param [Vagrant::Machine] machine
+        # @param [Kernel_V2::VagrantConfigDisk] disk_config
+        def self.create_disk(machine, disk_config)
+          machine.ui.detail(I18n.t("vagrant.cap.configure_disks.create_disk", name: disk_config.name))
+          disk_provider_config = {}
+
+          if disk_config.provider_config && disk_config.provider_config.key?(:hyperv)
+            disk_provider_config = disk_config.provider_config[:hyperv]
+          end
+
+          if !disk_provider_config.empty?
+            disk_provider_config = convert_size_vars!(disk_provider_config)
+          end
+
+          # Get the machines data dir, that will now be the path for the new disk
+          guest_disk_folder = machine.data_dir.join("Virtual Hard Disks")
+
+          if disk_config.file
+            disk_file = disk_config.file
+            LOGGER.info("Disk already defined by user at '#{disk_file}'. Using this disk instead of creating a new one...")
+          else
+            # Set the extension
+            disk_ext = disk_config.disk_ext
+            disk_file = File.join(guest_disk_folder, disk_config.name) + ".#{disk_ext}"
+
+            LOGGER.info("Attempting to create a new disk file '#{disk_file}' of size '#{disk_config.size}' bytes")
+
+            machine.provider.driver.create_disk(disk_file, disk_config.size, disk_provider_config)
+          end
+
+          disk_info = machine.provider.driver.get_disk(disk_file)
+          disk_metadata = {UUID: disk_info["DiskIdentifier"], Name: disk_config.name, Path: disk_info["Path"]}
+
+          machine.provider.driver.attach_disk(disk_file, disk_provider_config)
+
+          disk_metadata
+        end
+
+        # Converts any "shortcut" options such as "123MB" into its byte form. This
+        # is due to what parameter type is expected when calling the `New-VHD`
+        # powershell command
+        #
+        # @param [Hash] disk_provider_config
+        # @return [Hash] disk_provider_config
+        def self.convert_size_vars!(disk_provider_config)
+          if disk_provider_config.key?(:BlockSizeBytes)
+            bytes = Vagrant::Util::Numeric.string_to_bytes(disk_provider_config[:BlockSizeBytes])
+            disk_provider_config[:BlockSizeBytes] = bytes
+          end
+
+          disk_provider_config
+        end
+
+        # @param [Vagrant::Machine] machine
+        # @param [Config::Disk] disk_config - the current disk to configure
+        # @param [Hash] defined_disk - current disk as represented by VirtualBox
+        # @return [Hash] - disk_metadata
+        def self.resize_disk(machine, disk_config, defined_disk)
+          machine.ui.detail(I18n.t("vagrant.cap.configure_disks.resize_disk", name: disk_config.name), prefix: true)
+
+          machine.provider.driver.resize_disk(defined_disk["Path"], disk_config.size.to_i)
+
+          disk_info = machine.provider.driver.get_disk(defined_disk["Path"])
+
+          # Store updated metadata
+          disk_metadata = {UUID: disk_info["DiskIdentifier"], Name: disk_config.name, Path: disk_info["Path"]}
+
+          disk_metadata
+        end
+      end
+    end
+  end
+end