vagrant-parallels 1.1.0 → 1.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cc269a4cbf2360003f371aca48b009baa72df2f
-  data.tar.gz: 7210ed53e9d14ad25802f462c4a64b29496e23a6
+  metadata.gz: 8fc01455732e664712d913020806753766fa2c11
+  data.tar.gz: 83d9a5723aacfb1c01cbf210bc97aea553c87b44
 SHA512:
-  metadata.gz: 99a2c50f43cf9a0ff5505a17a928f9090b2f35b612473d69cf24e86322929f65deeda05c74b3b1bdcf2ac8a2173ff34598a077b154d91f6d2cd49bd701fd4f64
-  data.tar.gz: 1960c6a9e1cf96012aefeb3641a725f63cba7374131bfff6ebf405578c7b800809a8841597cece62bd77158741a52e3e5b99df459dfa0d1f42ddbaef15b99743
+  metadata.gz: a8565bde8a49ec3bf398be9a0c11a5e22ccb21286780d919fd5cd8cd63bbbf2d21373446a4be3640ecd3d0bea7ff9731114c6f3ef611049db4acd56f81cbd504
+  data.tar.gz: ce70eee926a912ca2460fcbcea90078360385d26730f9c4d57f22f0a6a756b71f653432b921adbbcae403a5a7392f52a1eceb0e7669883ec890d94cd471619e6

data/CONTRIBUTING.md

@@ -0,0 +1,61 @@
+## How to contribute
+
+We are glad you want to contribute to the `vagrant-parallels` plugin!
+First of all,  clone this repository:
+
+```
+$ git clone https://github.com/Parallels/vagrant-parallels
+$ cd vagrant-parallels
+```
+
+### Dependencies and Unit Tests
+
+To hack on our plugin, you'll need a [Ruby interpreter](https://www.ruby-lang.org/en/downloads/) 
+(>= 2.0) and [Bundler](http://bundler.io/) which can be installed with a simple 
+`gem install bundler`. Afterwards, do the following:
+
+```
+$ bundle install
+$ rake
+```
+
+This will run the unit test suite, which should come back all green! 
+Then you're good to go!
+
+If you want to run Vagrant without having to install the `vagrant-parallels` 
+gem, you may use `bundle exec`, like so:
+
+```
+$ bundle exec vagrant up --provider=parallels
+```
+
+### Building Provider from Source
+To build a `vagrant-parallels` gem just run this command:
+
+```
+$ rake build
+```
+
+The built "gem" package will appear in the `./pkg` folder.
+
+Then, if you want to install plugin from your locally built "gem", use the
+following commands:
+
+```
+$ vagrant plugin uninstall vagrant-parallels
+$ vagrant plugin install pkg/vagrant-parallels-<version>.gem
+```
+
+Now that you have your own plugin installed, check it with the command
+`vagrant plugin list`
+
+### Sending a Pull Request
+If you're ready to send your changes, please follow the next steps:
+
+1. Fork the 'vagrant-parallels' repository and ad it as a new remote (`git add
+remote my-fork <fork_url>`)
+2. Create a branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am "Added a sweet feature"`)
+4. Push the branch to your fork (`git push fork my-new-feature`)
+5. Create a pull request from your `my-new-feature` branch into `master` of
+`vagrant-parallels` repo

data/README.md

@@ -42,64 +42,9 @@ We recommend you to start from these pages:
 * [Getting Started](http://parallels.github.io/vagrant-parallels/docs/getting-started.html)
 * [Boxes](http://parallels.github.io/vagrant-parallels/docs/boxes/index.html)
 
-## Contributing to the Parallels Provider
-
-To work on the `vagrant-parallels` plugin development, clone this repository:
-
-```
-$ git clone https://github.com/Parallels/vagrant-parallels
-$ cd vagrant-parallels
-```
-
-Use [Bundler](http://bundler.io/) to get the dependencies (Ruby 2.0 is needed)
-and rake to run the unit test suit:
-
-```
-$ bundle install
-$ rake
-```
-
-If it passes successfully, you're ready to start developing the plugin. Use
-bundler to execute Vagrant and test the plugin without installing:
-
-```
-$ bundle exec vagrant up --provider=parallels
-```
-
-### Building Provider from Source
-To build a `vagrant-parallels` gem just run this command:
-
-```
-$ rake build
-```
-
-The built "gem" package will appear in the `./pkg` folder.
-
-Then, if you want to install plugin from your locally built "gem", use the
-following commands:
-
-```
-$ vagrant plugin uninstall vagrant-parallels
-$ vagrant plugin install pkg/vagrant-parallels-<version>.gem
-```
-
-Now that you have your own plugin installed, check it with the command
-`vagrant plugin list`
-
-### Sending a Pull Request
-If you're ready to send your changes, please follow the next steps:
-
-1. Fork the 'vagrant-parallels' repository and ad it as a new remote (`git add
-remote my-fork <fork_url>`)
-2. Create a branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am "Added a sweet feature"`)
-4. Push the branch to your fork (`git push fork my-new-feature`)
-5. Create a pull request from your `my-new-feature` branch into `master` of
-`vagrant-parallels` repo
-
 ## Getting Help
-Having problems while using the provider? Ask your question to our mailing list:
-[Google Group](https://groups.google.com/group/vagrant-parallels)
+Having problems while using the provider? Ask your question on the official forum:
+["Parallels Provider for Vagrant" forum branch](http://forum.parallels.com/forumdisplay.php?737-Parallels-Provider-for-Vagrant)
 
 If you get an error while using the Parallels provider or discover a bug,
 please report it on the [IssueTracker](https://github.com/Parallels/vagrant-parallels).

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class ClearForwardedPorts
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Port Forwarding feature is available only with PD >= 10
+          if !env[:machine].provider.pd_version_satisfies?('>= 10')
+            return @app.call(env)
+          end
+
+          if !env[:machine].provider.driver.read_forwarded_ports.empty?
+            env[:ui].info I18n.t('vagrant.actions.vm.clear_forward_ports.deleting')
+            env[:machine].provider.driver.clear_forwarded_ports
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -29,8 +29,8 @@ module VagrantPlugins
                 env[:machine].provider.driver.execute_prlctl(*processed_command)
               rescue VagrantPlugins::Parallels::Errors::ExecutionError => e
                 raise Vagrant::Errors::VMCustomizationFailed, {
-                  :command => command,
-                  :error   => e.inspect
+                  command: command,
+                  error:   e.inspect
                 }
               end
             end

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

@@ -4,7 +4,7 @@ module VagrantPlugins
       class Export
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant::plugins::parallels::export")
+          @logger = Log4r::Logger.new('vagrant_parallels::action::export')
         end
 
         def call(env)

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

@@ -0,0 +1,78 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class ForwardPorts
+        include Util::CompileForwardedPorts
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        #--------------------------------------------------------------
+        # Execution
+        #--------------------------------------------------------------
+        def call(env)
+          # Port Forwarding feature is available only with PD >= 10
+          if !env[:machine].provider.pd_version_satisfies?('>= 10')
+            return @app.call(env)
+          end
+
+          @env = env
+
+          # 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
+
+          @app.call(env)
+        end
+
+        def forward_ports
+          ports = []
+
+          @env[:forwarded_ports].each do |fp|
+            message_attributes = {
+              guest_port: fp.guest_port,
+              host_port: fp.host_port
+            }
+
+            # Assuming the only reason to establish port forwarding is
+            # because the VM is using Shared networking. Host-only and
+            # bridged networking don't require port-forwarding and establishing
+            # forwarded ports on these attachment types has uncertain behaviour.
+            @env[:ui].detail(I18n.t("vagrant_parallels.actions.vm.forward_ports.forwarding_entry",
+                                    message_attributes))
+
+            # 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),
+              protocol:  fp.protocol
+            }
+          end
+
+          if !ports.empty?
+            # We only need to forward ports if there are any to forward
+            @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
+end

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

@@ -4,7 +4,7 @@ module VagrantPlugins
       class HandleGuestTools
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant::plugins::parallels::handle_guest_tools")
+          @logger = Log4r::Logger.new('vagrant_parallels::action::handle_guest_tools')
         end
 
         def call(env)

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

@@ -4,7 +4,7 @@ module VagrantPlugins
       class Import
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant::plugins::parallels::import")
+          @logger = Log4r::Logger.new('vagrant_parallels::action::import')
         end
 
         def call(env)

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

@@ -19,7 +19,7 @@ module VagrantPlugins
 
         def initialize(app, env)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant::plugins::parallels::network")
+          @logger = Log4r::Logger.new('vagrant_parallels::action::network')
         end
 
         def call(env)
@@ -131,11 +131,11 @@ module VagrantPlugins
 
         def bridged_config(options)
           return {
-            :auto_config                     => true,
-            :bridge                          => nil,
-            :mac                             => nil,
-            :nic_type                        => nil,
-            :use_dhcp_assigned_default_route => false
+            auto_config:                     true,
+            bridge:                          nil,
+            mac:                             nil,
+            nic_type:                        nil,
+            use_dhcp_assigned_default_route: false
           }.merge(options || {})
         end
 
@@ -204,39 +204,39 @@ module VagrantPlugins
 
           # Given the choice we can now define the adapter we're using
           return {
-            :adapter     => config[:adapter],
-            :type        => :bridged,
-            :bridge      => chosen_bridge,
-            :mac_address => config[:mac],
-            :nic_type    => config[:nic_type]
+            adapter:     config[:adapter],
+            type:        :bridged,
+            bridge:      chosen_bridge,
+            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
+              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]
+            type:                            :dhcp,
+            use_dhcp_assigned_default_route: config[:use_dhcp_assigned_default_route]
           }
         end
 
         def hostonly_config(options)
           options = {
-            :auto_config => true,
-            :mac         => nil,
-            :nic_type    => nil,
-            :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
@@ -289,13 +289,13 @@ module VagrantPlugins
           end
 
           return {
-            :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]
+            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
 
@@ -318,34 +318,34 @@ module VagrantPlugins
           end
 
           return {
-            :adapter     => config[:adapter],
-            :hostonly    => interface[:name],
-            :mac_address => config[:mac],
-            :nic_type    => config[:nic_type],
-            :type        => :hostonly
+            adapter:     config[:adapter],
+            hostonly:    interface[:name],
+            mac_address: 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]
+            type:       config[:type],
+            adapter_ip: config[:adapter_ip],
+            ip:         config[:ip],
+            netmask:    config[:netmask]
           }
         end
 
 
         def shared_config(options)
           return {
-            :auto_config => false
+            auto_config: false
           }
         end
 
         def shared_adapter(config)
           return {
-            :adapter => config[:adapter],
-            :type    => :shared
+            adapter: config[:adapter],
+            type:    :shared
           }
         end
 
@@ -414,16 +414,16 @@ module VagrantPlugins
         # This creates a host only network for the given configuration.
         def hostonly_create_network(config)
           options = {
-              :network_id => next_network_id,
-              :adapter_ip => config[:adapter_ip],
-              :netmask    => config[:netmask],
+            network_id: next_network_id,
+            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]
+              ip:    config[:dhcp_ip],
+              lower: config[:dhcp_lower],
+              upper: config[:dhcp_upper]
             }
           end
 

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

@@ -0,0 +1,41 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class PrepareForwardedPortCollisionParams
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Port Forwarding feature is available only with PD >= 10
+          if !env[:machine].provider.pd_version_satisfies?('>= 10')
+            return @app.call(env)
+          end
+
+          # Get the forwarded ports used by other virtual machines and
+          # consider those in use as well.
+          env[:port_collision_extra_in_use] =
+            env[:machine].provider.driver.read_used_ports
+
+          # Build the remap for any existing collision detections
+          remap = {}
+          env[:port_collision_remap] = remap
+          env[:machine].provider.driver.read_forwarded_ports.each do |r|
+            env[:machine].config.vm.networks.each do |type, options|
+              next if type != :forwarded_port
+
+              # If the ID matches the name of the forwarded port, then
+              # remap.
+              if options[:id] == r[:name]
+                remap[options[:host]] = r[:hostport]
+                break
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module VagrantPlugins
       class PrepareNFSSettings
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+          @logger = Log4r::Logger.new('vagrant_parallels::action::nfs')
         end
 
         def call(env)

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

@@ -4,7 +4,7 @@ module VagrantPlugins
       class PrepareNFSValidIds
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+          @logger = Log4r::Logger.new('vagrant_parallels::action::nfs')
         end
 
         def call(env)

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

@@ -0,0 +1,55 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Parallels
+    module Action
+      class SaneDefaults
+        def initialize(app, env)
+          @logger = Log4r::Logger.new('vagrant_parallels::action::sanedefaults')
+          @app = app
+        end
+
+        def call(env)
+          # Set the env on an instance variable so we can access it in
+          # helpers.
+          @env = env
+
+          # Disable requiring password on such operations as creating, adding,
+          # removing or coning the virtual machine. [GH-67]
+          # It is available only since PD 10.
+          if env[:machine].provider.pd_version_satisfies?('>= 10')
+            @logger.info('Disabling any password restrictions...')
+            env[:machine].provider.driver.disable_password_restrictions
+          end
+
+          if env[:machine].provider.pd_version_satisfies?('>= 9')
+            @logger.info('Setting the power consumption mode...')
+            set_power_consumption
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def set_power_consumption
+          # Optimization of power consumption is defined by "Longer Battery Life" state.
+          vm_settings = @env[:machine].provider.driver.read_settings
+
+          old_val = vm_settings.fetch('Longer battery life') == 'on' ? true : false
+          new_val = @env[:machine].provider_config.optimize_power_consumption
+
+          if old_val == new_val
+            @logger.info('Skipping power consumption method because it is already set')
+          else
+            mode = new_val ? 'Longer battery life' : 'Better Performance'
+            @env[:ui].info I18n.t('vagrant_parallels.parallels.power_consumption.set_mode',
+                                  mode: mode)
+            @env[:machine].provider.driver.set_power_consumption_mode(new_val)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module VagrantPlugins
     module Action
       class SetName
         def initialize(app, env)
-          @logger = Log4r::Logger.new("vagrant::action::vm::setname")
+          @logger = Log4r::Logger.new('vagrant_parallels::action::setname')
           @app = app
         end
 

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

@@ -13,7 +13,6 @@ module VagrantPlugins
           files = {}
           env["package.include"].each do |file|
             source = Pathname.new(file)
-            dest   = nil
 
             # If the source is relative then we add the file as-is to the include
             # directory. Otherwise, we copy only the file into the root of the