vagrant 1.5.0 → 2.4.4

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

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require File.expand_path("../version_5_0", __FILE__)
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      # Driver for VirtualBox 5.1.x
+      class Version_5_1 < Version_5_0
+        def initialize(uuid)
+          super
+
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox_5_1")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require File.expand_path("../version_5_0", __FILE__)
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      # Driver for VirtualBox 5.2.x
+      class Version_5_2 < Version_5_0
+        def initialize(uuid)
+          super
+
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox_5_2")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require File.expand_path("../version_5_0", __FILE__)
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      # Driver for VirtualBox 6.0.x
+      class Version_6_0 < Version_5_0
+        def initialize(uuid)
+          super
+
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox_6_0")
+        end
+
+        def import(ovf)
+          ovf = Vagrant::Util::Platform.windows_path(ovf)
+
+          output = ""
+          total = ""
+          last  = 0
+
+          # Dry-run the import to get the suggested name and path
+          @logger.debug("Doing dry-run import to determine parallel-safe name...")
+          output = execute("import", "-n", ovf)
+          result = /Suggested VM name "(.+?)"/.match(output)
+          if !result
+            raise Vagrant::Errors::VirtualBoxNoName, output: output
+          end
+          suggested_name = result[1].to_s
+
+          # Append millisecond plus a random to the path in case we're
+          # importing the same box elsewhere.
+          specified_name = "#{suggested_name}_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
+          @logger.debug("-- Parallel safe name: #{specified_name}")
+
+          # Build the specified name param list
+          name_params = [
+            "--vsys", "0",
+            "--vmname", specified_name,
+          ]
+
+          # Target path for disks is no longer a full path. Extract the path for the
+          # settings file to determine the base directory which we can then use to
+          # build the disk paths
+          result = /Suggested VM settings file name "(?<settings_path>.+?)"/.match(output)
+          if !result
+            @logger.warn("Failed to locate base path for disks. Using current working directory.")
+            base_path = "."
+          else
+            base_path = result[:settings_path]
+            if Vagrant::Util::Platform.windows? || Vagrant::Util::Platform.wsl?
+              base_path.gsub!('\\', '/')
+            end
+            base_path = File.dirname(base_path)
+          end
+
+          @logger.info("Base path for disk import: #{base_path}")
+
+          # Extract the disks list and build the disk target params
+          disk_params = []
+          disks = output.scan(/(\d+): Hard disk image: source image=.+, target path=(.+),/)
+          disks.each do |unit_num, path|
+            path = File.join(base_path, File.basename(path))
+            disk_params << "--vsys"
+            disk_params << "0"
+            disk_params << "--unit"
+            disk_params << unit_num
+            disk_params << "--disk"
+            disk_params << path.reverse.sub("/#{suggested_name}/".reverse, "/#{specified_name}/".reverse).reverse # Replace only last occurrence
+          end
+
+          execute("import", ovf , *name_params, *disk_params, retryable: true) do |type, data|
+            if type == :stdout
+              # Keep track of the stdout so that we can get the VM name
+              output << data
+            elsif type == :stderr
+              # Append the data so we can see the full view
+              total << data.gsub("\r", "")
+
+              # Break up the lines. We can't get the progress until we see an "OK"
+              lines = total.split("\n")
+              if lines.include?("OK.")
+                # The progress of the import will be in the last line. Do a greedy
+                # regular expression to find what we're looking for.
+                match = /.+(\d{2})%/.match(lines.last)
+                if match
+                  current = match[1].to_i
+                  if current > last
+                    last = current
+                    yield current if block_given?
+                  end
+                end
+              end
+            end
+          end
+
+          return get_machine_id specified_name
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require File.expand_path("../version_6_0", __FILE__)
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      # Driver for VirtualBox 6.1.x
+      class Version_6_1 < Version_6_0
+        def initialize(uuid)
+          super
+
+          @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
+end

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

@@ -0,0 +1,306 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "rexml"
+
+require File.expand_path("../version_6_1", __FILE__)
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      # Driver for VirtualBox 7.0.x
+      class Version_7_0 < Version_6_1
+        # VirtualBox version requirement for using host only networks
+        # instead of host only interfaces
+        HOSTONLY_NET_REQUIREMENT=Gem::Requirement.new(">= 7")
+        # Prefix of name used for host only networks
+        HOSTONLY_NAME_PREFIX="vagrantnet-vbox"
+        DEFAULT_NETMASK="255.255.255.0"
+
+        def initialize(uuid)
+          super
+
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox_7_0")
+        end
+
+        def read_bridged_interfaces
+          ifaces = super
+          return ifaces if !use_host_only_nets?
+
+          # Get a list of all subnets which are in use for hostonly networks
+          hostonly_ifaces = read_host_only_networks.map do |net|
+            IPAddr.new(net[:lowerip]).mask(net[:networkmask])
+          end
+
+          # Prune any hostonly interfaces in the list
+          ifaces.delete_if { |i|
+            addr = begin
+                     IPAddr.new(i[:ip]).mask(i[:netmask])
+                   rescue IPAddr::Error => err
+                     @logger.warn("skipping bridged interface due to parse error #{err} (#{i}) ")
+                     nil
+                   end
+            addr.nil? ||
+              hostonly_ifaces.include?(addr)
+          }
+
+          ifaces
+        end
+
+        def delete_unused_host_only_networks
+          return super if !use_host_only_nets?
+
+          # First get the list of existing host only network names
+          network_names = read_host_only_networks.map { |net| net[:name] }
+          # Prune the network names to only include ones we manage
+          network_names.delete_if { |name| !name.start_with?(HOSTONLY_NAME_PREFIX) }
+
+          @logger.debug("managed host only network names: #{network_names}")
+
+          return if network_names.empty?
+
+          # Next get the list of host only networks currently in use
+          inuse_names = []
+          execute("list", "vms", retryable: true).split("\n").each do |line|
+            match = line.match(/^".+?"\s+\{(?<vmid>.+?)\}$/)
+            next if match.nil?
+            begin
+              info = execute("showvminfo", match[:vmid].to_s, "--machinereadable", retryable: true)
+              info.split("\n").each do |vmline|
+                if vmline.start_with?("hostonly-network")
+                  net_name = vmline.split("=", 2).last.to_s.gsub('"', "")
+                  inuse_names << net_name
+                end
+              end
+            rescue Vagrant::Errors::VBoxManageError => err
+              raise if !err.extra_data[:stderr].include?("VBOX_E_OBJECT_NOT_FOUND")
+            end
+          end
+
+          @logger.debug("currently in use network names: #{inuse_names}")
+
+          # Now remove all the networks not in use
+          (network_names - inuse_names).each do |name|
+            execute("hostonlynet", "remove", "--name", name, retryable: true)
+          end
+        end
+
+        def enable_adapters(adapters)
+          return super if !use_host_only_nets?
+
+          hostonly_adapters = adapters.find_all { |adapter| adapter[:hostonly] }
+          other_adapters = adapters - hostonly_adapters
+          super(other_adapters) if !other_adapters.empty?
+
+          if !hostonly_adapters.empty?
+            args = []
+            hostonly_adapters.each do |adapter|
+              args.concat(["--nic#{adapter[:adapter]}", "hostonlynet"])
+              args.concat(["--host-only-net#{adapter[:adapter]}", adapter[:hostonly],
+                           "--cableconnected#{adapter[:adapter]}", "on"])
+            end
+
+            execute("modifyvm", @uuid, *args, retryable: true)
+          end
+        end
+
+        def create_host_only_network(options)
+          # If we are not on macOS, just setup the hostonly interface
+          return super if !use_host_only_nets?
+
+          opts = {
+            netmask: options.fetch(:netmask, DEFAULT_NETMASK),
+          }
+
+          if options[:type] == :dhcp
+            opts[:lower] = options[:dhcp_lower]
+            opts[:upper] = options[:dhcp_upper]
+          else
+            addr = IPAddr.new(options[:adapter_ip])
+            opts[:upper] = opts[:lower] = addr.mask(opts[:netmask]).to_range.first.to_s
+          end
+
+          name_idx = read_host_only_networks.map { |hn|
+            next if !hn[:name].start_with?(HOSTONLY_NAME_PREFIX)
+            hn[:name].sub(HOSTONLY_NAME_PREFIX, "").to_i
+          }.compact.max.to_i + 1
+          opts[:name] = HOSTONLY_NAME_PREFIX + name_idx.to_s
+
+          execute("hostonlynet", "add",
+                  "--name", opts[:name],
+                  "--netmask", opts[:netmask],
+                  "--lower-ip", opts[:lower],
+                  "--upper-ip", opts[:upper],
+                  retryable: true)
+
+          {
+            name: opts[:name],
+            ip: options[:adapter_ip],
+            netmask: opts[:netmask],
+          }
+        end
+
+        # Disabled when host only nets are in use
+        def reconfig_host_only(options)
+          return super if !use_host_only_nets?
+        end
+
+        # Disabled when host only nets are in use since
+        # the host only nets will provide the dhcp server
+        def remove_dhcp_server(*_, **_)
+          super if !use_host_only_nets?
+        end
+
+        # Disabled when host only nets are in use since
+        # the host only nets will provide the dhcp server
+        def create_dhcp_server(*_, **_)
+          super if !use_host_only_nets?
+        end
+
+        def read_host_only_interfaces
+          return super if !use_host_only_nets?
+
+          # When host only nets are in use, read them and
+          # reformat the information to line up with how
+          # the interfaces is structured
+          read_host_only_networks.map do |net|
+            addr = begin
+                     IPAddr.new(net[:lowerip])
+                   rescue IPAddr::Error => err
+                     @logger.warn("invalid host only network lower IP encountered: #{err} (#{net})")
+                     next
+                   end
+            # Address of the interface will be the lower bound of the range or
+            # the first available address in the subnet
+            if addr == addr.mask(net[:networkmask])
+              addr = addr.succ
+            end
+
+            net[:netmask] = net[:networkmask]
+            if addr.ipv4?
+              net[:ip] = addr.to_s
+              net[:ipv6] = ""
+            else
+              net[:ip] = ""
+              net[:ipv6] = addr.to_s
+              net[:ipv6_prefix] = net[:netmask]
+            end
+
+            net[:status] = net[:state] == "Enabled" ? "Up" : "Down"
+
+            net
+          end.compact
+        end
+
+        def read_network_interfaces
+          return super if !use_host_only_nets?
+
+          {}.tap do |nics|
+            execute("showvminfo", @uuid, "--machinereadable", retryable: true).each_line do |line|
+              if m = line.match(/nic(?<adapter>\d+)="(?<type>.+?)"$/)
+                nics[m[:adapter].to_i] ||= {}
+                if m[:type] == "hostonlynetwork"
+                  nics[m[:adapter].to_i][:type] = :hostonly
+                else
+                  nics[m[:adapter].to_i][:type] = m[:type].to_sym
+                end
+              elsif m = line.match(/^bridgeadapter(?<adapter>\d+)="(?<network>.+?)"$/)
+                nics[m[:adapter].to_i] ||= {}
+                nics[m[:adapter].to_i][:bridge] = m[:network]
+              elsif m = line.match(/^hostonly-network(?<adapter>\d+)="(?<network>.+?)"$/)
+                nics[m[:adapter].to_i] ||= {}
+                nics[m[:adapter].to_i][:hostonly] = m[:network]
+              end
+            end
+          end
+        end
+
+        # Generate list of host only networks
+        def read_host_only_networks
+          networks = []
+          current = nil
+          execute("list", "hostonlynets", retryable: true).split("\n").each do |line|
+            line.chomp!
+            next if line.empty?
+            key, value = line.split(":", 2).map(&:strip)
+            key = key.downcase
+            if key == "name"
+              networks.push(current) if !current.nil?
+              current = Vagrant::Util::HashWithIndifferentAccess.new
+            end
+            current[key] = value
+          end
+          networks.push(current) if !current.nil?
+
+          networks
+        end
+
+        # The initial VirtualBox 7.0 release has an issue with displaying port
+        # forward information. When a single port forward is defined, the forwarding
+        # information can be found in the `showvminfo` output. Once more than a
+        # single port forward is defined, no forwarding information is provided
+        # in the `showvminfo` output. To work around this we grab the VM configuration
+        # file from the `showvminfo` output and extract the port forward information
+        # from there instead.
+        def read_forwarded_ports(uuid=nil, active_only=false)
+          # Only use this override for the 7.0.0 release.
+          return super if get_version.to_s != "7.0.0"
+
+          uuid ||= @uuid
+
+          @logger.debug("read_forward_ports: uuid=#{uuid} active_only=#{active_only}")
+
+          results = []
+
+          info = execute("showvminfo", uuid, "--machinereadable", retryable: true)
+          result = info.match(/CfgFile="(?<path>.+?)"/)
+          if result.nil?
+            raise Vagrant::Errors::VirtualBoxConfigNotFound,
+                  uuid: uuid
+          end
+
+          File.open(result[:path], "r") do |f|
+            doc = REXML::Document.new(f)
+            networks = REXML::XPath.each(doc.root, "Machine/Hardware/Network/Adapter")
+            networks.each do |net|
+              REXML::XPath.each(doc.root, net.xpath + "/NAT/Forwarding") do |fwd|
+                # Result Array values:
+                # [NIC Slot, Name, Host Port, Guest Port, Host IP]
+                result = [
+                  net.attribute("slot").value.to_i + 1,
+                  fwd.attribute("name")&.value.to_s,
+                  fwd.attribute("hostport")&.value.to_i,
+                  fwd.attribute("guestport")&.value.to_i,
+                  fwd.attribute("hostip")&.value.to_s
+                ]
+                @logger.debug(" - #{result.inspect}")
+                results << result
+              end
+            end
+          end
+
+          results
+        end
+
+        private
+
+        # Returns if hostonlynets are enabled on the current
+        # host platform
+        #
+        # @return [Boolean]
+        def use_host_only_nets?
+          Vagrant::Util::Platform.darwin? &&
+            HOSTONLY_NET_REQUIREMENT.satisfied_by?(get_version)
+        end
+
+        # VirtualBox version in use
+        #
+        # @return [Gem::Version]
+        def get_version
+          return @version if @version
+          @version = Gem::Version.new(Meta.new.version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require File.expand_path("../version_7_0", __FILE__)
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Driver
+      # Driver for VirtualBox 7.1.x
+      class Version_7_1 < Version_7_0
+        def initialize(uuid)
+          super
+
+          @logger = Log4r::Logger.new("vagrant::provider::virtualbox_7_1")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Model
+      # Represents a single forwarded port for VirtualBox. This has various
+      # helpers and defaults for a forwarded port.
+      class ForwardedPort
+        # The NAT adapter on which to attach the forwarded port.
+        #
+        # @return [Integer]
+        attr_reader :adapter
+
+        # If true, this port should be auto-corrected.
+        #
+        # @return [Boolean]
+        attr_reader :auto_correct
+
+        # The unique ID for the forwarded port.
+        #
+        # @return [String]
+        attr_reader :id
+
+        # The protocol to forward.
+        #
+        # @return [String]
+        attr_reader :protocol
+
+        # The IP that the forwarded port will connect to on the guest machine.
+        #
+        # @return [String]
+        attr_reader :guest_ip
+
+        # The port on the guest to be exposed on the host.
+        #
+        # @return [Integer]
+        attr_reader :guest_port
+
+        # The IP that the forwarded port will bind to on the host machine.
+        #
+        # @return [String]
+        attr_reader :host_ip
+
+        # The port on the host used to access the port on the guest.
+        #
+        # @return [Integer]
+        attr_reader :host_port
+
+        def initialize(id, host_port, guest_port, options)
+          @id         = id
+          @guest_port = guest_port
+          @host_port  = host_port
+
+          options ||= {}
+          @auto_correct = false
+          @auto_correct = options[:auto_correct] if options.key?(:auto_correct)
+          @adapter  = (options[:adapter] || 1).to_i
+          @guest_ip = options[:guest_ip] || nil
+          @host_ip = options[:host_ip] || nil
+          @protocol = options[:protocol] || "tcp"
+        end
+
+        # This corrects the host port and changes it to the given new port.
+        #
+        # @param [Integer] new_port The new port
+        def correct_host_port(new_port)
+          @host_port = new_port
+        end
+      end
+    end
+  end
+end