vagrant-unbundled 2.2.7.0 → 2.2.16.0

data/plugins/providers/virtualbox/driver/version_6_1.rb

@@ -10,6 +10,29 @@ module VagrantPlugins
 
           @logger = Log4r::Logger.new("vagrant::provider::virtualbox_6_1")
         end
+
+        def read_dhcp_servers
+          execute("list", "dhcpservers", retryable: true).split("\n\n").collect do |block|
+            info = {}
+
+            block.split("\n").each do |line|
+              if network = line[/^NetworkName:\s+HostInterfaceNetworking-(.+?)$/, 1]
+                info[:network]      = network
+                info[:network_name] = "HostInterfaceNetworking-#{network}"
+              elsif ip = line[/^Dhcpd IP:\s+(.+?)$/, 1]
+                info[:ip] = ip
+              elsif netmask = line[/^NetworkMask:\s+(.+?)$/, 1]
+                info[:netmask] = netmask
+              elsif lower = line[/^LowerIPAddress:\s+(.+?)$/, 1]
+                info[:lower] = lower
+              elsif upper = line[/^UpperIPAddress:\s+(.+?)$/, 1]
+                info[:upper] = upper
+              end
+            end
+
+            info
+          end
+        end
       end
     end
   end

data/plugins/providers/virtualbox/model/storage_controller.rb

@@ -0,0 +1,135 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Model
+      # Represents a storage controller for VirtualBox. Storage controllers
+      # have a type, a name, and can have hard disks or optical drives attached.
+      class StorageController
+        IDE_CONTROLLER_TYPES = ["PIIX4", "PIIX3", "ICH6"].map(&:freeze).freeze
+        SATA_CONTROLLER_TYPES = ["IntelAhci"].map(&:freeze).freeze
+        SCSI_CONTROLLER_TYPES = [ "LsiLogic", "BusLogic"].map(&:freeze).freeze
+
+        IDE_DEVICES_PER_PORT = 2.freeze
+        SATA_DEVICES_PER_PORT = 1.freeze
+        SCSI_DEVICES_PER_PORT = 1.freeze
+
+        IDE_BOOT_PRIORITY = 1.freeze
+        SATA_BOOT_PRIORITY = 2.freeze
+        SCSI_BOOT_PRIORITY = 3.freeze
+
+        # The name of the storage controller.
+        #
+        # @return [String]
+        attr_reader :name
+
+        # The specific type of controller.
+        #
+        # @return [String]
+        attr_reader :type
+
+        # The maximum number of avilable ports for the storage controller.
+        #
+        # @return [Integer]
+        attr_reader :maxportcount
+
+        # The number of devices that can be attached to each port. For SATA
+        # controllers, this will usually be 1, and for IDE controllers this
+        # will usually be 2.
+        # @return [Integer]
+        attr_reader :devices_per_port
+
+        # The maximum number of individual disks that can be attached to the
+        # storage controller. For SATA controllers, this equals the maximum
+        # number of ports. For IDE controllers, this will be twice the max
+        # number of ports (primary/secondary).
+        #
+        # @return [Integer]
+        attr_reader :limit
+
+        # The boot priority of the storage controller. This does not seem to
+        # depend on the controller number returned by `showvminfo`.
+        # Experimentation has determined that VirtualBox will try to boot from
+        # the first controller it finds with a hard disk, in this order:
+        #   IDE, SATA, SCSI
+        #
+        # @return [Integer]
+        attr_reader :boot_priority
+
+        # The list of disks/ISOs attached to each storage controller.
+        #
+        # @return [Array<Hash>]
+        attr_reader :attachments
+
+        def initialize(name, type, maxportcount, attachments)
+          @name = name
+          @type = type
+
+          @maxportcount = maxportcount.to_i
+
+          if IDE_CONTROLLER_TYPES.include?(@type)
+            @storage_bus = :ide
+            @devices_per_port = IDE_DEVICES_PER_PORT
+            @boot_priority = IDE_BOOT_PRIORITY
+          elsif SATA_CONTROLLER_TYPES.include?(@type)
+            @storage_bus = :sata
+            @devices_per_port = SATA_DEVICES_PER_PORT
+            @boot_priority = SATA_BOOT_PRIORITY
+          elsif SCSI_CONTROLLER_TYPES.include?(@type)
+            @storage_bus = :scsi
+            @devices_per_port = SCSI_DEVICES_PER_PORT
+            @boot_priority = SCSI_BOOT_PRIORITY
+          else
+            @storage_bus = :unknown
+            @devices_per_port = 1
+          end
+
+          @limit = @maxportcount * @devices_per_port
+
+          attachments ||= []
+          @attachments = attachments
+        end
+
+        # Get a single storage device, either by port/device address or by
+        # UUID.
+        #
+        # @param [Hash] opts - A hash of options to match
+        # @return [Hash] attachment - Attachment information
+        def get_attachment(opts = {})
+          if opts[:port] && opts[:device]
+            @attachments.detect { |a| a[:port] == opts[:port] &&
+                                      a[:device] == opts[:device] }
+          elsif opts[:uuid]
+            @attachments.detect { |a| a[:uuid] == opts[:uuid] }
+          end
+        end
+
+        # Returns true if the storage controller has a supported type.
+        #
+        # @return [Boolean]
+        def supported?
+          [:ide, :sata, :scsi].include?(@storage_bus)
+        end
+
+        # Returns true if the storage controller is a IDE type controller.
+        #
+        # @return [Boolean]
+        def ide?
+          @storage_bus == :ide
+        end
+
+        # Returns true if the storage controller is a SATA type controller.
+        #
+        # @return [Boolean]
+        def sata?
+          @storage_bus == :sata
+        end
+
+        # Returns true if the storage controller is a SCSI type controller.
+        #
+        # @return [Boolean]
+        def scsi?
+          @storage_bus == :scsi
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/model/storage_controller_array.rb

@@ -0,0 +1,98 @@
+require_relative "../cap/validate_disk_ext"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Model
+      # A collection of storage controllers. Includes finder methods to look
+      # up a storage controller by given attributes.
+      class StorageControllerArray < Array
+        # Returns a storage controller with the given name. Raises an
+        # exception if a matching controller can't be found.
+        #
+        # @param [String] name - The name of the storage controller
+        # @return [VagrantPlugins::ProviderVirtualBox::Model::StorageController]
+        def get_controller(name)
+          controller = detect { |c| c.name == name }
+          if !controller
+            raise Vagrant::Errors::VirtualBoxDisksControllerNotFound, name: name
+          end
+          controller
+        end
+
+        # Find the controller containing the primary disk (i.e. the boot
+        # disk). This is used to determine which controller virtual disks
+        # should be attached to.
+        #
+        # Raises an exception if no supported controllers are found.
+        #
+        # @return [VagrantPlugins::ProviderVirtualBox::Model::StorageController]
+        def get_primary_controller
+          ordered = find_all(&:supported?).sort_by(&:boot_priority)
+          controller = ordered.detect { |c| c.attachments.any? { |a| hdd?(a) } }
+
+          if !controller
+            raise Vagrant::Errors::VirtualBoxDisksNoSupportedControllers,
+              supported_types: supported_types.join(" ,")
+          end
+
+          controller
+        end
+
+        # Find the attachment representing the primary disk (i.e. the boot
+        # disk). We can't rely on the order of #list_hdds, as they will not
+        # always come in port order, but primary is always Port 0 Device 0.
+        #
+        # @return [Hash] attachment - Primary disk attachment information
+        def get_primary_attachment
+          attachment = nil
+
+          controller = get_primary_controller
+          attachment = controller.get_attachment(port: "0", device: "0")
+          if !attachment
+            raise Vagrant::Errors::VirtualBoxDisksPrimaryNotFound
+          end
+
+          attachment
+        end
+
+        # Returns the first supported storage controller for attaching dvds.
+        # Will raise an exception if no suitable controller can be found.
+        #
+        # @return [VagrantPlugins::ProviderVirtualBox::Model::StorageController]
+        def get_dvd_controller
+          ordered = find_all(&:supported?).sort_by(&:boot_priority)
+          controller = ordered.first
+          if !controller
+            raise Vagrant::Errors::VirtualBoxDisksNoSupportedControllers,
+              supported_types: supported_types.join(" ,")
+          end
+
+          controller
+        end
+
+        private
+
+        # Determine whether the given attachment is a hard disk.
+        #
+        # @param [Hash] attachment - Attachment information
+        # @return [Boolean]
+        def hdd?(attachment)
+          if !attachment
+            false
+          else
+            ext = File.extname(attachment[:location].to_s).downcase.split('.').last
+            VagrantPlugins::ProviderVirtualBox::Cap::ValidateDiskExt.validate_disk_ext(nil, ext)
+          end
+        end
+
+        # Returns a list of all the supported controller types.
+        #
+        # @return [Array<String>]
+        def supported_types
+          StorageController::SATA_CONTROLLER_TYPES + StorageController::IDE_CONTROLLER_TYPES +
+            StorageController::SCSI_CONTROLLER_TYPES
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/plugin.rb

@@ -39,10 +39,50 @@ module VagrantPlugins
         Cap::PublicAddress
       end
 
+      provider_capability(:virtualbox, :configure_disks) do
+        require_relative "cap/configure_disks"
+        Cap::ConfigureDisks
+      end
+
+      provider_capability(:virtualbox, :cleanup_disks) do
+        require_relative "cap/cleanup_disks"
+        Cap::CleanupDisks
+      end
+
+      provider_capability(:virtualbox, :validate_disk_ext) do
+        require_relative "cap/validate_disk_ext"
+        Cap::ValidateDiskExt
+      end
+
+      provider_capability(:virtualbox, :default_disk_exts) do
+        require_relative "cap/validate_disk_ext"
+        Cap::ValidateDiskExt
+      end
+
+      provider_capability(:virtualbox, :set_default_disk_ext) do
+        require_relative "cap/validate_disk_ext"
+        Cap::ValidateDiskExt
+      end
+
       provider_capability(:virtualbox, :snapshot_list) do
         require_relative "cap"
         Cap
       end
+
+      synced_folder_capability(:virtualbox, "mount_options") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      synced_folder_capability(:virtualbox, "mount_type") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
+
+      synced_folder_capability(:virtualbox, "mount_name") do
+        require_relative "cap/mount_options"
+        Cap::MountOptions
+      end
     end
 
     autoload :Action, File.expand_path("../action", __FILE__)
@@ -64,6 +104,8 @@ module VagrantPlugins
 
     module Model
       autoload :ForwardedPort, File.expand_path("../model/forwarded_port", __FILE__)
+      autoload :StorageController, File.expand_path("../model/storage_controller", __FILE__)
+      autoload :StorageControllerArray, File.expand_path("../model/storage_controller_array", __FILE__)
     end
 
     module Util

data/plugins/providers/virtualbox/provider.rb

@@ -23,7 +23,8 @@ module VagrantPlugins
       rescue Vagrant::Errors::VirtualBoxInvalidVersion,
              Vagrant::Errors::VirtualBoxNotDetected,
              Vagrant::Errors::VirtualBoxKernelModuleNotLoaded,
-             Vagrant::Errors::VirtualBoxInstallIncomplete
+             Vagrant::Errors::VirtualBoxInstallIncomplete,
+             Vagrant::Errors::VBoxManageNotFoundError
         raise if raise_error
         return false
       end

data/plugins/providers/virtualbox/synced_folder.rb

@@ -33,6 +33,7 @@ module VagrantPlugins
 
         # Go through each folder and mount
         machine.ui.output(I18n.t("vagrant.actions.vm.share_folders.mounting"))
+        fstab_folders = []
         folders.each do |id, data|
           if data[:guestpath]
             # Guest path specified, so mount the folder to specified point

data/plugins/provisioners/ansible/cap/guest/alpine/ansible_install.rb

@@ -0,0 +1,44 @@
+require_relative "../facts"
+require_relative "../pip/pip"
+
+module VagrantPlugins
+  module Ansible
+    module Cap
+      module Guest
+        module Alpine
+          module AnsibleInstall
+
+            def self.ansible_install(machine, install_mode, ansible_version, pip_args, pip_install_cmd = "")
+              case install_mode
+                when :pip
+                  pip_setup machine, pip_install_cmd
+                  Pip::pip_install machine, "ansible", ansible_version, pip_args, true
+                when :pip_args_only
+                  pip_setup machine, pip_install_cmd
+                  Pip::pip_install machine, "", "", pip_args, false
+                else
+                  ansible_apk_install machine
+              end
+            end
+
+            private
+
+            def self.ansible_apk_install(machine)
+              machine.communicate.sudo "apk add --update --no-cache python3 ansible"
+              machine.communicate.sudo "if [ ! -e /usr/bin/python ]; then ln -sf python3 /usr/bin/python ; fi"
+              machine.communicate.sudo "if [ ! -e /usr/bin/pip ]; then ln -sf pip3 /usr/bin/pip ; fi"
+            end
+
+            def self.pip_setup(machine, pip_install_cmd = "")
+              machine.communicate.sudo "apk add --update --no-cache python3"
+              machine.communicate.sudo "if [ ! -e /usr/bin/python ]; then ln -sf python3 /usr/bin/python ; fi"
+              machine.communicate.sudo "apk add --update --no-cache --virtual .build-deps python3-dev libffi-dev openssl-dev build-base"
+              Pip::get_pip machine, pip_install_cmd
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/ansible/cap/guest/freebsd/ansible_install.rb

@@ -11,7 +11,7 @@ module VagrantPlugins
               if install_mode != :default
                 raise Ansible::Errors::AnsiblePipInstallIsNotSupported
               else
-                machine.communicate.sudo "pkg install -qy py36-ansible"
+                machine.communicate.sudo "pkg install -qy py37-ansible"
               end
             end
 

data/plugins/provisioners/ansible/plugin.rb

@@ -45,6 +45,11 @@ module VagrantPlugins
         Cap::Guest::Arch::AnsibleInstall
       end
 
+      guest_capability(:alpine, :ansible_install) do
+        require_relative "cap/guest/alpine/ansible_install"
+        Cap::Guest::Alpine::AnsibleInstall
+      end
+
       guest_capability(:debian, :ansible_install) do
         require_relative "cap/guest/debian/ansible_install"
         Cap::Guest::Debian::AnsibleInstall

data/plugins/provisioners/ansible/provisioner/base.rb

@@ -375,7 +375,7 @@ gathered version stdout version:
             config.compatibility_mode = Ansible::COMPATIBILITY_MODE_V2_0
           end
 
-          @machine.env.ui.warn(I18n.t("vagrant.provisioners.ansible.compatibility_mode_warning",
+          @logger.info(I18n.t("vagrant.provisioners.ansible.compatibility_mode_warning",
             compatibility_mode: config.compatibility_mode,
             ansible_version: @gathered_version) +
           "\n")

data/plugins/provisioners/container/client.rb

@@ -0,0 +1,203 @@
+require 'digest/sha1'
+
+module VagrantPlugins
+  module ContainerProvisioner
+    class Client
+      def initialize(machine, container_command)
+        @machine = machine
+        @container_command =  container_command
+      end
+
+      # Build an image given a path to a Dockerfile
+      #
+      # @param [String] - Path to the Dockerfile to pass to
+      #   container build command
+      def build_images(images)
+        @machine.communicate.tap do |comm|
+          images.each do |path, opts|
+            @machine.ui.info(I18n.t("vagrant.container_building_single", path: path))
+            comm.sudo("#{@container_command} build #{opts[:args]} #{path}") do |type, data|
+              handle_comm(type, data)
+            end
+          end
+        end
+      end
+
+      # Pull image given a list of images
+      #
+      # @param [String] - Image name
+      def pull_images(*images)
+        @machine.communicate.tap do |comm|
+          images.each do |image|
+            @machine.ui.info(I18n.t("vagrant.container_pulling_single", name: image))
+            comm.sudo("#{@container_command} pull #{image}") do |type, data|
+              handle_comm(type, data)
+            end
+          end
+        end
+      end
+
+      def run(containers)
+        containers.each do |name, config|
+          cids_dir = "/var/lib/vagrant/cids"
+          config[:cidfile] ||= "#{cids_dir}/#{Digest::SHA1.hexdigest name}"
+
+          @machine.ui.info(I18n.t("vagrant.container_running", name: name))
+          @machine.communicate.sudo("mkdir -p #{cids_dir}")
+          run_container({
+            name: name,
+            original_name: name,
+          }.merge(config))
+        end
+      end
+
+      # Run a OCI container. If the container does not exist it will be
+      # created. If the image is stale it will be recreated and restarted
+      def run_container(config)
+        raise "Container's cidfile was not provided!" if !config[:cidfile]
+
+        id = "$(cat #{config[:cidfile]})"
+
+        if container_exists?(id)
+          if container_args_changed?(config)
+            @machine.ui.info(I18n.t("vagrant.container_restarting_container_args",
+              name: config[:name],
+            ))
+            stop_container(id)
+            create_container(config)
+          elsif container_image_changed?(config)
+            @machine.ui.info(I18n.t("vagrant.container_restarting_container_image",
+              name: config[:name],
+            ))
+            stop_container(id)
+            create_container(config)
+          else
+            start_container(id)
+          end
+        else
+          create_container(config)
+        end
+      end
+
+      def container_exists?(id)
+        lookup_container(id, true)
+      end
+
+      # Start container
+      #
+      # @param String - Image id
+      def start_container(id)
+        if !container_running?(id)
+          @machine.communicate.sudo("#{@container_command} start #{id}")
+        end
+      end
+
+      # Stop and remove container
+      #
+      # @param String - Image id
+      def stop_container(id)
+        @machine.communicate.sudo %[
+          #{@container_command} stop #{id}
+          #{@container_command} rm #{id}
+        ]
+      end
+
+      def container_running?(id)
+        lookup_container(id)
+      end
+
+      def container_image_changed?(config)
+        # Returns true if there is a container running with the given :name,
+        # and the container is not using the latest :image.
+
+        # Here, "<cmd> inspect <container>" returns the id of the image
+        # that the container is using. We check that the latest image that
+        # has been built with that name (:image)  matches the one that the
+        # container is running.
+        cmd = ("#{@container_command} inspect --format='{{.Image}}' #{config[:name]} |" +
+               " grep $(#{@container_command} images -q #{config[:image]})")
+        return !@machine.communicate.test(cmd)
+      end
+
+      def container_args_changed?(config)
+        path = container_data_path(config)
+        return true if !path.exist?
+
+        args = container_run_args(config)
+        sha  = Digest::SHA1.hexdigest(args)
+        return true if path.read.chomp != sha
+
+        return false
+      end
+
+      def create_container(config)
+        args = container_run_args(config)
+
+        @machine.communicate.sudo %[rm -f "#{config[:cidfile]}"]
+        @machine.communicate.sudo %[#{@container_command} run #{args}]
+
+        sha  = Digest::SHA1.hexdigest(args)
+        container_data_path(config).open("w+") do |f|
+          f.write(sha)
+        end
+      end
+
+      # Looks up if a container with a given id exists using the
+      # `ps` command. Returns Boolean
+      #
+      # @param String - Image id
+      def lookup_container(id, list_all = false)
+        container_ps = "sudo #{@container_command} ps -q"
+        container_ps << " -a" if list_all
+        @machine.communicate.tap do |comm|
+          return comm.test("#{container_ps} --no-trunc | grep -wFq #{id}")
+        end
+      end
+
+      def container_name(config)
+        name = config[:name]
+
+        # If the name is the automatically assigned name, then
+        # replace the "/" with "-" because "/" is not a valid
+        # character for a container name.
+        name = name.gsub("/", "-").gsub(":", "-") if name == config[:original_name]
+        name
+      end
+
+      # Compiles run arguments to be appended to command string.
+      # Returns String
+      def container_run_args(config)
+        name = container_name(config)
+
+        args = "--cidfile=#{config[:cidfile]} "
+        args << "-d " if config[:daemonize]
+        args << "--name #{name} " if name && config[:auto_assign_name]
+        args << "--restart=#{config[:restart]}" if config[:restart]
+        args << " #{config[:args]}" if config[:args]
+
+        "#{args} #{config[:image]} #{config[:cmd]}".strip
+      end
+
+      def container_data_path(config)
+        name = container_name(config)
+        @machine.data_dir.join("#{@container_command}-#{name}")
+      end
+
+      protected
+
+      # This handles outputting the communication data back to the UI
+      def handle_comm(type, data)
+        if [:stderr, :stdout].include?(type)
+          # Clear out the newline since we add one
+          data = data.chomp
+          return if data.empty?
+
+          options = {}
+          #options[:color] = color if !config.keep_color
+
+          @machine.ui.info(data.chomp, options)
+        end
+      end
+    end
+  end
+end