vagrant-parallels 1.5.1 → 1.6.0

data/lib/vagrant-parallels/action.rb

@@ -167,6 +167,7 @@ module VagrantPlugins
             b1.use HandleForwardedPortCollisions
             b1.use ForwardPorts
             b1.use Resume
+            b1.use Provision
             b1.use WaitForCommunicator, [:resuming, :running]
           end
         end
@@ -276,7 +277,11 @@ module VagrantPlugins
             # If the VM is NOT created yet, then do the setup steps
             if env1[:result]
               b1.use Customize, 'pre-import'
+              b1.use BoxRegister
+              b1.use PrepareClone
+              b1.use PrepareCloneSnapshot
               b1.use Import
+              b1.use BoxUnregister
               b1.use SaneDefaults
               b1.use Customize, 'post-import'
             end
@@ -330,6 +335,8 @@ module VagrantPlugins
 
 
       autoload :Boot, File.expand_path('../action/boot', __FILE__)
+      autoload :BoxRegister, File.expand_path('../action/box_register', __FILE__)
+      autoload :BoxUnregister, File.expand_path('../action/box_unregister', __FILE__)
       autoload :HandleGuestTools, File.expand_path('../action/handle_guest_tools', __FILE__)
       autoload :HandleForwardedPortCollisions, File.expand_path('../action/handle_forwarded_port_collisions.rb', __FILE__)
       autoload :ClearNetworkInterfaces, File.expand_path('../action/clear_network_interfaces', __FILE__)
@@ -344,6 +351,7 @@ module VagrantPlugins
       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 :PrepareCloneSnapshot, File.expand_path('../action/prepare_clone_snapshot', __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__)

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

@@ -0,0 +1,113 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Parallels
+    module Action
+      class BoxRegister
+        @@lock = Mutex.new
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_parallels::action::box_register')
+        end
+
+        def call(env)
+          # If we don't have a box, nothing to do
+          if !env[:machine].box
+            return @app.call(env)
+          end
+
+          # Do the register while locked so that nobody else register
+          # a box at the same time.
+          @@lock.synchronize do
+            lock_key = Digest::MD5.hexdigest(env[:machine].box.name)
+            env[:machine].env.lock(lock_key, retry: true) do
+              register_box(env)
+            end
+          end
+
+          # If we got interrupted, then the import could have been
+          # interrupted and its not a big deal. Just return out.
+          return if env[:interrupted]
+
+          # Register completed successfully. Continue the chain
+          @app.call(env)
+        end
+
+        protected
+
+        def box_path(env)
+          pvm = Dir.glob(env[:machine].box.directory.join('*.pvm')).first
+
+          if !pvm
+            raise Errors::BoxImageNotFound, name: env[:machine].box.name
+          end
+
+          pvm
+        end
+
+        def box_id(env, box_path)
+          # Get the box image UUID from XML-based configuration file
+          tpl_config = File.join(box_path, 'config.pvs')
+          xml = Nokogiri::XML(File.open(tpl_config))
+          id = xml.xpath('//ParallelsVirtualMachine/Identification/VmUuid').text
+
+          if !id
+            raise Errors::BoxIDNotFound,
+              name: env[:machine].box.name,
+              config: tpl_config
+          end
+
+          id
+        end
+
+        def register_box(env)
+          box_id_file = env[:machine].box.directory.join('box_id')
+
+          # Read the master ID if we have it in the file.
+          env[:clone_id] = box_id_file.read.chomp if box_id_file.file?
+
+          # If we have the ID and the VM exists already, then we
+          # have nothing to do. Success!
+          if env[:clone_id] && env[:machine].provider.driver.vm_exists?(env[:clone_id])
+            @logger.info(
+              "Box image '#{env[:machine].box.name}' is already registered " +
+                "(id=#{env[:clone_id]}) - skipping register step.")
+            return
+          end
+
+          env[:ui].info I18n.t('vagrant_parallels.actions.vm.box.register',
+                        name: env[:machine].box.name)
+
+          pvm = box_path(env)
+
+          # We need the box ID to be the same for all parallel runs
+          options = ['--preserve-uuid']
+
+          if env[:machine].provider_config.regen_src_uuid \
+            && env[:machine].provider.pd_version_satisfies?('>= 10.1.2')
+            options << '--regenerate-src-uuid'
+          end
+
+          # Register the box VM image
+          env[:machine].provider.driver.register(pvm, options)
+          env[:clone_id] = box_id(env, pvm)
+
+          @logger.info(
+            "Registered box #{env[:machine].box.name} with id #{env[:clone_id]}")
+
+          @logger.debug("Writing box id '#{env[:clone_id]}' to #{box_id_file}")
+          box_id_file.open('w+') do |f|
+            f.write(env[:clone_id])
+          end
+
+          if env[:machine].provider.pd_version_satisfies?('>= 10')
+            # Convert template to VM (compatibility with old-styled boxes)
+            env[:machine].provider.driver.execute_prlctl(
+              'set', env[:clone_id], '--template', 'off')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Parallels
+    module Action
+      class BoxUnregister
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_parallels::action::box_unregister')
+        end
+
+        def call(env)
+          # If we don't have a box, nothing to do
+          if !env[:machine].box
+            return @app.call(env)
+          end
+
+          unregister_box(env)
+
+          # If we got interrupted, then the import could have been
+          # interrupted and its not a big deal. Just return out.
+          return if env[:interrupted]
+
+          # Register completed successfully. Continue the chain
+          @app.call(env)
+        end
+
+        def recover(env)
+          unregister_box(env)
+        end
+
+        private
+
+        def unregister_box(env)
+          if env[:clone_id] && env[:machine].provider.driver.vm_exists?(env[:clone_id])
+            env[:ui].info I18n.t('vagrant_parallels.actions.vm.box.unregister')
+            env[:machine].provider.driver.unregister(env[:clone_id])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,84 +8,85 @@ module VagrantPlugins
         end
 
         def call(env)
-          @env = env
           if env[:machine].state.id != :stopped
             raise Vagrant::Errors::VMPowerOffToPackage
           end
 
-          @tpl_name = gen_template_name
-
-          export
-          compact_template
-          unregister_template
+          clone(env)
+          compact(env)
+          unregister_vm(env)
 
           @app.call(env)
         end
 
         def recover(env)
-          @env = env
-          unregister_template
+          unregister_vm(env)
         end
 
         private
 
-        def gen_template_name
+        def box_vm_name(env)
           # Use configured name if it is specified, or generate the new one
-          name = @env[:machine].provider_config.name
+          name = env[:machine].provider_config.name
           if !name
-            name = "#{@env[:root_path].basename.to_s}_#{@env[:machine].name}"
+            name = "#{env[:root_path].basename.to_s}_#{env[:machine].name}"
             name.gsub!(/[^-a-z0-9_]/i, '')
           end
 
-          tpl_name = "#{name}_box"
+          vm_name = "#{name}_box"
 
           # Ensure that the name is not in use
           ind = 0
-          while @env[:machine].provider.driver.read_vms.has_key?(tpl_name)
+          while env[:machine].provider.driver.read_vms.has_key?(vm_name)
             ind += 1
-            tpl_name = "#{name}_box_#{ind}"
+            vm_name = "#{name}_box_#{ind}"
           end
 
-          tpl_name
+          vm_name
         end
 
-        def export
-          @env[:ui].info I18n.t('vagrant.actions.vm.export.exporting')
+        def clone(env)
+          env[:ui].info I18n.t('vagrant.actions.vm.export.exporting')
 
           options = {
-            template: true,
-            dst: @env['export.temp_dir'].to_s
+            dst: env['export.temp_dir'].to_s
           }
 
-          @env[:machine].provider.driver.clone_vm(@env[:machine].id, @tpl_name, options) do |progress|
-            @env[:ui].clear_line
-            @env[:ui].report_progress(progress, 100, false)
+          env[:package_box_id] = env[:machine].provider.driver.clone_vm(
+            env[:machine].id, options) do |progress|
+            env[:ui].clear_line
+            env[:ui].report_progress(progress, 100, false)
 
-            # # If we got interrupted, then the import could have been interrupted.
-            # Just rise an exception and then 'recover' will be called to cleanup.
-            raise Vagrant::Errors::VagrantInterrupt if @env[:interrupted]
+            # If we got interrupted, then rise an exception and 'recover'
+            # will be called to cleanup.
+            raise Vagrant::Errors::VagrantInterrupt if env[:interrupted]
           end
 
+          # Set the box VM name
+          name = box_vm_name(env)
+          env[:machine].provider.driver.set_name(env[:package_box_id], name)
+
           # Clear the line a final time so the next data can appear
           # alone on the line.
-          @env[:ui].clear_line
+          env[:ui].clear_line
         end
 
-        def compact_template
-          @env[:ui].info I18n.t('vagrant_parallels.actions.vm.export.compacting')
-          @env[:machine].provider.driver.compact(@tpl_name) do |progress|
-            @env[:ui].clear_line
-            @env[:ui].report_progress(progress, 100, false)
+        def compact(env)
+          env[:ui].info I18n.t('vagrant_parallels.actions.vm.export.compacting')
+          env[:machine].provider.driver.compact(env[:package_box_id]) do |progress|
+            env[:ui].clear_line
+            env[:ui].report_progress(progress, 100, false)
           end
 
           # Clear the line a final time so the next data can appear
           # alone on the line.
-          @env[:ui].clear_line
+          env[:ui].clear_line
         end
 
-        def unregister_template
-          @logger.info("Unregister the box template: '#{@tpl_name}'")
-          @env[:machine].provider.driver.unregister(@tpl_name)
+        def unregister_vm(env)
+          return if !env[:package_box_id]
+          @logger.info("Unregister the box VM: '#{env[:package_box_id]}'")
+          env[:machine].provider.driver.unregister(env[:package_box_id])
         end
       end
     end

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

@@ -3,6 +3,7 @@ module VagrantPlugins
     module Action
       class ForwardPorts
         include VagrantPlugins::Parallels::Util::CompileForwardedPorts
+        @@lock = Mutex.new
 
         def initialize(app, env)
           @app = app
@@ -21,13 +22,30 @@ module VagrantPlugins
 
           # Get the ports we're forwarding
           env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
-          env[:ui].output(I18n.t('vagrant.actions.vm.forward_ports.forwarding'))
-          forward_ports
+
+          # Exit if there are no ports to forward
+          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.
+          @@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
+            end
+          end
 
           @app.call(env)
         end
 
         def forward_ports
+          all_rules = @env[:machine].provider.driver.read_forwarded_ports(true)
+          names_in_use = all_rules.collect { |r| r[:rule_name] }
           ports = []
 
           @env[:forwarded_ports].each do |fp|
@@ -43,11 +61,22 @@ module VagrantPlugins
             @env[:ui].detail(I18n.t('vagrant_parallels.actions.vm.forward_ports.forwarding_entry',
                                     message_attributes))
 
+            # In Parallels Desktop the scope port forwarding rules is global,
+            # so we have to keep their names unique.
+            unique_id = fp.id
+            # Append random suffix to get the unique rule name
+            while names_in_use.include?(unique_id)
+              suffix = (0...4).map { ('a'..'z').to_a[rand(26)] }.join
+              unique_id = "#{fp.id}_#{suffix}"
+            end
+            # Mark this rule name as in use
+            names_in_use << unique_id
+
             # Add the options to the ports array to send to the driver later
             ports << {
               guestport: fp.guest_port,
               hostport:  fp.host_port,
-              name:      get_unique_name(fp.id),
+              name:      unique_id,
               protocol:  fp.protocol
             }
           end
@@ -57,21 +86,6 @@ module VagrantPlugins
             @env[:machine].provider.driver.forward_ports(ports)
           end
         end
-
-        private
-
-        def get_unique_name(id)
-          all_rules = @env[:machine].provider.driver.read_forwarded_ports(true)
-          names_in_use = all_rules.collect { |r| r[:rule_name] }
-
-          # Append random suffix to get unique rule name
-          while names_in_use.include?(id)
-            suffix = (0...4).map { ('a'..'z').to_a[rand(26)] }.join
-            id = "#{id}_#{suffix}"
-          end
-
-          id
-        end
       end
     end
   end

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

@@ -1,17 +1,19 @@
 require 'nokogiri'
 
+require 'digest/md5'
+
 module VagrantPlugins
   module Parallels
     module Action
       class Import
+        @@lock = Mutex.new
+
         def initialize(app, env)
           @app = app
           @logger = Log4r::Logger.new('vagrant_parallels::action::import')
         end
 
         def call(env)
-          @machine = env[:machine]
-
           # Disable requiring password for register and clone actions [GH-67].
           # It is available only since PD 10.
           if env[:machine].provider.pd_version_satisfies?('>= 10')
@@ -20,32 +22,54 @@ module VagrantPlugins
             env[:machine].provider.driver.disable_password_restrictions(acts)
           end
 
-          # Register template to be able to clone it further
-          register_template(template_path.to_s)
+          # Linked clones are supported only for PD 11 and higher
+          if env[:machine].provider_config.linked_clone \
+            && env[:machine].provider.pd_version_satisfies?('>= 11')
+            # Linked clone creation should not be concurrent [GH-206]
+            @@lock.synchronize do
+              lock_key = Digest::MD5.hexdigest("#{env[:clone_id]}-linked-clone")
+              env[:machine].env.lock(lock_key, retry: true) do
+                clone_linked(env)
+              end
+            end
+          else
+            clone_full(env)
+          end
 
-          # Get template name. It might be changed during registration if name
-          # collision has been occurred
-          tpl_name = template_name(template_path)
+          # If we got interrupted, then the import could have been
+          # interrupted and its not a big deal. Just return out.
+          return if env[:interrupted]
 
-          # Import VM, e.q. clone it from registered template
-          import(env, tpl_name)
+          # Flag as erroneous and return if import failed
+          raise Errors::VMCloneFailure if !env[:machine].id
 
-          # Hide template since we dont need it anymore
-          unregister_template(tpl_name)
+          if env[:machine].provider_config.regen_src_uuid \
+            && env[:machine].provider.pd_version_satisfies?('< 11')
+            @logger.info('Regenerate SourceVmUuid by editing config.pvs file')
+            env[:machine].provider.driver.regenerate_src_uuid
+          end
 
-          # Flag as erroneous and return if import failed
-          raise Errors::VMImportFailure if !@machine.id
+          # Remove 'Icon\r' file from VM home (bug in PD 11.0.0)
+          if env[:machine].provider.pd_version_satisfies?('= 11.0.0')
+            vm_home = env[:machine].provider.driver.read_settings.fetch('Home')
+            broken_icns = Dir[File.join(vm_home, 'Icon*')]
+            FileUtils.rm(broken_icns, :force => true)
+          end
+
+          # Copy the SSH key from the clone machine if we can
+          if env[:clone_machine]
+            key_path = env[:clone_machine].data_dir.join('private_key')
+            if key_path.file?
+              FileUtils.cp(key_path, env[:machine].data_dir.join('private_key'))
+            end
+          end
 
           # Import completed successfully. Continue the chain
           @app.call(env)
         end
 
         def recover(env)
-          # We should to unregister template
-          tpl_name = template_name(template_path)
-          unregister_template(tpl_name)
-
-          if @machine.state.id != :not_created
+          if env[:machine] && env[:machine].state.id != :not_created
             return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)
             return if env['vagrant_parallels.error'].is_a?(Errors::VagrantParallelsError)
 
@@ -64,78 +88,12 @@ module VagrantPlugins
 
         protected
 
-        def register_template(tpl_path_s)
-          @logger.info("Register the box template: '#{tpl_path_s}'")
-          @machine.provider.driver.register(tpl_path_s)
-        end
-
-        def template_path
-          Pathname.glob(@machine.box.directory.join('*.pvm')).first
-        end
-
-        def template_name(tpl_path)
-          # Get template name from XML-based configuration file
-          tpl_config = tpl_path.join('config.pvs')
-          xml = Nokogiri::XML(File.open(tpl_config))
-          name = xml.xpath('//ParallelsVirtualMachine/Identification/VmName').text
-
-          if !name
-            raise Errors::ParallelsTplNameNotFound, config_path: tpl_config
-          end
-
-          name
-        end
-
-        def import(env, tpl_name)
-          # Linked clones are supported only for PD 11 and higher
-          if @machine.provider_config.use_linked_clone \
-            && @machine.provider.pd_version_satisfies?('>= 11')
-
-            env[:ui].info I18n.t('vagrant_parallels.actions.vm.import.importing_linked',
-                                 :name => @machine.box.name)
-            opts = {
-              snapshot_id: snapshot_id(tpl_name),
-              linked: true
-            }
-            # Linked clone creation should not be concurrent [GH-206]
-            begin
-              @machine.env.lock("parallels_linked_clone") do
-                clone(env, tpl_name, opts)
-              end
-            rescue Vagrant::Errors::EnvironmentLockedError
-              sleep 1
-              retry
-            end
-          else
-            env[:ui].info I18n.t('vagrant.actions.vm.import.importing',
-                                 :name => @machine.box.name)
-            clone(env, tpl_name)
-          end
-
-          if @machine.provider_config.regen_src_uuid
-            @logger.info('Regenerate SourceVmUuid')
-            @machine.provider.driver.regenerate_src_uuid
-          end
-
-          # Remove 'Icon\r' file from VM home (bug in PD 11.0.0)
-          if @machine.provider.pd_version_satisfies?('= 11.0.0')
-            vm_home = @machine.provider.driver.read_settings.fetch('Home')
-            broken_icns = Dir[File.join(vm_home, 'Icon*')]
-            FileUtils.rm(broken_icns, :force => true)
-          end
-        end
-
-        def clone(env, tpl_name, opts={})
-          # Generate virtual machine name
-          vm_name = "#{tpl_name}_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
-
-          @machine.id = @machine.provider.driver.clone_vm(tpl_name, vm_name, opts) do |progress|
+        def clone_full(env)
+          env[:ui].info I18n.t('vagrant_parallels.actions.vm.clone.full')
+          env[:machine].id = env[:machine].provider.driver.clone_vm(
+            env[:clone_id]) do |progress|
             env[:ui].clear_line
             env[:ui].report_progress(progress, 100, false)
-
-            # # If we got interrupted, then the import could have been interrupted.
-            # Just rise an exception and then 'recover' will be called to cleanup.
-            raise Vagrant::Errors::VagrantInterrupt if env[:interrupted]
           end
 
           # Clear the line one last time since the progress meter doesn't disappear
@@ -143,26 +101,21 @@ module VagrantPlugins
           env[:ui].clear_line
         end
 
-        def snapshot_id(tpl_name)
-          snap_id = @machine.provider.driver.read_current_snapshot(tpl_name)
-
-          # If there is no current snapshot, just create the new one.
-          if !snap_id
-            @logger.info('Create a new snapshot')
-            opts = {
-              name: 'vagrant_linked_clone',
-              desc: 'Snapshot to create linked clones for Vagrant'
-            }
-            snap_id = @machine.provider.driver.create_snapshot(tpl_name, opts)
+        def clone_linked(env)
+          opts = {
+            snapshot_id: env[:clone_snapshot_id],
+            linked: true
+          }
+          env[:ui].info I18n.t('vagrant_parallels.actions.vm.clone.linked')
+          env[:machine].id = env[:machine].provider.driver.clone_vm(
+            env[:clone_id], opts) do |progress|
+            env[:ui].clear_line
+            env[:ui].report_progress(progress, 100, false)
           end
 
-          @logger.info("User this snapshot ID to create a linked clone: #{snap_id}")
-          snap_id
-        end
-
-        def unregister_template(tpl_name)
-          @logger.info("Unregister the box template: '#{tpl_name}'")
-          @machine.provider.driver.unregister(tpl_name)
+          # Clear the line one last time since the progress meter doesn't disappear
+          # immediately.
+          env[:ui].clear_line
         end
       end
     end