vagrant-parallels 0.0.4 → 0.0.5

data/.gitignore

@@ -21,3 +21,4 @@ Vagrantfile
 .vagrant
 *.box
 *.pyc
+sandi_meter

data/README.md

@@ -1,14 +1,14 @@
 # Vagrant Parallels Provider
 
-This is a [Vagrant](http://www.vagrantup.com) 1.3+ plugin that adds an [Parallels Desktop](http://www.parallels.com/products/desktop/)
-provider to Vagrant, allowing Vagrant to control and provision machines using Parallels Desktop insead of the default Virtualbox.
+This is a [Vagrant](http://www.vagrantup.com) 1.3+ plugin that adds a [Parallels Desktop](http://www.parallels.com/products/desktop/)
+provider to Vagrant, allowing Vagrant to control and provision machines using Parallels Desktop instead of the default Virtualbox.
 
 ## Note
 
-This project is still in active development and not all vagrant features have been developed, please report any issues you might find.
-Almost all features are available except for exporting/packaging VM's this will be available soon.
+This project is still in active development and not all vagrant features have been developed, so please report any issues you might find.
+Almost all features are available except for exporting/packaging VM's.  This will be available soon.
 
-We look forward to hearing from you with any issues or features, Thank you
+We look forward to hearing from you with any issues or features.  Thank you!
 
 ## Usage
 Install using standard Vagrant 1.1+ plugin installation methods. After installing, then do a `vagrant up` and specify the `parallels` provider. An example is shown below.
@@ -21,7 +21,27 @@ $ vagrant up --provider=parallels
 ...
 ```
 
-You need to have a paralles compatible box file installed before doing a `vagrnat up`, please refer to the coming section for instaructions.
+You need to have a parallels compatible box file installed before doing a `vagrant up`, please refer to the coming section for instructions.
+
+### Default Provider
+
+When using parallels as your vagrant provider after almost every command you will need to append `--provider=parallels`. To simplify this you can set your default vagrant provider as **parallels**
+
+If you're using BASH
+
+```
+# Append to bash
+echo "export VAGRANT_DEFAULT_PROVIDER=parallels" | tee -a ~/.bashrc
+source ~/.bashrc
+```
+
+If you're using ZSH
+
+```
+# Append to zsh
+echo "export VAGRANT_DEFAULT_PROVIDER=parallels" | tee -a ~/.zshrc
+source ~/.zshrc
+```
 
 ## Box Format
 
@@ -40,6 +60,29 @@ The box format is basically just the required `metadata.json` file
 along with a `Vagrantfile` that does default settings for the
 provider-specific configuration for this provider.
 
+## Networking
+By default 'vagrant-parallels' uses the basic Vagrant networking approach. By default VM has one adapter assigned to the 'Shared' network in Parallels Desktop.
+But you can also add one ore more `:private_network` adapters, as described below: 
+
+### Private Network
+It is fully compatible with basic Vagrant [Private Networking](http://docs.vagrantup.com/v2/networking/private_network.html). 
+#### Available arguments:
+- `type` - IP configuration way: `:static` or `:dhcp`. Default is `:static`. If `:dchp` is set, such interface will get an IP dynamically from default subnet "10.37.129.1/255.255.255.0".
+- `ip` - IP address which will be assigned to this network adapter. It is required only if type is `:static`.
+- `netmask` - network mask. Default is `"255.255.255.0"`. It is required only if type is `:static`.
+- `nic_type` - Unnecessary argument, means the type of network adapter. Can be any of `"virtio"`, `"e1000"` or `"rtl"`. Default is `"e1000"`.
+
+#### Example:
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.network :private_network, ip: "33.33.33.50", netmask: "255.255.0.0" 
+  config.vm.network :private_network, type: :dhcp, nic_type: "rtl"
+end
+```
+It means that two private network adapters will be configured: 
+1) The first will have static ip '33.33.33.50' and mask '255.255.0.0'. It will be represented as device `"e1000"` by default (e.g. 'Intel(R) PRO/1000 MT').
+2) The second adapter will be configured as `"rtl"` ('Realtek RTL8029AS') and get an IP from internal DHCP server, which is working on the default network "10.37.129.1/255.255.255.0".
+
 ## Development
 
 To work on the `vagrant-parallels` plugin, clone this repository out
@@ -70,7 +113,7 @@ and add the following line to your `Vagrantfile`
 Vagrant.require_plugin "vagrant-parallels"
 ```
 
-You need to have a compatable box file installed, refer to box file section
+You need to have a compatible box file installed, refer to box file section
 
 Use bundler to execute Vagrant:
 
@@ -89,4 +132,16 @@ $ rake build
 $ vagrant plugin install ./pkg/vagrant-parallels-<version>.gem
 ...
 ```
-So, now you have your own plugin installed, check it by command `vagrant plugin list`
+So, now that you have your own plugin installed, check it with the command `vagrant plugin list`
+
+## Contributors
+
+A great thanks to the people who helping this project stand on its feet, thank you
+
+* Kevin Kaland `@wizonesolutions`
+* Mikhail Zholobov `@legal90`
+* Dmytro Vasylenko `@odi-um`
+* Thomas Koschate `@koschate`
+
+and to all the people who are using and testing this tool
+

data/lib/vagrant-parallels/action.rb

@@ -23,12 +23,14 @@ module VagrantPlugins
           #b.use PrepareNFSSettings
           b.use ClearSharedFolders
           b.use ShareFolders
+          b.use Network
           b.use ClearNetworkInterfaces
-          # b.use Network
           # b.use ForwardPorts
           b.use SetHostname
           # b.use SaneDefaults
+          b.use Customize, "pre-boot"
           b.use Boot
+          b.use Customize, "post-boot"
           b.use WaitForCommunicator
           b.use CheckGuestTools
         end
@@ -53,6 +55,7 @@ module VagrantPlugins
                 b3.use action_halt
                 b3.use UnregisterTemplate
                 b3.use Destroy
+                b3.use DestroyUnusedNetworkInterfaces
               else
                 b3.use MessageWillNotDestroy
               end
@@ -255,6 +258,7 @@ module VagrantPlugins
               b2.use CheckAccessible
               b2.use HandleBoxUrl
               b2.use RegisterTemplate
+              b2.use Customize, "pre-import"
               b2.use Import
               b2.use UnregisterTemplate
               b2.use MatchMACAddress
@@ -274,7 +278,9 @@ module VagrantPlugins
       autoload :ClearNetworkInterfaces, File.expand_path("../action/clear_network_interfaces", __FILE__)
       autoload :ClearSharedFolders, File.expand_path("../action/clear_shared_folders", __FILE__)
       autoload :Created, File.expand_path("../action/created", __FILE__)
+      autoload :Customize, File.expand_path("../action/customize", __FILE__)
       autoload :Destroy, File.expand_path("../action/destroy", __FILE__)
+      autoload :DestroyUnusedNetworkInterfaces, File.expand_path("../action/destroy_unused_network_interfaces", __FILE__)
       autoload :Export, File.expand_path("../action/export", __FILE__)
       autoload :ForcedHalt, File.expand_path("../action/forced_halt", __FILE__)
       autoload :Import, File.expand_path("../action/import", __FILE__)
@@ -286,6 +292,7 @@ module VagrantPlugins
       autoload :MessageNotCreated, File.expand_path("../action/message_not_created", __FILE__)
       autoload :MessageNotRunning, File.expand_path("../action/message_not_running", __FILE__)
       autoload :MessageWillNotDestroy, File.expand_path("../action/message_will_not_destroy", __FILE__)
+      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 :PruneNFSExports, File.expand_path("../action/prune_nfs_exports", __FILE__)

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

@@ -7,8 +7,6 @@ module VagrantPlugins
         end
 
         def call(env)
-          # Use the raw interface for now, while the virtualbox gem
-          # doesn't support guest properties (due to cross platform issues)
           tools_version = env[:machine].provider.driver.read_guest_tools_version
           if !tools_version
             env[:ui].warn I18n.t("vagrant.actions.vm.check_guest_tools.not_detected")
@@ -16,7 +14,7 @@ module VagrantPlugins
             env[:machine].provider.driver.verify! =~ /^[\w\s]+ ([\d.]+)$/
             os_version = $1
             unless os_version.start_with? tools_version
-              env[:ui].warn(I18n.t("vagrant.actions.vm.check_guest_tools.version_mismatch",
+              env[:ui].warn(I18n.t("vagrant_parallels.actions.vm.check_guest_tools.version_mismatch",
                                    tools_version: tools_version,
                                    parallels_version: os_version))
             end

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

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

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

@@ -0,0 +1,43 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class Customize
+        def initialize(app, env, event)
+          @app = app
+          @event = event
+        end
+
+        def call(env)
+          customizations = []
+          env[:machine].provider_config.customizations.each do |event, command|
+            if event == @event
+              customizations << command
+            end
+          end
+
+          if !customizations.empty?
+            env[:ui].info I18n.t("vagrant.actions.vm.customize.running", event: @event)
+
+            # Execute each customization command.
+            customizations.each do |command|
+              processed_command = command.collect do |arg|
+                arg = env[:machine].id if arg == :id
+                arg.to_s
+              end
+
+              result = env[:machine].provider.driver.set_vm_settings(processed_command)
+              if result.exit_code != 0
+                raise Vagrant::Errors::VMCustomizationFailed, {
+                    :command => processed_command.inspect,
+                    :error   => result.stderr
+                }
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require "log4r"
+
+module VagrantPlugins
+  module Parallels
+    module Action
+      class DestroyUnusedNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].provider_config.destroy_unused_network_interfaces
+            env[:ui].info I18n.t("vagrant.actions.vm.destroy_network.destroying")
+            env[:machine].provider.driver.delete_unused_host_only_networks
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,272 @@
+require "set"
+
+require "log4r"
+
+require "vagrant/util/network_ip"
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module Parallels
+    module Action
+      # This middleware class sets up all networking for the Parallels Desktop
+      # instance. This includes host only networks, bridged networking,
+      # forwarded ports, etc.
+      #
+      # This handles all the `config.vm.network` configurations.
+      class Network
+        include Vagrant::Util::NetworkIP
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::plugins::parallels::network")
+        end
+
+        def call(env)
+          @env = env
+          # Get the list of network adapters from the configuration
+          network_adapters_config = env[:machine].provider_config.network_adapters.dup
+
+          # Assign the adapter slot for each high-level network
+          available_slots = Set.new(0..7)
+          network_adapters_config.each do |slot, _data|
+            available_slots.delete(slot)
+          end
+
+          @logger.debug("Available slots for high-level adapters: #{available_slots.inspect}")
+          @logger.info("Determining network adapters required for high-level configuration...")
+          available_slots = available_slots.to_a.sort
+          env[:machine].config.vm.networks.each do |type, options|
+            # We only handle private and public networks
+            next if type != :private_network && type != :public_network
+
+            options = scoped_hash_override(options, :parallels)
+
+            # 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
+
+              slot = available_slots.shift
+            end
+
+            # Configure it
+            data = nil
+            if type == :private_network
+              # private_network = hostonly
+              data        = [:hostonly, options]
+            elsif type == :public_network
+              # public_network = bridged
+              data        = [:bridged, options]
+            end
+
+            # Store it!
+            @logger.info(" -- Slot #{slot}: #{data[0]}")
+            network_adapters_config[slot] = data
+          end
+
+          @logger.info("Determining adapters and compiling network configuration...")
+          adapters = []
+          network_adapters_config.each do |slot, data|
+            type    = data[0]
+            options = data[1]
+
+            @logger.info("Network slot #{slot}. Type: #{type}.")
+
+            # Get the normalized configuration for this type
+            config = send("#{type}_config", options)
+            config[:adapter] = slot
+            @logger.debug("Normalized configuration: #{config.inspect}")
+
+            # Get the virtual network adapter configuration
+            adapter = send("#{type}_adapter", config)
+            adapters << adapter
+            @logger.debug("Adapter configuration: #{adapter.inspect}")
+          end
+
+          if !adapters.empty?
+            # Enable the adapters
+            @logger.info("Enabling adapters...")
+            env[:ui].info I18n.t("vagrant.actions.vm.network.preparing")
+            env[:machine].provider.driver.enable_adapters(adapters)
+          end
+
+          # Continue the middleware chain.
+          @app.call(env)
+
+        end
+
+        def hostonly_config(options)
+          options = {
+              :mac         => nil,
+              :nic_type    => "e1000",
+              :netmask     => "255.255.255.0",
+              :type        => :static
+          }.merge(options)
+
+          # Make sure the type is a symbol
+          options[:type] = options[:type].to_sym
+
+          # Default IP is in the 20-bit private network block for DHCP based networks
+          options[:ip] = "10.37.129.1" if options[:type] == :dhcp && !options[:ip]
+
+          # Calculate our network address for the given IP/netmask
+          netaddr  = network_address(options[:ip], options[:netmask])
+
+          # Verify that a host-only network subnet would not collide
+          # with a bridged networking interface.
+          #
+          # If the subnets overlap in any way then the host only network
+          # will not work because the routing tables will force the
+          # traffic onto the real interface rather than the virtual
+          # network interface.
+          @env[:machine].provider.driver.read_bridged_interfaces.each do |interface|
+            that_netaddr = network_address(interface[:ip], interface[:netmask])
+            raise Vagrant::Errors::NetworkCollision if \
+              netaddr == that_netaddr && interface[:status] != "Down"
+          end
+
+          # Split the IP address into its components
+          ip_parts = netaddr.split(".").map { |i| i.to_i }
+
+          # Calculate the adapter IP, which we assume is the IP ".1" at
+          # the end usually.
+          adapter_ip    = ip_parts.dup
+          adapter_ip[3] += 1
+          options[:adapter_ip] ||= adapter_ip.join(".")
+
+          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"
+            dhcp_ip    = ip_parts.dup
+            dhcp_ip[3] += 2
+            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_options[:dhcp_lower] ||= dhcp_lower.join(".")
+
+            dhcp_upper    = ip_parts.dup
+            dhcp_upper[3] = 254
+            dhcp_options[:dhcp_upper] ||= dhcp_upper.join(".")
+          end
+
+          return {
+              :adapter_ip  => options[:adapter_ip],
+              :ip          => options[:ip],
+              :mac         => options[:mac],
+              :netmask     => options[:netmask],
+              :nic_type    => options[:nic_type],
+              :type        => options[:type],
+          }.merge(dhcp_options)
+        end
+
+        def hostonly_adapter(config)
+          @logger.info("Searching for matching hostonly network: #{config[:ip]}")
+          interface = hostonly_find_matching_network(config)
+
+          if !interface
+            @logger.info("Network not found. Creating if we can.")
+
+            # It is an error if a specific host only network name was specified
+            # but the network wasn't found.
+            if config[:name]
+              raise Vagrant::Errors::NetworkNotFound, :name => config[:name]
+            end
+
+            # Create a new network
+            interface = hostonly_create_network(config)
+            @logger.info("Created network: #{interface[:name]}")
+          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],
+          }
+        end
+
+        def shared_config(options)
+          return  {}
+        end
+
+        def shared_adapter(config)
+          return {
+              :adapter => config[:adapter],
+              :shared  => "Shared",
+              :type    => :shared,
+              :dhcp     => true,
+              :nic_type => "e1000"
+          }
+        end
+
+        #-----------------------------------------------------------------
+        # Misc. helpers
+        #-----------------------------------------------------------------
+        # This determines the next free network name
+        def next_network_name
+          # 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
+          end
+
+          if net_nums.empty?
+            "vagrant-vnet0"
+          else
+            net_nums.sort! if net_nums
+            free_names = Array(0..net_nums.last.next) - net_nums
+            "vagrant-vnet#{free_names.first}"
+          end
+        end
+
+        #-----------------------------------------------------------------
+        # Hostonly Helper Functions
+        #-----------------------------------------------------------------
+        # This creates a host only network for the given configuration.
+        def hostonly_create_network(config)
+          options = {
+              :name       => next_network_name,
+              :adapter_ip => config[:adapter_ip],
+              :netmask    => config[:netmask],
+          }
+
+          if config[:type] == :dhcp
+            options[:dhcp] = {
+                :ip => config[:dhcp_ip],
+                :lower => config[:dhcp_lower],
+                :upper => config[:dhcp_upper]
+            }
+          end
+
+          @env[:machine].provider.driver.create_host_only_network(options)
+        end
+
+        # This finds a matching host only network for the given configuration.
+        def hostonly_find_matching_network(config)
+          this_netaddr = network_address(config[:ip], config[:netmask])
+
+          @env[:machine].provider.driver.read_host_only_interfaces.each do |interface|
+            return interface if config[:name] && config[:name] == interface[:name]
+            return interface if this_netaddr == \
+              network_address(interface[:ip], interface[:netmask])
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end