vagrant-libvirt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 857a7572e2968583b54a002899aeb4ed206ce1a9
+  data.tar.gz: b2272a7a10779ccbaef6f5c8aa1eda3d7cc77d9f
+SHA512:
+  metadata.gz: 1eb41e05a79497bd68f8b8616d75b61ed8a4e7d4a9787ea90ec5ef0a061847f8ca12e2b6f80e3d95b941a6483cd2ef21df48ffd020cdda1949e4ea5d30784c2e
+  data.tar.gz: cb6363c8c70efaac9b3ed73cdace2ef42c658b946571a5d5bc8693144273af6612b0afdcc79ca8de69b685380fc33c7b009ca46bcae8b1de0cf9d5ce37125e91

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-libvirt.gemspec
+gemspec
+
+group :development do
+  # We depend on Vagrant for development, but we don't add it as a
+  # gem dependency because we expect to be installed within the
+  # Vagrant environment itself using `vagrant plugin`.
+  gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git"
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Lukas Stanek
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,33 @@
+# Vagrant Libvirt Provider
+
+This is a [Vagrant](http://www.vagrantup.com) 1.1+ plugin that adds an
+[Libvirt](http://libvirt.org) provider to Vagrant, allowing Vagrant to
+control and provision machines via Libvirt toolkit.
+
+**Note:** This plugin requires Vagrant 1.1+.
+
+## Features
+
+* Upload of box image (qcow2 format) to Libvirt storage pool.
+* Volume creation as COW diff image for each new domain.
+* Create and boot Libvirt domains.
+* SSH into domains.
+* Provision domains with any built-in Vagrant provisioner.
+* Minimal synced folder support via `rsync`.
+
+## Usage
+
+Install using standard Vagrant 1.1+ plugin installation methods. After
+installing, `vagrant up` and specify the `libvirt` provider. An example is
+shown below.
+
+```
+$ vagrant plugin install vagrant-libvirt
+...
+$ vagrant up --provider=libvirt
+...
+```
+
+Of course prior to doing this, you'll need to obtain an Libvirt-compatible
+box file for Vagrant.
+

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+
+require 'rubygems'
+require 'bundler/setup'
+#require 'bundler/gem_tasks'
+Bundler::GemHelper.install_tasks
+

data/example_box/README.md

@@ -0,0 +1,14 @@
+# Vagrant Libvirt Example Box
+
+Vagrant providers each require a custom provider-specific box format.
+This folder shows the example contents of a box for the `libvirt` provider.
+To turn this into a box create a vagrant image according documentation (don't
+forget to install rsync command) and create box with following command:
+
+```
+$ tar cvzf custom_box.box ./metadata.json ./Vagrantfile ./box.img
+```
+
+This box works by using Vagrant's built-in Vagrantfile merging to setup
+defaults for Libvirt. These defaults can easily be overwritten by higher-level
+Vagrantfiles (such as project root Vagrantfiles).

data/example_box/Vagrantfile

@@ -0,0 +1,45 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+
+  # Example configuration of new VM..
+  # 
+  #config.vm.define :test_vm do |test_vm|
+    # Box name
+    #test_vm.vm.box = "centos64"
+
+    # Interfaces for VM
+    # 
+    # Hostonly network is not supported in this version of provider. Bridged
+    # interface with network id specified can be created.
+    #test_vm.vm.network :bridged, :bridge => "default", :adapter => 1
+  #end
+
+  # Options for libvirt vagrant provider.
+  config.vm.provider :libvirt do |libvirt|
+
+    # A hypervisor name to access. Different drivers can be specified, but
+    # this version of provider creates KVM machines only. Some examples of
+    # drivers are qemu (KVM/qemu), xen (Xen hypervisor), lxc (Linux Containers),
+    # esx (VMware ESX), vmwarews (VMware Workstation) and more. Refer to
+    # documentation for available drivers (http://libvirt.org/drivers.html).
+    libvirt.driver = "qemu"
+
+    # The name of the server, where libvirtd is running.
+    libvirt.host = "localhost"
+
+    # If use ssh tunnel to connect to Libvirt.
+    libvirt.connect_via_ssh = false
+
+    # The username and password to access Libvirt. Password is not used when
+    # connecting via ssh.
+    libvirt.username = "root"
+    #libvirt.password = "secret"
+
+    # Libvirt storage pool name, where box image and instance snapshots will
+    # be stored.
+    libvirt.storage_pool_name = "default"
+  end
+end
+

data/example_box/metadata.json

@@ -0,0 +1,5 @@
+{
+  "provider"     : "libvirt"
+  "format"       : "qcow2"
+  "virtual_size" : "40"
+}

data/lib/vagrant-libvirt/action/connect_libvirt.rb

@@ -0,0 +1,72 @@
+require 'fog'
+require 'log4r'
+
+module VagrantPlugins
+  module Libvirt
+    module Action
+      class ConnectLibvirt
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_libvirt::action::connect_libvirt")
+          @app = app
+        end
+
+        def call(env)
+
+          # If already connected to libvirt, just use it and don't connect
+          # again.
+          if Libvirt.libvirt_connection
+            env[:libvirt_compute] = Libvirt.libvirt_connection
+            return @app.call(env)
+          end
+          
+          # Get config options for libvirt provider.
+          config = env[:machine].provider_config
+
+          # Setup connection uri.
+          uri = config.driver
+          if config.connect_via_ssh
+            uri << '+ssh://'
+            if config.username
+              uri << config.username + '@'
+            end
+
+            if config.host
+              uri << config.host
+            else
+              uri << 'localhost'
+            end
+          else
+            uri << '://'
+            uri << config.host if config.host
+          end                
+          uri << '/system?no_verify=1'
+
+          conn_attr = {}
+          conn_attr[:provider] = 'libvirt'
+          conn_attr[:libvirt_uri] = uri
+          conn_attr[:libvirt_username] = config.username if config.username
+          conn_attr[:libvirt_password] = config.password if config.password
+          
+          # Setup command for retrieving IP address for newly created machine
+          # with some MAC address. Get it via arp table. This solution doesn't
+          # require arpwatch to be installed.
+          conn_attr[:libvirt_ip_command] = "arp -an | grep $mac | sed '"
+          conn_attr[:libvirt_ip_command] << 's/.*(\([0-9\.]*\)).*/\1/'
+          conn_attr[:libvirt_ip_command] << "'"
+
+          @logger.info("Connecting to Libvirt (#{uri}) ...")
+          begin
+            env[:libvirt_compute] = Fog::Compute.new(conn_attr)
+          rescue Fog::Errors::Error => e
+            raise Errors::FogLibvirtConnectionError,
+              :error_message => e.message
+          end
+          Libvirt.libvirt_connection = env[:libvirt_compute]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-libvirt/action/create_domain.rb

@@ -0,0 +1,62 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Libvirt
+    module Action
+
+      class CreateDomain
+        include VagrantPlugins::Libvirt::Util::ErbTemplate
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_libvirt::action::create_domain")
+          @app = app
+        end
+
+        def call(env)
+          # Gather some info about domain
+          # TODO from Vagrantfile
+          @name = env[:domain_name]
+          @cpus = 1
+          @memory_size = 512*1024
+
+          # TODO get type from driver config option
+          @domain_type = 'kvm'
+
+          @os_type = 'hvm'
+
+          # Get path to domain image.
+          domain_volume = Libvirt::Util::Collection.find_matching(
+            env[:libvirt_compute].volumes.all, "#{@name}.img")
+          raise Errors::DomainVolumeExists if domain_volume == nil
+          @domain_volume_path = domain_volume.path
+
+          # Output the settings we're going to use to the user
+          env[:ui].info(I18n.t("vagrant_libvirt.creating_domain"))
+          env[:ui].info(" -- Name:          #{@name}")
+          env[:ui].info(" -- Domain type:   #{@domain_type}")
+          env[:ui].info(" -- Cpus:          #{@cpus}")
+          env[:ui].info(" -- Memory:        #{@memory_size/1024}M")
+          env[:ui].info(" -- Base box:      #{env[:machine].box.name}")
+          env[:ui].info(" -- Image:         #{@domain_volume_path}")
+
+          # Create libvirt domain.
+          # Is there a way to tell fog to create new domain with already
+          # existing volume? Use domain creation from template..
+          begin
+            server = env[:libvirt_compute].servers.create(
+              :xml => to_xml('domain'))
+          rescue Fog::Errors::Error => e
+            raise Errors::FogCreateServerError,
+              :error_message => e.message
+          end
+
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = server.id
+
+          @app.call(env)
+        end
+      end
+
+    end
+  end
+end

data/lib/vagrant-libvirt/action/create_domain_volume.rb

@@ -0,0 +1,58 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Libvirt
+    module Action
+
+      # Create a snapshot of base box image. This new snapshot is just new
+      # cow image with backing storage pointing to base box image. Use this
+      # image as new domain volume.
+      class CreateDomainVolume
+        include VagrantPlugins::Libvirt::Util::ErbTemplate
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_libvirt::action::create_domain_volume")
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_libvirt.creating_domain_volume"))
+
+          # Get config options.
+          config = env[:machine].provider_config
+
+          # This is name of newly created image for vm.
+          @name = "#{env[:domain_name]}.img"
+
+          # Verify the volume doesn't exist already.
+          domain_volume = Libvirt::Util::Collection.find_matching(
+            env[:libvirt_compute].volumes.all, @name)
+          raise Errors::DomainVolumeExists if domain_volume
+
+          # Get path to backing image - box volume.
+          box_volume = Libvirt::Util::Collection.find_matching(
+            env[:libvirt_compute].volumes.all, env[:box_volume_name])
+          @backing_file = box_volume.path
+
+          # Virtual size of image. Same as box image size.
+          @capacity = env[:machine].box.metadata['virtual_size'] #G
+
+          # Create new volume from xml template. Fog currently doesn't support
+          # volume snapshots directly.
+          begin
+            domain_volume = env[:libvirt_compute].volumes.create(
+              :xml       => to_xml('volume_snapshot'),
+              :pool_name => config.storage_pool_name)
+          rescue Fog::Errors::Error => e
+            raise Errors::FogDomainVolumeCreateError,
+              :error_message => e.message
+          end
+
+          @app.call(env)
+        end
+      end
+
+    end
+  end
+end
+

data/lib/vagrant-libvirt/action/create_network_interfaces.rb

@@ -0,0 +1,85 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Libvirt
+    module Action
+
+      # Create network interfaces for domain, before domain is running.
+      class CreateNetworkInterfaces
+        include VagrantPlugins::Libvirt::Util::ErbTemplate
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_libvirt::action::create_network_interfaces")
+          @app = app
+        end
+
+        def call(env)
+          # Get domain first.
+          begin
+            domain = env[:libvirt_compute].client.lookup_domain_by_uuid(
+              env[:machine].id.to_s)
+          rescue => e
+            raise Errors::NoDomainError,
+              :error_message => e.message
+          end
+
+          # Setup list of interfaces before creating them
+          adapters = []
+
+          # Assign main interface for provisioning to first slot.
+          # Use network 'default' as network for ssh connecting and
+          # machine provisioning. This should be maybe configurable in
+          # Vagrantfile in future.
+          adapters[0] = 'default'
+
+          env[:machine].config.vm.networks.each do |type, options|
+            # Other types than bridged are not supported for now.
+            next if type != :bridged
+
+            network_name = 'default'
+            network_name = options[:bridge] if options[:bridge]
+
+            if options[:adapter]
+              if adapters[options[:adapter]]
+                raise Errors::InterfaceSlotNotAvailable
+              end
+
+              adapters[options[:adapter].to_i] = network_name
+            else
+              empty_slot = find_empty(adapters, start=1)
+              raise Errors::InterfaceSlotNotAvailable if empty_slot == nil
+
+              adapters[empty_slot] = network_name
+            end           
+          end
+
+          # Create each interface as new domain device
+          adapters.each_with_index do |network_name, slot_number|
+            @iface_number = slot_number
+            @network_name = network_name
+            @logger.info("Creating network interface eth#{@iface_number}")
+            begin
+              domain.attach_device(to_xml('interface'))
+            rescue => e
+              raise Errors::AttachDeviceError,
+                :error_message => e.message
+            end
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def find_empty(array, start=0, stop=8)
+          for i in start..stop
+            return i if !array[i]
+          end
+          return nil
+        end
+      end
+
+    end
+  end
+end
+

data/lib/vagrant-libvirt/action/destroy_domain.rb

@@ -0,0 +1,28 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Libvirt
+    module Action
+      class DestroyDomain
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_libvirt::action::destroy_domain")
+          @app = app
+        end
+
+        def call(env)
+
+          # Destroy the server and remove the tracking ID          
+          env[:ui].info(I18n.t("vagrant_libvirt.destroy_domain"))
+
+          domain = env[:libvirt_compute].servers.get(env[:machine].id.to_s)
+          domain.destroy(:destroy_volumes => true)
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-libvirt/action/handle_box_image.rb

@@ -0,0 +1,121 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Libvirt
+    module Action
+      class HandleBoxImage
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_libvirt::action::handle_box_image")
+          @app = app
+        end
+
+        def call(env)
+
+          # Verify box metadata for mandatory values.
+          # 
+          # Virtual size has to be set for allocating space in storage pool.
+          box_virtual_size = env[:machine].box.metadata['virtual_size']
+          if box_virtual_size == nil
+            raise Errors::NoBoxVirtualSizeSet
+          end
+
+          # Support qcow2 format only for now, but other formats with backing
+          # store capability should be usable.
+          box_format = env[:machine].box.metadata['format']
+          if box_format == nil
+            raise Errors::NoBoxFormatSet
+          elsif box_format != 'qcow2'
+            raise Errors::WrongBoxFormatSet
+          end
+
+          # Get config options
+          config   = env[:machine].provider_config
+          box_image_file = env[:machine].box.directory.join("box.img").to_s
+          env[:box_volume_name] = env[:machine].box.name.to_s.dup
+          env[:box_volume_name] << '_vagrant_box_image.img'
+
+          # Don't continue if image already exists in storage pool.
+          return @app.call(env) if Libvirt::Util::Collection.find_matching(
+            env[:libvirt_compute].volumes.all, env[:box_volume_name])
+
+          # Box is not available as a storage pool volume. Create and upload
+          # it as a copy of local box image.
+          env[:ui].info(I18n.t("vagrant_libvirt.uploading_volume"))
+
+          # Create new volume in storage pool
+          box_image_size = File.size(box_image_file) # B
+          message = "Creating volume #{env[:box_volume_name]}"
+          message << " in storage pool #{config.storage_pool_name}."
+          @logger.info(message)
+          begin
+            fog_volume = env[:libvirt_compute].volumes.create(
+              :name        => env[:box_volume_name],
+              :allocation  => "#{box_image_size/1024/1024}M",
+              :capacity    => "#{box_virtual_size}G",
+              :format_type => box_format,
+              :pool_name   => config.storage_pool_name)
+          rescue Fog::Errors::Error => e
+            raise Errors::FogCreateVolumeError,
+              :error_message => e.message
+          end
+
+          # Upload box image to storage pool
+          ret = upload_image(box_image_file, config.storage_pool_name,
+            env[:box_volume_name], env) do |progress|
+              env[:ui].clear_line
+              env[:ui].report_progress(progress, box_image_size, false)
+          end
+
+          # Clear the line one last time since the progress meter doesn't
+          # disappear immediately.
+          env[:ui].clear_line
+
+          # If upload failed or was interrupted, remove created volume from
+          # storage pool.
+          if env[:interrupted] or !ret
+            begin
+              fog_volume.destroy
+            rescue
+              nil
+            end
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        # Fog libvirt currently doesn't support uploading images to storage
+        # pool volumes. Use ruby-libvirt client instead.
+        def upload_image(image_file, pool_name, volume_name, env)
+          image_size = File.size(image_file) # B
+
+          begin
+            pool = env[:libvirt_compute].client.lookup_storage_pool_by_name(
+              pool_name)
+            volume = pool.lookup_volume_by_name(volume_name)
+            stream = env[:libvirt_compute].client.stream
+            volume.upload(stream, offset=0, length=image_size)
+            buf_size = 1024*1024 # 1M
+            progress = 0
+            open(image_file, 'rb') do |io|
+              while (buff = io.read(buf_size)) do
+                sent = stream.send buff
+                progress += sent
+                yield progress
+              end 
+            end
+          rescue => e
+            raise Errors::ImageUploadError,
+              :error_message => e.message
+          end
+
+          return true if progress == image_size
+          false
+        end
+
+      end
+    end
+  end
+end
+

data/lib/vagrant-libvirt/action/handle_storage_pool.rb

@@ -0,0 +1,49 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Libvirt
+    module Action
+      class HandleStoragePool
+        include VagrantPlugins::Libvirt::Util::ErbTemplate
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_libvirt::action::handle_storage_pool")
+          @app = app
+        end
+
+        def call(env)
+          # Get config options.
+          config = env[:machine].provider_config
+
+          # Check for storage pool, where box image should be created
+          fog_pool = Libvirt::Util::Collection.find_matching(
+            env[:libvirt_compute].pools.all, config.storage_pool_name)
+          return @app.call(env) if fog_pool
+
+          @logger.info("No storage pool '#{config.storage_pool_name}' is available.")
+
+          # If user specified other pool than default, don't create default
+          # storage pool, just write error message.
+          raise Errors::NoStoragePool if config.storage_pool_name != 'default'
+
+          @logger.info("Creating storage pool 'default'")
+
+          # Fog libvirt currently doesn't support creating pools. Use
+          # ruby-libvirt client directly.
+          begin
+            libvirt_pool = env[:libvirt_compute].client.create_storage_pool_xml(
+              to_xml('default_storage_pool'))
+          rescue => e
+            raise Errors::CreatingStoragePoolError,
+              :error_message => e.message
+          end
+          raise Errors::NoStoragePool if !libvirt_pool
+
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/vagrant-libvirt/action/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Libvirt
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end