vagrant-vmware-desktop 0.0.1 → 3.0.0

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

@@ -0,0 +1,55 @@
+require "log4r"
+require "ipaddr"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This action maps an IP address to a MAC address in the DHCP
+      # server for the default NAT interface
+      class BaseMacToIp
+        include Common
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::basemactoip")
+        end
+
+        def call(env)
+          if env[:machine].provider_config.base_address
+            ip = env[:machine].provider_config.base_address
+            mac = env[:machine].provider_config.base_mac
+
+            validate_address!(env[:machine].provider.driver,
+              ip, env[:machine].provider_config.nat_device)
+
+            env[:machine].provider.driver.reserve_dhcp_address(ip, mac, env[:machine].provider_config.nat_device)
+
+            env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.mac_to_ip_mapping",
+              address: ip, mac: mac))
+          end
+          @app.call(env)
+        end
+
+        def validate_address!(driver, address, nat_device)
+          devices = driver.read_vmnet_devices
+          vmnet = devices.detect { |v| v[:name] == nat_device }
+          if !vmnet
+            raise Errors::MissingNATDevice
+          end
+          # NOTE: VMware dhcpd is configured as follows for addressing:
+          # .1          -> host machine
+          # .2 - .127   -> static address (valid here)
+          # .128 - .253 -> DHCP assigned
+          # .254        -> DHCP server
+          dev_subnet = "#{vmnet[:hostonly_subnet]}/25"
+          dev_addr = IPAddr.new(dev_subnet)
+          if address.end_with?(".1") || !dev_addr.include?(address)
+            raise Errors::BaseAddressRange,
+              range_start: dev_addr.to_range.first.succ.succ.to_s,
+              range_end: dev_addr.to_range.last.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require "log4r"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This class boots the actual VMware VM. It also waits
+      # for it to complete booting.
+      class Boot
+        include Common
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::boot")
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.booting"))
+          env[:machine].provider.driver.start(
+            env[:machine].provider_config.gui)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "log4r"
+
+require "vagrant-vmware-desktop/helper/lock"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This class checks that the existing network interfaces are all
+      # properly running and are happy, and shows an error otherwise.
+      class CheckExistingNetwork
+        include Common
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::check_existing_network")
+        end
+
+        def call(env)
+          if env[:machine].provider_config.verify_vmnet
+            @logger.info("Checking if the vmnet devices are healthy...")
+            Helper::Lock.lock(env[:machine], "vmware-network") do
+              env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.verifying_vmnet"))
+              env[:machine].provider.driver.verify_vmnet!
+            end
+          else
+            @logger.info("Skipping vmnet device verificiation, vmnet_verify option is false.")
+            env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.skipping_vmnet_verify"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This class checks to verify that VMware is properly
+      # installed and configured in such a way that Vagrant can use it.
+      class CheckVMware
+        include Common
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if !env[:check_vmware_complete]
+            # Tell the provider to verify itself.
+            env[:machine].provider.driver.verify!
+
+            # Mark that we completed it so we only do that once
+            env[:check_vmware_complete] = true
+          end
+
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This class checks if there is a new release of the Vagrant
+      # VMware desktop plugin or the Vagrant VMware utility available
+      # and notifies the user
+      class Checkpoint
+        include Common
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::checkpoint")
+        end
+
+        def call(env)
+          if !env[:checkpoint_complete]
+            if !CheckpointClient.instance.complete?
+              @logger.debug("waiting for checkpoint to complete...")
+            end
+            CheckpointClient.instance.result.each_pair do |name, result|
+              next if !result.is_a?(Hash)
+              next if result["cached"]
+              version_check(env, name, result)
+              alerts_check(env, name, result)
+            end
+            @logger.debug("checkpoint data processing complete")
+            env[:checkpoint_complete] = true
+          end
+          @app.call(env)
+        end
+
+        def alerts_check(env, name, result)
+          full_name = "vagrant-vmware-#{name}"
+          if result["alerts"] && !result["alerts"].empty?
+            result["alerts"].group_by{|a| a["level"]}.each_pair do |_, alerts|
+              alerts.each do |alert|
+                date = nil
+                begin
+                  date = Time.at(alert["date"])
+                rescue
+                  date = Time.now
+                end
+                output = I18n.t("vagrant.hashicorp.vagrant_vmware_desktop.alert",
+                  message: alert["message"],
+                  date: date,
+                  url: alert["url"]
+                )
+                case alert["level"]
+                when "info"
+                  alert_ui = Vagrant::UI::Prefixed.new(env.ui, full_name)
+                  alert_ui.info(output)
+                when "warn"
+                  alert_ui = Vagrant::UI::Prefixed.new(env.ui, "#{full_name}-warning")
+                  alert_ui.warn(output)
+                when "critical"
+                  alert_ui = Vagrant::UI::Prefixed.new(env.ui, "#{full_name}-alert")
+                  alert_ui.error(output)
+                end
+              end
+              env.ui.info("")
+            end
+          else
+            @logger.debug("no alert notifications to display")
+          end
+        end
+
+        def version_check(env, name, result)
+          name = name.to_s
+          latest_version = Gem::Version.new(result["current_version"])
+          installed_version = Gem::Version.new(result["installed_version"])
+          ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant-vmware-#{name}")
+          if latest_version > installed_version
+            @logger.info("new version of Vagrant VMware #{name.capitalize} available - #{latest_version}")
+            ui.info(I18n.t("hashicorp.vagrant_vmware_desktop.version_upgrade_available",
+              name: name.capitalize,
+              download_url: download_url["current_download_url"],
+              latest_version: latest_version))
+            env.ui.info("")
+          else
+            @logger.debug("Vagrant VMware #{name.capitalize} is currently up to date")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "log4r"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This class removes all shared folders from the VM.
+      class ClearSharedFolders
+        include Common
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::clear_shared_folders")
+        end
+
+        def call(env)
+          @logger.info("Clearing shared folders")
+          env[:machine].provider.driver.clear_shared_folders
+
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      module Common
+        # We don't want to expose the entire path to the middleware
+        # class, so we just give ourselves the class name.
+        #
+        # @return [String]
+        def to_s
+          class_name = self.class.to_s.split("::").last
+          "VMware Middleware: #{class_name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This modifies the env with some compatibility layers for
+      # prior versions of Vagrant.
+      class Compatibility
+        include Common
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          return @app.call(env) if env[:_vmware_compatibility]
+
+          if Vagrant::VERSION < "1.5.0"
+            if env[:ui]
+              # Create the new UI methods
+              ui = env[:ui]
+              def ui.detail(*args)
+                self.info(*args)
+              end
+
+              def ui.output(*args)
+                self.info(*args)
+              end
+            end
+          end
+
+          env[:_vmware_compatibility] = true
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class Created
+        include Common
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "log4r"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This deletes the machine from the system.
+      class Destroy
+        include Common
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::destroy")
+        end
+
+        def call(env)
+          if env[:machine].provider.state.id == :running
+            raise Errors::DestroyInvalidState
+          end
+
+          # As long as the VM exists, we destroy it.
+          if env[:machine].provider.state.id != :not_created
+            env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.destroying"))
+            env[:machine].provider.driver.delete
+            env[:machine].id = nil
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "log4r"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This discards the suspended state of the machine.
+      class DiscardSuspendedState
+        include Common
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::discard_suspended_state")
+        end
+
+        def call(env)
+          machine_state = env[:machine].provider.state.id
+          if machine_state == :suspended
+            env[:ui].info(I18n.t("hashicorp.vagrant_vmware_desktop.discarding_suspended_state"))
+          end
+
+          if machine_state != :not_created
+            # We don't care if the machine is suspended or not, just always
+            # delete the suspended state if it is created, since that is our job
+            env[:machine].provider.driver.discard_suspended_state
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      class Export
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          raise Vagrant::Errors::VMPowerOffToPackage if \
+            @env[:machine].state.id != :not_running
+
+          path = File.join(@env["export.temp_dir"], "box.vmx")
+
+          if Vagrant::Util::Platform.respond_to?(:wsl?) && Vagrant::Util::Platform.wsl?
+            path = Vagrant::Util::Platform.wsl_to_windows_path(path)
+          end
+
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.exporting")
+          @env[:machine].provider.driver.export(path)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "log4r"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Action
+      # This fixes old-style machine IDs that were set in early versions of
+      # the VMware providers.
+      class FixOldMachineID
+        include Common
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::fix_old_machine_id")
+        end
+
+        def call(env)
+          driver     = env[:machine].provider.driver
+          machine_id = env[:machine].id
+          if machine_id && driver.vmx_path.to_s != machine_id
+            @logger.warn("Old-style ID found. Resetting to VMX path.")
+            env[:machine].id = driver.vmx_path.to_s
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end