vagrant-parallels 0.2.1 → 0.2.2.rc1

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

@@ -14,21 +14,9 @@ module VagrantPlugins
         def call(env)
           @env = env
           create_metadata
-          create_vagrantfile
           @app.call(env)
         end
 
-        # This method creates the auto-generated Vagrantfile at the root of the
-        # box. This Vagrantfile contains the MAC address so that the user doesn't
-        # have to worry about it.
-        def create_vagrantfile
-          File.open(File.join(@env["export.temp_dir"], "Vagrantfile"), "w") do |f|
-            f.write(TemplateRenderer.render("package_Vagrantfile", {
-              :base_mac => @env[:machine].provider.driver.read_mac_address
-            }))
-          end
-        end
-
         def create_metadata
           File.open(File.join(@env["export.temp_dir"], "metadata.json"), "w") do |f|
             f.write(template_metadatafile)

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

@@ -8,7 +8,7 @@ module VagrantPlugins
         end
 
         def call(env)
-          env[:nfs_valid_ids] = env[:machine].provider.driver.read_all_names.values
+          env[:nfs_valid_ids] = env[:machine].provider.driver.read_vms.values
           @app.call(env)
         end
       end

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

@@ -28,8 +28,8 @@ module VagrantPlugins
           end
 
           # Verify the name is not taken
-          vms_names = env[:machine].provider.driver.read_all_names
-          raise Vagrant::Errors::VMNameExists, :name => name if \
+          vms_names = env[:machine].provider.driver.read_vms
+          raise VagrantPlugins::Parallels::Errors::VMNameExists, :name => name if \
             vms_names.has_key?(name) && vms_names[name] != env[:machine].id
 
           if vms_names.has_key?(name)

data/lib/vagrant-parallels/config.rb

@@ -1,12 +1,17 @@
 module VagrantPlugins
   module Parallels
     class Config < Vagrant.plugin("2", :config)
+      attr_accessor :check_guest_tools
       attr_reader :customizations
       attr_accessor :destroy_unused_network_interfaces
       attr_reader :network_adapters
       attr_accessor :name
 
+      # Compatibility with virtualbox provider's syntax
+      alias :check_guest_additions= :check_guest_tools=
+
       def initialize
+        @check_guest_tools = UNSET_VALUE
         @customizations   = []
         @destroy_unused_network_interfaces = UNSET_VALUE
         @network_adapters  = {}
@@ -21,8 +26,8 @@ module VagrantPlugins
         @customizations << [event, command]
       end
 
-      def network_adapter(slot, type, *args)
-        @network_adapters[slot] = [type, args]
+      def network_adapter(slot, type, **opts)
+        @network_adapters[slot] = [type, opts]
       end
 
       # @param size [Integer, String] the memory size in MB
@@ -35,6 +40,10 @@ module VagrantPlugins
       end
 
       def finalize!
+        if @check_guest_tools == UNSET_VALUE
+          @check_guest_tools = true
+        end
+
         if @destroy_unused_network_interfaces == UNSET_VALUE
           @destroy_unused_network_interfaces = true
         end

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

@@ -0,0 +1,281 @@
+require 'log4r'
+
+require 'vagrant/util/busy'
+require 'vagrant/util/network_ip'
+require 'vagrant/util/platform'
+require 'vagrant/util/retryable'
+require 'vagrant/util/subprocess'
+
+module VagrantPlugins
+  module Parallels
+    module Driver
+      # Base class for all Parallels drivers.
+      #
+      # This class provides useful tools for things such as executing
+      # PrlCtl and handling SIGINTs and so on.
+      class Base
+        # Include this so we can use `Subprocess` more easily.
+        include Vagrant::Util::Retryable
+        include Vagrant::Util::NetworkIP
+
+        def initialize
+          @logger = Log4r::Logger.new("vagrant::provider::parallels::base")
+
+          # This flag is used to keep track of interrupted state (SIGINT)
+          @interrupted = false
+
+          # Set the list of required CLI utils
+          @cli_paths = {
+            :prlctl        => "prlctl",
+            :prlsrvctl     => "prlsrvctl",
+            :prl_disk_tool => "prl_disk_tool",
+            :ifconfig      => "ifconfig"
+          }
+
+          @cli_paths.each do |name, path|
+            @logger.info("CLI utility '#{name}' path: #{path}")
+          end
+        end
+
+        # Clears the shared folders that have been set on the virtual machine.
+        def clear_shared_folders
+        end
+
+        # Creates a host only network with the given options.
+        #
+        # @param [Hash] options Options to create the host only network.
+        # @return [Hash] The details of the host only network, including
+        #   keys `:name`, `:bound_to`, `:ip`, `:netmask` and `:dhcp`
+        def create_host_only_network(options)
+        end
+
+        # Deletes the virtual machine references by this driver.
+        def delete
+        end
+
+        # Deletes all disabled network adapters from the VM configuration
+        def delete_disabled_adapters
+        end
+
+        # Deletes any host only networks that aren't being used for anything.
+        def delete_unused_host_only_networks
+        end
+
+        # Enables network adapters on the VM.
+        #
+        # The format of each adapter specification should be like so:
+        #
+        # {
+        #   :type     => :hostonly,
+        #   :hostonly => "vagrant-vnet0",
+        #   :bound_to => "vnic2",
+        #   :nic_type => "virtio"
+        # }
+        #
+        # This must support setting up both host only and bridged networks.
+        #
+        # @param [Array<Hash>] adapters Array of adapters to enable.
+        def enable_adapters(adapters)
+        end
+
+        # Execute a raw command straight through to 'prlctl' utility
+        #
+        # Accepts a :prlsrvctl as a first element of command if the command
+        # should be executed through to 'prlsrvctl' utility
+        #
+        # Accepts a :retryable => true option if the command should be retried
+        # upon failure.
+        #
+        # Raises a prlctl error if it fails.
+        #
+        # @param [Array] command Command to execute.
+        def execute_command(command)
+        end
+
+        # Exports the virtual machine to the given path.
+        #
+        # @param [String] path Path to the OVF file.
+        # @yield [progress] Yields the block with the progress of the export.
+        def export(path)
+        end
+
+        # Halts the virtual machine (pulls the plug).
+        def halt
+        end
+
+        # Imports the VM by cloning from registered template.
+        #
+        # @param [String] template_uuid Registered template UUID.
+        # @return [String] UUID of the imported VM.
+        def import(template_uuid)
+        end
+
+        # Parses given block (JSON string) to object
+        def json(default=nil)
+          data = yield
+          JSON.parse(data) rescue default
+        end
+
+        # Returns the maximum number of network adapters.
+        def max_network_adapters
+          16
+        end
+
+        # Returns a list of bridged interfaces.
+        #
+        # @return [Hash]
+        def read_bridged_interfaces
+        end
+
+        # Returns the guest tools version that is installed on this VM.
+        #
+        # @return [String]
+        def read_guest_tools_version
+        end
+
+        # Returns a list of available host only interfaces.
+        #
+        # @return [Hash]
+        def read_host_only_interfaces
+        end
+
+        # Returns the MAC address of the first network interface.
+        #
+        # @return [String]
+        def read_mac_address
+        end
+
+        # Returns a list of network interfaces of the VM.
+        #
+        # @return [Hash]
+        def read_network_interfaces
+        end
+
+        # Returns the current state of this VM.
+        #
+        # @return [Symbol]
+        def read_state
+        end
+
+        # Returns a list of all registered
+        # virtual machines and templates.
+        #
+        # @return [Hash]
+        def read_vms
+        end
+
+        # Resumes the virtual machine.
+        #
+        def resume(mac)
+        end
+
+        # Sets the MAC address of the first network adapter.
+        #
+        # @param [String] mac MAC address without any spaces/hyphens.
+        def set_mac_address(mac)
+        end
+
+        # Sets the VM name.
+        #
+        # @param [String] name New VM name.
+        def set_name(name)
+        end
+
+        # Share a set of folders on this VM.
+        #
+        # @param [Array<Hash>] folders
+        def share_folders(folders)
+        end
+
+        # Reads the SSH port of this VM.
+        #
+        # @param [Integer] expected Expected guest port of SSH.
+        def ssh_port(expected)
+        end
+
+        # Starts the virtual machine.
+        #
+        def start
+        end
+
+        # Suspend the virtual machine.
+        def suspend
+        end
+
+        # Verifies that the driver is ready to accept work.
+        #
+        # This should raise a VagrantError if things are not ready.
+        def verify!
+        end
+
+        # Checks if a VM with the given UUID exists.
+        #
+        # @return [Boolean]
+        def vm_exists?(uuid)
+        end
+
+        # Execute the given subcommand for PrlCtl and return the output.
+        def execute(*command, &block)
+          # Get the options hash if it exists
+          opts = {}
+          opts = command.pop if command.last.is_a?(Hash)
+
+          tries = opts[:retryable] ? 3 : 0
+
+          # Variable to store our execution result
+          r = nil
+
+          retryable(:on => VagrantPlugins::Parallels::Errors::PrlCtlError, :tries => tries, :sleep => 1) do
+            # If there is an error with PrlCtl, this gets set to true
+            errored = false
+
+            # Execute the command
+            r = raw(*command, &block)
+
+            # If the command was a failure, then raise an exception that is
+            # nicely handled by Vagrant.
+            if r.exit_code != 0
+              if @interrupted
+                @logger.info("Exit code != 0, but interrupted. Ignoring.")
+              else
+                errored = true
+              end
+            end
+
+            # If there was an error running prlctl, show the error and the
+            # output.
+            if errored
+              raise VagrantPlugins::Parallels::Errors::PrlCtlError,
+                :command => command.inspect,
+                :stderr  => r.stderr
+            end
+          end
+          r.stdout
+        end
+
+        # Executes a command and returns the raw result object.
+        def raw(*command, &block)
+          int_callback = lambda do
+            @interrupted = true
+
+            # We have to execute this in a thread due to trap contexts
+            # and locks.
+            Thread.new { @logger.info("Interrupted.") }
+          end
+
+          # Append in the options for subprocess
+          command << { :notify => [:stdout, :stderr] }
+
+          # Get the utility from the first argument:
+          # 'prlctl' by default
+          util = @cli_paths.has_key?(command.first) ? command.delete_at(0) : :prlctl
+          cli = @cli_paths[util]
+
+          Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute(cli, *command, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+require "forwardable"
+
+require "log4r"
+
+require File.expand_path("../base", __FILE__)
+
+module VagrantPlugins
+  module Parallels
+    module Driver
+      class Meta < Base
+        # This is raised if the VM is not found when initializing a driver
+        # with a UUID.
+        class VMNotFound < StandardError; end
+
+        # We use forwardable to do all our driver forwarding
+        extend Forwardable
+
+        # The UUID of the virtual machine we represent
+        attr_reader :uuid
+
+        # The version of Parallels Desktop that is running.
+        attr_reader :version
+
+        def initialize(uuid=nil)
+          # Setup the base
+          super()
+
+          @logger = Log4r::Logger.new("vagrant::provider::parallels::meta")
+          @uuid = uuid
+
+          # Read and assign the version of Parallels Desktop we know which
+          # specific driver to instantiate.
+          begin
+            @version = read_version || ""
+          rescue Vagrant::Errors::CommandUnavailable,
+            Vagrant::Errors::CommandUnavailableWindows
+            # This means that Parallels Desktop was not found, so we raise this
+            # error here.
+            raise VagrantPlugins::Parallels::Errors::ParallelsNotDetected
+          end
+
+          # Instantiate the proper version driver for VirtualBox
+          @logger.debug("Finding driver for Parallels Desktop version: #{@version}")
+          driver_map   = {
+            #TODO: Use customized class for each version
+            "8" => PD_8,
+            "9" => PD_9,
+            "10" => PD_9
+          }
+
+          driver_klass = nil
+          driver_map.each do |key, klass|
+            if @version.start_with?(key)
+              driver_klass = klass
+              break
+            end
+          end
+
+          if !driver_klass
+            supported_versions = driver_map.keys.sort.join(", ")
+            raise VagrantPlugins::Parallels::Errors::ParallelsInvalidVersion,
+                  supported_versions: supported_versions
+          end
+
+          @logger.info("Using Parallels driver: #{driver_klass}")
+          @driver = driver_klass.new(@uuid)
+
+          if @uuid
+            # Verify the VM exists, and if it doesn't, then don't worry
+            # about it (mark the UUID as nil)
+            raise VMNotFound if !@driver.vm_exists?(@uuid)
+          end
+        end
+
+        def_delegators :@driver,
+                       #:clear_forwarded_ports,
+                       :clear_shared_folders,
+                       :compact,
+                       :create_host_only_network,
+                       :delete,
+                       :delete_disabled_adapters,
+                       :delete_unused_host_only_networks,
+                       :enable_adapters,
+                       :execute_command,
+                       :export,
+                       #:forward_ports,
+                       :halt,
+                       :import,
+                       :read_ip_dhcp,
+                       #:read_forwarded_ports,
+                       :read_bridged_interfaces,
+                       :read_guest_tools_version,
+                       :read_guest_ip,
+                       :read_guest_property,
+                       :read_host_only_interfaces,
+                       :read_mac_address,
+                       :read_network_interfaces,
+                       :read_settings,
+                       :read_state,
+                       :read_used_ports,
+                       :read_virtual_networks,
+                       :read_vms,
+                       :read_vms_info,
+                       :read_vms_paths,
+                       :register,
+                       :registered?,
+                       :resume,
+                       :set_mac_address,
+                       :set_name,
+                       :share_folders,
+                       :ssh_port,
+                       :start,
+                       :suspend,
+                       :unregister,
+                       :verify!,
+                       :vm_exists?
+
+        protected
+
+        # This returns the version of Parallels Desktop that is running.
+        #
+        # @return [String]
+        def read_version
+          # The version string is usually in one of the following formats:
+          #
+          # * 8.0.12345.123456
+          # * 9.0.12345.123456
+
+          if execute('--version', retryable: true) =~ /prlctl version ([\d\.]+)/
+            return $1.downcase
+          else
+            return nil
+          end
+        end
+      end
+    end
+  end
+end