vagrant-vmware-desktop 0.0.1 → 3.0.0

data/lib/vagrant-vmware-desktop/action/forward_ports.rb

@@ -0,0 +1,110 @@
+require "json"
+require "set"
+
+require "log4r"
+
+require "vagrant/util/scoped_hash_override"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This does NAT port forwarding on the VMware VM.
+      class ForwardPorts
+        include Common
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::forward_ports")
+        end
+
+        def call(env)
+          # Build the definitions for our driver.
+          @logger.debug("Building up ports to forward...")
+          definitions = []
+          env[:machine].config.vm.networks.each do |type, options|
+            # Ignore anything but forwarded ports
+            next if type != :forwarded_port
+            options = scoped_hash_override(options, :vmware)
+
+            # Ignore disabled ports
+            next if options[:disabled]
+
+            definitions << {
+              device: env[:machine].provider_config.nat_device,
+              guest_port: options[:guest],
+              host_port: options[:host],
+              protocol: options[:protocol],
+            }
+          end
+
+          # Make sure we're not conflicting with any of the NAT forwarded
+          # ports. Note that port collision detection/handling should fix
+          # any collisions at a higher level, so this is more of an ASSERT
+          # type statement.
+          all_ports   = Set.new(env[:machine].provider.driver.all_forwarded_ports)
+          all_defined = Set.new(definitions.map { |d| d[:host_port].to_i })
+          intersection = all_ports & all_defined
+          if !intersection.empty?
+            raise Errors::ForwardedPortsCollideWithExistingNAT,
+              :ports => intersection.to_a.sort.join(", ")
+          end
+
+          # Set the guest IP on all forwarded ports
+          guest_ip = nil
+          5.times do |_|
+            guest_ip = env[:machine].provider.driver.read_ip(
+              env[:machine].provider_config.enable_vmrun_ip_lookup
+            )
+            break if guest_ip
+            sleep 2
+          end
+
+          if !guest_ip
+            raise Errors::ForwardedPortNoGuestIP
+          end
+
+          definitions.each do |fp|
+            fp[:guest_ip] = guest_ip
+          end
+
+          # UI
+          env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.forwarding_ports"))
+          definitions.each do |fp|
+            env[:ui].detail(I18n.t(
+              "hashicorp.vagrant_vmware_desktop.forward_port_entry",
+              :guest_port => fp[:guest_port],
+              :host_port => fp[:host_port]))
+          end
+
+          # Forward the ports!
+          env[:machine].provider.driver.forward_ports(definitions)
+
+          # Store the forwarded ports for later
+          env[:machine].data_dir.join("forwarded_ports").open("w+") do |f|
+            ports = {}
+            definitions.each do |fp|
+              ports[fp[:host_port].to_i] = fp[:guest_port].to_i
+            end
+
+            f.write(JSON.dump(ports))
+          end
+
+          # Because the network gets restarted when ports are forwarded the
+          # guest may see that the network connection has been lost and then
+          # regained. NetworkManager will some times see this and drop a
+          # current DHCP lease and start the process over again which prevents
+          # expected access to the guest. To prevent that, we just wait for a
+          # bit until the network is ready.
+          port_forward_network_pause = env[:machine].provider_config.port_forward_network_pause.to_i
+          if port_forward_network_pause > 0
+            env[:ui].info("Pausing for network to stabilize (#{port_forward_network_pause} seconds)")
+            sleep(port_forward_network_pause)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/action/halt.rb

@@ -0,0 +1,27 @@
+require "log4r"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This stops the VMware machine.
+      class Halt
+        include Common
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::halt")
+        end
+
+        def call(env)
+          if env[:machine].provider.state.id == :running
+            env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.stopping"))
+            stop_mode = env[:force_halt] ? "hard" : "soft"
+            env[:machine].provider.driver.stop(stop_mode)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/action/import.rb

@@ -0,0 +1,138 @@
+require "pathname"
+require "securerandom"
+
+require "log4r"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This class "imports" a VMware machine by copying the proper
+      # files over to the VM folder.
+      class Import
+        include Common
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::import")
+        end
+
+        def call(env)
+          # Create the folder to store the VM
+          vm_folder = env[:machine].provider_config.clone_directory
+          vm_folder ||= env[:machine].data_dir
+          if VagrantVMwareDesktop.wsl? && !VagrantVMwareDesktop.wsl_drvfs_path?(vm_folder) #  !Vagrant::Util::Platform.wsl_windows_access_bypass?(vm_folder)
+            @logger.info("import folder location cannot be used due to file system type (#{vm_folder})")
+            vm_folder = File.join(VagrantVMwareDesktop.windows_to_wsl_path(Vagrant::Util::Platform.wsl_windows_appdata_local), "vagrant-vmware-desktop")
+            @logger.info("import folder location has been updated to supported location: #{vm_folder}")
+          end
+          vm_folder = File.expand_path(vm_folder, env[:machine].env.root_path)
+          vm_folder = Pathname.new(vm_folder)
+          vm_folder.mkpath if !vm_folder.directory?
+          vm_folder = vm_folder.realpath
+
+          # Create a random name for our import. We protect against some
+          # weird theoretical realities where this never gets us a unique
+          # name.
+          found = false
+          10.times do |i|
+            temp = vm_folder.join(SecureRandom.uuid)
+            if !temp.exist?
+              vm_folder = temp
+              found = true
+              break
+            end
+          end
+          raise Errors::CloneFolderExists if !found
+          vm_folder.mkpath
+
+          # TODO: If cloning, we need to verify the clone machine is not running
+
+          # Determine the primary VMX file for the box
+          vmx_file = nil
+          if env[:clone_id]
+            vmx_file = Pathname.new(env[:clone_id])
+          else
+            vmx_file = env[:machine].box.metadata["vmx_file"]
+            if vmx_file
+              vmx_file = env[:machine].box.directory.join(vmx_file)
+            end
+
+            if !vmx_file
+              # Not specified by metadata, attempt to discover VMX file
+              @logger.info("VMX file not in metadata, attempting to discover...")
+
+              env[:machine].box.directory.children(true).each do |child|
+                if child.basename.to_s =~ /^(.+?)\.vmx$/
+                  vmx_file = child
+                  break
+                end
+              end
+            end
+          end
+
+          # If we don't have a VMX file, it is an error
+          raise Errors::BoxVMXFileNotFound if !vmx_file || !vmx_file.file?
+
+          # Otherwise, log it out and continue
+          @logger.debug("Cloning into: #{vm_folder}")
+          @logger.info("VMX file: #{vmx_file}")
+
+          # Clone the VM
+          clone_name = nil
+          clone_name = env[:machine].config.vm.clone if env[:clone_id]
+          clone_name = env[:machine].box.name if !clone_name
+          env[:ui].info(I18n.t(
+            "hashicorp.vagrant_vmware_desktop.cloning",
+            :name => clone_name))
+          env[:machine].id = env[:machine].provider.driver.clone(vmx_file, vm_folder, env[:machine].provider_config.linked_clone).to_s
+
+          # If we were interrupted, then undo this
+          destroy_import(env) if env[:interrupted]
+
+          # Silence!
+          env[:machine].provider.driver.suppress_messages
+
+          # Copy the SSH key from the clone machine if we can
+          if env[:clone_machine]
+            key_path = env[:clone_machine].data_dir.join("private_key")
+            if key_path.file?
+              FileUtils.cp(
+                key_path,
+                env[:machine].data_dir.join("private_key"))
+            end
+          end
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          if env[:machine].provider.state.id != :not_created
+            # Ignore errors that Vagrant knows about.
+            return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+            # Return if we already tried to destroyimport
+            return if env[:import_destroyed]
+
+            # Return if we're not supposed to destroy
+            return if !env[:destroy_on_error]
+
+            # Note that we already tried to destroy so we don't infinite loop
+            env[:import_destroyed] = true
+
+            # Undo the import
+            destroy_import(env)
+          end
+        end
+
+        # This undoes the import by destroying it.
+        def destroy_import(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/action/machine_lock.rb

@@ -0,0 +1,26 @@
+require "vagrant/action/builtin/lock"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This class locks a single machine so that operations can only be done
+      # on one machine at a time.
+      class MachineLock < Vagrant::Action::Builtin::Lock
+        include Common
+
+        def initialize(app, outer_env)
+          options = {}
+          options[:path] = lambda do |env|
+            env[:machine].data_dir.join("lock")
+          end
+
+          options[:exception] = lambda do |env|
+            Errors::SingleMachineLock.new(:machine => env[:machine].name)
+          end
+
+          super(app, outer_env, options)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/action/message_already_running.rb

@@ -0,0 +1,18 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      class MessageAlreadyRunning
+        include Common
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.already_running"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/action/message_not_created.rb

@@ -0,0 +1,18 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      class MessageNotCreated
+        include Common
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/action/message_not_running.rb

@@ -0,0 +1,18 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      class MessageNotRunning
+        include Common
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.not_running"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/action/network.rb

@@ -0,0 +1,339 @@
+require "set"
+
+require "log4r"
+
+require "vagrant/util/network_ip"
+require "vagrant/util/scoped_hash_override"
+
+require "vagrant-vmware-desktop/helper/lock"
+require "vagrant-vmware-desktop/helper/routing_table"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This action sets up all the network adapters for the machine and
+      # also tells the guest to configure the networks.
+      class Network
+        include Common
+
+        include Vagrant::Util::NetworkIP
+        include Vagrant::Util::ScopedHashOverride
+
+        DEFAULT_VMNET_NAT = "vmnet8"
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::network")
+        end
+
+        def call(env)
+          # Set this to an ivar so that helper methods have access to it
+          @env = env
+
+          # Get the list of network adapters from the configuration
+          network_adapters_config = env[:machine].provider_config.network_adapters.dup
+
+          # Assign the adapter slot for each high-level network
+          available_slots = Set.new(1..8)
+          network_adapters_config.each do |slot, _data|
+            available_slots.delete(slot)
+          end
+
+          @logger.debug("Available slots for high-level adapters: #{available_slots.inspect}")
+          @logger.info("Determining network adapters required for high-level configuration...")
+          available_slots = available_slots.to_a.sort
+          env[:machine].config.vm.networks.each do |type, options|
+            # We only handle private and public networks
+            next if type != :private_network && type != :public_network
+
+            scope_key = "vmware_#{PRODUCT_NAME}".to_sym
+            options   = scoped_hash_override(options, scope_key)
+
+            # Figure out the slot that this adapter will go into
+            slot = options[:adapter]
+            if !slot
+              if available_slots.empty?
+                raise Errors::NetworkingNoSlotsForHighLevel
+              end
+
+              slot = available_slots.shift
+            end
+
+            # Configure it
+            data = nil
+            if type == :private_network
+              # private_network = hostonly
+              data        = [:hostonly, options]
+            elsif type == :public_network
+              # public_network = bridged
+              data        = [:bridged, options]
+            end
+
+            # Store it!
+            @logger.info(" -- Slot #{slot}: #{data[0]}")
+            network_adapters_config[slot] = data
+          end
+
+          @logger.info("Determining adapters and compiling network configuration...")
+          adapters = []
+          networks = []
+          network_adapters_config.each do |slot, data|
+            type    = data[0]
+            options = data[1]
+
+            if slot == 0 && env[:machine].provider_config.nat_device != DEFAULT_VMNET_NAT
+              # TODO: what's the device name on windows?
+              options[:device] = "/dev/#{env[:machine].provider_config.nat_device}"
+            end
+
+            @logger.info("Slot #{slot}. Type: #{type}")
+
+            # Get normalized configuration so we can add/scrub values
+            config = send("#{type}_config", options)
+            @logger.debug("Normalized configuration: #{config.inspect}")
+
+            # Get the adapter configuration for the driver
+            adapter = send("#{type}_adapter", config)
+            adapter[:slot] = slot
+            adapters << adapter
+            @logger.debug("Adapter configuration: #{adapter.inspect}")
+
+            # Get the network configuration for the guest
+            network = send("#{type}_network_config", config)
+            network[:auto_config] = config[:auto_config]
+            networks << network
+            @logger.debug("Network configuration: #{network.inspect}")
+          end
+
+          if !adapters.empty?
+            # Modify the VM metadata to add adapters
+            @logger.info("Enabling #{adapters.length} adapters...")
+            Helper::Lock.lock(env[:machine], "vmware-network") do
+              env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.enabling_adapters"))
+              env[:machine].provider.driver.setup_adapters(adapters, env[:machine].provider_config.allowlist_verified)
+            end
+          end
+
+          @app.call(env)
+
+          if !networks.empty?
+            # Assign interface numbers to the networks
+            assign_interface_numbers(networks, adapters)
+
+            networks_to_configure = networks.select { |n| n[:auto_config] }
+            env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.configuring_networks"))
+            env[:machine].guest.capability(:configure_networks, networks_to_configure)
+          end
+        end
+
+        def nat_config(options)
+          return {
+            :auto_config => true,
+            :type        => :dhcp
+          }.merge(options)
+        end
+
+        def nat_adapter(config)
+          {
+            type: :nat,
+            mac_address: config[:mac_address],
+            vnet: config[:device]
+          }.compact
+        end
+
+        def nat_network_config(config)
+          return {
+            :type => :dhcp
+          }
+        end
+
+        def hostonly_config(options)
+          # Get the default configuration built up
+          config = {
+            :auto_config => true,
+            :netmask     => "255.255.255.0",
+            :type        => :dhcp
+          }.merge(options || {})
+
+          if options[:ip]
+            # Check if we are using ipv6, which is not supported
+            ip = IPAddr.new(options[:ip])
+            if ip.ipv6?
+              raise Errors::VMNetNoIPV6
+            end
+
+            # We are using static if we have an IP set
+            config[:type] = :static
+
+            # Get the static IP and use the static IP + subnet mask to
+            # determine the subnet IP.
+            static_ip = config[:ip]
+            subnet_ip = network_address(static_ip, config[:netmask])
+            config[:subnet_ip] = subnet_ip
+
+            # Calculate the actual IP of the adapter itself, which is usually
+            # just the network address "+ 1" in the last octet
+            ip_parts = subnet_ip.split(".").map { |i| i.to_i }
+            adapter_ip    = ip_parts.dup
+            adapter_ip[3] += 1
+            config[:adapter_ip] ||= adapter_ip.join(".")
+          end
+
+          # Make sure the type is a symbol
+          config[:type] = config[:type].to_sym
+
+          return config
+        end
+
+        def hostonly_adapter(config)
+          # If we're just doing normal DHCP, then we just connect to the
+          # basic default adapter.
+          if config[:type] == :dhcp
+            return {
+              :type => :hostonly
+            }
+          end
+
+          # Otherwise we want a static IP. Start by trying to find
+          # an existing network that matches our needs.
+          vmnet = nil
+          @env[:machine].provider.driver.read_vmnet_devices.each do |device|
+            if device[:hostonly_subnet] == config[:subnet_ip]
+              @logger.info("Found matching vmnet device: #{device[:name]}")
+              vmnet = device
+              break
+            end
+          end
+
+          # Check for collisions by checking for if there is another device
+          # that the IP would route to. The basic logic is: if there is
+          # a device, and it is NOT the vmnet we care about, then it
+          # is an error.
+          @logger.info("Checking for hostonly network collisions...")
+          device = routing_table.device_for_route(config[:ip])
+          if device
+            if !vmnet || device != vmnet[:name]
+              # There is a collision with some other networking device.
+              raise Errors::NetworkingHostOnlyCollision,
+                :device => device,
+                :ip     => config[:ip]
+            end
+          end
+
+          if !vmnet
+            @logger.info("No collisions detected, creating new vmnet device.")
+            vmnet = @env[:machine].provider.driver.create_vmnet_device(
+              :netmask => config[:netmask],
+              :subnet_ip => config[:subnet_ip])
+          end
+
+          # Determine MAC address of the adapter
+          mac_address = config[:mac]
+          mac_address = vmware_mac_format(mac_address) if mac_address
+
+          # Return a more complex configuration to describe what we need
+          return {
+            :type        => :custom,
+            :mac_address => mac_address,
+            :vnet        => vmnet[:name]
+          }
+        end
+
+        def hostonly_network_config(config)
+          return {
+            :type       => config[:type],
+            :adapter_ip => config[:adapter_ip],
+            :ip         => config[:ip],
+            :netmask    => config[:netmask]
+          }
+        end
+
+        def bridged_config(options)
+          return {
+            :auto_config => true,
+            :mac         => nil,
+            :type        => :dhcp
+          }.merge(options || {})
+        end
+
+        def bridged_adapter(config)
+          mac_address = config[:mac]
+          mac_address = vmware_mac_format(mac_address) if mac_address
+
+          return {
+            :type        => :bridged,
+            :mac_address => mac_address
+          }
+        end
+
+        def bridged_network_config(config)
+          if config[:ip]
+            options = {
+              auto_config: true,
+              mac:         nil,
+              netmask:     "255.255.255.0",
+            }.merge(config)
+            options[:type] = :static
+            return options
+          end
+
+          return {
+            :type => :dhcp
+          }
+        end
+
+        #-----------------------------------------------------------------
+        # Misc. helpers
+        #-----------------------------------------------------------------
+        # Assigns the actual interface number of a network based on the
+        # enabled NICs on the virtual machine.
+        #
+        # This interface number is used by the guest to configure the
+        # NIC on the guest VM.
+        #
+        # The networks are modified in place by adding an ":interface"
+        # field to each.
+        def assign_interface_numbers(networks, adapters)
+          # First create a mapping of adapter slot to interface number
+          # by reading over the existing network adapters.
+          slots_in_use = []
+          vm_adapters = @env[:machine].provider.driver.read_network_adapters
+          vm_adapters.each do |adapter|
+            slots_in_use << adapter[:slot].to_i
+          end
+
+          slot_to_interface = {}
+          slots_in_use.sort.each_index do |i|
+            slot_to_interface[slots_in_use[i]] = i
+          end
+
+          # Make a pass through the adapters to assign the :interface
+          # key to each network configuration.
+          adapters.each_index do |i|
+            adapter = adapters[i]
+            network = networks[i]
+
+            # Figure out the interface number by simple lookup
+            network[:interface] = slot_to_interface[adapter[:slot]]
+          end
+        end
+
+        # This converts the Vagrant configured MAC address format to
+        # a typical MAC address format.
+        #
+        # @param [String] mac
+        # @return [String]
+        def vmware_mac_format(mac)
+          mac.scan(/.{2}/).join(":")
+        end
+
+        # This is a lazy loaded {Helper::RoutingTable}.
+        #
+        # @return [Helper::RoutingTable]
+        def routing_table
+          @routing_table ||= Helper::RoutingTable.new
+        end
+      end
+    end
+  end
+end