vagrant-kvm 0.1.7 → 0.1.8

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

@@ -25,12 +25,11 @@ module VagrantPlugins
         def shared_folders
           {}.tap do |result|
             @env[:machine].config.vm.synced_folders.each do |id, data|
-              # Ignore NFS shared folders 
-              #next if data[:nfs]
+              next if data[:disabled]
 
-              unless data[:disabled]
-                # convert to NFS share
-                data[:nfs] = true
+              data[:nfs] = true unless @env[:machine].provider_config.enable_virtfs
+
+              if data[:nfs]
                 # This to prevent overwriting the actual shared folders data
                 result[id] = data.dup
               end

data/lib/vagrant-kvm/cap/mount_p9.rb

@@ -0,0 +1,40 @@
+require "digest/md5"
+require "vagrant/util/retryable"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Cap
+      class MountP9
+        extend Vagrant::Util::Retryable
+
+        def self.mount_p9_shared_folder(machine, folders, options)
+          folders.each do |name, opts|
+            # Expand the guest path so we can handle things like "~/vagrant"
+            expanded_guest_path = machine.guest.capability(
+              :shell_expand_guest_path, opts[:guestpath])
+
+            # Do the actual creating and mounting
+            machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
+
+            # Mount
+            # tag maximum len is 31
+            mount_tag = Digest::MD5.new.update(name).to_s[0,31]
+
+            mount_opts="-o trans=virtio"
+            mount_opts += ",access=#{options[:owner]}" if options[:owner]
+            mount_opts += ",version=#{options[:version]}" if options[:version]
+            mount_opts += ",#{opts[:mount_options]}" if opts[:mount_options]
+
+            mount_command = "mount -t 9p #{mount_opts} '#{mount_tag}' #{expanded_guest_path}"
+            retryable(:on => Vagrant::Errors::LinuxMountFailed,
+                      :tries => 5,
+                      :sleep => 3) do
+              machine.communicate.sudo(mount_command,
+                      :error_class => Vagrant::Errors::LinuxMountFailed)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/config.rb

@@ -1,3 +1,5 @@
+require 'etc'
+
 module VagrantPlugins
   module ProviderKvm
     class Config < Vagrant.plugin("2", :config)
@@ -21,6 +23,11 @@ module VagrantPlugins
       # @return [Hash]
       attr_reader :network_adapters
 
+      # The storage pool to use
+      #
+      # @return [String]
+      attr_accessor :storage_pool
+
       # The VM image format
       #
       # @return [String]
@@ -63,11 +70,27 @@ module VagrantPlugins
       attr_accessor :machine_type
       attr_accessor :network_model
       attr_accessor :video_model
+      attr_accessor :sound
+      attr_accessor :virtio_rng
+
+      # disk bus type
+      # sata/virtio
+      #
+      # @return [String]
+      attr_accessor :disk_bus
+
+      # Security labelling
+      # default: off
+      #
+      # @return [String]
+      attr_accessor :seclabel
       attr_accessor :force_pause
 
       def initialize
+        @customizations   = []
         @name             = UNSET_VALUE
         @gui              = UNSET_VALUE
+        @storage_pool     = UNSET_VALUE
         @image_type       = UNSET_VALUE
         @image_mode       = UNSET_VALUE
         @qemu_bin         = UNSET_VALUE
@@ -80,7 +103,27 @@ module VagrantPlugins
         @machine_type     = UNSET_VALUE
         @network_model    = UNSET_VALUE
         @video_model      = UNSET_VALUE
-        @force_pause    = UNSET_VALUE
+        @disk_bus         = UNSET_VALUE
+        @sound            = UNSET_VALUE
+        @force_pause      = UNSET_VALUE
+        @enable_virtfs    = UNSET_VALUE
+        @virtio_rng       = UNSET_VALUE
+      end
+
+      # Customize the VM by predefined actions.
+      #
+      # When called multiple times, the customizations will be applied
+      # in the order given.
+      #
+      # The special `:name` parameter in the command will be replaced with
+      # the unique ID or name of the virtual machine. This is useful for
+      # parameters to `modifyvm` and the like.
+      #
+      # @param [Array] command An array of arguments to pass to
+      def customize(*command)
+        event   = command.first.is_a?(String) ? command.shift : "pre-boot"
+        command = command[0]
+        @customizations << [event, command]
       end
 
       # This is the hook that is called to finalize the object before it
@@ -90,6 +133,9 @@ module VagrantPlugins
         @name = nil if @name == UNSET_VALUE
         # Default is to not show a GUI
         @gui = false if @gui == UNSET_VALUE
+        # Default is a storage pool we create for vagrant
+        login = Etc.getlogin
+        @storage_pool = 'vagrant-'+login.to_s if @storage_pool == UNSET_VALUE
         # Default image type is a sparsed raw
         @image_type = 'qcow2' if @image_type == UNSET_VALUE
         case @image_mode
@@ -141,7 +187,33 @@ module VagrantPlugins
         @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
+        @disk_bus = nil if @disk_bus == UNSET_VALUE
+        @sound = false if @sound == UNSET_VALUE
         @force_pause = false if @force_pause == UNSET_VALUE
+        @enable_virtfs = false if @enable_virtfs == UNSET_VALUE
+        @virtio_rng = nil if @virtio_rng == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        valid_events = ["pre-import", "pre-boot", "post-boot"]
+        @customizations.each do |event, _|
+          if !valid_events.include?(event)
+            errors << I18n.t(
+              "vagrant.kvm.config.invalid_event",
+              event: event.to_s,
+              valid_events: valid_events.join(", "))
+          end
+        end
+
+        @customizations.each do |event, command|
+          if event == "pre-import" && command.index(:id)
+            errors << I18n.t("vagrant.kvm.config.id_in_pre_import")
+          end
+        end
+
+        { "KVM Provider" => errors }
       end
     end
   end

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

@@ -1,5 +1,7 @@
 require 'libvirt'
 require 'log4r'
+require 'pathname'
+require "rexml/document"
 
 module VagrantPlugins
   module ProviderKvm
@@ -29,27 +31,17 @@ module VagrantPlugins
         # The UUID of the virtual machine we represent
         attr_reader :uuid
 
-        # The QEMU version
-        # XXX sufficient or have to check kvm and libvirt versions?
-        attr_reader :version
-
-        # KVM support status
-        attr_reader :kvm
-
         # Vagrant 1.5.x pool migration
         attr_reader :pool_migrate
 
         def initialize(uuid=nil)
           @logger = Log4r::Logger.new("vagrant::provider::kvm::driver")
           @uuid = uuid
-          # This should be configurable
-          @pool_name = "vagrant"
-          @network_name = "vagrant"
+          @virsh_path = "virsh"
           @pool_migrate = false
 
           load_kvm_module!
           connect_libvirt_qemu!
-          init_storage_pool!
 
           if @uuid
             # Verify the VM exists, and if it doesn't, then don't worry
@@ -150,17 +142,20 @@ module VagrantPlugins
         # @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={})
+        def import(box_xml_filename, volume_name, args={})
           @logger.info("Importing VM #{@name}")
           # create vm definition from xml
-          definition = File.open(definition) { |f| Util::VmDefinition.new(f.read) }
+          definition = File.open(box_xml_filename) { |f| Util::VmDefinition.new(f.read) }
           volume_path = lookup_volume_path_by_name(volume_name)
           args = {
             :image_type => "qcow2",
             :qemu_bin => "/usr/bin/qemu",
             :disk => volume_path,
-            :name => @name
+            :network => 'vagrant',
+            :name => @name,
+            :uuid => nil
           }.merge(args)
+          args.merge!(:virtio_rng => nil) if @conn.version.to_i < 1003000  # virtio_rng supported in 1.3.0+
           definition.update(args)
           # create vm
           @logger.info("Creating new VM")
@@ -172,33 +167,58 @@ module VagrantPlugins
 
         # Create network
         def create_network(config)
+          # Get the network if it exists
+          network_name = config[:name]
+          hosts = config[:hosts]
+          @logger.info("empty host!") unless hosts
           begin
-            # Get the network if it exists
-            @network = @conn.lookup_network_by_name(@network_name)
-            definition = Util::NetworkDefinition.new(@network_name,
-                                                     @network.xml_desc)
-          rescue Libvirt::RetrieveError
-            # Network doesn't exist, create with defaults
-            definition = Util::NetworkDefinition.new(@network_name)
-          end
-          definition.update(config)
-          if @network.nil?
-            @logger.info("Creating network #{@network_name}")
-            @network = define_network(definition) 
-          else
+            network = @conn.lookup_network_by_name(network_name)
+            definition = Util::NetworkDefinition.new(network_name,
+                                                     network.xml_desc)
+            old_def    = Util::NetworkDefinition.new(network_name,
+                                                     network.xml_desc)
+            definition.update(config)
+            @logger.info("Update network #{network_name}")
+            @logger.debug("From:\n#{old_def.as_xml}")
+            @logger.debug("TO:\n#{definition.as_xml}")
+
             # 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) 
+            if network.active?
+              @logger.info "Reusing existing configuration for #{network_name}"
+              update_command = Libvirt::Network::NETWORK_UPDATE_COMMAND_ADD_LAST
+              hosts.each do |host|
+                if old_def.already_exist_host?(host)
+                  update_command = Libvirt::Network::NETWORK_UPDATE_COMMAND_MODIFY
+                end
+              end
+              if update_command == Libvirt::Network::NETWORK_UPDATE_COMMAND_MODIFY
+                  @logger.info ("Updating network #{network_name} using UPDATE_COMMAND_MODIFY")
+              else
+                  @logger.info ("Updating network #{network_name} using UPDATE_COMMAND_ADD_LAST")
+             end
+
+             network.update(update_command,
+              Libvirt::Network::NETWORK_SECTION_IP_DHCP_HOST,
+              -1,
+              definition.as_host_xml,
+              Libvirt::Network::NETWORK_UPDATE_AFFECT_CURRENT
+              )
+             network.create unless network.active?
+            else # network is not active
+              @logger.info "Recreating network config for #{network_name}"
+              network.undefine
+              network = define_network(definition)
             end
+
+          rescue Libvirt::RetrieveError
+            # Network doesn't exist, create with defaults
+            definition = Util::NetworkDefinition.new(network_name)
+            definition.update(config)
+            @logger.info("Creating network #{network_name}")
+            @logger.debug("with\n#{definition.as_xml}")
+            network = define_network(definition)
           end
         end
 
@@ -210,68 +230,100 @@ module VagrantPlugins
           network
         end
 
-        # Initialize or create storage pool
-        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 = File.join(base_path, "/storage-pool")
-          FileUtils.mkpath(pool_path) unless Dir.exists?(pool_path)
-          init_storage_directory(
-                     :pool_path => pool_path,
-                     :pool_name => @pool_name,
-                     :owner => uid, :group=>gid, :mode=>'755')
-          init_storage_pool!
+        def get_default_ip
+          "192.168.123.10"
         end
 
-        def init_storage_directory(args={})
+        def read_machine_ip
+          if @uuid && vm_exists?(@uuid)
+            begin
+              domain = @conn.lookup_domain_by_uuid(@uuid)
+              definition = Util::VmDefinition.new(domain.xml_desc)
+              mac_address = definition.get(:mac)
+              network_name = definition.get(:network)
+              network = @conn.lookup_network_by_name(network_name)
+              network_definition = Util::NetworkDefinition.new(network_name,
+                                                     network.xml_desc)
+              network_definition.get(:hosts).each do |host|
+                return host[:ip] if mac_address == host[:mac]
+              end
+            rescue Libvirt::RetrieveError
+              @logger.info("cannot get definition og #{@uuid}")
+            end
+          else
+            @logger.debug("missing uuid? #{@uuid}")
+          end
+          get_default_ip
+        end
+
+        # Activate the driver's storage pool
+        def activate_storage_pool(pool_name)
+          # Get storage pool if it exists
+          @pool = init_storage_pool(pool_name)
+          # check neccesity of migrating to new storage pool format
+          # this is happen when user has already used vagrant-kvm 0.1.5 and after
+          # XXX needs clarification
+          check_migrate_box_storage_pool
+          @logger.info("Retrieving storage pool #{pool_name}")
+        end
+
+        # Initialize or Create a new storage pool
+        def init_storage_pool(pool_name, pool_path='/tmp', dir_mode='0755')
           begin
-            # Get the storage pool if it exists
-            pool = @conn.lookup_storage_pool_by_name(args[:pool_name])
-            @logger.info("Init storage pool #{args[:pool_name]}")
+            # Try to retrieve the storage pool
+            pool = @conn.lookup_storage_pool_by_name(pool_name)
+            @logger.info("Activating storage pool #{pool_name}")
+            pool.create unless pool.active?
+            pool.refresh
+            pool
           rescue Libvirt::RetrieveError
-             @logger.info("Init storage pool with owner: #{args[:owner]}")
-             storage_pool_xml = <<-EOF
+            create_storage_pool(pool_name, pool_path, dir_mode)
+          end
+        end
+
+        def create_storage_pool(pool_name, pool_path, dir_mode)
+          @logger.info("Creating new storage pool #{pool_name} in #{pool_path}")
+          # create dir if it doesn't exist
+          FileUtils.mkpath(pool_path) unless Dir.exists?(pool_path)
+          storage_pool_xml = <<-EOF
               <pool type="dir">
-              <name>#{args[:pool_name]}</name>
+              <name>#{pool_name}</name>
               <target>
-                <path>#{args[:pool_path]}</path>
+                <path>#{pool_path}</path>
                 <permissions>
-                 <owner>#{args[:owner]}</owner>
-                 <group>#{args[:group]}</group>
-                 <mode>#{args[:mode]}</mode>
+                 <owner>#{Process.uid}</owner>
+                 <group>#{Process.gid}</group>
+                 <mode>#{dir_mode}</mode>
                 </permissions>
               </target>
               </pool>
-             EOF
-            # create transient pool
-            #
-            # WARN:
-            #  vagrant-kvm 0.1.5 uses
-            #     pool = @conn.define_storage_pool_xml(storage_pool_xml)
-            #  that made 'pesistent' storage pool
-            #  this caused problem when following sinario:
-            #
-            #  1. user use vagrant-kvm 0.1.5 with vagrant-1.4.x
-            #  2. user upgrade vagrant 1.5.x
-            #  3. user upgrade vagrant 0.1.5.1 and after
-            #
-            #  vagrant-kvm 0.1.5 don't work with vagrant 1.5.x
-            #  previous synario can be happned on many user.
-            #
-            # We use transient pool instead of persistent one
-            # in vagrant-kvm 0.1.5.x, 0.1.6 and after
-            #
-            #  Pools defined here will be removed after system reboot.
-            #
+          EOF
+          # Create transient pool
+          # Pools defined here will be removed after system reboot.
+          @logger.debug("Creating storage pool with XML:\n #{storage_pool_xml}")
+          begin
             pool = @conn.create_storage_pool_xml(storage_pool_xml)
             pool.build unless pool.active?
-            #XXX use? pool.build(Libvirt::StoragePool::BUILD_NO_OVERWRITE)
-            @logger.info("Creating storage pool #{args[:pool_name]} in #{args[:pool_path]}")
+            pool.refresh
+            pool
+          rescue
+            # check conflict and shutdown old pool
+            defined_pool_list = @conn.list_storage_pools
+            defined_pool_list.each do |defined_pool_name|
+              defined_pool = @conn.lookup_storage_pool_by_name(defined_pool_name)
+              defined_pool_doc = REXML::Document.new defined_pool.xml_desc
+              defined_pool_path = File.expand_path(defined_pool_doc.elements["/pool/target/path"].text)
+              @logger.debug("check whether conflict with #{defined_pool_name} on #{defined_pool_path}")
+              if defined_pool_path == File.expand_path(pool_path)
+                defined_pool.destroy
+                pool = @conn.create_storage_pool_xml(storage_pool_xml)
+                pool.build unless pool.active?
+                pool.refresh
+                return pool
+              end
+            end
+            raise Errors::KvmFailStoragePool
           end
-          pool.create unless pool.active?
-          pool.refresh
-          pool
         end
 
         def check_migrate_box_storage_pool
@@ -286,7 +338,7 @@ module VagrantPlugins
                 @pool_migrate = true
               end
             rescue Libvirt::RetrieveError
-              @logger.info("fail to retrieve storage pool")
+              raise Errors::KvmFailStoragePool
             end
           end
         end
@@ -302,11 +354,45 @@ module VagrantPlugins
           end
         end
 
+        def storage_pool_path
+          doc = REXML::Document.new @pool.xml_desc
+          doc.elements["/pool/target/path"].text
+        end
+
         def lookup_volume_path_by_name(volume_name)
           volume = @pool.lookup_volume_by_name(volume_name)
           volume.path
         end
 
+        def list_all_network_ips
+          interfaces = read_network_interfaces
+          ips = []
+          interfaces.each do |interface|
+            next if interface.type == :user
+            ips << list_network_ips(interface.name)
+          end
+          ips
+        end
+
+        def list_default_network_ips
+          list_network_ips('vagrant')
+        end
+
+        def list_network_ips(network_name)
+          begin
+            network = @conn.lookup_network_by_name(network_name)
+            network_definition = Util::NetworkDefinition.new(network_name, network.xml_desc)
+            ips = []
+            if network_definition
+              ips = network_definition.hosts.map {|host| host[:ip]}
+            end
+            ips
+          rescue Libvirt::RetrieveError
+            @logger.info("error when getting network xml")
+            []
+          end
+        end
+
         # Returns a list of network interfaces of the VM.
         #
         # @return [Hash]
@@ -333,6 +419,22 @@ module VagrantPlugins
           end
         end
 
+        # Returns a hostname of the guest
+        # introduced from ruby-libvirt 0.5.0
+        #
+        # @return [String]
+        def hostname?
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.hostname
+        end
+
+        # reset the guest
+        # introduced from ruby-libvirt 0.5.0
+        def reset
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.reset
+        end
+
         def read_state
           domain = @conn.lookup_domain_by_uuid(@uuid)
           state, reason = domain.state
@@ -369,6 +471,7 @@ module VagrantPlugins
 
         def set_mac_address(mac)
           update_domain_xml(:mac => mac)
+          @logger.debug("set mac: #{mac}")
         end
 
         def set_gui(vnc_port, vnc_autoport, vnc_password)
@@ -384,6 +487,14 @@ module VagrantPlugins
           update_domain_xml(:disk_bus => disk_bus)
         end
 
+        def share_folders(folders)
+          update_domain_xml(:p9 => folders)
+        end
+
+        def clear_shared_folders
+          #stub
+        end
+
         def update_domain_xml(options)
           domain = @conn.lookup_domain_by_uuid(@uuid)
           # Use DOMAIN_XML_SECURE to dump ALL options (including VNC password)
@@ -396,6 +507,18 @@ module VagrantPlugins
           @conn.define_domain_xml(xml)
         end
 
+        def add_nic(nic)
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          # 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.add_nic(nic)
+          domain.undefine
+          xml = definition.as_xml
+          @logger.debug("add nic\nFrom #{original_xml} \nTo: #{xml}")
+          @conn.define_domain_xml(xml)
+        end
+
         # Starts the virtual machine.
         def start
           domain = @conn.lookup_domain_by_uuid(@uuid)
@@ -409,6 +532,20 @@ module VagrantPlugins
           domain.managed_save
         end
 
+        # Suspend for duration
+        # introduced from ruby-libvirt 0.5.0
+        def suspend_for_duration(target, duration)
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.pmsuspend_for_duration(target, duration)
+        end
+
+        # Wakeup the virtual machine
+        # introduced from ruby-libvirt 0.5.0
+        def wakeup
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.pmwakeup
+        end
+
         def can_save?
           domain = @conn.lookup_domain_by_uuid(@uuid)
           definition = Util::VmDefinition.new(domain.xml_desc)
@@ -446,7 +583,36 @@ module VagrantPlugins
           end
         end
 
-        # Verifies that the driver is ready and the connection is open
+        # Executes a command and returns the raw result object.
+        def raw(*command, &block)
+          int_callback = lambda do
+            @interrupted = true
+            @logger.info("Interrupted.")
+          end
+
+          # Append in the options for subprocess
+          command << { :notify => [:stdout, :stderr] }
+
+          Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute(@virsh_path, *command, &block)
+          end
+        end
+
+        def execute_command(command)
+          raw(*command)
+        end
+
+        # Verifies that the connection is alive
+        # introduced from ruby-libvirt 0.5.0
+        #
+        # This will raise a VagrantError if things are not ready.
+        def alive!
+          unless @conn.alive?
+            raise Vagrant::Errors::KvmNoConnection
+          end
+        end
+
+        # Verifies that the driver is	 ready and the connection is open
         #
         # This will raise a VagrantError if things are not ready.
         def verify!
@@ -470,41 +636,41 @@ module VagrantPlugins
         # Checks which Linux OS variants
         #
         # host_redhat?
+        # host_ubuntu?
         # 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
+          # Check also Korora, CentOS, Fedora,
+          #   Oracle Linux < 5.3 and
+          #   Red Hat Enterprise Linux and Oracle Linux >= 5.3
+          return true if check_os_release?("/etc/redhat-release",
+            ["CentOS","Fedora","Korora","Enterprise Linux Enterprise Linux","Red Hat Enterprise Linux"])
+          false
+        end
 
-              # Oracle Linux < 5.3
-              return true if contents =~ /^Enterprise Linux Enterprise Linux/
+        def host_suse?
+          check_os_release?("/etc/SuSE-release")
+        end
 
-              # Red Hat Enterprise Linux and Oracle Linux >= 5.3
-              return true if contents =~ /^Red Hat Enterprise Linux/
-            end
+        def host_ubuntu?
+          if rel = check_lsb_release?
+            return true if rel == "Ubuntu"
           end
-
           false
         end
 
         def host_debian?
-          File.exists?("/etc/debian_version")
+          check_os_release?("/etc/debian_version")
         end
 
         def host_gentoo?
-          File.exists?("/etc/gentoo-release")
+          check_os_release?("/etc/gentoo-release")
         end
 
         def host_arch?
-          File.exist?("/etc/arch-release")
+          check_os_release?("/etc/arch-release")
         end
 
         private
@@ -520,6 +686,30 @@ module VagrantPlugins
           "#{maj}.#{min}.#{rel}"
         end
 
+        # Check contents of release file
+        #
+        # filename: release file path
+        # criteria: ["CentOS","Fedora",...]
+        def check_os_release?(filename, criteria=nil)
+          return File.exists?(filename) unless criteria
+
+          release_file = Pathname.new(filename)
+          if release_file.exist?
+            release_file.open("r:ISO-8859-1:UTF-8") do |f|
+              contents = f.gets
+              criteria.each do |c|
+                return true if contents =~ /^#{c}/
+              end
+            end
+          end
+          false
+        end
+
+        def check_lsb_release?
+          return false unless File.exists?("/usr/bin/lsb_release")
+          IO.popen('/usr/bin/lsb_release -i') { |o| o.read.chomp.split("\t") }[1]
+        end
+
         def load_kvm_module!
           @logger.info("Check KVM kernel modules")
           kvm = File.readlines('/proc/modules').any? { |line| line =~ /kvm_(intel|amd)/ }
@@ -542,6 +732,7 @@ module VagrantPlugins
           # Open a connection to the qemu driver
           begin
             @conn = Libvirt::open('qemu:///system')
+            @conn.capabilities
           rescue Libvirt::Error => e
             if e.libvirt_code == 5
               # can't connect to hypervisor
@@ -551,24 +742,19 @@ module VagrantPlugins
             end
           end
 
-          @version = read_version
+          hv_type = @conn.type.to_s
+          unless hv_type == "QEMU"
+            raise Errors::KvmUnsupportedHypervisor,
+              :actual => hv_type, :required => "QEMU"
+          end
+
+          version = read_version
           if @conn.version.to_i < 1001000
             raise Errors::KvmInvalidVersion,
-              :actual => @version, :required => ">= 1.1.0"
+              :actual => version, :required => ">= 1.1.0"
           end
         end
 
-        def init_storage_pool!
-          # Get storage pool if it exists
-          begin
-            @pool = @conn.lookup_storage_pool_by_name(@pool_name)
-            # this is happen when user has already used vagrant-kvm 0.1.5 and after
-            # check neccesity of migration
-            check_migrate_box_storage_pool
-          rescue Libvirt::RetrieveError
-            # storage pool doesn't exist yet
-          end
-        end
       end
     end
   end