vagrant-parallels 1.5.1 → 1.6.0

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

@@ -161,18 +161,23 @@ module VagrantPlugins
             @logger.debug("Bridge was directly specified in config, searching for: #{config[:bridge]}")
 
             # Search for a matching bridged interface
-            bridgedifs.each do |interface|
-              if interface[:name].downcase == config[:bridge].downcase
-                @logger.debug('Specific bridge found as configured in the Vagrantfile. Using it.')
-                chosen_bridge = interface[:name]
-                break
+            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
               end
+              break if chosen_bridge
             end
 
             # If one wasn't found, then we notify the user here.
             if !chosen_bridge
-              @env[:ui].info I18n.t('vagrant.actions.vm.bridged_networking.specific_not_found',
-                                    :bridge => config[:bridge])
+              @env[:ui].info I18n.t(
+                'vagrant.actions.vm.bridged_networking.specific_not_found',
+                bridge: config[:bridge])
             end
           end
 
@@ -188,14 +193,14 @@ module VagrantPlugins
             else
               # More than one bridgable interface requires a user decision, so
               # show options to choose from.
-              @env[:ui].info I18n.t('vagrant.actions.vm.bridged_networking.available',
-                                    :prefix => false)
+              @env[:ui].info I18n.t(
+                'vagrant.actions.vm.bridged_networking.available', prefix: false)
               bridgedifs.each_index do |index|
                 interface = bridgedifs[index]
-                @env[:ui].info("#{index + 1}) #{interface[:name]}", :prefix => false)
+                @env[:ui].info("#{index + 1}) #{interface[:name]}", prefix: false)
               end
               @env[:ui].info(I18n.t(
-                               'vagrant.actions.vm.bridged_networking.choice_help')+"\n")
+                'vagrant.actions.vm.bridged_networking.choice_help')+"\n")
 
               # The range of valid choices
               valid = Range.new(1, bridgedifs.length)
@@ -410,8 +415,7 @@ module VagrantPlugins
           if net_nums.empty?
             'vagrant-vnet0'
           else
-            net_nums.sort! if net_nums
-            free_names = Array(0..net_nums.last.next) - net_nums
+            free_names = Array(0..net_nums.max) - net_nums
             "vagrant-vnet#{free_names.first}"
           end
         end

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

@@ -0,0 +1,67 @@
+require 'log4r'
+
+require 'digest/md5'
+
+module VagrantPlugins
+  module Parallels
+    module Action
+      class PrepareCloneSnapshot
+        @@lock = Mutex.new
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_parallels::action::prepare_clone_snapshot')
+        end
+
+        def call(env)
+          if !env[:clone_id]
+            @logger.info('No source VM for cloning, skip snapshot preparing')
+            return @app.call(env)
+          end
+
+          # If we're not doing a linked clone, snapshots don't matter
+          if !env[:machine].provider_config.linked_clone \
+            || env[:machine].provider.pd_version_satisfies?('< 11')
+            return @app.call(env)
+          end
+
+          # We lock so that we don't snapshot in parallel
+          @@lock.synchronize do
+            lock_key = Digest::MD5.hexdigest("#{env[:clone_id]}-snapshot")
+            env[:machine].env.lock(lock_key, retry: true) do
+              prepare_snapshot(env)
+            end
+          end
+
+          # Continue
+          @app.call(env)
+        end
+
+        protected
+
+        def prepare_snapshot(env)
+          set_snapshot = env[:machine].provider_config.linked_clone_snapshot
+          env[:clone_snapshot] = set_snapshot || 'vagrant_linked_clone'
+
+          # Get the snapshots. We're done if it already exists
+          snapshots = env[:machine].provider.driver.list_snapshots(env[:clone_id])
+
+          if snapshots.include?(env[:clone_snapshot])
+            env[:clone_snapshot_id] = snapshots[env[:clone_snapshot]]
+            @logger.info('Linked clone snapshot already exists, doing nothing')
+            return
+          end
+
+          # We've specified the snapshot name but it doesn't exist
+          if set_snapshot
+            raise Errors::SnapshotNotFound, snapshot: set_snapshot
+          end
+
+          @logger.info('Creating a new snapshot for linked clone')
+          env[:clone_snapshot_id] = env[:machine].provider.driver.create_snapshot(
+            env[:clone_id], env[:clone_snapshot])
+        end
+      end
+    end
+  end
+end

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

@@ -37,7 +37,7 @@ module VagrantPlugins
           else
             env[:ui].info(I18n.t(
                             'vagrant.actions.vm.set_name.setting_name', name: name))
-            env[:machine].provider.driver.set_name(name)
+            env[:machine].provider.driver.set_name(env[:machine].id, name)
           end
 
           # Create the sentinel

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class SnapshotDelete
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          snapshots = env[:machine].provider.driver.list_snapshots(env[:machine].id)
+          snapshot_id = snapshots[env[:snapshot_name]]
+
+          env[:ui].info I18n.t('vagrant.actions.vm.snapshot.deleting',
+                               name: env[:snapshot_name])
+          env[:machine].provider.driver.delete_snapshot(
+            env[:machine].id, snapshot_id)
+
+          env[:ui].success I18n.t('vagrant.actions.vm.snapshot.deleted',
+                                  name: env[:snapshot_name])
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class SnapshotRestore
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          snapshots = env[:machine].provider.driver.list_snapshots(env[:machine].id)
+          snapshot_id = snapshots[env[:snapshot_name]]
+
+          env[:ui].info I18n.t('vagrant.actions.vm.snapshot.restoring',
+                               name: env[:snapshot_name])
+          env[:machine].provider.driver.restore_snapshot(
+            env[:machine].id, snapshot_id)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class SnapshotSave
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t('vagrant.actions.vm.snapshot.saving',
+                               name: env[:snapshot_name])
+          env[:machine].provider.driver.create_snapshot(
+            env[:machine].id, env[:snapshot_name])
+
+          env[:ui].success I18n.t('vagrant.actions.vm.snapshot.saved',
+                                  name: env[:snapshot_name])
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/cap.rb

@@ -0,0 +1,63 @@
+module VagrantPlugins
+  module Parallels
+    module Cap
+      # 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)
+        return nil if machine.state.id != :running
+
+        {}.tap do |result|
+          machine.provider.driver.read_forwarded_ports.each do |fp|
+            result[fp[:hostport]] = fp[:guestport]
+          end
+        end
+      end
+
+      # Returns host's IP address that can be used to access the host machine
+      # from the VM.
+      #
+      # @return [String] Host's IP address
+      def self.host_address(machine)
+
+        shared_iface = machine.provider.driver.read_shared_interface
+        return shared_iface[:ip] if shared_iface
+
+        nil
+      end
+
+      # Reads the network interface card MAC addresses and returns them.
+      #
+      # @return [Hash<Integer, String>] Adapter => MAC address
+      def self.nic_mac_addresses(machine)
+        nic_macs = machine.provider.driver.read_mac_addresses
+
+        # Make numeration starting from 1, as it is expected in Vagrant.
+        Hash[nic_macs.map.with_index{ |mac, index| [index+1, mac] }]
+      end
+
+      # Returns guest's IP address that can be used to access the VM from the
+      # host machine.
+      #
+      # @return [String] Guest's IP address
+      def self.public_address(machine)
+        return nil if machine.state.id != :running
+
+        ssh_info = machine.ssh_info
+        return nil if !ssh_info
+        ssh_info[:host]
+      end
+
+      # Returns a list of the snapshots that are taken on this machine.
+      #
+      # @return [Array<String>] Snapshot Name
+      def self.snapshot_list(machine)
+        machine.provider.driver.list_snapshots(machine.id).keys
+      end
+    end
+  end
+end

data/lib/vagrant-parallels/config.rb

@@ -6,7 +6,8 @@ module VagrantPlugins
       attr_accessor :destroy_unused_network_interfaces
       attr_accessor :functional_psf
       attr_accessor :optimize_power_consumption
-      attr_accessor :use_linked_clone
+      attr_accessor :linked_clone
+      attr_accessor :linked_clone_snapshot
       attr_accessor :name
       attr_reader   :network_adapters
       attr_accessor :regen_src_uuid
@@ -17,13 +18,15 @@ module VagrantPlugins
 
       # Compatibility with old names
       alias :regen_box_uuid= :regen_src_uuid=
+      alias :use_linked_clone= :linked_clone=
 
       def initialize
         @check_guest_tools = UNSET_VALUE
         @customizations    = []
         @destroy_unused_network_interfaces = UNSET_VALUE
         @functional_psf = UNSET_VALUE
-        @use_linked_clone = UNSET_VALUE
+        @linked_clone   = UNSET_VALUE
+        @linked_clone_snapshot = UNSET_VALUE
         @network_adapters  = {}
         @name              = UNSET_VALUE
         @optimize_power_consumption = UNSET_VALUE
@@ -77,7 +80,8 @@ module VagrantPlugins
           @functional_psf = true
         end
 
-        @use_linked_clone = false if @use_linked_clone == UNSET_VALUE
+        @linked_clone = false if @linked_clone == UNSET_VALUE
+        @linked_clone_snapshot = nil if @linked_clone_snapshot == UNSET_VALUE
 
         @name = nil if @name == UNSET_VALUE
 

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

@@ -55,12 +55,12 @@ module VagrantPlugins
         # Makes a clone of the virtual machine.
         #
         # @param [String] src_name Name or UUID of the source VM or template.
-        # @param [String] dst_name Name of the destination VM.
         # @param [<String => String>] options Options to clone virtual machine.
         # @return [String] UUID of the new VM.
-        def clone_vm(src_name, dst_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]
-          args << '--template' if options[:template]
           args.concat(['--dst', options[:dst]]) if options[:dst]
 
           # Linked clone options
@@ -127,11 +127,16 @@ module VagrantPlugins
 
         # Creates a snapshot for the specified virtual machine.
         #
-        # @param [String] uuid Name or UUID of the target VM.
-        # @param [<Symbol => String, Boolean>] options Snapshot options.
+        # @param [String] uuid Name or UUID of the target VM
+        # @param [String] snapshot_name Snapshot name
         # @return [String] ID of the created snapshot.
-        def create_snapshot(uuid, options)
-          raise NotImplementedError
+        def create_snapshot(uuid, snapshot_name)
+          stdout = execute_prlctl('snapshot', uuid, '--name', snapshot_name)
+          if stdout =~ /\{([\w-]+)\}/
+            return Regexp.last_match(1)
+          end
+
+          raise Errors::SnapshotIdNotDetected, stdout: stdout
         end
 
         # Deletes the virtual machine references by this driver.
@@ -148,6 +153,14 @@ module VagrantPlugins
           end
         end
 
+        # Deletes the specified snapshot
+        #
+        # @param [String] uuid Name or UUID of the target VM
+        # @param [String] snapshot_id Snapshot ID
+        def delete_snapshot(uuid, snapshot_id)
+          execute_prlctl('snapshot-delete', uuid, '--id', snapshot_id)
+        end
+
         # Deletes any host only networks that aren't being used for anything.
         def delete_unused_host_only_networks
           raise NotImplementedError
@@ -203,6 +216,35 @@ module VagrantPlugins
           raise NotImplementedError
         end
 
+        # Lists all snapshots for the specified VM. Returns an empty hash if
+        # there are no snapshots.
+        #
+        # @param [String] uuid Name or UUID of the target VM.
+        # @return [<String => String>] {'Snapshot Name' => 'Snapshot UUID'}
+        def list_snapshots(uuid)
+          settings = read_settings(uuid)
+          snap_config = File.join(settings.fetch('Home'), 'Snapshots.xml')
+
+          # There are no snapshots, exit
+          return {} if !File.exist?(snap_config)
+
+          xml = Nokogiri::XML(File.read(snap_config))
+          snapshots = {}
+
+          # Loop over all 'SavedStateItem' and fetch 'Name' => 'ID' pairs
+          xml.xpath('//SavedStateItem').each do |snap|
+            snap_id = snap.attr('guid')
+
+            # The first entry is always empty (the base sate)
+            next if snap_id.empty?
+
+            snap_name = snap.at('Name').text
+            snapshots[snap_name] = snap_id
+          end
+
+          snapshots
+        end
+
         # Halts the virtual machine (pulls the plug).
         def halt(force=false)
           args = ['stop', @uuid]
@@ -247,15 +289,6 @@ module VagrantPlugins
           bridged_ifaces
         end
 
-        # Returns current snapshot ID for the specified VM. Returns nil if
-        # the VM doesn't have any snapshot.
-        #
-        # @param [String] uuid Name or UUID of the target VM.
-        # @return [String]
-        def read_current_snapshot(uuid)
-          raise NotImplementedError
-        end
-
         def read_forwarded_ports(global=false)
           raise NotImplementedError
         end
@@ -491,8 +524,9 @@ module VagrantPlugins
         # Registers the virtual machine
         #
         # @param [String] pvm_file Path to the machine image (*.pvm)
-        def register(pvm_file)
-          args = [@prlctl_path, 'register', pvm_file]
+        # @param [Array<String>] opts List of options for "prlctl register"
+        def register(pvm_file, opts=[])
+          args = [@prlctl_path, 'register', pvm_file, *opts]
 
           3.times do
             result = raw(*args)
@@ -513,14 +547,12 @@ module VagrantPlugins
           execute(*args)
         end
 
-        # Checks that specified virtual machine is registered
+        # Switches the VM state to the specified snapshot
         #
-        # @return [Boolean]
-        def registered?(uuid)
-          args = %w(list --all --info --no-header -o uuid)
-
-          execute_prlctl(*args).include?(uuid) ||
-            execute_prlctl(*args, '--template').include?(uuid)
+        # @param [String] uuid Name or UUID of the target VM
+        # @param [String] snapshot_id Snapshot ID
+        def restore_snapshot(uuid, snapshot_id)
+          execute_prlctl('snapshot-switch', uuid, '-i', snapshot_id)
         end
 
         # Resumes the virtual machine.
@@ -531,9 +563,10 @@ module VagrantPlugins
 
         # Sets the name of the virtual machine.
         #
-        # @param [String] name New VM name.
-        def set_name(name)
-          execute_prlctl('set', @uuid, '--name', name)
+        # @param [String] uuid VM name or UUID
+        # @param [String] new_name New VM name
+        def set_name(uuid, new_name)
+          execute_prlctl('set', uuid, '--name', new_name)
         end
 
         # Sets Power Consumption method.