vagrant-parallels 1.1.0 → 1.2.0.rc1

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

@@ -2,42 +2,98 @@ module VagrantPlugins
   module Parallels
     module GuestLinuxCap
       class MountParallelsSharedFolder
-
         def self.mount_parallels_shared_folder(machine, name, guestpath, options)
-          # Expand the guest path so we can handle things like "~/vagrant"
           expanded_guest_path = machine.guest.capability(
             :shell_expand_guest_path, guestpath)
 
-          machine.communicate.tap do |comm|
-            # clear prior symlink
-            if comm.test("test -L \"#{expanded_guest_path}\"", :sudo => true)
-              comm.sudo("rm \"#{expanded_guest_path}\"")
-            end
+          mount_commands = []
 
-            # clear prior directory if exists
-            if comm.test("test -d \"#{expanded_guest_path}\"", :sudo => true)
-              comm.sudo("rm -Rf \"#{expanded_guest_path}\"")
-            end
+          if options[:owner].is_a? Integer
+            mount_uid = options[:owner]
+          else
+            mount_uid = "`id -u #{options[:owner]}`"
+          end
+
+          if options[:group].is_a? Integer
+            mount_gid = options[:group]
+            mount_gid_old = options[:group]
+          else
+            mount_gid = "`getent group #{options[:group]} | cut -d: -f3`"
+            mount_gid_old = "`id -g #{options[:group]}`"
+          end
+
+          # First mount command uses getent to get the group
+          mount_options = "-o uid=#{mount_uid},gid=#{mount_gid}"
+          mount_options += ",#{options[:mount_options].join(",")}" if options[:mount_options]
+          mount_commands << "mount -t prl_fs #{mount_options} #{name} #{expanded_guest_path}"
+
+          # Second mount command uses the old style `id -g`
+          mount_options = "-o uid=#{mount_uid},gid=#{mount_gid_old}"
+          mount_options += ",#{options[:mount_options].join(",")}" if options[:mount_options]
+          mount_commands << "mount -t prl_fs #{mount_options} #{name} #{expanded_guest_path}"
+
+          # Clear prior symlink if exists
+          if machine.communicate.test("test -L #{expanded_guest_path}")
+            machine.communicate.sudo("rm #{expanded_guest_path}")
+          end
+
+          # Create the guest path if it doesn't exist
+          machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
 
-            # create intermediate directories if needed
-            intermediate_dir = File.dirname(expanded_guest_path)
-            if !comm.test("test -d \"#{intermediate_dir}\"", :sudo => true)
-              comm.sudo("mkdir -p \"#{intermediate_dir}\"")
+          # Attempt to mount the folder. We retry here a few times because
+          # it can fail early on.
+          attempts = 0
+          while true
+            success = true
+
+            mount_commands.each do |command|
+              no_such_device = false
+              status = machine.communicate.sudo(command, error_check: false) do |type, data|
+                no_such_device = true if type == :stderr && data =~ /No such device/i
+              end
+
+              success = status == 0 && !no_such_device
+              break if success
             end
 
-            # finally make the symlink
-            comm.sudo("ln -s \"/media/psf/#{name}\" \"#{expanded_guest_path}\"")
+            break if success
 
-            # Emit an upstart event if we can
-            if comm.test("test -x /sbin/initctl")
-              comm.sudo(
-                "/sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{expanded_guest_path}")
+            attempts += 1
+            if attempts > 10
+              raise Vagrant::Errors::LinuxMountFailed,
+                command: mount_commands.join("\n")
             end
+
+            sleep 2
+          end
+
+          # Emit an upstart event if we can
+          if machine.communicate.test("test -x /sbin/initctl")
+            machine.communicate.sudo(
+              "/sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{expanded_guest_path}")
           end
         end
 
         def self.unmount_parallels_shared_folder(machine, guestpath, options)
-          machine.communicate.sudo("rm #{guestpath}", error_check: false)
+          result = machine.communicate.sudo(
+            "umount #{guestpath}", error_check: false)
+          if result == 0
+            machine.communicate.sudo("rmdir #{guestpath}", error_check: false)
+          end
+        end
+
+        def self.prepare_psf_services(machine)
+          # Parallels Tools for Linux includes native auto-mount script,
+          # which causes loosing some of Vagrant-relative shared folders.
+          # So, we should to disable this behavior. [GH-102]
+
+          auto_mount_script = '/usr/bin/prlfsmountd'
+          if machine.communicate.test("test -f #{auto_mount_script}")
+            machine.communicate.sudo(
+              "echo -e '#!/bin/sh\n'" +
+                '# Shared folders auto-mount is disabled by Vagrant ' +
+                "> #{auto_mount_script}")
+          end
         end
       end
     end

data/lib/vagrant-parallels/model/forwarded_port.rb

@@ -0,0 +1,52 @@
+module VagrantPlugins
+  module Parallels
+    module Model
+      # Represents a single forwarded port for Parallels Desktop. This has
+      # various helpers and defaults for a forwarded port.
+      class ForwardedPort
+        # If true, the forwarded port should be auto-corrected.
+        #
+        # @return [Boolean]
+        attr_reader :auto_correct
+
+        # The unique ID for the forwarded port.
+        #
+        # @return [String]
+        attr_reader :id
+
+        # The protocol to forward.
+        #
+        # @return [String]
+        attr_reader :protocol
+
+        # The port on the guest to be exposed on the host.
+        #
+        # @return [Integer]
+        attr_reader :guest_port
+
+        # The port on the host used to access the port on the guest.
+        #
+        # @return [Integer]
+        attr_reader :host_port
+
+        def initialize(id, host_port, guest_port, options)
+          @id         = id
+          @guest_port = guest_port
+          @host_port  = host_port
+
+          options ||= {}
+          @auto_correct = false
+          @auto_correct = options[:auto_correct] if options.has_key?(:auto_correct)
+          @protocol = options[:protocol] || "tcp"
+        end
+
+        # This corrects the host port and changes it to the given new port.
+        #
+        # @param [Integer] new_port The new port
+        def correct_host_port(new_port)
+          @host_port = new_port
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/plugin.rb

@@ -50,6 +50,11 @@ module VagrantPlugins
         GuestLinuxCap::MountParallelsSharedFolder
       end
 
+      guest_capability(:linux, :prepare_psf_services) do
+        require_relative "guest_cap/linux/mount_parallels_shared_folder"
+        GuestLinuxCap::MountParallelsSharedFolder
+      end
+
       guest_capability(:linux, :install_parallels_tools) do
         require_relative "guest_cap/linux/install_parallels_tools"
         GuestLinuxCap::InstallParallelsTools
@@ -85,6 +90,15 @@ module VagrantPlugins
       autoload :Meta, File.expand_path("../driver/meta", __FILE__)
       autoload :PD_8, File.expand_path("../driver/pd_8", __FILE__)
       autoload :PD_9, File.expand_path("../driver/pd_9", __FILE__)
+      autoload :PD_10, File.expand_path("../driver/pd_10", __FILE__)
+    end
+
+    module Model
+      autoload :ForwardedPort, File.expand_path("../model/forwarded_port", __FILE__)
+    end
+
+    module Util
+      autoload :CompileForwardedPorts, File.expand_path("../util/compile_forwarded_ports", __FILE__)
     end
   end
 end

data/lib/vagrant-parallels/provider.rb

@@ -64,7 +64,7 @@ module VagrantPlugins
         # If the VM is not running that we can't possibly SSH into it
         return nil if state.id != :running
 
-        detected_ip = @driver.read_guest_ip
+        detected_ip = @driver.ssh_ip
 
         # If ip couldn't be detected then we cannot possibly SSH into it,
         # and should return nil too.
@@ -72,8 +72,8 @@ module VagrantPlugins
 
         # Return ip from running machine, use ip from config if available
         return {
-          :host => detected_ip,
-          :port => @driver.ssh_port(@machine.config.ssh.guest_port)
+          host: detected_ip,
+          port: @driver.ssh_port(@machine.config.ssh.guest_port)
         }
       end
 
@@ -101,6 +101,15 @@ module VagrantPlugins
         Vagrant::MachineState.new(state_id, short, long)
       end
 
+      # Determines if the installed Parallels Desktop version is
+      # satisfied by the given constraint or group of constraints.
+      #
+      # @return [Boolean]
+      def pd_version_satisfies?(*constraints)
+        pd_version = Gem::Version.new(@driver.version)
+        Gem::Requirement.new(*constraints).satisfied_by?(pd_version)
+      end
+
       # Returns a human-friendly string version of this provider which
       # includes the machine's ID that this provider represents, if it
       # has one.

data/lib/vagrant-parallels/synced_folder.rb

@@ -18,7 +18,6 @@ module VagrantPlugins
             hostpath = Vagrant::Util::Platform.cygwin_windows_path(hostpath)
           end
 
-
           defs << {
               name: os_friendly_id(id),
               hostpath: hostpath.to_s,
@@ -42,6 +41,12 @@ module VagrantPlugins
 
         shf_config = driver(machine).read_shared_folders
 
+        # Parallels Shared Folder services can override Vagrant synced folder
+        # configuration. These services should be pre-configured.
+        if machine.guest.capability?(:prepare_psf_services)
+          machine.guest.capability(:prepare_psf_services)
+        end
+
         # Go through each folder and mount
         machine.ui.output(I18n.t("vagrant.actions.vm.share_folders.mounting"))
         folders.each do |_ , data|

data/lib/vagrant-parallels/util/compile_forwarded_ports.rb

@@ -0,0 +1,35 @@
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module Parallels
+    module Util
+      module CompileForwardedPorts
+        include Vagrant::Util::ScopedHashOverride
+
+        # This method compiles the forwarded ports into {ForwardedPort}
+        # models.
+        def compile_forwarded_ports(config)
+          mappings = {}
+
+          config.vm.networks.each do |type, options|
+            if type == :forwarded_port
+              guest_port = options[:guest]
+              host_port  = options[:host]
+              protocol   = options[:protocol] || "tcp"
+              options    = scoped_hash_override(options, :parallels)
+              id         = options[:id]
+
+              # If the forwarded port was marked as disabled, ignore.
+              next if options[:disabled]
+
+              mappings[host_port.to_s + protocol.to_s] =
+                Model::ForwardedPort.new(id, host_port, guest_port, options)
+            end
+          end
+
+          mappings.values
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Parallels
-    VERSION = "1.1.0"
+    VERSION = "1.2.0.rc1"
   end
 end

data/locales/en.yml

@@ -126,3 +126,6 @@ en:
             reload your VM.
         export:
           compacting: Compacting exported HDDs...
+        forward_ports:
+          forwarding_entry: |-
+            %{guest_port} => %{host_port}

data/test/unit/driver/pd_10_test.rb

@@ -0,0 +1,228 @@
+require_relative "../base"
+
+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).
+        with("prlctl", "set", uuid, "--longer-battery-life", "on",
+             an_instance_of(Hash)).
+        and_return(subprocess_result(exit_code: 0))
+
+      subject.set_power_consumption_mode(true)
+    end
+
+    it "turns 'longer-battery-life' off" do
+      subprocess.should_receive(:execute).
+        with("prlctl", "set", uuid, "--longer-battery-life", "off",
+             an_instance_of(Hash)).
+        and_return(subprocess_result(exit_code: 0))
+
+      subject.set_power_consumption_mode(false)
+    end
+  end
+
+  describe "ssh_ip" do
+    it "returns 127.0.0.1" do
+      subject.ssh_ip.should == "127.0.0.1"
+    end
+  end
+
+end

data/test/unit/driver/pd_8_test.rb

@@ -15,13 +15,13 @@ describe VagrantPlugins::Parallels::Driver::PD_8 do
   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'
+    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
 
@@ -198,4 +198,24 @@ INFO[
     end
 
   end
+
+  describe "ssh_ip" do
+    let(:content) {'10.200.0.99="1394547632,1800,001c420000ff,01001c420000ff"'}
+
+    it "returns an IP address assigned to the specified MAC" do
+      driver.should_receive(:read_mac_address).and_return("001C420000FF")
+      File.should_receive(:open).with(an_instance_of(String)).
+        and_return(StringIO.new(content))
+
+      subject.ssh_ip.should == "10.200.0.99"
+    end
+
+    it "rises DhcpLeasesNotAccessible exception when file is not accessible" do
+      File.stub(:open).and_call_original
+      File.should_receive(:open).with(an_instance_of(String)).
+        and_raise(Errno::EACCES)
+      expect { subject.ssh_ip }.
+        to raise_error(VagrantPlugins::Parallels::Errors::DhcpLeasesNotAccessible)
+    end
+  end
 end

data/test/unit/driver/pd_9_test.rb

@@ -15,13 +15,13 @@ describe VagrantPlugins::Parallels::Driver::PD_9 do
   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'
+    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
 
@@ -218,4 +218,25 @@ describe VagrantPlugins::Parallels::Driver::PD_9 do
       subject.set_power_consumption_mode(false)
     end
   end
+
+  describe "ssh_ip" do
+    let(:content) {'10.200.0.99="1394547632,1800,001c420000ff,01001c420000ff"'}
+
+    it "returns an IP address assigned to the specified MAC" do
+      driver.should_receive(:read_mac_address).and_return("001C420000FF")
+      File.should_receive(:open).with(an_instance_of(String)).
+        and_return(StringIO.new(content))
+
+      subject.ssh_ip.should == "10.200.0.99"
+    end
+
+    it "rises DhcpLeasesNotAccessible exception when file is not accessible" do
+      File.stub(:open).and_call_original
+      File.should_receive(:open).with(an_instance_of(String)).
+        and_raise(Errno::EACCES)
+      expect { subject.ssh_ip }.
+        to raise_error(VagrantPlugins::Parallels::Errors::DhcpLeasesNotAccessible)
+    end
+  end
+
 end

data/test/unit/support/shared/parallels_context.rb

@@ -1,8 +1,9 @@
 shared_context "parallels" do
-  let(:parallels_context) { true                                }
-  let(:uuid)              { "1234-here-is-uuid-5678"            }
-  let(:parallels_version) { "9"                                 }
-  let(:subprocess)        { double("Vagrant::Util::Subprocess") }
+  let(:parallels_context) { true                                     }
+  let(:uuid)              { "1234-here-is-uuid-5678"                 }
+  let(:parallels_version) { "9"                                      }
+  let(:subprocess)        { double("Vagrant::Util::Subprocess")      }
+  let(:driver)            { subject.instance_variable_get("@driver") }
 
   # this is a helper that returns a duck type suitable from a system command
   # execution; allows setting exit_code, stdout, and stderr in stubs.