vagrant-libvirt 0.3.0 → 0.4.0

data/lib/vagrant-libvirt/driver.rb

@@ -60,12 +60,12 @@ module VagrantPlugins
         @@system_connection
       end
 
-      def get_domain(mid)
+      def get_domain(machine)
         begin
-          domain = connection.servers.get(mid)
+          domain = connection.servers.get(machine.id)
         rescue Libvirt::RetrieveError => e
           if e.libvirt_code == ProviderLibvirt::Util::ErrorCodes::VIR_ERR_NO_DOMAIN
-            @logger.debug("machine #{mid} not found #{e}.")
+            @logger.debug("machine #{machine.name} domain not found #{e}.")
             return nil
           else
             raise e
@@ -75,34 +75,31 @@ module VagrantPlugins
         domain
       end
 
-      def created?(mid)
-        domain = get_domain(mid)
+      def created?(machine)
+        domain = get_domain(machine)
         !domain.nil?
       end
 
       def get_ipaddress(machine)
         # Find the machine
-        domain = get_domain(machine.id)
-        if @machine.provider_config.qemu_use_session
-          return get_ipaddress_system domain.mac
-        end
+        domain = get_domain(machine)
 
         if domain.nil?
           # The machine can't be found
           return nil
         end
 
+        get_domain_ipaddress(machine, domain)
+      end
+
+      def get_domain_ipaddress(machine, domain)
+        if @machine.provider_config.qemu_use_session
+          return get_ipaddress_from_system domain.mac
+        end
+
         # Get IP address from arp table
-        ip_address = nil
         begin
-          domain.wait_for(2) do
-            addresses.each_pair do |_type, ip|
-              # Multiple leases are separated with a newline, return only
-              # the most recent address
-              ip_address = ip[0].split("\n").first unless ip[0].nil?
-            end
-            !ip_address.nil?
-          end
+          ip_address = get_ipaddress_from_domain(domain)
         rescue Fog::Errors::TimeoutError
           @logger.info('Timeout at waiting for an ip address for machine %s' % machine.name)
         end
@@ -115,7 +112,24 @@ module VagrantPlugins
         ip_address
       end
 
-      def get_ipaddress_system(mac)
+      def state(machine)
+        # may be other error states with initial retreival we can't handle
+        begin
+          domain = get_domain(machine)
+        rescue Libvirt::RetrieveError => e
+          @logger.debug("Machine #{machine.id} not found #{e}.")
+          return :not_created
+        end
+
+        # TODO: terminated no longer appears to be a valid fog state, remove?
+        return :not_created if domain.nil? || domain.state.to_sym == :terminated
+
+        domain.state.tr('-', '_').to_sym
+      end
+
+      private
+
+      def get_ipaddress_from_system(mac)
         ip_address = nil
 
         system_connection.list_all_networks.each do |net|
@@ -125,23 +139,24 @@ module VagrantPlugins
           break if ip_address
         end
 
-        return ip_address
+        ip_address
       end
 
-      def state(machine)
-        # may be other error states with initial retreival we can't handle
-        begin
-          domain = get_domain(machine.id)
-        rescue Libvirt::RetrieveError => e
-          @logger.debug("Machine #{machine.id} not found #{e}.")
-          return :not_created
-        end
+      def get_ipaddress_from_domain(domain)
+        ip_address = nil
+        domain.wait_for(2) do
+          addresses.each_pair do |type, ip|
+            # Multiple leases are separated with a newline, return only
+            # the most recent address
+            ip_address = ip[0].split("\n").first if ip[0] != nil
+          end
 
-        # TODO: terminated no longer appears to be a valid fog state, remove?
-        return :not_created if domain.nil? || domain.state.to_sym == :terminated
+          ip_address != nil
+        end
 
-        domain.state.tr('-', '_').to_sym
+        ip_address
       end
+
     end
   end
 end

data/lib/vagrant-libvirt/provider.rb

@@ -68,14 +68,7 @@ module VagrantPlugins
           forward_x11: @machine.config.ssh.forward_x11
         }
 
-        if @machine.provider_config.connect_via_ssh
-          ssh_info[:proxy_command] =
-            "ssh '#{@machine.provider_config.host}' " \
-            "-l '#{@machine.provider_config.username}' " \
-            "-i '#{@machine.provider_config.id_ssh_key_file}' " \
-            'nc %h %p'
-
-        end
+        ssh_info[:proxy_command] = @machine.provider_config.proxy_command if @machine.provider_config.proxy_command
 
         ssh_info
       end
@@ -98,7 +91,7 @@ module VagrantPlugins
         state_id = nil
         state_id = :not_created unless @machine.id
         state_id = :not_created if
-          !state_id && (!@machine.id || !driver.created?(@machine.id))
+          !state_id && (!@machine.id || !driver.created?(@machine))
         # Query the driver for the current state of the machine
         state_id = driver.state(@machine) if @machine.id && !state_id
         state_id = :unknown unless state_id

data/lib/vagrant-libvirt/templates/domain.xml.erb

@@ -104,14 +104,22 @@
     </hyperv>
     <% end %>
   </features>
-  <clock offset='utc'/>
+  <clock offset='<%= @clock_offset %>'>
+  <% @clock_timers.each do |clock_timer| %>
+    <timer<% clock_timer.each do |attr, value| %> <%= attr %>='<%= value %>'<% end %>/>
+  <% end %>
+  </clock>
   <devices>
     <% if @emulator_path %>
     <emulator><%= @emulator_path %></emulator>
     <% end %>
     <% if @domain_volume_path %>
     <disk type='file' device='disk'>
-      <driver name='qemu' type='qcow2' cache='<%= @domain_volume_cache %>'/>
+      <driver name='qemu' type='qcow2' <%=
+        @disk_driver_opts.empty? ? "cache='#{@domain_volume_cache}'" :
+            @disk_driver_opts.reject { |k,v| v.nil? }
+                             .map { |k,v| "#{k}='#{v}'"}
+                             .join(' ') -%>/>
       <source file='<%= @domain_volume_path %>'/>
       <%# we need to ensure a unique target dev -%>
       <target dev='<%= @disk_device %>' bus='<%= @disk_bus %>'/>
@@ -120,7 +128,12 @@
 <%# additional disks -%>
 <% @disks.each do |d| -%>
     <disk type='file' device='disk'>
-      <driver name='qemu' type='<%= d[:type] %>' cache='<%= d[:cache] %>'/>
+      <driver name='qemu' type='<%= d[:type] %>' <%=
+        d.select { |k,_| [:cache, :io, :copy_on_read, :discard, :detect_zeroes].include? k }
+         .reject { |k,v| v.nil? }
+         .map { |k,v| "#{k}='#{v}'"}
+         .join(' ')
+      -%>/>
       <source file='<%= d[:absolute_path] %>'/>
       <target dev='<%= d[:device] %>' bus='<%= d[:bus] %>'/>
       <% if d[:shareable] %>
@@ -257,11 +270,13 @@
       <% end %>
     <% end -%>
 
-    <% if @tpm_path -%>
+    <% if @tpm_path || @tpm_version -%>
     <%# TPM Device -%>
     <tpm model='<%= @tpm_model %>'>
-      <backend type='<%= @tpm_type %>'>
+      <backend type='<%= @tpm_type %>'<% if @tpm_version %> version='<%= @tpm_version %>'<% end %>>
+        <% if @tpm_path -%>
         <device path='<%= @tpm_path %>'/>
+        <% end -%>
       </backend>
     </tpm>
     <% end -%>
@@ -269,6 +284,15 @@
     <%# USB Controller -%>
     <controller type='usb' model='<%= @usbctl_dev[:model] %>' <%= "ports=\"#{@usbctl_dev[:ports]}\" " if @usbctl_dev[:ports] %>/>
     <% end %>
+    <% unless @memballoon_enabled.nil? %>
+    <% if @memballoon_enabled %>
+    <memballoon model='<%= @memballoon_model %>'>
+      <address type='pci' domain='0x0000' bus='<%= @memballoon_pci_bus %>' slot='<%= @memballoon_pci_slot %>' function='0x0'/>
+    </memballoon>
+    <% else %>
+    <memballoon model='none'/>
+    <% end %>
+    <% end %>
   </devices>
 
   <% if not @qemu_args.empty? or not @qemu_env.empty? %>

data/lib/vagrant-libvirt/version

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/vagrant-libvirt/version.rb

@@ -1,21 +1,49 @@
+require 'open3'
+require 'tmpdir'
+
 module VagrantPlugins
   module ProviderLibvirt
     VERSION_FILE = File.dirname(__FILE__) + "/version"
 
+    GIT_ARCHIVE_VERSION = "$Format:%H %D$"
+
+    HOMEPAGE = 'https://github.com/vagrant-libvirt/vagrant-libvirt'
+
     def self.get_version
       if File.exist?(VERSION_FILE)
+        # built gem
         version = File.read(VERSION_FILE)
-      else
+      elsif self.inside_git_repository
+        # local repo
         git_version = `git describe --tags`
-        version_parts = git_version.split('-').first(2) # drop the git sha if it exists
-        if version_parts.length > 1
-          # increment the patch number so that this is marked as a pre-release of the
-          # next possible release
-          main_version_parts = Gem::Version.new(version_parts[0]).segments
-          main_version_parts[-1] = main_version_parts.last + 1
-          version_parts = main_version_parts + ["pre", version_parts[1]]
+        version = self.version_from_describe(git_version)
+      elsif !GIT_ARCHIVE_VERSION.start_with?('$Format')
+        # archive - format string replaced during export
+        hash, refs = GIT_ARCHIVE_VERSION.split(' ', 2)
+
+        tag = refs.split(',').select { |ref| ref.strip.start_with?("tag:") }.first
+        if tag != nil
+          # tagged
+          version = tag.strip.split(' ').last
+        else
+          version = ""
+          # arbitrary branch/commit
+          Dir.mktmpdir do |dir|
+            stdout_and_stderr, status = Open3.capture2e("git -C #{dir} clone --bare #{HOMEPAGE}")
+            raise "failed to clone original to resolve version: #{stdout_and_stderr}" unless status.success?
+
+            stdout_and_stderr, status = Open3.capture2e("git --git-dir=#{dir}/vagrant-libvirt.git describe --tags #{hash}")
+            raise "failed to determine version for #{hash}: #{stdout_and_stderr}" unless status.success?
+
+            version = version_from_describe(stdout_and_stderr)
+          end
+
+          # in this case write the version file to avoid cloning a second time
+          File.write(VERSION_FILE, version)
         end
-        version = version_parts.join(".")
+      else
+        # no idea
+        version = "9999"
       end
 
       return version.freeze
@@ -24,5 +52,25 @@ module VagrantPlugins
     def self.write_version
       File.write(VERSION_FILE, self.get_version)
     end
+
+    private
+
+    def self.inside_git_repository
+      _, status = Open3.capture2e("git rev-parse --git-dir")
+
+      status.success?
+    end
+
+    def self.version_from_describe(describe)
+      version_parts = describe.split('-').first(2) # drop the git sha if it exists
+      if version_parts.length > 1
+        # increment the patch number so that this is marked as a pre-release of the
+        # next possible release
+        main_version_parts = Gem::Version.new(version_parts[0]).segments
+        main_version_parts[-1] = main_version_parts.last + 1
+        version_parts = main_version_parts + ["pre", version_parts[1]]
+      end
+      version = version_parts.join(".")
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,31 @@
-require 'coveralls'
-Coveralls.wear!
+require 'simplecov'
+require 'simplecov-lcov'
+
+# patch simplecov configuration
+if ! SimpleCov::Configuration.method_defined? :branch_coverage?
+  module SimpleCov
+    module Configuration
+      def branch_coverage?
+        return false
+      end
+    end
+  end
+end
+
+SimpleCov::Formatter::LcovFormatter.config do |config|
+  config.report_with_single_file = true
+  config.single_report_path = 'coverage/lcov.info'
+end
+
+SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new(
+  [
+    SimpleCov::Formatter::HTMLFormatter,
+    SimpleCov::Formatter::LcovFormatter,
+  ]
+)
+SimpleCov.start do
+  add_filter 'spec/'
+end
 
 require 'vagrant-libvirt'
 require 'support/environment_helper'

data/spec/support/libvirt_context.rb

@@ -7,6 +7,7 @@ shared_context 'libvirt' do
   let(:id)              { 'dummy-vagrant_dummy'     }
   let(:connection)      { double('connection') }
   let(:domain)          { double('domain') }
+  let(:logger)          { double('logger') }
 
   def connection_result(options = {})
     result = options.fetch(:result, nil)
@@ -26,5 +27,6 @@ shared_context 'libvirt' do
     allow(domain).to receive(:mac).and_return('9C:D5:53:F1:5A:E7')
 
     allow(machine).to receive(:id).and_return(id)
+    allow(Log4r::Logger).to receive(:new).and_return(logger)
   end
 end

data/spec/support/sharedcontext.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 shared_context 'unit' do
   include_context 'vagrant-unit'
 
+  let(:vagrantfile_providerconfig) { '' }
   let(:vagrantfile) do
     <<-EOF
     Vagrant.configure('2') do |config|
       config.vm.define :test
+      config.vm.provider :libvirt do |libvirt|
+        #{vagrantfile_providerconfig}
+      end
     end
     EOF
   end

data/spec/unit/action/create_domain_spec.rb

@@ -26,59 +26,134 @@ describe VagrantPlugins::ProviderLibvirt::Action::CreateDomain do
 
       allow(connection).to receive(:servers).and_return(servers)
       allow(connection).to receive(:volumes).and_return(volumes)
+
+      allow(logger).to receive(:info)
+
+      env[:domain_name] = "vagrant-test_default"
+
+      # should be ignored for system session and used for user session
+      allow(Process).to receive(:uid).and_return(9999)
+      allow(Process).to receive(:gid).and_return(9999)
     end
 
-    context 'default pool' do
-      let(:test_file) { 'default_storage_pool.xml' }
+    context 'connection => qemu:///system' do
+      context 'default pool' do
+        let(:test_file) { 'default_system_storage_pool.xml' }
 
-      it 'should execute correctly' do
-        expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
-        expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
-        expect(servers).to receive(:create).and_return(machine)
+        it 'should execute correctly' do
+          expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
+          expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
+          expect(servers).to receive(:create).and_return(machine)
+          expect(volumes).to_not receive(:create) # additional disks only
 
-        expect(subject.call(env)).to be_nil
-      end
+          expect(subject.call(env)).to be_nil
+        end
 
-      context 'additional disks' do
-        let(:vagrantfile) do
-          <<-EOF
-          Vagrant.configure('2') do |config|
-            config.vm.define :test
-            config.vm.provider :libvirt do |libvirt|
-              libvirt.storage :file, :size => '20G'
+        context 'additional disks' do
+          let(:vagrantfile) do
+            <<-EOF
+            Vagrant.configure('2') do |config|
+              config.vm.define :test
+              config.vm.provider :libvirt do |libvirt|
+                libvirt.storage :file, :size => '20G'
+              end
             end
+            EOF
           end
-          EOF
-        end
 
-        context 'volume create failed' do
-          it 'should raise an exception' do
-            expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
-            expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
-            expect(volumes).to receive(:create).and_raise(Libvirt::Error)
+          context 'volume create failed' do
+            it 'should raise an exception' do
+              expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
+              expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
+              expect(volumes).to receive(:create).and_raise(Libvirt::Error)
 
-            expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::FogCreateDomainVolumeError)
+              expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::FogCreateDomainVolumeError)
+            end
+          end
+
+          context 'volume create succeeded' do
+            it 'should complete' do
+              expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
+              expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
+              expect(volumes).to receive(:create).with(
+                hash_including(
+                  :path        => "/var/lib/libvirt/images/vagrant-test_default-vdb.qcow2",
+                  :owner       => 0,
+                  :group       => 0,
+                  :pool_name   => "default",
+                )
+              )
+              expect(servers).to receive(:create).and_return(machine)
+
+              expect(subject.call(env)).to be_nil
+            end
           end
         end
+      end
 
-        context 'volume create succeeded' do
-          it 'should complete' do
-            expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
-            expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
-            expect(volumes).to receive(:create)
-            expect(servers).to receive(:create).and_return(machine)
+      context 'no default pool' do
+        it 'should raise an exception' do
+          expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(nil)
 
-            expect(subject.call(env)).to be_nil
-          end
+          expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::NoStoragePool)
         end
       end
     end
 
-    context 'no default pool' do
-      it 'should raise an exception' do
-        expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(nil)
+    context 'connection => qemu:///session' do
+      let(:vagrantfile) do
+        <<-EOF
+        Vagrant.configure('2') do |config|
+          config.vm.define :test
+          config.vm.provider :libvirt do |libvirt|
+            libvirt.qemu_use_session = true
+          end
+        end
+        EOF
+      end
+
+      context 'default pool' do
+        let(:test_file) { 'default_user_storage_pool.xml' }
+
+        it 'should execute correctly' do
+          expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
+          expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
+          expect(servers).to receive(:create).and_return(machine)
+
+          expect(subject.call(env)).to be_nil
+        end
 
-        expect{ subject.call(env) }.to raise_error(VagrantPlugins::ProviderLibvirt::Errors::NoStoragePool)
+        context 'additional disks' do
+          let(:vagrantfile) do
+            <<-EOF
+            Vagrant.configure('2') do |config|
+              config.vm.define :test
+              config.vm.provider :libvirt do |libvirt|
+                libvirt.qemu_use_session = true
+                libvirt.storage :file, :size => '20G'
+              end
+            end
+            EOF
+          end
+
+          context 'volume create succeeded' do
+            it 'should complete' do
+              expect(libvirt_client).to receive(:lookup_storage_pool_by_name).and_return(libvirt_storage_pool)
+              expect(libvirt_storage_pool).to receive(:xml_desc).and_return(storage_pool_xml)
+              expect(volumes).to receive(:create).with(
+                hash_including(
+                  :path        => "/var/lib/libvirt/images/vagrant-test_default-vdb.qcow2",
+                  :owner       => 9999,
+                  :group       => 9999,
+                  :pool_name   => "default",
+                )
+              )
+              expect(servers).to receive(:create).and_return(machine)
+
+              expect(subject.call(env)).to be_nil
+            end
+          end
+        end
       end
     end
   end