vagrant-kvm 0.1.0

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant.commands.destroy.will_not_destroy",
+                              :name => env[:machine].name)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      # This middleware class configures networking
+      class Network
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::plugins::kvm::network")
+          @app    = app
+        end
+
+        def call(env)
+          # TODO: Validate network configuration prior to anything below
+          @env = env
+
+          options = nil
+          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 = {
+              :start => start_ip,
+              :end   => end_ip }
+            options = {
+              :base_ip => base_ip,
+              :netmask => "255.255.255.0",
+              :range   => range
+            }.merge(options)
+          end
+
+          hosts = []
+          name = env[:machine].provider_config.name ?
+                      env[:machine].provider_config.name : "default"
+          hosts << {
+            :mac => format_mac(env[:machine].config.vm.base_mac),
+            :name => name,
+            :ip => options[:ip]
+          }
+          options[:hosts] = hosts
+
+          env[:ui].info I18n.t("vagrant.actions.vm.network.preparing")
+          env[:machine].provider.driver.create_network(options)
+
+          @app.call(env)
+        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

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

@@ -0,0 +1,20 @@
+require 'vagrant/action/general/package'
+
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class Package < Vagrant::Action::General::Package
+        # Doing this so that we can test that the parent is properly
+        # called in the unit tests.
+        alias_method :general_call, :call
+        def call(env)
+          # Just match up a couple environmental variables so that
+          # the superclass will do the right thing. Then, call the
+          # superclass
+          env["package.directory"] = env["export.temp_dir"]
+          general_call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class PackageVagrantfile
+
+        include ProviderKvm::Util
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+          create_vagrantfile
+          @app.call(env)
+        end
+
+        # This method creates the auto-generated Vagrantfile at the root of the
+        # 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|
+            f.write(KvmTemplateRenderer.render("package_Vagrantfile", {
+              :base_mac => @env[:machine].provider.driver.read_mac_address
+            }))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class PrepareNFSSettings
+        def initialize(app,env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          using_nfs = false
+          env[:machine].config.vm.synced_folders.each do |id, opts|
+            if opts[:nfs]
+              using_nfs = true
+              break
+            end
+          end
+
+          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
+        #
+        # @param [Machine] machine
+        # @return [String]
+        def read_host_ip(machine)
+          ip = read_machine_ip(machine)
+          if ip
+            base_ip = ip.split(".")
+            base_ip[3] = "1"
+            return base_ip.join(".")
+          end
+
+          nil
+        end
+
+        # Returns the IP address of the guest by looking at the first
+        # enabled host only network.
+        #
+        # @return [String]
+        def read_machine_ip(machine)
+          machine.config.vm.networks.each do |type, options|
+            if type == :private_network && options[:ip].is_a?(String)
+              return options[:ip]
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class PruneNFSExports
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:host]
+            uuid = env[:machine].provider.driver.uuid
+            env[:host].nfs_prune(uuid)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].provider.state.id
+
+          if current_state == :paused
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.unpausing")
+            env[:machine].provider.driver.resume
+          elsif current_state == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:action_runner].run(Boot, env)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class SetupPackageFiles
+        def initialize(app, env)
+          @app = app
+
+          env["package.include"] ||= []
+          env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Vagrant::Errors::PackageIncludeMissing,
+              :file => from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require "pathname"
+
+require "log4r"
+
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class ShareFolders
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
+          @app    = app
+        end
+
+        def call(env)
+          @env = env
+
+          prepare_folders
+          create_metadata
+
+          @app.call(env)
+        end
+
+        # This method returns an actual list of shared
+        # folders to create and their proper path.
+        def shared_folders
+          {}.tap do |result|
+            @env[:machine].config.vm.synced_folders.each do |id, data|
+              # 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
+            end
+          end
+        end
+
+        # Prepares the shared folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          shared_folders.each do |id, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            if !hostpath.directory? && options[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                hostpath.mkpath
+              rescue Errno::EACCES
+                raise Vagrant::Errors::SharedFolderCreateFailed,
+                  :path => hostpath.to_s
+              end
+            end
+          end
+        end
+
+        def create_metadata
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+          folders = []
+          shared_folders.each do |id, data|
+            folders << {
+              :name => id,
+              :hostpath => File.expand_path(data[:hostpath], @env[:root_path]),
+              :transient => data[:transient]
+            }
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class Suspend
+        def initialize(app, env)
+          @app = app
+        end
+
+        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
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/config.rb

@@ -0,0 +1,31 @@
+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
+
+      # This should be set to the name of the VM
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # The defined network adapters.
+      #
+      # @return [Hash]
+      attr_reader :network_adapters
+
+      def initialize
+        @name             = UNSET_VALUE
+      end
+
+      # This is the hook that is called to finalize the object before it
+      # is put into use.
+      def finalize!
+        # The default name is just nothing, and we default it
+        @name = nil if @name == UNSET_VALUE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,271 @@
+require 'libvirt'
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderKvm
+    module Driver
+      class Driver
+        # This is raised if the VM is not found when initializing
+        # a driver with a UUID.
+        class VMNotFound < StandardError; end
+
+        include Util
+
+        # enum for states return by libvirt
+        VM_STATE = [
+          :no_state,
+          :running,
+          :blocked,
+          :paused,
+          :shutdown,
+          :shutoff,
+          :crashed]
+
+        # 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
+
+        def initialize(uuid=nil)
+          @logger = Log4r::Logger.new("vagrant::provider::kvm::driver")
+          @uuid = uuid
+          # This should be configurable
+          @pool_name = "vagrant"
+          @network_name = "vagrant"
+
+          # Open a connection to the qemu driver
+          begin
+            @conn = Libvirt::open('qemu:///system')
+          rescue Libvirt::Error => e
+            if e.libvirt_code == 5
+              # can't connect to hypervisor
+              raise Vagrant::Errors::KvmNoConnection
+            else
+              raise e
+            end
+          end
+          @version = read_version
+          if (@version[:maj] == 1 && @version[:min] < 2) || @version[:maj] < 1
+            raise Vagrant::Errors::KvmInvalidVersion
+          end
+
+          # Get storage pool if it exists
+          begin
+            @pool = @conn.lookup_storage_pool_by_name(@pool_name)
+            @logger.info("Init storage pool #{@pool_name}")
+          rescue Libvirt::RetrieveError
+            # storage pool doesn't exist yet
+          end
+
+          if @uuid
+            # Verify the VM exists, and if it doesn't, then don't worry
+            # about it (mark the UUID as nil)
+            raise VMNotFound if !vm_exists?(@uuid)
+          end
+        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)
+          volume.delete
+          # XXX remove pool if empty?
+          @pool.refresh
+          # remove any saved state
+          domain.managed_save_remove if domain.has_managed_save?
+          domain.undefine
+        end
+
+        # Halts the virtual machine
+        def halt
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.destroy
+        end
+
+        # Imports the VM
+        #
+        # @param [String] xml Path to the libvirt XML file.
+        # @param [String] path Destination path for the volume.
+        # @return [String] UUID of the imported VM.
+        def import(xml, path)
+          @logger.info("Importing VM")
+          # 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 raw #{new_path}")
+          @pool.refresh
+          volume = @pool.lookup_volume_by_name(new_disk)
+          definition.disk = volume.path
+          # 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.
+        # @return [String] UUID of the imported VM.
+        def import_ovf(ovf, path)
+          @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 raw #{new_path}")
+          @pool.refresh
+          volume = @pool.lookup_volume_by_name(new_disk)
+          definition.disk = volume.path
+          # create vm
+          @logger.info("Creating new VM")
+          domain = @conn.define_domain_xml(definition.as_libvirt)
+          domain.uuid
+        end
+
+        # Create network
+        def create_network(config)
+          begin
+            # Get the network if it exists
+            @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
+        end
+
+        # Initialize or create storage pool
+        def init_storage(base_path)
+          begin
+            # Get the storage pool if it exists
+            @pool = @conn.lookup_storage_pool_by_name(@pool_name)
+            @logger.info("Init storage pool #{@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}")
+          end
+          @pool.create unless @pool.active?
+          @pool.refresh
+        end
+
+        # Returns a list of network interfaces of the VM.
+        #
+        # @return [Hash]
+        def read_network_interfaces
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          Util::VmDefinition.list_interfaces(domain.xml_desc)
+        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
+          end
+          VM_STATE[state]
+        end
+
+        # Return the qemu version
+        #
+        # @return [Hash] with :maj and :min version numbers
+        def read_version
+          # libvirt returns a number like 1002002 for version 1.2.2
+          # we return just the major.minor part like this 1002
+          maj = @conn.version / 1000000
+          min = (@conn.version - maj*1000000) / 1000
+          { :maj => maj, :min => min }
+        end
+
+        # Resumes the previously paused virtual machine.
+        def resume
+          @logger.debug("Resuming paused VM...")
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.resume
+          true
+        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)
+        end
+
+        # Starts the virtual machine.
+        def start
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.create
+          true
+        end
+
+        # Suspend the virtual machine and saves its states.
+        def suspend
+          domain = @conn.lookup_domain_by_uuid(@uuid)
+          domain.managed_save
+        end
+
+        # Verifies that the driver is ready and the connection is open
+        #
+        # This will raise a VagrantError if things are not ready.
+        def verify!
+          if @conn.closed?
+            raise Vagrant::Errors::KvmNoConnection
+          end
+        end
+
+        # Checks if a VM with the given UUID exists.
+        #
+        # @return [Boolean]
+        def vm_exists?(uuid)
+          begin
+            @logger.info("Check if VM #{uuid} exists")
+            @conn.lookup_domain_by_uuid(uuid)
+          rescue Libvirt::RetrieveError
+            false
+          end
+        end
+      end
+    end
+  end
+end