vagrant-parallels 0.2.1 → 0.2.2.rc1

data/lib/vagrant-parallels/action.rb

@@ -261,11 +261,8 @@ module VagrantPlugins
             # If the VM is NOT created yet, then do the setup steps
             if !env[:result]
               b2.use CheckAccessible
-              b2.use RegisterTemplate
               b2.use Customize, "pre-import"
               b2.use Import
-              b2.use UnregisterTemplate
-              b2.use MatchMACAddress
             end
           end
           b.use action_start
@@ -288,7 +285,6 @@ module VagrantPlugins
       autoload :Import, File.expand_path("../action/import", __FILE__)
       autoload :IsSuspended, File.expand_path("../action/is_suspended", __FILE__)
       autoload :IsRunning, File.expand_path("../action/is_running", __FILE__)
-      autoload :MatchMACAddress, File.expand_path("../action/match_mac_address", __FILE__)
       autoload :MessageAlreadyRunning, File.expand_path("../action/message_already_running", __FILE__)
       autoload :MessageNotCreated, File.expand_path("../action/message_not_created", __FILE__)
       autoload :MessageNotRunning, File.expand_path("../action/message_not_running", __FILE__)
@@ -298,13 +294,10 @@ module VagrantPlugins
       autoload :PackageConfigFiles, File.expand_path("../action/package_config_files", __FILE__)
       autoload :PrepareNFSSettings, File.expand_path("../action/prepare_nfs_settings", __FILE__)
       autoload :PrepareNFSValidIds, File.expand_path("../action/prepare_nfs_valid_ids", __FILE__)
-      autoload :RegisterTemplate, File.expand_path("../action/register_template", __FILE__)
       autoload :Resume, File.expand_path("../action/resume", __FILE__)
       autoload :SetupPackageFiles, File.expand_path("../action/setup_package_files", __FILE__)
       autoload :SetName, File.expand_path("../action/set_name", __FILE__)
       autoload :Suspend, File.expand_path("../action/suspend", __FILE__)
-      autoload :UnregisterTemplate, File.expand_path("../action/unregister_template", __FILE__)
-
     end
   end
 end

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

@@ -12,7 +12,7 @@ module VagrantPlugins
             # is a very bad situation and can only be fixed by the user. It
             # also prohibits us from actually doing anything with the virtual
             # machine, so we raise an error.
-            raise Vagrant::Errors::VMInaccessible
+            raise VagrantPlugins::Parallels::Errors::VMInaccessible
           end
 
           @app.call(env)

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

@@ -4,9 +4,17 @@ module VagrantPlugins
       class CheckGuestTools
         def initialize(app, env)
           @app = app
+          @logger = Log4r::Logger.new("vagrant::plugins::parallels::check_guest_tools")
         end
 
         def call(env)
+          if !env[:machine].provider_config.check_guest_tools
+            @logger.info("Not checking guest tools because configuration")
+            return @app.call(env)
+          end
+
+          env[:ui].info(I18n.t("vagrant_parallels.parallels.checking_guest_tools"))
+
           tools_version = env[:machine].provider.driver.read_guest_tools_version
           if !tools_version
             env[:ui].warn I18n.t("vagrant_parallels.actions.vm.check_guest_tools.not_detected")
@@ -14,8 +22,8 @@ module VagrantPlugins
             pd_version = env[:machine].provider.driver.version
             unless pd_version.start_with? tools_version
               env[:ui].warn(I18n.t("vagrant_parallels.actions.vm.check_guest_tools.version_mismatch",
-                                   tools_version: tools_version,
-                                   parallels_version: pd_version))
+                                   :tools_version => tools_version,
+                                   :parallels_version => pd_version))
             end
           end
 

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

@@ -9,7 +9,7 @@ module VagrantPlugins
         def call(env)
           # Delete all disabled network adapters
           env[:ui].info I18n.t("vagrant.actions.vm.clear_network_interfaces.deleting")
-          env[:machine].provider.driver.delete_adapters
+          env[:machine].provider.driver.delete_disabled_adapters
 
           @app.call(env)
         end

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

@@ -25,11 +25,13 @@ module VagrantPlugins
                 arg.to_s
               end
 
-              result = env[:machine].provider.driver.set_vm_settings(processed_command)
-              if result.exit_code != 0
+              begin
+                env[:machine].provider.driver.execute_command(
+                  processed_command + [retryable: true])
+              rescue VagrantPlugins::Parallels::Errors::PrlCtlError => e
                 raise Vagrant::Errors::VMCustomizationFailed, {
-                    :command => processed_command.inspect,
-                    :error   => result.stderr
+                  :command => command,
+                  :error   => e.inspect
                 }
               end
             end

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

@@ -2,50 +2,94 @@ module VagrantPlugins
   module Parallels
     module Action
       class Export
-        include Util
-
         def initialize(app, env)
           @app = app
+          @logger = Log4r::Logger.new("vagrant::plugins::parallels::export")
         end
 
         def call(env)
           @env = env
+          if env[:machine].provider.state.id != :stopped
+            raise Vagrant::Errors::VMPowerOffToPackage
+          end
+
+          name = "#{env[:root_path].basename.to_s}_#{env[:machine].name}"
+          name.gsub!(/[^-a-z0-9_]/i, "")
+
+          # Check the name is not in use
+          if @env[:machine].provider.driver.read_vms.has_key?(@template_name)
+            @template_name << rand(100000).to_s
+          end
 
-          raise Vagrant::Errors::VMPowerOffToPackage if \
-            @env[:machine].provider.state.id != :stopped
 
-          export
-          compact
+          @template_name = gen_template_name
+          @template_uuid = export
+          compact_template
+          unregister_template
 
           @app.call(env)
         end
 
-        def export
-          temp_vm_name = generate_name(@env[:root_path], '_export')
+        def recover(env)
+          @env = env
+          unregister_template
+        end
+
+        private
+
+        def gen_template_name
+          # Use configured name if it is specified, or generate the new one
+          name = @env[:machine].provider_config.name
+          if !name
+            name = "#{@env[:root_path].basename.to_s}_#{@env[:machine].name}"
+            name.gsub!(/[^-a-z0-9_]/i, "")
+          end
+          tpl_name = "#{name}_box"
 
+          # Ensure that the name is not in use
+          if @env[:machine].provider.driver.read_vms.has_key?(tpl_name)
+            tpl_name << "_#{rand(1000)}"
+          end
+
+          tpl_name
+        end
+
+        def export
           @env[:ui].info I18n.t("vagrant.actions.vm.export.exporting")
-          @temp_vm_uuid = @env[:machine].provider.driver.export(@env["export.temp_dir"], temp_vm_name) do |progress|
+          tpl_uuid = @env[:machine].provider.driver.export(@env["export.temp_dir"], @template_name) 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 a final time so the next data can appear
           # alone on the line.
           @env[:ui].clear_line
+
+          tpl_uuid
         end
 
-        def compact
+        def compact_template
           @env[:ui].info I18n.t("vagrant_parallels.actions.vm.export.compacting")
-          @env[:machine].provider.driver.compact(@temp_vm_uuid) do |progress|
+          @env[:machine].provider.driver.compact(@template_uuid) do |progress|
             @env[:ui].clear_line
             @env[:ui].report_progress(progress, 100, false)
           end
-          @env[:machine].provider.driver.unregister(@temp_vm_uuid)
 
           # Clear the line a final time so the next data can appear
           # alone on the line.
           @env[:ui].clear_line
         end
+
+        def unregister_template
+          if @env[:machine].provider.driver.registered?(@template_uuid)
+            @logger.info("Unregister the box template: '#{@template_uuid}'")
+            @env[:machine].provider.driver.unregister(@template_uuid)
+          end
+        end
       end
     end
   end

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

@@ -2,41 +2,17 @@ module VagrantPlugins
   module Parallels
     module Action
       class Import
-
-        include Util
-
         def initialize(app, env)
           @app = app
+          @logger = Log4r::Logger.new("vagrant::plugins::parallels::import")
         end
 
-        #TODO: Clean up registered VM on interupt
         def call(env)
-          env[:ui].info I18n.t("vagrant.actions.vm.import.importing",
-                               :name => env[:machine].box.name)
-
-          vm_name = generate_name(env[:root_path])
-
-          # Verify the name is not taken
-          if env[:machine].provider.driver.read_all_names.has_key?(vm_name)
-            raise Vagrant::Errors::VMNameExists, :name => vm_name
-          end
-
-          # Import the virtual machine
-          template_path = File.realpath(Pathname.glob(env[:machine].box.directory.join('*.pvm')).first)
-          template_uuid = env[:machine].provider.driver.read_all_paths[template_path]
-
-          env[:machine].id = env[:machine].provider.driver.import(template_uuid, vm_name) do |progress|
-            env[:ui].clear_line
-            env[:ui].report_progress(progress, 100, false)
-          end
-
-          # Clear the line one last time since the progress meter doesn't disappear
-          # immediately.
-          env[:ui].clear_line
-
-          # If we got interrupted, then the import could have been
-          # interrupted and its not a big deal. Just return out.
-          return if env[:interrupted]
+          @env = env
+          @template_path = File.realpath(Pathname.glob(env[:machine].box.directory.join('*.pvm')).first)
+          @template_uuid = register_template
+          import
+          unregister_template
 
           # Flag as erroneous and return if import failed
           raise Vagrant::Errors::VMImportFailure if !env[:machine].id
@@ -46,8 +22,13 @@ module VagrantPlugins
         end
 
         def recover(env)
+          @env = env
+          # We should to unregister template
+          unregister_template
+
           if env[:machine].provider.state.id != :not_created
             return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+            return if env["vagrant_parallels.error"].is_a?(VagrantPlugins::Parallels::Errors::VagrantParallelsError)
 
             # If we're not supposed to destroy on error then just return
             return if !env[:destroy_on_error]
@@ -61,6 +42,44 @@ module VagrantPlugins
             env[:action_runner].run(Action.action_destroy, destroy_env)
           end
         end
+
+        protected
+
+        def register_template
+          if !@env[:machine].provider.driver.read_vms_paths.has_key?(@template_path)
+            @logger.info("Register the box template: '#{@template_path}'")
+            @env[:machine].provider.driver.register(@template_path)
+          end
+
+          # Return the uuid of registered template
+          @env[:machine].provider.driver.read_vms_paths[@template_path]
+        end
+
+        def import
+          @env[:ui].info I18n.t("vagrant.actions.vm.import.importing",
+                               :name => @env[:machine].box.name)
+
+          # Import the virtual machine
+          @env[:machine].id = @env[:machine].provider.driver.import(@template_uuid) 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
+          # immediately.
+          @env[:ui].clear_line
+        end
+
+        def unregister_template
+          if @env[:machine].provider.driver.registered?(@template_uuid)
+            @logger.info("Unregister the box template: '#{@template_uuid}'")
+            @env[:machine].provider.driver.unregister(@template_uuid)
+          end
+        end
       end
     end
   end

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

@@ -24,11 +24,15 @@ module VagrantPlugins
 
         def call(env)
           @env = env
+
           # Get the list of network adapters from the configuration
           network_adapters_config = env[:machine].provider_config.network_adapters.dup
 
+          # Get maximum number of network adapters
+          max_adapters = env[:machine].provider.driver.max_network_adapters
+
           # Assign the adapter slot for each high-level network
-          available_slots = Set.new(0..7)
+          available_slots = Set.new(0...max_adapters)
           network_adapters_config.each do |slot, _data|
             available_slots.delete(slot)
           end
@@ -56,10 +60,10 @@ module VagrantPlugins
             data = nil
             if type == :private_network
               # private_network = hostonly
-              data        = [:hostonly, options]
+              data = [:hostonly, options]
             elsif type == :public_network
               # public_network = bridged
-              data        = [:bridged, options]
+              data = [:bridged, options]
             end
 
             # Store it!
@@ -69,6 +73,7 @@ module VagrantPlugins
 
           @logger.info("Determining adapters and compiling network configuration...")
           adapters = []
+          networks = []
           network_adapters_config.each do |slot, data|
             type    = data[0]
             options = data[1]
@@ -84,29 +89,53 @@ module VagrantPlugins
             adapter = send("#{type}_adapter", config)
             adapters << adapter
             @logger.debug("Adapter configuration: #{adapter.inspect}")
+
+            # Get the network configuration
+            network = send("#{type}_network_config", config)
+            network[:auto_config] = config[:auto_config]
+            networks << network
           end
 
           if !adapters.empty?
             # Enable the adapters
             @logger.info("Enabling adapters...")
-            env[:ui].info I18n.t("vagrant.actions.vm.network.preparing")
+            env[:ui].info(I18n.t("vagrant.actions.vm.network.preparing"))
+            adapters.each do |adapter|
+              env[:ui].info(I18n.t(
+                "vagrant_parallels.parallels.network_adapter",
+                adapter: adapter[:adapter].to_s,
+                type: adapter[:type].to_s,
+                extra: "",
+              ))
+            end
+
             env[:machine].provider.driver.enable_adapters(adapters)
           end
 
           # Continue the middleware chain.
           @app.call(env)
 
-        end
+          # 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?
+            assign_interface_numbers(networks, adapters)
 
-        def bridged_config(options)
-          if options[:type] and options[:type].to_sym == :dhcp
-            options[:dhcp] = true
+            # Only configure the networks the user requested us to configure
+            networks_to_configure = networks.select { |n| n[:auto_config] }
+            if !networks_to_configure.empty?
+              env[:ui].info I18n.t("vagrant.actions.vm.network.configuring")
+              env[:machine].guest.capability(:configure_networks, networks_to_configure)
+            end
           end
+        end
 
+        def bridged_config(options)
           return {
-              :bridge    => nil,
-              :mac       => nil,
-              :nic_type  => "e1000",
+            :auto_config                     => true,
+            :bridge                          => nil,
+            :mac                             => nil,
+            :nic_type                        => nil,
+            :use_dhcp_assigned_default_route => false
           }.merge(options || {})
         end
 
@@ -175,24 +204,40 @@ module VagrantPlugins
 
           # Given the choice we can now define the adapter we're using
           return {
-              :adapter     => config[:adapter],
-              :type        => :bridged,
-              :bridge      => chosen_bridge[:name],
-              :bound_to    => chosen_bridge[:bound_to],
-              :mac_address => config[:mac],
-              :dhcp        => config[:dhcp],
-              :ip          => config[:ip],
-              :netmask     => config[:netmask],
-              :nic_type    => config[:nic_type]
+            :adapter     => config[:adapter],
+            :type        => :bridged,
+            :bridge      => chosen_bridge[:name],
+            :bound_to    => chosen_bridge[:bound_to],
+            :mac_address => config[:mac],
+            :nic_type    => config[:nic_type]
+          }
+        end
+
+        def bridged_network_config(config)
+          if config[:ip]
+            options = {
+                :auto_config => true,
+                :mac         => nil,
+                :netmask     => "255.255.255.0",
+                :type        => :static
+            }.merge(config)
+            options[:type] = options[:type].to_sym
+            return options
+          end
+
+          return {
+            :type => :dhcp,
+            :use_dhcp_assigned_default_route => config[:use_dhcp_assigned_default_route]
           }
         end
 
         def hostonly_config(options)
           options = {
-              :mac         => nil,
-              :nic_type    => "e1000",
-              :netmask     => "255.255.255.0",
-              :type        => :static
+            :auto_config => true,
+            :mac         => nil,
+            :nic_type    => nil,
+            :netmask     => "255.255.255.0",
+            :type        => :static
           }.merge(options)
 
           # Make sure the type is a symbol
@@ -229,14 +274,14 @@ module VagrantPlugins
           dhcp_options = {}
           if options[:type] == :dhcp
             # Calculate the DHCP server IP, which is the network address
-            # with the final octet + 2. So "172.28.0.0" turns into "172.28.0.2"
+            # with the final octet + 1. So "172.28.0.0" turns into "172.28.0.1"
             dhcp_ip    = ip_parts.dup
-            dhcp_ip[3] += 2
+            dhcp_ip[3] += 1
             dhcp_options[:dhcp_ip] ||= dhcp_ip.join(".")
 
             # Calculate the lower and upper bound for the DHCP server
             dhcp_lower    = ip_parts.dup
-            dhcp_lower[3] += 3
+            dhcp_lower[3] += 2
             dhcp_options[:dhcp_lower] ||= dhcp_lower.join(".")
 
             dhcp_upper    = ip_parts.dup
@@ -245,12 +290,13 @@ module VagrantPlugins
           end
 
           return {
-              :adapter_ip  => options[:adapter_ip],
-              :ip          => options[:ip],
-              :mac         => options[:mac],
-              :netmask     => options[:netmask],
-              :nic_type    => options[:nic_type],
-              :type        => options[:type],
+            :adapter_ip  => options[:adapter_ip],
+            :auto_config => options[:auto_config],
+            :ip          => options[:ip],
+            :mac         => options[:mac],
+            :netmask     => options[:netmask],
+            :nic_type    => options[:nic_type],
+            :type        => options[:type]
           }.merge(dhcp_options)
         end
 
@@ -273,35 +319,78 @@ module VagrantPlugins
           end
 
           return {
-              :adapter  => config[:adapter],
-              :hostonly => interface[:name],
-              :bound_to => interface[:bound_to],
-              :mac      => config[:mac],
-              :nic_type => config[:nic_type],
-              :type     => :hostonly,
-              :dhcp     => interface[:dhcp],
-              :ip       => config[:ip],
-              :netmask  => config[:netmask],
+            :adapter  => config[:adapter],
+            :hostonly => interface[:name],
+            :bound_to => interface[:bound_to],
+            :mac      => config[:mac],
+            :nic_type => config[:nic_type],
+            :type     => :hostonly
           }
         end
 
+        def hostonly_network_config(config)
+          return {
+            :type       => config[:type],
+            :adapter_ip => config[:adapter_ip],
+            :ip         => config[:ip],
+            :netmask    => config[:netmask]
+          }
+        end
+
+
         def shared_config(options)
-          return  {}
+          return {
+            :auto_config => false
+          }
         end
 
         def shared_adapter(config)
           return {
-              :adapter => config[:adapter],
-              :shared  => "Shared",
-              :type    => :shared,
-              :dhcp     => true,
-              :nic_type => "e1000"
+            :adapter => config[:adapter],
+            :type    => :shared
           }
         end
 
+        def shared_network_config(config)
+          return {}
+        end
+
         #-----------------------------------------------------------------
         # Misc. helpers
         #-----------------------------------------------------------------
+        # Assigns the actual interface number of a network based on the
+        # enabled NICs on the virtual machine.
+        #
+        # This interface number is used by the guest to configure the
+        # NIC on the guest VM.
+        #
+        # The networks are modified in place by adding an ":interface"
+        # field to each.
+        def assign_interface_numbers(networks, adapters)
+          current = 0
+          adapter_to_interface = {}
+
+          # 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
+          end
+
+          # Make a pass through the adapters to assign the :interface
+          # key to each network configuration.
+          adapters.each_index do |i|
+            adapter = adapters[i]
+            network = networks[i]
+
+            # Figure out the interface number by simple lookup
+            network[:interface] = adapter_to_interface[adapter[:adapter]]
+          end
+        end
+
         # This determines the next free network name
         def next_network_name
           # Get the list of numbers