vagrant-kvm 0.1.4 → 0.1.5

data/lib/vagrant-kvm/errors.rb

@@ -6,12 +6,30 @@ module VagrantPlugins
       class VagrantKVMError < Vagrant::Errors::VagrantError
         error_namespace("vagrant_kvm.errors")
       end
+
       class KvmNoConnection < VagrantKVMError
         error_key(:kvm_no_connection)
       end
+
       class KvmInvalidVersion < VagrantKVMError
         error_key(:kvm_invalid_version)
       end
+
+      class KvmNoQEMUBinary < VagrantKVMError
+        error_key(:kvm_no_qemu_binary)
+      end
+
+      class KvmFailImageConversion < VagrantKVMError
+        error_key(:kvm_fail_image_conversion)
+      end
+
+      class KvmBadBoxFormat < VagrantKVMError
+        error_key(:kvm_bad_box_format)
+      end
+
+      class KvmFailedCommand < VagrantKVMError
+        error_key(:kvm_failed_command)
+      end
     end
   end
 end

data/lib/vagrant-kvm/provider.rb

@@ -66,7 +66,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
 
       # Return the state of the VM
@@ -81,6 +83,7 @@ module VagrantPlugins
         state_id = :not_created if !@driver.uuid
         state_id = @driver.read_state if !state_id
         state_id = :unknown if !state_id
+        @logger.info("state is now:", state_id)
 
         # TODO Translate into short/long descriptions
         short = state_id

data/lib/vagrant-kvm/util.rb

@@ -4,9 +4,12 @@ module VagrantPlugins
   module ProviderKvm
     module Util
       util_root = Pathname.new(File.expand_path("../util", __FILE__))
+      autoload :DefinitionAttributes, util_root.join("definition_attributes")
       autoload :VmDefinition, util_root.join("vm_definition")
       autoload :NetworkDefinition, util_root.join("network_definition")
       autoload :KvmTemplateRenderer, util_root.join("kvm_template_renderer")
+      autoload :Commands, util_root.join("commands")
+      autoload :DiskInfo, util_root.join("disk_info")
     end
   end
 end

data/lib/vagrant-kvm/util/commands.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Util
+      module Commands
+        def run_root_command(cmd)
+          # FIXME detect whether 'sudo' or 'su -c'
+          # for safety, we run cmd as single argument of sudo
+          unless res = system('sudo ' + cmd)
+            raise Errors::KvmFailedCommand, cmd: cmd, res: res
+          end
+        end
+
+        def run_command(cmd)
+          unless res = system(cmd)
+            raise Errors::KvmFailedCommand, cmd: cmd, res: res
+          end
+          res
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-kvm/util/definition_attributes.rb

@@ -0,0 +1,33 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Util
+      module DefinitionAttributes
+        module InstanceMethods
+          def attributes
+            @attributes ||= {}
+          end
+
+          def attributes=(attrs)
+            @attributes = attrs
+          end
+
+          def get(key)
+            attributes[key]
+          end
+
+          def set(key, val)
+            attributes[key] = val
+          end
+
+          def update(args={})
+            attributes.merge!(args)
+          end
+        end
+
+        def self.included(receiver)
+          receiver.send :include, InstanceMethods
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/util/disk_info.rb

@@ -0,0 +1,48 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Util
+      class DiskInfo
+        include Errors
+
+        attr_reader :backing, :capacity, :cluster, :size, :type
+
+        def initialize(vol_path)
+          logger = Log4r::Logger.new("vagrant::kvm::util::disk_info")
+          # default values
+          @capacity = {:size => 10, :unit => 'G'}
+          @backing = nil
+          @cluster = nil
+          begin
+            diskinfo = %x[qemu-img info #{vol_path}]
+            diskinfo.each_line do |line|
+              case line
+              when /^file format:/
+                result = line.match(%r{file format:\s+(?<format>(\w+))})
+                @type = result[:format]
+              when /virtual size:/
+                result = line.match(%r{virtual size:\s+(?<size>\d+(\.\d+)?)(?<unit>.)\s+\((?<bytesize>\d+)\sbytes\)})
+                # always take the size in bytes to avoid conversion
+                @capacity = {:size => result[:bytesize], :unit => "B"}
+              when /^disk size:/
+                result = line.match(%r{disk size:\s+(?<size>\d+(\.\d+)?)(?<unit>.)})
+                @size = {:size => result[:size], :unit => result[:unit]}
+              when /^backing file:/
+                result = line.match(%r{backing file:\s+(?<file>(\S+))})
+                @backing = result[:file]
+              when /^cluster[_ ]size:/
+                result = line.match(%r{cluster[_ ]size:\s+(?<size>(\d+))})
+                @cluster = result[:size]
+              end
+            end
+          rescue Errors::KvmFailedCommand => e
+            logger.error 'Failed to find volume size. Using defaults.'
+            logger.error e
+          end
+        end
+
+        # TBD backing chain 'qemu-img info --backing-chain'
+
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/util/network_definition.rb

@@ -1,105 +1,65 @@
 # Utility class to manage libvirt network definition
-require "nokogiri"
+require "rexml/document"
 
 module VagrantPlugins
   module ProviderKvm
     module Util
       class NetworkDefinition
-        # Attributes of the Network
-        attr_reader :name
-        attr_reader :domain_name
-        attr_reader :base_ip
+        include DefinitionAttributes
 
         def initialize(name, definition=nil)
-          @name = name
+          # create with defaults
+          # XXX defaults should move to config
+          self.attributes = {
+            :forward => "nat",
+            :domain_name => "vagrant.local",
+            :base_ip => "192.168.192.1",
+            :netmask => "255.255.255.0",
+            :range => {
+              :start => "192.168.192.100",
+              :end => "192.168.192.200",
+            },
+            :hosts => [],
+            name: name,
+          }
+
           if definition
-            doc = Nokogiri::XML(definition)
-            @forward = doc.at_css("network forward")["mode"] if doc.at_css("network forward")
-            @domain_name = doc.at_css("network domain")["name"] if doc.at_css("network domain")
-            @base_ip = doc.at_css("network ip")["address"]
-            @netmask = doc.at_css("network ip")["netmask"]
-            @range = {
-              :start => doc.at_css("network ip dhcp range")["start"],
-              :end => doc.at_css("network ip dhcp range")["end"]
-            }
-            @hosts = []
-            doc.css("network ip dhcp host").each do |host|
-              @hosts << {
-                :mac => host["mac"],
-                :name => host["name"],
-                :ip => host["ip"]
+            doc = REXML::Document.new definition
+            if doc.elements["/network/forward"]
+              set(:forward, doc.elements["/network/forward"].attributes["mode"]) 
+            end
+
+            if doc.elements["/network/domain"]
+              set(:domain_name, doc.elements["/network/domain"].attributes["name"]) 
+            end
+            set(:base_ip, doc.elements["/network/ip"].attributes["address"])
+            set(:netmask, doc.elements["/network/ip"].attributes["netmask"])
+            set(:range, {
+              :start => doc.elements["/network/ip/dhcp/range"].attributes["start"],
+              :end => doc.elements["/network/ip/dhcp/range"].attributes["end"]
+            })
+            hosts = []
+            doc.elements.each("/network/ip/dhcp/host") do |host|
+              hosts << {
+                :mac => host.attributes["mac"],
+                :name => host.attributes["name"],
+                :ip => host.attributes["ip"]
               }
             end
-          else
-            # create with defaults
-            # XXX defaults should move to config
-            @forward = "nat"
-            @domain_name = "vagrant.local"
-            @base_ip = "192.168.192.1"
-            @netmask = "255.255.255.0"
-            @range = {
-              :start => "192.168.192.100",
-              :end => "192.168.192.200"}
-            @hosts = []
+            set(:hosts, hosts)
           end
         end
 
-        def configure(config)
-          config = {
-            :forward => @forward,
-            :domain_name => @domain_name,
-            :base_ip => @base_ip,
-            :netmask => @netmask,
-            :range => @range,
-            :hosts => @hosts}.merge(config)
-
-            @forward = config[:forward]
-            @domain_name = config[:domain_name]
-            @base_ip = config[:base_ip]
-            @netmask = config[:netmask]
-            @range = config[:range]
-            @hosts = config[:hosts]
-        end
-
-        def as_xml
-          xml = <<-EOXML
-            <network>
-              <name>#{@name}</name>
-              <forward mode='#{@forward}'/>
-              <domain name='#{@domain_name}'/>
-              <ip address='#{@base_ip}' netmask='#{@netmask}'>
-                <dhcp>
-                <range start='#{@range[:start]}' end='#{@range[:end]}' />
-                </dhcp>
-              </ip>
-            </network>
-          EOXML
-          xml = inject_hosts(xml) if @hosts.length > 0
-          xml
-        end
-
-        def add_host(host)
-          cur_host = @hosts.detect {|h| h[:mac] == host[:mac]}
-          if cur_host
-            cur_host[:ip] = host[:ip]
-            cur_host[:name] = host[:name]
-          else
-            @hosts << {
-              :mac => host[:mac],
-              :name => host[:name],
-              :ip => host[:ip]}
+        def ==(other)
+          # Don't compare the hosts
+          [:forward, :domain_name, :base_ip, :netmask, :range,].all? do |key|
+            get(key) == other.get(key)
           end
         end
 
-        def inject_hosts(xml)
-          doc = Nokogiri::XML(xml)
-          entry_point = doc.at_css("network ip dhcp range")
-          @hosts.each do |host|
-            entry_point.add_next_sibling "<host mac='#{host[:mac]}' name='#{host[:name]}' ip='#{host[:ip]}' />"
-          end
-          doc.to_xml
+        def as_xml
+          KvmTemplateRenderer.render("libvirt_network", attributes.dup)
         end
-
       end
     end
   end

data/lib/vagrant-kvm/util/vm_definition.rb

@@ -1,135 +1,119 @@
 # Utility class to translate ovf definition to libvirt XML
 # and manage XML formatting for libvirt interaction
 # Not a full OVF converter, only the minimal needed definition
-require "nokogiri"
+require "rexml/document"
 
 module VagrantPlugins
   module ProviderKvm
     module Util
       class VmDefinition
-        # Attributes of the VM
-        attr_accessor :name
-        attr_reader :cpus
-        attr_accessor :disk
-        attr_reader :mac
-        attr_reader :arch
-        attr_reader :network
-        attr_accessor :image_type
+        include Errors
+        include DefinitionAttributes
 
         def self.list_interfaces(definition)
-          nics = {}
-          ifcount = 0
-          doc = Nokogiri::XML(definition)
+          nics = []
+          doc = REXML::Document.new definition
           # look for user mode interfaces
-          doc.css("devices interface[type='user']").each do |item|
-            ifcount += 1
-            adapter = ifcount
-            nics[adapter] ||= {}
-            nics[adapter][:type] = :user
+          doc.elements.each("//devices/interface[@type='user']") do |item|
+            nics << {:type => :user, :network => nil }
           end
           # look for interfaces on virtual network
-          doc.css("devices interface[type='network']").each do |item|
-            ifcount += 1
-            adapter = ifcount
-            nics[adapter] ||= {}
-            nics[adapter][:network] = item.at_css("source")["network"]
-            nics[adapter][:type] = :network
+          doc.elements.each("//devices/interface[@type='network']") do |item|
+            nics << {
+              :type => :network,
+              :network => item.elements["source"].attributes["network"].to_s
+            }
           end
           nics
         end
 
-        def initialize(definition, source_type='libvirt')
-          @uuid = nil
-          @gui = nil
-          @network = 'default'
-          if source_type == 'ovf'
-            create_from_ovf(definition)
-          else
-            create_from_libvirt(definition)
+        def initialize(definition)
+          self.attributes = {
+            :uuid         => nil,
+            :gui          => nil,
+            :vnc_autoport => false,
+            :vnc_password => nil,
+            :network      => 'default',
+            :network_model => 'virtio',
+            :video_model  => 'cirrus'
+          }
+          doc = REXML::Document.new definition
+          memory_unit = doc.elements["/domain/memory"].attributes["unit"]
+          update({
+            :name        => doc.elements["/domain/name"].text,
+            :cpus        => doc.elements["/domain/vcpu"].text,
+            :memory      => size_in_bytes(doc.elements["/domain/memory"].text,
+                                  memory_unit), # always :memory is in bytes
+            :arch        => doc.elements["/domain/os/type"].attributes["arch"],
+            :machine_type => doc.elements["/domain/os/type"].attributes["machine"],
+            :disk        => doc.elements["//devices/disk/source"].attributes["file"],
+            :network     => doc.elements["//devices/interface/source"].attributes["network"],
+            :network_model => :default,
+            :mac         => format_mac(doc.elements["//devices/interface/mac"].attributes["address"]),
+            :image_type  => doc.elements["//devices/disk/driver"].attributes["type"],
+            :qemu_bin    => doc.elements["/domain/devices/emulator"].text,
+            :video_model => doc.elements["/domain/devices/video/model"].attributes["type"],
+            :disk_bus    => doc.elements["//devices/disk/target"].attributes["bus"]
+          })
+          model_node = doc.elements["//devices/interface/model"]
+          if model_node
+            update({
+              :model_node  => model_node,
+              :network_model => model_node.attributes["type"]
+            })
           end
-        end
-
-        def create_from_ovf(definition)
-          doc = Nokogiri::XML(definition)
-          # we don't need no namespace
-          doc.remove_namespaces!
-          @name = doc.at_css("VirtualSystemIdentifier").content
-          devices = doc.css("VirtualHardwareSection Item")
-          for device in devices
-            case device.at_css("ResourceType").content
-              # CPU
-            when "3"
-              @cpus = device.at_css("VirtualQuantity").content
-              # Memory
-            when "4"
-              @memory = size_in_bytes(device.at_css("VirtualQuantity").content,
-                                      device.at_css("AllocationUnits").content)
-            end
+          if doc.elements["/domain/uuid"]
+            update({:uuid => doc.elements["/domain/uuid"].text})
+          end
+          if doc.elements["//devices/graphics"]
+            attrs = doc.elements["//devices/graphics"].attributes
+            update({
+              :gui          => attrs["type"] == 'vnc',
+              :vnc_port     => attrs['port'].to_i,
+              :vnc_autoport => attrs['autoport'] == 'yes',
+              :vnc_password => attrs['passwd']
+            })
           end
-
-          # disk volume
-          diskref = doc.at_css("DiskSection Disk")["fileRef"]
-          @disk = doc.at_css("References File[id='#{diskref}']")["href"]
-          @image_type = 'raw'
-          # mac address
-          # XXX we use only the first nic
-          @mac = format_mac(doc.at_css("Machine Hardware Adapter[enabled='true']")['MACAddress'])
-
-          # the architecture is not defined in the ovf file
-          # we try to guess from OSType
-          # see https://www.virtualbox.org/browser/vbox/trunk/src/VBox/Main/include/ovfreader.h
-          @arch = doc.at_css("VirtualSystemIdentifier").
-            content[-2..-1] == '64' ? "x86_64" : "i686"
         end
 
-        def create_from_libvirt(definition)
-          doc = Nokogiri::XML(definition)
-          @name = doc.at_css("domain name").content
-          @uuid = doc.at_css("domain uuid").content if doc.at_css("domain uuid")
-          memory_unit = doc.at_css("domain memory")["unit"]
-          @memory = size_in_bytes(doc.at_css("domain memory").content,
-                                  memory_unit)
-          @cpus = doc.at_css("domain vcpu").content
-          @arch = doc.at_css("domain os type")["arch"]
-          @disk = doc.at_css("devices disk source")["file"]
-          @mac = doc.at_css("devices interface mac")["address"]
-          @network = doc.at_css("devices interface source")["network"]
-          @image_type = doc.at_css("devices disk driver")["type"]
-        end
+        def as_xml
+          if attributes[:qemu_bin]
+            # user specified path of qemu binary
+            qemu_bin_list = [attributes[:qemu_bin]]
+          else
+            # RedHat and Debian-based systems have different executable names
+            # depending on version/architectures
+            qemu_bin_list = ['/usr/bin/qemu-system-x86_64'] if get(:arch).match(/64$/)
+            qemu_bin_list = ['/usr/bin/qemu-system-i386']   if get(:arch).match(/^i.86$/)
+            qemu_bin_list += [ '/usr/bin/qemu-kvm', '/usr/bin/kvm' ]
+          end
 
-        def as_libvirt
-          # RedHat and Debian-based systems have different executable names
-          # depending on version/architectures
-          qemu_bin = [ '/usr/bin/qemu-kvm', '/usr/bin/kvm' ]
-          qemu_bin << '/usr/bin/qemu-system-x86_64' if @arch.match(/64$/)
-          qemu_bin << '/usr/bin/qemu-system-i386'   if @arch.match(/^i.86$/)
+          qemu_bin = qemu_bin_list.detect { |binary| File.exists? binary }
+          if not qemu_bin
+            raise Errors::KvmNoQEMUBinary,
+            :cause => attributes[:qemu_bin] ?
+            "Vagrantfile (specified binary: #{attributes[:qemu_bin]})" : "QEMU installation"
+          end
 
-          xml = KvmTemplateRenderer.render("libvirt_domain", {
-            :name => @name,
-            :uuid => @uuid,
-            :memory => size_from_bytes(@memory, "KiB"),
-            :cpus => @cpus,
-            :arch => @arch,
-            :disk => @disk,
-            :mac => format_mac(@mac),
-            :network => @network,
-            :gui => @gui,
-            :image_type => @image_type,
-            :qemu_bin => qemu_bin.detect { |binary| File.exists? binary }
-          })
+          xml = KvmTemplateRenderer.render("libvirt_domain",
+                attributes.merge!(:memory_size => get_memory("KiB"),
+                                  :memory_unit => "KiB")
+                )
           xml
         end
 
         def get_memory(unit="bytes")
-          size_from_bytes(@memory, unit)
+          size_from_bytes(get(:memory), unit)
         end
 
-        def set_mac(mac)
-          @mac = format_mac(mac)
-        end
-
-        def set_gui
-          @gui = true
+        def update(args={})
+          args.each {|k,v|
+            case k
+            when :mac
+              args[:mac] = format_mac(args[:mac])
+            end
+          }
+          super(args)
         end
 
         # Takes a quantity and a unit
@@ -193,6 +177,10 @@ module VagrantPlugins
           end
         end
 
+        def format_bool(v)
+          v ? "yes" : "no"
+        end
+
         def format_mac(mac)
           if mac.length == 12
             mac = mac[0..1] + ":" + mac[2..3] + ":" +