vagrant-parallels 1.1.0 → 1.2.0.rc1

data/lib/vagrant-parallels/action.rb

@@ -12,19 +12,20 @@ module VagrantPlugins
       def self.action_boot
         Vagrant::Action::Builder.new.tap do |b|
           b.use SetName
+          b.use ClearForwardedPorts
           b.use Provision
+          b.use EnvSet, port_collision_repair: true
+          b.use PrepareForwardedPortCollisionParams
+          b.use HandleForwardedPortCollisions
           b.use PrepareNFSValidIds
           b.use SyncedFolderCleanup
           b.use SyncedFolders
           b.use PrepareNFSSettings
           b.use Network
           b.use ClearNetworkInterfaces
+          b.use ForwardPorts
           b.use SetHostname
-          b.use Call, IsDriverVersion, '>= 9' do |env1, b1|
-            if env1[:result]
-              b1.use SetPowerConsumption
-            end
-          end
+          b.use SaneDefaults
           b.use Customize, "pre-boot"
           b.use Boot
           b.use Customize, "post-boot"
@@ -85,6 +86,8 @@ module VagrantPlugins
                 b2.use ForcedHalt
               end
             end
+
+            b1.use ClearForwardedPorts
           end
         end
       end
@@ -101,6 +104,7 @@ module VagrantPlugins
 
             b1.use SetupPackageFiles
             b1.use action_halt
+            b1.use ClearForwardedPorts
             b1.use PrepareNFSValidIds
             b1.use SyncedFolderCleanup
             b1.use Package
@@ -161,6 +165,9 @@ module VagrantPlugins
               next
             end
 
+            b1.use EnvSet, port_collision_repair: false
+            b1.use PrepareForwardedPortCollisionParams
+            b1.use HandleForwardedPortCollisions
             b1.use Resume
             b1.use WaitForCommunicator, [:resuming, :running]
           end
@@ -282,22 +289,24 @@ module VagrantPlugins
       autoload :Boot, File.expand_path("../action/boot", __FILE__)
       autoload :HandleGuestTools, File.expand_path("../action/handle_guest_tools", __FILE__)
       autoload :ClearNetworkInterfaces, File.expand_path("../action/clear_network_interfaces", __FILE__)
+      autoload :ClearForwardedPorts, File.expand_path("../action/clear_forwarded_ports", __FILE__)
       autoload :Customize, File.expand_path("../action/customize", __FILE__)
       autoload :Destroy, File.expand_path("../action/destroy", __FILE__)
       autoload :DestroyUnusedNetworkInterfaces, File.expand_path("../action/destroy_unused_network_interfaces", __FILE__)
       autoload :Export, File.expand_path("../action/export", __FILE__)
       autoload :ForcedHalt, File.expand_path("../action/forced_halt", __FILE__)
+      autoload :ForwardPorts, File.expand_path("../action/forward_ports", __FILE__)
       autoload :Import, File.expand_path("../action/import", __FILE__)
-      autoload :IsDriverVersion, File.expand_path("../action/is_driver_version", __FILE__)
       autoload :Network, File.expand_path("../action/network", __FILE__)
       autoload :Package, File.expand_path("../action/package", __FILE__)
       autoload :PackageConfigFiles, File.expand_path("../action/package_config_files", __FILE__)
+      autoload :PrepareForwardedPortCollisionParams, File.expand_path("../action/prepare_forwarded_port_collision_params", __FILE__)
       autoload :PrepareNFSSettings, File.expand_path("../action/prepare_nfs_settings", __FILE__)
       autoload :PrepareNFSValidIds, File.expand_path("../action/prepare_nfs_valid_ids", __FILE__)
       autoload :Resume, File.expand_path("../action/resume", __FILE__)
+      autoload :SaneDefaults, File.expand_path("../action/sane_defaults",__FILE__)
       autoload :SetupPackageFiles, File.expand_path("../action/setup_package_files", __FILE__)
       autoload :SetName, File.expand_path("../action/set_name", __FILE__)
-      autoload :SetPowerConsumption, File.expand_path("../action/set_power_consumption", __FILE__)
       autoload :Suspend, File.expand_path("../action/suspend", __FILE__)
     end
   end

data/lib/vagrant-parallels/cap/forwarded_ports.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module Parallels
+    module Cap
+      module ForwardedPorts
+        # Reads the forwarded ports that currently exist on the machine
+        # itself.
+        #
+        # This also may not match up with configured forwarded ports, because
+        # Vagrant auto port collision fixing may have taken place.
+        #
+        # @return [Hash<Integer, Integer>] Host => Guest port mappings.
+        def self.forwarded_ports(machine)
+          {}.tap do |result|
+            machine.provider.driver.read_forwarded_ports.each do |_, _, h, g|
+              result[h] = g
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module VagrantPlugins
         include Vagrant::Util::NetworkIP
 
         def initialize
-          @logger = Log4r::Logger.new("vagrant::provider::parallels::base")
+          @logger = Log4r::Logger.new('vagrant_parallels::driver::base')
 
           # This flag is used to keep track of interrupted state (SIGINT)
           @interrupted = false
@@ -58,6 +58,12 @@ module VagrantPlugins
         def delete_unused_host_only_networks
         end
 
+        # Disables requiring password on such operations as creating, adding,
+        # removing or cloning the virtual machine.
+        #
+        def disable_password_restrictions
+        end
+
         # Enables network adapters on the VM.
         #
         # The format of each adapter specification should be like so:
@@ -75,20 +81,6 @@ module VagrantPlugins
         def enable_adapters(adapters)
         end
 
-        # Execute a raw command straight through to 'prlctl' utility
-        #
-        # Accepts a :prlsrvctl as a first element of command if the command
-        # should be executed through to 'prlsrvctl' utility
-        #
-        # Accepts a :retryable => true option if the command should be retried
-        # upon failure.
-        #
-        # Raises a prlctl error if it fails.
-        #
-        # @param [Array] command Command to execute.
-        def execute_prlctl(command)
-        end
-
         # Exports the virtual machine to the given path.
         #
         # @param [String] path Path to the OVF file.
@@ -296,7 +288,7 @@ module VagrantPlugins
           end
 
           # Append in the options for subprocess
-          command << { :notify => [:stdout, :stderr] }
+          command << {notify: [:stdout, :stderr]}
 
           Vagrant::Util::Busy.busy(int_callback) do
             Vagrant::Util::Subprocess.execute(*command, &block)

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

@@ -25,7 +25,7 @@ module VagrantPlugins
           # Setup the base
           super()
 
-          @logger = Log4r::Logger.new("vagrant::provider::parallels::meta")
+          @logger = Log4r::Logger.new('vagrant_parallels::driver::meta')
           @uuid = uuid
 
           # Read and assign the version of Parallels Desktop we know which
@@ -44,7 +44,7 @@ module VagrantPlugins
           driver_map   = {
             "8" => PD_8,
             "9" => PD_9,
-            "10" => PD_9
+            "10" => PD_10
           }
 
           driver_klass = nil
@@ -58,10 +58,6 @@ module VagrantPlugins
           if !driver_klass
             supported_versions = driver_map.keys.sort
 
-            # TODO: Remove this after PD 10 release
-            # Don't show unreleased version in the error message
-            supported_versions.delete("10")
-
             raise VagrantPlugins::Parallels::Errors::ParallelsInvalidVersion,
                   supported_versions: supported_versions.join(", ")
           end
@@ -77,21 +73,24 @@ module VagrantPlugins
         end
 
         def_delegators :@driver,
+                       :clear_forwarded_ports,
                        :clear_shared_folders,
                        :compact,
                        :create_host_only_network,
                        :delete,
                        :delete_disabled_adapters,
                        :delete_unused_host_only_networks,
+                       :disable_password_restrictions,
                        :enable_adapters,
                        :execute_prlctl,
                        :export,
+                       :forward_ports,
                        :halt,
                        :import,
                        :read_bridged_interfaces,
+                       :read_forwarded_ports,
                        :read_guest_tools_state,
                        :read_guest_tools_iso_path,
-                       :read_guest_ip,
                        :read_host_only_interfaces,
                        :read_mac_address,
                        :read_mac_addresses,
@@ -112,6 +111,7 @@ module VagrantPlugins
                        :set_mac_address,
                        :set_name,
                        :share_folders,
+                       :ssh_ip,
                        :ssh_port,
                        :start,
                        :suspend,

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

@@ -0,0 +1,279 @@
+require 'log4r'
+
+require 'vagrant/util/platform'
+
+require File.expand_path('../pd_9', __FILE__)
+
+module VagrantPlugins
+  module Parallels
+    module Driver
+      # Driver for Parallels Desktop 10.
+      class PD_10 < PD_9
+        def initialize(uuid)
+          super(uuid)
+
+          @logger = Log4r::Logger.new('vagrant_parallels::driver::pd_10')
+        end
+
+        def clear_forwarded_ports
+          args = []
+          read_forwarded_ports.each do |r|
+            args.concat(["--nat-#{r[:protocol]}-del", r[:rule_name]])
+          end
+
+          if !args.empty?
+            execute_prlsrvctl('net', 'set', read_shared_network_id, *args)
+          end
+        end
+
+        def create_host_only_network(options)
+          # Create the interface
+          execute_prlsrvctl('net', 'add', options[:network_id], '--type', 'host-only')
+
+          # Configure it
+          args = ["--ip", "#{options[:adapter_ip]}/#{options[:netmask]}"]
+          if options[:dhcp]
+            args.concat(["--dhcp-ip", options[:dhcp][:ip],
+                         "--ip-scope-start", options[:dhcp][:lower],
+                         "--ip-scope-end", options[:dhcp][:upper]])
+          end
+
+          execute_prlsrvctl('net', 'set', options[:network_id], *args)
+
+          # Return the details
+          {
+            name:    options[:network_id],
+            ip:      options[:adapter_ip],
+            netmask: options[:netmask],
+            dhcp:    options[:dhcp]
+          }
+        end
+
+        def delete_unused_host_only_networks
+          networks = read_virtual_networks
+          # 'Shared'(vnic0) and 'Host-Only'(vnic1) are default in Parallels Desktop
+          # They should not be deleted anyway.
+          networks.keep_if do |net|
+            net['Type'] == "host-only" &&
+              net['Bound To'].match(/^(?>vnic|Parallels Host-Only #)(\d+)$/)[1].to_i >= 2
+          end
+
+          read_vms_info.each do |vm|
+            used_nets = vm.fetch('Hardware', {}).select { |name, _| name.start_with? 'net' }
+            used_nets.each_value do |net_params|
+              networks.delete_if { |net| net['Network ID'] == net_params.fetch('iface', nil) }
+            end
+          end
+
+          networks.each do |net|
+            # Delete the actual host only network interface.
+            execute_prlsrvctl('net', 'del', net['Network ID'])
+          end
+        end
+
+        def disable_password_restrictions
+          server_info = json { execute_prlsrvctl('info', '--json') }
+          server_info.fetch('Require password to',[]).each do |act|
+            execute_prlsrvctl('set', '--require-pwd', "#{act}:off")
+          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 do |name|
+            name.start_with? 'net'
+          end
+
+          # Disable all previously existing adapters (except shared 'vnet0')
+          existing_adapters.each do |adapter|
+            if adapter != 'vnet0'
+              execute_prlctl('set', @uuid, '--device-set', adapter, '--disable')
+            end
+          end
+
+          adapters.each do |adapter|
+            args = []
+            if existing_adapters.include? "net#{adapter[:adapter]}"
+              args.concat(["--device-set","net#{adapter[:adapter]}", "--enable"])
+            else
+              args.concat(["--device-add", "net"])
+            end
+
+            if adapter[:type] == :hostonly
+              args.concat(["--type", "host", "--iface", adapter[:hostonly]])
+            elsif adapter[:type] == :bridged
+              args.concat(["--type", "bridged", "--iface", adapter[:bridge]])
+            elsif adapter[:type] == :shared
+              args.concat(["--type", "shared"])
+            end
+
+            if adapter[:mac_address]
+              args.concat(["--mac", adapter[:mac_address]])
+            end
+
+            if adapter[:nic_type]
+              args.concat(["--adapter-type", adapter[:nic_type].to_s])
+            end
+
+            execute_prlctl("set", @uuid, *args)
+          end
+        end
+
+        def forward_ports(ports)
+          args = []
+          ports.each do |options|
+            protocol = options[:protocol] || 'tcp'
+            pf_builder = [
+              options[:name],
+              options[:hostport],
+              @uuid,
+              options[:guestport]
+            ]
+
+            args.concat(["--nat-#{protocol}-add", pf_builder.join(',')])
+          end
+
+          execute_prlsrvctl('net', 'set', read_shared_network_id, *args)
+        end
+
+        def read_forwarded_ports(global=false)
+          all_rules = read_shared_interface[:nat]
+
+          if global
+            all_rules
+          else
+            all_rules.select { |r| r[:guest].include?(@uuid) }
+          end
+        end
+
+        def read_host_only_interfaces
+          net_list = read_virtual_networks
+          net_list.keep_if { |net| net['Type'] == "host-only" }
+
+          hostonly_ifaces = []
+          net_list.each do |iface|
+            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['Network ID']
+            info[:ip]       = net_info['Parallels adapter']['IP address']
+            info[:netmask]  = net_info['Parallels adapter']['Subnet mask']
+            # Such interfaces are always in 'Up'
+            info[:status]   = "Up"
+
+            # 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])
+              info[:dhcp] = {
+                ip: dhcp_ip,
+                lower: net_info['DHCPv4 server']['IP scope start address'],
+                upper: net_info['DHCPv4 server']['IP scope end address']
+              }
+            end
+            hostonly_ifaces << info
+          end
+          hostonly_ifaces
+        end
+
+        def read_network_interfaces
+          nics = {}
+
+          # Get enabled VM's network interfaces
+          ifaces = read_settings.fetch('Hardware', {}).keep_if do |dev, params|
+            dev.start_with?('net') and params.fetch("enabled", true)
+          end
+          ifaces.each do |name, params|
+            adapter = name.match(/^net(\d+)$/)[1].to_i
+            nics[adapter] ||= {}
+
+            if params['type'] == "shared"
+              nics[adapter][:type] = :shared
+            elsif params['type'] == "host"
+              nics[adapter][:type] = :hostonly
+              nics[adapter][:hostonly] = params.fetch('iface','')
+            elsif params['type'] == "bridged"
+              nics[adapter][:type] = :bridged
+              nics[adapter][:bridge] = params.fetch('iface','')
+            end
+          end
+          nics
+        end
+
+        def read_shared_interface
+          net_info = json do
+            execute_prlsrvctl('net', 'info', read_shared_network_id, '--json')
+          end
+          info = {
+            name:    net_info['Bound To'],
+            ip:      net_info['Parallels adapter']['IP address'],
+            netmask: net_info['Parallels adapter']['Subnet mask'],
+            status:  'Up',
+            nat:     []
+          }
+
+          if net_info.key?('DHCPv4 server')
+            info[:dhcp] = {
+              ip:    net_info['DHCPv4 server']['Server address'],
+              lower: net_info['DHCPv4 server']['IP scope start address'],
+              upper: net_info['DHCPv4 server']['IP scope end address']
+            }
+          end
+
+          net_info['NAT server'].each do |group, rules|
+            rules.each do |name, params|
+              info[:nat] << {
+                rule_name: name,
+                protocol:  group == 'TCP rules' ? 'tcp' : 'udp',
+                guest:     params['destination IP/VM id'],
+                hostport:  params['source port'],
+                guestport: params['destination port']
+              }
+            end
+          end
+
+          info
+        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 read_used_ports
+          # Ignore our own used ports
+          read_forwarded_ports(true).reject { |r| r[:guest].include?(@uuid) }
+        end
+
+        def set_power_consumption_mode(optimized)
+          state = optimized ? 'on' : 'off'
+          execute_prlctl('set', @uuid, '--longer-battery-life', state)
+        end
+
+        def ssh_ip
+          '127.0.0.1'
+        end
+
+        def ssh_port(expected_port)
+          @logger.debug("Searching for SSH port: #{expected_port.inspect}")
+
+          # Look for the forwarded port only by comparing the guest port
+          read_forwarded_ports.each do |r|
+            return r[:hostport] if r[:guestport] == expected_port
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -12,7 +12,7 @@ module VagrantPlugins
         def initialize(uuid)
           super()
 
-          @logger = Log4r::Logger.new("vagrant::provider::parallels::pd_8")
+          @logger = Log4r::Logger.new('vagrant_parallels::driver::pd_8')
           @uuid = uuid
         end
 
@@ -60,10 +60,10 @@ module VagrantPlugins
 
           # Return the details
           return {
-            :name => iface_name,
-            :ip   => options[:adapter_ip],
-            :netmask => options[:netmask],
-            :dhcp => options[:dhcp]
+            name:    iface_name,
+            ip:      options[:adapter_ip],
+            netmask: options[:netmask],
+            dhcp:    options[:dhcp]
           }
         end
 
@@ -240,9 +240,9 @@ module VagrantPlugins
         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"
+            linux:   "prl-tools-lin.iso",
+            darwin:  "prl-tools-mac.iso",
+            windows: "prl-tools-win.iso"
           }
           return nil if !iso_name[guest_os]
 
@@ -289,9 +289,9 @@ module VagrantPlugins
             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'],
-                :upper   => net_info['DHCPv4 server']['IP scope end address']
+                ip:    dhcp_ip,
+                lower: net_info['DHCPv4 server']['IP scope start address'],
+                upper: net_info['DHCPv4 server']['IP scope end address']
               }
             end
             hostonly_ifaces << info
@@ -349,13 +349,17 @@ module VagrantPlugins
           vm.last
         end
 
-        def read_shared_interface
+        def read_shared_network_id
           # There should be only one Shared interface
-          shared_net = read_virtual_networks.detect { |net| net['Type'] == 'shared' }
-          return nil if !shared_net
+          shared_net = read_virtual_networks.detect do |net|
+            net['Type'] == 'shared'
+          end
+          shared_net.fetch('Network ID')
+        end
 
+        def read_shared_interface
           net_info = json do
-            execute_prlsrvctl('net', 'info', shared_net['Network ID'], '--json')
+            execute_prlsrvctl('net', 'info', read_shared_network_id, '--json')
           end
           info = {
             name:    net_info['Bound To'],
@@ -468,6 +472,10 @@ module VagrantPlugins
           end
         end
 
+        def ssh_ip
+          read_guest_ip
+        end
+
         def ssh_port(expected_port)
           expected_port
         end

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

@@ -12,7 +12,7 @@ module VagrantPlugins
         def initialize(uuid)
           super(uuid)
 
-          @logger = Log4r::Logger.new("vagrant::provider::parallels::pd_9")
+          @logger = Log4r::Logger.new('vagrant_parallels::driver::pd_9')
         end
 
         def read_settings