vagrant-parallels 2.2.2 → 2.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d138c790174855049184943ea5dada1b980eee3755f88f5e20059a2851fb2aa9
-  data.tar.gz: 277e1c323a916c085f4b45fed9ede685b1587246ace3e703a89b33038b59147f
+  metadata.gz: ede8c43d4ad31a4ad5cec8ecf94158e93a825ea959bf4a2cbf5da1b1428108ad
+  data.tar.gz: 0e56a44dcbd181577e69ef04525be3278a86fd6c0ccb41139635a19176d3768e
 SHA512:
-  metadata.gz: ee07c96b1a45d301d37b2c633e71ac176ca4859cf40d92cfd772d5549892a1edb64a74897270d9819f2ea0fe3f9a2a3916a447a65b60fd084100e06bcf86ef45
-  data.tar.gz: b963b62e1d1b86e89eb7d78c088881a9ae399fb529928fdb030ba921cd0d32f9b660529e160b1bb8f229d077fcc2a71df4cb90518f4a067e7fe2269447ed96dd
+  metadata.gz: a283f0ebedc0074f277fd902725d6724b1db7a7c822621885f5df8bba6197abe9e3e6a914a5cfc8146c4abd187c04a81c59ff02f364c058ffa3fbe7f7fc634be
+  data.tar.gz: 8af828330dc40be03eefcd34834e2eb1d7490ba7ed7331d01dbec224f148ca9743d961cc2510c889d97112f50bc3f7d0db0047c0c3cb5cc03316ed256ed665a3

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 2.2.5 (February 22, 2022)
+BUG FIXES:
+  - Fixed Parallels Tool installation on M1 hosts with arm64
+  [[GH-416](https://github.com/Parallels/vagrant-parallels/pull/416)]
+
+## 2.2.4 (August 18, 2021)
+BUG FIXES:
+  - Fixed running the provisioner on "vagrant up --provision"
+  [[GH-402](https://github.com/Parallels/vagrant-parallels/pull/402)]
+
+## 2.2.3 (July 14, 2021)
+BUG FIXES:
+  - Fixed the compatibility with Vagrant 2.2.17
+  [[GH-399](https://github.com/Parallels/vagrant-parallels/pull/399)]
+
 ## 2.2.2 (June 23, 2021)
 BUG FIXES:
   - Fixed shared folder mount on the VM reboot

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

@@ -5,7 +5,7 @@ module VagrantPlugins
         include VagrantPlugins::Parallels::Util::CompileForwardedPorts
         @@lock = Mutex.new
 
-        def initialize(app, env)
+        def initialize(app, _env)
           @app = app
         end
 
@@ -22,17 +22,15 @@ module VagrantPlugins
           return @app.call(env) if env[:forwarded_ports].empty?
 
           # Acquire both of class- and process-level locks so that we don't
-          # forward ports simultaneousely with someone else.
+          # forward ports simultaneously with someone else.
           @@lock.synchronize do
-            begin
-              env[:machine].env.lock('forward_ports') do
-                env[:ui].output(I18n.t('vagrant.actions.vm.forward_ports.forwarding'))
-                forward_ports
-              end
-            rescue Errors::EnvironmentLockedError
-              sleep 1
-              retry
+            env[:machine].env.lock('forward_ports') do
+              env[:ui].output(I18n.t('vagrant.actions.vm.forward_ports.forwarding'))
+              forward_ports
             end
+          rescue Vagrant::Errors::EnvironmentLockedError
+            sleep 1
+            retry
           end
 
           @app.call(env)
@@ -46,7 +44,9 @@ module VagrantPlugins
           @env[:forwarded_ports].each do |fp|
             message_attributes = {
               guest_port: fp.guest_port,
-              host_port: fp.host_port
+              guest_ip: fp.guest_ip,
+              host_port: fp.host_port,
+              host_ip: fp.host_ip
             }
 
             # Assuming the only reason to establish port forwarding is
@@ -54,7 +54,7 @@ module VagrantPlugins
             # bridged networking don't require port-forwarding and establishing
             # forwarded ports on these attachment types has uncertain behaviour.
             @env[:ui].detail(I18n.t('vagrant_parallels.actions.vm.forward_ports.forwarding_entry',
-                                    message_attributes))
+                                    **message_attributes))
 
             # In Parallels Desktop the scope port forwarding rules is global,
             # so we have to keep their names unique.
@@ -69,14 +69,16 @@ module VagrantPlugins
 
             # Add the options to the ports array to send to the driver later
             ports << {
-              guestport: fp.guest_port,
-              hostport:  fp.host_port,
-              name:      unique_id,
-              protocol:  fp.protocol
+              guest_port: fp.guest_port,
+              guest_ip: fp.guest_ip,
+              host_port: fp.host_port,
+              host_ip: fp.host_ip,
+              name: unique_id,
+              protocol: fp.protocol
             }
           end
 
-          if !ports.empty?
+          unless ports.empty?
             # We only need to forward ports if there are any to forward
             @env[:machine].provider.driver.forward_ports(ports)
           end

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

@@ -16,7 +16,7 @@ module VagrantPlugins
         include Vagrant::Util::ScopedHashOverride
         @@lock = Mutex.new
 
-        def initialize(app, env)
+        def initialize(app, _env)
           @app    = app
           @logger = Log4r::Logger.new('vagrant_parallels::action::network')
         end
@@ -44,20 +44,20 @@ module VagrantPlugins
 
             # Figure out the slot that this adapter will go into
             slot = options[:adapter]
-            if !slot
-              if available_slots.empty?
-                raise VagrantPlugins::Parallels::Errors::ParallelsNoRoomForHighLevelNetwork
-              end
+            unless slot
+              raise VagrantPlugins::Parallels::Errors::ParallelsNoRoomForHighLevelNetwork if available_slots.empty?
 
               slot = available_slots.shift
             end
 
             # Configure it
             data = nil
-            if type == :private_network
+            #noinspection RubyCaseWithoutElseBlockInspection
+            case type
+            when :private_network
               # private_network = hostonly
               data = [:hostonly, options]
-            elsif type == :public_network
+            when :public_network
               # public_network = bridged
               data = [:bridged, options]
             end
@@ -103,16 +103,15 @@ module VagrantPlugins
             networks << network
           end
 
-          if !adapters.empty?
+          unless adapters.empty?
             # Enable the adapters
             @logger.info('Enabling adapters...')
             env[:ui].output(I18n.t('vagrant.actions.vm.network.preparing'))
             adapters.each do |adapter|
-              env[:ui].detail(I18n.t(
-                'vagrant_parallels.parallels.network_adapter',
-                adapter: adapter[:adapter].to_s,
-                type: adapter[:type].to_s,
-                extra: '',
+              env[:ui].detail(I18n.t('vagrant_parallels.parallels.network_adapter',
+                                     adapter: adapter[:adapter].to_s,
+                                     type: adapter[:type].to_s,
+                                     extra: '',
               ))
             end
 
@@ -124,12 +123,12 @@ module VagrantPlugins
 
           # If we have networks to configure, then we configure it now, since
           # that requires the machine to be up and running.
-          if !adapters.empty? && !networks.empty?
+          unless adapters.empty? && networks.empty?
             assign_interface_numbers(networks, adapters)
 
             # Only configure the networks the user requested us to configure
             networks_to_configure = networks.select { |n| n[:auto_config] }
-            if !networks_to_configure.empty?
+            unless networks_to_configure.empty?
               env[:ui].info I18n.t('vagrant.actions.vm.network.configuring')
               env[:machine].guest.capability(:configure_networks, networks_to_configure)
             end
@@ -138,10 +137,10 @@ module VagrantPlugins
 
         def bridged_config(options)
           {
-            auto_config:                     true,
-            bridge:                          nil,
-            mac:                             nil,
-            nic_type:                        nil,
+            auto_config: true,
+            bridge: nil,
+            mac: nil,
+            nic_type: nil,
             use_dhcp_assigned_default_route: false
           }.merge(options || {})
         end
@@ -162,17 +161,17 @@ module VagrantPlugins
             Array(config[:bridge]).each do |bridge|
               bridge = bridge.downcase if bridge.respond_to?(:downcase)
               bridgedifs.each do |interface|
-                if bridge === interface[:name].downcase
-                  @logger.debug('Specific bridge found as configured in the Vagrantfile. Using it.')
-                  chosen_bridge = interface[:name]
-                  break
-                end
+                next unless bridge === interface[:name].downcase
+
+                @logger.debug('Specific bridge found as configured in the Vagrantfile. Using it.')
+                chosen_bridge = interface[:name]
+                break
               end
               break if chosen_bridge
             end
 
             # If one wasn't found, then we notify the user here.
-            if !chosen_bridge
+            unless chosen_bridge
               @env[:ui].info I18n.t(
                 'vagrant.actions.vm.bridged_networking.specific_not_found',
                 bridge: config[:bridge])
@@ -183,7 +182,7 @@ module VagrantPlugins
           # specified in the Vagrantfile, or the bridge specified in the Vagrantfile
           # wasn't found), then we fall back to the normal means of searching for a
           # bridged network.
-          if !chosen_bridge
+          unless chosen_bridge
             if bridgedifs.length == 1
               # One bridgable interface? Just use it.
               chosen_bridge = bridgedifs[0][:name]
@@ -197,15 +196,14 @@ module VagrantPlugins
                 interface = bridgedifs[index]
                 @env[:ui].info("#{index + 1}) #{interface[:name]}", prefix: false)
               end
-              @env[:ui].info(I18n.t(
-                'vagrant.actions.vm.bridged_networking.choice_help')+"\n")
+              @env[:ui].info("#{I18n.t('vagrant.actions.vm.bridged_networking.choice_help')}\n")
 
               # The range of valid choices
               valid = Range.new(1, bridgedifs.length)
 
               # The choice that the user has chosen as the bridging interface
               choice = nil
-              while !valid.include?(choice)
+              until valid.include?(choice)
                 choice = @env[:ui].ask(
                   'Which interface should the network bridge to? Enter a number: ')
                 choice = choice.to_i
@@ -219,11 +217,11 @@ module VagrantPlugins
 
           # Given the choice we can now define the adapter we're using
           {
-            adapter:     config[:adapter],
-            type:        :bridged,
-            bridge:      chosen_bridge,
+            adapter: config[:adapter],
+            type: :bridged,
+            bridge: chosen_bridge,
             mac_address: config[:mac],
-            nic_type:    config[:nic_type]
+            nic_type: config[:nic_type]
           }
         end
 
@@ -231,16 +229,16 @@ module VagrantPlugins
           if config[:ip]
             options = {
               auto_config: true,
-              mac:         nil,
-              netmask:     '255.255.255.0',
-              type:        :static
+              mac: nil,
+              netmask: '255.255.255.0',
+              type: :static
             }.merge(config)
             options[:type] = options[:type].to_sym
             return options
           end
 
           {
-            type:                            :dhcp,
+            type: :dhcp,
             use_dhcp_assigned_default_route: config[:use_dhcp_assigned_default_route]
           }
         end
@@ -248,10 +246,10 @@ module VagrantPlugins
         def hostonly_config(options)
           options = {
             auto_config: true,
-            mac:         nil,
-            name:        nil,
-            nic_type:    nil,
-            type:        :static
+            mac: nil,
+            name: nil,
+            nic_type: nil,
+            type: :static
           }.merge(options)
 
           # Make sure the type is a symbol
@@ -290,13 +288,14 @@ module VagrantPlugins
             # network interface.
             @env[:machine].provider.driver.read_bridged_interfaces.each do |interface|
               next if interface[:status] == 'Down'
+
               that_netaddr = IPAddr.new("#{interface[:ip]}/#{interface[:netmask]}")
-              if netaddr.include? that_netaddr
-                raise VagrantPlugins::Parallels::Errors::NetworkCollision,
-                  hostonly_netaddr: netaddr,
-                  bridge_netaddr:   that_netaddr,
-                  bridge_interface: interface[:name]
-              end
+              next unless netaddr.include? that_netaddr
+
+              raise VagrantPlugins::Parallels::Errors::NetworkCollision,
+                    hostonly_netaddr: netaddr,
+                    bridge_netaddr: that_netaddr,
+                    bridge_interface: interface[:name]
             end
           end
 
@@ -319,14 +318,14 @@ module VagrantPlugins
           end
 
           {
-            adapter_ip:  options[:adapter_ip],
+            adapter_ip: options[:adapter_ip],
             auto_config: options[:auto_config],
-            ip:          options[:ip],
-            mac:         options[:mac],
-            name:        options[:name],
-            netmask:     options[:netmask],
-            nic_type:    options[:nic_type],
-            type:        options[:type]
+            ip: options[:ip],
+            mac: options[:mac],
+            name: options[:name],
+            netmask: options[:netmask],
+            nic_type: options[:nic_type],
+            type: options[:type]
           }.merge(dhcp_options)
         end
 
@@ -334,7 +333,7 @@ module VagrantPlugins
           @logger.info("Searching for matching hostonly network: #{config[:ip]}")
           interface = hostonly_find_matching_network(config)
 
-          if !interface
+          unless interface
             @logger.info('Network not found. Creating if we can.')
 
             # Create a new network
@@ -343,25 +342,25 @@ module VagrantPlugins
           end
 
           {
-            adapter:     config[:adapter],
-            hostonly:    interface[:name],
+            adapter: config[:adapter],
+            hostonly: interface[:name],
             mac_address: config[:mac],
-            nic_type:    config[:nic_type],
-            type:        :hostonly
+            nic_type: config[:nic_type],
+            type: :hostonly
           }
         end
 
         def hostonly_network_config(config)
           {
-            type:       config[:type],
+            type: config[:type],
             adapter_ip: config[:adapter_ip],
-            ip:         config[:ip],
-            netmask:    config[:netmask]
+            ip: config[:ip],
+            netmask: config[:netmask]
           }
         end
 
 
-        def shared_config(options)
+        def shared_config(_options)
           {
             auto_config: false
           }
@@ -370,11 +369,11 @@ module VagrantPlugins
         def shared_adapter(config)
           {
             adapter: config[:adapter],
-            type:    :shared
+            type: :shared
           }
         end
 
-        def shared_network_config(config)
+        def shared_network_config(_config)
           {}
         end
 
@@ -396,11 +395,11 @@ module VagrantPlugins
           # Make a first pass to assign interface numbers by adapter location
           vm_adapters = @env[:machine].provider.driver.read_network_interfaces
           vm_adapters.sort.each do |number, adapter|
-            if adapter[:type] != :none
-              # Not used, so assign the interface number and increment
-              adapter_to_interface[number] = current
-              current += 1
-            end
+            next unless adapter[:type] != :none
+
+            # Not used, so assign the interface number and increment
+            adapter_to_interface[number] = current
+            current += 1
           end
 
           # Make a pass through the adapters to assign the :interface
@@ -419,9 +418,7 @@ module VagrantPlugins
           # Get the list of numbers
           net_nums = []
           @env[:machine].provider.driver.read_virtual_networks.each do |net|
-            if net['Network ID'] =~ /^vagrant-vnet(\d+)$/
-              net_nums << $1.to_i
-            end
+            net_nums << $1.to_i if net['Network ID'] =~ /^vagrant-vnet(\d+)$/
           end
 
           if net_nums.empty?
@@ -440,12 +437,12 @@ module VagrantPlugins
           options = {
             network_id: config[:name] || next_network_id,
             adapter_ip: config[:adapter_ip],
-            netmask:    config[:netmask],
+            netmask: config[:netmask],
           }
 
           if config[:type] == :dhcp
             options[:dhcp] = {
-              ip:    config[:dhcp_ip],
+              ip: config[:dhcp_ip],
               lower: config[:dhcp_lower],
               upper: config[:dhcp_upper]
             }

data/lib/vagrant-parallels/action.rb

@@ -277,8 +277,7 @@ module VagrantPlugins
           b.use Call, IsState, :running do |env1, b1|
             # If the VM is running, run the necessary provisioners
             if env1[:result]
-              b1.use Message, I18n.t('vagrant_parallels.commands.common.vm_already_running')
-              action_provision
+              b1.use action_provision
               next
             end
 

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

@@ -27,11 +27,11 @@ module VagrantPlugins
           # This flag is used to keep track of interrupted state (SIGINT)
           @interrupted = false
 
-          @prlctl_path    = util_path('prlctl')
+          @prlctl_path = util_path('prlctl')
           @prlsrvctl_path = util_path('prlsrvctl')
           @prldisktool_path = util_path('prl_disk_tool')
 
-          if !@prlctl_path
+          unless @prlctl_path
             # This means that Parallels Desktop was not found, so we raise this
             # error here.
             raise VagrantPlugins::Parallels::Errors::ParallelsNotDetected
@@ -60,9 +60,7 @@ module VagrantPlugins
             args.concat(["--nat-#{r[:protocol]}-del", r[:name]])
           end
 
-          if !args.empty?
-            execute_prlsrvctl('net', 'set', read_shared_network_id, *args)
-          end
+          execute_prlsrvctl('net', 'set', read_shared_network_id, *args) unless args.empty?
         end
 
         # Clears the shared folders that have been set on the virtual machine.
@@ -78,7 +76,7 @@ module VagrantPlugins
         # @param [String] src_name Name or UUID of the source VM or template.
         # @param [<String => String>] options Options to clone virtual machine.
         # @return [String] UUID of the new VM.
-        def clone_vm(src_name, options={})
+        def clone_vm(src_name, options = {})
           dst_name = "vagrant_temp_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
 
           args = ['clone', src_name, '--name', dst_name]
@@ -146,10 +144,10 @@ module VagrantPlugins
 
           # Return the details
           {
-            name:    options[:network_id],
-            ip:      options[:adapter_ip],
+            name: options[:network_id],
+            ip: options[:adapter_ip],
             netmask: options[:netmask],
-            dhcp:    options[:dhcp]
+            dhcp: options[:dhcp]
           }
         end
 
@@ -160,9 +158,7 @@ module VagrantPlugins
         # @return [String] ID of the created snapshot.
         def create_snapshot(uuid, snapshot_name)
           stdout = execute_prlctl('snapshot', uuid, '--name', snapshot_name)
-          if stdout =~ /\{([\w-]+)\}/
-            return Regexp.last_match(1)
-          end
+          return Regexp.last_match(1) if stdout =~ /{([\w-]+)}/
 
           raise Errors::SnapshotIdNotDetected, stdout: stdout
         end
@@ -222,7 +218,7 @@ module VagrantPlugins
         # ['create-vm', 'add-vm', 'remove-vm', 'clone-vm']
         def disable_password_restrictions(acts)
           server_info = json { execute_prlsrvctl('info', '--json') }
-          server_info.fetch('Require password to',[]).each do |act|
+          server_info.fetch('Require password to', []).each do |act|
             execute_prlsrvctl('set', '--require-pwd', "#{act}:off") if acts.include? act
           end
         end
@@ -251,34 +247,29 @@ module VagrantPlugins
 
           # 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
+            execute_prlctl('set', @uuid, '--device-set', adapter, '--disable') if adapter != 'vnet0'
           end
 
           adapters.each do |adapter|
             args = []
             if existing_adapters.include? "net#{adapter[:adapter]}"
-              args.concat(['--device-set',"net#{adapter[:adapter]}", '--enable'])
+              args.concat(['--device-set', "net#{adapter[:adapter]}", '--enable'])
             else
-              args.concat(['--device-add', 'net'])
+              args.concat(%w[--device-add net])
             end
 
-            if adapter[:type] == :hostonly
+            case adapter[:type]
+            when :hostonly
               args.concat(['--type', 'host', '--iface', adapter[:hostonly]])
-            elsif adapter[:type] == :bridged
+            when :bridged
               args.concat(['--type', 'bridged', '--iface', adapter[:bridge]])
-            elsif adapter[:type] == :shared
-              args.concat(['--type', 'shared'])
+            when :shared
+              args.concat(%w[--type shared])
             end
 
-            if adapter[:mac_address]
-              args.concat(['--mac', adapter[:mac_address]])
-            end
+            args.concat(['--mac', adapter[:mac_address]]) if adapter[:mac_address]
 
-            if adapter[:nic_type]
-              args.concat(['--adapter-type', adapter[:nic_type].to_s])
-            end
+            args.concat(['--adapter-type', adapter[:nic_type].to_s]) if adapter[:nic_type]
 
             execute_prlctl('set', @uuid, *args)
           end
@@ -308,9 +299,9 @@ module VagrantPlugins
             protocol = options[:protocol] || 'tcp'
             pf_builder = [
               options[:name],
-              options[:hostport],
+              options[:host_port],
               @uuid,
-              options[:guestport]
+              options[:guest_port]
             ]
 
             args.concat(["--nat-#{protocol}-add", pf_builder.join(',')])
@@ -329,7 +320,7 @@ module VagrantPlugins
           snap_config = File.join(settings.fetch('Home'), 'Snapshots.xml')
 
           # There are no snapshots, exit
-          return {} if !File.exist?(snap_config)
+          return {} unless File.exist?(snap_config)
 
           xml = Nokogiri::XML(File.read(snap_config))
           snapshots = {}
@@ -349,7 +340,7 @@ module VagrantPlugins
         end
 
         # Halts the virtual machine (pulls the plug).
-        def halt(force=false)
+        def halt(force = false)
           args = ['stop', @uuid]
           args << '--kill' if force
           execute_prlctl(*args)
@@ -370,22 +361,18 @@ module VagrantPlugins
             info = {}
             ifconfig = execute('ifconfig', iface)
             # Assign default values
-            info[:name]    = iface
-            info[:ip]      = '0.0.0.0'
+            info[:name] = iface
+            info[:ip] = '0.0.0.0'
             info[:netmask] = '0.0.0.0'
-            info[:status]  = 'Down'
+            info[:status] = 'Down'
 
-            if ifconfig =~ /(?<=inet\s)(\S*)/
-              info[:ip] = $1.to_s
-            end
+            info[:ip] = $1.to_s if ifconfig =~ /(?<=inet\s)(\S*)/
             if ifconfig =~ /(?<=netmask\s)(\S*)/
               # Netmask will be converted from hex to dec:
               # '0xffffff00' -> '255.255.255.0'
-              info[:netmask] = $1.hex.to_s(16).scan(/../).each.map{|octet| octet.hex}.join('.')
-            end
-            if ifconfig =~ /\W(UP)\W/ and ifconfig !~ /(?<=status:\s)inactive$/
-              info[:status] = 'Up'
+              info[:netmask] = $1.hex.to_s(16).scan(/../).each.map { |octet| octet.hex }.join('.')
             end
+            info[:status] = 'Up' if ifconfig =~ /\W(UP)\W/ and ifconfig !~ /(?<=status:\s)inactive$/
 
             bridged_ifaces << info
           end
@@ -406,7 +393,7 @@ module VagrantPlugins
         # @param [Boolean] global If true, returns all the rules on the host.
         # Otherwise only rules related to the context VM will be returned.
         # @return [Array<Symbol => String>]
-        def read_forwarded_ports(global=false)
+        def read_forwarded_ports(global = false)
           all_rules = read_shared_interface[:nat]
 
           if global
@@ -426,44 +413,44 @@ module VagrantPlugins
           leases = {}
           begin
             File.open(leases_file).grep(/#{mac_addr}/) do |line|
-              _, ip, exp, dur, _, _ = line.split /([\d.]*)="(\d*),(\d*),(\w*),(\w*)".*/
+              _, ip, exp, dur, = line.split /([\d.]*)="(\d*),(\d*),(\w*),(\w*)".*/
               leases[ip] = exp.to_i - dur.to_i
             end
           rescue Errno::EACCES
-            raise Errors::DhcpLeasesNotAccessible, :leases_file => leases_file.to_s
+            raise Errors::DhcpLeasesNotAccessible, leases_file: leases_file.to_s
           rescue Errno::ENOENT
             # File does not exist
             # Perhaps, it is the fist start of Parallels Desktop
-            return nil
+            return ''
           end
 
-          return nil if leases.empty?
+          return '' if leases.empty?
 
           # Get the most resent lease and return an associated IP
-          leases.sort_by { |_ip, lease_time| lease_time }.last.first
+          leases.max_by { |_ip, lease_time| lease_time }.first
         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)
-          guest_os = guest_os.to_sym
-          iso_name ={
+        def read_guest_tools_iso_path(guest_os, arch=nil)
+          guest_os = (guest_os + (['arm', 'arm64', 'aarch64'].include?(arch.to_s.strip) ? '_arm' : '')).to_sym
+          iso_name = {
             linux: 'prl-tools-lin.iso',
+            linux_arm: 'prl-tools-lin-arm.iso',
             darwin: 'prl-tools-mac.iso',
+            darwin_arm: 'prl-tools-mac-arm.iso',
             windows: 'PTIAgent.exe'
           }
-          return nil if !iso_name[guest_os]
+          return nil unless iso_name[guest_os]
 
-          bundle_id =  'com.parallels.desktop.console'
+          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
+          raise Errors::ParallelsToolsIsoNotFound, iso_path: iso_path unless File.exist?(iso_path)
 
           iso_path
         end
@@ -478,7 +465,7 @@ module VagrantPlugins
         # @return [Symbol]
         def read_guest_tools_state
           state = read_settings.fetch('GuestTools', {}).fetch('state', nil)
-          state = 'not_installed' if !state
+          state ||= 'not_installed'
           state.to_sym
         end
 
@@ -512,18 +499,18 @@ module VagrantPlugins
             end
 
             iface = {
-              name:   net_info['Network ID'],
+              name: net_info['Network ID'],
               status: 'Down'
             }
 
             adapter = net_info['Parallels adapter']
             if adapter
-              iface[:ip]       = adapter['IPv4 address']
-              iface[:netmask]  = adapter['IPv4 subnet mask']
-              iface[:status]   = 'Up'
+              iface[:ip] = adapter['IPv4 address']
+              iface[:netmask] = adapter['IPv4 subnet mask']
+              iface[:status] = 'Up'
 
               if adapter['IPv6 address'] && adapter['IPv6 subnet mask']
-                iface[:ipv6]        = adapter['IPv6 address']
+                iface[:ipv6] = adapter['IPv6 address']
                 iface[:ipv6_prefix] = adapter['IPv6 subnet mask']
               end
             end
@@ -542,9 +529,7 @@ module VagrantPlugins
             name.start_with?('net') && params['type'] == 'shared'
           end
 
-          if shared_ifaces.empty?
-            raise Errors::SharedInterfaceNotFound
-          end
+          raise Errors::SharedInterfaceNotFound if shared_ifaces.empty?
 
           shared_ifaces.values.first.fetch('mac', nil)
         end
@@ -570,14 +555,15 @@ module VagrantPlugins
             adapter = name.match(/^net(\d+)$/)[1].to_i
             nics[adapter] ||= {}
 
-            if params['type'] == 'shared'
+            case params['type']
+            when 'shared'
               nics[adapter][:type] = :shared
-            elsif params['type'] == 'host'
+            when 'host'
               nics[adapter][:type] = :hostonly
-              nics[adapter][:hostonly] = params.fetch('iface','')
-            elsif params['type'] == 'bridged'
+              nics[adapter][:hostonly] = params.fetch('iface', '')
+            when 'bridged'
               nics[adapter][:type] = :bridged
-              nics[adapter][:bridge] = params.fetch('iface','')
+              nics[adapter][:bridge] = params.fetch('iface', '')
             end
           end
           nics
@@ -586,8 +572,8 @@ module VagrantPlugins
         # Returns virtual machine settings
         #
         # @return [<String => String, Hash>]
-        def read_settings(uuid=@uuid)
-          vm = json { execute_prlctl('list', uuid, '--info', '--no-header', '--json')  }
+        def read_settings(uuid = @uuid)
+          vm = json { execute_prlctl('list', uuid, '--info', '--no-header', '--json') }
           vm.last
         end
 
@@ -609,20 +595,20 @@ module VagrantPlugins
           end
 
           iface = {
-            nat:    [],
+            nat: [],
             status: 'Down'
           }
           adapter = net_info['Parallels adapter']
 
           if adapter
-            iface[:ip]       = adapter['IPv4 address']
-            iface[:netmask]  = adapter['IPv4 subnet mask']
-            iface[:status]   = 'Up'
+            iface[:ip] = adapter['IPv4 address']
+            iface[:netmask] = adapter['IPv4 subnet mask']
+            iface[:status] = 'Up'
           end
 
           if net_info.key?('DHCPv4 server')
             iface[:dhcp] = {
-              ip:    net_info['DHCPv4 server']['Server address'],
+              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']
             }
@@ -631,10 +617,10 @@ module VagrantPlugins
           net_info['NAT server'].each do |group, rules|
             rules.each do |name, params|
               iface[:nat] << {
-                name:      name,
-                protocol:  group == 'TCP rules' ? 'tcp' : 'udp',
-                guest:     params['destination IP/VM id'],
-                hostport:  params['source port'],
+                name: name,
+                protocol: group == 'TCP rules' ? 'tcp' : 'udp',
+                guest: params['destination IP/VM id'],
+                hostport: params['source port'],
                 guestport: params['destination port']
               }
             end
@@ -650,7 +636,7 @@ module VagrantPlugins
         def read_shared_folders
           shf_info = read_settings.fetch('Host Shared Folders', {})
           list = {}
-          shf_info.delete_if { |k,v| k == 'enabled' }.each do |id, data|
+          shf_info.delete_if { |k, _v| k == 'enabled' }.each do |id, data|
             list[id] = data.fetch('path')
           end
 
@@ -686,11 +672,9 @@ module VagrantPlugins
         # @param [String] option Name of option (See all: `prlctl list -L`)
         # @param [String] uuid Virtual machine UUID
         # @return [String]
-        def read_vm_option(option, uuid=@uuid)
-          out = execute_prlctl('list', uuid,'--no-header', '-o', option).strip
-          if out.empty?
-            raise Errors::ParallelsVMOptionNotFound, vm_option: option
-          end
+        def read_vm_option(option, uuid = @uuid)
+          out = execute_prlctl('list', uuid, '--no-header', '-o', option).strip
+          raise Errors::ParallelsVMOptionNotFound, vm_option: option if out.empty?
 
           out
         end
@@ -699,7 +683,7 @@ module VagrantPlugins
         #
         # @return [<String => String>]
         def read_vms
-          args = %w(list --all --no-header --json -o name,uuid)
+          args = %w[list --all --no-header --json -o name,uuid]
           vms_arr = json { execute_prlctl(*args) }
           templates_arr = json { execute_prlctl(*args, '--template') }
 
@@ -711,7 +695,7 @@ module VagrantPlugins
         #
         # @return [Array <String => String>]
         def read_vms_info
-          args = %w(list --all --info --no-header --json)
+          args = %w[list --all --info --no-header --json]
           vms_arr = json { execute_prlctl(*args) }
           templates_arr = json { execute_prlctl(*args, '--template') }
 
@@ -722,7 +706,7 @@ module VagrantPlugins
         #
         # @param [String] pvm_file Path to the machine image (*.pvm)
         # @param [Array<String>] opts List of options for "prlctl register"
-        def register(pvm_file, opts=[])
+        def register(pvm_file, opts = [])
           execute_prlctl('register', pvm_file, *opts)
         end
 
@@ -823,7 +807,7 @@ module VagrantPlugins
 
             # Sometimes this happens. In this case, retry.
             # If we don't see this text, the VM really doesn't exist.
-            return false if !result.stderr.include?('Login failed:')
+            return false unless result.stderr.include?('Login failed:')
 
             # Sleep a bit though to give Parallels Desktop time to fix itself
             sleep 2
@@ -861,8 +845,8 @@ module VagrantPlugins
               # If there was an error running command, show the error and the
               # output.
               raise VagrantPlugins::Parallels::Errors::ExecutionError,
-                :command => command.inspect,
-                :stderr  => r.stderr
+                    command: command.inspect,
+                    stderr: r.stderr
             end
           end
           r.stdout
@@ -877,12 +861,10 @@ module VagrantPlugins
             JSON.parse(data)
           rescue JSON::JSONError
             # We retried already, raise the issue and be done
-            if raise_error
-              raise VagrantPlugins::Parallels::Errors::JSONParseError, data: data
-            end
+            raise VagrantPlugins::Parallels::Errors::JSONParseError, data: data if raise_error
 
             # Remove garbage before/after json string[GH-204]
-            data = data[/(\{.*\}|\[.*\])/m]
+            data = data[/({.*}|\[.*\])/m]
 
             # Remove all control characters unsupported by JSON [GH-219]
             data.tr!("\u0000-\u001f", '')
@@ -903,7 +885,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/guest_cap/darwin/install_parallels_tools.rb

@@ -5,8 +5,11 @@ module VagrantPlugins
 
         def self.install_parallels_tools(machine)
           machine.communicate.tap do |comm|
+            arch = ''
+            comm.execute("uname -p") { |type, data| arch << data if type == :stdout }
+
             tools_iso_path = File.expand_path(
-              machine.provider.driver.read_guest_tools_iso_path('darwin'),
+              machine.provider.driver.read_guest_tools_iso_path("darwin", arch),
               machine.env.root_path
             )
             remote_file = '/tmp/prl-tools-mac.iso'

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

@@ -1,3 +1,5 @@
+require 'log4r'
+
 module VagrantPlugins
   module Parallels
     module GuestLinuxCap
@@ -8,8 +10,11 @@ module VagrantPlugins
             machine.communicate.sudo('ptiagent-cmd --install')
           else
             machine.communicate.tap do |comm|
+              arch = ''
+              comm.execute("uname -p") { |type, data| arch << data if type == :stdout }
+
               tools_iso_path = File.expand_path(
-                machine.provider.driver.read_guest_tools_iso_path('linux'),
+                machine.provider.driver.read_guest_tools_iso_path("linux", arch),
                 machine.env.root_path
               )
               remote_file = '/tmp/prl-tools-lin.iso'

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

@@ -29,14 +29,26 @@ module VagrantPlugins
         # @return [Integer]
         attr_reader :host_port
 
-        def initialize(id, host_port, guest_port, options)
+        # The ip of the guest to be used for the port.
+        #
+        # @return [String]
+        attr_reader :guest_ip
+
+        # The ip of the host used to access the port.
+        #
+        # @return [String]
+        attr_reader :host_ip
+
+        def initialize(id, host_port, guest_port, host_ip, guest_ip, **options)
           @id         = id
           @guest_port = guest_port
+          @guest_ip   = guest_ip
           @host_port  = host_port
+          @host_ip    = host_ip
 
           options ||= {}
           @auto_correct = false
-          @auto_correct = options[:auto_correct] if options.has_key?(:auto_correct)
+          @auto_correct = options[:auto_correct] if options.key?(:auto_correct)
           @protocol = options[:protocol] || 'tcp'
         end
 

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

@@ -12,23 +12,25 @@ module VagrantPlugins
           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]
-
-              # Temporary disable automatically pre-configured forwarded ports
-              # for SSH, since it is working not so well [GH-146]
-              next if id == 'ssh'
-
-              mappings[host_port.to_s + protocol.to_s] =
-                Model::ForwardedPort.new(id, host_port, guest_port, options)
-            end
+            next unless type == :forwarded_port
+
+            guest_port = options[:guest]
+            guest_ip   = options[:guest_ip]
+            host_port  = options[:host]
+            host_ip    = options[:host_ip]
+            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]
+
+            # Temporary disable automatically pre-configured forwarded ports
+            # for SSH, since it is working not so well [GH-146]
+            next if id == 'ssh'
+
+            mappings[host_port.to_s + protocol.to_s] =
+              Model::ForwardedPort.new(id, host_port, guest_port, host_ip, guest_ip, **options)
           end
 
           mappings.values

data/lib/vagrant-parallels/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Parallels
-    VERSION = '2.2.2'
+    VERSION = '2.2.5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-parallels
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.5
 platform: ruby
 authors:
 - Mikhail Zholobov
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-23 00:00:00.000000000 Z
+date: 2022-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -31,28 +31,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.5.0
+        version: 3.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.5.0
+        version: 3.10.0
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement