vagrant-vmware-desktop 0.0.1 → 3.0.0

data/lib/vagrant-vmware-desktop/guest_cap/linux/verify_vmware_hgfs.rb

@@ -0,0 +1,27 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module GuestCap
+      module Linux
+        class VerifyVMwareHGFS
+          def self.verify_vmware_hgfs(machine)
+            # Retry a few times since some systems take time to load
+            # the VMware kernel modules.
+            8.times do |i|
+              # Kernel module
+              return true if machine.communicate.test(
+                "PATH=\"/sbin:$PATH\" lsmod | grep -i '^vmhgfs'")
+
+              # open-vm-tools (FUSE filesystem)
+              return true if machine.communicate.test(
+                "command -v vmhgfs-fuse")
+
+              sleep(2 ** i)
+            end
+
+            return false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/helper/lock.rb

@@ -0,0 +1,26 @@
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Helper
+      # The Lock module implements some locking primitives for parallelism
+      # that respect the Vagrant version that is available.
+      module Lock
+        def self.lock(machine, name, **opts, &block)
+          # Before version 1.6, we don't have any sort of locking
+          return block.call if Vagrant::VERSION < "1.6.0"
+
+          # Set some defaults
+          opts = { retry: true }.merge(opts)
+
+          # Lock the environment and yield it.
+          begin
+            return machine.env.lock(name, &block)
+          rescue Vagrant::Errors::EnvironmentLockedError
+            raise if !opts[:retry]
+            sleep 1
+            retry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/helper/routing_table.rb

@@ -0,0 +1,182 @@
+require "ipaddr"
+
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+require "vagrant-vmware-desktop/errors"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Helper
+      # This class reads the TCP/IP routing table for the current host.
+      # On Mac OS X and Linux machines, `netstat` is used. Windows is
+      # not currently implemented, but similar applications are installed
+      # by default.
+      class RoutingTable
+        def initialize
+          if Vagrant::Util::Platform.darwin?
+            @table = read_table_darwin
+          elsif Vagrant::Util::Platform.linux?
+            @table = read_table_linux
+          elsif Vagrant::Util::Platform.windows?
+            @table = read_table_windows
+          else
+            raise Errors::RoutingTableUnsupportedOS
+          end
+        end
+
+        # This will return the device that the given IP would be routed
+        # to, or `nil` if it would just route to the default route.
+        #
+        # @param [String] ip The IP address.
+        def device_for_route(ip)
+          return @table[ip] if @table.has_key?(ip)
+
+          smallest = nil
+          smallest_size = nil
+          @table.each do |destination, interface|
+            if destination.include?(IPAddr.new(ip))
+              # Ruby 2.0 adds a "size" operator to Range, which we should
+              # use when we switch to it.
+              ip_range = destination.to_range
+              ip_size = ip_range.max.to_i - ip_range.min.to_i
+              if smallest_size.nil? || ip_size < smallest_size
+                smallest = interface
+                smallest_size = ip_size
+              end
+            end
+          end
+
+          smallest
+        end
+
+        protected
+
+        def read_table_darwin
+          netstat_path = Vagrant::Util::Which.which("netstat")
+          raise Errors::RoutingTableCommandNotFound if !netstat_path
+
+          r = Vagrant::Util::Subprocess.execute(netstat_path, "-nr", "-f", "inet")
+          raise Errors::RoutingTableLoadError, :output => r.stderr if r.exit_code != 0
+
+          result = {}
+          r.stdout.split("\n").each do |line|
+            # If the line doesn't start with a number, it isn't worth
+            # looking at.
+            next if line !~ /^\d/
+
+            # Split by whitespace
+            parts = line.split
+
+            # Get out the destination and device, since these are
+            # the only fields we actually care about.
+            destination = parts[0]
+            device      = parts[5]
+
+            # Convert the destination into an IPAddr. This involves splitting
+            # out the mask and figuring out the proper IP address formatting...
+            ip_parts = destination.split("/")
+            mask     = ip_parts[1]
+            ip_parts = ip_parts[0].split(".")
+            mask     ||= Array.new(ip_parts.length, "255")
+
+            while ip_parts.length < 4
+              ip_parts << "0"
+              mask     << "0" if mask.is_a?(Array)
+            end
+
+            # If mask is an array we turn it into a real mask here
+            mask = mask.join(".") if mask.is_a?(Array)
+
+            # Build the IP and final destination
+            ip_parts = ip_parts.join(".")
+            destination = IPAddr.new("#{ip_parts}/#{mask}")
+
+            # Map the destination to the device
+            result[destination] = device
+          end
+
+          result
+        end
+
+        def read_table_linux
+          netstat_path = Vagrant::Util::Which.which("netstat")
+          raise Errors::RoutingTableCommandNotFound if !netstat_path
+
+          r = Vagrant::Util::Subprocess.execute(netstat_path, "-nr")
+          raise Errors::RoutingTableLoadError, :output => r.stderr if r.exit_code != 0
+
+          result = {}
+          r.stdout.split("\n").each do |line|
+            # If the line doesn't start with a number, it isn't worth
+            # looking at.
+            next if line !~ /^\d/
+
+            # Split by whitespace
+            parts = line.split
+
+            # Grab the pieces
+            destination = parts[0]
+            mask        = parts[2]
+            device      = parts[7]
+
+            # If the destination is default, then ignore
+            next if destination == "0.0.0.0"
+
+            # Build the IP
+            ip = IPAddr.new("#{destination}/#{mask}")
+
+            # Map the destination to the device
+            result[ip] = device
+          end
+
+          result
+        end
+
+        def read_table_windows
+          netsh_path = Vagrant::Util::Which.which("netsh.exe")
+          raise Errors::RoutingTableCommandNotFound if !netsh_path
+
+          r = Vagrant::Util::Subprocess.execute(
+            netsh_path, "interface", "ip", "show", "route")
+          raise Errors::RoutingTableLoadError, :output => r.stderr if r.exit_code != 0
+
+          # Just use Unix-style line endings
+          r.stdout.gsub!("\r\n", "\n")
+
+          result = {}
+          r.stdout.split("\n").each do |line|
+            # Split by whitespace
+            parts = line.split
+
+            # If there aren't enough parts, ignore it
+            next if parts.length < 6
+
+            # If we didn't get numbers for the metrics, then ignore
+            next if parts[2] !~ /^\d+$/
+
+            # Grab the pieces
+            ip     = parts[3]
+            device = parts[5..-1].join(" ")
+
+            # If we're working with a VMware device, parse out the vmnet
+            match = /^VMware Network Adapter (.+?)$/.match(device)
+            device = match[1].downcase if match
+
+            # If the destination is default, then ignore
+            next if ip == "0.0.0.0/0"
+
+            # Build the IP
+            ip = IPAddr.new(ip)
+
+            # Map the destination to the device
+            result[ip] = device
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/helper/vagrant_utility.rb

@@ -0,0 +1,185 @@
+require "log4r"
+require "net/http"
+require "net/https"
+
+require "vagrant"
+require "vagrant/util/downloader"
+require "vagrant/util/string_block_editor"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    module Helper
+      # This is a class for dealing the vagrant vmware utility API
+      class VagrantUtility
+
+        # Response wrapper class
+        class Response
+
+          # Raw value being wrapped
+          #
+          # @return [Hash]
+          attr_reader :value
+
+          def initialize(value)
+            if !value.is_a?(Hash)
+              raise TypeError.new("Expecting value of `Hash` type but received `#{value.class}`")
+            end
+            @value = value
+          end
+
+          # Provides Hash#dig functionality but will raise
+          # an invalid response exception if given path raises
+          # an error.
+          #
+          # @return [Object]
+          def get(*args)
+            begin
+              value.dig(*args)
+            rescue => err
+              raise Errors::DriverAPIInvalidResponse
+            end
+          end
+
+          def [](v)
+            value[v]
+          end
+
+          # @return [TrueClass, FalseClass] response is success
+          def success?
+            value[:success]
+          end
+        end
+
+        # @return [Net::HTTP]
+        attr_reader :connection
+        # @return [Hash]
+        attr_reader :headers
+        # @return [Log4r::Logger]
+        attr_reader :logger
+
+        def initialize(host, port, **opts)
+          @logger = Log4r::Logger.new("hashicorp::provider::vmware::vagrant_utility")
+          @logger.debug("initialize HOST=#{host} PORT=#{port}")
+          @connection = Net::HTTP.new(host, port)
+          @connection.use_ssl = true
+          @connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          @connection.ca_file = File.join(opts[:certificate_path], "vagrant-utility.crt")
+          @headers = {
+            "Content-Type" => "application/vnd.hashicorp.vagrant.vmware.rest-v1+json",
+            "Origin" => "https://#{host}:#{port}",
+            "User-Agent" => Vagrant::Util::Downloader::USER_AGENT +
+              " - VagrantVMWareDesktop/#{VagrantVMwareDesktop::VERSION}",
+            "X-Requested-With" => "Vagrant",
+          }
+          cert_path = File.join(opts[:certificate_path], "vagrant-utility.client.crt")
+          key_path = File.join(opts[:certificate_path], "vagrant-utility.client.key")
+          begin
+            @connection.cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+          rescue => err
+            @logger.debug("certificate load failure - #{err.class}: #{err}")
+            raise Errors::DriverAPICertificateError.new(
+              path: cert_path,
+              message: err.message
+            )
+          end
+          begin
+            @connection.key = OpenSSL::PKey::RSA.new(File.read(key_path))
+          rescue => err
+            @logger.debug("key load failure - #{err.class}: #{err}")
+            raise Errors::DriverAPIKeyError.new(
+              path: key_path,
+              message: err.message
+            )
+          end
+        end
+
+        # Perform GET
+        #
+        # @param [String] path
+        # @return [Response]
+        def get(path)
+          perform_request(:get, path)
+        end
+
+        # Perform PUT
+        #
+        # @param [String] path
+        # @param [Object] payload
+        # @return [Response]
+        def put(path, payload=nil)
+          perform_request(:put, path, payload)
+        end
+
+        # Perform POST
+        #
+        # @param [String] path
+        # @param [Object] payload
+        # @return [Response]
+        def post(path, payload=nil)
+          perform_request(:post, path, payload)
+        end
+
+        # Perform DELETE
+        #
+        # @param [String] path
+        # @param [Object] payload
+        # @return [Response]
+        def delete(path, payload=nil)
+          perform_request(:delete, path, payload)
+        end
+
+        # Perform the remote request and process the result
+        #
+        # @param [String,Symbol] method HTTP method
+        # @param [String] path remote path
+        # @param [Object] data request body
+        # @param [Hash] rheaders custom request headers
+        # @return [Response]
+        def perform_request(method, path, data=nil, rheaders={})
+          req_headers = headers.merge(rheaders)
+          if data && !data.is_a?(String)
+            data = JSON.generate(data)
+          end
+          method = method.to_s.upcase
+          response = process_response do
+            connection.send_request(method, path, data, req_headers)
+          end
+          if !response.success?
+            error = "ERROR=#{response.get(:content, :message)}"
+          end
+          @logger.debug("request METHOD=#{method} PATH=#{path} RESPONSE=#{response.get(:code)} #{error}")
+          response
+        end
+
+        # Wraps response into Response instance
+        #
+        # @yieldblock [Net::HTTPResponse]
+        # @return [Response]
+        def process_response
+          begin
+            response = yield
+            result = {
+              code: response.code.to_i,
+              success: response.code.start_with?('2')
+            }
+            if response.class.body_permitted?
+              body = response.body
+              begin
+                result[:content] = JSON.parse(body, :symbolize_names => true)
+              rescue
+                result[:content] = body
+              end
+            else
+              result[:content] = nil
+            end
+            Response.new(result)
+          rescue Net::HTTPServiceUnavailable
+            raise Errors::DriverAPIConnectionFailed
+          rescue => err
+            raise Errors::DriverAPIRequestUnexpectedError, error: err
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmware-desktop/plugin.rb

@@ -0,0 +1,148 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant VMware #{HashiCorp::VagrantVMwareDesktop::PRODUCT_NAME} provider must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "VMware #{HashiCorp::VagrantVMwareDesktop::PRODUCT_NAME} provider is only compatible with Vagrant 1.2+"
+end
+
+require "vagrant-vmware-desktop/setup_plugin"
+
+module HashiCorp
+  module VagrantVMwareDesktop
+    class Plugin < Vagrant.plugin("2")
+      name "VMware #{PRODUCT_NAME.capitalize} Provider"
+      description <<-DESC
+      This plugin installs a provider which allows Vagrant to manage
+      VMware #{PRODUCT_NAME.capitalize} machines.
+      DESC
+
+      def self.provider_name
+        "vmware_#{PRODUCT_NAME}".to_sym
+      end
+
+      def self.provider_options
+        {
+          box_format: ["vmware_desktop", "vmware_fusion", "vmware_workstation"],
+          priority: 10,
+        }
+      end
+
+      #--------------------------------------------------------------
+      # Action Hooks
+      #--------------------------------------------------------------
+      # Plugin activation/licensing
+      action_hook(:activation_start, :environment_load) do |h|
+        h.append(SetupPlugin)
+      end
+
+      #--------------------------------------------------------------
+      # VMware Provider
+      #--------------------------------------------------------------
+
+      # We register two providers now, vmware_desktop which is named after
+      # this plugin's now current name, and vmware_PRODUCT_NAME which is
+      # the legacy naming covering vmware_workstation and vmware_fusion.
+      # This provides backwards compatibility ensuring things still work
+      # after upgrading
+
+      [:vmware_desktop, provider_name].each do |p_name|
+        config(p_name, :provider) do
+          require File.expand_path("../config", __FILE__)
+          Config
+        end
+
+        provider_capability(p_name, :snapshot_list) do
+          require File.expand_path("../cap/snapshot", __FILE__)
+          Cap::Snapshot
+        end
+
+        provider_capability(p_name, :delete_all_snapshots) do
+          require File.expand_path("../cap/snapshot", __FILE__)
+          Cap::Snapshot
+        end
+
+        provider_capability(p_name, :delete_snapshot) do
+          require File.expand_path("../cap/snapshot", __FILE__)
+          Cap::Snapshot
+        end
+
+        provider(p_name, provider_options) do
+          require File.expand_path("../provider", __FILE__)
+          Provider
+        end
+
+        provider_capability(p_name, :forwarded_ports) do
+          require File.expand_path("../cap/provider", __FILE__)
+          Cap::Provider
+        end
+
+        provider_capability(p_name, :public_address) do
+          require File.expand_path("../cap/provider", __FILE__)
+          Cap::Provider
+        end
+
+        provider_capability(p_name, :nic_mac_addresses) do
+          require File.expand_path("../cap/provider", __FILE__)
+          Cap::Provider
+        end
+
+        provider_capability(p_name, :scrub_forwarded_ports) do
+          require File.expand_path("../cap/provider", __FILE__)
+          Cap::Provider
+        end
+
+        Vagrant::Util::Experimental.guard_with(:disks) do
+          provider_capability(p_name, :set_default_disk_ext) do
+            require File.expand_path("../cap/disk", __FILE__)
+            Cap::Disk
+          end
+
+          provider_capability(p_name, :default_disk_exts) do
+            require File.expand_path("../cap/disk", __FILE__)
+            Cap::Disk
+          end
+
+          provider_capability(p_name, :configure_disks) do
+            require File.expand_path("../cap/disk", __FILE__)
+            Cap::Disk
+          end
+
+          provider_capability(p_name, :cleanup_disks) do
+            require File.expand_path("../cap/disk", __FILE__)
+            Cap::Disk
+          end
+        end
+      end
+
+      #--------------------------------------------------------------
+      # Synced Folder
+      #--------------------------------------------------------------
+
+      synced_folder(:vmware) do
+        require File.expand_path("../synced_folder", __FILE__)
+        SyncedFolder
+      end
+
+      #--------------------------------------------------------------
+      # Capabilities introduced by VMware provider
+      #--------------------------------------------------------------
+
+      guest_capability("linux", "verify_vmware_hgfs") do
+        require_relative "guest_cap/linux/verify_vmware_hgfs"
+        GuestCap::Linux::VerifyVMwareHGFS
+      end
+
+      guest_capability("linux", "mount_vmware_shared_folder") do
+        require_relative "guest_cap/linux/mount_vmware_shared_folder"
+        GuestCap::Linux::MountVMwareSharedFolder
+      end
+
+      autoload :Action, File.expand_path("../action", __FILE__)
+    end
+  end
+end