vagrant-kvm 0.1.0

data/lib/vagrant-kvm/errors.rb

@@ -0,0 +1,11 @@
+require "vagrant"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Errors
+      class VagrantKVMError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_kvm.errors")
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant KVM plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.1.0"
+  raise "The Vagrant KVM plugin is only compatible with Vagrant 1.1+"
+end
+
+module VagrantPlugins
+  module ProviderKvm
+    class Plugin < Vagrant.plugin("2")
+      name "KVM provider"
+      description <<-EOF
+      The KVM provider allows Vagrant to manage and control
+      QEMU/KVM virtual machines with libvirt.
+      EOF
+
+      config(:kvm, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:kvm) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", ProviderKvm.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_kvm")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/provider.rb

@@ -0,0 +1,104 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module ProviderKvm
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :driver
+
+      def initialize(machine)
+        @logger  = Log4r::Logger.new("vagrant_kvm")
+        @machine = machine
+
+        # This method will load in our driver, so we call it now to
+        # initialize it.
+        machine_id_changed
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      # If the machine ID changed, then we need to rebuild our underlying
+      # driver.
+      def machine_id_changed
+        id = @machine.id
+
+        begin
+          @logger.debug("Instantiating the driver for machine ID: #{@machine.id.inspect}")
+          @driver = Driver::Driver.new(id)
+        rescue Driver::Driver::VMNotFound
+          # The virtual machine doesn't exist, so we probably have a stale
+          # ID. Just clear the id out of the machine and reload it.
+          @logger.debug("VM not found! Clearing saved machine ID and reloading.")
+          id = nil
+          retry
+        end
+      end
+
+      # Returns the SSH info for accessing the VM.
+      def ssh_info
+        # If the VM is not created then we cannot possibly SSH into it, so
+        # we return nil.
+        return nil if state == :not_created
+
+        #ip_addr = @driver.read_ip(@machine.config.vm.base_mac)
+        return {
+          :host => read_machine_ip,
+          :port => "22" # XXX should be somewhere in default config
+        }
+      end
+
+      # XXX duplicated from prepare_nfs_settings
+      # Returns the IP address of the guest by looking at the first
+      # enabled host only network.
+      #
+      # @return [String]
+      def read_machine_ip
+        @machine.config.vm.networks.each do |type, options|
+          if type == :private_network && options[:ip].is_a?(String)
+            return options[:ip]
+          end
+        end
+
+        nil
+      end
+
+      # Return the state of the VM
+      #
+      # @return [Symbol]
+      def state
+        # XXX: What happens if we destroy the VM but the UUID is still
+        # set here?
+
+        # Determine the ID of the state here.
+        state_id = nil
+        state_id = :not_created if !@driver.uuid
+        state_id = @driver.read_state if !state_id
+        state_id = :unknown if !state_id
+
+        # TODO Translate into short/long descriptions
+        short = state_id
+        long  = I18n.t("vagrant.commands.status.#{state_id}")
+
+        # Return the state
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      # Returns a human-friendly string version of this provider which
+      # includes the machine's ID that this provider represents, if it
+      # has one.
+      #
+      # @return [String]
+      def to_s
+        id = @machine.id ? @machine.id : "new VM"
+        "QEMU/KVM (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/util.rb

@@ -0,0 +1,12 @@
+require "pathname"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Util
+      util_root = Pathname.new(File.expand_path("../util", __FILE__))
+      autoload :VmDefinition, util_root.join("vm_definition")
+      autoload :NetworkDefinition, util_root.join("network_definition")
+      autoload :KvmTemplateRenderer, util_root.join("kvm_template_renderer")
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module ProviderKvm
+    module Util
+      # For TemplateRenderer
+      include Vagrant::Util
+      class KvmTemplateRenderer < TemplateRenderer
+
+        # Returns the full path to the template, taking into accoun the gem directory
+        # and adding the `.erb` extension to the end.
+        #
+        # @return [String]
+        def full_template_path
+          ProviderKvm.source_root.join('templates', "#{template}.erb").to_s.squeeze("/")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# Utility class to manage libvirt network definition
+require "nokogiri"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Util
+      class NetworkDefinition
+        # Attributes of the Network
+        attr_reader :name
+        attr_reader :domain_name
+        attr_reader :base_ip
+
+        def initialize(name, definition=nil)
+          @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"]
+              }
+            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 = []
+          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]}
+          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
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# 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"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Util
+      class VmDefinition
+        # Attributes of the VM
+        attr_reader :name
+        attr_reader :cpus
+        attr_accessor :disk
+        attr_reader :mac
+        attr_reader :arch
+        attr_reader :network
+
+        def self.list_interfaces(definition)
+          nics = {}
+          ifcount = 0
+          doc = Nokogiri::XML(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
+          end
+          # look for interfaces on virtual network
+          doc.css("devices interface[type='netwok']").each do |item|
+            ifcount += 1
+            adapter = ifcount
+            nics[adapter] ||= {}
+            nics[adapter][:network] = item.at_css("source")["network"]
+            nics[adapter][:type] = :network
+          end
+          nics
+        end
+
+        def initialize(definition, source_type='libvirt')
+          @uuid = nil
+          @network = 'default'
+          if source_type == 'ovf'
+            create_from_ovf(definition)
+          else
+            create_from_libvirt(definition)
+          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
+          end
+
+          # disk volume
+          diskref = doc.at_css("DiskSection Disk")["fileRef"]
+          @disk = doc.at_css("References File[id='#{diskref}']")["href"]
+
+          # 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"]
+        end
+
+        def as_libvirt
+          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
+          })
+          xml
+        end
+
+        def get_memory(unit="bytes")
+          size_from_bytes(@memory, unit)
+        end
+
+        def set_mac(mac)
+          @mac = format_mac(mac)
+        end
+
+        # Takes a quantity and a unit
+        # returns quantity in bytes
+        # mib = true to use mebibytes, etc
+        # defaults to false because ovf MB != megabytes
+        def size_in_bytes(qty, unit, mib=false)
+          qty = qty.to_i
+          unit = unit.downcase
+          if !mib
+            case unit
+            when "kb", "kilobytes"
+              unit = "kib"
+            when "mb", "megabytes"
+              unit = "mib"
+            when "gb", "gigabytes"
+              unit = "gib"
+            end
+          end
+          case unit
+          when "b", "bytes"
+            qty.to_s
+          when "kb", "kilobytes"
+            (qty * 1000).to_s
+          when "kib", "kibibytes"
+            (qty * 1024).to_s
+          when "mb", "megabytes"
+            (qty * 1000000).to_s
+          when "m", "mib", "mebibytes"
+            (qty * 1048576).to_s
+          when "gb", "gigabytes"
+            (qty * 1000000000).to_s
+          when "g", "gib", "gibibytes"
+            (qty * 1073741824).to_s
+          else
+            raise ArgumentError, "Unknown unit #{unit}"
+          end
+        end
+
+        # Takes a qty and a unit
+        # returns byte quantity in that unit
+        def size_from_bytes(qty, unit)
+          qty = qty.to_i
+          case unit.downcase
+          when "b", "bytes"
+            qty.to_s
+          when "kb", "kilobytes"
+            (qty / 1000).to_s
+          when "kib", "kibibytes"
+            (qty / 1024).to_s
+          when "mb", "megabytes"
+            (qty / 1000000).to_s
+          when "m", "mib", "mebibytes"
+            (qty / 1048576).to_s
+          when "gb", "gigabytes"
+            (qty / 1000000000).to_s
+          when "g", "gib", "gibibytes"
+            (qty / 1073741824).to_s
+          else
+            raise ArgumentError, "Unknown unit #{unit}"
+          end
+        end
+
+        def format_mac(mac)
+          if mac.length == 12
+            mac = mac[0..1] + ":" + mac[2..3] + ":" +
+              mac[4..5] + ":" + mac[6..7] + ":" +
+              mac[8..9] + ":" + mac[10..11]
+          end
+          mac
+        end
+
+      end
+    end
+  end
+end