vagrant-kvm 0.1.0

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

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class Boot
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          # Start up the VM
+          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-kvm/action/check_box.rb

@@ -0,0 +1,36 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class CheckBox
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          box_name = env[:machine].config.vm.box
+          raise Vagrant::Errors::BoxNotSpecified if !box_name
+
+          if !env[:box_collection].find(box_name, :kvm)
+            box_url = env[:machine].config.vm.box_url
+            raise Vagrant::Errors::BoxSpecifiedDoesntExist, :name => box_name if !box_url
+
+            # Add the box then reload the box collection so that it becomes
+            # aware of it.
+            env[:ui].info I18n.t("vagrant.actions.vm.check_box.not_found", :name => box_name)
+            env[:action_runner].run(Vagrant::Action.action_box_add, {
+              :box_name     => box_name,
+              :box_provider => env[:machine].provider_name,
+              :box_url      => box_url
+            })
+
+            # Reload the environment and set the VM to be the new loaded VM.
+            env[:machine] = env[:machine].env.machine(
+              env[:machine].name, env[:machine].provider_name, true)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderKvm
+    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-kvm/action/check_kvm.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      # Checks that the libvirt/kvm/qemu environment is ready to be used.
+      class CheckKvm
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # This verifies that kvm/qemu is installed, the environment is
+          # set-up 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.
+          Driver::Driver.new.verify!
+
+          # Carry on.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderKvm
+    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-kvm/action/created.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderKvm
+    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-kvm/action/destroy.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module ProviderKvm
+    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-kvm/action/destroy_confirm.rb

@@ -0,0 +1,17 @@
+require "vagrant/action/builtin/confirm"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class DestroyConfirm < Vagrant::Action::Builtin::Confirm
+        def initialize(app, env)
+          force_key = :force_confirm_destroy
+          message   = I18n.t("vagrant.commands.destroy.confirmation",
+                             :name => env[:machine].name)
+
+          super(app, env, message, force_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "fileutils"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class Export
+        attr_reader :temp_dir
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+
+          raise Vagrant::Errors::VMPowerOffToPackage if \
+            @env[:machine].provider.state.id != :poweroff
+
+          setup_temp_dir
+          export
+
+          @app.call(env)
+
+          recover(env) # called to cleanup temp directory
+        end
+
+        def recover(env)
+          if temp_dir && File.exist?(temp_dir)
+            FileUtils.rm_rf(temp_dir)
+          end
+        end
+
+        def setup_temp_dir
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.create_dir")
+          @temp_dir = @env["export.temp_dir"] = @env[:tmp_path].join(Time.now.to_i.to_s)
+          FileUtils.mkpath(@env["export.temp_dir"])
+        end
+
+        def export
+          @env[:ui].info I18n.t("vagrant.actions.vm.export.exporting")
+          @env[:machine].provider.driver.export(xml_path) do |progress|
+            @env[:ui].clear_line
+            @env[:ui].report_progress(progress.percent, 100, false)
+          end
+
+          # Clear the line a final time so the next data can appear
+          # alone on the line.
+          @env[:ui].clear_line
+        end
+
+        def xml_path
+          File.join(@env["export.temp_dir"], "box.xml")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderKvm
+    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
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module VagrantPlugins
+  module ProviderKvm
+    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)
+
+          # Import the virtual machine (ovf or libvirt)
+          # if a libvirt XML definition is present we use it
+          # otherwise we convert the OVF
+          storage_path = File.join(env[:tmp_path],"/storage-pool")
+          box_file = env[:machine].box.directory.join("box.xml").to_s
+          if File.file?(box_file)
+            env[:machine].id = env[:machine].provider.driver.import(
+                        box_file, storage_path)
+          else
+            box_file = env[:machine].box.directory.join("box.ovf").to_s
+            env[:machine].id = env[:machine].provider.driver.import_ovf(
+                        box_file, storage_path)
+          end
+
+          # 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-kvm/action/init_storage_pool.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      # Initialize storage pool.
+      class InitStoragePool
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Create a storage pool in tmp_path if it doesn't exist
+          Driver::Driver.new.init_storage(env[:tmp_path])
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderKvm
+    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-kvm/action/is_running.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderKvm
+    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-kvm/action/is_saved.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class IsSaved
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is saved.
+          env[:result] = env[:machine].state.id == :saved
+
+          # 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-kvm/action/match_mac_address.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderKvm
+    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-kvm/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module ProviderKvm
+    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