vagrant-kvm 0.1.4 → 0.1.5

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

@@ -9,7 +9,9 @@ module VagrantPlugins
 
         def call(env)
           # Create a storage pool in tmp_path if it doesn't exist
-          Driver::Driver.new.init_storage(env[:tmp_path])
+          userid = Process.uid.to_s
+          groupid = Process.gid.to_s
+          Driver::Driver.new.init_storage(env[:tmp_path], userid, groupid)
 
           @app.call(env)
         end

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

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

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

@@ -15,28 +15,27 @@ module VagrantPlugins
           # TODO: Validate network configuration prior to anything below
           @env = env
 
-          options = nil
+          options= {}
           env[:machine].config.vm.networks.each do |type, network_options|
             options = network_options if type == :private_network
           end
 
-          if options.has_key?(:ip)
-            addr = options[:ip].split(".")
-            addr[3] = "1"
-            base_ip = addr.join(".")
-            addr[3] = "100"
-            start_ip = addr.join(".")
-            addr[3] = "200"
-            end_ip = addr.join(".")
-            range = {
+          options[:ip] = "192.168.123.10" unless options.has_key?(:ip)
+          addr = options[:ip].split(".")
+          addr[3] = "1"
+          base_ip = addr.join(".")
+          addr[3] = "100"
+          start_ip = addr.join(".")
+          addr[3] = "200"
+          end_ip = addr.join(".")
+          range = {
               :start => start_ip,
               :end   => end_ip }
-            options = {
+          options = {
               :base_ip => base_ip,
               :netmask => "255.255.255.0",
               :range   => range
-            }.merge(options)
-          end
+          }.merge(options)
 
           hosts = []
           name = env[:machine].provider_config.name ?

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

@@ -19,7 +19,9 @@ module VagrantPlugins
         # 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|
+          tmp_dir = @env["export.temp_dir"]
+          tmp_dir = "/tmp" if !tmp_dir
+          File.open(File.join(tmp_dir, "Vagrantfile"), "w") do |f|
             f.write(KvmTemplateRenderer.render("package_Vagrantfile", {
               :base_mac => @env[:machine].provider.driver.read_mac_address
             }))

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class PrepareGui
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          config = env[:machine].provider_config
+          if config.gui
+            driver = env[:machine].provider.driver
+            driver.set_gui(config.vnc_port, config.vnc_autoport, config.vnc_password)
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -9,22 +9,11 @@ module VagrantPlugins
 
         def call(env)
           @app.call(env)
+          @machine = env[:machine]
 
-          using_nfs = false
-          env[:machine].config.vm.synced_folders.each do |id, opts|
-            if opts[:nfs]
-              using_nfs = true
-              break
-            end
-          end
+          env[:nfs_host_ip]    = read_host_ip(env[:machine])
+          env[:nfs_machine_ip] = read_machine_ip(env[:machine])
 
-          if using_nfs
-            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
-            env[:nfs_host_ip]    = read_host_ip(env[:machine])
-            env[:nfs_machine_ip] = read_machine_ip(env[:machine])
-
-            raise Vagrant::Errors::NFSNoHostonlyNetwork if !env[:nfs_machine_ip]
-          end
         end
 
         # Returns the IP address of the first host only network adapter
@@ -39,7 +28,8 @@ module VagrantPlugins
             return base_ip.join(".")
           end
 
-          nil
+          # If no private network configuration, return default ip
+          "192.168.123.1"
         end
 
         # Returns the IP address of the guest by looking at the first
@@ -53,7 +43,9 @@ module VagrantPlugins
             end
           end
 
-          nil
+          # XXX duplicated with network.rb default
+          # If no private network configuration, return default ip
+          "192.168.123.10"
         end
       end
     end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class PrepareNFSValidIds
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          env[:nfs_valid_ids] = env[:machine].provider.driver.uuid
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class ResetImagePermission
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+
+          #current_state = env[:machine].state.id
+          #if current_state == :shutoff
+            userid = Process.uid.to_s
+            groupid = Process.gid.to_s
+            env[:machine].provider.driver.reset_volume_permission(userid, groupid)
+          #end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class ResumeNetwork
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          interfaces = env[:machine].provider.driver.read_network_interfaces
+          interfaces.each do |nic|
+            next unless nic[:type] == :network
+
+            network_name = nic[:network].to_s
+            state = env[:machine].provider.driver.network_state?(network_name)
+            unless state
+              # start network and related services such as forward and nfs
+              env[:machine].provider.driver.start_network(network_name)
+              env[:action_runner].run(ForwardPorts, env)
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -28,11 +28,12 @@ module VagrantPlugins
               # Ignore NFS shared folders 
               #next if data[:nfs]
 
-              # convert to NFS share
-              data[:nfs] = true
-
-              # This to prevent overwriting the actual shared folders data
-              result[id] = data.dup
+              unless data[:disabled]
+                # convert to NFS share
+                data[:nfs] = true
+                # This to prevent overwriting the actual shared folders data
+                result[id] = data.dup
+              end
             end
           end
         end

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

@@ -9,7 +9,14 @@ module VagrantPlugins
         def call(env)
           if env[:machine].provider.state.id == :running
             env[:ui].info I18n.t("vagrant.actions.vm.suspend.suspending")
-            env[:machine].provider.driver.suspend
+            if env[:machine].provider_config.force_suspend
+              env[:machine].provider.driver.suspend
+            elsif  env[:machine].provider.driver.can_save?
+              env[:machine].provider.driver.save
+            else
+              env[:ui].warn ("Suspend is not supported. use pause instead.")
+              env[:machine].provider.driver.suspend
+            end
           end
 
           @app.call(env)

data/lib/vagrant-kvm/config.rb

@@ -2,7 +2,7 @@ module VagrantPlugins
   module ProviderKvm
     class Config < Vagrant.plugin("2", :config)
       # An array of customizations to make on the VM prior to booting it.
-      #
+
       # @return [Array]
       attr_reader :customizations
 
@@ -26,10 +26,61 @@ module VagrantPlugins
       # @return [String]
       attr_accessor :image_type
 
+      # VM image mode(clone or COW with backing file)
+      #
+      # @return [Boolean]
+      attr_reader :image_backing
+
+      # VM image mode(clone or COW with backing file)
+      #
+      # @return [String]
+      attr_accessor :image_mode
+
+      # path of qemu binary
+      #
+      # @return [String]
+      attr_accessor :qemu_bin
+
+      # cpu model
+      #
+      # @return [String]: x86_64/i386
+      attr_accessor :cpu_model
+
+      # memory size in bytes
+      # default: defined in box
+      #
+      # @return [String]
+      attr_accessor :memory_size
+
+      # core number of cpu
+      # default: defined in box
+      #
+      # @return [String]
+      attr_accessor :core_number
+      attr_accessor :vnc_port
+      attr_accessor :vnc_autoport
+      attr_accessor :vnc_password
+      attr_accessor :machine_type
+      attr_accessor :network_model
+      attr_accessor :video_model
+      attr_accessor :force_pause
+
       def initialize
         @name             = UNSET_VALUE
         @gui              = UNSET_VALUE
         @image_type       = UNSET_VALUE
+        @image_mode       = UNSET_VALUE
+        @qemu_bin         = UNSET_VALUE
+        @cpu_model        = UNSET_VALUE
+        @memory_size      = UNSET_VALUE
+        @core_number      = UNSET_VALUE
+        @vnc_port         = UNSET_VALUE
+        @vnc_autoport     = UNSET_VALUE
+        @vnc_password     = UNSET_VALUE
+        @machine_type     = UNSET_VALUE
+        @network_model    = UNSET_VALUE
+        @video_model      = UNSET_VALUE
+        @force_pause    = UNSET_VALUE
       end
 
       # This is the hook that is called to finalize the object before it
@@ -40,7 +91,57 @@ module VagrantPlugins
         # Default is to not show a GUI
         @gui = false if @gui == UNSET_VALUE
         # Default image type is a sparsed raw
-        @image_type = 'raw' if @image_type == UNSET_VALUE
+        @image_type = 'qcow2' if @image_type == UNSET_VALUE
+        case @image_mode
+        when UNSET_VALUE
+          @image_backing = true
+        when 'clone'
+          @image_backing = false
+        when 'cow'
+          @image_backing = true
+        else
+          @image_backing = true
+        end
+        # Search qemu binary with the default behavior
+        @qemu_bin = nil if @qemu_bin == UNSET_VALUE
+        # Default cpu model is x86_64, acceptable only x86_64/i686
+        @cpu_model = 'x86_64' if @cpu_model == UNSET_VALUE
+        @cpu_model = 'x86_64' unless @cpu_model =~ /^(i686|x86_64)$/
+        # Process memory size directive
+        # accept the case
+        # integer recgnized as KiB
+        # <num>KiB/KB/kb/MiB/MB/mb/GiB/GB/gb
+        #
+        case @memory_size
+        when /^([0-9][0-9]*)(KiB|kib)$/
+          @memory_size = ("#{$1}".to_i * 1024).to_s
+        when /^([0-9][0-9]*)(KB|kb)$/
+          @memory_size = ("#{$1}".to_i * 1000).to_s
+        when /^([0-9][0-9]*)(m||MiB|mib|)$/
+          @memory_size = ("#{$1}".to_i * 1048576).to_s
+        when /^([0-9][0-9]*)(MB|mb|)$/
+          @memory_size = ("#{$1}".to_i * 1000000).to_s
+        when /^([0-9][0-9]*)(g||GiB|gib)$/
+          @memory_size = ("#{$1}".to_i * 1073741824).to_s
+        when /^([0-9][0-9]*)(GB|gb|)$/
+          @memory_size = ("#{$1}".to_i * 1000000000).to_s
+        when /^([0-9][0-9]*)$/
+          @memory_size = ("#{$1}".to_i * 1024).to_s
+        when UNSET_VALUE
+          @memory_size = nil
+        else
+          @memory_size = nil
+        end
+        # Default core number is 1
+        @core_number = 1 if @core_number == UNSET_VALUE
+
+        @vnc_autoport = false if @vnc_autoport == UNSET_VALUE
+        @vnc_password = nil if @vnc_password == UNSET_VALUE
+        @vnc_port = -1 if @vnc_port == UNSET_VALUE
+        @machine_type = "pc-1.2" if @machine_type == UNSET_VALUE
+        @network_model = "virtio" if @network_model == UNSET_VALUE
+        @video_model = "cirrus" if @video_model == UNSET_VALUE
+        @force_pause = false if @force_pause == UNSET_VALUE
       end
     end
   end

data/lib/vagrant-kvm/driver/driver.rb

@@ -11,6 +11,7 @@ module VagrantPlugins
 
         include Util
         include Errors
+        include Util::Commands
 
         # enum for states return by libvirt
         VM_STATE = [
@@ -32,16 +33,21 @@ module VagrantPlugins
         # XXX sufficient or have to check kvm and libvirt versions?
         attr_reader :version
 
-        def initialize(uuid=nil)
+        # KVM support status
+        attr_reader :kvm
+
+        def initialize(uuid=nil, conn=nil)
           @logger = Log4r::Logger.new("vagrant::provider::kvm::driver")
           @uuid = uuid
           # This should be configurable
           @pool_name = "vagrant"
           @network_name = "vagrant"
 
+          load_kvm_module!
+
           # Open a connection to the qemu driver
           begin
-            @conn = Libvirt::open('qemu:///system')
+            @conn = conn || Libvirt::open('qemu:///system')
           rescue Libvirt::Error => e
             if e.libvirt_code == 5
               # can't connect to hypervisor
@@ -52,9 +58,9 @@ module VagrantPlugins
           end
 
           @version = read_version
-          if @version < "1.2.0"
+          if @conn.version.to_i < 1001000
             raise Errors::KvmInvalidVersion,
-              :actual => @version, :required => "< 1.2.0"
+              :actual => @version, :required => ">= 1.1.0"
           end
 
           # Get storage pool if it exists
@@ -72,10 +78,73 @@ module VagrantPlugins
           end
         end
 
+        # create empty volume in storage pool
+        # args: disk_name, capacity, path, image_type, box_pool, box_path,
+        #       backing, owner, group, mode, label
+        def create_volume(args={})
+          args = { # default values
+            :owner => '-1',
+            :group => '-1',
+            :mode  => '0744',
+            :label => 'virt_image_t',
+            :backing => false
+          }.merge(args)
+          msg = "Creating volume #{args[:disk_name]}"
+          msg += " backed by volume #{args[:box_path]}" if args[:backing]
+          capacity = args[:capacity]
+          @logger.info(msg)
+          storage_vol_xml = <<-EOF
+          <volume>
+            <name>#{args[:disk_name]}</name>
+            <allocation>0</allocation>
+            <capacity unit="#{capacity[:unit]}">#{capacity[:size]}</capacity>
+            <target>
+              <path>#{args[:path]}</path>
+              <format type='#{args[:image_type]}'/>
+              <permissions>
+                <owner>#{args[:owner]}</owner>
+                <group>#{args[:group]}</group>
+                <mode>#{args[:mode]}</mode>
+                <label>#{args[:label]}</label>
+              </permissions>
+            </target>
+            EOF
+
+          if args[:backing]
+            storage_vol_xml += <<-EOF
+            <backingStore>
+              <path>#{args[:box_path]}</path>
+              <format type='#{args[:image_type]}'/>
+            </backingStore>
+           EOF
+          end
+          storage_vol_xml += "</volume>"
+
+          @logger.debug "Creating volume with XML:\n#{storage_vol_xml}"
+          if args[:backing]
+            vol = @pool.create_volume_xml(storage_vol_xml)
+          else
+            pool = @conn.lookup_storage_pool_by_name(args[:box_pool])
+            clonevol = pool.lookup_volume_by_path(args[:box_path])
+            # create_volume_xml_from() can convert disk image type automatically.
+            vol = @pool.create_volume_xml_from(storage_vol_xml, clonevol)
+          end
+          @pool.refresh
+        end
+
+        def reset_volume_permission(userid, groupid)
+          @logger.info("Revert image owner to #{userid}:#{groupid}")
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          definition = Util::VmDefinition.new(domain.xml_desc)
+          volume_path = definition.attributes[:disk]
+          run_root_command("chown #{userid}:#{groupid} " + volume_path)
+          run_root_command("chmod 660 " + volume_path)
+        end
+
         def delete
           domain = @conn.lookup_domain_by_uuid(@uuid)
-          definition = Util::VmDefinition.new(domain.xml_desc, 'libvirt')
-          volume = @pool.lookup_volume_by_path(definition.disk)
+          definition = Util::VmDefinition.new(domain.xml_desc)
+          volume = @pool.lookup_volume_by_path(definition.attributes[:disk])
           volume.delete
           # XXX remove pool if empty?
           @pool.refresh
@@ -84,6 +153,12 @@ module VagrantPlugins
           domain.undefine
         end
 
+        def find_box_disk(xml)
+          definition = File.open(xml) { |f|
+            Util::VmDefinition.new(f.read) }
+          definition.attributes[:disk]
+        end
+
         # Halts the virtual machine
         def halt
           domain = @conn.lookup_domain_by_uuid(@uuid)
@@ -92,63 +167,26 @@ module VagrantPlugins
 
         # Imports the VM
         #
-        # @param [String] xml Path to the libvirt XML file.
-        # @param [String] path Destination path for the volume.
-        # @param [String] image_type An image type for the volume.
-        # @return [String] UUID of the imported VM.
-        def import(xml, path, image_type)
-          @logger.info("Importing VM")
+        # @param [String] definition Path to the VM XML file.
+        # @param [String] volume_name Name of the imported volume
+        # @param [Hash]   attributes
+        def import(definition, volume_name, args={})
+          @logger.info("Importing VM #{@name}")
           # create vm definition from xml
-          definition = File.open(xml) { |f|
-            Util::VmDefinition.new(f.read) }
-          # copy volume to storage pool
-          box_disk = definition.disk
-          new_disk = File.basename(box_disk, File.extname(box_disk)) + "-" +
-            Time.now.to_i.to_s + ".img"
-          @logger.info("Copying volume #{box_disk} to #{new_disk}")
-          old_path = File.join(File.dirname(xml), box_disk)
-          new_path = File.join(path, new_disk)
-          # we use qemu-img convert to preserve image size
-          system("qemu-img convert -p #{old_path} -O #{image_type} #{new_path}")
-          @pool.refresh
-          volume = @pool.lookup_volume_by_name(new_disk)
-          definition.disk = volume.path
-          definition.name = @name
-          definition.image_type = image_type
-          # create vm
-          @logger.info("Creating new VM")
-          domain = @conn.define_domain_xml(definition.as_libvirt)
-          domain.uuid
-        end
-
-        # Imports the VM from an OVF file.
-        # XXX should be fusioned with import
-        #
-        # @param [String] ovf Path to the OVF file.
-        # @param [String] path Destination path for the volume.
-        # @param [String] image_type An image type for the volume.
-        # @return [String] UUID of the imported VM.
-        def import_ovf(ovf, path, image_type)
-          @logger.info("Importing OVF definition for VM")
-          # create vm definition from ovf
-          definition = File.open(ovf) { |f|
-            Util::VmDefinition.new(f.read, 'ovf') }
-          # copy volume to storage pool
-          box_disk = definition.disk
-          new_disk = File.basename(box_disk, File.extname(box_disk)) + "-" +
-            Time.now.to_i.to_s + ".img"
-          @logger.info("Converting volume #{box_disk} to #{new_disk}")
-          old_path = File.join(File.dirname(ovf), box_disk)
-          new_path = File.join(path, new_disk)
-          system("qemu-img convert -p #{old_path} -O #{image_type} #{new_path}")
-          @pool.refresh
-          volume = @pool.lookup_volume_by_name(new_disk)
-          definition.disk = volume.path
-          definition.name = @name
-          definition.image_type = image_type
+          definition = File.open(definition) { |f| Util::VmDefinition.new(f.read) }
+          volume = @pool.lookup_volume_by_name(volume_name)
+          args = {
+            :image_type => "qcow2",
+            :qemu_bin => "/usr/bin/qemu",
+            :disk => volume.path,
+            :name => @name
+          }.merge(args)
+          definition.update(args)
           # create vm
           @logger.info("Creating new VM")
-          domain = @conn.define_domain_xml(definition.as_libvirt)
+          xml_definition = definition.as_xml
+          @logger.debug("Creating new VM with XML config:\n#{xml_definition}")
+          domain = @conn.define_domain_xml(xml_definition)
           domain.uuid
         end
 
@@ -159,44 +197,89 @@ module VagrantPlugins
             @network = @conn.lookup_network_by_name(@network_name)
             definition = Util::NetworkDefinition.new(@network_name,
                                                      @network.xml_desc)
-            @network.destroy if @network.active?
-            @network.undefine
           rescue Libvirt::RetrieveError
             # Network doesn't exist, create with defaults
             definition = Util::NetworkDefinition.new(@network_name)
           end
-          definition.configure(config)
-          @network = @conn.define_network_xml(definition.as_xml)
-          @logger.info("Creating network #{@network_name}")
-          @network.create
+          definition.update(config)
+          if @network.nil?
+            @logger.info("Creating network #{@network_name}")
+            @network = define_network(definition) 
+          else
+            # Only destroy existing network if config has changed. This is
+            # necessary because other VM could be currently using this network
+            # and will loose connectivity if the network is destroyed.
+            old_def = Util::NetworkDefinition.new(@network_name, @network.xml_desc)
+            if old_def == definition && @network.active?
+              @logger.info "Reusing existing configuration for #{@network_name}"
+            else
+              @logger.info "Recreating network config for #{@network_name}"
+              @logger.debug "Old definition was:\n#{@network.xml_desc}"
+              @network.destroy if @network.active?
+              @network.undefine
+              @network = define_network(definition) 
+            end
+          end
+        end
+
+        def define_network(definition)
+          xml = definition.as_xml
+          @logger.debug "Defining new network with XML:\n#{xml}"
+          network = @conn.define_network_xml(xml)
+          network.create
+          network
         end
 
         # Initialize or create storage pool
-        def init_storage(base_path)
+        def init_storage(base_path, uid, gid)
+          # Storage pool doesn't exist so we create it
+          # create dir if it doesn't exist
+          # if we let libvirt create the dir it is owned by root
+          pool_path = base_path.join("storage-pool")
+          pool_path.mkpath unless Dir.exists?(pool_path)
+          @pool = init_storage_directory(
+                     :pool_path => pool_path,
+                     :pool_name => @pool_name,
+                     :owner => uid, :group=>gid, :mode=>'755')
+        end
+
+        def init_storage_directory(args={})
           begin
             # Get the storage pool if it exists
-            @pool = @conn.lookup_storage_pool_by_name(@pool_name)
-            @logger.info("Init storage pool #{@pool_name}")
+            pool = @conn.lookup_storage_pool_by_name(args[:pool_name])
+            @logger.info("Init storage pool #{args[:pool_name]}")
           rescue Libvirt::RetrieveError
-            # Storage pool doesn't exist so we create it
-            # create dir if it doesn't exist
-            # if we let libvirt create the dir it is owned by root
-            pool_path = base_path.join("storage-pool")
-            pool_path.mkpath unless Dir.exists?(pool_path)
-            storage_pool_xml = <<-EOF
-          <pool type="dir">
-            <name>#{@pool_name}</name>
-            <target>
-              <path>#{pool_path}</path>
-            </target>
-          </pool>
-            EOF
-            @pool = @conn.define_storage_pool_xml(storage_pool_xml)
-            @pool.build
-            @logger.info("Creating storage pool #{@pool_name} in #{pool_path}")
+             @logger.info("Init storage pool with owner: #{args[:owner]}")
+             storage_pool_xml = <<-EOF
+              <pool type="dir">
+              <name>#{args[:pool_name]}</name>
+              <target>
+                <path>#{args[:pool_path]}</path>
+                <permissions>
+                 <owner>#{args[:owner]}</owner>
+                 <group>#{args[:group]}</group>
+                 <mode>#{args[:mode]}</mode>
+                </permissions>
+              </target>
+              </pool>
+             EOF
+            pool = @conn.define_storage_pool_xml(storage_pool_xml)
+            pool.build
+            @logger.info("Creating storage pool #{args[:pool_name]} in #{args[:pool_path]}")
+          end
+          pool.create unless pool.active?
+          pool.refresh
+          pool
+        end
+
+        def free_storage_pool(pool_name)
+          begin
+            pool = @conn.lookup_storage_pool_by_name(pool_name)
+            pool.destroy
+            pool.free
+          rescue Libvirt::RetrieveError
+            @logger.info("fail to free storage pool #{pool_name}")
           end
-          @pool.create unless @pool.active?
-          @pool.refresh
         end
 
         # Returns a list of network interfaces of the VM.
@@ -207,12 +290,36 @@ module VagrantPlugins
           Util::VmDefinition.list_interfaces(domain.xml_desc)
         end
 
+        def network_state?(network_name)
+          begin
+            network = @conn.lookup_network_by_name(network_name)
+            network.active?
+          rescue Libvirt::RetrieveError
+            false
+          end
+        end
+
+        def start_network(network_name)
+          begin
+            network = @conn.lookup_network_by_name(network_name)
+            network.create unless network.active?
+          rescue Libvirt::RetrieveError
+            false
+          end
+        end
+
         def read_state
           domain = @conn.lookup_domain_by_uuid(@uuid)
           state, reason = domain.state
           # check if domain has been saved
-          if VM_STATE[state] == :shutoff and domain.has_managed_save?
-            return :saved
+          case VM_STATE[state]
+          when :shutoff
+            if domain.has_managed_save?
+              return :saved
+            end
+            return :poweroff
+          when :shutdown
+            return :poweroff
           end
           VM_STATE[state]
         end
@@ -228,6 +335,12 @@ module VagrantPlugins
           "#{maj}.#{min}.#{rel}"
         end
 
+        def read_mac_address
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          definition = Util::VmDefinition.new(domain.xml_desc)
+          definition.attributes[:mac]
+        end
+
         # Resumes the previously paused virtual machine.
         def resume
           @logger.debug("Resuming paused VM...")
@@ -241,19 +354,32 @@ module VagrantPlugins
         end
 
         def set_mac_address(mac)
-          domain = @conn.lookup_domain_by_uuid(@uuid)
-          definition = Util::VmDefinition.new(domain.xml_desc, 'libvirt')
-          definition.set_mac(mac)
-          domain.undefine
-          @conn.define_domain_xml(definition.as_libvirt)
+          update_domain_xml(:mac => mac)
         end
 
-        def set_gui
+        def set_gui(vnc_port, vnc_autoport, vnc_password)
+          @logger.debug("Enabling GUI")
+          update_domain_xml(
+            :gui => true,
+            :vnc_port => vnc_port,
+            :vnc_autoport => vnc_autoport,
+            :vnc_password => vnc_password)
+        end
+
+        def set_diskbus(disk_bus)
+          update_domain_xml(:disk_bus => disk_bus)
+        end
+
+        def update_domain_xml(options)
           domain = @conn.lookup_domain_by_uuid(@uuid)
-          definition = Util::VmDefinition.new(domain.xml_desc, 'libvirt')
-          definition.set_gui
+          # Use DOMAIN_XML_SECURE to dump ALL options (including VNC password)
+          original_xml = domain.xml_desc(Libvirt::Domain::DOMAIN_XML_SECURE)
+          definition = Util::VmDefinition.new(original_xml)
+          definition.update(options)
           domain.undefine
-          @conn.define_domain_xml(definition.as_libvirt)
+          xml = definition.as_xml
+          @logger.debug("Updating domain xml\nFrom: #{original_xml}\nTo: #{xml}")
+          @conn.define_domain_xml(xml)
         end
 
         # Starts the virtual machine.
@@ -264,11 +390,48 @@ module VagrantPlugins
         end
 
         # Suspend the virtual machine and saves its states.
-        def suspend
+        def save
           domain = @conn.lookup_domain_by_uuid(@uuid)
           domain.managed_save
         end
 
+        def can_save?
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          definition = Util::VmDefinition.new(domain.xml_desc)
+          disk_bus = definition.get(:disk_bus)
+          return disk_bus != 'sata'
+        end
+
+        # Suspend the virtual machine temporaly
+        def suspend
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.suspend
+        end
+
+        # Export
+        def export(xml_path)
+          @logger.info("FIXME: export has not tested yet.")
+          new_disk = 'disk.img'
+          # create new_disk
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          definition = Util::VmDefinition.new(domain.xml_desc)
+          disk_image = definition.attributes[:disk]
+          to_path = File.dirname(xml_path)
+          new_path = File.join(to_path, new_disk)
+          @logger.info("create disk image #{new_path}")
+          run_command("qemu-img convert -c -S 4k -O qcow2 #{disk_image} #{new_path}")
+          # write out box.xml
+          definition.update(:disk => new_disk,:gui  => false,:uuid => nil)
+          File.open(xml_path,'w') do |f|
+            f.puts(definition.as_xml)
+          end
+          # write metadata.json
+          json_path=File.join(to_path, 'metadata.json')
+          File.open(json_path,'w') do |f|
+            f.puts('{"provider": "kvm"}')
+          end
+        end
+
         # Verifies that the driver is ready and the connection is open
         #
         # This will raise a VagrantError if things are not ready.
@@ -289,6 +452,65 @@ module VagrantPlugins
             false
           end
         end
+
+        # Checks which Linux OS variants
+        #
+        # host_redhat?
+        # host_debian?
+        # host_gentoo?
+        # host_arch?
+        # @return [Boolean]
+        def host_redhat?
+          release_file = Pathname.new("/etc/redhat-release")
+
+          if release_file.exist?
+            release_file.open("r:ISO-8859-1:UTF-8") do |f|
+              contents = f.gets
+              return true if contents =~ /^CentOS/ # CentOS
+              return true if contents =~ /^Fedora/ # Fedora
+              return true if contents =~ /^Korora/ # Korora
+
+              # Oracle Linux < 5.3
+              return true if contents =~ /^Enterprise Linux Enterprise Linux/
+
+              # Red Hat Enterprise Linux and Oracle Linux >= 5.3
+              return true if contents =~ /^Red Hat Enterprise Linux/
+            end
+          end
+
+          false
+        end
+
+        def host_debian?
+          File.exists?("/etc/debian_version")
+        end
+
+        def host_gentoo?
+          File.exists?("/etc/gentoo-release")
+        end
+
+        def host_arch?
+          File.exist?("/etc/arch-release")
+        end
+
+        private
+        def load_kvm_module!
+          @logger.info("Check KVM kernel modules")
+          kvm = File.readlines('/proc/modules').any? { |line| line =~ /kvm_(intel|amd)/ }
+          unless kvm
+            case File.read('/proc/cpuinfo')
+            when /vmx/
+              kvm = true if run_command("sudo /sbin/modprobe kvm-intel")
+            when /svm/
+              kvm = true if run_command("sudo /sbin/modprobe kvm-amd")
+            else
+              # looks like virtualization is not supported
+            end
+          end
+          # FIXME: see KVM/ARM project
+          raise Errors::VagrantKVMError, "KVM is unavailable" unless kvm
+          true
+        end
       end
     end
   end