vagrant-parallels 1.2.2 → 1.3.0

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

@@ -59,7 +59,7 @@ module VagrantPlugins
           iface_name = net_info['Bound To']
 
           # Return the details
-          return {
+          {
             name:    iface_name,
             ip:      options[:adapter_ip],
             netmask: options[:netmask],
@@ -170,11 +170,10 @@ module VagrantPlugins
           execute(*args)
         end
 
-        def import(template_uuid)
-          template_name = read_vms.key(template_uuid)
-          vm_name = "#{template_name}_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
+        def import(tpl_name)
+          vm_name = "#{tpl_name}_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
 
-          execute_prlctl('clone', template_uuid, '--name', vm_name) do |type, data|
+          execute_prlctl('clone', tpl_name, '--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.
@@ -277,7 +276,8 @@ module VagrantPlugins
             info = {}
             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[:name]     = net_info['Network ID']
+            info[:bound_to] = net_info['Bound To']
             info[:ip]       = net_info['Parallels adapter']['IP address']
             info[:netmask]  = net_info['Parallels adapter']['Subnet mask']
             # Such interfaces are always in 'Up'
@@ -300,19 +300,13 @@ module VagrantPlugins
         end
 
         def read_mac_address
-          read_settings.fetch('Hardware', {}).fetch('net0', {}).fetch('mac', nil)
+          # Get MAC of Shared network interface (net0)
+          read_vm_option('mac').strip.split(' ').first.gsub(':', '')
         end
 
         def read_mac_addresses
-          macs = {}
-          read_settings.fetch('Hardware', {}).each do |device, params|
-            if device =~ /^net(\d+)$/
-              adapter = $1
-              mac = params.fetch('mac')
-              macs[adapter] = mac
-            end
-          end
-          macs
+          macs = read_vm_option('mac').strip.split(' ')
+          Hash[macs.map.with_index{ |mac, ind| [ind.to_s, mac.gsub(':', '')]  }]
         end
 
         def read_network_interfaces
@@ -345,7 +339,7 @@ module VagrantPlugins
         end
 
         def read_settings
-          vm = json { execute_prlctl('list', @uuid, '--info', '--json').gsub(/^INFO/, '') }
+          vm = json { execute_prlctl('list', @uuid, '--info', '--no-header', '--json')  }
           vm.last
         end
 
@@ -390,40 +384,33 @@ module VagrantPlugins
         end
 
         def read_state
-          vm = json { execute_prlctl('list', @uuid, '--json').gsub(/^INFO/, '') }
-          return nil if !vm.last
-          vm.last.fetch('status').to_sym
+          read_vm_option('status').strip.to_sym
         end
 
         def read_virtual_networks
           json { execute_prlsrvctl('net', 'list', '--json') }
         end
 
+        def read_vm_option(option, uuid=@uuid)
+          execute_prlctl('list', uuid,'--no-header', '-o', option)
+        end
+
         def read_vms
-          results = {}
-          vms_arr = json([]) do
-            execute_prlctl('list', '--all', '--json').gsub(/^INFO/, '')
-          end
-          templates_arr = json([]) do
-            execute_prlctl('list', '--all', '--json', '--template').gsub(/^INFO/, '')
-          end
-          vms = vms_arr | templates_arr
-          vms.each do |item|
-            results[item.fetch('name')] = item.fetch('uuid')
-          end
+          args = %w(list --all --no-header --json -o name,uuid)
+          vms_arr = json([]) { execute_prlctl(*args) }
+          templates_arr = json([]) { execute_prlctl(*args, '--template') }
 
-          results
+          vms = vms_arr | templates_arr
+          Hash[vms.map { |i| [i.fetch('name'), i.fetch('uuid')] }]
         end
 
         # 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_prlctl('list', '--all','--info', '--json').gsub(/^INFO/, '')
-          end
-          templates_arr = json([]) do
-            execute_prlctl('list', '--all','--info', '--json', '--template').gsub(/^INFO/, '')
-          end
+          args = %w(list --all --info --no-header --json)
+          vms_arr = json([]) { execute_prlctl(*args) }
+          templates_arr = json([]) { execute_prlctl(*args, '--template') }
+
           vms_arr | templates_arr
         end
 
@@ -441,11 +428,31 @@ module VagrantPlugins
         def register(pvm_file, regen_src_uuid=false)
           args = ['prlctl', 'register', pvm_file]
           args << '--regenerate-src-uuid' if regen_src_uuid
+
+          3.times do
+            result = raw(*args)
+            # Exit if everything is OK
+            return if result.exit_code == 0
+
+            # It may occur in the race condition with other Vagrant processes.
+            # It is OK, just exit.
+            return if result.stderr.include?('is already registered.')
+
+            # Sleep a bit though to give Parallels Desktop time to fix itself
+            sleep 2
+          end
+
+          # If we reach this point, it means that we consistently got the
+          # failure, do a standard execute now. This will raise an
+          # exception if it fails again.
           execute(*args)
         end
 
         def registered?(uuid)
-          read_vms.has_value?(uuid)
+          args = %w(list --all --info --no-header -o uuid)
+
+          execute_prlctl(*args).include?(uuid) ||
+            execute_prlctl(*args, '--template').include?(uuid)
         end
 
         def resume
@@ -489,7 +496,25 @@ module VagrantPlugins
         end
 
         def unregister(uuid)
-          execute_prlctl('unregister', uuid)
+          args = ['prlctl', 'unregister', uuid]
+          3.times do
+            result = raw(*args)
+            # Exit if everything is OK
+            return if result.exit_code == 0
+
+            # It may occur in the race condition with other Vagrant processes.
+            # Both are OK, just exit.
+            return if result.stderr.include?('is not registered')
+            return if result.stderr.include?('is being cloned')
+
+            # Sleep a bit though to give Parallels Desktop time to fix itself
+            sleep 2
+          end
+
+          # If we reach this point, it means that we consistently got the
+          # failure, do a standard execute now. This will raise an
+          # exception if it fails again.
+          execute(*args)
         end
 
         def unshare_folders(names)
@@ -499,7 +524,23 @@ module VagrantPlugins
         end
 
         def vm_exists?(uuid)
-          raw('prlctl', 'list', uuid).exit_code == 0
+          5.times do |i|
+            result = raw('prlctl', 'list', uuid)
+            return true if result.exit_code == 0
+
+            # Sometimes this happens. In this case, retry. If
+            # we don't see this text, the VM really probably doesn't exist.
+            return false if !result.stderr.include?('Login failed:')
+
+            # Sleep a bit though to give Parallels Desktop time to fix itself
+            sleep 2
+          end
+
+          # If we reach this point, it means that we consistently got the
+          # failure, do a standard prlctl now. This will raise an
+          # exception if it fails again.
+          execute_prlctl('list', uuid)
+          true
         end
       end
     end

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

@@ -15,44 +15,6 @@ module VagrantPlugins
           @logger = Log4r::Logger.new('vagrant_parallels::driver::pd_9')
         end
 
-        def read_settings
-          vm = json { execute_prlctl('list', @uuid, '--info', '--json') }
-          vm.last
-        end
-
-        def read_state
-          vm = json { execute_prlctl('list', @uuid, '--json') }
-          return nil if !vm.last
-          vm.last.fetch('status').to_sym
-        end
-
-        def read_vms
-          results = {}
-          vms_arr = json([]) do
-            execute_prlctl('list', '--all', '--json')
-          end
-          templates_arr = json([]) do
-            execute_prlctl('list', '--all', '--json', '--template')
-          end
-          vms = vms_arr | templates_arr
-          vms.each do |item|
-            results[item.fetch('name')] = item.fetch('uuid')
-          end
-
-          results
-        end
-
-        # 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_prlctl('list', '--all','--info', '--json')
-          end
-          templates_arr = json([]) do
-            execute_prlctl('list', '--all','--info', '--json', '--template')
-          end
-          vms_arr | templates_arr
-        end
-
         def set_power_consumption_mode(optimized)
           state = optimized ? 'on' : 'off'
           execute_prlctl('set', @uuid, '--longer-battery-life', state)

data/lib/vagrant-parallels/errors.rb

@@ -15,6 +15,10 @@ module VagrantPlugins
         error_key(:linux_mount_failed)
       end
 
+      class LinuxPrlFsInvalidOptions < VagrantParallelsError
+        error_key(:linux_prl_fs_invalid_options)
+      end
+
       class MacOSXRequired < VagrantParallelsError
         error_key(:mac_os_x_required)
       end
@@ -43,6 +47,10 @@ module VagrantPlugins
         error_key(:parallels_tools_iso_not_found)
       end
 
+      class ParallelsTplNameNotFound < VagrantParallelsError
+        error_key(:parallels_tpl_name_not_found)
+      end
+
       class VMImportFailure < VagrantParallelsError
         error_key(:vm_import_failure)
       end

data/lib/vagrant-parallels/guest_cap/linux/mount_parallels_shared_folder.rb

@@ -3,6 +3,18 @@ module VagrantPlugins
     module GuestLinuxCap
       class MountParallelsSharedFolder
         def self.mount_parallels_shared_folder(machine, name, guestpath, options)
+          # Sanity check for mount options: we are not supporting
+          # VirtualBox-specific 'fmode' and 'dmode' options
+          if options[:mount_options]
+            invalid_opts = options[:mount_options].select do |opt|
+              opt =~ /^(d|f)mode/
+            end
+
+            if !invalid_opts.empty?
+              raise Errors::LinuxPrlFsInvalidOptions, options: invalid_opts
+            end
+          end
+
           expanded_guest_path = machine.guest.capability(
             :shell_expand_guest_path, guestpath)
 

data/lib/vagrant-parallels/plugin.rb

@@ -20,7 +20,7 @@ module VagrantPlugins
       Parallels-based virtual machines.
       EOF
 
-      provider(:parallels) do
+      provider(:parallels, parallel: true, priority: 7) do
         require File.expand_path("../provider", __FILE__)
         Provider
       end

data/lib/vagrant-parallels/provider.rb

@@ -7,6 +7,10 @@ module VagrantPlugins
       attr_reader :driver
 
       def self.usable?(raise_error=false)
+        if !Vagrant::Util::Platform.darwin?
+          raise Errors::MacOSXRequired
+        end
+
         # Instantiate the driver, which will determine the Parallels Desktop
         # version and all that, which checks for Parallels Desktop being present
         Driver::Meta.new
@@ -23,10 +27,6 @@ module VagrantPlugins
         @logger = Log4r::Logger.new("vagrant::provider::parallels")
         @machine = machine
 
-        if !Vagrant::Util::Platform.darwin?
-          raise Errors::MacOSXRequired
-        end
-
         # This method will load in our driver, so we call it now to
         # initialize it.
         machine_id_changed

data/lib/vagrant-parallels/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Parallels
-    VERSION = "1.2.2"
+    VERSION = "1.3.0"
   end
 end

data/locales/en.yml

@@ -31,7 +31,11 @@ en:
         The command attempted was:
 
         %{command}
+      linux_prl_fs_invalid_options: |-
+        Failed to mount folders in Linux guest. You've specified mount options
+        which are not supported by "prl_fs" file system.
 
+        Invalid mount options: %{options}
       mac_os_x_required: |-
         Parallels provider works only on OS X (Mac OS X) systems.
       parallels_install_incomplete: |-
@@ -61,6 +65,11 @@ en:
         reinstall Parallels Desktop.
 
         Expected ISO path: "%{iso_path}"
+      parallels_tpl_name_not_found: |-
+        The VM import failed! Template name not found. Please verify that
+        the box you're using is not corrupted and try again.
+
+        Template config path: "%{config_path}"
       vm_import_failure: |-
         The VM import failed! Please verify that the box you're using is not
         corrupted and try again.

data/test/unit/driver/pd_10_test.rb

@@ -4,201 +4,10 @@ describe VagrantPlugins::Parallels::Driver::PD_10 do
   include_context "parallels"
   let(:parallels_version) { "10" }
 
-  let(:vm_name) {'VM_Name'}
-
-  let(:tpl_uuid) {'1234-some-template-uuid-5678'}
-  let(:tpl_name) {'Some_Template_Name'}
-
-  let(:tools_state) {'installed'}
-  let(:tools_version) {'10.0.23062.123456'}
-
-  let(:hostonly_iface) {'vnic10'}
-
-  let(:vnic_options) do {
-    name:       'vagrant_vnic6',
-    adapter_ip: '11.11.11.11',
-    netmask:    '255.255.252.0',
-    dhcp:       {
-      ip:    '11.11.11.11',
-      lower: '11.11.8.1',
-      upper: '11.11.11.254'
-    }
-  } end
-
   subject { VagrantPlugins::Parallels::Driver::Meta.new(uuid) }
 
   it_behaves_like "parallels desktop driver"
 
-  before do
-    # Returns short info about all registered VMs
-    # `prlctl list --all --json`
-    subprocess.stub(:execute).
-      with("prlctl", "list", "--all", "--json", kind_of(Hash)) do
-        out = <<-eos
-[
-  {
-    "uuid": "#{uuid}",
-    "status": "stopped",
-    "name": "#{vm_name}"
-  }
-]
-        eos
-        subprocess_result(stdout: out)
-    end
-
-    # Returns short info about all registered templates
-    # `prlctl list --all --json --template`
-    subprocess.stub(:execute).
-      with("prlctl", "list", "--all", "--json", "--template", kind_of(Hash)) do
-        out = <<-eos
-[
-  {
-    "uuid": "1234-some-template-uuid-5678",
-    "name": "Some_Template_Name"
-  }
-]
-        eos
-        subprocess_result(stdout: out)
-    end
-
-
-    # Returns detailed info about specified VM or all registered VMs
-    # `prlctl list <vm_uuid> --info --json`
-    # `prlctl list --all --info --json`
-    subprocess.stub(:execute).
-      with("prlctl", "list", kind_of(String), "--info", "--json",
-           kind_of(Hash)) do
-        out = <<-eos
-[
-  {
-    "ID": "#{uuid}",
-    "Name": "#{vm_name}",
-    "State": "stopped",
-    "Home": "/path/to/#{vm_name}.pvm/",
-    "GuestTools": {
-      "state": "#{tools_state}",
-      "version": "#{tools_version}"
-    },
-    "Hardware": {
-      "cpu": {
-        "cpus": 1
-      },
-      "memory": {
-        "size": "512Mb"
-      },
-      "hdd0": {
-        "enabled": true,
-        "image": "/path/to/disk1.hdd"
-      },
-      "net0": {
-        "enabled": true,
-        "type": "shared",
-        "mac": "001C42B4B074",
-        "card": "e1000",
-        "dhcp": "yes"
-      },
-      "net1": {
-        "enabled": true,
-        "type": "bridged",
-        "iface": "vnic2",
-        "mac": "001C42EC0068",
-        "card": "e1000",
-        "ips": "33.33.33.5/255.255.255.0 "
-      }
-    },
-    "Host Shared Folders": {
-      "enabled": true,
-      "shared_folder_1": {
-        "enabled": true,
-        "path": "/path/to/shared/folder/1"
-      },
-      "shared_folder_2": {
-        "enabled": true,
-        "path": "/path/to/shared/folder/2"
-      }
-    }
-  }
-]
-        eos
-        subprocess_result(stdout: out)
-    end
-
-    # Returns detailed info about specified template or all registered templates
-    # `prlctl list <tpl_uuid> --info --json --template`
-    # `prlctl list --all --info --json --template`
-    subprocess.stub(:execute).
-      with("prlctl", "list", kind_of(String), "--info", "--json", "--template",
-           kind_of(Hash)) do
-      out = <<-eos
-[
-  {
-    "ID": "#{tpl_uuid}",
-    "Name": "#{tpl_name}",
-    "State": "stopped",
-    "Home": "/path/to/#{tpl_name}.pvm/",
-    "GuestTools": {
-      "state": "#{tools_state}",
-      "version": "#{tools_version}"
-    },
-    "Hardware": {
-      "cpu": {
-        "cpus": 1
-      },
-      "memory": {
-        "size": "512Mb"
-      },
-      "hdd0": {
-        "enabled": true,
-        "image": "/path/to/harddisk.hdd"
-      },
-      "net0": {
-        "enabled": true,
-        "type": "shared",
-        "mac": "001C42F6E500",
-        "card": "e1000",
-        "dhcp": "yes"
-      },
-      "net1": {
-        "enabled": true,
-        "type": "bridged",
-        "iface": "vnic4",
-        "mac": "001C42AB0071",
-        "card": "e1000",
-        "ips": "33.33.33.10/255.255.255.0 "
-      }
-    }
-  }
-]
-      eos
-      subprocess_result(stdout: out)
-    end
-
-    # Returns detailed info about virtual network interface
-    # `prlsrvctl net info <net_name>, '--json', retryable: true)
-    subprocess.stub(:execute).
-      with("prlsrvctl", "net", "info", kind_of(String), "--json",
-           kind_of(Hash)) do
-      out = <<-eos
-{
-  "Network ID": "#{vnic_options[:name]}",
-  "Type": "host-only",
-  "Bound To": "#{hostonly_iface}",
-  "Parallels adapter": {
-    "IP address": "#{vnic_options[:adapter_ip]}",
-    "Subnet mask": "#{vnic_options[:netmask]}"
-  },
-  "DHCPv4 server": {
-    "Server address": "#{vnic_options[:dhcp][:ip] || "10.37.132.1"}",
-    "IP scope start address": "#{vnic_options[:dhcp][:lower] || "10.37.132.1"}",
-    "IP scope end address": "#{vnic_options[:dhcp][:upper] || "10.37.132.254"}"
-  }
-}
-      eos
-      subprocess_result(stdout: out)
-    end
-
-  end
-
   describe "set_power_consumption_mode" do
     it "turns 'longer-battery-life' on" do
       subprocess.should_receive(:execute).