vagrant-parallels 1.0.9.rc1 → 1.1.0

data/lib/vagrant-parallels/action/import.rb

@@ -15,7 +15,7 @@ module VagrantPlugins
           unregister_template
 
           # Flag as erroneous and return if import failed
-          raise Vagrant::Errors::VMImportFailure if !env[:machine].id
+          raise VagrantPlugins::Parallels::Errors::VMImportFailure if !env[:machine].id
 
           # Import completed successfully. Continue the chain
           @app.call(env)

data/lib/vagrant-parallels/action/is_driver_version.rb

@@ -0,0 +1,28 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      # This middleware is meant to be used with Call and can check if
+      # a version of Parallels Desktop satisfies the given constraint.
+      class IsDriverVersion
+        # @param [String] requirement Can be a full requirement specification,
+        # like ">= 9.0.24229", or a list of them, like [">= 9","< 10.0.2"].
+        def initialize(app, env, requirement, **opts)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::plugins::parallels::is_driver_version")
+          @requirement = Gem::Requirement.new(requirement)
+          @invert = !!opts[:invert]
+        end
+
+        def call(env)
+          @logger.debug("Checking if 'prlctl' driver version satisfies '#{@requirement}'")
+          driver_version = Gem::Version.new(env[:machine].provider.driver.version)
+          @logger.debug("-- 'prlctl' driver version: #{driver_version}")
+
+          env[:result] = @requirement.satisfied_by?(driver_version)
+          env[:result] = !env[:result] if @invert
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/action/set_power_consumption.rb

@@ -1,6 +1,8 @@
 module VagrantPlugins
   module Parallels
     module Action
+      # Important: It works only with Parallels Desktop >= 9 !
+      # Use "IsDriverVersion" middleware to wrap it.
       class SetPowerConsumption
         def initialize(app, env)
           @logger = Log4r::Logger.new("vagrant::plugins::parallels::power_consumption")
@@ -8,12 +10,6 @@ module VagrantPlugins
         end
 
         def call(env)
-          pd_version = env[:machine].provider.driver.version
-          if Gem::Version.new(pd_version) < Gem::Version.new("9")
-            @logger.info("Power consumption management is available only for Parallels Desktop >= 9")
-            return @app.call(env)
-          end
-
           # Optimization of power consumption is defined by "Longer Battery Life" state.
           vm_settings = env[:machine].provider.driver.read_settings
 

data/lib/vagrant-parallels/config.rb

@@ -8,6 +8,7 @@ module VagrantPlugins
       attr_accessor :optimize_power_consumption
       attr_accessor :name
       attr_reader   :network_adapters
+      attr_accessor :update_guest_tools
 
 
       # Compatibility with virtualbox provider's syntax
@@ -21,6 +22,7 @@ module VagrantPlugins
         @network_adapters  = {}
         @name              = UNSET_VALUE
         @optimize_power_consumption = UNSET_VALUE
+        @update_guest_tools = UNSET_VALUE
 
         network_adapter(0, :shared)
       end
@@ -70,6 +72,10 @@ module VagrantPlugins
         end
 
         @name = nil if @name == UNSET_VALUE
+
+        if @update_guest_tools == UNSET_VALUE
+          @update_guest_tools = false
+        end
       end
 
       def validate(machine)

data/lib/vagrant-parallels/driver/base.rb

@@ -3,7 +3,6 @@ require 'log4r'
 require 'vagrant/util/busy'
 require 'vagrant/util/network_ip'
 require 'vagrant/util/platform'
-require 'vagrant/util/retryable'
 require 'vagrant/util/subprocess'
 
 module VagrantPlugins
@@ -24,17 +23,11 @@ module VagrantPlugins
           # This flag is used to keep track of interrupted state (SIGINT)
           @interrupted = false
 
-          # Set the list of required CLI utils
-          @cli_paths = {
-            :prlctl        => "prlctl",
-            :prlsrvctl     => "prlsrvctl",
-            :prl_disk_tool => "prl_disk_tool",
-            :ifconfig      => "ifconfig"
-          }
+          @prlctl_path    = "prlctl"
+          @prlsrvctl_path = "prlsrvctl"
 
-          @cli_paths.each do |name, path|
-            @logger.info("CLI utility '#{name}' path: #{path}")
-          end
+          @logger.info("prlctl path: #{@prlctl_path}")
+          @logger.info("prlsrvctl path: #{@prlsrvctl_path}")
         end
 
         # Clears the shared folders that have been set on the virtual machine.
@@ -93,7 +86,7 @@ module VagrantPlugins
         # Raises a prlctl error if it fails.
         #
         # @param [Array] command Command to execute.
-        def execute_command(command)
+        def execute_prlctl(command)
         end
 
         # Exports the virtual machine to the given path.
@@ -131,10 +124,22 @@ module VagrantPlugins
         def read_bridged_interfaces
         end
 
-        # Returns the guest tools version that is installed on this VM.
+        # Returns the state of guest tools that is installed on this VM.
+        # Can be any of:
+        # * "installed"
+        # * "not_installed"
+        # * "possibly_installed"
+        # * "outdated"
         #
         # @return [String]
-        def read_guest_tools_version
+        def read_guest_tools_state
+        end
+
+        # Returns path to the Parallels Tools ISO file.
+        #
+        # @param [String] guest_os Guest os type: "linux", "darwin" or "windows"
+        # @return [String] Path to the ISO.
+        def read_guest_tools_iso_path(guest_os)
         end
 
         # Returns a list of available host only interfaces.
@@ -244,50 +249,35 @@ module VagrantPlugins
         def unshare_folders(names)
         end
 
-        # Verifies that the driver is ready to accept work.
-        #
-        # This should raise a VagrantError if things are not ready.
-        def verify!
-        end
-
         # Checks if a VM with the given UUID exists.
         #
         # @return [Boolean]
         def vm_exists?(uuid)
         end
 
-        # Execute the given subcommand for PrlCtl and return the output.
-        def execute(*command, &block)
-          # Get the options hash if it exists
-          opts = {}
-          opts = command.pop if command.last.is_a?(Hash)
-
-          tries = opts[:retryable] ? 3 : 0
-
-          # Variable to store our execution result
-          r = nil
-
-          retryable(:on => VagrantPlugins::Parallels::Errors::PrlCtlError, :tries => tries, :sleep => 1) do
-            # If there is an error with PrlCtl, this gets set to true
-            errored = false
-
-            # Execute the command
-            r = raw(*command, &block)
-
-            # If the command was a failure, then raise an exception that is
-            # nicely handled by Vagrant.
-            if r.exit_code != 0
-              if @interrupted
-                @logger.info("Exit code != 0, but interrupted. Ignoring.")
-              else
-                errored = true
-              end
-            end
+        # Wraps 'execute' and returns the output of given 'prlctl' subcommand.
+        def execute_prlctl(*command, &block)
+          execute(@prlctl_path, *command, &block)
+        end
 
-            # If there was an error running prlctl, show the error and the
-            # output.
-            if errored
-              raise VagrantPlugins::Parallels::Errors::PrlCtlError,
+        #Wraps 'execute' and returns the output of given 'prlsrvctl' subcommand.
+        def execute_prlsrvctl(*command, &block)
+          execute(@prlsrvctl_path, *command, &block)
+        end
+
+        # Execute the given command and return the output.
+        def execute(*command, &block)
+          r = raw(*command, &block)
+
+          # If the command was a failure, then raise an exception that is
+          # nicely handled by Vagrant.
+          if r.exit_code != 0
+            if @interrupted
+              @logger.info("Exit code != 0, but interrupted. Ignoring.")
+            else
+              # If there was an error running command, show the error and the
+              # output.
+              raise VagrantPlugins::Parallels::Errors::ExecutionError,
                 :command => command.inspect,
                 :stderr  => r.stderr
             end
@@ -308,13 +298,8 @@ module VagrantPlugins
           # Append in the options for subprocess
           command << { :notify => [:stdout, :stderr] }
 
-          # Get the utility from the first argument:
-          # 'prlctl' by default
-          util = @cli_paths.has_key?(command.first) ? command.delete_at(0) : :prlctl
-          cli = @cli_paths[util]
-
           Vagrant::Util::Busy.busy(int_callback) do
-            Vagrant::Util::Subprocess.execute(cli, *command, &block)
+            Vagrant::Util::Subprocess.execute(*command, &block)
           end
         end
       end

data/lib/vagrant-parallels/driver/meta.rb

@@ -84,14 +84,14 @@ module VagrantPlugins
                        :delete_disabled_adapters,
                        :delete_unused_host_only_networks,
                        :enable_adapters,
-                       :execute_command,
+                       :execute_prlctl,
                        :export,
                        :halt,
                        :import,
                        :read_bridged_interfaces,
-                       :read_guest_tools_version,
+                       :read_guest_tools_state,
+                       :read_guest_tools_iso_path,
                        :read_guest_ip,
-                       :read_guest_property,
                        :read_host_only_interfaces,
                        :read_mac_address,
                        :read_mac_addresses,
@@ -116,7 +116,6 @@ module VagrantPlugins
                        :start,
                        :suspend,
                        :unregister,
-                       :verify!,
                        :vm_exists?
 
         protected
@@ -133,7 +132,7 @@ module VagrantPlugins
           #
           # But we need exactly the first 3 numbers: "x.x.x"
 
-          if execute('--version', retryable: true) =~ /prlctl version (\d+\.\d+.\d+)/
+          if execute('prlctl', '--version') =~ /prlctl version (\d+\.\d+.\d+)/
             return $1
           else
             return nil

data/lib/vagrant-parallels/driver/pd_8.rb

@@ -18,9 +18,11 @@ module VagrantPlugins
 
 
         def compact(uuid)
-          used_drives = read_settings.fetch('Hardware', {}).select { |name, _| name.start_with? 'hdd' }
+          used_drives = read_settings.fetch('Hardware', {}).select do |name, _|
+            name.start_with? 'hdd'
+          end
           used_drives.each_value do |drive_params|
-            execute(:prl_disk_tool, 'compact', '--hdd', drive_params["image"]) do |type, data|
+            execute('prl_disk_tool', 'compact', '--hdd', drive_params['image']) do |type, data|
               lines = data.split("\r")
               # The progress of the compact will be in the last line. Do a greedy
               # regular expression to find what we're looking for.
@@ -34,13 +36,13 @@ module VagrantPlugins
         def clear_shared_folders
           share_ids = read_shared_folders.keys
           share_ids.each do |id|
-            execute("set", @uuid, "--shf-host-del", id)
+            execute_prlctl('set', @uuid, '--shf-host-del', id)
           end
         end
 
         def create_host_only_network(options)
           # Create the interface
-          execute(:prlsrvctl, "net", "add", options[:network_id], "--type", "host-only")
+          execute_prlsrvctl('net', 'add', options[:network_id], '--type', 'host-only')
 
           # Configure it
           args = ["--ip", "#{options[:adapter_ip]}/#{options[:netmask]}"]
@@ -50,10 +52,10 @@ module VagrantPlugins
                          "--ip-scope-end", options[:dhcp][:upper]])
           end
 
-          execute(:prlsrvctl, "net", "set", options[:network_id], *args)
+          execute_prlsrvctl('net', 'set', options[:network_id], *args)
 
           # Determine interface to which it has been bound
-          net_info = json { execute(:prlsrvctl, 'net', 'info', options[:network_id], '--json', retryable: true) }
+          net_info = json { execute_prlsrvctl('net', 'info', options[:network_id], '--json') }
           iface_name = net_info['Bound To']
 
           # Return the details
@@ -66,13 +68,13 @@ module VagrantPlugins
         end
 
         def delete
-          execute('delete', @uuid)
+          execute_prlctl('delete', @uuid)
         end
 
         def delete_disabled_adapters
           read_settings.fetch('Hardware', {}).each do |adapter, params|
-            if adapter.start_with?('net') and !params.fetch("enabled", true)
-              execute('set', @uuid, '--device-del', adapter)
+            if adapter.start_with?('net') and !params.fetch('enabled', true)
+              execute_prlctl('set', @uuid, '--device-del', adapter)
             end
           end
         end
@@ -97,19 +99,21 @@ module VagrantPlugins
 
           networks.each do |net|
             # Delete the actual host only network interface.
-            execute(:prlsrvctl, "net", "del", net["Network ID"])
+            execute_prlsrvctl('net', 'del', net['Network ID'])
           end
         end
 
         def enable_adapters(adapters)
           # Get adapters which have already configured for this VM
           # Such adapters will be just overridden
-          existing_adapters = read_settings.fetch('Hardware', {}).keys.select { |name| name.start_with? 'net' }
+          existing_adapters = read_settings.fetch('Hardware', {}).keys.select do |name|
+            name.start_with? 'net'
+          end
 
           # Disable all previously existing adapters (except shared 'vnet0')
           existing_adapters.each do |adapter|
             if adapter != 'vnet0'
-              execute('set', @uuid, '--device-set', adapter, '--disable')
+              execute_prlctl('set', @uuid, '--device-set', adapter, '--disable')
             end
           end
 
@@ -141,16 +145,15 @@ module VagrantPlugins
               args.concat(["--adapter-type", adapter[:nic_type].to_s])
             end
 
-            execute("set", @uuid, *args)
+            execute_prlctl("set", @uuid, *args)
           end
         end
 
-        def execute_command(command)
-          execute(*command)
-        end
-
         def export(path, tpl_name)
-          execute("clone", @uuid, "--name", tpl_name, "--template", "--dst", path.to_s) do |type, data|
+          execute_prlctl('clone', @uuid,
+                         '--name', tpl_name,
+                         '--template',
+                         '--dst', path.to_s) do |type, data|
             lines = data.split("\r")
             # The progress of the export will be in the last line. Do a greedy
             # regular expression to find what we're looking for.
@@ -162,7 +165,7 @@ module VagrantPlugins
         end
 
         def halt(force=false)
-          args = ['stop', @uuid]
+          args = ['prlctl', 'stop', @uuid]
           args << '--kill' if force
           execute(*args)
         end
@@ -171,7 +174,7 @@ module VagrantPlugins
           template_name = read_vms.key(template_uuid)
           vm_name = "#{template_name}_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
 
-          execute("clone", template_uuid, '--name', vm_name) do |type, data|
+          execute_prlctl('clone', template_uuid, '--name', vm_name) do |type, data|
             lines = data.split("\r")
             # The progress of the import will be in the last line. Do a greedy
             # regular expression to find what we're looking for.
@@ -192,7 +195,7 @@ module VagrantPlugins
           bridged_ifaces = []
           net_list.keys.each do |iface|
             info = {}
-            ifconfig = execute(:ifconfig, iface)
+            ifconfig = execute('ifconfig', iface)
             # Assign default values
             info[:name]    = iface
             info[:ip]      = "0.0.0.0"
@@ -234,13 +237,35 @@ module VagrantPlugins
           nil
         end
 
-        def read_guest_tools_version
-          tools_version = read_settings.fetch('GuestTools', {}).fetch('version', '')
-          tools_version[/(^\d+\.\d+.\d+)/]
+        def read_guest_tools_iso_path(guest_os)
+          guest_os = guest_os.to_sym
+          iso_name ={
+            :linux   => "prl-tools-lin.iso",
+            :darwin  => "prl-tools-mac.iso",
+            :windows => "prl-tools-win.iso"
+          }
+          return nil if !iso_name[guest_os]
+
+          bundle_id =  'com.parallels.desktop.console'
+          bundle_path = execute('mdfind', "kMDItemCFBundleIdentifier == #{bundle_id}")
+          iso_path = File.expand_path("./Contents/Resources/Tools/#{iso_name[guest_os]}",
+                                      bundle_path.split("\n")[0])
+
+          if !File.exist?(iso_path)
+            raise Errors::ParallelsToolsIsoNotFound, :iso_path => iso_path
+          end
+
+          iso_path
+        end
+
+        def read_guest_tools_state
+          state = read_settings.fetch('GuestTools', {}).fetch('state', nil)
+          state = "not_installed" if !state
+          state.to_sym
         end
 
         def read_host_info
-          json { execute('server', 'info', '--json', retryable: true) }
+          json { execute_prlctl('server', 'info', '--json') }
         end
 
         def read_host_only_interfaces
@@ -250,7 +275,7 @@ module VagrantPlugins
           hostonly_ifaces = []
           net_list.each do |iface|
             info = {}
-            net_info = json { execute(:prlsrvctl, 'net', 'info', iface['Network ID'], '--json') }
+            net_info = json { execute_prlsrvctl('net', 'info', iface['Network ID'], '--json') }
             # Really we need to work with bounded virtual interface
             info[:name]     = net_info['Bound To']
             info[:ip]       = net_info['Parallels adapter']['IP address']
@@ -261,7 +286,8 @@ module VagrantPlugins
             # There may be a fake DHCPv4 parameters
             # We can trust them only if adapter IP and DHCP IP are in the same subnet
             dhcp_ip = net_info['DHCPv4 server']['Server address']
-            if network_address(info[:ip], info[:netmask]) == network_address(dhcp_ip, info[:netmask])
+            if network_address(info[:ip], info[:netmask]) ==
+              network_address(dhcp_ip, info[:netmask])
               info[:dhcp] = {
                 :ip      => dhcp_ip,
                 :lower   => net_info['DHCPv4 server']['IP scope start address'],
@@ -319,7 +345,7 @@ module VagrantPlugins
         end
 
         def read_settings
-          vm = json { execute('list', @uuid, '--info', '--json', retryable: true).gsub(/^INFO/, '') }
+          vm = json { execute_prlctl('list', @uuid, '--info', '--json').gsub(/^INFO/, '') }
           vm.last
         end
 
@@ -328,7 +354,9 @@ module VagrantPlugins
           shared_net = read_virtual_networks.detect { |net| net['Type'] == 'shared' }
           return nil if !shared_net
 
-          net_info = json { execute(:prlsrvctl, 'net', 'info', shared_net['Network ID'], '--json') }
+          net_info = json do
+            execute_prlsrvctl('net', 'info', shared_net['Network ID'], '--json')
+          end
           info = {
             name:    net_info['Bound To'],
             ip:      net_info['Parallels adapter']['IP address'],
@@ -358,22 +386,22 @@ module VagrantPlugins
         end
 
         def read_state
-          vm = json { execute('list', @uuid, '--json', retryable: true).gsub(/^INFO/, '') }
+          vm = json { execute_prlctl('list', @uuid, '--json').gsub(/^INFO/, '') }
           return nil if !vm.last
           vm.last.fetch('status').to_sym
         end
 
         def read_virtual_networks
-          json { execute(:prlsrvctl, 'net', 'list', '--json', retryable: true) }
+          json { execute_prlsrvctl('net', 'list', '--json') }
         end
 
         def read_vms
           results = {}
           vms_arr = json([]) do
-            execute('list', '--all', '--json', retryable: true).gsub(/^INFO/, '')
+            execute_prlctl('list', '--all', '--json').gsub(/^INFO/, '')
           end
           templates_arr = json([]) do
-            execute('list', '--all', '--json', '--template', retryable: true).gsub(/^INFO/, '')
+            execute_prlctl('list', '--all', '--json', '--template').gsub(/^INFO/, '')
           end
           vms = vms_arr | templates_arr
           vms.each do |item|
@@ -383,13 +411,14 @@ module VagrantPlugins
           results
         end
 
-        # Parse the JSON from *all* VMs and templates. Then return an array of objects (without duplicates)
+        # Parse the JSON from *all* VMs and templates.
+        # Then return an array of objects (without duplicates)
         def read_vms_info
           vms_arr = json([]) do
-            execute('list', '--all','--info', '--json', retryable: true).gsub(/^INFO/, '')
+            execute_prlctl('list', '--all','--info', '--json').gsub(/^INFO/, '')
           end
           templates_arr = json([]) do
-            execute('list', '--all','--info', '--json', '--template', retryable: true).gsub(/^INFO/, '')
+            execute_prlctl('list', '--all','--info', '--json', '--template').gsub(/^INFO/, '')
           end
           vms_arr | templates_arr
         end
@@ -406,7 +435,7 @@ module VagrantPlugins
         end
 
         def register(pvm_file, regen_src_uuid=false)
-          args = ['register', pvm_file]
+          args = ['prlctl', 'register', pvm_file]
           args << '--regenerate-src-uuid' if regen_src_uuid
           execute(*args)
         end
@@ -416,21 +445,26 @@ module VagrantPlugins
         end
 
         def resume
-          execute('resume', @uuid)
+          execute_prlctl('resume', @uuid)
         end
 
         def set_mac_address(mac)
-          execute('set', @uuid, '--device-set', 'net0', '--type', 'shared', '--mac', mac)
+          execute_prlctl('set', @uuid,
+                         '--device-set', 'net0',
+                         '--type', 'shared',
+                         '--mac', mac)
         end
 
         def set_name(name)
-          execute('set', @uuid, '--name', name, :retryable => true)
+          execute_prlctl('set', @uuid, '--name', name)
         end
 
         def share_folders(folders)
           folders.each do |folder|
             # Add the shared folder
-            execute('set', @uuid, '--shf-host-add', folder[:name], '--path', folder[:hostpath])
+            execute_prlctl('set', @uuid,
+                           '--shf-host-add', folder[:name],
+                           '--path', folder[:hostpath])
           end
         end
 
@@ -439,29 +473,25 @@ module VagrantPlugins
         end
 
         def start
-          execute('start', @uuid)
+          execute_prlctl('start', @uuid)
         end
 
         def suspend
-          execute('suspend', @uuid)
+          execute_prlctl('suspend', @uuid)
         end
 
         def unregister(uuid)
-          execute("unregister", uuid)
+          execute_prlctl('unregister', uuid)
         end
 
         def unshare_folders(names)
           names.each do |name|
-            execute("set", @uuid, "--shf-host-del", name)
+            execute_prlctl('set', @uuid, '--shf-host-del', name)
           end
         end
 
-        def verify!
-          execute('--version', retryable: true)
-        end
-
         def vm_exists?(uuid)
-          raw("list", uuid).exit_code == 0
+          raw('prlctl', 'list', uuid).exit_code == 0
         end
       end
     end