vagrant-parallels 0.0.1.dev

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class Boot
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          env[:ui].info I18n.t("vagrant.actions.vm.boot.booting")
+          env[:machine].provider.driver.start
+
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class CheckAccessible
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :inaccessible
+            # The VM we are attempting to manipulate is inaccessible. This
+            # 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
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      # This middleware checks that the VM is created, and raises an exception
+      # if it is not, notifying the user that creation is required.
+      class CheckCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :not_created
+            raise Vagrant::Errors::VMNotCreatedError
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class CheckGuestTools
+        def initialize(app, env)
+          @app = app
+        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")
+          else
+            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",
+                                   tools_version: tools_version,
+                                   parallels_version: os_version))
+            end
+          end
+
+          # Continue
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      # Checks that Parallels is installed and ready to be used.
+      class CheckParallels
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # This verifies that Parallels is installed and the driver is
+          # ready to function. If not, then an exception will be raised
+          # which will break us out of execution of the middleware sequence.
+          env[:machine].provider.driver.verify!
+
+          # Carry on.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      # This middleware checks that the VM is running, and raises an exception
+      # if it is not, notifying the user that the VM must be running.
+      class CheckRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].state.id != :running
+            raise Vagrant::Errors::VMNotRunningError
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class ClearNetworkInterfaces
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # "Enable" all the adapters we setup.
+          env[:ui].info I18n.t("vagrant.actions.vm.clear_network_interfaces.deleting")
+          env[:machine].provider.driver.delete_adapters
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class ClearSharedFolders
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine].provider.driver.clear_shared_folders
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class Created
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is created.
+          env[:result] = (env[:machine].state.id != :not_created)
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class Destroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.destroy.destroying")
+          env[:machine].provider.driver.delete
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class ForcedHalt
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].state.id
+          if current_state == :running
+            env[:ui].info I18n.t("vagrant.actions.vm.halt.force")
+            env[:machine].provider.driver.halt(:force)
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class Import
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.actions.vm.import.importing",
+                               :name => env[:machine].box.name)
+
+          prefix = env[:root_path].basename.to_s
+          prefix.gsub!(/[^-a-z0-9_]/i, "")
+          vm_name = prefix + "_#{Time.now.to_i}"
+
+          # Verify the name is not taken
+          if env[:machine].provider.driver.registered? vm_name
+            raise Vagrant::Errors::VMNameExists, :name => vm_name
+          end
+
+          # Import the virtual machine
+          template_name = Pathname.glob(
+              env[:machine].box.directory.join('*.pvm')
+            ).first.basename.to_s[0...-4]
+
+          env[:machine].id = env[:machine].provider.driver.import(template_name, 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]
+
+          # Flag as erroneous and return if import failed
+          raise Vagrant::Errors::VMImportFailure if !env[:machine].id
+
+          # Import completed successfully. Continue the chain
+          @app.call(env)
+        end
+
+        def recover(env)
+          if env[:machine].provider.state.id != :not_created
+            return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+            # Interrupted, destroy the VM. We note that we don't want to
+            # validate the configuration here, and we don't want to confirm
+            # we want to destroy.
+            destroy_env = env.clone
+            destroy_env[:config_validate] = false
+            destroy_env[:force_confirm_destroy] = true
+            env[:action_runner].run(Action.action_destroy, destroy_env)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class IsPaused
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+
+          # Set the result to be true if the machine is paused.
+          env[:result] = env[:machine].state.id == :paused
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class IsRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is running.
+          env[:result] = env[:machine].state.id == :running
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class IsSaved
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+
+          # Set the result to be true if the machine is suspended.
+          env[:result] = env[:machine].state.id == :suspended
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class MatchMACAddress
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          raise Vagrant::Errors::VMBaseMacNotSpecified if !env[:machine].config.vm.base_mac
+
+          # Create the proc which we want to use to modify the virtual machine
+          env[:ui].info I18n.t("vagrant.actions.vm.match_mac.matching")
+          env[:machine].provider.driver.set_mac_address(env[:machine].config.vm.base_mac)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class MessageAlreadyRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_already_running")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Parallels
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.common.vm_not_created")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end